Global manager for orphaned nodes from terminated threads. More...

#include <hazard_pointer.h>

Collaboration diagram for kcenon::thread::detail::global_reclamation_manager:

Public Member Functions
void	add_orphaned_nodes (retire_node *head, size_t count)
	Add a list of retired nodes to the global orphanage.

size_t	reclaim (const std::vector< void * > &protected_ptrs)
	Reclaim orphaned nodes that are no longer protected.

size_t	get_orphaned_count () const
	Get statistics.

Static Public Member Functions
static global_reclamation_manager &	instance ()

Private Member Functions
	global_reclamation_manager ()=default

Private Attributes
std::atomic< retire_node * >	head_ {nullptr}

std::atomic< size_t >	count_ {0}

Detailed Description

Global manager for orphaned nodes from terminated threads.

Definition at line 82 of file hazard_pointer.h.

Constructor & Destructor Documentation

◆ global_reclamation_manager()

kcenon::thread::detail::global_reclamation_manager::global_reclamation_manager ( )

privatedefault

Member Function Documentation

◆ add_orphaned_nodes()

void kcenon::thread::detail::global_reclamation_manager::add_orphaned_nodes	(	retire_node *	head,
		size_t	count )

Add a list of retired nodes to the global orphanage.

Parameters

head	Head of the linked list of retired nodes
count	Number of nodes in the list

Definition at line 153 of file hazard_pointer.cpp.

                                                                                   {
    if (!head)
        return;
 
    // Find tail of the new list
    retire_node* tail = head;
    while (tail->next) {
        tail = tail->next;
    }
 
    // Atomically prepend to the global list
    // Use acq_rel: acquire to see the current list, release to publish
    // the new nodes so that reclaim() sees them
    retire_node* old_head = head_.load(std::memory_order_acquire);
    do {
        tail->next = old_head;
    } while (!head_.compare_exchange_weak(old_head, head, std::memory_order_acq_rel,
                                          std::memory_order_relaxed));
 
    count_.fetch_add(count, std::memory_order_relaxed);
}

References count_, head_, and kcenon::thread::detail::retire_node::next.

Referenced by reclaim(), and kcenon::thread::hazard_pointer_domain< T >::thread_retire_list::reclaim_all().

Here is the caller graph for this function:

◆ get_orphaned_count()

size_t kcenon::thread::detail::global_reclamation_manager::get_orphaned_count ( ) const

Get statistics.

Definition at line 233 of file hazard_pointer.cpp.

                                                            {
    return count_.load(std::memory_order_relaxed);
}

References count_.

◆ instance()

global_reclamation_manager & kcenon::thread::detail::global_reclamation_manager::instance ( )

static

Definition at line 148 of file hazard_pointer.cpp.

                                                                 {
    static global_reclamation_manager manager;
    return manager;
}

Referenced by kcenon::thread::hazard_pointer_domain< T >::reclaim(), and kcenon::thread::hazard_pointer_domain< T >::thread_retire_list::reclaim_all().

Here is the caller graph for this function:

◆ reclaim()

size_t kcenon::thread::detail::global_reclamation_manager::reclaim ( const std::vector< void * > & protected_ptrs )

Reclaim orphaned nodes that are no longer protected.

Parameters

protected_ptrs List of currently protected pointers

Returns: Number of nodes reclaimed

Definition at line 175 of file hazard_pointer.cpp.

                                                                                 {
    // Take the entire list to process
    // Use acq_rel: acquire to see all node data, release to publish
    // the nullptr so concurrent add_orphaned_nodes sees it
    retire_node* curr = head_.exchange(nullptr, std::memory_order_acq_rel);
    if (!curr)
        return 0;
 
    size_t reclaimed = 0;
    retire_node* keep_head = nullptr;
    retire_node* keep_tail = nullptr;
    size_t keep_count = 0;
 
    while (curr) {
        retire_node* next = curr->next;
        bool is_protected = false;
 
        // Check if protected
        // Binary search since protected_ptrs is sorted
        if (std::binary_search(protected_ptrs.begin(), protected_ptrs.end(), curr->ptr)) {
            is_protected = true;
        }
 
        if (!is_protected) {
            // Safe to delete
            curr->deleter(curr->ptr);
            delete curr;
            ++reclaimed;
        } else {
            // Keep node
            if (!keep_head) {
                keep_head = curr;
                keep_tail = curr;
            } else {
                keep_tail->next = curr;
                keep_tail = curr;
            }
            curr->next = nullptr;
            ++keep_count;
        }
 
        curr = next;
    }
 
    // Subtract reclaimed count (not kept, since kept nodes will be re-added
    // via add_orphaned_nodes which increments count_ itself)
    // We need to subtract the total taken (reclaimed + keep_count) because
    // add_orphaned_nodes will add keep_count back
    count_.fetch_sub(reclaimed + keep_count, std::memory_order_relaxed);
 
    // Add back kept nodes (this will add keep_count to count_)
    if (keep_head) {
        add_orphaned_nodes(keep_head, keep_count);
    }
 
    return reclaimed;
}