kcenon::thread::detail::hazard_pointer_registry Class Reference

Global hazard pointer registry Manages all thread-local hazard lists. More...

#include <hazard_pointer.h>

Collaboration diagram for kcenon::thread::detail::hazard_pointer_registry:

Public Member Functions
thread_hazard_list *	get_thread_list ()
	Get or create thread-local hazard list.
void	mark_inactive ()
	Mark current thread's list as inactive.
std::vector< void * >	scan_hazard_pointers ()
	Scan all hazard pointers and collect protected pointers.
size_t	get_active_thread_count () const
	Get total number of active threads.

Static Public Member Functions
static hazard_pointer_registry &	instance ()

Private Member Functions
	hazard_pointer_registry ()=default

Private Attributes
std::atomic< thread_hazard_list * >	head_ {nullptr}
std::atomic< size_t >	thread_count_ {0}

Detailed Description

Global hazard pointer registry Manages all thread-local hazard lists.

Definition at line 58 of file hazard_pointer.h.

Constructor & Destructor Documentation

hazard_pointer_registry()

kcenon::thread::detail::hazard_pointer_registry::hazard_pointer_registry ( )

privatedefault

Member Function Documentation

get_active_thread_count()

size_t kcenon::thread::detail::hazard_pointer_registry::get_active_thread_count

(

)

const

Get total number of active threads.

Definition at line 143 of file hazard_pointer.cpp.

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

References thread_count_.

get_thread_list()

thread_hazard_list * kcenon::thread::detail::hazard_pointer_registry::get_thread_list

(

)

Get or create thread-local hazard list.

Definition at line 22 of file hazard_pointer.cpp.

                                                             {
    // Thread-local storage for this thread's hazard list
    static thread_local thread_hazard_list* thread_list = nullptr;
 
    if (thread_list == nullptr) {
        // Try to reuse an inactive list first to prevent unbounded memory growth
        thread_hazard_list* curr = head_.load(std::memory_order_acquire);
        while (curr) {
            bool expected = false;
            // Try to claim an inactive list
            // Use acq_rel: acquire to see prior hazard pointer clears,
            // release to publish active=true to scanning threads
            if (curr->active.compare_exchange_strong(expected, true, std::memory_order_acq_rel,
                                                     std::memory_order_relaxed)) {
                thread_list = curr;
                thread_count_.fetch_add(1, std::memory_order_relaxed);
                break;
            }
            curr = curr->next;
        }
 
        // If no inactive list found, allocate a new one
        if (thread_list == nullptr) {
            thread_list = new thread_hazard_list();
 
            // Add to global linked list
            // Use acq_rel on CAS: acquire to read current list, release to
            // publish the new node so that scanning threads see it
            thread_hazard_list* old_head = head_.load(std::memory_order_acquire);
            do {
                thread_list->next = old_head;
            } while (!head_.compare_exchange_weak(old_head, thread_list, std::memory_order_acq_rel,
                                                  std::memory_order_relaxed));
 
            thread_count_.fetch_add(1, std::memory_order_relaxed);
        }
 
        // Register thread cleanup
        static thread_local struct thread_cleanup {
            thread_hazard_list* list;
 
            ~thread_cleanup() {
                if (list) {
                    hazard_pointer_registry::instance().mark_inactive();
                }
            }
        } cleanup{thread_list};
    }
 
    return thread_list;
}

References kcenon::thread::detail::thread_hazard_list::active, head_, kcenon::thread::detail::thread_hazard_list::next, and thread_count_.

Referenced by kcenon::thread::hazard_pointer::hazard_pointer(), and mark_inactive().

Here is the caller graph for this function:

instance()

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

static

Definition at line 16 of file hazard_pointer.cpp.

                                                           {
    static hazard_pointer_registry registry;
    return registry;
}

Referenced by kcenon::thread::hazard_pointer_domain< T >::get_stats(), kcenon::thread::hazard_pointer::hazard_pointer(), 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:

mark_inactive()

void kcenon::thread::detail::hazard_pointer_registry::mark_inactive

(

)

Mark current thread's list as inactive.

Definition at line 75 of file hazard_pointer.cpp.

                                            {
    static thread_local thread_hazard_list* thread_list = get_thread_list();
 
    if (thread_list) {
        // Clear all hazard pointers
        for (auto& h : thread_list->hazards) {
            h.store(nullptr, std::memory_order_release);
        }
 
        // Mark as inactive (using release to ensure visibility)
        thread_list->active.store(false, std::memory_order_release);
        thread_count_.fetch_sub(1, std::memory_order_relaxed);
    }
}

References kcenon::thread::detail::thread_hazard_list::active, get_thread_list(), kcenon::thread::detail::thread_hazard_list::hazards, and thread_count_.

Here is the call graph for this function:

scan_hazard_pointers()

std::vector< void * > kcenon::thread::detail::hazard_pointer_registry::scan_hazard_pointers

(

)

Scan all hazard pointers and collect protected pointers.

Definition at line 91 of file hazard_pointer.cpp.

                                                               {
    std::vector<void*> protected_ptrs;
    protected_ptrs.reserve(256);  // Pre-allocate reasonable size
 
    // Marker value for owned but not protecting slots
    const void* SLOT_OWNED_MARKER = reinterpret_cast<void*>(0x1);
 
    // Periodically clean up inactive thread lists
    // Use scan counter to avoid overhead on every scan
    static thread_local size_t scan_counter = 0;
    static constexpr size_t CLEANUP_INTERVAL = 100;  // Clean every 100 scans
    bool should_cleanup = (++scan_counter % CLEANUP_INTERVAL == 0);
 
    // Traverse all thread lists
    thread_hazard_list* curr = head_.load(std::memory_order_acquire);
    size_t inactive_count = 0;
 
    while (curr) {
        // IMPORTANT: Scan ALL records regardless of active status.
        // A thread may be in the process of setting a hazard pointer before
        // setting active=true (race window in get_thread_list). If we skip
        // inactive records, we might miss a valid hazard pointer and
        // prematurely reclaim a protected node.
        // This matches the approach used in safe_hazard_pointer.h.
        for (auto& hazard : curr->hazards) {
            void* ptr = hazard.load(std::memory_order_acquire);
            // Only add if it's a real pointer (not nullptr or SLOT_OWNED_MARKER)
            if (ptr != nullptr && ptr != SLOT_OWNED_MARKER) {
                protected_ptrs.push_back(ptr);
            }
        }
 
        if (!curr->active.load(std::memory_order_acquire)) {
            ++inactive_count;
        }
 
        curr = curr->next;
    }
 
    // Sort for efficient binary search in scan_and_reclaim
    // O(N log N) but enables O(log N) lookups later
    std::sort(protected_ptrs.begin(), protected_ptrs.end());
 
    // Remove duplicates to minimize search space
    // Multiple threads may protect the same pointer
    protected_ptrs.erase(std::unique(protected_ptrs.begin(), protected_ptrs.end()),
                         protected_ptrs.end());
 
    return protected_ptrs;
}

References kcenon::thread::detail::thread_hazard_list::active, kcenon::thread::detail::thread_hazard_list::hazards, head_, and kcenon::thread::detail::thread_hazard_list::next.

Member Data Documentation

head_

std::atomic<thread_hazard_list*> kcenon::thread::detail::hazard_pointer_registry::head_ {nullptr}

private

Definition at line 77 of file hazard_pointer.h.

{nullptr};

Referenced by get_thread_list(), and scan_hazard_pointers().

thread_count_

std::atomic<size_t> kcenon::thread::detail::hazard_pointer_registry::thread_count_ {0}

private

Definition at line 78 of file hazard_pointer.h.

{0};

Referenced by get_active_thread_count(), get_thread_list(), and mark_inactive().

---

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

• include/kcenon/thread/core/hazard_pointer.h
• src/core/hazard_pointer.cpp