Parallel Traffic Simulation

Updated 12 January 2026

Parallel traffic simulation is a method that uses distributed and parallel computing to process complex traffic models—from microscopic to macroscopic scales—in near real-time.
It employs techniques such as domain decomposition, agent-based and scenario-level parallelism, and hardware acceleration via multi-core CPUs and GPUs to manage millions of vehicles.
This approach supports applications like congestion analysis, infrastructure planning, and intelligent transportation systems while tackling challenges in synchronization, load balancing, and data management.

Parallel traffic simulation refers to the use of parallel and distributed computation to accelerate and scale traffic simulation models spanning microscopic, mesoscopic, and macroscopic regimes. This paradigm enables simulations of urban-scale and regional-scale road networks with millions of vehicles in real or near-real time, supporting applications from infrastructure planning and congestion analysis to reinforcement learning for intelligent transportation systems. Key techniques include domain and scenario decomposition, algorithmic restructuring for data or task parallelism, high-performance computing (HPC) platforms such as multi-core CPUs and GPUs, and integration of hybrid (traffic + communication) simulation. The field encompasses both methodological innovation and systems engineering to overcome limitations of sequential simulators, addressing constraints in computational throughput, synchronization, data management, and model fidelity.

1. Mathematical and Algorithmic Foundations

Traffic simulation models targeted by parallelization range from discrete-state cellular automata (CA), through time-driven car-following models, to event-based queueing networks. Representative algorithms include:

Cellular Automata Models: Biham-Middleton-Levine (BML) and Nagel–Schreckenberg (NaSch) models update all cells/vehicles in parallel based on neighborhood rules. Parallelism arises naturally due to local dependency structures; vectorization (SIMD) and block partitioning are common (Marzolla, 2018, Zon et al., 2023).
Microscopic Car-Following Models: Ordinary differential equations (ODEs), e.g., variants of the Intelligent Driver Model (IDM), are solved for each vehicle. Parallel strategies exploit the per-vehicle independence per time-step aside from the leader-follower coupling (Kurtc et al., 2016, Son et al., 2024, Jiang et al., 2024).
Continuous Cellular Automata (CCA): These hybrid models combine continuous position and velocity states with discrete-time parallel updates, embedding agent-level heterogeneity (e.g., fuzzy decision modules) and enabling massive parallel execution (Rodaro et al., 2013).
Discrete-Event Network Models: Each link in a regional graph acts as an event processor; vehicles propagate as events, supporting partitioning across MPI ranks with advanced time-synchronization (e.g., conservative/optimistic PDES) (Chan et al., 2022).

These models exhibit varying degrees of data and control dependency, which strongly influence parallelization choices and attainable speedup.

2. Parallelization Strategies and System Architectures

Domain and Data Decomposition

Spatial/Network Partitioning: The road/network graph is divided via graph partitioning algorithms (e.g., METIS) to balance computation and minimize cut-edges/boundary interactions. Each partition is assigned to a compute node or process that independently executes local updates, requiring inter-partition communication only for cross-boundary vehicles or state (Chen et al., 2020, Hoque et al., 2018, Chan et al., 2022).
Agent-based Parallelism: Each vehicle, cell, or actor is mapped to a thread/processing unit (thread-per-agent or cell-per-thread), particularly frequent in CA and microscopic models on CPUs/GPUs (Son et al., 2024, Jiang et al., 2024, Rodaro et al., 2013).
Scenario-level Parallelism: For parameter sweeps or what-if analyses, each scenario is run independently on a dedicated process, yielding embarrassingly parallel workloads amenable to cloud and cluster execution (Sengupta et al., 5 Jan 2026).

Hardware Mapping

Multi-core CPUs: Domain or agent decomposition with OpenMP or MPI; optimal for medium-scale simulations and task mixing (e.g., I/O + compute). SIMD intrinsics provide further acceleration in CA (Marzolla, 2018, Zon et al., 2023).
GPUs: Very-large-scale thread-per-agent paradigms, with careful attention to memory layout (SoA), coalesced accesses, and kernel design to exploit massive data parallelism (Son et al., 2024, Jiang et al., 2024, Rodaro et al., 2013).
Clusters/HPC: Distributed-memory partitioning using MPI, sometimes hybridized with OpenMP for intra-node event parallelism (Chen et al., 2020, Hoque et al., 2018, Chan et al., 2022, Jiang et al., 2024).
Hybrid Parallelism: Hierarchical combination of inter-node MPI, intra-node OpenMP/pthreads, and accelerator kernels, plus application-specific cross-domain coupling (e.g., traffic and V2X communications via SUMO-OMNeT++ closed-loop coupling in shared memory) (Hoque et al., 2018, Mavromatis et al., 2018).

3. Synchronization and Communication

Parallel traffic simulation is fundamentally constrained by dependencies that necessitate periodic synchronization and data exchange:

Conservative Time-stepping: Event simulation partitions employ lookahead and restrict time advancement to guarantee causality (e.g., min neighbor/vehicle propagation time) (Hoque et al., 2018, Chan et al., 2022).
Synchronous Phase Barriers: CA and agent-based simulators typically synchronize at the end of each global timestep, only exchanging updates for boundary vehicles/cells (Zon et al., 2023, Chen et al., 2020, Marzolla, 2018).
Inter-partition Messaging: MPI_Alltoall or peer-to-peer communication is used to exchange vehicle states across spatial boundaries with double-copy or shadow-vehicle schemes ensuring correctness (Chen et al., 2020, Chan et al., 2022).
GPU P2P Transfers: For multi-GPU frameworks, vehicles crossing GPU domains are transferred via cudaMemcpyPeer, with ghost zones for overlapping states (Jiang et al., 2024).

Communication and synchronization overheads tend to dominate at large core/GPU count; their minimization is central to system scalability.

4. Representative Architectures and Frameworks

Simulator/Framework	Parallelization Granularity	Model/Kernel	Max Scale Demonstrated
LPSim (Jiang et al., 2024)	GPU, thread-per-vehicle	IDM, lane-changing	9M trips on 2×A100 <3min
diffIDM (Son et al., 2024)	GPU/CPU, thread-per-vehicle	Fully differentiable IDM trajectory	2M vehicles, real-time
Mobiliti (Chan et al., 2022)	Event/actor per link (MPI)	Time-Warp PDES	19M trips, 1M links, 512 cores
QarSUMO (Chen et al., 2020)	Partitioned SUMO instances	Microscopic	28,800 vehicles, 32 cores
BigSUMO (Sengupta et al., 5 Jan 2026)	Scenario-level (worker pool)	SUMO batch	100s of what-if scenarios
BML/NaSch CA (Marzolla, 2018)	Cell/vehicle-per-thread	CA	4096×4096 grids (CPU/GPU)
CCA (Rodaro et al., 2013)	GPU, lane kernel	Fuzzy CA	~30,000 vehicles, 8–10× speedup

The architectures reflect a spectrum of decomposition: scenario-level (independent replicas), network-level, agent-level, and hybrid event-actor.

5. Performance Results and Scalability Analysis

Reported speedups—and practical bottlenecks—depend on load balance, communication patterns, and the nature of real-world traffic:

Microscopic Multi-rate Integration: Kurtc and Anufriev demonstrated up to 3.3× reduction in CPU time for large car-following ODE systems using per-vehicle adaptive sub-stepping, grouping vehicles by $\Delta t_i$ for parallel processing (Kurtc et al., 2016).
GPU-accelerated Simulators: LPSim reaches $\sim$ 113× faster runtime compared to 32-core CPU for 9M trips; diffIDM processes $2\times10^6$ vehicles per step in $<30$ ms, limited predominantly by memory bandwidth (Jiang et al., 2024, Son et al., 2024).
Distributed-Memory PDES: Mobiliti simulated 19M trip legs in under 3 min on 512 cores, achieving $>100\times$ speedup; efficiency drops sub-linearly beyond $\sim$ 64 cores due to communication overhead (Chan et al., 2022).
Parallel CA: NaSch 1D CA achieves $>12\times$ speedup on 16 cores, efficiency $>0.75$ ; BML CA attains $183\times$ speedup (OpenMP+SIMD) for $N=2048$ , and $\sim42\times$ (CUDA) (Zon et al., 2023, Marzolla, 2018).
Partitioned SUMO: QarSUMO delivers up to $11.1\times$ reduction in wall-clock time on a synthetic grid (32 cores), with per-trip time errors $<2.0\%$ (Chen et al., 2020).
Embarrassingly Parallel Scenarios: BigSUMO’s worker-pool design yields linear speedup to 16–32 cores, then saturates due to I/O/memory bandwidth (Sengupta et al., 5 Jan 2026).

Most systems exhibit nearly linear strong scaling up to tens of cores (or several GPUs), with diminishing returns as communication/synchronization begins to dominate aggregate cost.

6. Model Fidelity, Limitations, and Extensions

Practical parallel traffic simulators must balance fidelity, extensibility, and throughput:

Model Realism: CA models offer computational efficiency but limited driver realism; continuous CA approaches and ODE-based car-following achieve higher fidelity at greater computational cost (Rodaro et al., 2013, Kurtc et al., 2016).
Dynamic Routing and Learning: Full PDES and actor frameworks enable dynamic rerouting, which necessitates scalable shortest-path updating and data movement; for example, Mobiliti uses Customizable Contraction Hierarchies to accelerate reroute checks (Chan et al., 2022).
Hybrid Coupling: Interfacing traffic models with V2X communication simulators (SUMO–OMNeT++) can introduce synchronization and partitioning mismatches, tackled via coordinated partition maps and hybrid (OpenMP/MPI) coupling (Hoque et al., 2018, Mavromatis et al., 2018).
Load Imbalance and Communication Limits: Dynamic demand (e.g., rush-hour surges, heavy congestion) can lead to temporal or spatial load imbalance. Static partitioning is commonly used; dynamic or adaptive partitioning is an area for extension (Chen et al., 2020, Chan et al., 2022).

Notably, CA and agent-based methods are inherently amenable to both shared-memory (CPU) and SIMD/GPU parallelism; ODE-based multi-rate stepping benefits from per-agent grouping; fully distributed event-based techniques predominate at regional scales.

7. Current Challenges and Research Directions

Key open problems and directions:

Communication Efficiency: As the number of partitions or GPUs increases, inter-node and P2P communication overheads become dominant. Techniques using ghost zones, hierarchical partitions, and communication-computation overlap are active research areas (Jiang et al., 2024, Chan et al., 2022).
Model Coupling and Data Fusion: Achieving efficient, high-fidelity coupling between traffic simulation and heterogeneous sensor/communication data streams, including real-time ingestion and trajectory reconstruction, presents new computational and data management challenges (Hoque et al., 2018).
Hybrid Parallelism and Heterogeneous Hardware: Efficiently exploiting hybrid CPU-GPU systems, variable memory hierarchies, and future hardware demands further algorithmic innovation in load balancing, partitioning, and kernel design.
Extensibility and Open-Source Availability: The availability of modular, open-source codes (e.g., LPSim, diffIDM) accelerates reproducibility and community extension, but integration of new behaviors (buses, trucks, advanced signaling) remains a challenge (Jiang et al., 2024, Son et al., 2024).
Adaptive Partitioning and Load Rebalancing: Run-time repartitioning to resolve hot-spots, dynamic demand, or localized congestion remains an important avenue for maximizing resource utilization and simulation fidelity in dynamic urban scenarios (Chen et al., 2020, Chan et al., 2022).

In conclusion, parallel traffic simulation, enabled by algorithmic design, system engineering, and parallel hardware, is central to contemporary and future urban mobility planning, large-scale scenario analysis, and the research of complex transportation phenomena at previously intractable scales.