allocator_pool.h

Go to the documentation of this file.

 
#ifndef CPPCOMMON_MEMORY_ALLOCATOR_POOL_H
#define CPPCOMMON_MEMORY_ALLOCATOR_POOL_H
 
#include "allocator.h"
 
namespace CppCommon {
 
 
template <class TAuxMemoryManager = DefaultMemoryManager>
class PoolMemoryManager
{
public:
 
    explicit PoolMemoryManager(TAuxMemoryManager& auxiliary) : PoolMemoryManager(auxiliary, 65536, 0) {}
 
    explicit PoolMemoryManager(TAuxMemoryManager& auxiliary, size_t page, size_t pages = 0);
 
    explicit PoolMemoryManager(TAuxMemoryManager& auxiliary, void* buffer, size_t capacity);
    PoolMemoryManager(const PoolMemoryManager&) = delete;
    PoolMemoryManager(PoolMemoryManager&&) = delete;
    ~PoolMemoryManager() { clear(); }
 
    PoolMemoryManager& operator=(const PoolMemoryManager&) = delete;
    PoolMemoryManager& operator=(PoolMemoryManager&&) = delete;
 
    size_t allocated() const noexcept { return _allocated; }
    size_t allocations() const noexcept { return _allocations; }
 
    size_t page() const noexcept { return _page; }
    size_t pages() const noexcept { return _max_pages; }
 
    size_t max_size() const noexcept { return _auxiliary.max_size(); }
 
    TAuxMemoryManager& auxiliary() noexcept { return _auxiliary; }
 
 
    void* malloc(size_t size, size_t alignment = alignof(std::max_align_t));
 
    void free(void* ptr, size_t size);
 
    void reset();
 
    void reset(size_t page, size_t pages = 0);
 
    void reset(void* buffer, size_t capacity);
 
    void clear();
 
private:
    // Pool page contains allocated and free blocks
    struct Page
    {
        uint8_t* buffer;
        Page* prev;
        Page* next;
    };
    // Allocated block
    struct AllocBlock
    {
        size_t size;
        size_t adjustment;
    };
    // Free block
    struct FreeBlock
    {
        size_t size;
        FreeBlock* next;
    };
 
    // Allocation statistics
    size_t _allocated;
    size_t _allocations;
 
    // Auxiliary memory manager
    TAuxMemoryManager& _auxiliary;
 
    // Pool pages
    bool _external;
    size_t _max_pages;
    size_t _pages;
    size_t _page;
    Page* _current;
 
    // Free block
    FreeBlock* _free_block;
 
    size_t AlignAdjustment(const void* address, size_t alignment);
    size_t AlignAdjustment(const void* address, size_t alignment, size_t header);
 
    Page* AllocateMemoryPool(size_t capacity, Page* prev);
    void ClearMemoryPool();
};
 
template <typename T, class TAuxMemoryManager = DefaultMemoryManager, bool nothrow = false>
using PoolAllocator = Allocator<T, PoolMemoryManager<TAuxMemoryManager>, nothrow>;
 
} // namespace CppCommon
 
#include "allocator_pool.inl"
 
#endif // CPPCOMMON_MEMORY_ALLOCATOR_POOL_H