Crate sling

This crates provides a sequentially locking Ring Buffer. It allows for a fast and non-writer-blocking SPMC-queue, where all consumers read all messages.

There are two ways of consuming from the queue. If threads share a ReadGuard through a shared reference, they will steal queue items from one anothers such that no two threads will read the same message. When a ReadGuard is cloned, the new ReadGuard’s reading progress will no longer affect the other one. If two threads each use a separate ReadGuard, they will be able to read the same messages.

It is also important to keep in mind, that slow readers will be overrun by the writer if they do not consume messages quickly enough.

let buffer = RingBuffer::<_, 128>::new();

let mut writer = buffer.try_lock().unwrap();
let mut reader = buffer.reader();

std::thread::scope(|s| {
    let reader = &reader;
    for t in 0..8 {
        s.spawn(move || {
            for _ in 0..100 {
                if let Some(val) = reader.pop_front() {
                    println!("t: {}, val: {:?}", t, val);
                };
            }
        });
    }

    for i in 0..100 {
        writer.push_back([i, i, i]);
    }
});

Structs

ReadGuard

Shared read access to its buffer. When multiple threads consume from the RingBuffer throught the same ReadGuard, they will share progress on the queue. Distinct RingBuffers do not share progress.

RingBuffer

A fixed-size, non-write-blocking, ring buffer, that behaves like a SPMC queue and can be safely shared across threads. It is limited to only work for types that are copy, as multiple threads can read the same message.

WriteGuard

Provides exclusive write access to the RingBuffer.