object_pool.h

Go to the documentation of this file.

// BSD 3-Clause License
// Copyright (c) 2025, 🍀☀🌕🌥 🌊
// See the LICENSE file in the project root for full license information.
 
#pragma once
 
#include <cstddef>
#include <memory>
#include <mutex>
#include <stack>
#include <utility>
#include <new>
#include <vector>
 
namespace kcenon::common::utils {
 
namespace detail {
template<typename T>
struct RawDelete {
    void operator()(T* ptr) const noexcept {
        ::operator delete(static_cast<void*>(ptr));
    }
};
} // namespace detail
 
template<typename T>
class ObjectPool;
 
template<typename T>
struct PoolDeleter {
    ObjectPool<T>* pool = nullptr;
    void operator()(T* ptr) const noexcept {
        if (pool) {
            pool->release(ptr);
        }
    }
};
 
template<typename T>
class ObjectPool {
public:
    using value_type = T;
    using deleter_type = PoolDeleter<T>;
    using pointer_type = std::unique_ptr<T, deleter_type>;
 
    explicit ObjectPool(std::size_t growth = 32)
        : growth_(growth == 0 ? 1 : growth) {}
 
    template<typename... Args>
    pointer_type acquire(bool* reused, Args&&... args) {
        T* raw = nullptr;
        bool reused_local = false;
        {
            std::lock_guard<std::mutex> lock(mutex_);
            if (free_list_.empty()) {
                allocate_block_unlocked(growth_);
            } else {
                reused_local = true;
            }
 
            raw = free_list_.top();
            free_list_.pop();
        }
 
        if (reused) {
            *reused = reused_local;
        }
 
        new (raw) T(std::forward<Args>(args)...);
        return pointer_type(raw, deleter_type{this});
    }
 
    template<typename... Args>
    pointer_type acquire(Args&&... args) {
        return acquire(static_cast<bool*>(nullptr), std::forward<Args>(args)...);
    }
 
    void release(T* ptr) noexcept {
        if (!ptr) {
            return;
        }
 
        ptr->~T();
        std::lock_guard<std::mutex> lock(mutex_);
        free_list_.push(ptr);
    }
 
    void reserve(std::size_t count) {
        if (count == 0) {
            return;
        }
        std::lock_guard<std::mutex> lock(mutex_);
        allocate_block_unlocked(count);
    }
 
    void clear() {
        std::lock_guard<std::mutex> lock(mutex_);
        free_list_ = std::stack<T*>();
        storage_.clear();
    }
 
    [[nodiscard]] std::size_t available() const {
        std::lock_guard<std::mutex> lock(mutex_);
        return free_list_.size();
    }
 
private:
    using RawPtr = std::unique_ptr<T, detail::RawDelete<T>>;
 
    void allocate_block_unlocked(std::size_t count) {
        for (std::size_t i = 0; i < count; ++i) {
            RawPtr block(static_cast<T*>(::operator new(sizeof(T))));
            free_list_.push(block.get());
            storage_.push_back(std::move(block));
        }
    }
 
    std::size_t growth_;
    mutable std::mutex mutex_;
    std::stack<T*> free_list_;
    std::vector<RawPtr> storage_;
};
 
} // namespace kcenon::common::utils