pool_allocator.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 "memory_pool.h"
 
#include <cstddef>
#include <atomic>
#include <new>
#include <type_traits>
#include <utility>
 
namespace kcenon::container::internal {
 
struct pool_size_class {
    static constexpr std::size_t small_threshold = 64;    // <= 64 bytes
    static constexpr std::size_t medium_threshold = 256;  // <= 256 bytes
    static constexpr std::size_t blocks_per_chunk = 1024;
};
 
struct pool_allocator_stats {
    std::size_t pool_hits{0};           // Allocations satisfied from pool
    std::size_t pool_misses{0};         // Allocations that went to heap
    std::size_t small_pool_allocs{0};   // Small pool allocations
    std::size_t medium_pool_allocs{0};  // Medium pool allocations
    std::size_t deallocations{0};       // Total deallocations
 
    double hit_rate() const noexcept {
        auto total = pool_hits + pool_misses;
        return total > 0 ? static_cast<double>(pool_hits) / total : 0.0;
    }
};
 
class pool_allocator {
public:
    static pool_allocator& instance() noexcept {
        thread_local pool_allocator allocator;
        return allocator;
    }
 
    void* allocate(std::size_t size) noexcept {
        if (size == 0) {
            return nullptr;
        }
 
#if CONTAINER_USE_MEMORY_POOL
        try {
            if (size <= pool_size_class::small_threshold) {
                void* ptr = small_pool_.allocate();
                stats_.pool_hits++;
                stats_.small_pool_allocs++;
                return ptr;
            } else if (size <= pool_size_class::medium_threshold) {
                void* ptr = medium_pool_.allocate();
                stats_.pool_hits++;
                stats_.medium_pool_allocs++;
                return ptr;
            }
        } catch (...) {
            // Pool allocation failed, fall through to heap
        }
#endif
        // Large allocation or pool disabled: use heap
        stats_.pool_misses++;
        return ::operator new(size, std::nothrow);
    }
 
    void deallocate(void* ptr, std::size_t size) noexcept {
        if (!ptr) {
            return;
        }
 
        stats_.deallocations++;
 
#if CONTAINER_USE_MEMORY_POOL
        if (size <= pool_size_class::small_threshold) {
            small_pool_.deallocate(ptr);
            return;
        } else if (size <= pool_size_class::medium_threshold) {
            medium_pool_.deallocate(ptr);
            return;
        }
#endif
        // Large allocation: use heap
        ::operator delete(ptr);
    }
 
    pool_allocator_stats get_stats() const noexcept {
        return stats_;
    }
 
    fixed_block_pool::statistics get_small_pool_stats() const {
        return small_pool_.get_statistics();
    }
 
    fixed_block_pool::statistics get_medium_pool_stats() const {
        return medium_pool_.get_statistics();
    }
 
    void reset_stats() noexcept {
        stats_ = pool_allocator_stats{};
    }
 
private:
    pool_allocator()
        : small_pool_(pool_size_class::small_threshold, pool_size_class::blocks_per_chunk)
        , medium_pool_(pool_size_class::medium_threshold, pool_size_class::blocks_per_chunk)
    {}
 
    // Non-copyable, non-movable
    pool_allocator(const pool_allocator&) = delete;
    pool_allocator& operator=(const pool_allocator&) = delete;
    pool_allocator(pool_allocator&&) = delete;
    pool_allocator& operator=(pool_allocator&&) = delete;
 
    fixed_block_pool small_pool_;
    fixed_block_pool medium_pool_;
    pool_allocator_stats stats_;
};
 
template<typename T, typename... Args>
T* pool_allocate(Args&&... args) noexcept {
    static_assert(std::is_nothrow_destructible_v<T>,
                  "pool_allocate requires nothrow destructible types");
 
    void* ptr = pool_allocator::instance().allocate(sizeof(T));
    if (!ptr) {
        return nullptr;
    }
 
    try {
        return new (ptr) T(std::forward<Args>(args)...);
    } catch (...) {
        pool_allocator::instance().deallocate(ptr, sizeof(T));
        return nullptr;
    }
}
 
template<typename T>
void pool_deallocate(T* ptr) noexcept {
    if (!ptr) {
        return;
    }
 
    ptr->~T();
    pool_allocator::instance().deallocate(ptr, sizeof(T));
}
 
template<typename T>
constexpr bool is_pool_allocatable() noexcept {
    return sizeof(T) <= pool_size_class::medium_threshold;
}
 
inline constexpr int get_size_class(std::size_t size) noexcept {
    if (size <= pool_size_class::small_threshold) {
        return 0;
    } else if (size <= pool_size_class::medium_threshold) {
        return 1;
    }
    return 2;
}
 
} // namespace kcenon::container::internal