145 lines
3.5 KiB
C++
145 lines
3.5 KiB
C++
// Copyright (c) Wojciech Figat. All rights reserved.
|
|
|
|
#pragma once
|
|
|
|
#include "Allocation.h"
|
|
|
|
/// <summary>
|
|
/// Allocator that uses pages for stack-based allocs without freeing memory during it's lifetime.
|
|
/// </summary>
|
|
class ArenaAllocator
|
|
{
|
|
private:
|
|
struct Page
|
|
{
|
|
void* Memory;
|
|
Page* Next;
|
|
uint32 Offset, Size;
|
|
};
|
|
|
|
int32 _pageSize;
|
|
Page* _first = nullptr;
|
|
|
|
public:
|
|
ArenaAllocator(int32 pageSizeBytes = 1024 * 1024) // 1 MB by default
|
|
: _pageSize(pageSizeBytes)
|
|
{
|
|
}
|
|
|
|
~ArenaAllocator()
|
|
{
|
|
Free();
|
|
}
|
|
|
|
// Allocates a chunk of unitialized memory.
|
|
void* Allocate(uint64 size, uint64 alignment = 1);
|
|
|
|
// Frees all memory allocations within allocator.
|
|
void Free();
|
|
|
|
// Creates a new object within the arena allocator.
|
|
template<class T, class... Args>
|
|
inline T* New(Args&&...args)
|
|
{
|
|
T* ptr = (T*)Allocate(sizeof(T));
|
|
new(ptr) T(Forward<Args>(args)...);
|
|
return ptr;
|
|
}
|
|
|
|
// Invokes destructor on values in an array and clears it.
|
|
template<typename Value, typename Allocator>
|
|
static void ClearDelete(Array<Value, Allocator>& collection)
|
|
{
|
|
Value* ptr = collection.Get();
|
|
for (int32 i = 0; i < collection.Count(); i++)
|
|
Memory::DestructItem(ptr[i]);
|
|
collection.Clear();
|
|
}
|
|
|
|
// Invokes destructor on values in a dictionary and clears it.
|
|
template<typename Key, typename Value, typename Allocator>
|
|
static void ClearDelete(Dictionary<Key, Value, Allocator>& collection)
|
|
{
|
|
for (auto it = collection.Begin(); it.IsNotEnd(); ++it)
|
|
Memory::DestructItem(it->Value);
|
|
collection.Clear();
|
|
}
|
|
};
|
|
|
|
/// <summary>
|
|
/// The memory allocation policy that uses a part of shared page allocator. Allocations are performed in stack-manner, and free is no-op.
|
|
/// </summary>
|
|
class ArenaAllocation
|
|
{
|
|
public:
|
|
enum { HasSwap = true };
|
|
typedef ArenaAllocator* Tag;
|
|
|
|
template<typename T>
|
|
class Data
|
|
{
|
|
private:
|
|
T* _data = nullptr;
|
|
ArenaAllocator* _arena = nullptr;
|
|
|
|
public:
|
|
FORCE_INLINE Data()
|
|
{
|
|
}
|
|
|
|
FORCE_INLINE Data(Tag tag)
|
|
{
|
|
_arena = tag;
|
|
}
|
|
|
|
FORCE_INLINE ~Data()
|
|
{
|
|
}
|
|
|
|
FORCE_INLINE T* Get()
|
|
{
|
|
return _data;
|
|
}
|
|
|
|
FORCE_INLINE const T* Get() const
|
|
{
|
|
return _data;
|
|
}
|
|
|
|
FORCE_INLINE int32 CalculateCapacityGrow(int32 capacity, const int32 minCapacity) const
|
|
{
|
|
return AllocationUtils::CalculateCapacityGrow(capacity, minCapacity);
|
|
}
|
|
|
|
FORCE_INLINE void Allocate(const int32 capacity)
|
|
{
|
|
ASSERT_LOW_LAYER(!_data && _arena);
|
|
_data = (T*)_arena->Allocate(capacity * sizeof(T), alignof(T));
|
|
}
|
|
|
|
FORCE_INLINE void Relocate(const int32 capacity, int32 oldCount, int32 newCount)
|
|
{
|
|
ASSERT_LOW_LAYER(_arena);
|
|
T* newData = capacity != 0 ? (T*)_arena->Allocate(capacity * sizeof(T), alignof(T)) : nullptr;
|
|
if (oldCount)
|
|
{
|
|
if (newCount > 0)
|
|
Memory::MoveItems(newData, _data, newCount);
|
|
Memory::DestructItems(_data, oldCount);
|
|
}
|
|
_data = newData;
|
|
}
|
|
|
|
FORCE_INLINE void Free()
|
|
{
|
|
_data = nullptr;
|
|
}
|
|
|
|
FORCE_INLINE void Swap(Data& other)
|
|
{
|
|
::Swap(_data, other._data);
|
|
::Swap(_arena, other._arena);
|
|
}
|
|
};
|
|
};
|