Allocator.h

#pragma once
 
 
#include "../FoundationBase.h"
#include "../Platform/Atomic.h"
 
#include <OsoMemoryProfiler/CogsMemoryProfile.h>
 
#ifndef _WIN32
#include <utility>
#endif
 
namespace Cogs {
  namespace Memory {
#ifdef EMSCRIPTEN
    constexpr size_t kDefaultAlignment = 8;
#else
    // For MSVC/GCC/Clang on Windows/Linux
#if defined(_M_X64) || defined(__amd64__)
    constexpr size_t kDefaultAlignment = 16;
#else
    constexpr size_t kDefaultAlignment = 8;
#endif
#endif
 
    class COGSFOUNDATION_API Allocator
    {
    public:
      Allocator() = default;
      virtual ~Allocator() = default;
 
      static Allocator * defaultAllocator();
 
      static Allocator * overflowAllocator();
 
      virtual void * allocate(size_t size, size_t alignment = 0, MemBlockType type = MemBlockType::Block);
 
      virtual void deallocate(void * ptr, size_t size, MemBlockType type = MemBlockType::Block);
 
      virtual void changeType(void* ptr, size_t size, MemBlockType oldType, MemBlockType newType);
 
      virtual size_t getAllocatedBytes() const { return allocated; }
 
      virtual size_t getAllocationCount() const { return allocations; }
 
    protected:
      Cogs::Atomic<size_t> allocated{0};
      Cogs::Atomic<size_t> allocations{0};
    };
 
    template<typename T>
    T * create(Allocator * allocator)
    {
      void * memory = allocator->allocate(sizeof(T), alignof(T));
 
      return new (memory) T();
    }
 
    template<typename T, typename... Args>
    T * create(Allocator * allocator, Args&&... args)
    {
      void * memory = allocator->allocate(sizeof(T), alignof(T));
 
      return new (memory) T(std::forward<Args>(args)...);
    }
 
    template<typename T>
    void destroy(T * t, Allocator * allocator)
    {
      t->~T();
 
      allocator->deallocate(t, sizeof(T));
    }
  }
}