cameron314/readerwriterqueue
Readerwriterqueue
This project is a single-producer single-consumer concurrent queue for C++ designed for lock-free data exchange between threads. It provides a thread-safe mechanism to transfer data without the use of mutexes or locks.
The queue is implemented as a contiguous circular buffer that supports dynamic capacity growth to prevent data loss when the queue reaches its limit. It utilizes atomic synchronization and wait-free index management to coordinate data access between the writing and reading threads.
The library covers inter-thread communication and buffer management, offering both blocking and non-blocking dequeue operations to manage how consuming threads wait for new data.
Features
- Single-Producer Single-Consumer Queues - Implements a specialized single-producer single-consumer model to eliminate contention and minimize synchronization overhead.
- Lock-Free Thread Communication - Provides high-performance primitives for transferring data between threads without the overhead of mutex locking.
- Thread-Safe Communication Channels - Offers a high-performance C++ data structure for safe information passing between concurrent threads.
- Circular Memory Buffers - Uses a ring-based memory layout to efficiently reuse space for data exchange between threads.
- Contiguous Memory Buffers - Allocates elements in flat, contiguous memory blocks to optimize cache locality and reduce latency.
- Lock-Free - Employs atomic primitives and memory barriers to ensure thread-safe data exchange without mutex locks.
- Buffer Capacity Growth - Supports dynamic allocation of larger contiguous blocks when the queue reaches capacity to prevent data loss.
- Wait-Free Synchronization - Manages head and tail indices using atomic integers to guarantee progress for both producer and consumer.
- Dynamic Buffer Management - Manages queue elements by combining upfront memory reservation with dynamic capacity expansion.
- Low Latency Messaging - Minimizes message delivery delay between threads by avoiding traditional mutex synchronization.
- Inter-Thread Buffer Management - Handles data streams between threads using a contiguous memory buffer that grows as demand increases.
- Blocking Synchronization - Implements mechanisms to suspend consumer threads until the producer adds new data to the queue.
- Concurrency and Parallelism - Fast single-producer single-consumer lock-free queue.
