Inter-Module Communication Protocols

In this lesson, you will learn how to design high-performance binary protocols for structured data exchange between isolated WebAssembly modules.

When multiple Wasm modules operate within the same host runtime, passing complex data via JSON or string serialization is prohibitively expensive due to the overhead of repeated allocations and encoding cycles. In high-performance embedded-like Wasm environments, we achieve efficiency by defining a shared memory binary contract.

The Binary Layout Strategy

Instead of passing high-level objects, we define a fixed-layout struct that resides in a shared linear memory segment. Since both modules share the same WebAssembly.Memory instance (or have mapped memory regions), we can use repr(C) to ensure the memory layout is predictable and platform-independent.

Consider a simple binary message format for sensor data:

#[repr(C, packed)]
pub struct SensorPacket {
    pub sensor_id: u32,
    pub timestamp: u64,
    pub value: f32,
}

Implementing the Protocol

To communicate, the Producer module writes the SensorPacket directly into a pre-allocated offset in linear memory. The Consumer module, knowing the memory layout, reads the bytes directly from that offset.

To prevent data races, we utilize the Atomic Operations we covered in lesson 5. By placing an atomic "ready" flag at the start of our memory block, we can synchronize the modules without expensive host-side calls:

// Memory offset 0: Flag (0: Empty, 1: Ready)
// Memory offset 4: SensorPacket data
pub unsafe fn send_message(ptr: *mut u32, packet: SensorPacket) {
    // Write the data
    let data_ptr = (ptr as *mut u8).add(4) as *mut SensorPacket;
    *data_ptr = packet;
    
    // Set flag to 1 atomically to signal readiness
    core::sync::atomic::AtomicU32::from_ptr(ptr)
        .store(1, core::sync::atomic::Ordering::Release);
}

Performance Benefits

This approach provides near-zero-copy communication. By avoiding intermediate buffers and leveraging repr(C) alongside core::ptr operations, we bypass the host bridge entirely for data transfer. This minimizes the pressure on the Wasm garbage collector and keeps the instruction count for inter-module synchronization strictly minimal, which is critical for real-time specialized runtime targets.

Key Takeaway: Use repr(C) structs and shared atomic memory offsets to facilitate high-speed communication that avoids the overhead of serialization and host-side context switching.