MemoryPool.hh

// Copyright QED Software 2023.
 
#ifndef GRAIL_POOL_ALLOCATOR_H
#define GRAIL_POOL_ALLOCATOR_H
 
#include "../GrailCore/consts.h"
#include "../GrailLogger/LoggerManager.hh"
 
#include <memory>
#include <string>
#include <type_traits>
#include <utility>
 
namespace grail
{
namespace planner
{
    template <typename T>
    class Emplacer final
    {
    public:
        Emplacer(typename std::enable_if<std::is_trivially_destructible<T>::value>::type* = 0)
        {
        }
 
        template <typename... Arguments>
        T& operator()(void* memoryCell, Arguments&&... arguments)
        {
            return *(new(memoryCell) T{std::forward<Arguments>(arguments)...});
        }
    };
 
    template <>
    class Emplacer<std::string>
    {
    public:
        template <typename... Arguments>
        std::string& operator()(void* memoryCell, Arguments&&... arguments)
        {
            if(StringLength(std::forward<Arguments>(arguments)...) > consts::MAX_STRING_SIZE)
            {
                throw std::bad_alloc{};
            }
            return *(new(memoryCell) std::string{std::forward<Arguments>(arguments)...});
        }
 
    private:
        std::size_t StringLength(const std::string& string) const
        {
            return string.size();
        }
    };
 
    template <>
    class Emplacer<const std::string>
    {
    public:
        template <typename... Arguments>
        const std::string& operator()(void* memoryCell, Arguments&&... arguments)
        {
            if(StringLength(std::forward<Arguments>(arguments)...) > consts::MAX_STRING_SIZE)
            {
                GRAIL_LOG(consts::DEFAULT_GRAIL_LOG_GROUP, logger::Severity::ERRORS, "Planner memory pool out of memory");
                throw std::bad_alloc{};
            }
            return *(new(memoryCell) const std::string{std::forward<Arguments>(arguments)...});
        }
 
    private:
        std::size_t StringLength(const std::string& string) const
        {
            return string.size();
        }
    };
 
    class MemoryPool final
    {
    public:
        MemoryPool(const std::size_t BYTES = 5242880u)
            : blocks{new char[BYTES]},
              currentMemoryCell{&blocks[0]},
              _size{0},
              BYTES{BYTES}
        {
        }
 
        ~MemoryPool()
        {
            delete[] blocks;
        }
 
        template <typename T, typename... ConstructorArguments>
        T& Emplace(ConstructorArguments&&... arguments)
        {
            std::size_t memoryRequired = sizeof(T);
            std::size_t alignment = alignof(T);
            std::size_t leftoverBytes = _size % alignment;
 
            if(leftoverBytes > 0)
            {
                std::size_t padding = (alignment - leftoverBytes);
                _size += padding;
                if(_size < BYTES)
                {
                    currentMemoryCell = static_cast<char*>(currentMemoryCell) + padding;
                }
            }
 
            _size += memoryRequired;
 
            if(_size > BYTES)
            {
                throw std::bad_alloc{};
            }
 
            Emplacer<T> emplacer;
            T& result = emplacer(currentMemoryCell, std::forward<ConstructorArguments>(arguments)...);
            currentMemoryCell = static_cast<char*>(currentMemoryCell) + memoryRequired;
            return result;
        }
 
        std::size_t Size() const
        {
            return _size;
        }
 
        void Reset(std::size_t size = 0)
        {
            if(size >= BYTES)
            {
                GRAIL_LOG(consts::DEFAULT_GRAIL_LOG_GROUP, logger::Severity::ERRORS, "Pool reset to size exceeding allocated memory");
                size = BYTES-1;
            }
            
            currentMemoryCell = &blocks[size];
            _size = size;
        }
 
    private:
        char* const blocks;
        void* currentMemoryCell;
        std::size_t _size;
        const std::size_t BYTES;
    };
}
}
 
#endif // GRAIL_POOL_ALLOCATOR_H