Skip to main content

Documentation Index

Fetch the complete documentation index at: https://docs.cerulion.com/llms.txt

Use this file to discover all available pages before exploring further.

ROS2 bag recording adds 3–8 ms of jitter per message. Your robot behaves differently when you record it. Every production failure becomes unreproducible — because the act of recording changed the behavior that led to the failure. This is the observer effect applied to robotics, and it affects every team running ROS2 in production.
Comparison showing ROS2 bag recording adding overhead to the data path vs Cerulion's zero-copy logging reading directly from shared memory with no impact
Cerulion logs everything with zero performance impact. What you record is what happened.
The fundamental problem: If recording changes your robot’s timing, then your logs don’t represent what actually happened. Debugging from those logs is debugging a different system.

​
Why Recording Slows Your Robot

ROS2 bag recording inserts itself into the data path. Every message that gets recorded must be serialized, copied to a buffer, and written to disk. This adds CPU load, memory pressure, and timing jitter to the entire stack. ROS2 recording adds serialization and copy overhead to every message. Cerulion writes directly from shared memory — the publisher never knows recording is happening. The consequences compound:
  • CPU contention — Serialization burns 5–15% of per-core CPU, competing directly with your perception and planning pipelines
  • Timing changes — 3–8 ms of added latency shifts when nodes execute, changing the order of operations
  • Memory pressure — Buffer allocations increase heap pressure and trigger page faults, adding unpredictable spikes
  • Debug ≠ production — The system you’re recording is not the system that failed

​
The Zero-Copy Difference

zero-copy-cpu

0% CPU Impact

No serialization, no copies. The publisher’s timing is completely unchanged.
zero-copy-timestamps

Deterministic Timestamps

Timestamps reflect when events actually occurred — no jitter from the recording process.
zero-copy-replay

Faithful Replay

Replay a production log and get the same execution. Same node ordering, same timing, same outputs.

​
How It Works

Cerulion’s logging reads directly from shared memory. No serialization. No copies. No CPU impact on the publishing node. Think of it like a security camera that records through a window — it sees everything without entering the room.

Direct shared memory access

Messages already exist in shared memory for pub/sub transport. The logger reads from the same memory region — it doesn’t ask the publisher to do anything extra. The publisher’s timing is completely unchanged. Added latency to the publishing node: 0 ns.
ROS2 bag recording requires serializing every message before writing it — burning 5–15% of per-core CPU on every logged topic. Cerulion’s wire format is already in shared memory — the logger writes the raw bytes directly to disk. Zero CPU overhead on the data path.
Because logging doesn’t perturb the system, timestamps in the log accurately reflect when events actually occurred. ROS2 bag recording can shift timestamps by 3–8 ms due to serialization delays. Cerulion’s timestamps are faithful to the original event — no jitter introduced by the recording process itself.
Disk I/O happens on a dedicated background thread with its own CPU affinity. Even disk latency spikes don’t affect your real-time nodes. The logger and the runtime are fully decoupled.

​
What This Means for Safety

For self-driving vehicles, surgical robots, and any safety-critical application, two capabilities are non-negotiable:
  1. Faithful recording — The log must represent exactly what happened, with correct timing
  2. Deterministic replay — Playing back the log must reproduce the same behavior
Zero-copy logging makes both possible. Because recording doesn’t change behavior, and because Cerulion’s runtime is deterministic, you can replay a production log and get the same execution — the same node ordering, the same timing, the same outputs. This is the foundation of trustworthy log resim.
When your autonomous vehicle makes an unexpected decision in the field, you need to understand exactly what happened. Not what would have happened if you’d been recording. Not an approximation. The exact sequence of events, faithfully captured with no observer effect.
Ready to try Cerulion? Start with the quickstart and have a working camera-to-display pipeline in 5 minutes — or schedule a 15-min call with the team.