kcenon::monitoring::memory_pool Class Reference

Thread-safe fixed-size block memory allocator. More...

#include <memory_pool.h>

Collaboration diagram for kcenon::monitoring::memory_pool:

Public Member Functions
	memory_pool ()
	Default constructor with default configuration.
	memory_pool (const memory_pool_config &config)
	Construct with configuration.
	~memory_pool ()
	memory_pool (const memory_pool &)=delete
memory_pool &	operator= (const memory_pool &)=delete
	memory_pool (memory_pool &&other) noexcept
memory_pool &	operator= (memory_pool &&other) noexcept
common::Result< void * >	allocate ()
	Allocate a memory block.
common::VoidResult	deallocate (void *ptr)
	Deallocate a memory block.
template<typename T , typename... Args>
common::Result< T * >	allocate_object (Args &&... args)
	Allocate and construct an object.
template<typename T >
common::VoidResult	deallocate_object (T *obj)
	Destroy and deallocate an object.
size_t	available_blocks () const
	Get number of available blocks.
size_t	total_blocks () const
	Get total number of blocks.
size_t	block_size () const
	Get block size.
const memory_pool_statistics &	get_statistics () const
	Get pool statistics.
void	reset_statistics ()
	Reset statistics.

Private Member Functions
void	initialize_pool ()
bool	grow_pool ()
bool	is_owned_block (void *ptr) const
void	update_peak_usage ()

Private Attributes
memory_pool_config	config_
size_t	block_size_
size_t	total_blocks_
std::vector< void * >	free_blocks_
std::vector< void * >	memory_chunks_
std::mutex	mutex_
memory_pool_statistics	stats_

Detailed Description

Thread-safe fixed-size block memory allocator.

This pool pre-allocates memory blocks of fixed size for efficient allocation/deallocation without heap fragmentation.

Definition at line 171 of file memory_pool.h.

Constructor & Destructor Documentation

memory_pool() [1/4]

kcenon::monitoring::memory_pool::memory_pool ( )

inline

Default constructor with default configuration.

Definition at line 176 of file memory_pool.h.

: memory_pool(memory_pool_config{}) {}

memory_pool() [2/4]

kcenon::monitoring::memory_pool::memory_pool ( const memory_pool_config & config )

inlineexplicit

Construct with configuration.

Parameters

config

Pool configuration

Definition at line 182 of file memory_pool.h.

        : config_(config)
        , block_size_(config.block_size)
        , total_blocks_(config.initial_blocks) {
        initialize_pool();
    }

References initialize_pool().

Here is the call graph for this function:

~memory_pool()

kcenon::monitoring::memory_pool::~memory_pool ( )

inline

Definition at line 189 of file memory_pool.h.

                   {
        for (auto* chunk : memory_chunks_) {
            detail::aligned_free_impl(chunk);
        }
    }

References detail::aligned_free_impl(), and memory_chunks_.

Here is the call graph for this function:

memory_pool() [3/4]

kcenon::monitoring::memory_pool::memory_pool ( const memory_pool & )

delete

memory_pool() [4/4]

kcenon::monitoring::memory_pool::memory_pool ( memory_pool && other )

inlinenoexcept

Definition at line 200 of file memory_pool.h.

        : config_(other.config_)
        , block_size_(other.block_size_)
        , total_blocks_(other.total_blocks_)
        , free_blocks_(std::move(other.free_blocks_))
        , memory_chunks_(std::move(other.memory_chunks_))
        , stats_(std::move(other.stats_)) {
        other.total_blocks_ = 0;
    }

References kcenon::monitoring::other.

Member Function Documentation

allocate()

common::Result< void * > kcenon::monitoring::memory_pool::allocate ( )

inline

Allocate a memory block.

Returns

common::Result<void*> containing pointer to allocated block

Definition at line 230 of file memory_pool.h.

                                   {
        std::lock_guard<std::mutex> lock(mutex_);
 
        if (free_blocks_.empty()) {
            // Try to grow the pool
            if (!grow_pool()) {
                stats_.allocation_failures++;
                return common::Result<void*>::err(error_info(monitoring_error_code::resource_unavailable, "Memory pool exhausted").to_common_error());
            }
        }
 
        void* block = free_blocks_.back();
        free_blocks_.pop_back();
 
        stats_.total_allocations++;
        update_peak_usage();
 
        return common::ok(block);
    }

References kcenon::monitoring::memory_pool_statistics::allocation_failures, free_blocks_, grow_pool(), mutex_, kcenon::monitoring::resource_unavailable, stats_, kcenon::monitoring::memory_pool_statistics::total_allocations, and update_peak_usage().

Referenced by allocate_object(), TEST_F(), TEST_F(), and TEST_F().

Here is the call graph for this function:

Here is the caller graph for this function:

allocate_object()

template<typename T , typename... Args>

common::Result< T * > kcenon::monitoring::memory_pool::allocate_object ( Args &&... args )

inline

Allocate and construct an object.

Template Parameters

T	The object type
Args	Constructor argument types

Parameters

args	Constructor arguments

Returns

common::Result<T*> containing pointer to constructed object

Definition at line 281 of file memory_pool.h.

                                                     {
        if (sizeof(T) > block_size_) {
            return common::Result<T*>::err(error_info(monitoring_error_code::invalid_argument, "Object size exceeds block size").to_common_error());
        }
 
        auto result = allocate();
        if (result.is_err()) {
            return common::Result<T*>::err(error_info(monitoring_error_code::resource_unavailable, "Failed to allocate memory for object").to_common_error());
        }
 
        void* ptr = result.value();
        T* obj = new (ptr) T(std::forward<Args>(args)...);
 
        return common::ok(obj);
    }

References allocate(), block_size_, kcenon::monitoring::invalid_argument, and kcenon::monitoring::resource_unavailable.

Referenced by TEST_F(), and TEST_F().

Here is the call graph for this function:

Here is the caller graph for this function:

available_blocks()

size_t kcenon::monitoring::memory_pool::available_blocks ( ) const

inline

Get number of available blocks.

Returns

Number of free blocks

Definition at line 317 of file memory_pool.h.

                                    {
        std::lock_guard<std::mutex> lock(mutex_);
        return free_blocks_.size();
    }

References free_blocks_, and mutex_.

Referenced by TEST_F(), and TEST_F().

Here is the caller graph for this function:

block_size()

size_t kcenon::monitoring::memory_pool::block_size ( ) const

inline

Get block size.

Returns

Size of each block in bytes

Definition at line 334 of file memory_pool.h.

                              {
        return block_size_;
    }

References block_size_.

deallocate()

common::VoidResult kcenon::monitoring::memory_pool::deallocate ( void * ptr )

inline

Deallocate a memory block.

Parameters

ptr	Pointer to the block to deallocate

Returns

common::VoidResult indicating success or error

Definition at line 255 of file memory_pool.h.

                                           {
        if (ptr == nullptr) {
            return common::VoidResult::err(error_info(monitoring_error_code::invalid_argument, "Cannot deallocate null pointer").to_common_error());
        }
 
        std::lock_guard<std::mutex> lock(mutex_);
 
        // Verify the pointer belongs to this pool
        if (!is_owned_block(ptr)) {
            return common::VoidResult::err(error_info(monitoring_error_code::invalid_argument, "Pointer does not belong to this pool").to_common_error());
        }
 
        free_blocks_.push_back(ptr);
        stats_.total_deallocations++;
 
        return common::ok();
    }

References free_blocks_, kcenon::monitoring::invalid_argument, is_owned_block(), mutex_, stats_, and kcenon::monitoring::memory_pool_statistics::total_deallocations.

Referenced by deallocate_object(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), and TEST_F().

Here is the call graph for this function:

Here is the caller graph for this function:

deallocate_object()

template<typename T >

common::VoidResult kcenon::monitoring::memory_pool::deallocate_object ( T * obj )

inline

Destroy and deallocate an object.

Template Parameters

T	The object type

Parameters

obj	Pointer to the object

Returns

common::VoidResult indicating success or error

Definition at line 304 of file memory_pool.h.

                                               {
        if (obj == nullptr) {
            return common::VoidResult::err(error_info(monitoring_error_code::invalid_argument, "Cannot deallocate null object").to_common_error());
        }
 
        obj->~T();
        return deallocate(static_cast<void*>(obj));
    }

References deallocate(), and kcenon::monitoring::invalid_argument.

Referenced by TEST_F().

Here is the call graph for this function:

Here is the caller graph for this function:

get_statistics()

const memory_pool_statistics & kcenon::monitoring::memory_pool::get_statistics ( ) const

inline

Get pool statistics.

Returns

Reference to statistics

Definition at line 342 of file memory_pool.h.

                                                         {
        return stats_;
    }

References stats_.

Referenced by TEST_F(), TEST_F(), and TEST_F().

Here is the caller graph for this function:

grow_pool()

bool kcenon::monitoring::memory_pool::grow_pool ( )

inlineprivate

Definition at line 372 of file memory_pool.h.

                     {
        if (config_.max_blocks > 0 && total_blocks_ >= config_.max_blocks) {
            return false;
        }
 
        size_t new_blocks = std::min(total_blocks_, config_.max_blocks - total_blocks_);
        if (new_blocks == 0) {
            new_blocks = total_blocks_;  // Double the size
        }
 
        size_t chunk_size = new_blocks * block_size_;
        void* chunk = detail::aligned_alloc_impl(config_.alignment, chunk_size);
 
        if (chunk == nullptr) {
            return false;
        }
 
        memory_chunks_.push_back(chunk);
 
        char* ptr = static_cast<char*>(chunk);
        for (size_t i = 0; i < new_blocks; ++i) {
            free_blocks_.push_back(ptr + i * block_size_);
        }
 
        total_blocks_ += new_blocks;
        return true;
    }

References detail::aligned_alloc_impl(), kcenon::monitoring::memory_pool_config::alignment, block_size_, config_, free_blocks_, kcenon::monitoring::memory_pool_config::max_blocks, memory_chunks_, and total_blocks_.

Referenced by allocate().

Here is the call graph for this function:

Here is the caller graph for this function:

initialize_pool()

void kcenon::monitoring::memory_pool::initialize_pool ( )

inlineprivate

Definition at line 354 of file memory_pool.h.

                           {
        size_t chunk_size = total_blocks_ * block_size_;
        void* chunk = detail::aligned_alloc_impl(config_.alignment, chunk_size);
 
        if (chunk == nullptr) {
            throw std::bad_alloc();
        }
 
        memory_chunks_.push_back(chunk);
 
        // Initialize free block list
        free_blocks_.reserve(total_blocks_);
        char* ptr = static_cast<char*>(chunk);
        for (size_t i = 0; i < total_blocks_; ++i) {
            free_blocks_.push_back(ptr + i * block_size_);
        }
    }

References detail::aligned_alloc_impl(), kcenon::monitoring::memory_pool_config::alignment, block_size_, config_, free_blocks_, memory_chunks_, and total_blocks_.

Referenced by memory_pool().

Here is the call graph for this function:

Here is the caller graph for this function:

is_owned_block()

bool kcenon::monitoring::memory_pool::is_owned_block ( void * ptr ) const

inlineprivate

Definition at line 400 of file memory_pool.h.

                                         {
        for (size_t i = 0; i < memory_chunks_.size(); ++i) {
            char* chunk_start = static_cast<char*>(memory_chunks_[i]);
            size_t chunk_blocks = (i == 0) ? config_.initial_blocks :
                                  ((total_blocks_ - config_.initial_blocks) / (memory_chunks_.size() - 1));
            char* chunk_end = chunk_start + chunk_blocks * block_size_;
 
            if (ptr >= chunk_start && ptr < chunk_end) {
                // Verify alignment
                size_t offset = static_cast<char*>(ptr) - chunk_start;
                if (offset % block_size_ == 0) {
                    return true;
                }
            }
        }
        return false;
    }

References block_size_, config_, kcenon::monitoring::memory_pool_config::initial_blocks, memory_chunks_, and total_blocks_.

Referenced by deallocate().

Here is the caller graph for this function:

operator=() [1/2]

memory_pool & kcenon::monitoring::memory_pool::operator= ( const memory_pool & )

delete

operator=() [2/2]

memory_pool & kcenon::monitoring::memory_pool::operator= ( memory_pool && other )

inlinenoexcept

Definition at line 210 of file memory_pool.h.

                                                         {
        if (this != &other) {
            for (auto* chunk : memory_chunks_) {
                detail::aligned_free_impl(chunk);
            }
            config_ = other.config_;
            block_size_ = other.block_size_;
            total_blocks_ = other.total_blocks_;
            free_blocks_ = std::move(other.free_blocks_);
            memory_chunks_ = std::move(other.memory_chunks_);
            stats_ = std::move(other.stats_);
            other.total_blocks_ = 0;
        }
        return *this;
    }

References detail::aligned_free_impl(), block_size_, config_, free_blocks_, memory_chunks_, kcenon::monitoring::other, stats_, and total_blocks_.

Here is the call graph for this function:

reset_statistics()

void kcenon::monitoring::memory_pool::reset_statistics ( )

inline

Reset statistics.

Definition at line 349 of file memory_pool.h.

                            {
        stats_.reset();
    }

References kcenon::monitoring::memory_pool_statistics::reset(), and stats_.

Here is the call graph for this function:

total_blocks()

size_t kcenon::monitoring::memory_pool::total_blocks ( ) const

inline

Get total number of blocks.

Returns

Total block count

Definition at line 326 of file memory_pool.h.

                                {
        return total_blocks_;
    }

References total_blocks_.

Referenced by TEST_F().

Here is the caller graph for this function:

update_peak_usage()

void kcenon::monitoring::memory_pool::update_peak_usage ( )

inlineprivate

Definition at line 418 of file memory_pool.h.

                             {
        size_t current_usage = total_blocks_ - free_blocks_.size();
        size_t peak = stats_.peak_usage.load();
        while (current_usage > peak) {
            if (stats_.peak_usage.compare_exchange_weak(peak, current_usage)) {
                break;
            }
        }
    }

References free_blocks_, kcenon::monitoring::memory_pool_statistics::peak_usage, stats_, and total_blocks_.

Referenced by allocate().

Here is the caller graph for this function:

Member Data Documentation

block_size_

size_t kcenon::monitoring::memory_pool::block_size_

private

Definition at line 429 of file memory_pool.h.

Referenced by allocate_object(), block_size(), grow_pool(), initialize_pool(), is_owned_block(), and operator=().

config_

memory_pool_config kcenon::monitoring::memory_pool::config_

private

Definition at line 428 of file memory_pool.h.

Referenced by grow_pool(), initialize_pool(), is_owned_block(), and operator=().

free_blocks_

std::vector<void*> kcenon::monitoring::memory_pool::free_blocks_

private

Definition at line 431 of file memory_pool.h.

Referenced by allocate(), available_blocks(), deallocate(), grow_pool(), initialize_pool(), operator=(), and update_peak_usage().

memory_chunks_

std::vector<void*> kcenon::monitoring::memory_pool::memory_chunks_

private

Definition at line 432 of file memory_pool.h.

Referenced by grow_pool(), initialize_pool(), is_owned_block(), operator=(), and ~memory_pool().

mutex_

std::mutex kcenon::monitoring::memory_pool::mutex_

mutableprivate

Definition at line 433 of file memory_pool.h.

Referenced by allocate(), available_blocks(), and deallocate().

stats_

memory_pool_statistics kcenon::monitoring::memory_pool::stats_

mutableprivate

Definition at line 434 of file memory_pool.h.

Referenced by allocate(), deallocate(), get_statistics(), operator=(), reset_statistics(), and update_peak_usage().

total_blocks_

size_t kcenon::monitoring::memory_pool::total_blocks_

private

Definition at line 430 of file memory_pool.h.

Referenced by grow_pool(), initialize_pool(), is_owned_block(), operator=(), total_blocks(), and update_peak_usage().

---

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

• include/kcenon/monitoring/optimization/memory_pool.h