Improvements in JSON dump - now prints Flags, Layout, CreationFrameIndex, more detailed Type.
Added function Allocator::SetCurrentFrameIndex.
diff --git a/src/Common.h b/src/Common.h
index 3495357..794c572 100644
--- a/src/Common.h
+++ b/src/Common.h
@@ -22,11 +22,12 @@
#pragma once
+#define WIN32_LEAN_AND_MEAN
+#define NOMINMAX
+
#include <dxgi1_4.h>
#include <d3d12.h>
-#define WIN32_LEAN_AND_MEAN
-#define NOMINMAX
#include <Windows.h>
#include <atlbase.h> // For CComPtr
diff --git a/src/D3D12MemAlloc.cpp b/src/D3D12MemAlloc.cpp
index 14e008f..931fbb7 100644
--- a/src/D3D12MemAlloc.cpp
+++ b/src/D3D12MemAlloc.cpp
@@ -842,6 +842,7 @@
void ContinueString(LPCWSTR pStr);
void ContinueString(UINT num);
void ContinueString(UINT64 num);
+ void AddAllocationToObject(const Allocation& alloc);
// void ContinueString_Pointer(const void* ptr);
void EndString(LPCWSTR pStr = NULL);
@@ -1105,6 +1106,52 @@
}
}
+void JsonWriter::AddAllocationToObject(const Allocation& alloc)
+{
+ WriteString(L"Type");
+ switch (alloc.m_ResourceDimension) {
+ case D3D12_RESOURCE_DIMENSION_UNKNOWN:
+ WriteString(L"UNKNOWN");
+ break;
+ case D3D12_RESOURCE_DIMENSION_BUFFER:
+ WriteString(L"BUFFER");
+ break;
+ case D3D12_RESOURCE_DIMENSION_TEXTURE1D:
+ WriteString(L"TEXTURE1D");
+ break;
+ case D3D12_RESOURCE_DIMENSION_TEXTURE2D:
+ WriteString(L"TEXTURE2D");
+ break;
+ case D3D12_RESOURCE_DIMENSION_TEXTURE3D:
+ WriteString(L"TEXTURE3D");
+ break;
+ default: D3D12MA_ASSERT(0); break;
+ }
+ WriteString(L"Size");
+ WriteNumber(alloc.GetSize());
+ LPCWSTR name = alloc.GetName();
+ if(name != NULL)
+ {
+ WriteString(L"Name");
+ WriteString(name);
+ }
+ if(alloc.m_ResourceFlags)
+ {
+ WriteString(L"Flags");
+ WriteNumber((UINT)alloc.m_ResourceFlags);
+ }
+ if(alloc.m_TextureLayout)
+ {
+ WriteString(L"Layout");
+ WriteNumber((UINT)alloc.m_TextureLayout);
+ }
+ if(alloc.m_CreationFrameIndex)
+ {
+ WriteString(L"CreationFrameIndex");
+ WriteNumber(alloc.m_CreationFrameIndex);
+ }
+}
+
////////////////////////////////////////////////////////////////////////////////
// Private class PoolAllocator
@@ -2073,6 +2120,10 @@
// Allocation object must be deleted externally afterwards.
void FreeHeapMemory(Allocation* allocation);
+ void SetCurrentFrameIndex(UINT frameIndex);
+
+ UINT GetCurrentFrameIndex() const { return m_CurrentFrameIndex.load(); }
+
void CalculateStats(Stats& outStats);
void BuildStatsString(WCHAR** ppStatsString, BOOL DetailedMap);
@@ -2092,6 +2143,7 @@
ID3D12Device* m_Device;
UINT64 m_PreferredBlockSize;
ALLOCATION_CALLBACKS m_AllocationCallbacks;
+ D3D12MA_ATOMIC_UINT32 m_CurrentFrameIndex;
D3D12_FEATURE_DATA_D3D12_OPTIONS m_D3D12Options;
@@ -2686,25 +2738,19 @@
json.BeginObject(true);
json.WriteString(L"Offset");
json.WriteNumber(suballoc.offset);
- json.WriteString(L"Type");
if(suballoc.type == SUBALLOCATION_TYPE_FREE)
{
+ json.WriteString(L"Type");
json.WriteString(L"FREE");
+ json.WriteString(L"Size");
+ json.WriteNumber(suballoc.size);
}
else
{
- json.WriteString(L"ALLOCATION");
const Allocation* const alloc = suballoc.allocation;
D3D12MA_ASSERT(alloc);
- const WCHAR* const name = alloc->GetName();
- if(name != NULL)
- {
- json.WriteString(L"Name");
- json.WriteString(name);
- }
+ json.AddAllocationToObject(*alloc);
}
- json.WriteString(L"Size");
- json.WriteNumber(suballoc.size);
json.EndObject();
}
json.EndArray();
@@ -3195,7 +3241,8 @@
m_UseMutex((desc.Flags & ALLOCATOR_FLAG_SINGLETHREADED) == 0),
m_Device(desc.pDevice),
m_PreferredBlockSize(desc.PreferredBlockSize != 0 ? desc.PreferredBlockSize : D3D12MA_DEFAULT_BLOCK_SIZE),
- m_AllocationCallbacks(allocationCallbacks)
+ m_AllocationCallbacks(allocationCallbacks),
+ m_CurrentFrameIndex(0)
// Below this line don't use allocationCallbacks but m_AllocationCallbacks!!!
{
// desc.pAllocationCallbacks intentionally ignored here, preprocessed by CreateAllocator.
@@ -3334,7 +3381,7 @@
(void**)&res);
if(SUCCEEDED(hr))
{
- (*ppAllocation)->SetResource(res);
+ (*ppAllocation)->SetResource(res, pResourceDesc);
if(ppvResource != NULL)
{
res->AddRef();
@@ -3447,7 +3494,7 @@
{
Allocation* alloc = D3D12MA_NEW(m_AllocationCallbacks, Allocation)();
alloc->InitCommitted(this, resAllocInfo.SizeInBytes, pAllocDesc->HeapType);
- alloc->SetResource(res);
+ alloc->SetResource(res, pResourceDesc);
*ppAllocation = alloc;
if(ppvResource != NULL)
@@ -3654,6 +3701,11 @@
allocation->m_Heap.heap->Release();
}
+void AllocatorPimpl::SetCurrentFrameIndex(UINT frameIndex)
+{
+ m_CurrentFrameIndex.store(frameIndex);
+}
+
void AllocatorPimpl::CalculateStats(Stats& outStats)
{
// Init stats
@@ -3832,16 +3884,7 @@
D3D12MA_ASSERT(alloc);
json.BeginObject(true);
- json.WriteString(L"Type");
- json.WriteString(L"ALLOCATION");
- json.WriteString(L"Size");
- json.WriteNumber(alloc->GetSize());
- LPCWSTR name = alloc->GetName();
- if(name != NULL)
- {
- json.WriteString(L"Name");
- json.WriteString(name);
- }
+ json.AddAllocationToObject(*alloc);
json.EndObject();
}
json.EndArray();
@@ -3961,16 +4004,22 @@
void Allocation::InitCommitted(AllocatorPimpl* allocator, UINT64 size, D3D12_HEAP_TYPE heapType)
{
+ D3D12MA_ASSERT(allocator);
m_Allocator = allocator;
m_Type = TYPE_COMMITTED;
m_Size = size;
m_Resource = NULL;
m_Name = NULL;
m_Committed.heapType = heapType;
+ m_CreationFrameIndex = allocator->GetCurrentFrameIndex();
+ m_ResourceDimension = D3D12_RESOURCE_DIMENSION_UNKNOWN;
+ m_ResourceFlags = D3D12_RESOURCE_FLAG_NONE;
+ m_TextureLayout = D3D12_TEXTURE_LAYOUT_UNKNOWN;
}
void Allocation::InitPlaced(AllocatorPimpl* allocator, UINT64 size, UINT64 offset, UINT64 alignment, NormalBlock* block)
{
+ D3D12MA_ASSERT(allocator);
m_Allocator = allocator;
m_Type = TYPE_PLACED;
m_Size = size;
@@ -3978,22 +4027,35 @@
m_Name = NULL;
m_Placed.offset = offset;
m_Placed.block = block;
+ m_CreationFrameIndex = allocator->GetCurrentFrameIndex();
+ m_ResourceDimension = D3D12_RESOURCE_DIMENSION_UNKNOWN;
+ m_ResourceFlags = D3D12_RESOURCE_FLAG_NONE;
+ m_TextureLayout = D3D12_TEXTURE_LAYOUT_UNKNOWN;
}
void Allocation::InitHeap(AllocatorPimpl* allocator, UINT64 size, D3D12_HEAP_TYPE heapType, ID3D12Heap* heap)
{
+ D3D12MA_ASSERT(allocator);
m_Allocator = allocator;
m_Type = TYPE_HEAP;
m_Size = size;
m_Name = NULL;
m_Heap.heapType = heapType;
m_Heap.heap = heap;
+ m_CreationFrameIndex = allocator->GetCurrentFrameIndex();
+ m_ResourceDimension = D3D12_RESOURCE_DIMENSION_UNKNOWN;
+ m_ResourceFlags = D3D12_RESOURCE_FLAG_NONE;
+ m_TextureLayout = D3D12_TEXTURE_LAYOUT_UNKNOWN;
}
-void Allocation::SetResource(ID3D12Resource* resource)
+void Allocation::SetResource(ID3D12Resource* resource, const D3D12_RESOURCE_DESC* pResourceDesc)
{
D3D12MA_ASSERT(m_Resource == NULL);
+ D3D12MA_ASSERT(pResourceDesc);
m_Resource = resource;
+ m_ResourceDimension = pResourceDesc->Dimension;
+ m_ResourceFlags = pResourceDesc->Flags;
+ m_TextureLayout = pResourceDesc->Layout;
}
void Allocation::FreeName()
@@ -4076,6 +4138,12 @@
return m_Pimpl->AllocateMemory(pAllocDesc, heapFlags, pAllocInfo, ppAllocation);
}
+void Allocator::SetCurrentFrameIndex(UINT frameIndex)
+{
+ D3D12MA_DEBUG_GLOBAL_MUTEX_LOCK
+ m_Pimpl->SetCurrentFrameIndex(frameIndex);
+}
+
void Allocator::CalculateStats(Stats* pStats)
{
D3D12MA_ASSERT(pStats);
diff --git a/src/D3D12MemAlloc.h b/src/D3D12MemAlloc.h
index bffec84..c78a900 100644
--- a/src/D3D12MemAlloc.h
+++ b/src/D3D12MemAlloc.h
@@ -347,6 +347,7 @@
class AllocatorPimpl;
class NormalBlock;
class BlockVector;
+class JsonWriter;
/// \endcond
/// Pointer to custom callback function that allocates CPU memory.
@@ -474,6 +475,7 @@
private:
friend class AllocatorPimpl;
friend class BlockVector;
+ friend class JsonWriter;
template<typename T> friend void D3D12MA_DELETE(const ALLOCATION_CALLBACKS&, T*);
AllocatorPimpl* m_Allocator;
@@ -486,6 +488,10 @@
} m_Type;
UINT64 m_Size;
ID3D12Resource* m_Resource;
+ D3D12_RESOURCE_DIMENSION m_ResourceDimension;
+ D3D12_RESOURCE_FLAGS m_ResourceFlags;
+ D3D12_TEXTURE_LAYOUT m_TextureLayout;
+ UINT m_CreationFrameIndex;
wchar_t* m_Name;
union
@@ -513,7 +519,7 @@
void InitCommitted(AllocatorPimpl* allocator, UINT64 size, D3D12_HEAP_TYPE heapType);
void InitPlaced(AllocatorPimpl* allocator, UINT64 size, UINT64 offset, UINT64 alignment, NormalBlock* block);
void InitHeap(AllocatorPimpl* allocator, UINT64 size, D3D12_HEAP_TYPE heapType, ID3D12Heap* heap);
- void SetResource(ID3D12Resource* resource);
+ void SetResource(ID3D12Resource* resource, const D3D12_RESOURCE_DESC* pResourceDesc);
void FreeName();
D3D12MA_CLASS_NO_COPY(Allocation)
@@ -675,6 +681,12 @@
const D3D12_RESOURCE_ALLOCATION_INFO* pAllocInfo,
Allocation** ppAllocation);
+ /** \brief Sets the index of the current frame.
+
+ This function is used to set the frame index in the allocator when a new game frame begins.
+ */
+ void SetCurrentFrameIndex(UINT frameIndex);
+
/** \brief Retrieves statistics from the current state of the allocator.
*/
void CalculateStats(Stats* pStats);
diff --git a/src/D3D12Sample.cpp b/src/D3D12Sample.cpp
index 5348827..9d8032d 100644
--- a/src/D3D12Sample.cpp
+++ b/src/D3D12Sample.cpp
@@ -1392,6 +1392,15 @@
ExecuteTests();
break;
+ case 'J':
+ {
+ WCHAR* statsString = NULL;
+ g_Allocator->BuildStatsString(&statsString, TRUE);
+ wprintf(L"%s\n", statsString);
+ g_Allocator->FreeStatsString(statsString);
+ }
+ break;
+
case VK_ESCAPE:
PostMessage(g_Wnd, WM_CLOSE, 0, 0);
break;
diff --git a/src/Tests.cpp b/src/Tests.cpp
index 6ae268e..2e69e95 100644
--- a/src/Tests.cpp
+++ b/src/Tests.cpp
@@ -20,8 +20,8 @@
// THE SOFTWARE.
//
-#include "Tests.h"
#include "Common.h"
+#include "Tests.h"
#include <thread>
extern ID3D12GraphicsCommandList* BeginCommandList();
@@ -91,6 +91,54 @@
return true;
}
+static void TestFrameIndexAndJson(const TestContext& ctx)
+{
+ const UINT64 bufSize = 32ull * 1024;
+
+ D3D12MA::ALLOCATION_DESC allocDesc = {};
+ allocDesc.HeapType = D3D12_HEAP_TYPE_UPLOAD;
+ allocDesc.Flags = D3D12MA::ALLOCATION_FLAG_COMMITTED;
+
+ D3D12_RESOURCE_DESC resourceDesc;
+ FillResourceDescForBuffer(resourceDesc, bufSize);
+
+ const UINT BEGIN_INDEX = 10;
+ const UINT END_INDEX = 20;
+ UINT frameIndex = 0;
+ for (UINT frameIndex = BEGIN_INDEX; frameIndex < END_INDEX; ++frameIndex)
+ {
+ ctx.allocator->SetCurrentFrameIndex(frameIndex);
+ D3D12MA::Allocation* alloc = nullptr;
+ CHECK_HR(ctx.allocator->CreateResource(
+ &allocDesc,
+ &resourceDesc,
+ D3D12_RESOURCE_STATE_GENERIC_READ,
+ NULL,
+ &alloc,
+ __uuidof(ID3D12Resource),
+ NULL));
+
+ WCHAR* statsString;
+ ctx.allocator->BuildStatsString(&statsString, TRUE);
+ const UINT BUFFER_SIZE = 1024;
+ WCHAR buffer[BUFFER_SIZE];
+ for (UINT testIndex = BEGIN_INDEX; testIndex < END_INDEX; ++testIndex)
+ {
+ swprintf(buffer, BUFFER_SIZE, L"\"CreationFrameIndex\": %u", testIndex);
+ if (testIndex == frameIndex)
+ {
+ CHECK_BOOL(wcsstr(statsString, buffer) != NULL);
+ }
+ else
+ {
+ CHECK_BOOL(wcsstr(statsString, buffer) == NULL);
+ }
+ }
+ ctx.allocator->FreeStatsString(statsString);
+ alloc->Release();
+ }
+}
+
static void TestCommittedResourcesAndJson(const TestContext& ctx)
{
wprintf(L"Test committed resources and JSON\n");
@@ -261,6 +309,77 @@
renderTargetRes.allocation.reset(alloc);
}
+static void TestAliasingMemory(const TestContext& ctx)
+{
+ wprintf(L"Test aliasing memory\n");
+
+ D3D12MA::ALLOCATION_DESC allocDesc = {};
+ allocDesc.HeapType = D3D12_HEAP_TYPE_DEFAULT;
+
+ D3D12_RESOURCE_DESC resourceDesc1 = {};
+ resourceDesc1.Dimension = D3D12_RESOURCE_DIMENSION_TEXTURE2D;
+ resourceDesc1.Alignment = 0;
+ resourceDesc1.Width = 1920;
+ resourceDesc1.Height = 1080;
+ resourceDesc1.DepthOrArraySize = 1;
+ resourceDesc1.MipLevels = 1;
+ resourceDesc1.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
+ resourceDesc1.SampleDesc.Count = 1;
+ resourceDesc1.SampleDesc.Quality = 0;
+ resourceDesc1.Layout = D3D12_TEXTURE_LAYOUT_UNKNOWN;
+ resourceDesc1.Flags = D3D12_RESOURCE_FLAG_ALLOW_RENDER_TARGET | D3D12_RESOURCE_FLAG_ALLOW_UNORDERED_ACCESS;
+
+ D3D12_RESOURCE_DESC resourceDesc2 = {};
+ resourceDesc2.Dimension = D3D12_RESOURCE_DIMENSION_TEXTURE2D;
+ resourceDesc2.Alignment = 0;
+ resourceDesc2.Width = 1024;
+ resourceDesc2.Height = 1024;
+ resourceDesc2.DepthOrArraySize = 1;
+ resourceDesc2.MipLevels = 0;
+ resourceDesc2.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
+ resourceDesc2.SampleDesc.Count = 1;
+ resourceDesc2.SampleDesc.Quality = 0;
+ resourceDesc2.Layout = D3D12_TEXTURE_LAYOUT_UNKNOWN;
+ resourceDesc2.Flags = D3D12_RESOURCE_FLAG_ALLOW_RENDER_TARGET;
+
+ const D3D12_RESOURCE_ALLOCATION_INFO allocInfo1 = ctx.device->GetResourceAllocationInfo(0, 1, &resourceDesc1);
+ const D3D12_RESOURCE_ALLOCATION_INFO allocInfo2 = ctx.device->GetResourceAllocationInfo(0, 1, &resourceDesc2);
+
+ D3D12_RESOURCE_ALLOCATION_INFO allocInfo = {};
+ allocInfo.Alignment = std::max(allocInfo1.Alignment, allocInfo2.Alignment);
+ allocInfo.SizeInBytes = std::max(allocInfo1.SizeInBytes, allocInfo2.SizeInBytes);
+
+ D3D12MA::Allocation* allocPtr = NULL;
+ CHECK_HR( ctx.allocator->AllocateMemory(
+ &allocDesc,
+ D3D12_HEAP_FLAG_ALLOW_ONLY_RT_DS_TEXTURES,
+ &allocInfo,
+ &allocPtr) );
+ AllocationUniquePtr alloc(allocPtr);
+ CHECK_BOOL(allocPtr != NULL && allocPtr->GetHeap() != NULL);
+
+ ID3D12Resource* resPtr = NULL;
+ CHECK_HR( ctx.device->CreatePlacedResource(
+ alloc->GetHeap(),
+ alloc->GetOffset(),
+ &resourceDesc1,
+ D3D12_RESOURCE_STATE_COMMON,
+ NULL, // pOptimizedClearValue
+ IID_PPV_ARGS(&resPtr)) );
+ CComPtr<ID3D12Resource> res1(resPtr);
+ CHECK_BOOL(resPtr != NULL);
+
+ CHECK_HR( ctx.device->CreatePlacedResource(
+ alloc->GetHeap(),
+ alloc->GetOffset(),
+ &resourceDesc2,
+ D3D12_RESOURCE_STATE_COMMON,
+ NULL, // pOptimizedClearValue
+ IID_PPV_ARGS(&resPtr)) );
+ CComPtr<ID3D12Resource> res2(resPtr);
+ CHECK_BOOL(resPtr != NULL);
+}
+
static void TestMapping(const TestContext& ctx)
{
wprintf(L"Test mapping\n");
@@ -632,8 +751,10 @@
static void TestGroupBasics(const TestContext& ctx)
{
+ TestFrameIndexAndJson(ctx);
TestCommittedResourcesAndJson(ctx);
TestPlacedResources(ctx);
+ TestAliasingMemory(ctx);
TestMapping(ctx);
TestStats(ctx);
TestTransfer(ctx);
