Lock-free single-producer single-consumer queue. More...

#include <lockfree_queue.h>

Collaboration diagram for kcenon::logger::async::lockfree_spsc_queue< T, Size >:

Classes
struct	cell
	Cell structure with sequence number for ABA prevention. More...

Public Member Functions
	lockfree_spsc_queue ()
	Constructor.

	~lockfree_spsc_queue ()
	Destructor.

bool	enqueue (const T &item)
	Enqueue an item (producer side)

bool	enqueue (T &&item)
	Enqueue an item using move semantics (producer side)

bool	dequeue (T &item)
	Dequeue an item (consumer side)

bool	empty () const
	Check if queue is empty.

bool	full () const
	Check if queue is full.

size_t	size () const
	Get approximate queue size.

constexpr size_t	capacity () const
	Get queue capacity.

Private Member Functions
template<typename U >
bool	enqueue_impl (U &&item)
	Implementation for enqueue operations.

Private Attributes
std::atomic< size_t >	head_

std::atomic< size_t >	tail_

std::array< cell, Size >	cells_

Static Private Attributes
static constexpr size_t	mask_ = Size - 1

static constexpr size_t	cache_line_size = 64
	Cache line size for padding.

Detailed Description

template<typename T, size_t Size>
class kcenon::logger::async::lockfree_spsc_queue< T, Size >

Lock-free single-producer single-consumer queue.

Template Parameters

T	Type of elements to store
Size	Queue capacity (must be power of 2)

Definition at line 35 of file lockfree_queue.h.

Constructor & Destructor Documentation

◆ lockfree_spsc_queue()

template<typename T , size_t Size>

kcenon::logger::async::lockfree_spsc_queue< T, Size >::lockfree_spsc_queue ( )

inline

Constructor.

Definition at line 43 of file lockfree_queue.h.

        : head_{0}
        , tail_{0} {
        // Initialize cell sequence numbers for ABA prevention
        for (size_t i = 0; i < Size; ++i) {
            cells_[i].sequence.store(i, std::memory_order_relaxed);
        }
    }

References kcenon::logger::async::lockfree_spsc_queue< T, Size >::cells_.

◆ ~lockfree_spsc_queue()

template<typename T , size_t Size>

kcenon::logger::async::lockfree_spsc_queue< T, Size >::~lockfree_spsc_queue ( )

inline

Destructor.

Definition at line 55 of file lockfree_queue.h.

                           {
        T item;
        while (dequeue(item)) {
            // Clean up remaining items
        }
    }

References kcenon::logger::async::lockfree_spsc_queue< T, Size >::dequeue().

Here is the call graph for this function:

Member Function Documentation

◆ capacity()

template<typename T , size_t Size>

size_t kcenon::logger::async::lockfree_spsc_queue< T, Size >::capacity ( ) const

inlineconstexpr

Get queue capacity.

Returns: Maximum number of elements

Definition at line 137 of file lockfree_queue.h.

                                      {
        return Size;
    }

◆ dequeue()

template<typename T , size_t Size>

bool kcenon::logger::async::lockfree_spsc_queue< T, Size >::dequeue ( T & item )

inline

Dequeue an item (consumer side)

Parameters

item	Reference to store the dequeued item

Returns: true if successful, false if queue is empty

Definition at line 85 of file lockfree_queue.h.

                          {
        const size_t pos = tail_.load(std::memory_order_relaxed);
        auto& cell = cells_[pos & mask_];
 
        const size_t seq = cell.sequence.load(std::memory_order_acquire);
        const size_t expected_seq = pos + 1;
 
        if (seq != expected_seq) {
            return false; // Queue is empty
        }
 
        item = std::move(cell.data);
        cell.sequence.store(pos + mask_ + 1, std::memory_order_release);
        tail_.store(pos + 1, std::memory_order_relaxed);
 
        return true;
    }

References kcenon::logger::async::lockfree_spsc_queue< T, Size >::cells_, kcenon::logger::async::lockfree_spsc_queue< T, Size >::cell::data, kcenon::logger::async::lockfree_spsc_queue< T, Size >::mask_, kcenon::logger::async::lockfree_spsc_queue< T, Size >::cell::sequence, and kcenon::logger::async::lockfree_spsc_queue< T, Size >::tail_.

Referenced by kcenon::logger::async::lockfree_spsc_queue< T, Size >::~lockfree_spsc_queue().

Here is the caller graph for this function:

◆ empty()

template<typename T , size_t Size>

bool kcenon::logger::async::lockfree_spsc_queue< T, Size >::empty ( ) const

inline

Check if queue is empty.

Returns: true if empty

Definition at line 107 of file lockfree_queue.h.

                       {
        const size_t head_pos = head_.load(std::memory_order_acquire);
        const size_t tail_pos = tail_.load(std::memory_order_acquire);
        return head_pos == tail_pos;
    }

References kcenon::logger::async::lockfree_spsc_queue< T, Size >::head_, and kcenon::logger::async::lockfree_spsc_queue< T, Size >::tail_.

◆ enqueue() [1/2]

template<typename T , size_t Size>

bool kcenon::logger::async::lockfree_spsc_queue< T, Size >::enqueue ( const T & item )

inline

Enqueue an item (producer side)

Parameters

item	Item to enqueue

Returns: true if successful, false if queue is full

Definition at line 67 of file lockfree_queue.h.

                                {
        return enqueue_impl(item);
    }

References kcenon::logger::async::lockfree_spsc_queue< T, Size >::enqueue_impl().

Here is the call graph for this function:

◆ enqueue() [2/2]

template<typename T , size_t Size>

bool kcenon::logger::async::lockfree_spsc_queue< T, Size >::enqueue ( T && item )

inline

Enqueue an item using move semantics (producer side)

Parameters

item	Item to enqueue

Returns: true if successful, false if queue is full

Definition at line 76 of file lockfree_queue.h.

                           {
        return enqueue_impl(std::move(item));
    }

References kcenon::logger::async::lockfree_spsc_queue< T, Size >::enqueue_impl().

Here is the call graph for this function:

◆ enqueue_impl()

template<typename T , size_t Size>

template<typename U >

bool kcenon::logger::async::lockfree_spsc_queue< T, Size >::enqueue_impl ( U && item )

inlineprivate

Implementation for enqueue operations.

Template Parameters

U	Universal reference type

Parameters

item	Item to enqueue

Returns: true if successful, false if queue is full

Definition at line 166 of file lockfree_queue.h.

                                {
        const size_t pos = head_.load(std::memory_order_relaxed);
        auto& cell = cells_[pos & mask_];
 
        const size_t seq = cell.sequence.load(std::memory_order_acquire);
        const size_t expected_seq = pos;
 
        if (seq != expected_seq) {
            return false; // Queue is full
        }
 
        cell.data = std::forward<U>(item);
        cell.sequence.store(pos + 1, std::memory_order_release);
        head_.store(pos + 1, std::memory_order_relaxed);
 
        return true;
    }

References kcenon::logger::async::lockfree_spsc_queue< T, Size >::cell::data, and kcenon::logger::async::lockfree_spsc_queue< T, Size >::cell::sequence.

Referenced by kcenon::logger::async::lockfree_spsc_queue< T, Size >::enqueue(), and kcenon::logger::async::lockfree_spsc_queue< T, Size >::enqueue().

Here is the caller graph for this function:

◆ full()

template<typename T , size_t Size>

bool kcenon::logger::async::lockfree_spsc_queue< T, Size >::full ( ) const

inline

Check if queue is full.

Returns: true if full

Definition at line 117 of file lockfree_queue.h.

                      {
        const size_t head_pos = head_.load(std::memory_order_acquire);
        const size_t tail_pos = tail_.load(std::memory_order_acquire);
        return ((head_pos + 1) & mask_) == (tail_pos & mask_);
    }

References kcenon::logger::async::lockfree_spsc_queue< T, Size >::head_, kcenon::logger::async::lockfree_spsc_queue< T, Size >::mask_, and kcenon::logger::async::lockfree_spsc_queue< T, Size >::tail_.

◆ size()

template<typename T , size_t Size>

size_t kcenon::logger::async::lockfree_spsc_queue< T, Size >::size ( ) const

inline

Get approximate queue size.

Returns: Approximate number of elements in queue

Definition at line 127 of file lockfree_queue.h.

                        {
        const size_t head_pos = head_.load(std::memory_order_acquire);
        const size_t tail_pos = tail_.load(std::memory_order_acquire);
        return head_pos - tail_pos;
    }