Предварительное выделение пользовательской кучи для системы компонентов объекта

C ++ поддерживает классовые пулы памяти для такого рода вещей. Универсальный new/delete пара неизбежно торгуется среди

• Время, потраченное на поиск свободного блока нужного размера, чтобы удовлетворить каждый запрос
• Время, потраченное на объединение свободных блоков
• Время, затрачиваемое на поддержание и, возможно, реорганизацию внутренних структур данных, чтобы ускорить две вышеуказанные операции.

Основной способ получить скорость — полностью избежать этих компромиссов с помощью пользовательских распределителей, которые, как вы говорите, предварительно выделяют большой кусок памяти, рассматриваемый как простой массив свободных объектов одинакового размера. Первоначально все они связаны в свободном списке, где указатели ссылок занимают первые байты каждого блока, «наложенного», куда в конечном итоге будут поступать данные. Распределение — это просто освобождение блока от заголовка свободного списка — операция «pop», требующая около 2 инструкций. Распределение — это «толчок»: еще две инструкции. Во многих случаях аппаратное обеспечение памяти может быть настроено на генерацию прерывания, когда пул пуст, так что нет никаких накладных расходов на выделение для обнаружения
это условие ошибки. (В системах GC тот же прием используется для инициирования сбора без дополнительных затрат.)

В вашем случае вам понадобятся два пула: один для сущностей и один для компонентов.

Определить свой собственный распределитель пулов не так сложно, особенно если ваше приложение однопоточное. Увидеть этот документ для учебного лечения.

Одна из ваших проблем может быть решена путем выделения достаточного пространства в векторах при их создании.

За

vector<unique_ptr<Entity>> entities;

обеспечить достаточно места в конструкторе

Manager::Manager() : entities(10000)
{
//...
}

Таким образом, вы избегаете перераспределения и копирования на более поздних этапах.

Второй вопрос — создание вашего unique_ptr<Entity> указатели. Здесь, поскольку вы всегда будете использовать созданные по умолчанию объекты, вы также можете использовать заранее выделенный пул объектов, из которого вы создаете указатели. Вместо вызова нового вы бы назвали собственный класс

class EntityPool
{
public:
EntityPool(unsigned int size = 10000) : pool(size), nextEntity(0)
{
}
Entity* getNext(void)
{
if (nextEntity != pool.size()) // if pool is exhausted create new
{
pool.emplace_back(Entity());
}
return pool[nextEntity++];
}
private:
vector<Entity> pool;
unsigned int nextEntity; // index into the vector to the next Entity
};

struct Manager
{
vector<unique_ptr<Entity>> entities;
Entity& createEntity()
{
entities.emplace_back(entityPoolInstance.getNext());
return *result;
}
//...

Или вы можете подключить стандартное «новое размещение». Это позволяет вам выделить большой блок памяти для конструирования (размещения) объектов по вашему выбору. Это будет держать блок в куче столько времени, сколько вам нужно, и позволит вам выделить несколько недолговечных объектов в этом блоке вместо выполнения дорогостоящих распределений и перераспределений, которые просто заканчивают фрагментацией кучи. Здесь задействовано несколько проблем, но в целом это ДЕЙСТВИТЕЛЬНО простое решение, не требующее перехода к пользовательскому маршруту менеджера памяти.
Вот отличная обработка устранения некоторых ловушек и описание размещения новых в деталях.
Я использовал простые структуры данных, такие как стек, для отслеживания следующего свободного блока, который будет выделен: помещать адрес блока, который собирается удалить, в стек. При выделении просто вытолкните следующий свободный блок из стека и используйте его в качестве аргумента для размещения нового. Супер просто и супер быстро!

Используя большинство ответов и Google в качестве ссылок, я реализовал некоторые утилиты предварительного выделения в моем Библиотека SSVUtils.

Prealloc.h

Пример:

using MemUnit = char;
using MemUnitPtr = MemUnit*;
using MemSize = decltype(sizeof(MemUnit)); // Should always be 1 byte

class MemBuffer
{
Uptr<MemUnit[]> buffer;
MemRange range;

MemBuffer(MemSize mSize) : ...
{
// initialize buffer from mSize
}
};

class PreAllocatorChunk
{
protected:
MemSize chunkSize;
MemBuffer buffer;
std::stack<MemRange> available;

public:
PreAllocatorChunk(MemSize mChunkSize, unsigned int mChunks) : ...
{
// Add "chunks" to to available...
}

template<typename T, typename... TArgs> T* create(TArgs&&... mArgs)
{
// create on first "chunk" using placement new
auto toUse(available.top().begin); available.pop();
return new (toUse) T{std::forward<TArgs>(mArgs)...};
}
};

Доступны дополнительные утилиты предварительного выделения:

• PreAllocatorDynamic: предварительно выделяет большой буфер, затем при создании объекта разделяет буфер на две части:

  • [buffer start, buffer start + obj size)
  • [buffer start + obj size, buffer end)

  Когда объект уничтожен, его занятый диапазон памяти устанавливается как «доступный». Если во время создания нового объекта не найден достаточно большой «чанк», предварительный распределитель пытается объединить смежные куски памяти, прежде чем выдать исключение времени выполнения. Этот предварительный распределитель иногда быстрее, чем new/delete, но это сильно зависит от размера предварительно выделенного буфера.

• PreAllocatorStatic<T>: унаследовано от PreAllocatorChunk, Размер куска равен sizeof(T), Самый быстрый предварительный распределитель, менее гибкий. Почти всегда быстрее чем new/delete,