kcenon::network::utils::buffer_pool::impl Class Reference

Collaboration diagram for kcenon::network::utils::buffer_pool::impl:

Public Member Functions
	impl (size_t pool_size, size_t default_capacity)
auto	acquire (size_t min_capacity, buffer_pool *parent) -> std::shared_ptr< std::vector< uint8_t > >
auto	release (std::vector< uint8_t > *buffer) -> void
auto	get_stats () const -> std::pair< size_t, size_t >
auto	clear () -> void

Private Attributes
size_t	pool_size_
size_t	default_capacity_
std::atomic< size_t >	total_allocated_
std::mutex	mutex_
std::deque< std::unique_ptr< std::vector< uint8_t > > >	available_buffers_

Detailed Description

Definition at line 15 of file buffer_pool.cpp.

Constructor & Destructor Documentation

impl()

kcenon::network::utils::buffer_pool::impl::impl ( size_t pool_size, size_t default_capacity )

inlineexplicit

Definition at line 18 of file buffer_pool.cpp.

            : pool_size_(pool_size), default_capacity_(default_capacity), total_allocated_(0)
        {
            NETWORK_LOG_DEBUG("[buffer_pool] Created with pool_size=" +
                              std::to_string(pool_size) +
                              ", default_capacity=" + std::to_string(default_capacity));
        }

References NETWORK_LOG_DEBUG.

Member Function Documentation

acquire()

auto kcenon::network::utils::buffer_pool::impl::acquire ( size_t min_capacity, buffer_pool * parent ) -> std::shared_ptr<std::vector<uint8_t>>

inline

Definition at line 26 of file buffer_pool.cpp.

        {
            std::unique_lock<std::mutex> lock(mutex_);
 
            // Try to find a suitable buffer in the pool
            for (auto it = available_buffers_.begin(); it != available_buffers_.end(); ++it)
            {
                if ((*it)->capacity() >= min_capacity)
                {
                    auto buffer = std::move(*it);
                    available_buffers_.erase(it);
 
                    // Clear the buffer but keep capacity
                    buffer->clear();
 
                    NETWORK_LOG_TRACE("[buffer_pool] Acquired buffer from pool, capacity=" +
                                      std::to_string(buffer->capacity()));
 
                    // Return with custom deleter that returns buffer to pool
                    return std::shared_ptr<std::vector<uint8_t>>(
                        buffer.release(), [parent](std::vector<uint8_t>* buf) {
                            if (parent)
                            {
                                parent->release(buf);
                            }
                            else
                            {
                                delete buf;
                            }
                        });
                }
            }
 
            // No suitable buffer found, create a new one
            size_t capacity = std::max(min_capacity, default_capacity_);
            auto buffer = std::make_unique<std::vector<uint8_t>>();
            buffer->reserve(capacity);
 
            total_allocated_.fetch_add(1);
 
            NETWORK_LOG_TRACE("[buffer_pool] Created new buffer, capacity=" +
                              std::to_string(capacity) +
                              ", total_allocated=" + std::to_string(total_allocated_.load()));
 
            // Return with custom deleter
            return std::shared_ptr<std::vector<uint8_t>>(
                buffer.release(), [parent](std::vector<uint8_t>* buf) {
                    if (parent)
                    {
                        parent->release(buf);
                    }
                    else
                    {
                        delete buf;
                    }
                });
        }

References available_buffers_, default_capacity_, mutex_, NETWORK_LOG_TRACE, and total_allocated_.

clear()

auto kcenon::network::utils::buffer_pool::impl::clear ( ) -> void

inline

Definition at line 113 of file buffer_pool.cpp.

        {
            std::unique_lock<std::mutex> lock(mutex_);
 
            size_t cleared = available_buffers_.size();
            available_buffers_.clear();
 
            total_allocated_.fetch_sub(cleared);
 
            NETWORK_LOG_INFO("[buffer_pool] Cleared " + std::to_string(cleared) + " buffers");
        }

References available_buffers_, mutex_, NETWORK_LOG_INFO, and total_allocated_.

Referenced by kcenon::network::utils::buffer_pool::~buffer_pool().

Here is the caller graph for this function:

get_stats()

auto kcenon::network::utils::buffer_pool::impl::get_stats ( ) const -> std::pair<size_t, size_t>

inline

Definition at line 107 of file buffer_pool.cpp.

        {
            std::lock_guard<std::mutex> lock(mutex_);
            return {available_buffers_.size(), total_allocated_.load()};
        }

References available_buffers_, mutex_, and total_allocated_.

Referenced by kcenon::network::utils::buffer_pool::get_stats().

Here is the caller graph for this function:

release()

auto kcenon::network::utils::buffer_pool::impl::release ( std::vector< uint8_t > * buffer ) -> void

inline

Definition at line 84 of file buffer_pool.cpp.

        {
            if (!buffer)
                return;
 
            std::unique_lock<std::mutex> lock(mutex_);
 
            // If pool is full, just delete the buffer
            if (available_buffers_.size() >= pool_size_)
            {
                NETWORK_LOG_TRACE("[buffer_pool] Pool full, deleting buffer");
                delete buffer;
                total_allocated_.fetch_sub(1);
                return;
            }
 
            // Return buffer to pool
            available_buffers_.emplace_back(buffer);
 
            NETWORK_LOG_TRACE("[buffer_pool] Returned buffer to pool, available=" +
                              std::to_string(available_buffers_.size()));
        }

References available_buffers_, mutex_, NETWORK_LOG_TRACE, pool_size_, and total_allocated_.

Member Data Documentation

available_buffers_

std::deque<std::unique_ptr<std::vector<uint8_t> > > kcenon::network::utils::buffer_pool::impl::available_buffers_

private

Definition at line 131 of file buffer_pool.cpp.

Referenced by acquire(), clear(), get_stats(), and release().

default_capacity_

size_t kcenon::network::utils::buffer_pool::impl::default_capacity_

private

Definition at line 127 of file buffer_pool.cpp.

Referenced by acquire().

mutex_

std::mutex kcenon::network::utils::buffer_pool::impl::mutex_

mutableprivate

Definition at line 130 of file buffer_pool.cpp.

Referenced by acquire(), clear(), get_stats(), and release().

pool_size_

size_t kcenon::network::utils::buffer_pool::impl::pool_size_

private

Definition at line 126 of file buffer_pool.cpp.

Referenced by release().

total_allocated_

std::atomic<size_t> kcenon::network::utils::buffer_pool::impl::total_allocated_

private

Definition at line 128 of file buffer_pool.cpp.

Referenced by acquire(), clear(), get_stats(), and release().

---

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

• src/internal/utils/buffer_pool.cpp