Patedam/Juliet
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Reallocate-Arena #1

Merged
Patedam merged 7 commits from Reallocate-Arena into main 2026-02-14 11:24:30 -05:00
Conversation 0 Commits 7 Files Changed 36 +156 -189
21 changed files with 156 additions and 189 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Showing only changes of commit 679edf48ed - Show all commits

1
Juliet/Juliet.vcxproj
View File

@@ -156,7 +156,6 @@
<CustomBuild Include="src\Core\Math\Math_Private.h" />
<CustomBuild Include="src\Core\Math\MathRound.cpp" />
<CustomBuild Include="src\Core\Memory\Allocator.cpp" />
<CustomBuild Include="src\Core\Memory\EngineArena.h" />
<CustomBuild Include="src\Core\Memory\MemoryArena.cpp" />
<CustomBuild Include="src\Core\Memory\MemoryArenaTests.cpp" />
<CustomBuild Include="src\Core\Memory\ScratchArena.cpp" />

3
Juliet/Juliet.vcxproj.filters
View File

@@ -315,9 +315,6 @@
<CustomBuild Include="src\Core\Memory\Allocator.cpp">
<Filter>src\Core\Memory</Filter>
</CustomBuild>
<CustomBuild Include="src\Core\Memory\EngineArena.h">
<Filter>src\Core\Memory</Filter>
</CustomBuild>
<CustomBuild Include="src\Core\Memory\MemoryArena.cpp">
<Filter>src\Core\Memory</Filter>
</CustomBuild>

10
Juliet/include/Core/Container/Vector.h
View File

@@ -16,7 +16,7 @@ namespace Juliet
DataFirst = DataLast = nullptr;
Count = 0;
Stride = sizeof(Type);
Arena = ArenaAllocate();
Arena = ArenaAllocate(JULIET_DEBUG_ONLY({ .CanReserveMore = false }));
}
void Destroy()
{
@@ -27,6 +27,14 @@ namespace Juliet
Arena = nullptr;
}
void Resize(size_t newCount)
{
Type* entry = ArenaPushArray<Type>(Arena, newCount);
Count = newCount;
DataFirst = entry;
DataLast = entry + newCount;
}
void PushBack(const Type& value)
{
Assert(Arena);

5
Juliet/include/Core/HotReload/HotReload.h
View File

@@ -9,6 +9,8 @@ namespace Juliet
struct HotReloadCode
{
Arena* Arena;
String DLLFullPath;
String LockFullPath;
String TransientDLLName;
@@ -26,8 +28,7 @@ namespace Juliet
bool IsValid : 1;
};
extern JULIET_API void InitHotReloadCode(HotReloadCode& code, String dllName,
String transientDllName, String lockFilename);
extern JULIET_API void InitHotReloadCode(HotReloadCode& code, String dllName, String transientDllName, String lockFilename);
extern JULIET_API void ShutdownHotReloadCode(HotReloadCode& code);
extern JULIET_API void LoadCode(HotReloadCode& code);

6
Juliet/include/Core/Memory/MemoryArena.h
View File

@@ -30,6 +30,8 @@ namespace Juliet
uint64 Reserved;
Arena* FreeLast;
JULIET_DEBUG_ONLY(bool CanReserveMore : 1;)
};
static_assert(sizeof(Arena) <= k_ArenaHeaderSize);
@@ -37,6 +39,10 @@ namespace Juliet
{
uint64 ReserveSize = g_Arena_Default_Reserve_Size;
uint64 CommitSize = g_Arena_Default_Commit_Size;
// When false, will assert if a new block is reserved.
// Useful for Vectors as they are guaranteed to be linear and i wont need to implement memcopy to increase capacity
JULIET_DEBUG_ONLY(bool CanReserveMore : 1 = true;)
};
[[nodiscard]] Arena* ArenaAllocate(const ArenaParams& params = {},

2
Juliet/include/Juliet.h
View File

@@ -21,8 +21,10 @@
#ifdef DEBUG
#define JULIET_DEBUG 1
#define JULIET_DEBUG_ONLY(expr) expr
#else
#define JULIET_DEBUG 0
#define JULIET_DEBUG_ONLY(expr)
#endif
// Manual override to disable ImGui

1
Juliet/src/Core/HAL/Display/Display.cpp
View File

@@ -2,7 +2,6 @@
#include <Core/HAL/Display/Display_Private.h>
#include <Core/HAL/Display/DisplayDevice.h>
#include <Core/Memory/Allocator.h>
#include <Core/Memory/EngineArena.h>
#include <Core/Memory/MemoryArena.h>
namespace Juliet

1
Juliet/src/Core/HAL/Display/Win32/Win32DisplayDevice.cpp
View File

@@ -1,7 +1,6 @@
#include <Core/HAL/Display/DisplayDevice.h>
#include <Core/HAL/Display/Win32/Win32DisplayEvent.h>
#include <Core/HAL/Display/Win32/Win32Window.h>
#include <Core/Memory/EngineArena.h>
namespace Juliet::Win32
{

3
Juliet/src/Core/HAL/Display/Win32/Win32Window.cpp
View File

@@ -2,8 +2,7 @@
#include <Core/HAL/Display/Win32/Win32Window.h>
#include <Core/HAL/Display/Window.h>
#include <Core/Memory/Allocator.h>
#include <Core/Memory/EngineArena.h>
#include <Core/Memory/Utils.h>
#include <Core/Memory/MemoryArena.h>
namespace Juliet::Win32
{

11
Juliet/src/Core/HotReload/HotReload.cpp
View File

@@ -2,8 +2,6 @@
#include <Core/HotReload/HotReload.h>
#include <Core/Logging/LogManager.h>
#include <Core/Logging/LogTypes.h>
#include <Core/Memory/Allocator.h>
#include <Core/Memory/EngineArena.h>
#include <Core/Memory/MemoryArena.h>
#include <Core/Thread/Thread.h>
@@ -13,6 +11,8 @@ namespace Juliet
{
void InitHotReloadCode(HotReloadCode& code, String dllName, String transientDllName, String lockFilename)
{
code.Arena = ArenaAllocate();
// Get the app base path and build the dll path from there.
String basePath = GetBasePath();
size_t basePathLength = StringLength(basePath);
@@ -24,7 +24,8 @@ namespace Juliet
// TODO: Add path composition into filesystem + string format + string builder
const size_t dllFullPathLength =
basePathLength + StringLength(dllName) + 1; // Need +1 because snprintf needs 0 terminated strings
code.DLLFullPath.Data = ArenaPushArray<char>(GetEngineArena(), dllFullPathLength, ConstString("DLLFullPath"));
code.DLLFullPath.Data = ArenaPushArray<char>(code.Arena, dllFullPathLength);
int writtenSize = snprintf(CStr(code.DLLFullPath), dllFullPathLength, "%s%s", CStr(basePath), CStr(dllName));
if (writtenSize < static_cast<int>(dllFullPathLength) - 1)
{
@@ -37,7 +38,7 @@ namespace Juliet
// Lock filename path
const size_t lockPathLength =
basePathLength + StringLength(lockFilename) + 1; // Need +1 because snprintf needs 0 terminated strings
code.LockFullPath.Data = ArenaPushArray<char>(GetEngineArena(), lockPathLength, ConstString("LockFullPath"));
code.LockFullPath.Data = ArenaPushArray<char>(code.Arena, lockPathLength);
writtenSize = snprintf(CStr(code.LockFullPath), lockPathLength, "%s%s", CStr(basePath), CStr(lockFilename));
if (writtenSize < static_cast<int>(lockPathLength) - 1)
{
@@ -59,6 +60,8 @@ namespace Juliet
// Arena memory persists until engine shutdown
code.LockFullPath.Size = 0;
// Arena memory persists until engine shutdown
ArenaRelease(code.Arena);
}
void ReloadCode(HotReloadCode& code)

29
Juliet/src/Core/ImGui/ImGuiService.cpp
View File

@@ -9,7 +9,6 @@
#include <backends/imgui_impl_win32.h>
#include <imgui.h>
#include <Core/Memory/EngineArena.h>
#include <cstdio>
// Forward declare implementation functions from backends
@@ -24,34 +23,16 @@ namespace Juliet::ImGuiService
// Dedicated Paged Arena for ImGui
// Sharing the same underlying Engine Pool for blocks, but separate Arena chain.
MemoryArena g_ImGuiArena;
Arena* g_ImGuiArena = {};
void* ImGuiAllocWrapper(size_t size, void* /*user_data*/)
{
// Store size in header to allow Pop
// Align total size to 16 to avoid padding issues with ArenaPop LIFO check
size_t actualSize = size + 16;
actualSize = (actualSize + 15) & ~static_cast<size_t>(15);
// We do save the size when we push so we can pop exactly the size.
if (void* ptr = ArenaPush(&g_ImGuiArena, actualSize, 16, ConstString("ImGui")))
{
// Write size at start
*static_cast<size_t*>(ptr) = actualSize;
return static_cast<uint8*>(ptr) + 16;
}
return nullptr;
return ArenaPush(g_ImGuiArena, size, 8, false);
}
void ImGuiFreeWrapper(void* ptr, void* /*user_data*/)
void ImGuiFreeWrapper(void* /*ptr*/, void* /*user_data*/)
{
Assert(ptr);
uint8* originalPtr = static_cast<uint8*>(ptr) - 16;
size_t actualSize = *reinterpret_cast<size_t*>(originalPtr);
// Attempt LIFO Pop
ArenaPop(&g_ImGuiArena, originalPtr, actualSize);
// TODO : Free list of imgui elements.
}
} // namespace
@@ -60,7 +41,7 @@ namespace Juliet::ImGuiService
Assert(!g_Initialized);
// Initialize ImGui Arena using Engine Pool
MemoryArenaCreate(&g_ImGuiArena, GetEngineArena()->BackingPool);
g_ImGuiArena = ArenaAllocate();
// Setup Allocator
ImGui::SetAllocatorFunctions(ImGuiAllocWrapper, ImGuiFreeWrapper, nullptr);

10
Juliet/src/Core/Memory/EngineArena.h
View File

@@ -1,10 +0,0 @@
#pragma once
#include <Core/Memory/MemoryArena.h>
namespace Juliet
{
// Persistent engine-only arena.
// Not exported to the Game DLL.
MemoryArena* GetEngineArena();
} // namespace Juliet

15
Juliet/src/Core/Memory/MemoryArena.cpp
View File

@@ -44,6 +44,8 @@ namespace Juliet
arena->BasePosition = 0;
arena->Position = k_ArenaHeaderSize;
arena->CanReserveMore = params.CanReserveMore;
return arena;
}
@@ -65,6 +67,8 @@ namespace Juliet
// If allowed and needed, add a new block and chain it to the arena.
if (current->Reserved < positionPostPush /* flags : chaining allowed */)
{
Assert(arena->CanReserveMore);
Arena* newBlock = nullptr;
{
Arena* prev_block;
@@ -552,11 +556,9 @@ namespace Juliet
namespace
{
MemoryPool g_ScratchMemory;
MemoryPool g_EngineMemory;
MemoryPool g_GameMemory;
MemoryArena g_ScratchArena;
MemoryArena g_EngineArena;
MemoryArena g_GameArena;
// Backing Buffers
@@ -565,7 +567,6 @@ namespace Juliet
void* g_GameBuffer = nullptr;
constexpr size_t kScratchSize = Megabytes(64);
constexpr size_t kEngineSize = Megabytes(256);
constexpr size_t kGameSize = Megabytes(512);
void InitPool(MemoryPool* pool, void* buffer, size_t size)
@@ -589,10 +590,7 @@ namespace Juliet
{
return &g_ScratchArena;
}
MemoryArena* GetEngineArena()
{
return &g_EngineArena;
}
MemoryArena* GetGameArena()
{
return &g_GameArena;
@@ -606,15 +604,12 @@ namespace Juliet
void MemoryArenasInit()
{
g_ScratchBuffer = Malloc(kScratchSize);
g_EngineBuffer = Malloc(kEngineSize);
g_GameBuffer = Malloc(kGameSize);
InitPool(&g_ScratchMemory, g_ScratchBuffer, kScratchSize);
InitPool(&g_EngineMemory, g_EngineBuffer, kEngineSize);
InitPool(&g_GameMemory, g_GameBuffer, kGameSize);
MemoryArenaCreate(&g_ScratchArena, &g_ScratchMemory);
MemoryArenaCreate(&g_EngineArena, &g_EngineMemory);
MemoryArenaCreate(&g_GameArena, &g_GameMemory);
#if JULIET_DEBUG

2
Juliet/src/Engine/Debug/MemoryDebugger.cpp
View File

@@ -1,5 +1,4 @@
#include <Core/Common/String.h>
#include <Core/Memory/EngineArena.h>
#include <Engine/Debug/MemoryDebugger.h>
#include <imgui.h>
@@ -420,7 +419,6 @@ namespace Juliet::Debug
if (ImGui::Begin("Memory Debugger"))
{
DrawMemoryArena(ConstString("Game Arena"), *GetGameArena(), s_ConfirmedHovered, frameHovered);
DrawMemoryArena(ConstString("Engine Arena"), *GetEngineArena(), s_ConfirmedHovered, frameHovered);
}
ImGui::End();

7
Juliet/src/Graphics/D3D12/D3D12CommandList.cpp
View File

@@ -454,8 +454,11 @@ namespace Juliet::D3D12
return false;
}
ReturnSamplerHeapToPool(driver, commandList->Sampler_Heap);
commandList->Sampler_Heap = nullptr;
if (commandList->Sampler_Heap) [[likely]]
{
ReturnSamplerHeapToPool(driver, commandList->Sampler_Heap);
commandList->Sampler_Heap = nullptr;
}
commandList->CRB_SRV_UAV_Heap = nullptr;
// Clean up resource tracking

16
Juliet/src/Graphics/D3D12/D3D12Common.cpp
View File

@@ -4,8 +4,8 @@
#include <Graphics/D3D12/D3D12Common.h>
#include <Graphics/D3D12/D3D12GraphicsDevice.h>
#include <Graphics/D3D12/D3D12Includes.h>
#include <Graphics/D3D12/D3D12Utils.h>
// TODO: Convert the whole file to memory arenas
namespace Juliet::D3D12::Internal
{
namespace
@@ -25,8 +25,8 @@ namespace Juliet::D3D12::Internal
bool ExtendStagingDescriptorPool(NonNullPtr<D3D12Driver> driver, D3D12StagingDescriptorPool& pool)
{
D3D12DescriptorHeap* heap =
Internal::CreateDescriptorHeap(driver, pool.Heaps[0]->HeapType, kStagingHeapDescriptorExpectedCount, true);
D3D12DescriptorHeap* heap = Internal::CreateDescriptorHeap(driver, pool.Arena, pool.Heaps[0]->HeapType,
kStagingHeapDescriptorExpectedCount, true);
if (!heap)
{
return false;
@@ -49,13 +49,17 @@ namespace Juliet::D3D12::Internal
D3D12StagingDescriptorPool* CreateStagingDescriptorPool(NonNullPtr<D3D12Driver> driver, D3D12_DESCRIPTOR_HEAP_TYPE type)
{
D3D12DescriptorHeap* heap = CreateDescriptorHeap(driver, type, kStagingHeapDescriptorExpectedCount, true);
Arena* arena = ArenaAllocate();
D3D12DescriptorHeap* heap = CreateDescriptorHeap(driver, arena, type, kStagingHeapDescriptorExpectedCount, true);
if (!heap)
{
ArenaRelease(arena);
return nullptr;
}
auto pool = static_cast<D3D12StagingDescriptorPool*>(Calloc(1, sizeof(D3D12StagingDescriptorPool)));
auto pool = static_cast<D3D12StagingDescriptorPool*>(Calloc(1, sizeof(D3D12StagingDescriptorPool)));
pool->Arena = arena;
// First create the heaps
pool->HeapCount = 1;
@@ -113,6 +117,8 @@ namespace Juliet::D3D12::Internal
Free(pool->Heaps);
Free(pool->FreeDescriptors);
ArenaRelease(pool->Arena);
Free(pool.Get());
}
} // namespace Juliet::D3D12::Internal

9
Juliet/src/Graphics/D3D12/D3D12Common.h
View File

@@ -22,8 +22,9 @@ namespace Juliet::D3D12
struct D3D12StagingDescriptorPool
{
Arena* Arena;
Internal::D3D12DescriptorHeap** Heaps;
uint32 HeapCount;
uint32 HeapCount;
// Descriptor handles are owned by resources, so these can be thought of as descriptions of a free index within a heap.
uint32 FreeDescriptorCapacity;
@@ -35,9 +36,9 @@ namespace Juliet::D3D12
struct D3D12StagingDescriptor
{
D3D12StagingDescriptorPool* Pool;
Internal::D3D12DescriptorHeap* Heap;
D3D12_CPU_DESCRIPTOR_HANDLE CpuHandle;
uint32 CpuHandleIndex;
Internal::D3D12DescriptorHeap* Heap;
D3D12_CPU_DESCRIPTOR_HANDLE CpuHandle;
uint32 CpuHandleIndex;
};
namespace Internal

115
Juliet/src/Graphics/D3D12/D3D12DescriptorHeap.cpp
View File

@@ -1,26 +1,52 @@
#include <Core/Logging/LogManager.h>
#include <Core/Logging/LogTypes.h>
#include <Core/Memory/Allocator.h>
#include <Core/Memory/EngineArena.h>
#include <Graphics/D3D12/D3D12DescriptorHeap.h>
#include <Graphics/D3D12/D3D12GraphicsDevice.h>
#include <Graphics/D3D12/D3D12Utils.h>
namespace Juliet::D3D12::Internal
{
D3D12DescriptorHeap* CreateDescriptorHeap(NonNullPtr<D3D12Driver> driver, D3D12_DESCRIPTOR_HEAP_TYPE type, uint32 count, bool isStaging)
void CreateDescriptorHeapPool(NonNullPtr<D3D12Driver> driver, D3D12DescriptorHeapPool& heapPool,
D3D12_DESCRIPTOR_HEAP_TYPE type, uint32 count)
{
auto heap = ArenaPushType<D3D12DescriptorHeap>(GetEngineArena(), ConstString("D3D12DescriptorHeap"));
if (!heap)
// Heap pool is just single linked list of free elements
constexpr size_t kInitialCapacity = 4;
heapPool.Arena = ArenaAllocate();
heapPool.FirstFreeDescriptorHeap = nullptr;
// Pre allocate 4
for (uint32 i = 0; i < kInitialCapacity; ++i)
{
return nullptr;
D3D12DescriptorHeap* descriptorHeap = CreateDescriptorHeap(driver, heapPool.Arena, type, count, false);
descriptorHeap->Next = heapPool.FirstFreeDescriptorHeap;
heapPool.FirstFreeDescriptorHeap = descriptorHeap;
}
}
void DestroyDescriptorHeapPool(D3D12DescriptorHeapPool& heapPool)
{
D3D12DescriptorHeap* current = heapPool.FirstFreeDescriptorHeap;
while (current != nullptr)
{
D3D12DescriptorHeap* next = current->Next;
DestroyDescriptorHeap(current);
current = next;
}
ArenaRelease(heapPool.Arena);
}
D3D12DescriptorHeap* CreateDescriptorHeap(NonNullPtr<D3D12Driver> driver, NonNullPtr<Arena> arena,
D3D12_DESCRIPTOR_HEAP_TYPE type, uint32 count, bool isStaging)
{
D3D12DescriptorHeap* heap = ArenaPushStruct<D3D12DescriptorHeap>(arena.Get());
Assert(heap);
heap->CurrentDescriptorIndex = 0;
heap->FreeIndicesCapacity = 16;
heap->FreeIndicesCount = 0;
heap->FreeIndices = ArenaPushArray<uint32>(GetEngineArena(), heap->FreeIndicesCapacity,
ConstString("D3D12DescriptorHeap/FreeIndices"));
heap->FreeIndices.Create();
heap->FreeIndices.Resize(16);
heap->CurrentFreeIndex = 0;
D3D12_DESCRIPTOR_HEAP_DESC heapDesc;
heapDesc.NumDescriptors = count;
@@ -54,23 +80,21 @@ namespace Juliet::D3D12::Internal
void DestroyDescriptorHeap(NonNullPtr<D3D12DescriptorHeap> heap)
{
heap->FreeIndices.Destroy();
if (heap->Handle)
{
heap->Handle->Release();
}
// TODO: should not free because its on an arena, but need to use arena properly
// SafeFree(heap->FreeIndices);
// Free(heap.Get());
}
bool AssignDescriptor(D3D12DescriptorHeap* heap, D3D12Descriptor& outDescriptor)
{
uint32 index = UINT32_MAX;
if (heap->FreeIndicesCount > 0)
if (heap->CurrentFreeIndex > 0)
{
heap->FreeIndicesCount -= 1;
index = heap->FreeIndices[heap->FreeIndicesCount];
heap->CurrentFreeIndex -= 1;
index = heap->FreeIndices[heap->CurrentFreeIndex];
}
else if (heap->CurrentDescriptorIndex < heap->MaxDescriptors)
{
@@ -102,55 +126,42 @@ namespace Juliet::D3D12::Internal
D3D12DescriptorHeap* heap = descriptor.Heap;
if (heap->FreeIndicesCount >= heap->FreeIndicesCapacity)
if (heap->CurrentFreeIndex >= heap->FreeIndices.Count)
{
size_t oldCapacity = heap->FreeIndicesCapacity;
heap->FreeIndicesCapacity *= 2;
heap->FreeIndices = ArenaRealloc<uint32>(GetEngineArena(), heap->FreeIndices, oldCapacity,
heap->FreeIndicesCapacity, ConstString("FreeIndices"));
}
heap->FreeIndices[heap->FreeIndicesCount] = descriptor.Index;
heap->FreeIndicesCount++;
}
D3D12DescriptorHeap* AcquireSamplerHeapFromPool(NonNullPtr<D3D12Driver> d3d12Driver, DescriptorHeapCreator creator)
{
D3D12DescriptorHeap* result;
D3D12DescriptorHeapPool* pool = &d3d12Driver->SamplerHeapPool;
if (pool->Count > 0)
{
result = pool->Heaps[pool->Count - 1];
pool->Count -= 1;
heap->FreeIndices.PushBack(descriptor.Index);
}
else
{
result = creator(d3d12Driver, D3D12_DESCRIPTOR_HEAP_TYPE_SAMPLER, GPUDriver::kSampler_HeapDescriptorCount, false);
heap->FreeIndices[heap->CurrentFreeIndex] = descriptor.Index;
heap->CurrentFreeIndex++;
}
}
D3D12DescriptorHeap* AcquireSamplerHeapFromPool(NonNullPtr<D3D12Driver> d3d12Driver)
{
D3D12DescriptorHeapPool& pool = d3d12Driver->SamplerHeapPool;
D3D12DescriptorHeap* result = pool.FirstFreeDescriptorHeap;
if (result)
{
pool.FirstFreeDescriptorHeap = pool.FirstFreeDescriptorHeap->Next;
}
else
{
result = CreateDescriptorHeap(d3d12Driver, pool.Arena, D3D12_DESCRIPTOR_HEAP_TYPE_SAMPLER,
GPUDriver::kSampler_HeapDescriptorCount, false);
}
return result;
}
void ReturnSamplerHeapToPool(NonNullPtr<D3D12Driver> d3d12Driver, D3D12DescriptorHeap* heap)
void ReturnSamplerHeapToPool(NonNullPtr<D3D12Driver> d3d12Driver, NonNullPtr<D3D12DescriptorHeap> heap)
{
if (heap == nullptr)
{
return;
}
D3D12DescriptorHeapPool* pool = &d3d12Driver->SamplerHeapPool;
D3D12DescriptorHeapPool& pool = d3d12Driver->SamplerHeapPool;
heap->CurrentDescriptorIndex = 0;
if (pool->Count >= pool->Capacity)
{
size_t oldCapacity = pool->Capacity;
pool->Capacity *= 2;
pool->Heaps = ArenaRealloc(GetEngineArena(), pool->Heaps, oldCapacity, pool->Capacity, ConstString("Heaps"));
}
pool->Heaps[pool->Count] = heap;
pool->Count += 1;
heap->Next = pool.FirstFreeDescriptorHeap;
pool.FirstFreeDescriptorHeap = heap;
}
} // namespace Juliet::D3D12::Internal

31
Juliet/src/Graphics/D3D12/D3D12DescriptorHeap.h
View File

@@ -1,6 +1,7 @@
#pragma once
#include <Core/Common/NonNullPtr.h>
#include <Core/Networking/NetworkPacket.h>
#include <Graphics/D3D12/D3D12Includes.h>
// Forward declare
@@ -14,6 +15,7 @@ namespace Juliet::D3D12::Internal
// https://learn.microsoft.com/en-us/windows/win32/direct3d12/descriptor-heaps
struct D3D12DescriptorHeap
{
D3D12DescriptorHeap* Next;
ID3D12DescriptorHeap* Handle;
D3D12_DESCRIPTOR_HEAP_TYPE HeapType;
D3D12_CPU_DESCRIPTOR_HANDLE DescriptorHeapCPUStart;
@@ -22,11 +24,10 @@ namespace Juliet::D3D12::Internal
uint32 DescriptorSize;
uint32 CurrentDescriptorIndex; // only used by GPU heaps
uint32* FreeIndices;
uint32 FreeIndicesCapacity;
uint32 FreeIndicesCount;
VectorArena<uint32> FreeIndices;
index_t CurrentFreeIndex;
bool Staging : 1;
bool Staging : 1;
};
struct D3D12Descriptor
@@ -39,20 +40,24 @@ namespace Juliet::D3D12::Internal
struct D3D12DescriptorHeapPool
{
D3D12DescriptorHeap** Heaps;
size_t Capacity;
size_t Count;
Arena* Arena;
D3D12DescriptorHeap* FirstFreeDescriptorHeap;
};
using DescriptorHeapCreator = D3D12DescriptorHeap* (*)(NonNullPtr<D3D12Driver>, D3D12_DESCRIPTOR_HEAP_TYPE, uint32, bool);
using DescriptorHeapCreator = D3D12DescriptorHeap* (*)(NonNullPtr<D3D12Driver>, D3D12DescriptorHeapPool& heapPool,
D3D12_DESCRIPTOR_HEAP_TYPE, uint32, bool);
extern D3D12DescriptorHeap* CreateDescriptorHeap(NonNullPtr<D3D12Driver> driver,
D3D12_DESCRIPTOR_HEAP_TYPE type, uint32 count, bool isStaging);
extern void CreateDescriptorHeapPool(NonNullPtr<D3D12Driver> driver, D3D12DescriptorHeapPool& heapPool,
D3D12_DESCRIPTOR_HEAP_TYPE type, uint32 count);
extern void DestroyDescriptorHeapPool(D3D12DescriptorHeapPool& pool);
extern D3D12DescriptorHeap* CreateDescriptorHeap(NonNullPtr<D3D12Driver> driver, NonNullPtr<Arena> arena,
D3D12_DESCRIPTOR_HEAP_TYPE type, uint32 count, bool isStaging);
extern void DestroyDescriptorHeap(NonNullPtr<D3D12DescriptorHeap> heap);
extern D3D12DescriptorHeap* AcquireSamplerHeapFromPool(NonNullPtr<D3D12Driver> d3d12Driver, DescriptorHeapCreator creator = CreateDescriptorHeap);
extern void ReturnSamplerHeapToPool(NonNullPtr<D3D12Driver> d3d12Driver, D3D12DescriptorHeap* heap);
extern D3D12DescriptorHeap* AcquireSamplerHeapFromPool(NonNullPtr<D3D12Driver> d3d12Driver);
extern void ReturnSamplerHeapToPool(NonNullPtr<D3D12Driver> d3d12Driver, NonNullPtr<D3D12DescriptorHeap> heap);
extern bool AssignDescriptor(D3D12DescriptorHeap* heap, D3D12Descriptor& outDescriptor);
extern void ReleaseDescriptor(const D3D12Descriptor& descriptor);
} // namespace Juliet::D3D12
} // namespace Juliet::D3D12::Internal

55
Juliet/src/Graphics/D3D12/D3D12GraphicsDevice.cpp
View File

@@ -3,7 +3,6 @@
#include <Core/Logging/LogManager.h>
#include <Core/Logging/LogTypes.h>
#include <Core/Memory/Allocator.h>
#include <Core/Memory/EngineArena.h>
#include <Graphics/D3D12/D3D12Buffer.h>
#include <Graphics/D3D12/D3D12CommandList.h>
#include <Graphics/D3D12/D3D12DescriptorHeap.h>
@@ -471,22 +470,7 @@ namespace Juliet::D3D12
}
}
auto DestroyDescriptorHeapPool = [](Internal::D3D12DescriptorHeapPool& heapPool)
{
if (heapPool.Heaps)
{
for (uint32 i = 0; i < heapPool.Count; ++i)
{
if (heapPool.Heaps[i])
{
Internal::DestroyDescriptorHeap(heapPool.Heaps[i]);
heapPool.Heaps[i] = nullptr;
}
}
// SafeFree(heapPool.Heaps); // Allocated with Arena, do not free.
}
};
DestroyDescriptorHeapPool(driver->SamplerHeapPool);
Internal::DestroyDescriptorHeapPool(driver->SamplerHeapPool);
// Release command buffers
for (uint32 i = 0; i < driver->AvailableCommandListCount; i += 1)
@@ -571,6 +555,7 @@ namespace Juliet::D3D12
driver->D3D12SerializeVersionedRootSignatureFct = nullptr;
ArenaRelease(driver->DriverArena);
Free(driver.Get());
}
@@ -745,6 +730,9 @@ namespace Juliet::D3D12
{
auto driver = static_cast<D3D12Driver*>(Calloc(1, sizeof(D3D12Driver)));
// TODO : Convert everything to arena
driver->DriverArena = ArenaAllocate();
#if JULIET_DEBUG
#ifdef IDXGIINFOQUEUE_SUPPORTED
if (enableDebug)
@@ -1023,32 +1011,8 @@ namespace Juliet::D3D12
}
}
// Other Descriptor pools
auto CreateDescriptorPool = [&](Internal::D3D12DescriptorHeapPool& heapPool,
D3D12_DESCRIPTOR_HEAP_TYPE type, uint32 count) -> bool
{
heapPool.Capacity = 4;
heapPool.Count = 4;
heapPool.Heaps = ArenaPushArray<Internal::D3D12DescriptorHeap*>(GetEngineArena(), heapPool.Capacity,
ConstString("DescriptorHeap"));
for (uint32 i = 0; i < heapPool.Capacity; ++i)
{
heapPool.Heaps[i] = Internal::CreateDescriptorHeap(driver, type, count, false);
if (heapPool.Heaps[i] == nullptr)
{
return false;
}
}
return true;
};
if (!CreateDescriptorPool(driver->SamplerHeapPool, D3D12_DESCRIPTOR_HEAP_TYPE_SAMPLER, GPUDriver::kSampler_HeapDescriptorCount))
{
DestroyDriver_Internal(driver);
return nullptr;
}
CreateDescriptorHeapPool(driver, driver->SamplerHeapPool, D3D12_DESCRIPTOR_HEAP_TYPE_SAMPLER,
GPUDriver::kSampler_HeapDescriptorCount);
// Deferred dispose vectors
driver->GraphicsPipelinesToDisposeCapacity = 4;
@@ -1125,8 +1089,9 @@ namespace Juliet::D3D12
driver->GraphicsDevice = device;
// Create Global Bindless Heap that stays alive for the driver whole lifetime
driver->BindlessDescriptorHeap = Internal::CreateDescriptorHeap(driver, D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV,
GPUDriver::kCBV_SRV_UAV_HeapDescriptorCount, false);
driver->BindlessDescriptorHeap =
Internal::CreateDescriptorHeap(driver, driver->DriverArena, D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV,
GPUDriver::kCBV_SRV_UAV_HeapDescriptorCount, false);
return device;
}

13
Juliet/src/Graphics/GraphicsDevice.h
View File

@@ -30,6 +30,8 @@ namespace Juliet
struct GPUDriver
{
Arena* DriverArena = {};
static constexpr uint8 kMaxFramesInFlight = 3;
static constexpr uint8 kMaxColorTargetInfo = 4;
static constexpr uint8 kMaxUniformBuffersPerStage = 4;
@@ -74,9 +76,6 @@ namespace Juliet
void (*DrawIndexedPrimitives)(NonNullPtr<CommandList> commandList, uint32 numIndices, uint32 numInstances,
uint32 firstIndex, uint32 vertexOffset, uint32 firstInstance);
void (*SetPushConstants)(NonNullPtr<CommandList> commandList, ShaderStage stage, uint32 rootParameterIndex,
uint32 numConstants, const void* constants);
@@ -108,10 +107,10 @@ namespace Juliet
void* (*MapGraphicsTransferBuffer)(NonNullPtr<GPUDriver> driver, NonNullPtr<GraphicsTransferBuffer> buffer);
void (*UnmapGraphicsTransferBuffer)(NonNullPtr<GPUDriver> driver, NonNullPtr<GraphicsTransferBuffer> buffer);
void (*CopyBuffer)(NonNullPtr<CommandList> commandList, NonNullPtr<GraphicsBuffer> dst,
NonNullPtr<GraphicsTransferBuffer> src, size_t size, size_t dstOffset, size_t srcOffset);
void (*CopyBufferToTexture)(NonNullPtr<CommandList> commandList, NonNullPtr<Texture> dst,
NonNullPtr<GraphicsTransferBuffer> src); // Assume full copy for now
void (*CopyBuffer)(NonNullPtr<CommandList> commandList, NonNullPtr<GraphicsBuffer> dst,
NonNullPtr<GraphicsTransferBuffer> src, size_t size, size_t dstOffset, size_t srcOffset);
void (*CopyBufferToTexture)(NonNullPtr<CommandList> commandList, NonNullPtr<Texture> dst,
NonNullPtr<GraphicsTransferBuffer> src); // Assume full copy for now
void (*TransitionBufferToReadable)(NonNullPtr<CommandList> commandList, NonNullPtr<GraphicsBuffer> buffer);
uint32 (*GetDescriptorIndex)(NonNullPtr<GraphicsDevice> device, NonNullPtr<GraphicsBuffer> buffer);