Crate bcast

Expand description

Low latency, single producer & many consumer (SPMC) ring buffer that works with shared memory. Natively supports variable message sizes.

§Examples

Create Writer and use claim to publish a message.

use bcast::RingBuffer;

// create writer
let bytes = [0u8; 1024];
let mut writer = RingBuffer::new(&bytes).into_writer();

// publish first message
let mut claim = writer.claim(5, true);
claim.get_buffer_mut().copy_from_slice(b"hello");
claim.commit();

// publish second message
let mut claim = writer.claim(5, true);
claim.get_buffer_mut().copy_from_slice(b"world");
claim.commit();

Create Reader and use batch_iter tp receive messages.

use bcast::RingBuffer;

// create reader
let bytes = [0u8; 1024];
let mut reader = RingBuffer::new(&bytes).into_reader();
let mut iter = reader.read_batch().into_iter();
let mut payload = [0u8; 1024];

// read first message
let msg = iter.next().unwrap().unwrap();
let len = msg.read(&mut payload).unwrap();
assert_eq!(b"hello", &payload[..len]);

// read second message
let msg = iter.next().unwrap().unwrap();
let len = msg.read(&mut payload).unwrap();
assert_eq!(b"world", &payload[..len]);

// no more messages
assert!(iter.next().is_none())

Re-exports§

pub use error::Result;

Modules§

error: Defines error types.

Structs§

Batch: Represents pending batch of messages between last observed producer position and the reader current position. Should be used in conjunction with BatchIter to allow iteration.
BatchIter: Iterator that allows to process pending messages in a batch. This is more efficient than iterating over the messages using receive_next() on the Reader directly.
Claim: Represents region of the RingBuffer we can publish message to.
Message: Contains coordinates to some payload at particular point in time. Messages are consumer in a ‘lazily’ way that’s why it’s safe to clone() and pass them around. When message is read (consumed) it can result in overrun error if the producer has lapped around.
Reader: Wraps RingBuffer and allows to receive messages. Multiple readers can be present at any time, they operate independently and are not part of any congestion control flow. As a result, each reader can be overrun by the producer if it’s unable to keep up.
RingBuffer: Single producer, many consumer (SPMC) ring buffer backed by shared memory.
Writer: Wraps RingBuffer and allows to publish messages. Only single writer should be present at any time.

Constants§