ComponentPool.cpp

#include "ComponentPool.h"
 
#include "../Reflection/TypeDatabase.h"
 
#include <OsoMemoryProfiler/CogsMemoryProfile.h>
 
#include <numeric>
#include <algorithm>
#include <cmath>
 
using namespace Cogs::Reflection;
 
Cogs::ComponentModel::ComponentPoolBase::ComponentPoolBase(const Reflection::TypeId typeId, SizeType capacity, Memory::Allocator * allocator, MemBlockType memType) :
  next(0),
  roster(allocator),
  store(allocator, memType),
  elementSize(0),
  componentType(typeId),
  flags(ComponentPoolFlags::None)
{
  const auto & type = TypeDatabase::getType(componentType);
 
  elementSize = type.getSize();
 
  resize(capacity);
}
 
Cogs::ComponentModel::ComponentHandle Cogs::ComponentModel::ComponentPoolBase::allocateComponent()
{
  if (isSet(ComponentPoolFlags::AllowGrow) && static_cast<size_t>(next) == roster.size()) {
    const size_t newSize = std::min(static_cast<size_t>(maxSize()), static_cast<size_t>(std::round(static_cast<double>(roster.size()) * 1.55)));
 
    resize(static_cast<SizeType>(newSize));
  }
 
  assert(next < roster.size() && "Component pool over capacity.");
 
  // Find next free component.
  const auto nextIndex = roster[next];
  auto component = get(nextIndex);
 
  const auto & type = TypeDatabase::getType(componentType);
 
  // Initialize component by calling default constructor.
  TypeDatabase::constructInstance(type, component, elementSize);
 
  OsoMP_Allocate(COGSMEM_Component, component, elementSize, nullptr, 0);
 
  // Initialize housekeeping data.
  static uint16_t generation = 0;
  component->setIndex(next++);
  component->setTypeId(componentType);
  component->setActive();
  component->setGeneration(generation);
 
  return ComponentHandle{ this, nextIndex, componentType, generation++ };
}
 
void Cogs::ComponentModel::ComponentPoolBase::deallocateComponent(ComponentHandle handle)
{
  auto component = handle.resolve();
  const auto & type = TypeDatabase::getType(componentType);
 
  const ComponentIndex rosterIndex = component->getIndex();
 
  OsoMP_Free(COGSMEM_Component, component, nullptr, 0);
 
  assert(rosterIndex < next && "Roster index out of bounds");
 
  // Move old component index to first free roster slot.
  std::swap(roster[rosterIndex], roster[--next]);
 
  // Component index fix up.
  get(roster[rosterIndex])->setIndex(rosterIndex);
 
  component->setGeneration(component->getGeneration() + 1);
 
  // Destroy old component by invoking destructor.
  TypeDatabase::destructInstance(type, component);
 
#ifdef _DEBUG
  constexpr const uint8_t bytes [] = {
    0x3F, 0xB3, 0xAD, 0xDE
  };
 
  // Set memory to detect uninitialized usage easier.
  for (size_t i = 0; i < type.getSize(); ++i) {
    reinterpret_cast<uint8_t *>(component)[i] = bytes[i % 4];
  }
#endif
}
 
void Cogs::ComponentModel::ComponentPoolBase::resize(SizeType capacity)
{
  const size_t oldSize = roster.size();
 
  roster.resize(capacity);
  store.resize(static_cast<size_t>(capacity) * elementSize, true, false);
 
  std::iota(roster.begin() + oldSize, roster.end(), next);
}
 
Cogs::SizeType Cogs::ComponentModel::ComponentPoolBase::maxSize() const
{
  return std::numeric_limits<SizeType>::max();
}