无锁无序槽池 / Lock-free, unordered slot pool More...

#include <lockfree_pool.hpp>

Collaboration diagram for LibXR::LockFreePool< Data >:

Data Structures
union	Slot
	单个槽结构体 / Individual slot structure (cache line aligned) More...

Public Types
enum class	SlotState : uint32_t { FREE = 0 , BUSY = 1 , READY = 2 , RECYCLE = UINT32_MAX }
	槽状态 / Slot state More...

Public Member Functions
	LockFreePool (uint32_t slot_count)
	构造对象池 / Constructor for the pool

	~LockFreePool ()
	析构，释放槽池内存 / Destructor, releasing pool memory

ErrorCode	Put (const Data &data)
	向池中放入一个元素 / Put an element into the pool

ErrorCode	Put (const Data &data, uint32_t &start_index)
	向池中放入一个元素，返回起始槽索引 / Put an element into the pool and return the starting slot index

ErrorCode	PutToSlot (const Data &data, uint32_t index)
	向指定槽放入一个元素 / Put an element into a specific slot

ErrorCode	Get (Data &data)
	从池中取出一个元素 / Retrieve an element from the pool

ErrorCode	Get (Data &data, uint32_t &start_index)
	从指定槽位开始，取出一个元素 / Retrieve an element from the pool

ErrorCode	GetFromSlot (Data &data, uint32_t index)
	从指定槽位开始，取出一个元素 / Retrieve an element from the pool

ErrorCode	RecycleSlot (uint32_t index)
	回收指定槽位 / Recycle a slot

size_t	Size () const
	查询池中可取元素数量 / Query the number of available elements in the pool

size_t	EmptySize ()
	查询当前池可用槽数量 / Query the number of writable slots in the pool

uint32_t	SlotCount () const
	获取槽总数 / Get the total number of slots in the pool

Protected Member Functions
Slot &	operator[] (uint32_t index)

Private Attributes
const uint32_t	SLOT_COUNT
	槽总数 / Number of slots

Slot *	slots_
	槽数组指针 / Array of slots

Detailed Description

template<typename Data>
class LibXR::LockFreePool< Data >

无锁无序槽池 / Lock-free, unordered slot pool

该类实现了一个固定容量的无锁无序对象池，允许多个线程安全地并发存入（Put）和取出（Get）元素。每个槽独立管理，无严格顺序，适用于高性能、多线程或中断场景的数据缓存、对象重用等需求。

This class implements a lock-free, unordered slot/object pool with a fixed size. Multiple threads can safely Put (store) and Get (retrieve) elements concurrently. Each slot is managed independently, making it ideal for high-performance, multi-thread, or interrupt-safe buffering and object reuse.

Template Parameters

Data	槽中存储的数据类型 / Type of data stored in each slot.

Definition at line 25 of file lockfree_pool.hpp.

Member Enumeration Documentation

◆ SlotState

template<typename Data >

enum class LibXR::LockFreePool::SlotState : uint32_t

strong

槽状态 / Slot state

Enumerator
FREE	空闲，可写 / Slot is free and can be written.
BUSY	正在写入 / Slot is being written.
READY	写入完成，可读 / Slot contains valid data, ready to read.
RECYCLE	已读待回收 / Slot was read, waiting for next write.

Definition at line 30 of file lockfree_pool.hpp.

  {
    FREE = 0,             
    BUSY = 1,             
    READY = 2,            
    RECYCLE = UINT32_MAX  
 
  };

Constructor & Destructor Documentation

◆ LockFreePool()

template<typename Data >

LibXR::LockFreePool< Data >::LockFreePool ( uint32_t slot_count )

inline

构造对象池 / Constructor for the pool

Parameters

slot_count 槽数量 / Number of slots in the pool

Definition at line 56 of file lockfree_pool.hpp.

      : SLOT_COUNT(slot_count),
        slots_(new(std::align_val_t(LIBXR_CACHE_LINE_SIZE)) Slot[slot_count])
  {
    for (uint32_t index = 0; index < SLOT_COUNT; index++)
    {
      slots_[index].slot.state.store(SlotState::FREE, std::memory_order_relaxed);
    }
  }

◆ ~LockFreePool()

template<typename Data >

LibXR::LockFreePool< Data >::~LockFreePool ( )

inline

析构，释放槽池内存 / Destructor, releasing pool memory

Definition at line 69 of file lockfree_pool.hpp.

69{ delete[] slots_; }

Member Function Documentation

◆ EmptySize()

template<typename Data >

size_t LibXR::LockFreePool< Data >::EmptySize ( )

inlinenodiscard

查询当前池可用槽数量 / Query the number of writable slots in the pool

Returns: 可写入的空槽数 / Number of writable slots in pool

Definition at line 265 of file lockfree_pool.hpp.

  {
    uint32_t size = 0;
    for (uint32_t index = 0; index < SLOT_COUNT; index++)
    {
      auto state = slots_[index].slot.state.load(std::memory_order_relaxed);
      if (state == SlotState::FREE || state == SlotState::RECYCLE)
      {
        size++;
      }
    }
    return size;
  }

◆ Get() [1/2]

template<typename Data >

ErrorCode LibXR::LockFreePool< Data >::Get ( Data & data )

inline

从池中取出一个元素 / Retrieve an element from the pool

Parameters

[out] data 获取到的数据 / Variable to store the retrieved data

Returns

操作结果 / Operation result:

ErrorCode::OK：成功取出 / Successfully retrieved
ErrorCode::EMPTY：池空，无可取元素 / Pool empty, no available element

Definition at line 150 of file lockfree_pool.hpp.

  {
    uint32_t start_index = 0;
 
    return Get(data, start_index);
  }

◆ Get() [2/2]

template<typename Data >

ErrorCode LibXR::LockFreePool< Data >::Get	(	Data &	data,
		uint32_t &	start_index )

inline

从指定槽位开始，取出一个元素 / Retrieve an element from the pool

Parameters

[out]	data	获取到的数据 / Variable to store the retrieved data
[in,out]	start_index	本次起始槽，返回本次实际取出槽位置 / Starting slot index, returned with the actual slot index

Returns

操作结果 / Operation result:

ErrorCode::OK：成功取出 / Successfully retrieved
ErrorCode::EMPTY：池空，无可取元素 / Pool empty, no available element

Definition at line 167 of file lockfree_pool.hpp.

  {
    for (uint32_t index = start_index; index < SLOT_COUNT; index++)
    {
      auto expected = slots_[index].slot.state.load(std::memory_order_acquire);
      if (expected == SlotState::READY)
      {
        if (slots_[index].slot.state.compare_exchange_strong(expected, SlotState::BUSY,
                                                             std::memory_order_acquire,
                                                             std::memory_order_relaxed))
        {
          data = slots_[index].slot.data;
          slots_[index].slot.state.store(SlotState::RECYCLE, std::memory_order_release);
          start_index = index;
          return ErrorCode::OK;
        }
      }
      if (expected == SlotState::FREE)
      {
        start_index = 0;
        return ErrorCode::EMPTY;
      }
    }
 
    start_index = 0;
    return ErrorCode::EMPTY;
  }

◆ GetFromSlot()

template<typename Data >

ErrorCode LibXR::LockFreePool< Data >::GetFromSlot	(	Data &	data,
		uint32_t	index )

inline

从指定槽位开始，取出一个元素 / Retrieve an element from the pool

Parameters

data	获取到的数据 / Variable to store the retrieved data
index	槽索引 / Slot index

Returns

ErrorCode 操作结果 / Operation result:

ErrorCode::OK：成功取出 / Successfully retrieved
ErrorCode::EMPTY：池空，无可取元素 / Pool empty, no available element

Definition at line 204 of file lockfree_pool.hpp.

  {
    auto expected = slots_[index].slot.state.load(std::memory_order_acquire);
    if (expected == SlotState::READY)
    {
      if (slots_[index].slot.state.compare_exchange_strong(expected, SlotState::BUSY,
                                                           std::memory_order_acquire,
                                                           std::memory_order_relaxed))
      {
        data = slots_[index].slot.data;
        slots_[index].slot.state.store(SlotState::RECYCLE, std::memory_order_release);
        return ErrorCode::OK;
      }
    }
    return ErrorCode::EMPTY;
  }

◆ operator[]()

template<typename Data >

Slot & LibXR::LockFreePool< Data >::operator[] ( uint32_t index )

inlineprotected

Definition at line 287 of file lockfree_pool.hpp.

  {
    if (index >= SLOT_COUNT)
    {
      ASSERT(false);
    }
    return slots_[index];
  }

◆ Put() [1/2]

template<typename Data >

ErrorCode LibXR::LockFreePool< Data >::Put ( const Data & data )

inline

向池中放入一个元素 / Put an element into the pool

Parameters

data	要存储的数据 / Data to store

Returns

操作结果 / Operation result:

ErrorCode::OK：成功放入 / Successfully put
ErrorCode::FULL：池满，无法放入 / Pool full, cannot put

Definition at line 79 of file lockfree_pool.hpp.

  {
    uint32_t start_index = 0;
    return Put(data, start_index);
  }

◆ Put() [2/2]

template<typename Data >

ErrorCode LibXR::LockFreePool< Data >::Put	(	const Data &	data,
		uint32_t &	start_index )

inline

向池中放入一个元素，返回起始槽索引 / Put an element into the pool and return the starting slot index

Parameters

data	要存储的数据 / Data to store
start_index	起始槽索引 / Starting slot index

Returns

ErrorCode 操作结果 / Operation result:

ErrorCode::OK：成功放入 / Successfully put
ErrorCode::FULL：池满，无法放入 / Pool full, cannot put

Definition at line 95 of file lockfree_pool.hpp.

  {
    for (uint32_t index = start_index; index < SLOT_COUNT; index++)
    {
      auto expected = slots_[index].slot.state.load(std::memory_order_relaxed);
      if (expected == SlotState::FREE || expected == SlotState::RECYCLE)
      {
        if (slots_[index].slot.state.compare_exchange_strong(expected, SlotState::BUSY,
                                                             std::memory_order_release,
                                                             std::memory_order_relaxed))
        {
          slots_[index].slot.data = data;
          slots_[index].slot.state.store(SlotState::READY, std::memory_order_release);
          start_index = index;
          return ErrorCode::OK;
        }
      }
    }
    return ErrorCode::FULL;
  }

◆ PutToSlot()

template<typename Data >

ErrorCode LibXR::LockFreePool< Data >::PutToSlot	(	const Data &	data,
		uint32_t	index )

inline

向指定槽放入一个元素 / Put an element into a specific slot

Parameters

data	要存储的数据 / Data to store
index	槽索引 / Slot index

Returns

ErrorCode 操作结果 / Operation result:

ErrorCode::OK：成功放入 / Successfully put
ErrorCode::FULL：池满，无法放入 / Pool full, cannot put

Definition at line 125 of file lockfree_pool.hpp.

  {
    auto expected = slots_[index].slot.state.load(std::memory_order_relaxed);
    if (expected == SlotState::FREE || expected == SlotState::RECYCLE)
    {
      if (slots_[index].slot.state.compare_exchange_strong(expected, SlotState::BUSY,
                                                           std::memory_order_release,
                                                           std::memory_order_relaxed))
      {
        slots_[index].slot.data = data;
        slots_[index].slot.state.store(SlotState::READY, std::memory_order_release);
        return ErrorCode::OK;
      }
    }
    return ErrorCode::FULL;
  }

◆ RecycleSlot()

template<typename Data >

ErrorCode LibXR::LockFreePool< Data >::RecycleSlot ( uint32_t index )

inline

回收指定槽位 / Recycle a slot

Parameters

index 槽索引 / Slot index

Returns

ErrorCode 操作结果 / Operation result:

ErrorCode::OK：成功回收 / Successfully recycled
ErrorCode::EMPTY：池空，无可回收元素 / Pool empty, no available element

Definition at line 229 of file lockfree_pool.hpp.

  {
    auto expected = slots_[index].slot.state.load(std::memory_order_relaxed);
    if (expected == SlotState::READY)
    {
      if (slots_[index].slot.state.compare_exchange_strong(expected, SlotState::RECYCLE,
                                                           std::memory_order_release,
                                                           std::memory_order_relaxed))
      {
        return ErrorCode::OK;
      }
    }
    return ErrorCode::EMPTY;
  }

◆ Size()

template<typename Data >

size_t LibXR::LockFreePool< Data >::Size ( ) const

inlinenodiscard

查询池中可取元素数量 / Query the number of available elements in the pool

Returns: 当前池中READY元素个数 / Number of ready elements in pool

Definition at line 248 of file lockfree_pool.hpp.

  {
    uint32_t size = 0;
    for (uint32_t index = 0; index < SLOT_COUNT; index++)
    {
      if (slots_[index].slot.state.load(std::memory_order_relaxed) == SlotState::READY)
      {
        size++;
      }
    }
    return size;
  }

◆ SlotCount()

template<typename Data >

uint32_t LibXR::LockFreePool< Data >::SlotCount ( ) const

inline

获取槽总数 / Get the total number of slots in the pool

Returns: uint32_t 槽总数

Definition at line 284 of file lockfree_pool.hpp.

284{ return SLOT_COUNT; }

Field Documentation

◆ SLOT_COUNT

template<typename Data >

const uint32_t LibXR::LockFreePool< Data >::SLOT_COUNT

private

槽总数 / Number of slots

Definition at line 297 of file lockfree_pool.hpp.

◆ slots_

template<typename Data >

Slot* LibXR::LockFreePool< Data >::slots_

private

槽数组指针 / Array of slots

Definition at line 298 of file lockfree_pool.hpp.

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

src/structure/lockfree_pool.hpp

Data Structures

Public Types

Public Member Functions

Protected Member Functions

Private Attributes

Detailed Description

Member Enumeration Documentation

◆ SlotState

Constructor & Destructor Documentation

◆ LockFreePool()

◆ ~LockFreePool()

Member Function Documentation

◆ EmptySize()

◆ Get() [1/2]

◆ Get() [2/2]

◆ GetFromSlot()

◆ operator[]()

◆ Put() [1/2]

◆ Put() [2/2]

◆ PutToSlot()

◆ RecycleSlot()

◆ Size()

◆ SlotCount()

Field Documentation

◆ SLOT_COUNT

◆ slots_