kcenon::thread::hazard_pointer Class Reference

Single hazard pointer that protects one object from reclamation Uses RAII pattern - automatically releases protection on destruction. More...

#include <hazard_pointer.h>

Collaboration diagram for kcenon::thread::hazard_pointer:

Public Member Functions
	hazard_pointer ()
	Default constructor - acquires a hazard pointer slot.
	hazard_pointer (hazard_pointer &&other) noexcept
	Move constructor.
hazard_pointer &	operator= (hazard_pointer &&other) noexcept
	Move assignment.
	~hazard_pointer ()
	Destructor - automatically releases protection.
	hazard_pointer (const hazard_pointer &)=delete
	Non-copyable.
hazard_pointer &	operator= (const hazard_pointer &)=delete
template<typename T >
void	protect (T *ptr) noexcept
	Protect a pointer from reclamation.
void	reset () noexcept
	Release protection.
bool	is_protected () const noexcept
	Check if currently protecting a pointer.
void *	get_protected () const noexcept
	Get the protected pointer (may be null)

Private Attributes
std::atomic< void * > *	slot_
size_t	slot_index_

Static Private Attributes
static const void *	SLOT_OWNED_MARKER = reinterpret_cast<void*>(0x1)

Detailed Description

Single hazard pointer that protects one object from reclamation Uses RAII pattern - automatically releases protection on destruction.

Definition at line 110 of file hazard_pointer.h.

Constructor & Destructor Documentation

hazard_pointer() [1/3]

kcenon::thread::hazard_pointer::hazard_pointer

(

)

Default constructor - acquires a hazard pointer slot.

Definition at line 241 of file hazard_pointer.cpp.

                               : slot_(nullptr), slot_index_(0) {
    auto* thread_list = detail::hazard_pointer_registry::instance().get_thread_list();
 
    // Find an available slot (slot value is nullptr means available)
    for (size_t i = 0; i < detail::thread_hazard_list::MAX_HAZARDS_PER_THREAD; ++i) {
        void* expected = nullptr;
        // Try to claim this slot with SLOT_OWNED_MARKER
        // Use acq_rel: acquire to synchronize with prior release of the slot,
        // release to publish ownership to scanning threads
        if (thread_list->hazards[i].compare_exchange_strong(
                expected, const_cast<void*>(SLOT_OWNED_MARKER), std::memory_order_acq_rel,
                std::memory_order_relaxed)) {
            slot_ = &thread_list->hazards[i];
            slot_index_ = i;
            // Slot is now owned with SLOT_OWNED_MARKER
            return;
        }
    }
 
    throw std::runtime_error("Hazard pointer slots exhausted");
}

References kcenon::thread::detail::hazard_pointer_registry::get_thread_list(), kcenon::thread::detail::hazard_pointer_registry::instance(), kcenon::thread::detail::thread_hazard_list::MAX_HAZARDS_PER_THREAD, slot_, slot_index_, and SLOT_OWNED_MARKER.

Referenced by kcenon::thread::hazard_pointer_domain< T >::acquire().

Here is the call graph for this function:

Here is the caller graph for this function:

hazard_pointer() [2/3]

kcenon::thread::hazard_pointer::hazard_pointer ( hazard_pointer && other )

noexcept

Move constructor.

Definition at line 263 of file hazard_pointer.cpp.

    : slot_(other.slot_), slot_index_(other.slot_index_) {
    other.slot_ = nullptr;
    other.slot_index_ = 0;
}

~hazard_pointer()

kcenon::thread::hazard_pointer::~hazard_pointer

(

)

Destructor - automatically releases protection.

Definition at line 282 of file hazard_pointer.cpp.

                                {
    if (slot_) {
        // Release the slot back to the pool
        slot_->store(nullptr, std::memory_order_release);
    }
}

References slot_.

hazard_pointer() [3/3]

kcenon::thread::hazard_pointer::hazard_pointer ( const hazard_pointer & )

delete

Non-copyable.

Member Function Documentation

get_protected()

void * kcenon::thread::hazard_pointer::get_protected ( ) const

noexcept

Get the protected pointer (may be null)

Definition at line 304 of file hazard_pointer.cpp.

                                                   {
    if (!slot_) {
        return nullptr;
    }
    void* ptr = slot_->load(std::memory_order_acquire);
    // Return nullptr if slot is just owned but not protecting anything
    return (ptr == SLOT_OWNED_MARKER) ? nullptr : ptr;
}

References slot_, and SLOT_OWNED_MARKER.

is_protected()

bool kcenon::thread::hazard_pointer::is_protected ( ) const

noexcept

Check if currently protecting a pointer.

Definition at line 296 of file hazard_pointer.cpp.

                                                 {
    if (!slot_) {
        return false;
    }
    void* ptr = slot_->load(std::memory_order_acquire);
    return ptr != nullptr && ptr != SLOT_OWNED_MARKER;
}

References slot_, and SLOT_OWNED_MARKER.

Referenced by kcenon::thread::hazard_pointer_domain< T >::thread_retire_list::scan_and_reclaim().

Here is the caller graph for this function:

operator=() [1/2]

hazard_pointer & kcenon::thread::hazard_pointer::operator= ( const hazard_pointer & )

delete

operator=() [2/2]

hazard_pointer & kcenon::thread::hazard_pointer::operator= ( hazard_pointer && other )

noexcept

Move assignment.

Definition at line 269 of file hazard_pointer.cpp.

                                                                         {
    if (this != &other) {
        reset();
 
        slot_ = other.slot_;
        slot_index_ = other.slot_index_;
 
        other.slot_ = nullptr;
        other.slot_index_ = 0;
    }
    return *this;
}

protect()

template<typename T >

void kcenon::thread::hazard_pointer::protect ( T * ptr )

inlinenoexcept

Protect a pointer from reclamation.

Parameters

ptr	Pointer to protect

Note

Thread-safe, can be called concurrently

Uses memory_order_seq_cst to ensure the hazard pointer store is globally visible before any subsequent load of the shared pointer in the protect-then-verify pattern. On weak memory architectures (ARM), release + acquire is insufficient because the store and subsequent load can be reordered.

Definition at line 137 of file hazard_pointer.h.

                                  {
        if (slot_) {
            slot_->store(static_cast<void*>(ptr), std::memory_order_seq_cst);
        }
    }

References slot_.

reset()

void kcenon::thread::hazard_pointer::reset ( )

noexcept

Release protection.

Note

After reset(), the previously protected pointer may be reclaimed

Keeps the slot owned but clears the protected pointer

Definition at line 289 of file hazard_pointer.cpp.

                                    {
    if (slot_) {
        // Clear protection but keep slot owned
        slot_->store(const_cast<void*>(SLOT_OWNED_MARKER), std::memory_order_release);
    }
}

References slot_, and SLOT_OWNED_MARKER.

Member Data Documentation

slot_

std::atomic<void*>* kcenon::thread::hazard_pointer::slot_

private

Definition at line 158 of file hazard_pointer.h.

Referenced by get_protected(), hazard_pointer(), is_protected(), protect(), reset(), and ~hazard_pointer().

slot_index_

size_t kcenon::thread::hazard_pointer::slot_index_

private

Definition at line 159 of file hazard_pointer.h.

Referenced by hazard_pointer().

SLOT_OWNED_MARKER

const void* kcenon::thread::hazard_pointer::SLOT_OWNED_MARKER = reinterpret_cast<void*>(0x1)

inlinestaticprivate

Definition at line 156 of file hazard_pointer.h.

Referenced by get_protected(), hazard_pointer(), is_protected(), and reset().

---

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

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