Allocator.cpp

#include "Allocator.h"
 
#include "../Logging/Logger.h"
 
#if defined(_WIN32) && defined(COGS_FOUNDATION_ALIGNED_MALLOC)
#define USE_ALIGNED_MALLOC
 
#include <malloc.h>
#endif
 
#include <stdlib.h>
 
namespace{
  Cogs::Logging::Log logger = Cogs::Logging::getLogger("Allocator");
}
 
Cogs::Memory::Allocator * Cogs::Memory::Allocator::defaultAllocator()
{
  static Allocator allocator;
 
  return &allocator;
}
 
Cogs::Memory::Allocator * Cogs::Memory::Allocator::overflowAllocator()
{
  return defaultAllocator();
}
 
void * Cogs::Memory::Allocator::allocate(size_t size, size_t alignment, MemBlockType type)
{
  allocated += size;
  ++allocations;
 
#ifdef USE_ALIGNED_MALLOC
  void * memory = _aligned_malloc(size, alignment > kDefaultAlignment ? alignment : kDefaultAlignment);
#else
  void * memory = nullptr;
  if (alignment <= kDefaultAlignment) {
    memory = malloc(size);
  } else {
    assert(false && "Unsupported alignment restrictions.");
  }
#endif
 
  if (!memory) {
    LOG_ERROR(logger, "Failed to allocate %zd bytes of %zd byte aligned memory.", size, alignment);
  }
  (void)type;
  OsoMP_Allocate(uint8_t(type), memory, size, nullptr, 0);
 
#if 0
  // Enable to check assumptions regarding default alignment.
  assert((intptr_t)memory % kDefaultAlignment == 0 && "Invalid base alignment");
#endif
  return memory;
}
 
void Cogs::Memory::Allocator::deallocate(void * ptr, size_t size, MemBlockType type)
{
  (void)type;
  OsoMP_Free(uint8_t(type), ptr, nullptr, 0);
 
#ifdef USE_ALIGNED_MALLOC
  _aligned_free(ptr);
#else
  free(ptr);
#endif
  allocated -= size;
  --allocations;
}
 
void Cogs::Memory::Allocator::changeType(void* ptr, size_t size, MemBlockType oldType, MemBlockType newType)
{
  (void)ptr;
  (void)size;
  (void)oldType;
  (void)newType;
  OsoMP_Free(uint8_t(oldType), ptr, nullptr, 0);
  OsoMP_Allocate(uint8_t(newType), ptr, size, nullptr, 0);
}