Paper: arXiv 2609.21173
Authors: Vincent Maciejewski
Abstract
The actor model - state isolation, data-race freedom, and sequential single-message reasoning - has long been dismissed as unsuitable for high-frequency trading (HFT): actors seem to imply many threads, a mailbox per actor, and a heap-allocated message plus a context switch per interaction, overhead incompatible with a microsecond budget. This paper argues the dismissal is wrong for co-located actors, with a deployed, measured implementation: kaspar-hft, an open-source C++20 framework. Four extensions adapt the model for HFT: fast_send, a synchronous delivery mechanism in which the sending thread runs the receiver’s handler inline and returns the reply as a value; actor groups, which co-schedule actors on one thread behind a shared mailbox; per-actor selectable mailbox queues; and a memory pool. fast_send has receiver transparency: the handler is written identically for synchronous and asynchronous delivery and does not depend on which was used or which thread runs it. A grouped synchronous chain runs on one thread, cutting scheduler context switches from O(N) to O(1); a thread-local call-chain test detects cyclic invocation on one thread before any lock is taken, while a cycle spread across threads deadlocks. Microbenchmarks put the synchronous round trip at tens of nanoseconds. On a live CME market-data feed (ES, NQ, ZN futures), when the socket-reader thread decodes each packet and updates the book itself, socket-to-book medians for book updates are 0.8-1.1 microseconds, and a fast_send hop is about 1% of that. The shared-queue group also yields a production/simulation duality: the same actor code runs unchanged in live trading and deterministic backtest.
Complexity vs Empirical Score
- Math Complexity: 4.0/10
- Empirical Rigor: 8.0/10
- Quadrant: Street Traders — empirical and applied, lower math complexity
Why this score: This paper presents a highly novel adaptation of the actor model for HFT, backed by strong empirical evidence from live market data. The methodology is clearly articulated, and the practical implementation in an open-source framework enhances its reproducibility and impact. The focus on microsecond latency budgets and real-world performance makes it highly relevant for quantitative finance practitioners.
Research Flowchart
flowchart TD
A["Research Goal: Adapt Actor Model for HFT Low-Latency"] --> B{"Methodology: kaspar-hft C++20 Framework Development"};
B --> C{"Key Adaptations"};
C --> C1["fast_send: Synchronous Message Delivery"];
C --> C2["Actor Groups: Co-scheduling on one thread"];
C --> C3["Selectable Mailbox Queues"];
C --> C4["Memory Pool"];
C --> D["Computational Processes: Microbenchmarks & Live Market Data Test"];
D --> E["Data/Inputs: CME Market Data Feed (ES, NQ, ZN futures)"];
D --> F["Key Findings/Outcomes"];
F --> F1["fast_send round trip: tens of nanoseconds"];
F --> F2["Socket-to-book median latency: 0.8-1.1 microseconds"];
F --> F3["Fast_send hop: ~1% of latency"];
F --> F4["Production/Simulation Duality: same actor code for trading/backtest"];
F --> F5["Actor Model is suitable for HFT with adaptations"];
Evidence Card
What the authors claim, on what data, and who has checked it. Read from the paper's own text by a language model: every quote is verbatim, nothing was re-run. How to read this card
Proposes
The paper proposes four extensions to the actor model for high‑frequency trading, most notably fast_send—a synchronous delivery mechanism where the sender runs the receiver's handler inline and returns the reply as a value—along with actor groups, selectable mailbox queues, and a memory pool.
Source sentence
Four extensions adapt the model for HFT: fast_send, a synchronous delivery mechanism in which the sending thread runs the receiver's handler inline and returns the reply as a value; actor groups, which co-schedule actors on one thread behind a shared mailbox; per-actor selectable mailbox queues;
Assumes 2
- The work assumes co‑located actors that share an address space, so fast_send can be used without network round‑trip overhead. model
Source sentence
12 Discussion and limitations The scope is co-located actors. fast_send applies only when sender and receiver share an address space; a synchronous cross-machine call would reintroduce the network round trip it exists to avoid, and the actor model’s location transparency means the sender can fall back to asynchronous delivery when the receiver is remote.
- The HFT hot path must meet a microsecond‑level latency budget. execution
Source sentence
The actor model - state isolation, data-race freedom, and sequential single-message reasoning - has long been dismissed as unsuitable for high-frequency trading (HFT): actors seem to imply many threads, a mailbox per actor, and a heap-allocated message plus a context switch per interaction, overhead incompatible with a microsecond budget.
Data
- CME market‑data feed (ES, NQ, ZN futures) market-prices proprietary
Source sentence
On a live CME market-data feed (ES, NQ, ZN futures), when the socket-reader thread decodes each packet and updates the book itself, socket-to-book medians for book updates are 0.8-1.1 microseconds, and a fast_send hop is about 1% of that.
- Recorded CME sessions used for simulation synthetic proprietary
Source sentence
and order-event messages and emits child-order messages; it was built and validated entirely in simulation, driven from recorded CME sessions, and then deployed to production without modification — the same actor and the same handlers, reading from a live feed instead of a file.
Costs
Not applicable
Finds 5
- Microbenchmarks show the synchronous round‑trip latency of fast_send is on the order of tens of nanoseconds (≈30 ns total, ≈10 ns per hop). performance figure from elsewhere in the paper
Source sentence
Microbenchmarks put the synchronous round trip at tens of nanoseconds. Broken down per hop, a single fast_send invocation costs ∼10 ns, of which a bare (devirtualized) direct call is ∼1 ns measured the same way; so the framework adds ∼10 ns per hop over a direct call, covering the receiver-lock acquire/release, message-field setup, handler-cache dispatch, and reply wrapping.
- When the socket‑reader thread decodes each packet and updates the book, socket‑to‑book median latency is 0.8–1.1 µs, and a fast_send hop adds about 1 % of that latency. performance
Source sentence
On a live CME market-data feed (ES, NQ, ZN futures), when the socket-reader thread decodes each packet and updates the book itself, socket-to-book medians for book updates are 0.8-1.1 microseconds, and a fast_send hop is about 1% of that.
- Co‑scheduling two actors on one thread (grouping) reduces a cross‑thread asynchronous round‑trip from ≈3.4 µs to 90 ns, a 37× reduction. performance figure from elsewhere in the paper
Source sentence
Co-scheduling the two actors on one thread (grouping) removes both wakeups and reduces the round trip to 90 ns, a 37× reduction.
- Replacing mailbox push/pop with inline fast_send further reduces the round‑trip to ≈30 ns. performance
Source sentence
Replacing the remaining mailbox push/pop with an inline fast_send reduces the round trip to ∼30 ns (amortized; the per-sample p50 is resolution-bound), because a fast_send is mechanically a locked function call: it takes the receiver’s lock and runs the handler inline.
- Using a fixed‑size memory pool cuts the latency tail from a maximum of 5.5 ms to 33 µs, a two‑order‑of‑magnitude reduction in the p99.9+ tail. performance
Source sentence
The larger and platform-independent benefit is the tail: in a separate run the maximum round trip fell from 5.5 ms to 33 µs once pooled, because the pool never takes the general allocator’s occasional slow path: a two-order-of-magnitude reduction of the p99.9+ tail that an unpooled servicing stage would otherwise inject into the path. Scope.
Checked by others
No other paper in the archive has been found to support or contradict these findings (compared with 8 related papers). Coverage is partial, so this is neither replication nor refutation.
Extracted 2026-11-14 · same card as JSON · A language model chose these items: check the source sentence before relying on one.