Struct SampleAllocator 

pub struct SampleAllocator { /* private fields */ }

Builds dora-owned output samples without borrowing the node.

Why this exists (dora-rs/dora#2742)

An operator runs on its own thread and hands its outputs to the runtime’s event loop. If what crosses that boundary is an Arrow array whose buffers belong to the operator’s language runtime — a pyarrow array wrapping a numpy buffer, say — then the runtime ends up freeing them. Releasing a numpy-backed buffer acquires the Python GIL (pyarrow’s NumPyBuffer destructor does PyAcquireGIL), so the runtime’s event loop blocks for as long as the operator holds the GIL. That made a node unable to observe Stop, and the daemon force-killed it at the grace period.

Handing the operator thread an allocator instead lets it encode into memory dora owns and release its own payload while it still holds the GIL. It is not an extra copy: the IPC encode is the same single copy the node would otherwise have made, just performed on the other side of the channel.

Implementations

impl SampleAllocator

pub fn allocate(&self, data_len: usize) -> NodeResult<DataSample>

Allocates a DataSample of the specified size.

For payloads at or above the zero-copy threshold the buffer is allocated directly from the zenoh SHM provider (when available), so the producer writes straight into shared memory and publishing moves the buffer into zenoh’s put without a further copy. Smaller payloads — or the case where no SHM provider exists (interactive/testing mode) — use a heap-allocated, 128-byte-aligned buffer; the SHM provider is page-aligned, so dedicating a full page to a small message is pure waste.

pub fn encode_arrow(&self, array: &DoraArray) -> NodeResult<EncodedSample>

Encodes array as a complete Arrow IPC stream into a freshly allocated sample. Uses the hand-rolled 1-copy fast path when the array type is eligible, falling back to the official writer (one extra copy) otherwise.

The returned sample shares no memory with array, so the caller may — and, when the payload is owned by a foreign runtime, must — drop array on its own thread rather than let it travel to the node.

pub fn heap() -> Self

An allocator with no shared memory, so every sample is heap-backed.

This is what a node without a zenoh session (interactive/testing mode) uses; it also lets callers that only need the encoding — tests, most obviously — build one without a live node.

Trait Implementations

impl Clone for SampleAllocator

fn clone(&self) -> SampleAllocator

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for SampleAllocator

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.