kcenon::thread::hazard_pointer_domain< T > Class Template Reference

Domain managing hazard pointers and retirement for a specific type. More...

#include <hazard_pointer.h>

Collaboration diagram for kcenon::thread::hazard_pointer_domain< T >:

Classes
struct	stats
	Get statistics. More...
struct	thread_retire_list

Public Member Functions
hazard_pointer	acquire ()
	Acquire a hazard pointer for this domain.
void	retire (T *ptr)
	Retire an object for later reclamation.
size_t	reclaim ()
	Force reclamation scan (optional, for testing)
stats	get_stats () const
	~hazard_pointer_domain ()
	Destructor - ensures all retire objects are reclaimed.

Static Public Member Functions
static hazard_pointer_domain &	global ()
	Get the global domain instance for type T.

Private Member Functions
	hazard_pointer_domain ()=default

Static Private Member Functions
static thread_retire_list &	get_thread_retire_list ()

Private Attributes
std::atomic< size_t >	objects_retired_ {0}
std::atomic< size_t >	objects_reclaimed_ {0}
std::atomic< size_t >	scan_count_ {0}

Detailed Description

template<typename T>
class kcenon::thread::hazard_pointer_domain< T >

Domain managing hazard pointers and retirement for a specific type.

Template Parameters

T	Type of objects protected by this domain

Definition at line 165 of file hazard_pointer.h.

Constructor & Destructor Documentation

~hazard_pointer_domain()

template<typename T >

kcenon::thread::hazard_pointer_domain< T >::~hazard_pointer_domain

(

)

Destructor - ensures all retire objects are reclaimed.

Definition at line 292 of file hazard_pointer.h.

                                                 {
    // Ensure all objects are reclaimed before domain destruction
    auto& retire_list = get_thread_retire_list();
    retire_list.reclaim_all();
}

hazard_pointer_domain()

template<typename T >

kcenon::thread::hazard_pointer_domain< T >::hazard_pointer_domain ( )

privatedefault

Member Function Documentation

acquire()

template<typename T >

hazard_pointer kcenon::thread::hazard_pointer_domain< T >::acquire ( )

inline

Acquire a hazard pointer for this domain.

Returns

Hazard pointer that will automatically release on destruction

Definition at line 175 of file hazard_pointer.h.

                             {
        return hazard_pointer();
    }

References kcenon::thread::hazard_pointer::hazard_pointer().

Here is the call graph for this function:

get_stats()

template<typename T >

auto kcenon::thread::hazard_pointer_domain< T >::get_stats

(

)

const

Definition at line 281 of file hazard_pointer.h.

                                                        {
    auto& registry = detail::hazard_pointer_registry::instance();
 
    return stats{.hazard_pointers_allocated = registry.get_active_thread_count() *
                                              detail::thread_hazard_list::MAX_HAZARDS_PER_THREAD,
                 .objects_retired = objects_retired_.load(std::memory_order_relaxed),
                 .objects_reclaimed = objects_reclaimed_.load(std::memory_order_relaxed),
                 .scan_count = scan_count_.load(std::memory_order_relaxed)};
}

References kcenon::thread::detail::hazard_pointer_registry::instance(), and kcenon::thread::detail::thread_hazard_list::MAX_HAZARDS_PER_THREAD.

Here is the call graph for this function:

get_thread_retire_list()

template<typename T >

static thread_retire_list & kcenon::thread::hazard_pointer_domain< T >::get_thread_retire_list ( )

inlinestaticprivate

Definition at line 230 of file hazard_pointer.h.

                                                        {
        static thread_local thread_retire_list list;
        return list;
    }

global()

template<typename T >

static hazard_pointer_domain & kcenon::thread::hazard_pointer_domain< T >::global ( )

inlinestatic

Get the global domain instance for type T.

Definition at line 168 of file hazard_pointer.h.

                                           {
        static hazard_pointer_domain instance;
        return instance;
    }

reclaim()

template<typename T >

size_t kcenon::thread::hazard_pointer_domain< T >::reclaim

(

)

Force reclamation scan (optional, for testing)

Returns

Number of objects reclaimed

Definition at line 261 of file hazard_pointer.h.

                                         {
    scan_count_.fetch_add(1, std::memory_order_relaxed);
 
    // Scan all hazard pointers to get protected set
    auto& registry = detail::hazard_pointer_registry::instance();
    auto protected_ptrs = registry.scan_hazard_pointers();
 
    // Reclaim objects not in protected set
    auto& retire_list = get_thread_retire_list();
    size_t reclaimed = retire_list.scan_and_reclaim(protected_ptrs);
 
    // Also try to reclaim from global orphanage
    // We can do this every time or periodically. Doing it every time ensures faster cleanup.
    reclaimed += detail::global_reclamation_manager::instance().reclaim(protected_ptrs);
 
    objects_reclaimed_.fetch_add(reclaimed, std::memory_order_relaxed);
    return reclaimed;
}

References kcenon::thread::detail::global_reclamation_manager::instance(), kcenon::thread::detail::hazard_pointer_registry::instance(), and kcenon::thread::detail::global_reclamation_manager::reclaim().

Here is the call graph for this function:

retire()

template<typename T >

void kcenon::thread::hazard_pointer_domain< T >::retire

(

T *

ptr

)

Retire an object for later reclamation.

Parameters

ptr	Pointer to object to retire

Note

Object will be deleted when no hazard pointers protect it

Definition at line 244 of file hazard_pointer.h.

                                            {
    if (!ptr) {
        return;
    }
 
    auto& retire_list = get_thread_retire_list();
    retire_list.add(ptr);
    objects_retired_.fetch_add(1, std::memory_order_relaxed);
 
    // Check if we should run reclamation using adaptive threshold
    // Threshold scales with active thread count to prevent excessive memory
    if (retire_list.count >= retire_list.get_adaptive_threshold()) {
        reclaim();
    }
}

Member Data Documentation

objects_reclaimed_

template<typename T >

std::atomic<size_t> kcenon::thread::hazard_pointer_domain< T >::objects_reclaimed_ {0}

mutableprivate

Definition at line 237 of file hazard_pointer.h.

{0};

objects_retired_

template<typename T >

std::atomic<size_t> kcenon::thread::hazard_pointer_domain< T >::objects_retired_ {0}

mutableprivate

Definition at line 236 of file hazard_pointer.h.

{0};

scan_count_

template<typename T >

std::atomic<size_t> kcenon::thread::hazard_pointer_domain< T >::scan_count_ {0}

mutableprivate

Definition at line 238 of file hazard_pointer.h.

{0};

---

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

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