Struct RingBuffer 

pub struct RingBuffer<T> { /* private fields */ }

Thread-safe ring buffer for streaming data

This implementation uses VecDeque wrapped in Arc<RwLock> to provide efficient ring buffer operations with proper indexed access for windowing in multi-threaded scenarios.

Features

• Thread-safe concurrent access via RwLock
• Bounded capacity with automatic overwrite of oldest elements
• Efficient O(k) sliding window operations where k is window size
• Zero unsafe code
• Direct indexed access for efficient windowing
• Shareable across threads with Arc

Performance Characteristics

• Operations: O(1) push/pop (with locking overhead ~10-50ns per operation)
• Sliding window: O(k) where k is window size (efficient vectorized copy)
• Concurrent reads: Multiple threads can read simultaneously via RwLock
• Write contention: Only one writer at a time, may cause blocking under high contention
• Memory overhead: ~2-3x higher than LocalRingBuffer due to Arc/RwLock wrapper

Performance Under Contention

Low contention (few threads, infrequent writes):

• Performs well with minimal overhead
• RwLock allows efficient concurrent reads

High contention (many threads, frequent writes):

• Write operations may block waiting for lock acquisition
• Performance degrades with increasing writer contention
• Consider using separate buffers per thread if possible

When to Use Each Implementation

Use RingBuffer when:

• Multiple threads need to access the same buffer
• Producer-consumer patterns across threads
• Shared data collection and analysis
• Thread safety is required

Use LocalRingBuffer when:

• Single-threaded processing (~2x faster)
• Performance-critical inner loops
• Local buffering in compute-intensive functions
• Thread safety is not needed

Benchmark results (1M operations):

• LocalRingBuffer: ~3ms (no synchronization)
• RingBuffer: ~5-8ms (with RwLock overhead)
• High contention: ~15-30ms (multiple writers)

Implementations

impl<T: Copy + Default> RingBuffer<T>

pub fn new(capacity: usize) -> Self

Create new ring buffer with given capacity

pub fn push(&self, value: T)

Push value to buffer, overwriting oldest if full

pub fn sliding_window(&self, size: usize) -> Vec<T>

Get sliding window of last N elements

Performance

This method efficiently accesses the last N elements using VecDeque’s indexed access, avoiding the need to pop and push all elements. Time complexity: O(n) where n is the window size.

pub fn get(&self, index: usize) -> Option<T>

Get a single element by index (0 = oldest, len-1 = newest)

pub fn last(&self) -> Option<T>

Get the most recent element

pub fn first(&self) -> Option<T>

Get the oldest element

pub fn len(&self) -> usize

Get current size of buffer

pub fn is_empty(&self) -> bool

Check if buffer is empty

pub fn clear(&self)

Clear the buffer

pub fn capacity(&self) -> usize

Get capacity of the buffer

pub fn to_vec(&self) -> Vec<T>

Convert to vector (for testing/debugging)

pub fn sliding_window_into(&self, size: usize, dest: &mut [T]) -> usize

Zero-allocation sliding window - writes into pre-allocated buffer

Thread-safe version that minimizes lock hold time by copying directly into the destination buffer.

Returns

Number of elements written to destination

pub fn get_recent_samples(&self, count: usize, dest: &mut [T]) -> usize

Get the most recent N samples for circular convolution

Returns

Number of samples copied

Trait Implementations

impl<T: Copy + Default> Clone for RingBuffer<T>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.