kcenon::thread::detail::lockfree_job_queue::node_pool Class Reference

Lock-free node freelist (Treiber stack) for node recycling. More...

Collaboration diagram for kcenon::thread::detail::lockfree_job_queue::node_pool:

Public Member Functions
	node_pool ()=default
	~node_pool ()
	node_pool (const node_pool &)=delete
node_pool &	operator= (const node_pool &)=delete
node *	acquire (std::unique_ptr< job > &&job_data)
	Acquire a node from the pool, or allocate a new one.
void	release (node *n)
	Return a retired node to the pool for reuse.

Private Attributes
std::atomic< node * >	free_list_ {nullptr}

Detailed Description

Lock-free node freelist (Treiber stack) for node recycling.

Reduces heap allocations by reusing retired queue nodes. Nodes are returned to the pool via hazard pointer reclamation callbacks and acquired on enqueue instead of calling new.

Shared via shared_ptr so retire callbacks remain valid after queue destruction (the hazard pointer domain is a process-wide singleton and may invoke deleters after the queue is destroyed).

Definition at line 238 of file lockfree_job_queue.h.

Constructor & Destructor Documentation

node_pool() [1/2]

kcenon::thread::detail::lockfree_job_queue::node_pool::node_pool ( )

default

~node_pool()

kcenon::thread::detail::lockfree_job_queue::node_pool::~node_pool ( )

inline

Definition at line 242 of file lockfree_job_queue.h.

                     {
            // Drain freelist and delete all pooled nodes
            node* head = free_list_.load(std::memory_order_relaxed);
            while (head) {
                node* next = head->next.load(std::memory_order_relaxed);
                delete head;
                head = next;
            }
        }

References free_list_, and kcenon::thread::detail::lockfree_job_queue::node::next.

node_pool() [2/2]

kcenon::thread::detail::lockfree_job_queue::node_pool::node_pool ( const node_pool & )

delete

Member Function Documentation

acquire()

node * kcenon::thread::detail::lockfree_job_queue::node_pool::acquire ( std::unique_ptr< job > && job_data )

inline

Acquire a node from the pool, or allocate a new one.

Parameters

job_data

Job to store in the node

Returns

Pointer to a ready-to-use node

Definition at line 261 of file lockfree_job_queue.h.

                                                     {
            node* head = free_list_.load(std::memory_order_acquire);
            while (head) {
                if (free_list_.compare_exchange_weak(
                        head, head->next.load(std::memory_order_relaxed),
                        std::memory_order_acq_rel,
                        std::memory_order_acquire)) {
                    // Reuse pooled node — reset fields
                    head->data = std::move(job_data);
                    head->next.store(nullptr, std::memory_order_relaxed);
                    return head;
                }
                // head is updated by CAS on failure, retry
            }
            // Pool empty — allocate fresh node
            return new node(std::move(job_data));
        }

References kcenon::thread::detail::lockfree_job_queue::node::data, free_list_, and kcenon::thread::detail::lockfree_job_queue::node::next.

operator=()

node_pool & kcenon::thread::detail::lockfree_job_queue::node_pool::operator= ( const node_pool & )

delete

release()

void kcenon::thread::detail::lockfree_job_queue::node_pool::release ( node * n )

inline

Return a retired node to the pool for reuse.

Parameters

n	Node to recycle (must have been fully retired by HP scan)

Definition at line 283 of file lockfree_job_queue.h.

                              {
            if (!n) return;
            // Clear payload before pooling
            n->data.reset();
            node* old_head = free_list_.load(std::memory_order_relaxed);
            do {
                n->next.store(old_head, std::memory_order_relaxed);
            } while (!free_list_.compare_exchange_weak(
                old_head, n,
                std::memory_order_release,
                std::memory_order_relaxed));
        }

References kcenon::thread::detail::lockfree_job_queue::node::data, free_list_, and kcenon::thread::detail::lockfree_job_queue::node::next.

Member Data Documentation

free_list_

std::atomic<node*> kcenon::thread::detail::lockfree_job_queue::node_pool::free_list_ {nullptr}

private

Definition at line 297 of file lockfree_job_queue.h.

{nullptr};

Referenced by acquire(), release(), and ~node_pool().

---

The documentation for this class was generated from the following file:

• include/kcenon/thread/lockfree/lockfree_job_queue.h