Thread-local hazard pointer record with explicit memory ordering. More...

#include <safe_hazard_pointer.h>

Collaboration diagram for kcenon::thread::safe_hazard_pointer_record:

Public Member Functions
	safe_hazard_pointer_record ()

void	protect (void *p, size_t slot=0) noexcept
	Protect a pointer from reclamation.

void	clear (size_t slot=0) noexcept
	Clear hazard pointer protection.

bool	contains (void *p) const noexcept
	Check if a pointer is protected by this record.

void *	get (size_t slot=0) const noexcept
	Get protected pointer at slot.

Public Attributes
std::atomic< safe_hazard_pointer_record * >	next {nullptr}

std::atomic< bool >	active {false}

Static Public Attributes
static constexpr size_t	MAX_HAZARD_POINTERS = 2

Private Attributes
std::array< std::atomic< void * >, MAX_HAZARD_POINTERS >	hazard_pointers_

Detailed Description

Thread-local hazard pointer record with explicit memory ordering.

Each thread maintains a small array of hazard pointers. All atomic operations use explicit memory_order for correctness on weak memory model architectures (ARM, etc.)

Definition at line 34 of file safe_hazard_pointer.h.

Constructor & Destructor Documentation

◆ safe_hazard_pointer_record()

kcenon::thread::safe_hazard_pointer_record::safe_hazard_pointer_record ( )

inline

Examples: /home/runner/work/thread_system/thread_system/include/kcenon/thread/core/safe_hazard_pointer.h.

Definition at line 38 of file safe_hazard_pointer.h.

                                 {
        for (auto& hp : hazard_pointers_) {
            hp.store(nullptr, std::memory_order_relaxed);
        }
        next.store(nullptr, std::memory_order_relaxed);
        active.store(false, std::memory_order_relaxed);
    }

References active, hazard_pointers_, and next.

Member Function Documentation

◆ clear()

void kcenon::thread::safe_hazard_pointer_record::clear ( size_t slot = 0 )

inlinenoexcept

Clear hazard pointer protection.

Parameters

slot	Slot index

Uses memory_order_release to ensure the clear is visible before any subsequent operations.

Examples: /home/runner/work/thread_system/thread_system/include/kcenon/thread/core/safe_hazard_pointer.h.

Definition at line 66 of file safe_hazard_pointer.h.

                                         {
        assert(slot < MAX_HAZARD_POINTERS);
        hazard_pointers_[slot].store(nullptr, std::memory_order_release);
    }

References hazard_pointers_, and MAX_HAZARD_POINTERS.

Referenced by kcenon::thread::safe_hazard_pointer_domain::acquire(), and kcenon::thread::safe_hazard_guard::clear().

Here is the caller graph for this function:

◆ contains()

bool kcenon::thread::safe_hazard_pointer_record::contains ( void * p ) const

inlinenodiscardnoexcept

Check if a pointer is protected by this record.

Parameters

p	Pointer to check

Returns: true if protected

Uses memory_order_acquire to synchronize with protect() calls.

Examples: /home/runner/work/thread_system/thread_system/include/kcenon/thread/core/safe_hazard_pointer.h.

Definition at line 78 of file safe_hazard_pointer.h.

                                                        {
        for (const auto& hp : hazard_pointers_) {
            if (hp.load(std::memory_order_acquire) == p) {
                return true;
            }
        }
        return false;
    }

References hazard_pointers_.

◆ get()

void * kcenon::thread::safe_hazard_pointer_record::get ( size_t slot = 0 ) const

inlinenodiscardnoexcept

Get protected pointer at slot.

Parameters

slot	Slot index

Returns: Protected pointer or nullptr

Examples: /home/runner/work/thread_system/thread_system/include/kcenon/thread/core/safe_hazard_pointer.h.

Definition at line 92 of file safe_hazard_pointer.h.

                                                            {
        assert(slot < MAX_HAZARD_POINTERS);
        return hazard_pointers_[slot].load(std::memory_order_acquire);
    }

References hazard_pointers_, and MAX_HAZARD_POINTERS.

Referenced by kcenon::thread::safe_hazard_pointer_domain::collect_internal(), and kcenon::thread::safe_hazard_guard::get().

Here is the caller graph for this function:

◆ protect()

void kcenon::thread::safe_hazard_pointer_record::protect	(	void *	p,
		size_t	slot = 0 )

inlinenoexcept

Protect a pointer from reclamation.

Parameters

p	Pointer to protect
slot	Slot index (0 or 1)

Uses memory_order_release to ensure visibility to other threads scanning hazard pointers.

Examples: /home/runner/work/thread_system/thread_system/include/kcenon/thread/core/safe_hazard_pointer.h.

Definition at line 54 of file safe_hazard_pointer.h.

                                                    {
        assert(slot < MAX_HAZARD_POINTERS);
        hazard_pointers_[slot].store(p, std::memory_order_release);
    }

References hazard_pointers_, and MAX_HAZARD_POINTERS.

Referenced by kcenon::thread::safe_hazard_guard::protect(), and kcenon::thread::safe_hazard_guard::safe_hazard_guard().

Here is the caller graph for this function: