A Quantitative Investment Firm
Quantitative Systems Developer
Develop backtesting and matching engines, live market data pipelines and inference optimizations; build the market data platform and cross-site GPU cluster supporting quantitative research and production.
Quantitative Engines & Low-Latency Pipelines
- Backtesting: led development of a new Rust engine. The same 2,033-stock validation task fell from a 28.9 s C# baseline to 3.77 s, with SHA-256-verified byte-identical output.
- Batch matching: built a C++ engine processing a full trading day across 2,306 Shanghai stocks in about 18.9 s on 32 threads; 15.47 million trades matched the existing simulator byte for byte.
- Deterministic parallel replay: designed streaming replay with model inference for the C# engine. A persistent thread pool delivered a 19× speedup over the serial baseline, with output parity across repeated multithreaded runs as an acceptance check.
- Live market data: asynchronous publishing and cache-layout restructuring cut consumer-thread stalls per model interval from 3,795 ms to 0–1 ms; parity tests for this refactor retained bit-identical output.
- GPU inference: graph partitioning, concurrent streams and CUDA Graph reduced inference from 269 μs with monolithic TensorRT to 66 μs; end-to-end latency including feature packing fell from 327 μs to 124 μs.
Data Platforms & Compute Infrastructure
- Market data: rewrote historical data transcoding in Rust, migrating to Arrow IPC with per-object checks against the source. Optimized C# streaming reads for monthly datasets above 10 billion rows: 2.4–2.8× faster, with read-time memory growth down from about 40 GB to 2–4 GB.
- Compute cluster: built and now operate a cross-site Slurm cluster with GPU resources on the scale of a hundred cards; delivered dual-controller high availability and node automation. Maintain parallel storage, identity services and alerting, and handle compute, storage and network incidents.
- Engineering acceptance: incorporated output comparisons, automated tests, code review and structured handoffs into multi-agent development; maintain shared tooling configuration and upgrade scripts for the team.
Workload & Validation Records
- Replay workloads
- The Rust full-market replay covers 4,932 stocks in 26.85 s, or 9.37 s with caching. A separate comparison on the same 2,033-stock task shows a 7.7× speedup over C#. C# replay of 2,306 stocks includes model inference and takes about 52 minutes.
- Output parity
- Parity checks cover Rust/C# outputs for the same task, C++ matched trades, repeated C# multithreaded runs, and outputs before and after the live-path refactor.
- Numerical inference
- GPU inference P99 latency fell from 4.7 ms to 73 μs. A hand-written CPU SIMD forward pass replaced ONNX Runtime, cutting inference from 29 μs to 2.9 μs per stock with maximum absolute error ≤ 1e-8.
- Capacity and signal regression
- An extreme session with over a billion events was replayed at the original rate with zero ring-buffer overruns. End-to-end validation passed on 11 trading days with pooled signal correlation ≥ 0.998. C++ strategy full-market parallel replay fell from about 3.5 hours to 422 s.
- Incremental data and operations
- Historical migration covers 2,500+ trading days. Daily increments complete in about 20 minutes including validation and cross-site sync, with rollback and backfill procedures. Trading-log ingestion into ClickHouse uses minute-level scans with a 3-day lookback, failure reruns and notifications.
Stack
- Languages & runtimes
- C++, Rust, C# / .NET; Python
- Data & compute
- Arrow / Parquet, ClickHouse, Flink, CUDA / TensorRT
- Backend & distributed
- ASP.NET Core, Redis, Kafka / RocketMQ, Elasticsearch, relational databases
- Infrastructure
- Slurm, BeeGFS, MinIO, FreeIPA, Ansible, Docker