Allocator.h

#pragma once
 
 
#include <Foundation/Time/Time.h>
#include <Foundation/Types/ArrayPtr.h>
#include <Foundation/Types/Id.h>
#include <utility>
 
 
#ifdef new
#  undef new
#endif
 
#ifdef delete
#  undef delete
#endif
 
using plAllocatorId = plGenericId<24, 8>;
 
class PL_FOUNDATION_DLL plAllocator
{
public:
  struct Stats
  {
    PL_DECLARE_POD_TYPE();
 
    plUInt64 m_uiNumAllocations = 0;         
    plUInt64 m_uiNumDeallocations = 0;       
    plUInt64 m_uiAllocationSize = 0;         
 
    plUInt64 m_uiPerFrameAllocationSize = 0; 
    plTime m_PerFrameAllocationTime;         
  };
 
  plAllocator();
  virtual ~plAllocator();
 
  virtual void* Allocate(size_t uiSize, size_t uiAlign, plMemoryUtils::DestructorFunction destructorFunc = nullptr) = 0;
  virtual void Deallocate(void* pPtr) = 0;
  virtual void* Reallocate(void* pPtr, size_t uiCurrentSize, size_t uiNewSize, size_t uiAlign);
 
  virtual size_t AllocatedSize(const void* pPtr) = 0;
 
  virtual plAllocatorId GetId() const = 0;
  virtual Stats GetStats() const = 0;
 
private:
  PL_DISALLOW_COPY_AND_ASSIGN(plAllocator);
};
 
#include <Foundation/Memory/Implementation/Allocator_inl.h>
 
#define PL_NEW(allocator, type, ...) \
  plInternal::NewInstance<type>(     \
    new ((allocator)->Allocate(sizeof(type), PL_ALIGNMENT_OF(type), plMemoryUtils::MakeDestructorFunction<type>())) type(__VA_ARGS__), (allocator))
 
#define PL_DELETE(allocator, ptr)       \
  {                                     \
    plInternal::Delete(allocator, ptr); \
    ptr = nullptr;                      \
  }
 
#define PL_NEW_ARRAY(allocator, type, count) plInternal::CreateArray<type>(allocator, count)
 
#define PL_DELETE_ARRAY(allocator, arrayPtr)      \
  {                                               \
    plInternal::DeleteArray(allocator, arrayPtr); \
    arrayPtr.Clear();                             \
  }
 
#define PL_NEW_RAW_BUFFER(allocator, type, count) plInternal::CreateRawBuffer<type>(allocator, count)
 
#define PL_DELETE_RAW_BUFFER(allocator, ptr)     \
  {                                              \
    plInternal::DeleteRawBuffer(allocator, ptr); \
    ptr = nullptr;                               \
  }
 
#define PL_EXTEND_RAW_BUFFER(allocator, ptr, oldSize, newSize) plInternal::ExtendRawBuffer(ptr, allocator, oldSize, newSize)
 
 
 
#define PL_DEFAULT_NEW(type, ...) PL_NEW(plFoundation::GetDefaultAllocator(), type, __VA_ARGS__)
 
#define PL_DEFAULT_DELETE(ptr) PL_DELETE(plFoundation::GetDefaultAllocator(), ptr)
 
#define PL_DEFAULT_NEW_ARRAY(type, count) PL_NEW_ARRAY(plFoundation::GetDefaultAllocator(), type, count)
 
#define PL_DEFAULT_DELETE_ARRAY(arrayPtr) PL_DELETE_ARRAY(plFoundation::GetDefaultAllocator(), arrayPtr)
 
#define PL_DEFAULT_NEW_RAW_BUFFER(type, count) PL_NEW_RAW_BUFFER(plFoundation::GetDefaultAllocator(), type, count)
 
#define PL_DEFAULT_DELETE_RAW_BUFFER(ptr) PL_DELETE_RAW_BUFFER(plFoundation::GetDefaultAllocator(), ptr)