object_pool.h

Go to the documentation of this file.

// BSD 3-Clause License
// Copyright (c) 2021-2025, 🍀☀🌕🌥 🌊
// See the LICENSE file in the project root for full license information.
 
#pragma once
 
#include <kcenon/logger/core/error_codes.h>
#include <memory>
#include <vector>
#include <mutex>
#include <atomic>
#include <queue>
 
namespace kcenon::logger::memory {
 
template<typename T>
class object_pool {
public:
    struct config {
        size_t initial_size{100};        
        size_t max_size{10000};          
        bool allow_growth{true};         
 
        config() = default;
    };
 
    explicit object_pool(const config& cfg = config{})
        : config_(cfg), pool_size_(0) {
        initialize_pool();
    }
 
    ~object_pool() = default;
 
    std::unique_ptr<T> acquire() {
        std::lock_guard<std::mutex> lock(mutex_);
 
        if (!available_objects_.empty()) {
            auto obj = std::move(available_objects_.front());
            available_objects_.pop();
            return obj;
        }
 
        // If pool is empty and growth is allowed, create new object
        if (config_.allow_growth && pool_size_.load() < config_.max_size) {
            pool_size_.fetch_add(1);
            return std::make_unique<T>();
        }
 
        // Create temporary object if pool limits reached
        return std::make_unique<T>();
    }
 
    void release(std::unique_ptr<T> obj) {
        if (!obj) {
            return;
        }
 
        std::lock_guard<std::mutex> lock(mutex_);
 
        // Only return to pool if not exceeding max size
        if (available_objects_.size() < config_.max_size) {
            available_objects_.push(std::move(obj));
        }
        // If exceeding max size, object will be destroyed automatically
    }
 
    struct statistics {
        size_t total_size;
        size_t available_count;
        size_t in_use_count;
    };
 
    statistics get_statistics() const {
        std::lock_guard<std::mutex> lock(mutex_);
        statistics stats;
        stats.total_size = pool_size_.load();
        stats.available_count = available_objects_.size();
        stats.in_use_count = pool_size_.load() - available_objects_.size();
        return stats;
    }
 
    void clear() {
        std::lock_guard<std::mutex> lock(mutex_);
        while (!available_objects_.empty()) {
            available_objects_.pop();
        }
        pool_size_.store(0);
    }
 
private:
    void initialize_pool() {
        std::lock_guard<std::mutex> lock(mutex_);
 
        for (size_t i = 0; i < config_.initial_size; ++i) {
            available_objects_.push(std::make_unique<T>());
        }
 
        pool_size_.store(config_.initial_size);
    }
 
    config config_;                                    
    mutable std::mutex mutex_;                         
    std::queue<std::unique_ptr<T>> available_objects_; 
    std::atomic<size_t> pool_size_;                    
};
 
template<typename T>
class thread_local_object_pool {
public:
    struct config {
        size_t global_max{10000};        
        size_t local_cache_size{16};     
        size_t initial_size{100};        
        bool allow_growth{true};         
 
        config() = default;
    };
 
    explicit thread_local_object_pool(const config& cfg = config{})
        : config_(cfg)
        , global_size_(0) {
        initialize_pool();
    }
 
    ~thread_local_object_pool() = default;
 
    std::unique_ptr<T> acquire() {
        // Step 1: Check thread-local cache first (no lock!)
        auto& local_cache = get_local_cache();
 
        if (!local_cache.empty()) {
            local_cache_hits_.fetch_add(1, std::memory_order_relaxed);
            auto obj = std::move(local_cache.back());
            local_cache.pop_back();
            return obj;
        }
 
        // Step 2: Fetch batch from global pool (lock once)
        {
            std::lock_guard<std::mutex> lock(global_mutex_);
 
            // Batch size: half of local cache size
            size_t batch_size = std::min(
                config_.local_cache_size / 2,
                global_pool_.size()
            );
 
            for (size_t i = 0; i < batch_size; ++i) {
                if (!global_pool_.empty()) {
                    local_cache.push_back(std::move(global_pool_.back()));
                    global_pool_.pop_back();
                }
            }
        }
 
        // Step 3: Try local cache again after batch fetch
        if (!local_cache.empty()) {
            global_pool_hits_.fetch_add(1, std::memory_order_relaxed);
            auto obj = std::move(local_cache.back());
            local_cache.pop_back();
            return obj;
        }
 
        // Step 4: Create new object if pool is empty
        if (config_.allow_growth && global_size_.load(std::memory_order_relaxed) < config_.global_max) {
            global_size_.fetch_add(1, std::memory_order_relaxed);
            new_allocations_.fetch_add(1, std::memory_order_relaxed);
            return std::make_unique<T>();
        }
 
        // Fallback: create temporary object even if limit reached
        // (same behavior as original object_pool)
        return std::make_unique<T>();
    }
 
    void release(std::unique_ptr<T> obj) {
        if (!obj) {
            return;
        }
 
        // Step 1: Add to thread-local cache (no lock!)
        auto& local_cache = get_local_cache();
 
        if (local_cache.size() < config_.local_cache_size) {
            local_cache.push_back(std::move(obj));
            return;
        }
 
        // Step 2: Transfer batch to global pool when local cache is full
        {
            std::lock_guard<std::mutex> lock(global_mutex_);
 
            // Move half of local cache to global
            size_t transfer_count = config_.local_cache_size / 2;
 
            for (size_t i = 0; i < transfer_count && !local_cache.empty(); ++i) {
                if (global_pool_.size() < config_.global_max) {
                    global_pool_.push_back(std::move(local_cache.back()));
                    local_cache.pop_back();
                }
            }
 
            // Add current object to global pool
            if (global_pool_.size() < config_.global_max) {
                global_pool_.push_back(std::move(obj));
            }
            // If exceeding max, object will be destroyed automatically
        }
    }
 
    struct statistics {
        size_t global_size;         
        size_t global_pool_size;    
        size_t local_cache_hits;    
        size_t global_pool_hits;    
        size_t new_allocations;     
    };
 
    statistics get_statistics() const {
        std::lock_guard<std::mutex> lock(global_mutex_);
        statistics stats;
        stats.global_size = global_size_.load(std::memory_order_relaxed);
        stats.global_pool_size = global_pool_.size();
        stats.local_cache_hits = local_cache_hits_.load(std::memory_order_relaxed);
        stats.global_pool_hits = global_pool_hits_.load(std::memory_order_relaxed);
        stats.new_allocations = new_allocations_.load(std::memory_order_relaxed);
        return stats;
    }
 
    void clear() {
        std::lock_guard<std::mutex> lock(global_mutex_);
        global_pool_.clear();
        global_size_.store(0, std::memory_order_relaxed);
        local_cache_hits_.store(0, std::memory_order_relaxed);
        global_pool_hits_.store(0, std::memory_order_relaxed);
        new_allocations_.store(0, std::memory_order_relaxed);
    }
 
private:
    static std::vector<std::unique_ptr<T>>& get_local_cache() {
        thread_local std::vector<std::unique_ptr<T>> cache;
        return cache;
    }
 
    void initialize_pool() {
        std::lock_guard<std::mutex> lock(global_mutex_);
 
        for (size_t i = 0; i < config_.initial_size; ++i) {
            global_pool_.push_back(std::make_unique<T>());
        }
 
        global_size_.store(config_.initial_size, std::memory_order_relaxed);
    }
 
    // Configuration
    config config_;
 
    // Global pool
    std::vector<std::unique_ptr<T>> global_pool_;
    mutable std::mutex global_mutex_;
 
    // Statistics (atomic for lock-free reads)
    std::atomic<size_t> global_size_{0};
    std::atomic<size_t> local_cache_hits_{0};
    std::atomic<size_t> global_pool_hits_{0};
    std::atomic<size_t> new_allocations_{0};
};
 
} // namespace kcenon::logger::memory