KineticSim: A Lightweight, High-Performance Execution Engine for Real-Time Market Simulators

Abstract: Simulating financial markets at scale with multi-agent (Agent-Based) models is critical for market design, regulatory stress-testing, and reinforcement learning, but traditional CPU simulators are bottlenecked by sequential processing while vectorized GPU frameworks suffer from kernel-launch overhead and redundant global-memory round-trips. We formalize, analyze, and evaluate a reusable parallel design pattern: persistent, state-carrying clearing for iterative multi-agent reductions. By caching mutable simulation state in thread-block shared memory across step boundaries, aggregating agent actions via shared-memory atomics, and resolving the clearing function cooperatively, the pattern reduces the per-step critical-path depth from Theta(L+A) for sequential clearing (L price-grid ticks, A agents) to Theta(log L + ceil(A/L)) and makes global-memory traffic independent of the step count. We implement this in KineticSim, a lightweight GPU execution engine that simulates massive ensembles of limit-order books in parallel, reaching a peak throughput of over 54.7 billion agent-events per second. On a fixed workload it delivers speedups of 3406x over CPU (NumPy), 27.8x over PyTorch GPU, 42.8x over JAX GPU, and 8.4x over a naive custom CUDA baseline, while using roughly an order of magnitude less GPU memory than PyTorch. Across 53 configurations the two custom CUDA engines produce bitwise-identical order books, and aggregate statistics match the CPU reference to within 0.1%. The pattern generalizes to other iterative multi-agent workloads requiring state-persistent, block-localized reductions.

• The paper presents a novel execution engine leveraging GPU shared memory and cooperative intra-block parallelism to dramatically reduce simulation latency and memory traffic.
• The methodology achieves peak throughput of 54.7 billion agent events/sec with speedups up to 3695× over CPU baselines and a 10× reduction in GPU global memory usage.
• Empirical evaluations confirm numerical correctness and realistic market behaviors, establishing KineticSim as a scalable and efficient tool for financial agent-based models.

KineticSim: Architecture and Performance Analysis of a GPU-Optimized Real-Time Market Simulator

Motivation and Parallel Systems Challenge

Simulating large-scale market dynamics via agent-based models (ABMs) is critical for market microstructure research, stress testing, and reinforcement learning-driven strategy development. However, classical CPU simulators such as ABIDES are limited by sequential processing, and while vectorized GPU frameworks (JAX, PyTorch) accelerate array-based rollouts, they suffer from significant global memory bandwidth constraints and kernel launch overheads. KineticSim introduces a persistent, state-carrying block-level clearing pattern that exploits GPU shared-memory and intra-block thread cooperation to reduce critical path depth and amortize global memory access, fundamentally changing how financial ABMs are executed at scale.

Execution Engine and Core Design Pattern

KineticSim maps each independent market environment to a CUDA thread block, maintaining all mutable market state (limit order book, order buffers, clearing statistics) in fast shared memory throughout the simulation. The architecture leverages cooperative intra-block parallelism, assigning each price tick to a thread and enabling efficient parallel prefix/suffix scans for cumulative demand-supply computation, atomic order aggregation, and rapid tournament reductions for clearing price determination.

Figure 1: KineticSim's block-level persistent shared-memory architecture, mapping each market to a CUDA block and maintaining the LOB on-chip throughout the simulation.

This design generalizes to iterative multi-agent reductions where block-localized state must be persistent across loop boundaries, collapsing per-step global-memory traffic from $\Theta(S \cdot M \cdot L)$ to $\Theta(M \cdot L)$ and reducing critical path depth from $\Theta(L + A)$ to $\Theta(\log L + \lceil A/L \rceil)$. The pattern is extensible to other ABMs demanding state persistence and cooperative reduction, including MARL, parallel Monte Carlo searches, and traffic routing models.

Algorithmic Implementation and Systems Abstractions

Within each market block, the methodology follows a structured persistent schedule:

• Shared-memory arrays for LOB and order buffers are initialized.
• Cooperative threads find best quotes and mid-price through atomic operations.
• Each thread executes agent logic in a grid-stride loop, using a stateless counter-based SplitMix64 PRNG keyed on $(market, agent, step, channel)$ for reproducibility and eliminating the need for global-memory RNG state.
• Orders are accumulated atomically in shared memory.
• Parallel Hillis-Steele scans construct cumulative profiles yielding executable volumes.
• A cooperative tournament reduction determines the clearing price, and unmatched interest updates the residual LOB in shared memory for the next step.
• Final state is written back to global memory post-simulation.

By construction, floating-point atomicAdd operations avoid nondeterminism due to integer summation properties, yielding bitwise identity between KineticSim and the naive custom kernel under integer order quantities.

Empirical Evaluation and Correctness

KineticSim is benchmarked against four baselines: CPU (NumPy), PyTorch GPU, JAX GPU, and a Naive Custom CUDA kernel. The evaluation demonstrates:

• Peak throughput of 54.7 billion agent events/sec.
• Maximum observed speedups: 3695$\times$ over CPU, 243$\times$ over PyTorch GPU, 315$\times$ over JAX GPU (for low $M$), 69.2$\times$ over naive custom CUDA (for small $\Theta(M \cdot L)$0).
• Bitwise-identical outputs between the two custom CUDA backends; aggregate statistics match NumPy within 0.1%.

(Figure 2)

Figure 2: Cross-backend semantic equivalence in mean clearing price and volume per market, confirming numerical identity between engines.

Strong scaling results show KineticSim linearly scales with agent density and market count until saturating hardware resources. Throughput and memory footprint remain optimal, with a consistent $\Theta(M \cdot L)$1 reduction in GPU global-memory compared to PyTorch GPU. Amortized execution cost per agent-event drops to 0.019 ns, an order of magnitude below naive CUDA and three orders below CPU.

(Figure 3)

Figure 3: Throughput scaling across multiple markets and agent densities, illustrating KineticSim's dominance over baselines.

(Figure 4)

Figure 4: Speedup results for fixed workload and scaling regimes; KineticSim provides orders-of-magnitude improvements across all configurations.

(Figure 5)

Figure 5: Memory efficiency and amortized agent-event execution cost, demonstrating shared-memory residency advantage.

Per-step latency is minimized ($\Theta(M \cdot L)$223 $\Theta(M \cdot L)$3s), with negligible variance, confirming elimination of kernel launch overhead and host synchronization bottlenecks.

(Figure 6)

Figure 6: Per-step latency distribution, revealing KineticSim's sub-23 $\Theta(M \cdot L)$4s latency and tight error bars.

Emergent Market Micro-Dynamics and Large-Scale Experiments

Parameter sweeps on agent composition illustrate that KineticSim not only achieves computational scaling but also credibly reproduces empirical stylized facts in price dynamics:

• Volatility escalates with momentum agent fraction.
• Fat-tailed return distributions and abrupt tail risk emerge at high momentum fractions.
• Increased trading volume with trend-followers.
• Volatility clustering observed via autocorrelation of absolute returns.

These results demonstrate that the simulator's output aligns with real-market phenomena, facilitating rapid experimentation inaccessible to prior frameworks.

(Figure 7)

Figure 7: Emergent dynamics from agent composition sweeps, showing realistic volatility, fat tails, and clustering in returns.

Systems Design Generality and Architectural Implications

KineticSim's block-level layout, shared-memory residency, and cooperative reduction scan primitives are directly portable to datacenter GPUs (A100, H100) and enable 100% theoretical occupancy due to low per-block resource footprint. Compiler-based frameworks (torch.compile, jax.jit) cannot match KineticSim's performance due to structural inability to declare block-local persistent variables, requiring global-memory state roundtrips and kernel launches even in fused graphs.

Limitations include restriction to uniform-price call auctions, requirement for price grid sizes fitting in shared memory, and statistical validation against CPU references due to RNG implementation differences. Extension to continuous double auctions, support for tiled grids, multi-GPU scaling, and MARL interfaces are feasible future directions.

Conclusion

KineticSim formalizes and implements a persistent shared-memory clearing pattern for iterative multi-agent market simulation. It achieves significant throughput, latency, and memory efficiency gains relative to both CPU-based and vectorized GPU frameworks. Empirical evaluation validates both correctness and financial realism, and systemic design analysis confirms generality to other parallel ABMs. The simulator is suitable for rapid parameter sweeps, real-time RL environments, and experimental market design, addressing critical bottlenecks in scalable agent-based finance.

Implications and Future Prospects

KineticSim's architectural pattern advances GPU ABM execution paradigms, enabling practical deployment for high-frequency market design, regulatory analysis, and RL-driven policy optimization. In the broader AI ecosystem, persistent block-level cooperative scheduling is poised to accelerate multi-agent training scenarios across MARL, real-time traffic, and complex social simulation, with direct implications for applied AI and optimal control in data-intensive domains.

For in-depth citation context, see arXiv paper "KineticSim: A Lightweight, High-Performance Execution Engine for Real-Time Market Simulators" (2606.21784).