allocator_arena.h

Go to the documentation of this file.

 
#ifndef CPPCOMMON_MEMORY_ALLOCATOR_ARENA_H
#define CPPCOMMON_MEMORY_ALLOCATOR_ARENA_H
 
#include "allocator.h"
 
namespace CppCommon {
 
 
template <class TAuxMemoryManager = DefaultMemoryManager>
class ArenaMemoryManager
{
public:
 
    explicit ArenaMemoryManager(TAuxMemoryManager& auxiliary) : ArenaMemoryManager(auxiliary, 65536) {}
 
    explicit ArenaMemoryManager(TAuxMemoryManager& auxiliary, size_t capacity);
 
    explicit ArenaMemoryManager(TAuxMemoryManager& auxiliary, void* buffer, size_t capacity);
    ArenaMemoryManager(const ArenaMemoryManager&) = delete;
    ArenaMemoryManager(ArenaMemoryManager&&) = delete;
    ~ArenaMemoryManager() { clear(); }
 
    ArenaMemoryManager& operator=(const ArenaMemoryManager&) = delete;
    ArenaMemoryManager& operator=(ArenaMemoryManager&&) = delete;
 
    size_t allocated() const noexcept { return _allocated; }
    size_t allocations() const noexcept { return _allocations; }
 
    const uint8_t* buffer() const noexcept { return _buffer; }
    size_t capacity() const noexcept { return _capacity; }
    size_t size() const noexcept { return _size; }
 
    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 capacity);
 
    void reset(void* buffer, size_t capacity);
 
    void clear();
 
private:
    // Arena page
    struct Page
    {
        uint8_t* buffer;
        size_t capacity;
        size_t size;
        Page* prev;
    };
 
    // Allocation statistics
    size_t _allocated;
    size_t _allocations;
 
    // Auxiliary memory manager
    TAuxMemoryManager& _auxiliary;
 
    // Arena pages
    Page* _current;
    size_t _reserved;
 
    // External buffer
    bool _external;
    uint8_t* _buffer;
    size_t _capacity;
    size_t _size;
 
    Page* AllocateArena(size_t capacity, Page* prev);
    void ClearArena();
};
 
template <typename T, class TAuxMemoryManager = DefaultMemoryManager, bool nothrow = false>
using ArenaAllocator = Allocator<T, ArenaMemoryManager<TAuxMemoryManager>, nothrow>;
 
} // namespace CppCommon
 
#include "allocator_arena.inl"
 
#endif // CPPCOMMON_MEMORY_ALLOCATOR_ARENA_H