Sub-Millisecond IPC for Autonomous Robots: Zero-Copy Shared Memory with Zenoh and ROS2 Jazzy

Sub-Millisecond IPC for Autonomous Robots: Zero-Copy Shared Memory with Zenoh and ROS2 Jazzy

By TechIDaily Robotics Systems Architecture & High-Performance Middleware · Published 2026-10-10

Modern autonomous robots are sensory powerhouses. A single mobile manipulator frequently integrates two 4K color stereo cameras (60 FPS), multiple high-density optical tactile sensors, and a 128-channel LiDAR. Taken together, internal sensor ingestion generates between 1.2 GB/s and 3.5 GB/s of continuous sensory telemetry.

Historically, the robotic middleware layer (ROS2 based on traditional DDS implementations such as FastDDS or CycloneDDS) relies on network protocol stacks for inter-process communication (IPC). Even when nodes reside on the exact same physical system-on-chip (SoC), data traverses socket abstractions and undergoes Common Data Representation (CDR) serialization:

1. The camera driver writes raw frame bytes into user space.
2. The middleware serializes the frame into a network buffer.
3. The kernel copies the buffer via the loopback interface (lo).
4. The perception node deserializes the bytes in its own address space.

This multi-copy overhead incurs 12ms to 25ms of latency jitter and consumes up to 45% of available CPU cores merely copying memory blocks.

With the advent of ROS2 Jazzy Jalisco and Eclipse Zenoh (`rmw_zenoh_cpp`) paired with POSIX shared memory (powered by iceoryx2), robotics engineering has entered the zero-copy era.

1. Architectural Comparison: DDS Network Sockets vs. Zero-Copy Shared Memory

2. Mathematical Formalism of IPC Latency Overhead

The end-to-end transport latency $T_{\text{ipc}}$ for a payload of size $S$ (e.g., a 32 MB uncompressed 4K image frame) is modeled as:

T_{\text{ipc}} = T_{\text{alloc}} + N_{\text{copy}} \cdot \left(\frac{S}{\text{BW}_{\text{mem}}}\right) + T_{\text{notify}}

Where $\text{BW}_{\text{mem}}$ is memory bandwidth and $N_{\text{copy}}$ is the number of copy operations. In traditional DDS, $N_{\text{copy}} \ge 3$.

In a zero-copy loaned-message architecture, $N_{\text{copy}} = 0$:

T_{\text{ipc}}^{\text{zero-copy}} = T_{\text{loan}} + T_{\text{notify}} \approx 320\text{ ns} + 480\text{ ns} < 1.0\, \mu\text{s}

Transfer time becomes completely independent of message payload size.

The following C++ implementation demonstrates the Loaned Message pattern utilizing ROS2 Jazzy and Zenoh zero-copy buffers:

class="tok-comment">#include <rclcpp/rclcpp.hpp>
class="tok-comment">#include <sensor_msgs/msg/image.hpp>

class ZeroCopyCameraPublisher : public rclcpp::Node {
public:
  ZeroCopyCameraPublisher() : Node(class="tok-string">"zero_copy_camera_publisher") {
    class="tok-comment">// Enable loaned message allocation
    image_pub_ = this->create_publisher<sensor_msgs::msg::Image>(
        class="tok-string">"/camera/stereo_left/image_raw", rclcpp::QoS(10));
    
    timer_ = this->create_wall_timer(
        std::chrono::milliseconds(16), class="tok-comment">// 60 FPS
        std::bind(&ZeroCopyCameraPublisher::captureAndPublishFrame, this));

    RCLCPP_INFO(this->get_logger(), class="tok-string">"Zero-Copy Camera Node Initialized with Loaned Messages.");
  }

private:
  void captureAndPublishFrame() {
    class="tok-comment">// 1. Borrow a pre-allocated shared-memory buffer directly from /dev/shm
    auto loaned_msg = image_pub_->borrow_loaned_message();
    if (!loaned_msg.is_valid()) {
    class="tok-comment"># ... [Implementation detail: 19 lines of low-level hardware/state routines condensed] ...

  rclcpp::Publisher<sensor_msgs::msg::Image>::SharedPtr image_pub_;
  rclcpp::TimerBase::SharedPtr timer_;
};

3. Communication Signaling Sequence

4. Benchmark: Traditional DDS vs. Zero-Copy Zenoh on NVIDIA Jetson AGX Orin

Benchmarked with dual 4K stereo streams (64 MB/s per frame pair @ 60 FPS):

5. Key Engineering Insights

1. Payload Agnostic Latency: With zero-copy shared memory, transporting a 100 MB volumetric octree takes the exact same sub-millisecond duration as transmitting a single scalar floating-point number.
2. CPU Energy Conservation: Mobile robots running on 48V LiFePO4 batteries gain 20 to 35 minutes of extra operating runtime by eliminating useless memory duplication loops.
3. Seamless Network Bridging: While local IPC stays in ultra-fast shared memory, Zenoh seamlessly bridges selected topics over Wi-Fi/5G to cloud teleoperation stations without requiring separate proxy gateways.