Heuristic:CARLA simulator Carla Sensor Queue Synchronization Pattern
| Knowledge Sources | |
|---|---|
| Domains | Simulation, Optimization |
| Last Updated | 2026-02-15 07:00 GMT |
Overview
Use a thread-safe Queue to synchronize multi-sensor data collection, blocking the main loop until all sensors have delivered data for the current frame.
Description
In synchronous mode, CARLA sends the world snapshot and sensor data streams in parallel. Without explicit synchronization, the client may process sensor data from different frames, corrupting the dataset. The canonical pattern uses Python's `queue.Queue` as a synchronization barrier: each sensor callback pushes its data into the queue, and the main loop blocks until all expected sensor messages for the current tick are received. This ensures frame-accurate alignment across all sensors.
Usage
Use this heuristic whenever collecting data from multiple sensors simultaneously in synchronous mode (Workflow 4: Sensor Data Collection). This is critical for:
- Multi-camera rigs (e.g., RGB + depth + semantic segmentation)
- Sensor fusion datasets (camera + LiDAR + radar)
- Any application requiring time-synchronized sensor readings
The Insight (Rule of Thumb)
- Action: Create a `queue.Queue()`, pass it to each sensor's `listen()` callback. After `world.tick()`, call `queue.get(timeout=...)` once per sensor.
- Value: Use a timeout (e.g., 1.0 second) on `queue.get()` to avoid deadlocks if a sensor fails.
- Trade-off: Blocks the main loop until all sensors respond. If a sensor has a lower capture frequency, it may not produce data every tick, causing the queue to block indefinitely without a timeout.
- Assumption: All sensors must gather information at every tick. If not, the client must track which sensors tick at each frame.
Reasoning
The sensor_synchronization.py example header at lines 13-22 explicitly documents this:
"The communication model for the synchronous mode in CARLA sends the snapshot of the world and the sensors streams in parallel. This suppose that all the sensors gather information at every tick. If this is not the case, the clients needs to take in account at each frame how many sensors are going to tick at each frame."
# PythonAPI/examples/sensor_synchronization.py:30-37
def sensor_callback(sensor_data, sensor_queue, sensor_name):
# Do stuff with the sensor_data data like save it to disk
# Then you just need to add to the queue
sensor_queue.put((sensor_data.frame, sensor_name))
# Main loop pattern:
sensor_queue = Queue()
# ... attach sensors with listen() callbacks that push to sensor_queue ...
# After world.tick():
# for each sensor: data = sensor_queue.get(True, 1.0)