Merge branch 'master' into WasZeroInitialized
diff --git a/src/D3D12MemAlloc.cpp b/src/D3D12MemAlloc.cpp
index 6c55b6e..7e8b2a4 100644
--- a/src/D3D12MemAlloc.cpp
+++ b/src/D3D12MemAlloc.cpp
@@ -86,14 +86,15 @@
#define D3D12MA_DEFAULT_BLOCK_SIZE (256ull * 1024 * 1024)
#endif
-#ifndef D3D12MA_EXTRA_DEFAULT_TYPE_HEAP_FLAGS
+#ifndef D3D12MA_ALLOW_SHADER_ATOMICS
/*
- Here you can control additional heap flags added to heaps/resources created in DEFAULT heap type.
- It's mostly for automatic usage of the cryptic, undocumented flag D3D12_HEAP_FLAG_ALLOW_SHADER_ATOMICS.
- Its absence doesn't seem to change anything but better to use it always, just in case.
+ Set this to 1 to make the library automatically adding flag
+ D3D12_HEAP_FLAG_ALLOW_SHADER_ATOMICS to any allocated heap that might contain a
+ buffer or a texture used as a UAV. You can change it to 0 if you are sure your
+ program doesn't use atomic functions in its shaders. In practice this flag
+ doesn't seem to change anything.
*/
- //#define D3D12MA_EXTRA_DEFAULT_TYPE_HEAP_FLAGS (D3D12_HEAP_FLAG_ALLOW_SHADER_ATOMICS)
- #define D3D12MA_EXTRA_DEFAULT_TYPE_HEAP_FLAGS (D3D12_HEAP_FLAG_NONE)
+ #define D3D12MA_ALLOW_SHADER_ATOMICS (1)
#endif
////////////////////////////////////////////////////////////////////////////////
@@ -730,6 +731,16 @@
return tileCount <= 16;
}
+static D3D12_HEAP_FLAGS GetExtraHeapFlagsToIgnore()
+{
+ D3D12_HEAP_FLAGS result =
+ D3D12_HEAP_FLAG_DENY_BUFFERS | D3D12_HEAP_FLAG_DENY_RT_DS_TEXTURES | D3D12_HEAP_FLAG_DENY_NON_RT_DS_TEXTURES;
+#if D3D12MA_ALLOW_SHADER_ATOMICS
+ result |= D3D12_HEAP_FLAG_ALLOW_SHADER_ATOMICS;
+#endif
+ return result;
+}
+
////////////////////////////////////////////////////////////////////////////////
// Private class Vector
@@ -1610,9 +1621,9 @@
private:
List<T>* m_pList;
- List<T>::Item* m_pItem;
+ Item* m_pItem;
- iterator(List<T>* pList, List<T>::Item* pItem) :
+ iterator(List<T>* pList, Item* pItem) :
m_pList(pList),
m_pItem(pItem)
{
@@ -1692,14 +1703,14 @@
}
private:
- const_iterator(const List<T>* pList, const List<T>::Item* pItem) :
+ const_iterator(const List<T>* pList, const Item* pItem) :
m_pList(pList),
m_pItem(pItem)
{
}
const List<T>* m_pList;
- const List<T>::Item* m_pItem;
+ const Item* m_pItem;
friend class List<T>;
};
@@ -1936,7 +1947,7 @@
}
template<typename T>
-typename List<T>::Item* List<T>::InsertBefore(List<T>::Item* pItem, const T& value)
+typename List<T>::Item* List<T>::InsertBefore(Item* pItem, const T& value)
{
Item* const newItem = InsertBefore(pItem);
newItem->Value = value;
@@ -1944,7 +1955,7 @@
}
template<typename T>
-typename List<T>::Item* List<T>::InsertAfter(List<T>::Item* pItem, const T& value)
+typename List<T>::Item* List<T>::InsertAfter(Item* pItem, const T& value)
{
Item* const newItem = InsertAfter(pItem);
newItem->Value = value;
@@ -2442,7 +2453,6 @@
HRESULT AllocateMemory(
const ALLOCATION_DESC* pAllocDesc,
- D3D12_HEAP_FLAGS heapFlags,
const D3D12_RESOURCE_ALLOCATION_INFO* pAllocInfo,
Allocation** ppAllocation);
@@ -2515,7 +2525,6 @@
// Creates and returns Allocation object.
HRESULT AllocateHeap(
const ALLOCATION_DESC* pAllocDesc,
- D3D12_HEAP_FLAGS heapFlags,
const D3D12_RESOURCE_ALLOCATION_INFO& allocInfo,
Allocation** ppAllocation);
@@ -2538,7 +2547,7 @@
UINT CalcDefaultPoolCount() const;
UINT CalcDefaultPoolIndex(const ALLOCATION_DESC& allocDesc, const D3D12_RESOURCE_DESC& resourceDesc) const;
// This one returns UINT32_MAX if nonstandard heap flags are used and index cannot be calculcated.
- UINT CalcDefaultPoolIndex(const ALLOCATION_DESC& allocDesc, const D3D12_HEAP_FLAGS heapFlags) const;
+ UINT CalcDefaultPoolIndex(const ALLOCATION_DESC& allocDesc) const;
void CalcDefaultPoolParams(D3D12_HEAP_TYPE& outHeapType, D3D12_HEAP_FLAGS& outHeapFlags, UINT index) const;
// Registers Allocation object in m_pCommittedAllocations.
@@ -3317,7 +3326,7 @@
{
Budget budget = {};
m_hAllocator->GetBudgetForHeapType(budget, m_HeapType);
- freeMemory = (budget.Usage < budget.Budget) ? (budget.Budget - budget.Usage) : 0;
+ freeMemory = (budget.UsageBytes < budget.BudgetBytes) ? (budget.BudgetBytes - budget.UsageBytes) : 0;
}
const bool canCreateNewBlock =
@@ -3436,7 +3445,7 @@
{
Budget budget = {};
m_hAllocator->GetBudgetForHeapType(budget, m_HeapType);
- budgetExceeded = budget.Usage >= budget.Budget;
+ budgetExceeded = budget.UsageBytes >= budget.BudgetBytes;
}
// Scope for lock.
@@ -3754,6 +3763,20 @@
D3D12MA_ASSERT(resAllocInfo.SizeInBytes > 0);
const UINT defaultPoolIndex = CalcDefaultPoolIndex(*pAllocDesc, resourceDesc2);
+ const bool requireCommittedMemory = defaultPoolIndex == UINT32_MAX;
+ if(requireCommittedMemory)
+ {
+ return AllocateCommittedResource(
+ &finalAllocDesc,
+ &resourceDesc2,
+ resAllocInfo,
+ InitialResourceState,
+ pOptimizedClearValue,
+ ppAllocation,
+ riidResource,
+ ppvResource);
+ }
+
BlockVector* blockVector = m_BlockVectors[defaultPoolIndex];
D3D12MA_ASSERT(blockVector);
@@ -3831,7 +3854,6 @@
HRESULT AllocatorPimpl::AllocateMemory(
const ALLOCATION_DESC* pAllocDesc,
- D3D12_HEAP_FLAGS heapFlags,
const D3D12_RESOURCE_ALLOCATION_INFO* pAllocInfo,
Allocation** ppAllocation)
{
@@ -3844,16 +3866,18 @@
ALLOCATION_DESC finalAllocDesc = *pAllocDesc;
- const UINT defaultPoolIndex = CalcDefaultPoolIndex(*pAllocDesc, heapFlags);
- if(defaultPoolIndex == UINT32_MAX)
+ const UINT defaultPoolIndex = CalcDefaultPoolIndex(*pAllocDesc);
+ bool requireCommittedMemory = (defaultPoolIndex == UINT32_MAX);
+ if(requireCommittedMemory)
{
- return E_INVALIDARG;
+ return AllocateHeap(&finalAllocDesc, *pAllocInfo, ppAllocation);
}
+
BlockVector* blockVector = m_BlockVectors[defaultPoolIndex];
D3D12MA_ASSERT(blockVector);
const UINT64 preferredBlockSize = blockVector->GetPreferredBlockSize();
- bool preferCommittedMemory =
+ const bool preferCommittedMemory =
m_AlwaysCommitted ||
// Heuristics: Allocate committed memory if requested size if greater than half of preferred block size.
pAllocInfo->SizeInBytes > preferredBlockSize / 2;
@@ -3865,7 +3889,7 @@
if((finalAllocDesc.Flags & ALLOCATION_FLAG_COMMITTED) != 0)
{
- return AllocateHeap(&finalAllocDesc, heapFlags, *pAllocInfo, ppAllocation);
+ return AllocateHeap(&finalAllocDesc, *pAllocInfo, ppAllocation);
}
else
{
@@ -3880,7 +3904,7 @@
return hr;
}
- return AllocateHeap(&finalAllocDesc, heapFlags, *pAllocInfo, ppAllocation);
+ return AllocateHeap(&finalAllocDesc, *pAllocInfo, ppAllocation);
}
}
@@ -3909,7 +3933,7 @@
{
Budget budget = {};
GetBudgetForHeapType(budget, pAllocDesc->HeapType);
- if(budget.Usage + resAllocInfo.SizeInBytes > budget.Budget)
+ if(budget.UsageBytes + resAllocInfo.SizeInBytes > budget.BudgetBytes)
{
return E_OUTOFMEMORY;
}
@@ -3918,8 +3942,14 @@
D3D12_HEAP_PROPERTIES heapProps = {};
heapProps.Type = pAllocDesc->HeapType;
- const D3D12_HEAP_FLAGS heapFlags = pAllocDesc->HeapType == D3D12_HEAP_TYPE_DEFAULT ?
- D3D12MA_EXTRA_DEFAULT_TYPE_HEAP_FLAGS : D3D12_HEAP_FLAG_NONE;
+ D3D12_HEAP_FLAGS heapFlags = pAllocDesc->ExtraHeapFlags;
+#if D3D12MA_ALLOW_SHADER_ATOMICS
+ if((pResourceDesc->Flags & D3D12_RESOURCE_FLAG_ALLOW_UNORDERED_ACCESS) != 0)
+ {
+ D3D12MA_ASSERT(pAllocDesc->HeapType == D3D12_HEAP_TYPE_DEFAULT);
+ heapFlags = D3D12_HEAP_FLAG_ALLOW_SHADER_ATOMICS;
+ }
+#endif
ID3D12Resource* res = NULL;
HRESULT hr = m_Device->CreateCommittedResource(
@@ -3950,7 +3980,6 @@
HRESULT AllocatorPimpl::AllocateHeap(
const ALLOCATION_DESC* pAllocDesc,
- D3D12_HEAP_FLAGS heapFlags,
const D3D12_RESOURCE_ALLOCATION_INFO& allocInfo,
Allocation** ppAllocation)
{
@@ -3965,16 +3994,19 @@
{
Budget budget = {};
GetBudgetForHeapType(budget, pAllocDesc->HeapType);
- if(budget.Usage + allocInfo.SizeInBytes > budget.Budget)
+ if(budget.UsageBytes + allocInfo.SizeInBytes > budget.BudgetBytes)
{
return E_OUTOFMEMORY;
}
}
+ D3D12_HEAP_FLAGS heapFlags = pAllocDesc->ExtraHeapFlags;
+#if D3D12MA_ALLOW_SHADER_ATOMICS
if(pAllocDesc->HeapType == D3D12_HEAP_TYPE_DEFAULT)
{
- heapFlags |= D3D12MA_EXTRA_DEFAULT_TYPE_HEAP_FLAGS;
+ heapFlags |= D3D12_HEAP_FLAG_ALLOW_SHADER_ATOMICS;
}
+#endif
D3D12_HEAP_DESC heapDesc = {};
heapDesc.SizeInBytes = allocInfo.SizeInBytes;
@@ -4012,6 +4044,12 @@
UINT AllocatorPimpl::CalcDefaultPoolIndex(const ALLOCATION_DESC& allocDesc, const D3D12_RESOURCE_DESC& resourceDesc) const
{
+ const D3D12_HEAP_FLAGS extraHeapFlags = allocDesc.ExtraHeapFlags & ~GetExtraHeapFlagsToIgnore();
+ if(extraHeapFlags != 0)
+ {
+ return UINT32_MAX;
+ }
+
UINT poolIndex = UINT_MAX;
switch(allocDesc.HeapType)
{
@@ -4039,8 +4077,14 @@
return poolIndex;
}
-UINT AllocatorPimpl::CalcDefaultPoolIndex(const ALLOCATION_DESC& allocDesc, const D3D12_HEAP_FLAGS heapFlags) const
+UINT AllocatorPimpl::CalcDefaultPoolIndex(const ALLOCATION_DESC& allocDesc) const
{
+ const D3D12_HEAP_FLAGS extraHeapFlags = allocDesc.ExtraHeapFlags & ~GetExtraHeapFlagsToIgnore();
+ if(extraHeapFlags != 0)
+ {
+ return UINT32_MAX;
+ }
+
UINT poolIndex = UINT_MAX;
switch(allocDesc.HeapType)
{
@@ -4054,9 +4098,9 @@
{
poolIndex *= 3;
- const bool allowBuffers = (heapFlags & D3D12_HEAP_FLAG_DENY_BUFFERS) == 0;
- const bool allowRtDsTextures = (heapFlags & D3D12_HEAP_FLAG_DENY_RT_DS_TEXTURES) == 0;
- const bool allowNonRtDsTextures = (heapFlags & D3D12_HEAP_FLAG_DENY_NON_RT_DS_TEXTURES) == 0;
+ const bool allowBuffers = (allocDesc.ExtraHeapFlags & D3D12_HEAP_FLAG_DENY_BUFFERS) == 0;
+ const bool allowRtDsTextures = (allocDesc.ExtraHeapFlags & D3D12_HEAP_FLAG_DENY_RT_DS_TEXTURES) == 0;
+ const bool allowNonRtDsTextures = (allocDesc.ExtraHeapFlags & D3D12_HEAP_FLAG_DENY_NON_RT_DS_TEXTURES) == 0;
const uint8_t allowedGroupCount = (allowBuffers ? 1 : 0) + (allowRtDsTextures ? 1 : 0) + (allowNonRtDsTextures ? 1 : 0);
if(allowedGroupCount != 1)
@@ -4115,10 +4159,12 @@
D3D12MA_ASSERT(0);
}
+#if D3D12MA_ALLOW_SHADER_ATOMICS
if(outHeapType == D3D12_HEAP_TYPE_DEFAULT)
{
- outHeapFlags |= D3D12MA_EXTRA_DEFAULT_TYPE_HEAP_FLAGS;
+ outHeapFlags |= D3D12_HEAP_FLAG_ALLOW_SHADER_ATOMICS;
}
+#endif
}
void AllocatorPimpl::RegisterCommittedAllocation(Allocation* alloc, D3D12_HEAP_TYPE heapType)
@@ -4266,27 +4312,27 @@
if(m_Budget.m_D3D12UsageLocal + outGpuBudget->BlockBytes > m_Budget.m_BlockBytesAtBudgetFetch[0])
{
- outGpuBudget->Usage = m_Budget.m_D3D12UsageLocal +
+ outGpuBudget->UsageBytes = m_Budget.m_D3D12UsageLocal +
outGpuBudget->BlockBytes - m_Budget.m_BlockBytesAtBudgetFetch[0];
}
else
{
- outGpuBudget->Usage = 0;
+ outGpuBudget->UsageBytes = 0;
}
- outGpuBudget->Budget = m_Budget.m_D3D12BudgetLocal;
+ outGpuBudget->BudgetBytes = m_Budget.m_D3D12BudgetLocal;
}
if(outCpuBudget)
{
if(m_Budget.m_D3D12UsageNonLocal + outCpuBudget->BlockBytes > m_Budget.m_BlockBytesAtBudgetFetch[1] + m_Budget.m_BlockBytesAtBudgetFetch[2])
{
- outCpuBudget->Usage = m_Budget.m_D3D12UsageNonLocal +
+ outCpuBudget->UsageBytes = m_Budget.m_D3D12UsageNonLocal +
outCpuBudget->BlockBytes - (m_Budget.m_BlockBytesAtBudgetFetch[1] + m_Budget.m_BlockBytesAtBudgetFetch[2]);
}
else
{
- outCpuBudget->Usage = 0;
+ outCpuBudget->UsageBytes = 0;
}
- outCpuBudget->Budget = m_Budget.m_D3D12BudgetNonLocal;
+ outCpuBudget->BudgetBytes = m_Budget.m_D3D12BudgetNonLocal;
}
}
else
@@ -4301,14 +4347,14 @@
if(outGpuBudget)
{
const UINT64 gpuMemorySize = m_AdapterDesc.DedicatedVideoMemory + m_AdapterDesc.DedicatedSystemMemory; // TODO: Is this right?
- outGpuBudget->Usage = outGpuBudget->BlockBytes;
- outGpuBudget->Budget = gpuMemorySize * 8 / 10; // 80% heuristics.
+ outGpuBudget->UsageBytes = outGpuBudget->BlockBytes;
+ outGpuBudget->BudgetBytes = gpuMemorySize * 8 / 10; // 80% heuristics.
}
if(outCpuBudget)
{
const UINT64 cpuMemorySize = m_AdapterDesc.SharedSystemMemory; // TODO: Is this right?
- outCpuBudget->Usage = outCpuBudget->BlockBytes;
- outCpuBudget->Budget = cpuMemorySize * 8 / 10; // 80% heuristics.
+ outCpuBudget->UsageBytes = outCpuBudget->BlockBytes;
+ outCpuBudget->BudgetBytes = cpuMemorySize * 8 / 10; // 80% heuristics.
}
}
}
@@ -4573,10 +4619,10 @@
json.WriteNumber(budget.BlockBytes);
json.WriteString(L"AllocationBytes");
json.WriteNumber(budget.AllocationBytes);
- json.WriteString(L"Usage");
- json.WriteNumber(budget.Usage);
- json.WriteString(L"Budget");
- json.WriteNumber(budget.Budget);
+ json.WriteString(L"UsageBytes");
+ json.WriteNumber(budget.UsageBytes);
+ json.WriteString(L"BudgetBytes");
+ json.WriteNumber(budget.BudgetBytes);
}
json.EndObject();
}
@@ -4814,7 +4860,6 @@
HRESULT Allocator::AllocateMemory(
const ALLOCATION_DESC* pAllocDesc,
- D3D12_HEAP_FLAGS heapFlags,
const D3D12_RESOURCE_ALLOCATION_INFO* pAllocInfo,
Allocation** ppAllocation)
{
@@ -4825,14 +4870,13 @@
pAllocInfo->Alignment == D3D12_DEFAULT_RESOURCE_PLACEMENT_ALIGNMENT ||
pAllocInfo->Alignment == D3D12_DEFAULT_MSAA_RESOURCE_PLACEMENT_ALIGNMENT) ||
pAllocInfo->SizeInBytes == 0 ||
- pAllocInfo->SizeInBytes % (64ull * 1024) != 0 ||
- (heapFlags & ~(D3D12_HEAP_FLAG_DENY_BUFFERS | D3D12_HEAP_FLAG_DENY_RT_DS_TEXTURES | D3D12_HEAP_FLAG_DENY_NON_RT_DS_TEXTURES)) != 0)
+ pAllocInfo->SizeInBytes % (64ull * 1024) != 0)
{
D3D12MA_ASSERT(0 && "Invalid arguments passed to Allocator::AllocateMemory.");
return E_INVALIDARG;
}
D3D12MA_DEBUG_GLOBAL_MUTEX_LOCK
- return m_Pimpl->AllocateMemory(pAllocDesc, heapFlags, pAllocInfo, ppAllocation);
+ return m_Pimpl->AllocateMemory(pAllocDesc, pAllocInfo, ppAllocation);
}
void Allocator::SetCurrentFrameIndex(UINT frameIndex)
diff --git a/src/D3D12MemAlloc.h b/src/D3D12MemAlloc.h
index 2f0870d..4898e38 100644
--- a/src/D3D12MemAlloc.h
+++ b/src/D3D12MemAlloc.h
@@ -440,6 +440,23 @@
It must be one of: `D3D12_HEAP_TYPE_DEFAULT`, `D3D12_HEAP_TYPE_UPLOAD`, `D3D12_HEAP_TYPE_READBACK`.
*/
D3D12_HEAP_TYPE HeapType;
+ /** \brief Additional heap flags to be used when allocating memory.
+
+ In most cases it can be 0.
+
+ - If you use D3D12MA::Allocator::CreateResource(), you don't need to care.
+ In case of D3D12MA::Allocator::GetD3D12Options()`.ResourceHeapTier == D3D12_RESOURCE_HEAP_TIER_1`,
+ necessary flag `D3D12_HEAP_FLAG_ALLOW_ONLY_BUFFERS`, `D3D12_HEAP_FLAG_ALLOW_ONLY_NON_RT_DS_TEXTURES`,
+ or `D3D12_HEAP_FLAG_ALLOW_ONLY_RT_DS_TEXTURES` is added automatically.
+ - If you use D3D12MA::Allocator::AllocateMemory() and
+ D3D12MA::Allocator::GetD3D12Options()`.ResourceHeapTier == D3D12_RESOURCE_HEAP_TIER_1`,
+ you must specify one of those `ALLOW_ONLY` flags. When it's `TIER_2`, you can leave it 0.
+ - If configuration macro `D3D12MA_ALLOW_SHADER_ATOMICS` is set to 1 (which is the default),
+ `D3D12_HEAP_FLAG_ALLOW_SHADER_ATOMICS` is added automatically wherever it might be needed.
+ - You can specify additional flags if needed. Then the memory will always be allocated as
+ separate block using `D3D12Device::CreateCommittedResource` or `CreateHeap`, not as part of an existing larget block.
+ */
+ D3D12_HEAP_FLAGS ExtraHeapFlags;
};
/** \brief Represents single memory allocation.
@@ -722,7 +739,7 @@
also occupying the memory, like swapchain, pipeline state objects, descriptor heaps, command lists, or
memory blocks allocated outside of this library, if any.
*/
- UINT64 Usage;
+ UINT64 UsageBytes;
/** \brief Estimated amount of memory available to the program, in bytes.
@@ -730,10 +747,10 @@
It might be different (most probably smaller) than memory sizes reported in `DXGI_ADAPTER_DESC` due to factors
external to the program, like other programs also consuming system resources.
- Difference `Budget - Usage` is the amount of additional memory that can probably
+ Difference `BudgetBytes - UsageBytes` is the amount of additional memory that can probably
be allocated without problems. Exceeding the budget may result in various problems.
*/
- UINT64 Budget;
+ UINT64 BudgetBytes;
};
/**
@@ -796,12 +813,13 @@
This function is similar to `ID3D12Device::CreateHeap`, but it may really assign
part of a larger, existing heap to the allocation.
- If ResourceHeapTier = 1, `heapFlags` must be one of these values, depending on type
+ If ResourceHeapTier = 1, `heapFlags` must contain one of these values, depending on type
of resources you are going to create in this memory:
`D3D12_HEAP_FLAG_ALLOW_ONLY_BUFFERS`,
`D3D12_HEAP_FLAG_ALLOW_ONLY_NON_RT_DS_TEXTURES`,
`D3D12_HEAP_FLAG_ALLOW_ONLY_RT_DS_TEXTURES`.
- If ResourceHeapTier = 2, `heapFlags` may be `D3D12_HEAP_FLAG_ALLOW_ALL_BUFFERS_AND_TEXTURES`.
+ If ResourceHeapTier = 2, `heapFlags` may be `D3D12_HEAP_FLAG_ALLOW_ALL_BUFFERS_AND_TEXTURES` = 0.
+ Additional flags in `heapFlags` are allowed as well.
`pAllocInfo->SizeInBytes` must be multiply of 64KB.
`pAllocInfo->Alignment` must be one of the legal values as described in documentation of `D3D12_HEAP_DESC`.
@@ -811,7 +829,6 @@
*/
HRESULT AllocateMemory(
const ALLOCATION_DESC* pAllocDesc,
- D3D12_HEAP_FLAGS heapFlags,
const D3D12_RESOURCE_ALLOCATION_INFO* pAllocInfo,
Allocation** ppAllocation);
diff --git a/src/Tests.cpp b/src/Tests.cpp
index 113c64a..2c1bfb3 100644
--- a/src/Tests.cpp
+++ b/src/Tests.cpp
@@ -178,7 +178,7 @@
ResourceWithAllocation resources[count];
D3D12MA::ALLOCATION_DESC allocDesc = {};
- allocDesc.HeapType = D3D12_HEAP_TYPE_UPLOAD;
+ allocDesc.HeapType = D3D12_HEAP_TYPE_DEFAULT;
allocDesc.Flags = D3D12MA::ALLOCATION_FLAG_COMMITTED;
D3D12_RESOURCE_DESC resourceDesc;
@@ -192,7 +192,7 @@
CHECK_HR( ctx.allocator->CreateResource(
&allocDesc,
&resourceDesc,
- D3D12_RESOURCE_STATE_GENERIC_READ,
+ D3D12_RESOURCE_STATE_COPY_DEST,
NULL,
&alloc,
__uuidof(ID3D12Resource),
@@ -236,6 +236,65 @@
ctx.allocator->FreeStatsString(jsonString);
}
+static void TestCustomHeapFlags(const TestContext& ctx)
+{
+ wprintf(L"Test custom heap flags\n");
+
+ // 1. Just memory heap with custom flags
+ {
+ D3D12MA::ALLOCATION_DESC allocDesc = {};
+ allocDesc.HeapType = D3D12_HEAP_TYPE_DEFAULT;
+ allocDesc.ExtraHeapFlags = D3D12_HEAP_FLAG_ALLOW_ONLY_NON_RT_DS_TEXTURES |
+ D3D12_HEAP_FLAG_SHARED; // Extra flag.
+
+ D3D12_RESOURCE_ALLOCATION_INFO resAllocInfo = {};
+ resAllocInfo.SizeInBytes = D3D12_DEFAULT_RESOURCE_PLACEMENT_ALIGNMENT;
+ resAllocInfo.Alignment = D3D12_DEFAULT_RESOURCE_PLACEMENT_ALIGNMENT;
+
+ D3D12MA::Allocation* alloc = nullptr;
+ CHECK_HR( ctx.allocator->AllocateMemory(&allocDesc, &resAllocInfo, &alloc) );
+ ResourceWithAllocation res;
+ res.allocation.reset(alloc);
+
+ // Must be created as separate allocation.
+ CHECK_BOOL( res.allocation->GetOffset() == 0 );
+ }
+
+ // 2. Committed resource with custom flags
+ {
+ D3D12_RESOURCE_DESC resourceDesc = {};
+ resourceDesc.Dimension = D3D12_RESOURCE_DIMENSION_TEXTURE2D;
+ resourceDesc.Alignment = 0;
+ resourceDesc.Width = 1920;
+ resourceDesc.Height = 1080;
+ resourceDesc.DepthOrArraySize = 1;
+ resourceDesc.MipLevels = 1;
+ resourceDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
+ resourceDesc.SampleDesc.Count = 1;
+ resourceDesc.SampleDesc.Quality = 0;
+ resourceDesc.Layout = D3D12_TEXTURE_LAYOUT_ROW_MAJOR;
+ resourceDesc.Flags = D3D12_RESOURCE_FLAG_ALLOW_CROSS_ADAPTER;
+
+ D3D12MA::ALLOCATION_DESC allocDesc = {};
+ allocDesc.HeapType = D3D12_HEAP_TYPE_DEFAULT;
+ allocDesc.ExtraHeapFlags = D3D12_HEAP_FLAG_SHARED | D3D12_HEAP_FLAG_SHARED_CROSS_ADAPTER; // Extra flags.
+
+ ResourceWithAllocation res;
+ D3D12MA::Allocation* alloc = nullptr;
+ CHECK_HR( ctx.allocator->CreateResource(
+ &allocDesc,
+ &resourceDesc,
+ D3D12_RESOURCE_STATE_COMMON,
+ NULL,
+ &alloc,
+ IID_PPV_ARGS(&res.resource)) );
+ res.allocation.reset(alloc);
+
+ // Must be created as committed.
+ CHECK_BOOL( res.allocation->GetHeap() == NULL );
+ }
+}
+
static void TestPlacedResources(const TestContext& ctx)
{
wprintf(L"Test placed resources\n");
@@ -346,6 +405,7 @@
D3D12MA::ALLOCATION_DESC allocDesc = {};
allocDesc.HeapType = D3D12_HEAP_TYPE_DEFAULT;
+ allocDesc.ExtraHeapFlags = D3D12_HEAP_FLAG_ALLOW_ONLY_RT_DS_TEXTURES;
D3D12_RESOURCE_DESC resourceDesc1 = {};
resourceDesc1.Dimension = D3D12_RESOURCE_DIMENSION_TEXTURE2D;
@@ -383,7 +443,6 @@
D3D12MA::Allocation* allocPtr = NULL;
CHECK_HR( ctx.allocator->AllocateMemory(
&allocDesc,
- D3D12_HEAP_FLAG_ALLOW_ONLY_RT_DS_TEXTURES,
&allocInfo,
&allocPtr) );
AllocationUniquePtr alloc(allocPtr);
@@ -941,6 +1000,7 @@
{
TestFrameIndexAndJson(ctx);
TestCommittedResourcesAndJson(ctx);
+ TestCustomHeapFlags(ctx);
TestPlacedResources(ctx);
TestAliasingMemory(ctx);
TestMapping(ctx);
