Writing and Reading Data

How to read and write data in shared memory from any language

Once a region is created or opened, reading and writing data is a matter of pointer arithmetic on the data area. The first byte of usable data is at offset 64 (after the header).

Getting a pointer to the data area

Every adapter provides a method that returns a view of the shared memory:

Rust

// Returns *mut u8 pointing to data area
let ptr = region.as_ptr();

The returned view is a direct mapping into physical memory. Writing to it is immediately visible to all other processes that have the same region open. No flush, no commit, no sync.

Writing primitive values

Rust

unsafe { std::ptr::write(ptr as *mut u32, 42) };
unsafe { std::ptr::write(ptr.add(4) as *mut f32, 3.14) };

Writing arrays and buffers

The most common use case for Zinc is sharing large arrays — tensors, frames, point clouds. Here is how to write and read a float array:

Rust

let data: &[f32] = &[1.0, 2.0, 3.0, 4.0];
let n_bytes = data.len() * std::mem::size_of::<f32>();
unsafe {
    std::ptr::copy_nonoverlapping(
        data.as_ptr() as *const u8,
        ptr,
        n_bytes,
    );
}

Memory layout conventions

Zinc does not impose a data format. Bytes at offset 64 and beyond are yours to manage. For polyglot setups where multiple languages read and write the same region, you need a layout convention.

Common approaches:

• Fixed offset fields. Assign each field a fixed position: strings as fixed-size byte arrays, numbers at known offsets, arrays at known offsets with a length prefix.
• Schema-driven layout. Use a zero-copy serialization framework like FlatBuffers or Cap’n Proto that operates on shared memory directly.
• Header + data. Write a small descriptor at the start of the data area describing the number and types of the remaining fields.

The simplest approach is a fixed layout with explicit offsets. Not flexible, but trivially correct in every language.

Capacity

The capacity value represents usable bytes after the 64-byte header. It is set at creation time and cannot be changed. The value must be a multiple of the system page size (typically 4096 bytes).

To determine the capacity:

Rust

let cap = region.capacity();