Lock-Free Ring Buffers (The Infinity Stream Architecture)

Eliminating Mutex Contention in Event Streaming

In high-throughput commit log engines like Infinity Stream, millions of messages per second flow through ingestion pipelines. Protecting a message queue with a Mutex<VecDeque<T>> triggers catastrophic context-switching overhead when hundreds of worker threads contend for the lock.

Single-Producer Single-Consumer (SPSC) Lock-Free Ring

By separating the head index (mutated solely by the producer) and the tail index (mutated solely by the consumer), an SPSC ring buffer achieves wait-free, zero-lock message transmission:

use std::sync::atomic::{AtomicUsize, Ordering};
use std::cell::UnsafeCell;

pub struct SpscRingBuffer {
    buffer: [UnsafeCell>; CAP],
    head: AtomicUsize, // Written by Producer
    tail: AtomicUsize, // Written by Consumer
}

unsafe impl Sync for SpscRingBuffer {}

impl SpscRingBuffer {
    pub fn push(&self, item: T) -> Result<(), T> {
        let head = self.head.load(Ordering::Relaxed);
        let tail = self.tail.load(Ordering::Acquire);

        if head.wrapping_sub(tail) >= CAP {
            return Err(item); // Buffer full
        }

        let slot = unsafe { &mut *self.buffer[head % CAP].get() };
        *slot = Some(item);

        self.head.store(head.wrapping_add(1), Ordering::Release);
        Ok(())
    }

    pub fn pop(&self) -> Option {
        let tail = self.tail.load(Ordering::Relaxed);
        let head = self.head.load(Ordering::Acquire);

        if tail == head {
            return None; // Buffer empty
        }

        let slot = unsafe { &mut *self.buffer[tail % CAP].get() };
        let item = slot.take();

        self.tail.store(tail.wrapping_add(1), Ordering::Release);
        item
    }
}