#include <memory_pool.h>

Collaboration diagram for kcenon::container::internal::fixed_block_pool:

Classes
struct	statistics
	Statistics for monitoring memory pool usage. More...

Public Member Functions
	fixed_block_pool (std::size_t block_size, std::size_t blocks_per_chunk=1024)

	~fixed_block_pool ()=default

void *	allocate ()

void	deallocate (void *p)

std::size_t	block_size () const noexcept

statistics	get_statistics () const
	Get current pool statistics.

Private Member Functions
void	allocate_chunk_unlocked ()

Private Attributes
std::size_t	block_size_

std::size_t	blocks_per_chunk_

std::vector< std::unique_ptr< std::uint8_t[]> >	chunks_

void *	free_list_ {nullptr}

std::mutex	mutex_

std::size_t	allocated_count_ {0}

Detailed Description

Definition at line 21 of file memory_pool.h.

Constructor & Destructor Documentation

◆ fixed_block_pool()

kcenon::container::internal::fixed_block_pool::fixed_block_pool	(	std::size_t	block_size,
		std::size_t	blocks_per_chunk = 1024 )

inlineexplicit

Definition at line 23 of file memory_pool.h.

25 : block_size_(block_size < sizeof(void*) ? sizeof(void*) : block_size)

26 , blocks_per_chunk_(blocks_per_chunk) {}

kcenon::container::internal::fixed_block_pool::block_size_

std::size_t block_size_

Definition memory_pool.h:140

kcenon::container::internal::fixed_block_pool::block_size

std::size_t block_size() const noexcept

Definition memory_pool.h:76

kcenon::container::internal::fixed_block_pool::blocks_per_chunk_

std::size_t blocks_per_chunk_

Definition memory_pool.h:141

◆ ~fixed_block_pool()

kcenon::container::internal::fixed_block_pool::~fixed_block_pool ( )

default

Member Function Documentation

◆ allocate()

void * kcenon::container::internal::fixed_block_pool::allocate ( )

inline

Definition at line 30 of file memory_pool.h.

                     {
        std::lock_guard<std::mutex> lock(mutex_);
        if (!free_list_) {
            try {
                allocate_chunk_unlocked();
            } catch (const std::bad_alloc&) {
                // Chunk allocation failed, propagate the exception
                throw;
            }
            // Verify that allocate_chunk_unlocked() actually created free blocks
            if (!free_list_) {
                throw std::runtime_error("Memory pool chunk allocation failed to create free list");
            }
        }
        void* p = free_list_;
        free_list_ = *reinterpret_cast<void**>(free_list_);
        ++allocated_count_;
        return p;
    }

References allocate_chunk_unlocked(), allocated_count_, free_list_, and mutex_.

Referenced by kcenon::container::internal::pool_allocator::allocate().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ allocate_chunk_unlocked()

void kcenon::container::internal::fixed_block_pool::allocate_chunk_unlocked ( )

inlineprivate

Definition at line 127 of file memory_pool.h.

                                   {
        std::unique_ptr<std::uint8_t[]> chunk(new std::uint8_t[block_size_ * blocks_per_chunk_]);
        std::uint8_t* base = chunk.get();
        chunks_.push_back(std::move(chunk));
        // Build free list
        for (std::size_t i = 0; i < blocks_per_chunk_; ++i) {
            void* p = base + i * block_size_;
            *reinterpret_cast<void**>(p) = free_list_;
            free_list_ = p;
        }
    }

References block_size_, blocks_per_chunk_, chunks_, and free_list_.

Referenced by allocate().

Here is the caller graph for this function:

◆ block_size()

std::size_t kcenon::container::internal::fixed_block_pool::block_size ( ) const

inlinenoexcept

Definition at line 76 of file memory_pool.h.

76{ return block_size_; }

References block_size_.

◆ deallocate()

void kcenon::container::internal::fixed_block_pool::deallocate ( void * p )

inline

Definition at line 50 of file memory_pool.h.

                             {
        if (!p) return;
        std::lock_guard<std::mutex> lock(mutex_);
 
        // Validate pointer belongs to one of our pool chunks.
        // This lightweight range check runs in all build modes to
        // prevent free-list corruption from invalid deallocations.
        bool found = false;
        for (const auto& chunk : chunks_) {
            std::uint8_t* chunk_start = chunk.get();
            std::uint8_t* chunk_end = chunk_start + (block_size_ * blocks_per_chunk_);
            if (reinterpret_cast<std::uint8_t*>(p) >= chunk_start &&
                reinterpret_cast<std::uint8_t*>(p) < chunk_end) {
                found = true;
                break;
            }
        }
        if (!found) {
            return;
        }
 
        *reinterpret_cast<void**>(p) = free_list_;
        free_list_ = p;
        --allocated_count_;
    }

References allocated_count_, block_size_, blocks_per_chunk_, chunks_, free_list_, and mutex_.

Referenced by kcenon::container::internal::pool_allocator::deallocate().

Here is the caller graph for this function:

◆ get_statistics()

statistics kcenon::container::internal::fixed_block_pool::get_statistics ( ) const

inline

Get current pool statistics.

Note: This method is thread-safe but may impact performance if called frequently

Definition at line 105 of file memory_pool.h.

                                      {
        std::lock_guard<std::mutex> lock(mutex_);
 
        // Count free blocks in the free list
        std::size_t free_count = 0;
        void* current = free_list_;
        while (current) {
            ++free_count;
            current = *reinterpret_cast<void**>(current);
        }
 
        std::size_t total_capacity = chunks_.size() * blocks_per_chunk_;
 
        return statistics{
            chunks_.size(),
            allocated_count_,
            total_capacity,
            free_count
        };
    }