Road Network Partitioning with Distributed Threaded-Parallelism for Large-Scale SUMO Traffic Simulation
This paper presents a two-level parallel architecture combining thread-level parallelism and distributed execution to significantly accelerate large-scale SUMO traffic simulations on complex road networks, achieving up to 13.32× speedup while validating the method's accuracy and identifying global synchronization as the primary scalability bottleneck.
Original paper licensed under CC BY 4.0 (https://creativecommons.org/licenses/by/4.0/). This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer
Imagine a city where every car, every truck, and every bus is a living thing, moving with its own intentions, reacting to traffic lights, and navigating around accidents in real time. This is the world of microscopic traffic simulation, a powerful tool used by engineers and planners to test how a city will behave before a single shovel hits the ground. Instead of guessing, they build a digital twin of the road network, filling it with thousands of virtual vehicles to see how a new highway or a sudden crash will ripple through the system. The software that does this, known as SUMO, is incredibly detailed, tracking the speed and position of every individual vehicle. However, this level of detail comes at a steep price: the more complex the city and the more cars on the road, the longer the computer takes to run the simulation. For a massive network like the one surrounding the Port of Rotterdam, a single simulation can take hours, making it difficult to test many different scenarios quickly.
To solve this, researchers have long tried to split the work. One way is to chop the road network into smaller pieces, like slicing a map into puzzle pieces, and let different computers handle each piece at the same time. Another way is to make a single computer work faster by using all its internal cores to do many tasks at once. Until now, these two approaches were often kept separate, or limited by the way computer programs are built. A team of researchers from Universitat Jaume I in Spain has now combined these strategies into a single, powerful system. They built a new framework that not only splits the massive Rotterdam road network across multiple computers but also uses a modern, free-threaded version of the Python programming language to make each individual computer work much more efficiently than before. Their goal was simple: to see if they could make these huge, complex traffic simulations run significantly faster without losing any of the accuracy or detail that planners rely on.
The researchers started by tackling the problem on a single machine. In the past, when they tried to speed up the simulation by dividing the work, they had to create separate "processes," which are like independent programs running side-by-side. This method worked, but it was clunky because each process had to copy data back and forth, wasting time. The team realized that a newer version of Python, which allows multiple threads of execution to run freely without a traditional lock, could do this job better. They replaced the heavy, separate processes with lightweight threads that share the same memory space. When they tested this on a single computer with six processor cores, the new thread-based approach was dramatically faster than the old process-based one. In the best-case scenario with 15,000 vehicles and no accidents, the new method made the simulation run nearly six times faster than the original, unparallelized version. This was a significant leap, proving that simply changing how the software organizes its work on one machine could yield massive gains.
But the team did not stop at a single machine. They took this improved, thread-based system and connected it across a network of computers to handle the full scale of the Rotterdam region. They divided the road network into different zones, assigning each zone to a separate computer, or "domain worker." A central master computer acted as the traffic controller, ensuring that all the separate simulations stayed in sync and that vehicles moving from one zone to another were handed off correctly. They tested this distributed system with up to twelve different computers working together, simulating traffic levels ranging from 15,000 to 30,000 vehicles, and even introducing simulated accidents to see how the system handled sudden bottlenecks. The results were striking. By combining the efficient single-machine thread work with the power of multiple computers, they achieved speedups of up to 13.3 times compared to the original, slow sequential simulation. Even more importantly, when they compared the distributed system to their best single-machine setup, the distributed version still provided an extra boost of between 1.5 and 2.5 times faster.
The researchers were careful to ensure that this speed did not come at the cost of accuracy. They checked the traffic volume on every road segment to make sure the split simulation produced the exact same results as the original, unsplit version. They found that the traffic patterns were preserved with high precision; the number of cars entering and leaving each road segment matched the original simulation almost perfectly, with differences of less than one percent in the best cases. The system handled the complex task of moving vehicles across the boundaries of the different computer zones without any errors or lost data. However, they also discovered a limit to how much faster they could go. As they added more computers to the network, the time spent waiting for all the machines to synchronize and exchange data began to eat up a larger portion of the total time. In the most fragmented setups, with twelve computers, nearly three-quarters of the time was spent waiting for synchronization rather than actually simulating traffic. This suggests that while adding more computers helps, there is a point of diminishing returns where the coordination overhead becomes the main bottleneck.
Ultimately, this work demonstrates that large-scale traffic simulations can be made practical for real-time decision-making without needing to rewrite the core simulation engine. By cleverly combining a modern, efficient way of using a single computer's power with a distributed network of machines, the researchers showed that it is possible to simulate complex, accident-prone urban environments in a fraction of the time it used to take. The system proved robust enough to handle dynamic routing and sudden incidents, maintaining the integrity of the traffic flow across all the different computing nodes. While the synchronization overhead remains a challenge for scaling even further, the study confirms that this two-level approach—using threads within a machine and distributing those machines across a network—is a highly effective way to tackle the computational demands of modern, connected mobility. The findings offer a clear path forward for traffic managers who need to run multiple "what-if" scenarios quickly, allowing them to test emergency responses or infrastructure changes with a speed and detail that was previously out of reach.
Drowning in papers in your field?
Get daily digests of the most novel papers matching your research keywords — with technical summaries, in your language.