MemoryContext.cpp

#include "MemoryContext.h"
 
#include "Foundation/Logging/Logger.h"
#include "Foundation/Memory/Allocator.h"
#include "Foundation/Platform/Atomic.h"
#include "Foundation/StringView.h"
 
#include <algorithm>
 
namespace
{
  Cogs::Logging::Log logger = Cogs::Logging::getLogger("Memory");
}
 
namespace Cogs::Core
{
  class CoreAllocator : public Memory::Allocator
  {
  public:
    CoreAllocator(Memory::Allocator * baseAllocator, StringView tag, bool base = false) :
      baseAllocator(baseAllocator),
      tag(tag),
      base(base)
    {
    }
 
    ~CoreAllocator()
    {
      if (!base && tag != "Strings") {
        if (allocationCount || allocationSize) {
          LOG_WARNING(logger, "[%.*s] Leaked %zu allocations, %zu bytes.", StringViewFormat(tag), allocationCount.load(), allocationSize.load());
          assert(allocationSize == 0 && "Core memory leaked.");
        }
      }
    }
 
    size_t size() const { return allocationSize; }
    size_t count() const { return allocationCount; }
 
    size_t peakSize() const { return peakAllocationSize; }
    size_t peakCount() const { return peakAllocationCount; }
 
    void * allocate(size_t size, size_t alignment, MemBlockType type = MemBlockType::CoreAllocator) override
    {
      allocationSize += size;
      peakAllocationSize = std::max(peakAllocationSize.load(), allocationSize.load());
      ++allocationCount;
      peakAllocationCount = std::max(peakAllocationCount.load(), allocationCount.load());
 
      return baseAllocator->allocate(size, alignment, type);
    }
 
    void deallocate(void * ptr, size_t size, MemBlockType type = MemBlockType::CoreAllocator) override
    {
      allocationSize -= size;
      --allocationCount;
 
      baseAllocator->deallocate(ptr, size, type);
    }
 
    size_t getAllocatedBytes() const override { return allocationSize; }
 
    size_t getAllocationCount() const override  { return allocationCount; }
 
  private:
    Memory::Allocator * baseAllocator;
 
    Atomic<size_t> allocationSize{ 0 };
    Atomic<size_t> allocationCount{ 0 };
    Atomic<size_t> peakAllocationSize{ 0 };
    Atomic<size_t> peakAllocationCount{ 0 };
 
    StringView tag;
    bool base = false;
  };
 
  struct MemoryContextStorage
  {
    MemoryContextStorage() :
      baseAllocator(Memory::Allocator::defaultAllocator(), "Core", true),
      resourceAllocator(&baseAllocator, "Resources"),
      componentAllocator(&baseAllocator, "Components"),
      ioAllocator(&baseAllocator, "IO"),
      scriptAllocator(&baseAllocator, "Script")
    {
    }
 
    CoreAllocator baseAllocator;
    CoreAllocator resourceAllocator;
    CoreAllocator componentAllocator;
    CoreAllocator ioAllocator;
    CoreAllocator scriptAllocator;
  };
 
  
  size_t getAllocatedBytes(const Memory::Allocator * allocator)
  {
    return ((CoreAllocator *)allocator)->size();
  }
 
  size_t getAllocationCount(const Memory::Allocator * allocator)
  {
    return ((CoreAllocator *)allocator)->count();
  }
 
  size_t getPeakBytes(const Memory::Allocator * allocator)
  {
    return ((CoreAllocator *)allocator)->peakSize();
  }
 
  size_t getPeakCount(const Memory::Allocator * allocator)
  {
    return ((CoreAllocator *)allocator)->peakCount();
  }
}
 
Cogs::Memory::Allocator * Cogs::Core::MemoryContext::getStringsAllocator() {
  static CoreAllocator cSringsAllocator(Memory::Allocator::defaultAllocator(), "Strings");
 
  return &cSringsAllocator;
}
 
Cogs::Core::MemoryContext::MemoryContext() :
  storage(std::make_unique<MemoryContextStorage>()),
  baseAllocator(&storage->baseAllocator),
  resourceAllocator(&storage->resourceAllocator),
  ioAllocator(&storage->ioAllocator),
  componentAllocator(&storage->componentAllocator),
  scriptAllocator(&storage->scriptAllocator)
{
 
}
 
Cogs::Core::MemoryContext::~MemoryContext()
{
 
}