From b6c5bea3cdda6dd5d0182ca768f201da412fc577 Mon Sep 17 00:00:00 2001 From: Adam Sawicki Date: Wed, 5 Jul 2023 10:09:03 +0200 Subject: [PATCH] Added support for GPU Upload Heaps from Agility SDK 1.710.0-preview Added Allocator::IsGPUUploadHeapSupported. Extended TotalStatistics::HeapType[] to 5 elements. --- ...lass_d3_d12_m_a_1_1_allocator-members.html | 5 +- docs/html/class_d3_d12_m_a_1_1_allocator.html | 25 +++ docs/html/configuration.html | 16 +- docs/html/defragmentation.html | 20 +-- docs/html/functions.html | 3 +- docs/html/functions_func.html | 1 + docs/html/functions_vars.html | 2 +- docs/html/index.html | 4 +- docs/html/quick_start.html | 14 +- docs/html/resource_aliasing.html | 8 +- docs/html/search/all_7.js | 2 +- docs/html/search/all_8.js | 3 +- docs/html/search/functions_6.js | 3 +- docs/html/search/variables_5.js | 2 +- docs/html/statistics.html | 6 +- ..._d12_m_a_1_1_total_statistics-members.html | 2 +- ...truct_d3_d12_m_a_1_1_total_statistics.html | 17 +- docs/html/virtual_allocator.html | 20 +-- include/D3D12MemAlloc.h | 22 ++- src/CMakeLists.txt | 38 +++- src/D3D12MemAlloc.cpp | 164 +++++++++++++----- src/D3D12Sample.cpp | 15 ++ src/Tests.cpp | 156 +++++++++++++++++ 23 files changed, 438 insertions(+), 110 deletions(-) diff --git a/docs/html/class_d3_d12_m_a_1_1_allocator-members.html b/docs/html/class_d3_d12_m_a_1_1_allocator-members.html index 2534d48..8b5dd73 100644 --- a/docs/html/class_d3_d12_m_a_1_1_allocator-members.html +++ b/docs/html/class_d3_d12_m_a_1_1_allocator-members.html @@ -97,8 +97,9 @@ $(function() { GetD3D12Options() constD3D12MA::Allocator GetMemoryCapacity(UINT memorySegmentGroup) constD3D12MA::Allocator IsCacheCoherentUMA() constD3D12MA::Allocator - IsUMA() constD3D12MA::Allocator - SetCurrentFrameIndex(UINT frameIndex)D3D12MA::Allocator + IsGPUUploadHeapSupported() constD3D12MA::Allocator + IsUMA() constD3D12MA::Allocator + SetCurrentFrameIndex(UINT frameIndex)D3D12MA::Allocator
diff --git a/docs/html/class_d3_d12_m_a_1_1_allocator.html b/docs/html/class_d3_d12_m_a_1_1_allocator.html index 9e4fa2d..fb92b61 100644 --- a/docs/html/class_d3_d12_m_a_1_1_allocator.html +++ b/docs/html/class_d3_d12_m_a_1_1_allocator.html @@ -102,6 +102,9 @@ Public Member Functions BOOL IsCacheCoherentUMA () const  Returns true if D3D12_FEATURE_DATA_ARCHITECTURE1::CacheCoherentUMA was found to be true.
  +BOOL IsGPUUploadHeapSupported () const + Returns true if GPU Upload Heaps are supported on the current system.
+  UINT64 GetMemoryCapacity (UINT memorySegmentGroup) const  Returns total amount of memory of specific segment group, in bytes.
  @@ -893,6 +896,28 @@ Public Member Functions
  • "ID3D12Device::GetCustomHeapProperties method (d3d12.h)"
    • + + + +

    ◆ IsGPUUploadHeapSupported()

    + +
    +
    + + + + + + + +
    BOOL D3D12MA::Allocator::IsGPUUploadHeapSupported () const
    +
    + +

    Returns true if GPU Upload Heaps are supported on the current system.

    +

    When true, you can use D3D12_HEAP_TYPE_GPU_UPLOAD.

    +

    This flag is fetched from D3D12_FEATURE_D3D12_OPTIONS16::GPUUploadHeapSupported.

    +

    #define D3D12MA_OPTIONS16_SUPPORTED 1 is needed for the compilation of this library. Otherwise the flag is always false.

    +
    diff --git a/docs/html/configuration.html b/docs/html/configuration.html index 3236f86..840ed94 100644 --- a/docs/html/configuration.html +++ b/docs/html/configuration.html @@ -108,15 +108,15 @@ Custom CPU memory allocator
    D3D12MA::Allocator* allocator;
    HRESULT hr = D3D12MA::CreateAllocator(&allocatorDesc, &allocator);
    -
    D3D12MA::Allocator
    Represents main object of this library initialized for particular ID3D12Device.
    Definition: D3D12MemAlloc.h:1102
    +
    D3D12MA::Allocator
    Represents main object of this library initialized for particular ID3D12Device.
    Definition: D3D12MemAlloc.h:1112
    D3D12MA::CreateAllocator
    D3D12MA_API HRESULT CreateAllocator(const ALLOCATOR_DESC *pDesc, Allocator **ppAllocator)
    Creates new main D3D12MA::Allocator object and returns it through ppAllocator.
    -
    D3D12MA::ALLOCATION_CALLBACKS
    Custom callbacks to CPU memory allocation functions.
    Definition: D3D12MemAlloc.h:200
    -
    D3D12MA::ALLOCATION_CALLBACKS::pFree
    FREE_FUNC_PTR pFree
    Dellocation function.
    Definition: D3D12MemAlloc.h:204
    -
    D3D12MA::ALLOCATION_CALLBACKS::pAllocate
    ALLOCATE_FUNC_PTR pAllocate
    Allocation function.
    Definition: D3D12MemAlloc.h:202
    -
    D3D12MA::ALLOCATOR_DESC
    Parameters of created Allocator object. To be used with CreateAllocator().
    Definition: D3D12MemAlloc.h:1063
    -
    D3D12MA::ALLOCATOR_DESC::pAllocationCallbacks
    const ALLOCATION_CALLBACKS * pAllocationCallbacks
    Custom CPU memory allocation callbacks. Optional.
    Definition: D3D12MemAlloc.h:1083
    -
    D3D12MA::ALLOCATOR_DESC::pAdapter
    IDXGIAdapter * pAdapter
    Definition: D3D12MemAlloc.h:1089
    -
    D3D12MA::ALLOCATOR_DESC::pDevice
    ID3D12Device * pDevice
    Definition: D3D12MemAlloc.h:1071
    +
    D3D12MA::ALLOCATION_CALLBACKS
    Custom callbacks to CPU memory allocation functions.
    Definition: D3D12MemAlloc.h:209
    +
    D3D12MA::ALLOCATION_CALLBACKS::pFree
    FREE_FUNC_PTR pFree
    Dellocation function.
    Definition: D3D12MemAlloc.h:213
    +
    D3D12MA::ALLOCATION_CALLBACKS::pAllocate
    ALLOCATE_FUNC_PTR pAllocate
    Allocation function.
    Definition: D3D12MemAlloc.h:211
    +
    D3D12MA::ALLOCATOR_DESC
    Parameters of created Allocator object. To be used with CreateAllocator().
    Definition: D3D12MemAlloc.h:1073
    +
    D3D12MA::ALLOCATOR_DESC::pAllocationCallbacks
    const ALLOCATION_CALLBACKS * pAllocationCallbacks
    Custom CPU memory allocation callbacks. Optional.
    Definition: D3D12MemAlloc.h:1093
    +
    D3D12MA::ALLOCATOR_DESC::pAdapter
    IDXGIAdapter * pAdapter
    Definition: D3D12MemAlloc.h:1099
    +
    D3D12MA::ALLOCATOR_DESC::pDevice
    ID3D12Device * pDevice
    Definition: D3D12MemAlloc.h:1081

    Debug margins

    By default, allocations are laid out in memory blocks next to each other if possible (considering required alignment returned by ID3D12Device::GetResourceAllocationInfo).

    diff --git a/docs/html/defragmentation.html b/docs/html/defragmentation.html index d616995..71a95da 100644 --- a/docs/html/defragmentation.html +++ b/docs/html/defragmentation.html @@ -134,19 +134,19 @@ $(function() {
    defragCtx->Release();
    D3D12MA::Allocation::SetResource
    void SetResource(ID3D12Resource *pResource)
    Releases the resource currently pointed by the allocation (if any), sets it to new one,...
    D3D12MA::Allocation::GetOffset
    UINT64 GetOffset() const
    Returns offset in bytes from the start of memory heap.
    -
    D3D12MA::Allocation::GetResource
    ID3D12Resource * GetResource() const
    Returns D3D12 resource associated with this object.
    Definition: D3D12MemAlloc.h:502
    +
    D3D12MA::Allocation::GetResource
    ID3D12Resource * GetResource() const
    Returns D3D12 resource associated with this object.
    Definition: D3D12MemAlloc.h:512
    D3D12MA::Allocation::GetHeap
    ID3D12Heap * GetHeap() const
    Returns memory heap that the resource is created in.
    -
    D3D12MA::DefragmentationContext
    Represents defragmentation process in progress.
    Definition: D3D12MemAlloc.h:781
    +
    D3D12MA::DefragmentationContext
    Represents defragmentation process in progress.
    Definition: D3D12MemAlloc.h:791
    D3D12MA::DefragmentationContext::BeginPass
    HRESULT BeginPass(DEFRAGMENTATION_PASS_MOVE_INFO *pPassInfo)
    Starts single defragmentation pass.
    D3D12MA::DefragmentationContext::EndPass
    HRESULT EndPass(DEFRAGMENTATION_PASS_MOVE_INFO *pPassInfo)
    Ends single defragmentation pass.
    -
    D3D12MA::DEFRAGMENTATION_FLAG_ALGORITHM_FAST
    @ DEFRAGMENTATION_FLAG_ALGORITHM_FAST
    Definition: D3D12MemAlloc.h:661
    -
    D3D12MA::DEFRAGMENTATION_DESC
    Parameters for defragmentation.
    Definition: D3D12MemAlloc.h:683
    -
    D3D12MA::DEFRAGMENTATION_DESC::Flags
    DEFRAGMENTATION_FLAGS Flags
    Flags.
    Definition: D3D12MemAlloc.h:685
    -
    D3D12MA::DEFRAGMENTATION_MOVE::pSrcAllocation
    Allocation * pSrcAllocation
    Allocation that should be moved.
    Definition: D3D12MemAlloc.h:719
    -
    D3D12MA::DEFRAGMENTATION_MOVE::pDstTmpAllocation
    Allocation * pDstTmpAllocation
    Temporary allocation pointing to destination memory that will replace pSrcAllocation.
    Definition: D3D12MemAlloc.h:727
    -
    D3D12MA::DEFRAGMENTATION_PASS_MOVE_INFO
    Parameters for incremental defragmentation steps.
    Definition: D3D12MemAlloc.h:735
    -
    D3D12MA::DEFRAGMENTATION_PASS_MOVE_INFO::pMoves
    DEFRAGMENTATION_MOVE * pMoves
    Array of moves to be performed by the user in the current defragmentation pass.
    Definition: D3D12MemAlloc.h:759
    -
    D3D12MA::DEFRAGMENTATION_PASS_MOVE_INFO::MoveCount
    UINT32 MoveCount
    Number of elements in the pMoves array.
    Definition: D3D12MemAlloc.h:737
    +
    D3D12MA::DEFRAGMENTATION_FLAG_ALGORITHM_FAST
    @ DEFRAGMENTATION_FLAG_ALGORITHM_FAST
    Definition: D3D12MemAlloc.h:671
    +
    D3D12MA::DEFRAGMENTATION_DESC
    Parameters for defragmentation.
    Definition: D3D12MemAlloc.h:693
    +
    D3D12MA::DEFRAGMENTATION_DESC::Flags
    DEFRAGMENTATION_FLAGS Flags
    Flags.
    Definition: D3D12MemAlloc.h:695
    +
    D3D12MA::DEFRAGMENTATION_MOVE::pSrcAllocation
    Allocation * pSrcAllocation
    Allocation that should be moved.
    Definition: D3D12MemAlloc.h:729
    +
    D3D12MA::DEFRAGMENTATION_MOVE::pDstTmpAllocation
    Allocation * pDstTmpAllocation
    Temporary allocation pointing to destination memory that will replace pSrcAllocation.
    Definition: D3D12MemAlloc.h:737
    +
    D3D12MA::DEFRAGMENTATION_PASS_MOVE_INFO
    Parameters for incremental defragmentation steps.
    Definition: D3D12MemAlloc.h:745
    +
    D3D12MA::DEFRAGMENTATION_PASS_MOVE_INFO::pMoves
    DEFRAGMENTATION_MOVE * pMoves
    Array of moves to be performed by the user in the current defragmentation pass.
    Definition: D3D12MemAlloc.h:769
    +
    D3D12MA::DEFRAGMENTATION_PASS_MOVE_INFO::MoveCount
    UINT32 MoveCount
    Number of elements in the pMoves array.
    Definition: D3D12MemAlloc.h:747

    Although functions like D3D12MA::Allocator::CreateResource() create an allocation and a buffer/texture at once, these are just a shortcut for allocating memory and creating a placed resource. Defragmentation works on memory allocations only. You must handle the rest manually. Defragmentation is an iterative process that should repreat "passes" as long as related functions return S_FALSE not S_OK. In each pass:

    1. D3D12MA::DefragmentationContext::BeginPass() function call:

      - i -

      diff --git a/docs/html/functions_func.html b/docs/html/functions_func.html index aefa1c5..8d78308 100644 --- a/docs/html/functions_func.html +++ b/docs/html/functions_func.html @@ -129,6 +129,7 @@ $(function() {

      - i -

      diff --git a/docs/html/functions_vars.html b/docs/html/functions_vars.html index 4861b16..9b86a93 100644 --- a/docs/html/functions_vars.html +++ b/docs/html/functions_vars.html @@ -114,7 +114,7 @@ $(function() {
    2. HeapFlags : D3D12MA::POOL_DESC
    3. HeapProperties : D3D12MA::POOL_DESC
    4. HeapsFreed : D3D12MA::DEFRAGMENTATION_STATS
      5. -
    5. HeapType : D3D12MA::ALLOCATION_DESC, D3D12MA::TotalStatistics
      6. +
    6. HeapType : D3D12MA::ALLOCATION_DESC, D3D12MA::TotalStatistics
      7. diff --git a/docs/html/index.html b/docs/html/index.html index 7a17fb5..90ef9a0 100644 --- a/docs/html/index.html +++ b/docs/html/index.html @@ -72,8 +72,8 @@ $(function() {
      D3D12 Memory Allocator
      -

      Version 2.1.0-development (2022-12-15)

      -

      Copyright (c) 2019-2022 Advanced Micro Devices, Inc. All rights reserved.
      +

      Version 2.1.0-development (2023-07-05)

      +

      Copyright (c) 2019-2023 Advanced Micro Devices, Inc. All rights reserved.
      License: MIT

      Documentation of all members: D3D12MemAlloc.h

      diff --git a/docs/html/quick_start.html b/docs/html/quick_start.html index 2c01790..796b4c4 100644 --- a/docs/html/quick_start.html +++ b/docs/html/quick_start.html @@ -97,11 +97,11 @@ Project setup and initialization

      D3D12MA::Allocator* allocator;
      HRESULT hr = D3D12MA::CreateAllocator(&allocatorDesc, &allocator);
      -
      D3D12MA::Allocator
      Represents main object of this library initialized for particular ID3D12Device.
      Definition: D3D12MemAlloc.h:1102
      +
      D3D12MA::Allocator
      Represents main object of this library initialized for particular ID3D12Device.
      Definition: D3D12MemAlloc.h:1112
      D3D12MA::CreateAllocator
      D3D12MA_API HRESULT CreateAllocator(const ALLOCATOR_DESC *pDesc, Allocator **ppAllocator)
      Creates new main D3D12MA::Allocator object and returns it through ppAllocator.
      -
      D3D12MA::ALLOCATOR_DESC
      Parameters of created Allocator object. To be used with CreateAllocator().
      Definition: D3D12MemAlloc.h:1063
      -
      D3D12MA::ALLOCATOR_DESC::pAdapter
      IDXGIAdapter * pAdapter
      Definition: D3D12MemAlloc.h:1089
      -
      D3D12MA::ALLOCATOR_DESC::pDevice
      ID3D12Device * pDevice
      Definition: D3D12MemAlloc.h:1071
      +
      D3D12MA::ALLOCATOR_DESC
      Parameters of created Allocator object. To be used with CreateAllocator().
      Definition: D3D12MemAlloc.h:1073
      +
      D3D12MA::ALLOCATOR_DESC::pAdapter
      IDXGIAdapter * pAdapter
      Definition: D3D12MemAlloc.h:1099
      +
      D3D12MA::ALLOCATOR_DESC::pDevice
      ID3D12Device * pDevice
      Definition: D3D12MemAlloc.h:1081

      (5.) Right before destroying the D3D12 device, destroy the allocator object.

      Objects of this library must be destroyed by calling Release method. They are somewhat compatible with COM: they implement IUnknown interface with its virtual methods: AddRef, Release, QueryInterface, and they are reference-counted internally. You can use smart pointers designed for COM with objects of this library - e.g. CComPtr or Microsoft::WRL::ComPtr. The reference counter is thread-safe. QueryInterface method supports only IUnknown, as classes of this library don't define their own GUIDs.

      allocator->Release();
      @@ -136,10 +136,10 @@ Creating resources
      IID_NULL, NULL);
      // Use allocation->GetResource()...
      -
      D3D12MA::Allocation
      Represents single memory allocation.
      Definition: D3D12MemAlloc.h:473
      +
      D3D12MA::Allocation
      Represents single memory allocation.
      Definition: D3D12MemAlloc.h:483
      D3D12MA::Allocator::CreateResource
      HRESULT CreateResource(const ALLOCATION_DESC *pAllocDesc, const D3D12_RESOURCE_DESC *pResourceDesc, D3D12_RESOURCE_STATES InitialResourceState, const D3D12_CLEAR_VALUE *pOptimizedClearValue, Allocation **ppAllocation, REFIID riidResource, void **ppvResource)
      Allocates memory and creates a D3D12 resource (buffer or texture). This is the main allocation functi...
      -
      D3D12MA::ALLOCATION_DESC
      Parameters of created D3D12MA::Allocation object. To be used with Allocator::CreateResource.
      Definition: D3D12MemAlloc.h:290
      -
      D3D12MA::ALLOCATION_DESC::HeapType
      D3D12_HEAP_TYPE HeapType
      The type of memory heap where the new allocation should be placed.
      Definition: D3D12MemAlloc.h:299
      +
      D3D12MA::ALLOCATION_DESC
      Parameters of created D3D12MA::Allocation object. To be used with Allocator::CreateResource.
      Definition: D3D12MemAlloc.h:299
      +
      D3D12MA::ALLOCATION_DESC::HeapType
      D3D12_HEAP_TYPE HeapType
      The type of memory heap where the new allocation should be placed.
      Definition: D3D12MemAlloc.h:308

      You need to release the allocation object when no longer needed. This will also release the D3D12 resource.

      allocation->Release();

      The advantage of using the allocator instead of creating committed resource, and the main purpose of this library, is that it can decide to allocate bigger memory heap internally using ID3D12Device::CreateHeap and place multiple resources in it, at different offsets, using ID3D12Device::CreatePlacedResource. The library manages its own collection of allocated memory blocks (heaps) and remembers which parts of them are occupied and which parts are free to be used for new resources.

      diff --git a/docs/html/resource_aliasing.html b/docs/html/resource_aliasing.html index 57ce825..65a8a33 100644 --- a/docs/html/resource_aliasing.html +++ b/docs/html/resource_aliasing.html @@ -151,11 +151,11 @@ $(function() {
      res2->Release();
      res1->Release();
      alloc->Release();
      -
      D3D12MA::Allocation
      Represents single memory allocation.
      Definition: D3D12MemAlloc.h:473
      +
      D3D12MA::Allocation
      Represents single memory allocation.
      Definition: D3D12MemAlloc.h:483
      D3D12MA::Allocation::GetHeap
      ID3D12Heap * GetHeap() const
      Returns memory heap that the resource is created in.
      -
      D3D12MA::ALLOCATION_DESC
      Parameters of created D3D12MA::Allocation object. To be used with Allocator::CreateResource.
      Definition: D3D12MemAlloc.h:290
      -
      D3D12MA::ALLOCATION_DESC::ExtraHeapFlags
      D3D12_HEAP_FLAGS ExtraHeapFlags
      Additional heap flags to be used when allocating memory.
      Definition: D3D12MemAlloc.h:315
      -
      D3D12MA::ALLOCATION_DESC::HeapType
      D3D12_HEAP_TYPE HeapType
      The type of memory heap where the new allocation should be placed.
      Definition: D3D12MemAlloc.h:299
      +
      D3D12MA::ALLOCATION_DESC
      Parameters of created D3D12MA::Allocation object. To be used with Allocator::CreateResource.
      Definition: D3D12MemAlloc.h:299
      +
      D3D12MA::ALLOCATION_DESC::ExtraHeapFlags
      D3D12_HEAP_FLAGS ExtraHeapFlags
      Additional heap flags to be used when allocating memory.
      Definition: D3D12MemAlloc.h:324
      +
      D3D12MA::ALLOCATION_DESC::HeapType
      D3D12_HEAP_TYPE HeapType
      The type of memory heap where the new allocation should be placed.
      Definition: D3D12MemAlloc.h:308

      Remember that using resouces that alias in memory requires proper synchronization. You need to issue a special barrier of type D3D12_RESOURCE_BARRIER_TYPE_ALIASING. You also need to treat a resource after aliasing as uninitialized - containing garbage data. For example, if you use res1 and then want to use res2, you need to first initialize res2 using either Clear, Discard, or Copy to the entire resource.

      Additional considerations:

        diff --git a/docs/html/search/all_7.js b/docs/html/search/all_7.js index 50de5ed..c602ab1 100644 --- a/docs/html/search/all_7.js +++ b/docs/html/search/all_7.js @@ -4,5 +4,5 @@ var searchData= ['heapflags_1',['HeapFlags',['../struct_d3_d12_m_a_1_1_p_o_o_l___d_e_s_c.html#a3795956e4fbfe7c3a23546e02e5d28dc',1,'D3D12MA::POOL_DESC']]], ['heapproperties_2',['HeapProperties',['../struct_d3_d12_m_a_1_1_p_o_o_l___d_e_s_c.html#a06e06813bcb5206e9f7a8b0564bf1d6a',1,'D3D12MA::POOL_DESC']]], ['heapsfreed_3',['HeapsFreed',['../struct_d3_d12_m_a_1_1_d_e_f_r_a_g_m_e_n_t_a_t_i_o_n___s_t_a_t_s.html#aecc6120afcf75028c9850f8d475b727d',1,'D3D12MA::DEFRAGMENTATION_STATS']]], - ['heaptype_4',['HeapType',['../struct_d3_d12_m_a_1_1_a_l_l_o_c_a_t_i_o_n___d_e_s_c.html#aa46b3c0456e5a23edef3328607ebf4d7',1,'D3D12MA::ALLOCATION_DESC::HeapType()'],['../struct_d3_d12_m_a_1_1_total_statistics.html#a07247152fc70a8ee5605cab0fe220ea5',1,'D3D12MA::TotalStatistics::HeapType()']]] + ['heaptype_4',['HeapType',['../struct_d3_d12_m_a_1_1_a_l_l_o_c_a_t_i_o_n___d_e_s_c.html#aa46b3c0456e5a23edef3328607ebf4d7',1,'D3D12MA::ALLOCATION_DESC::HeapType()'],['../struct_d3_d12_m_a_1_1_total_statistics.html#abad2e48b38f8a73a4daf8577e7a33b89',1,'D3D12MA::TotalStatistics::HeapType()']]] ]; diff --git a/docs/html/search/all_8.js b/docs/html/search/all_8.js index dfdf1c8..22c80f9 100644 --- a/docs/html/search/all_8.js +++ b/docs/html/search/all_8.js @@ -2,5 +2,6 @@ var searchData= [ ['iscachecoherentuma_0',['IsCacheCoherentUMA',['../class_d3_d12_m_a_1_1_allocator.html#a08210561b92c4bd7ede9dd7beba4bb80',1,'D3D12MA::Allocator']]], ['isempty_1',['IsEmpty',['../class_d3_d12_m_a_1_1_virtual_block.html#a7b23fd2da6f0343095fb14b31395678b',1,'D3D12MA::VirtualBlock']]], - ['isuma_2',['IsUMA',['../class_d3_d12_m_a_1_1_allocator.html#a9e742884bd45dd7f01193d13fcd05af0',1,'D3D12MA::Allocator']]] + ['isgpuuploadheapsupported_2',['IsGPUUploadHeapSupported',['../class_d3_d12_m_a_1_1_allocator.html#a3f3fd1e88cf2cd02257fe272e08a273c',1,'D3D12MA::Allocator']]], + ['isuma_3',['IsUMA',['../class_d3_d12_m_a_1_1_allocator.html#a9e742884bd45dd7f01193d13fcd05af0',1,'D3D12MA::Allocator']]] ]; diff --git a/docs/html/search/functions_6.js b/docs/html/search/functions_6.js index dfdf1c8..22c80f9 100644 --- a/docs/html/search/functions_6.js +++ b/docs/html/search/functions_6.js @@ -2,5 +2,6 @@ var searchData= [ ['iscachecoherentuma_0',['IsCacheCoherentUMA',['../class_d3_d12_m_a_1_1_allocator.html#a08210561b92c4bd7ede9dd7beba4bb80',1,'D3D12MA::Allocator']]], ['isempty_1',['IsEmpty',['../class_d3_d12_m_a_1_1_virtual_block.html#a7b23fd2da6f0343095fb14b31395678b',1,'D3D12MA::VirtualBlock']]], - ['isuma_2',['IsUMA',['../class_d3_d12_m_a_1_1_allocator.html#a9e742884bd45dd7f01193d13fcd05af0',1,'D3D12MA::Allocator']]] + ['isgpuuploadheapsupported_2',['IsGPUUploadHeapSupported',['../class_d3_d12_m_a_1_1_allocator.html#a3f3fd1e88cf2cd02257fe272e08a273c',1,'D3D12MA::Allocator']]], + ['isuma_3',['IsUMA',['../class_d3_d12_m_a_1_1_allocator.html#a9e742884bd45dd7f01193d13fcd05af0',1,'D3D12MA::Allocator']]] ]; diff --git a/docs/html/search/variables_5.js b/docs/html/search/variables_5.js index 50de5ed..c602ab1 100644 --- a/docs/html/search/variables_5.js +++ b/docs/html/search/variables_5.js @@ -4,5 +4,5 @@ var searchData= ['heapflags_1',['HeapFlags',['../struct_d3_d12_m_a_1_1_p_o_o_l___d_e_s_c.html#a3795956e4fbfe7c3a23546e02e5d28dc',1,'D3D12MA::POOL_DESC']]], ['heapproperties_2',['HeapProperties',['../struct_d3_d12_m_a_1_1_p_o_o_l___d_e_s_c.html#a06e06813bcb5206e9f7a8b0564bf1d6a',1,'D3D12MA::POOL_DESC']]], ['heapsfreed_3',['HeapsFreed',['../struct_d3_d12_m_a_1_1_d_e_f_r_a_g_m_e_n_t_a_t_i_o_n___s_t_a_t_s.html#aecc6120afcf75028c9850f8d475b727d',1,'D3D12MA::DEFRAGMENTATION_STATS']]], - ['heaptype_4',['HeapType',['../struct_d3_d12_m_a_1_1_a_l_l_o_c_a_t_i_o_n___d_e_s_c.html#aa46b3c0456e5a23edef3328607ebf4d7',1,'D3D12MA::ALLOCATION_DESC::HeapType()'],['../struct_d3_d12_m_a_1_1_total_statistics.html#a07247152fc70a8ee5605cab0fe220ea5',1,'D3D12MA::TotalStatistics::HeapType()']]] + ['heaptype_4',['HeapType',['../struct_d3_d12_m_a_1_1_a_l_l_o_c_a_t_i_o_n___d_e_s_c.html#aa46b3c0456e5a23edef3328607ebf4d7',1,'D3D12MA::ALLOCATION_DESC::HeapType()'],['../struct_d3_d12_m_a_1_1_total_statistics.html#abad2e48b38f8a73a4daf8577e7a33b89',1,'D3D12MA::TotalStatistics::HeapType()']]] ]; diff --git a/docs/html/statistics.html b/docs/html/statistics.html index 07f2e67..bcf04cb 100644 --- a/docs/html/statistics.html +++ b/docs/html/statistics.html @@ -92,9 +92,9 @@ Numeric statistics
        printf("D3D12 reports total usage %llu B with budget %llu B.\n",
        localBudget.UsageBytes,
        localBudget.BudgetBytes);
        -
        D3D12MA::Budget
        Statistics of current memory usage and available budget for a specific memory segment group.
        Definition: D3D12MemAlloc.h:424
        -
        D3D12MA::Budget::BudgetBytes
        UINT64 BudgetBytes
        Estimated amount of memory available to the program.
        Definition: D3D12MemAlloc.h:447
        -
        D3D12MA::Budget::UsageBytes
        UINT64 UsageBytes
        Estimated current memory usage of the program.
        Definition: D3D12MemAlloc.h:436
        +
        D3D12MA::Budget
        Statistics of current memory usage and available budget for a specific memory segment group.
        Definition: D3D12MemAlloc.h:434
        +
        D3D12MA::Budget::BudgetBytes
        UINT64 BudgetBytes
        Estimated amount of memory available to the program.
        Definition: D3D12MemAlloc.h:457
        +
        D3D12MA::Budget::UsageBytes
        UINT64 UsageBytes
        Estimated current memory usage of the program.
        Definition: D3D12MemAlloc.h:446

      You can query for more detailed statistics per heap type, memory segment group, and totals, including minimum and maximum allocation size and unused range size, by calling function D3D12MA::Allocator::CalculateStatistics() and inspecting structure D3D12MA::TotalStatistics. This function is slower though, as it has to traverse all the internal data structures, so it should be used only for debugging purposes.

      You can query for statistics of a custom pool using function D3D12MA::Pool::GetStatistics() or D3D12MA::Pool::CalculateStatistics().

      You can query for information about a specific allocation using functions of the D3D12MA::Allocation class, e.g. GetSize(), GetOffset(), GetHeap().

      diff --git a/docs/html/struct_d3_d12_m_a_1_1_total_statistics-members.html b/docs/html/struct_d3_d12_m_a_1_1_total_statistics-members.html index 7fbd0a7..66a7520 100644 --- a/docs/html/struct_d3_d12_m_a_1_1_total_statistics-members.html +++ b/docs/html/struct_d3_d12_m_a_1_1_total_statistics-members.html @@ -79,7 +79,7 @@ $(function() {

      This is the complete list of members for D3D12MA::TotalStatistics, including all inherited members.

      - +
      HeapTypeD3D12MA::TotalStatistics
      HeapTypeD3D12MA::TotalStatistics
      MemorySegmentGroupD3D12MA::TotalStatistics
      TotalD3D12MA::TotalStatistics
      diff --git a/docs/html/struct_d3_d12_m_a_1_1_total_statistics.html b/docs/html/struct_d3_d12_m_a_1_1_total_statistics.html index 1538657..587eab5 100644 --- a/docs/html/struct_d3_d12_m_a_1_1_total_statistics.html +++ b/docs/html/struct_d3_d12_m_a_1_1_total_statistics.html @@ -87,9 +87,9 @@ $(function() { - - - + + + @@ -101,14 +101,14 @@ Public Attributes

      General statistics from current state of the allocator - total memory usage across all memory heaps and segments.

      These are slower to calculate. Use for debugging purposes. See function D3D12MA::Allocator::CalculateStatistics().

      Member Data Documentation

      - -

      ◆ HeapType

      + +

      ◆ HeapType

      Public Attributes

      DetailedStatistics HeapType [4]
       One element for each type of heap located at the following indices:
       
      DetailedStatistics HeapType [5]
       One element for each type of heap located at the following indices:
       
      DetailedStatistics MemorySegmentGroup [2]
       One element for each memory segment group located at the following indices:
       
      - +
      DetailedStatistics D3D12MA::TotalStatistics::HeapType[4]DetailedStatistics D3D12MA::TotalStatistics::HeapType[5]
      @@ -118,7 +118,8 @@ Public Attributes
    7. 0 = D3D12_HEAP_TYPE_DEFAULT
    8. 1 = D3D12_HEAP_TYPE_UPLOAD
    9. 2 = D3D12_HEAP_TYPE_READBACK
      10. -
    10. 3 = D3D12_HEAP_TYPE_CUSTOM
      11. +
    11. 3 = D3D12_HEAP_TYPE_CUSTOM
      12. +
    12. 4 = D3D12_HEAP_TYPE_GPU_UPLOAD
      13. @@ -143,7 +144,7 @@ Public Attributes

      Meaning of these segment groups is:

      • When IsUMA() == FALSE (discrete graphics card):
          -
        • DXGI_MEMORY_SEGMENT_GROUP_LOCAL (index 0) represents GPU memory (resources allocated in D3D12_HEAP_TYPE_DEFAULT or D3D12_MEMORY_POOL_L1).
          • +
        • DXGI_MEMORY_SEGMENT_GROUP_LOCAL (index 0) represents GPU memory (resources allocated in D3D12_HEAP_TYPE_DEFAULT, D3D12_HEAP_TYPE_GPU_UPLOAD or D3D12_MEMORY_POOL_L1).
        • DXGI_MEMORY_SEGMENT_GROUP_NON_LOCAL (index 1) represents system memory (resources allocated in D3D12_HEAP_TYPE_UPLOAD, D3D12_HEAP_TYPE_READBACK, or D3D12_MEMORY_POOL_L0).
        • diff --git a/docs/html/virtual_allocator.html b/docs/html/virtual_allocator.html index da10590..bee43c8 100644 --- a/docs/html/virtual_allocator.html +++ b/docs/html/virtual_allocator.html @@ -90,9 +90,9 @@ Creating virtual block
        D3D12MA::VirtualBlock *block;
        HRESULT hr = CreateVirtualBlock(&blockDesc, &block);
        -
        D3D12MA::VirtualBlock
        Represents pure allocation algorithm and a data structure with allocations in some memory block,...
        Definition: D3D12MemAlloc.h:1507
        -
        D3D12MA::VIRTUAL_BLOCK_DESC
        Parameters of created D3D12MA::VirtualBlock object to be passed to CreateVirtualBlock().
        Definition: D3D12MemAlloc.h:1413
        -
        D3D12MA::VIRTUAL_BLOCK_DESC::Size
        UINT64 Size
        Total size of the block.
        Definition: D3D12MemAlloc.h:1421
        +
        D3D12MA::VirtualBlock
        Represents pure allocation algorithm and a data structure with allocations in some memory block,...
        Definition: D3D12MemAlloc.h:1526
        +
        D3D12MA::VIRTUAL_BLOCK_DESC
        Parameters of created D3D12MA::VirtualBlock object to be passed to CreateVirtualBlock().
        Definition: D3D12MemAlloc.h:1432
        +
        D3D12MA::VIRTUAL_BLOCK_DESC::Size
        UINT64 Size
        Total size of the block.
        Definition: D3D12MemAlloc.h:1440

        Making virtual allocations

        D3D12MA::VirtualBlock object contains internal data structure that keeps track of free and occupied regions using the same code as the main D3D12 memory allocator. A single allocation is identified by a lightweight structure D3D12MA::VirtualAllocation. You will also likely want to know the offset at which the allocation was made in the block.

        @@ -117,9 +117,9 @@ Making virtual allocations
        // Allocation failed - no space for it could be found. Handle this error!
        }
        D3D12MA::VirtualBlock::Allocate
        HRESULT Allocate(const VIRTUAL_ALLOCATION_DESC *pDesc, VirtualAllocation *pAllocation, UINT64 *pOffset)
        Creates new allocation.
        -
        D3D12MA::VIRTUAL_ALLOCATION_DESC
        Parameters of created virtual allocation to be passed to VirtualBlock::Allocate().
        Definition: D3D12MemAlloc.h:1458
        -
        D3D12MA::VIRTUAL_ALLOCATION_DESC::Size
        UINT64 Size
        Size of the allocation.
        Definition: D3D12MemAlloc.h:1465
        -
        D3D12MA::VirtualAllocation
        Represents single memory allocation done inside VirtualBlock.
        Definition: D3D12MemAlloc.h:453
        +
        D3D12MA::VIRTUAL_ALLOCATION_DESC
        Parameters of created virtual allocation to be passed to VirtualBlock::Allocate().
        Definition: D3D12MemAlloc.h:1477
        +
        D3D12MA::VIRTUAL_ALLOCATION_DESC::Size
        UINT64 Size
        Size of the allocation.
        Definition: D3D12MemAlloc.h:1484
        +
        D3D12MA::VirtualAllocation
        Represents single memory allocation done inside VirtualBlock.
        Definition: D3D12MemAlloc.h:463

        Deallocation

        When no longer needed, an allocation can be freed by calling D3D12MA::VirtualBlock::FreeAllocation.

        @@ -156,7 +156,7 @@ Alignment and units
        D3D12MA::VirtualAllocation alloc;
        UINT64 allocOffset;
        hr = block->Allocate(&allocDesc, &alloc, &allocOffset);
        -
        D3D12MA::VIRTUAL_ALLOCATION_DESC::Alignment
        UINT64 Alignment
        Required alignment of the allocation.
        Definition: D3D12MemAlloc.h:1470
        +
        D3D12MA::VIRTUAL_ALLOCATION_DESC::Alignment
        UINT64 Alignment
        Required alignment of the allocation.
        Definition: D3D12MemAlloc.h:1489

        Alignments of different allocations made from one block may vary. However, if all alignments and sizes are always multiply of some size e.g. 4 B or sizeof(MyDataStruct), you can express all sizes, alignments, and offsets in multiples of that size instead of individual bytes. It might be more convenient, but you need to make sure to use this new unit consistently in all the places:

        • D3D12MA::VIRTUAL_BLOCK_DESC::Size
          • @@ -171,9 +171,9 @@ Statistics
          printf("My virtual block has %llu bytes used by %u virtual allocations\n",
          stats.AllocationBytes, stats.AllocationCount);
          D3D12MA::VirtualBlock::GetStatistics
          void GetStatistics(Statistics *pStats) const
          Retrieves basic statistics of the virtual block that are fast to calculate.
          -
          D3D12MA::Statistics
          Calculated statistics of memory usage e.g. in a specific memory heap type, memory segment group,...
          Definition: D3D12MemAlloc.h:332
          -
          D3D12MA::Statistics::AllocationBytes
          UINT64 AllocationBytes
          Total number of bytes occupied by all D3D12MA::Allocation objects.
          Definition: D3D12MemAlloc.h:350
          -
          D3D12MA::Statistics::AllocationCount
          UINT AllocationCount
          Number of D3D12MA::Allocation objects allocated.
          Definition: D3D12MemAlloc.h:340
          +
          D3D12MA::Statistics
          Calculated statistics of memory usage e.g. in a specific memory heap type, memory segment group,...
          Definition: D3D12MemAlloc.h:341
          +
          D3D12MA::Statistics::AllocationBytes
          UINT64 AllocationBytes
          Total number of bytes occupied by all D3D12MA::Allocation objects.
          Definition: D3D12MemAlloc.h:359
          +
          D3D12MA::Statistics::AllocationCount
          UINT AllocationCount
          Number of D3D12MA::Allocation objects allocated.
          Definition: D3D12MemAlloc.h:349

          More detailed statistics can be obtained using function D3D12MA::VirtualBlock::CalculateStatistics(), but they are slower to calculate.

          You can also request a full list of allocations and free regions as a string in JSON format by calling D3D12MA::VirtualBlock::BuildStatsString. Returned string must be later freed using D3D12MA::VirtualBlock::FreeStatsString. The format of this string may differ from the one returned by the main D3D12 allocator, but it is similar.

          diff --git a/include/D3D12MemAlloc.h b/include/D3D12MemAlloc.h index 4bf64ee..6cf8ebc 100644 --- a/include/D3D12MemAlloc.h +++ b/include/D3D12MemAlloc.h @@ -24,9 +24,9 @@ /** \mainpage D3D12 Memory Allocator -Version 2.1.0-development (2022-12-15) +Version 2.1.0-development (2023-07-05) -Copyright (c) 2019-2022 Advanced Micro Devices, Inc. All rights reserved. \n +Copyright (c) 2019-2023 Advanced Micro Devices, Inc. All rights reserved. \n License: MIT Documentation of all members: D3D12MemAlloc.h @@ -402,8 +402,9 @@ struct TotalStatistics - 1 = `D3D12_HEAP_TYPE_UPLOAD` - 2 = `D3D12_HEAP_TYPE_READBACK` - 3 = `D3D12_HEAP_TYPE_CUSTOM` + - 4 = `D3D12_HEAP_TYPE_GPU_UPLOAD` */ - DetailedStatistics HeapType[4]; + DetailedStatistics HeapType[5]; /** \brief One element for each memory segment group located at the following indices: - 0 = `DXGI_MEMORY_SEGMENT_GROUP_LOCAL` @@ -413,9 +414,9 @@ struct TotalStatistics - When `IsUMA() == FALSE` (discrete graphics card): - `DXGI_MEMORY_SEGMENT_GROUP_LOCAL` (index 0) represents GPU memory - (resources allocated in `D3D12_HEAP_TYPE_DEFAULT` or `D3D12_MEMORY_POOL_L1`). + (resources allocated in `D3D12_HEAP_TYPE_DEFAULT`, `D3D12_HEAP_TYPE_GPU_UPLOAD` or `D3D12_MEMORY_POOL_L1`). - `DXGI_MEMORY_SEGMENT_GROUP_NON_LOCAL` (index 1) represents system memory - (resources allocated in `D3D12_HEAP_TYPE_UPLOAD`, `D3D12_HEAP_TYPE_READBACK`, or `D3D12_MEMORY_POOL_L0`). + (resources allocated in `D3D12_HEAP_TYPE_UPLOAD`, `D3D12_HEAP_TYPE_READBACK`, or `D3D12_MEMORY_POOL_L0`). - When `IsUMA() == TRUE` (integrated graphics chip): - `DXGI_MEMORY_SEGMENT_GROUP_LOCAL` = (index 0) represents memory shared for all the resources. - `DXGI_MEMORY_SEGMENT_GROUP_NON_LOCAL` = (index 1) is unused and always 0. @@ -1130,6 +1131,15 @@ public: - "ID3D12Device::GetCustomHeapProperties method (d3d12.h)" */ BOOL IsCacheCoherentUMA() const; + /** \brief Returns true if GPU Upload Heaps are supported on the current system. + + When true, you can use `D3D12_HEAP_TYPE_GPU_UPLOAD`. + + This flag is fetched from `D3D12_FEATURE_D3D12_OPTIONS16::GPUUploadHeapSupported`. + + `#define D3D12MA_OPTIONS16_SUPPORTED 1` is needed for the compilation of this library. Otherwise the flag is always false. + */ + BOOL IsGPUUploadHeapSupported() const; /** \brief Returns total amount of memory of specific segment group, in bytes. \param memorySegmentGroup use `DXGI_MEMORY_SEGMENT_GROUP_LOCAL` or DXGI_MEMORY_SEGMENT_GROUP_NON_LOCAL`. @@ -1333,7 +1343,7 @@ public: - `pNonLocalBudget` returns the budget of the system memory available for D3D12 resources. - When IsUMA() `== TRUE` (integrated graphics chip): - `pLocalBudget` returns the budget of the shared memory available for all D3D12 resources. - All memory is considered "local". + All memory is considered "local". - `pNonLocalBudget` is not applicable and returns zeros. This function is called "get" not "calculate" because it is very fast, suitable to be called diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt index 10ac885..17f253a 100644 --- a/src/CMakeLists.txt +++ b/src/CMakeLists.txt @@ -17,8 +17,7 @@ set_target_properties( D3D12MemoryAllocator PROPERTIES CXX_EXTENSIONS OFF - # Use C++14 - CXX_STANDARD 14 + CXX_STANDARD 17 CXX_STANDARD_REQUIRED ON OUTPUT_NAME "D3D12MA" @@ -108,8 +107,7 @@ if(D3D12MA_BUILD_SAMPLE) D3D12Sample PROPERTIES CXX_EXTENSIONS OFF - # Use C++14 - CXX_STANDARD 14 + CXX_STANDARD 17 CXX_STANDARD_REQUIRED ON ) @@ -126,3 +124,35 @@ if(D3D12MA_BUILD_SAMPLE) message(STATUS "D3D12Sample application is not supported to Linux") endif() endif() + +set(D3D12MA_AGILITY_SDK_DIRECTORY "" CACHE STRING "Path to unpacked DX12 Agility SDK. Leave empty to compile without it.") +option(D3D12MA_AGILITY_SDK_PREVIEW "Set if DX12 Agility SDK is preview version." OFF) +if(D3D12MA_AGILITY_SDK_DIRECTORY) + if(EXISTS "${D3D12MA_AGILITY_SDK_DIRECTORY}/build/native/include/d3d12.h") + message(STATUS "DX12 Agility SDK used from \"${D3D12MA_AGILITY_SDK_DIRECTORY}\".") + target_compile_definitions(D3D12MemoryAllocator PRIVATE D3D12MA_USE_AGILITY_SDK=1) + target_include_directories(D3D12MemoryAllocator BEFORE PRIVATE "${D3D12MA_AGILITY_SDK_DIRECTORY}/build/native/include") + if(D3D12MA_AGILITY_SDK_PREVIEW) + target_compile_definitions(D3D12MemoryAllocator PRIVATE D3D12MA_USE_AGILITY_SDK_PREVIEW=1) + endif() + if(${D3D12MA_BUILD_SAMPLE} AND ${WIN32}) + target_compile_definitions(D3D12Sample PRIVATE D3D12MA_USE_AGILITY_SDK=1) + target_include_directories(D3D12Sample BEFORE PRIVATE "${D3D12MA_AGILITY_SDK_DIRECTORY}/build/native/include") + if(D3D12MA_AGILITY_SDK_PREVIEW) + target_compile_definitions(D3D12Sample PRIVATE D3D12MA_USE_AGILITY_SDK_PREVIEW=1) + endif() + endif() + else() + message(FATAL_ERROR "DX12 Agility SDK not found - cannot find file \"${D3D12MA_AGILITY_SDK_DIRECTORY}/build/native/include/d3d12.h\".") + endif() +else() + message(STATUS "DX12 Agility SDK not used.") +endif() + +option(D3D12MA_OPTIONS16_SUPPORTED "Set if using Agility SDK 1.710.0-preview or newer that defines D3D12_FEATURE_DATA_D3D12_OPTIONS16." OFF) +if(D3D12MA_OPTIONS16_SUPPORTED) + target_compile_definitions(D3D12MemoryAllocator PRIVATE D3D12MA_OPTIONS16_SUPPORTED=1) + if(${D3D12MA_BUILD_SAMPLE} AND ${WIN32}) + target_compile_definitions(D3D12Sample PRIVATE D3D12MA_OPTIONS16_SUPPORTED=1) + endif() +endif() diff --git a/src/D3D12MemAlloc.cpp b/src/D3D12MemAlloc.cpp index ed88072..aad198b 100644 --- a/src/D3D12MemAlloc.cpp +++ b/src/D3D12MemAlloc.cpp @@ -134,9 +134,9 @@ especially to test compatibility with D3D12_RESOURCE_HEAP_TIER_1 on modern GPUs. namespace D3D12MA { -static constexpr UINT HEAP_TYPE_COUNT = 4; -static constexpr UINT STANDARD_HEAP_TYPE_COUNT = 3; // Only DEFAULT, UPLOAD, READBACK. -static constexpr UINT DEFAULT_POOL_MAX_COUNT = 9; +static constexpr UINT HEAP_TYPE_COUNT = 5; +static constexpr UINT STANDARD_HEAP_TYPE_COUNT = 4; // Only DEFAULT, UPLOAD, READBACK, GPU_UPLOAD. +static constexpr UINT DEFAULT_POOL_MAX_COUNT = STANDARD_HEAP_TYPE_COUNT * 3; static const UINT NEW_BLOCK_SIZE_SHIFT_MAX = 3; // Minimum size of a free suballocation to register it in the free suballocation collection. static const UINT64 MIN_FREE_SUBALLOCATION_SIZE_TO_REGISTER = 16; @@ -147,6 +147,14 @@ static const WCHAR* const HeapTypeNames[] = L"UPLOAD", L"READBACK", L"CUSTOM", + L"GPU_UPLOAD", +}; +static const WCHAR* const StandardHeapTypeNames[] = +{ + L"DEFAULT", + L"UPLOAD", + L"READBACK", + L"GPU_UPLOAD", }; static const D3D12_HEAP_FLAGS RESOURCE_CLASS_HEAP_FLAGS = @@ -154,6 +162,8 @@ static const D3D12_HEAP_FLAGS RESOURCE_CLASS_HEAP_FLAGS = static const D3D12_RESIDENCY_PRIORITY D3D12_RESIDENCY_PRIORITY_NONE = D3D12_RESIDENCY_PRIORITY(0); +static const D3D12_HEAP_TYPE D3D12_HEAP_TYPE_GPU_UPLOAD_COPY = (D3D12_HEAP_TYPE)5; + #ifndef _D3D12MA_ENUM_DECLARATIONS // Local copy of this enum, as it is provided only by , so it may not be available. @@ -452,23 +462,28 @@ static IterT BinaryFindSorted(const IterT& beg, const IterT& end, const KeyT& va return end; } -static UINT HeapTypeToIndex(D3D12_HEAP_TYPE type) +static UINT StandardHeapTypeToIndex(D3D12_HEAP_TYPE type) { switch (type) { case D3D12_HEAP_TYPE_DEFAULT: return 0; case D3D12_HEAP_TYPE_UPLOAD: return 1; case D3D12_HEAP_TYPE_READBACK: return 2; - case D3D12_HEAP_TYPE_CUSTOM: return 3; + case D3D12_HEAP_TYPE_GPU_UPLOAD_COPY: return 3; default: D3D12MA_ASSERT(0); return UINT_MAX; } } -static D3D12_HEAP_TYPE IndexToHeapType(UINT heapTypeIndex) +static D3D12_HEAP_TYPE IndexToStandardHeapType(UINT heapTypeIndex) { - D3D12MA_ASSERT(heapTypeIndex < 4); - // D3D12_HEAP_TYPE_DEFAULT starts at 1. - return (D3D12_HEAP_TYPE)(heapTypeIndex + 1); + switch(heapTypeIndex) + { + case 0: return D3D12_HEAP_TYPE_DEFAULT; + case 1: return D3D12_HEAP_TYPE_UPLOAD; + case 2: return D3D12_HEAP_TYPE_READBACK; + case 3: return D3D12_HEAP_TYPE_GPU_UPLOAD_COPY; + default: D3D12MA_ASSERT(0); return D3D12_HEAP_TYPE_CUSTOM; + } } static UINT64 HeapFlagsToAlignment(D3D12_HEAP_FLAGS flags, bool denyMsaaTextures) @@ -516,7 +531,8 @@ static bool IsHeapTypeStandard(D3D12_HEAP_TYPE type) { return type == D3D12_HEAP_TYPE_DEFAULT || type == D3D12_HEAP_TYPE_UPLOAD || - type == D3D12_HEAP_TYPE_READBACK; + type == D3D12_HEAP_TYPE_READBACK || + type == D3D12_HEAP_TYPE_GPU_UPLOAD_COPY; } static D3D12_HEAP_PROPERTIES StandardHeapTypeToHeapProperties(D3D12_HEAP_TYPE type) @@ -6558,6 +6574,7 @@ public: BOOL IsUMA() const { return m_D3D12Architecture.UMA; } BOOL IsCacheCoherentUMA() const { return m_D3D12Architecture.CacheCoherentUMA; } bool SupportsResourceHeapTier2() const { return m_D3D12Options.ResourceHeapTier >= D3D12_RESOURCE_HEAP_TIER_2; } + bool IsGPUUploadHeapSupported() const { return m_GPUUploadHeapSupported != FALSE; } bool UseMutex() const { return m_UseMutex; } AllocationObjectAllocator& GetAllocationObjectAllocator() { return m_AllocationObjectAllocator; } UINT GetCurrentFrameIndex() const { return m_CurrentFrameIndex.load(); } @@ -6566,6 +6583,7 @@ public: 0: D3D12_HEAP_TYPE_DEFAULT 1: D3D12_HEAP_TYPE_UPLOAD 2: D3D12_HEAP_TYPE_READBACK + 3: D3D12_HEAP_TYPE_GPU_UPLOAD else: 0: D3D12_HEAP_TYPE_DEFAULT + buffer 1: D3D12_HEAP_TYPE_DEFAULT + texture @@ -6576,8 +6594,11 @@ public: 6: D3D12_HEAP_TYPE_READBACK + buffer 7: D3D12_HEAP_TYPE_READBACK + texture 8: D3D12_HEAP_TYPE_READBACK + texture RT or DS + 9: D3D12_HEAP_TYPE_GPU_UPLOAD + buffer + 10: D3D12_HEAP_TYPE_GPU_UPLOAD + texture + 11: D3D12_HEAP_TYPE_GPU_UPLOAD + texture RT or DS */ - UINT GetDefaultPoolCount() const { return SupportsResourceHeapTier2() ? 3 : 9; } + UINT GetDefaultPoolCount() const { return SupportsResourceHeapTier2() ? 4 : 12; } BlockVector** GetDefaultPools() { return m_BlockVectors; } HRESULT Init(const ALLOCATOR_DESC& desc); @@ -6625,8 +6646,8 @@ public: void SetResidencyPriority(ID3D12Pageable* obj, D3D12_RESIDENCY_PRIORITY priority) const; void SetCurrentFrameIndex(UINT frameIndex); - // For more deailed stats use outCutomHeaps to access statistics divided into L0 and L1 group - void CalculateStatistics(TotalStatistics& outStats, DetailedStatistics outCutomHeaps[2] = NULL); + // For more deailed stats use outCustomHeaps to access statistics divided into L0 and L1 group + void CalculateStatistics(TotalStatistics& outStats, DetailedStatistics outCustomHeaps[2] = NULL); void GetBudget(Budget* outLocalBudget, Budget* outNonLocalBudget); void GetBudgetForHeapType(Budget& outBudget, D3D12_HEAP_TYPE heapType); @@ -6663,6 +6684,7 @@ private: D3D12MA_ATOMIC_UINT32 m_CurrentFrameIndex; DXGI_ADAPTER_DESC m_AdapterDesc; D3D12_FEATURE_DATA_D3D12_OPTIONS m_D3D12Options; + BOOL m_GPUUploadHeapSupported = FALSE; D3D12_FEATURE_DATA_ARCHITECTURE m_D3D12Architecture; AllocationObjectAllocator m_AllocationObjectAllocator; @@ -6747,7 +6769,7 @@ AllocatorPimpl::AllocatorPimpl(const ALLOCATION_CALLBACKS& allocationCallbacks, { m_CommittedAllocations[i].Init( m_UseMutex, - (D3D12_HEAP_TYPE)(D3D12_HEAP_TYPE_DEFAULT + i), + IndexToStandardHeapType(i), NULL); // pool } @@ -6802,6 +6824,20 @@ HRESULT AllocatorPimpl::Init(const ALLOCATOR_DESC& desc) m_D3D12Options.ResourceHeapTier = (D3D12MA_FORCE_RESOURCE_HEAP_TIER); #endif +// You must define this macro to like `#define D3D12MA_OPTIONS16_SUPPORTED 1` to enable GPU Upload Heaps! +// Unfortunately there is no way to programmatically check if the included defines D3D12_FEATURE_DATA_D3D12_OPTIONS16 or not. +// Main interfaces have respective macros like __ID3D12Device4_INTERFACE_DEFINED__, but structures like this do not. +#if D3D12MA_OPTIONS16_SUPPORTED + { + D3D12_FEATURE_DATA_D3D12_OPTIONS16 options16 = {}; + hr = m_Device->CheckFeatureSupport(D3D12_FEATURE_D3D12_OPTIONS16, &options16, sizeof(options16)); + if (SUCCEEDED(hr)) + { + m_GPUUploadHeapSupported = options16.GPUUploadHeapSupported; + } + } +#endif + hr = m_Device->CheckFeatureSupport(D3D12_FEATURE_ARCHITECTURE, &m_D3D12Architecture, sizeof(m_D3D12Architecture)); if (FAILED(hr)) { @@ -6901,7 +6937,7 @@ UINT AllocatorPimpl::StandardHeapTypeToMemorySegmentGroup(D3D12_HEAP_TYPE heapTy D3D12MA_ASSERT(IsHeapTypeStandard(heapType)); if (IsUMA()) return DXGI_MEMORY_SEGMENT_GROUP_LOCAL_COPY; - return heapType == D3D12_HEAP_TYPE_DEFAULT ? + return (heapType == D3D12_HEAP_TYPE_DEFAULT || heapType == D3D12_HEAP_TYPE_GPU_UPLOAD_COPY) ? DXGI_MEMORY_SEGMENT_GROUP_LOCAL_COPY : DXGI_MEMORY_SEGMENT_GROUP_NON_LOCAL_COPY; } @@ -7253,7 +7289,7 @@ void AllocatorPimpl::SetCurrentFrameIndex(UINT frameIndex) #endif } -void AllocatorPimpl::CalculateStatistics(TotalStatistics& outStats, DetailedStatistics outCutomHeaps[2]) +void AllocatorPimpl::CalculateStatistics(TotalStatistics& outStats, DetailedStatistics outCustomHeaps[2]) { // Init stats for (size_t i = 0; i < HEAP_TYPE_COUNT; i++) @@ -7261,21 +7297,22 @@ void AllocatorPimpl::CalculateStatistics(TotalStatistics& outStats, DetailedStat for (size_t i = 0; i < DXGI_MEMORY_SEGMENT_GROUP_COUNT; i++) ClearDetailedStatistics(outStats.MemorySegmentGroup[i]); ClearDetailedStatistics(outStats.Total); - if (outCutomHeaps) + if (outCustomHeaps) { - ClearDetailedStatistics(outCutomHeaps[0]); - ClearDetailedStatistics(outCutomHeaps[1]); + ClearDetailedStatistics(outCustomHeaps[0]); + ClearDetailedStatistics(outCustomHeaps[1]); } - // Process default pools. 3 standard heap types only. Add them to outStats.HeapType[i]. + // Process default pools. 4 standard heap types only. Add them to outStats.HeapType[i]. if (SupportsResourceHeapTier2()) { - // DEFAULT, UPLOAD, READBACK. + // DEFAULT, UPLOAD, READBACK, GPU_UPLOAD. for (size_t heapTypeIndex = 0; heapTypeIndex < STANDARD_HEAP_TYPE_COUNT; ++heapTypeIndex) { BlockVector* const pBlockVector = m_BlockVectors[heapTypeIndex]; D3D12MA_ASSERT(pBlockVector); - pBlockVector->AddDetailedStatistics(outStats.HeapType[heapTypeIndex]); + const size_t outputIndex = heapTypeIndex < 3 ? heapTypeIndex : 4; // GPU_UPLOAD 3 -> 4 + pBlockVector->AddDetailedStatistics(outStats.HeapType[outputIndex]); } } else @@ -7287,7 +7324,9 @@ void AllocatorPimpl::CalculateStatistics(TotalStatistics& outStats, DetailedStat { BlockVector* const pBlockVector = m_BlockVectors[heapTypeIndex * 3 + heapSubType]; D3D12MA_ASSERT(pBlockVector); - pBlockVector->AddDetailedStatistics(outStats.HeapType[heapTypeIndex]); + + const size_t outputIndex = heapTypeIndex < 3 ? heapTypeIndex : 4; // GPU_UPLOAD 3 -> 4 + pBlockVector->AddDetailedStatistics(outStats.HeapType[outputIndex]); } } } @@ -7302,6 +7341,9 @@ void AllocatorPimpl::CalculateStatistics(TotalStatistics& outStats, DetailedStat AddDetailedStatistics( outStats.MemorySegmentGroup[StandardHeapTypeToMemorySegmentGroup(D3D12_HEAP_TYPE_READBACK)], outStats.HeapType[2]); + AddDetailedStatistics( + outStats.MemorySegmentGroup[StandardHeapTypeToMemorySegmentGroup(D3D12_HEAP_TYPE_GPU_UPLOAD_COPY)], + outStats.HeapType[4]); // Process custom pools. DetailedStatistics tmpStats; @@ -7321,20 +7363,21 @@ void AllocatorPimpl::CalculateStatistics(TotalStatistics& outStats, DetailedStat AddDetailedStatistics( outStats.MemorySegmentGroup[memorySegment], tmpStats); - if (outCutomHeaps) - AddDetailedStatistics(outCutomHeaps[memorySegment], tmpStats); + if (outCustomHeaps) + AddDetailedStatistics(outCustomHeaps[memorySegment], tmpStats); } } - // Process committed allocations. 3 standard heap types only. + // Process committed allocations. standard heap types only. for (UINT heapTypeIndex = 0; heapTypeIndex < STANDARD_HEAP_TYPE_COUNT; ++heapTypeIndex) { ClearDetailedStatistics(tmpStats); m_CommittedAllocations[heapTypeIndex].AddDetailedStatistics(tmpStats); + const size_t outputIndex = heapTypeIndex < 3 ? heapTypeIndex : 4; // GPU_UPLOAD 3 -> 4 AddDetailedStatistics( - outStats.HeapType[heapTypeIndex], tmpStats); + outStats.HeapType[outputIndex], tmpStats); AddDetailedStatistics( - outStats.MemorySegmentGroup[StandardHeapTypeToMemorySegmentGroup(IndexToHeapType(heapTypeIndex))], tmpStats); + outStats.MemorySegmentGroup[StandardHeapTypeToMemorySegmentGroup(IndexToStandardHeapType(heapTypeIndex))], tmpStats); } // Sum up memory segment groups to totals. @@ -7354,19 +7397,24 @@ void AllocatorPimpl::CalculateStatistics(TotalStatistics& outStats, DetailedStat D3D12MA_ASSERT(outStats.Total.Stats.BlockCount == outStats.HeapType[0].Stats.BlockCount + outStats.HeapType[1].Stats.BlockCount + - outStats.HeapType[2].Stats.BlockCount + outStats.HeapType[3].Stats.BlockCount); + outStats.HeapType[2].Stats.BlockCount + outStats.HeapType[3].Stats.BlockCount + + outStats.HeapType[4].Stats.BlockCount); D3D12MA_ASSERT(outStats.Total.Stats.AllocationCount == outStats.HeapType[0].Stats.AllocationCount + outStats.HeapType[1].Stats.AllocationCount + - outStats.HeapType[2].Stats.AllocationCount + outStats.HeapType[3].Stats.AllocationCount); + outStats.HeapType[2].Stats.AllocationCount + outStats.HeapType[3].Stats.AllocationCount + + outStats.HeapType[4].Stats.AllocationCount); D3D12MA_ASSERT(outStats.Total.Stats.BlockBytes == outStats.HeapType[0].Stats.BlockBytes + outStats.HeapType[1].Stats.BlockBytes + - outStats.HeapType[2].Stats.BlockBytes + outStats.HeapType[3].Stats.BlockBytes); + outStats.HeapType[2].Stats.BlockBytes + outStats.HeapType[3].Stats.BlockBytes + + outStats.HeapType[4].Stats.BlockBytes); D3D12MA_ASSERT(outStats.Total.Stats.AllocationBytes == outStats.HeapType[0].Stats.AllocationBytes + outStats.HeapType[1].Stats.AllocationBytes + - outStats.HeapType[2].Stats.AllocationBytes + outStats.HeapType[3].Stats.AllocationBytes); + outStats.HeapType[2].Stats.AllocationBytes + outStats.HeapType[3].Stats.AllocationBytes + + outStats.HeapType[4].Stats.AllocationBytes); D3D12MA_ASSERT(outStats.Total.UnusedRangeCount == outStats.HeapType[0].UnusedRangeCount + outStats.HeapType[1].UnusedRangeCount + - outStats.HeapType[2].UnusedRangeCount + outStats.HeapType[3].UnusedRangeCount); + outStats.HeapType[2].UnusedRangeCount + outStats.HeapType[3].UnusedRangeCount + + outStats.HeapType[4].UnusedRangeCount); } void AllocatorPimpl::GetBudget(Budget* outLocalBudget, Budget* outNonLocalBudget) @@ -7414,6 +7462,7 @@ void AllocatorPimpl::GetBudgetForHeapType(Budget& outBudget, D3D12_HEAP_TYPE hea switch (heapType) { case D3D12_HEAP_TYPE_DEFAULT: + case D3D12_HEAP_TYPE_GPU_UPLOAD_COPY: GetBudget(&outBudget, NULL); break; case D3D12_HEAP_TYPE_UPLOAD: @@ -7470,6 +7519,9 @@ void AllocatorPimpl::BuildStatsString(WCHAR** ppStatsString, BOOL detailedMap) json.WriteBool(m_D3D12Architecture.UMA); json.WriteString(L"CacheCoherentUMA"); json.WriteBool(m_D3D12Architecture.CacheCoherentUMA); + + json.WriteString(L"GPUUploadHeapSupported"); + json.WriteBool(m_GPUUploadHeapSupported != FALSE); } json.EndObject(); } @@ -7502,6 +7554,17 @@ void AllocatorPimpl::BuildStatsString(WCHAR** ppStatsString, BOOL detailedMap) json.AddDetailedStatisticsInfoObject(stats.HeapType[0]); } json.EndObject(); + + if(IsGPUUploadHeapSupported()) + { + json.WriteString(L"GPU_UPLOAD"); + json.BeginObject(); + { + json.WriteString(L"Stats"); + json.AddDetailedStatisticsInfoObject(stats.HeapType[4]); + } + json.EndObject(); + } } json.WriteString(L"UPLOAD"); json.BeginObject(); @@ -7552,6 +7615,17 @@ void AllocatorPimpl::BuildStatsString(WCHAR** ppStatsString, BOOL detailedMap) } json.EndObject(); + if(IsGPUUploadHeapSupported()) + { + json.WriteString(L"GPU_UPLOAD"); + json.BeginObject(); + { + json.WriteString(L"Stats"); + json.AddDetailedStatisticsInfoObject(stats.HeapType[4]); + } + json.EndObject(); + } + json.WriteString(L"CUSTOM"); json.BeginObject(); { @@ -7678,7 +7752,7 @@ void AllocatorPimpl::BuildStatsString(WCHAR** ppStatsString, BOOL detailedMap) { for (uint8_t heapType = 0; heapType < STANDARD_HEAP_TYPE_COUNT; ++heapType) { - json.WriteString(HeapTypeNames[heapType]); + json.WriteString(StandardHeapTypeNames[heapType]); json.BeginObject(); writeHeapInfo(m_BlockVectors[heapType], m_CommittedAllocations + heapType, false); json.EndObject(); @@ -7695,11 +7769,11 @@ void AllocatorPimpl::BuildStatsString(WCHAR** ppStatsString, BOOL detailedMap) L" - Textures", L" - Textures RT/DS", }; - json.BeginString(HeapTypeNames[heapType]); + json.BeginString(StandardHeapTypeNames[heapType]); json.EndString(heapSubTypeName[heapSubType]); json.BeginObject(); - writeHeapInfo(m_BlockVectors[heapType + heapSubType], m_CommittedAllocations + heapType, false); + writeHeapInfo(m_BlockVectors[heapType * 3 + heapSubType], m_CommittedAllocations + heapType, false); json.EndObject(); } } @@ -7989,6 +8063,9 @@ HRESULT AllocatorPimpl::CalcAllocationParams(const ALLOCATION_DESC& allocDesc, U outCommittedAllocationParams = CommittedAllocationParameters(); outPreferCommitted = false; + D3D12MA_ASSERT((allocDesc.HeapType != D3D12_HEAP_TYPE_GPU_UPLOAD_COPY || IsGPUUploadHeapSupported()) && + "Trying to allocate from D3D12_HEAP_TYPE_GPU_UPLOAD while GPUUploadHeapSupported == FALSE or D3D12MA_OPTIONS16_SUPPORTED macro was not defined when compiling D3D12MA library."); + bool msaaAlwaysCommitted; if (allocDesc.CustomPool != NULL) { @@ -8014,7 +8091,7 @@ HRESULT AllocatorPimpl::CalcAllocationParams(const ALLOCATION_DESC& allocDesc, U outCommittedAllocationParams.m_HeapProperties = StandardHeapTypeToHeapProperties(allocDesc.HeapType); outCommittedAllocationParams.m_HeapFlags = allocDesc.ExtraHeapFlags; - outCommittedAllocationParams.m_List = &m_CommittedAllocations[HeapTypeToIndex(allocDesc.HeapType)]; + outCommittedAllocationParams.m_List = &m_CommittedAllocations[StandardHeapTypeToIndex(allocDesc.HeapType)]; // outCommittedAllocationParams.m_ResidencyPriority intentionally left with default value. const ResourceClass resourceClass = (resDesc != NULL) ? @@ -8088,6 +8165,7 @@ UINT AllocatorPimpl::CalcDefaultPoolIndex(const ALLOCATION_DESC& allocDesc, Reso case D3D12_HEAP_TYPE_DEFAULT: poolIndex = 0; break; case D3D12_HEAP_TYPE_UPLOAD: poolIndex = 1; break; case D3D12_HEAP_TYPE_READBACK: poolIndex = 2; break; + case D3D12_HEAP_TYPE_GPU_UPLOAD_COPY: poolIndex = 3; break; default: D3D12MA_ASSERT(0); } @@ -8143,6 +8221,9 @@ void AllocatorPimpl::CalcDefaultPoolParams(D3D12_HEAP_TYPE& outHeapType, D3D12_H case 2: outHeapType = D3D12_HEAP_TYPE_READBACK; break; + case 3: + outHeapType = D3D12_HEAP_TYPE_GPU_UPLOAD_COPY; + break; default: D3D12MA_ASSERT(0); } @@ -8150,7 +8231,7 @@ void AllocatorPimpl::CalcDefaultPoolParams(D3D12_HEAP_TYPE& outHeapType, D3D12_H void AllocatorPimpl::RegisterPool(Pool* pool, D3D12_HEAP_TYPE heapType) { - const UINT heapTypeIndex = HeapTypeToIndex(heapType); + const UINT heapTypeIndex = (UINT)heapType - 1; MutexLockWrite lock(m_PoolsMutex[heapTypeIndex], m_UseMutex); m_Pools[heapTypeIndex].PushBack(pool->m_Pimpl); @@ -8158,7 +8239,7 @@ void AllocatorPimpl::RegisterPool(Pool* pool, D3D12_HEAP_TYPE heapType) void AllocatorPimpl::UnregisterPool(Pool* pool, D3D12_HEAP_TYPE heapType) { - const UINT heapTypeIndex = HeapTypeToIndex(heapType); + const UINT heapTypeIndex = (UINT)heapType - 1; MutexLockWrite lock(m_PoolsMutex[heapTypeIndex], m_UseMutex); m_Pools[heapTypeIndex].Remove(pool->m_Pimpl); @@ -10133,6 +10214,11 @@ BOOL Allocator::IsCacheCoherentUMA() const return m_Pimpl->IsCacheCoherentUMA(); } +BOOL Allocator::IsGPUUploadHeapSupported() const +{ + return m_Pimpl->IsGPUUploadHeapSupported(); +} + UINT64 Allocator::GetMemoryCapacity(UINT memorySegmentGroup) const { return m_Pimpl->GetMemoryCapacity(memorySegmentGroup); diff --git a/src/D3D12Sample.cpp b/src/D3D12Sample.cpp index 31e2451..db49f3b 100644 --- a/src/D3D12Sample.cpp +++ b/src/D3D12Sample.cpp @@ -26,6 +26,7 @@ #include #include // For StrStrI + namespace VS { #include "Shaders\VS_Compiled.h" @@ -35,6 +36,15 @@ namespace PS #include "Shaders\PS_Compiled.h" } +#if D3D12MA_USE_AGILITY_SDK + #if D3D12MA_USE_AGILITY_SDK_PREVIEW + extern "C" { __declspec(dllexport) extern const UINT D3D12SDKVersion = D3D12_PREVIEW_SDK_VERSION; } + #else + extern "C" { __declspec(dllexport) extern const UINT D3D12SDKVersion = D3D12_SDK_VERSION; } + #endif + extern "C" { __declspec(dllexport) extern const char* D3D12SDKPath = u8".\\D3D12\\"; } +#endif + enum class ExitCode : int { GPUList = 2, @@ -563,6 +573,8 @@ static std::wstring SizeToStr(size_t size) static void PrintAdapterInformation(IDXGIAdapter1* adapter) { + assert(g_Allocator); + wprintf(L"DXGI_ADAPTER_DESC1:\n"); wprintf(L" Description = %s\n", g_AdapterDesc.Description); wprintf(L" VendorId = 0x%X (%s)\n", g_AdapterDesc.VendorId, VendorIDToStr(g_AdapterDesc.VendorId)); @@ -589,6 +601,9 @@ static void PrintAdapterInformation(IDXGIAdapter1* adapter) assert(0); } + wprintf(L"D3D12_FEATURE_DATA_D3D12_OPTIONS16:\n"); + wprintf(L" GPUUploadHeapSupported = %u\n", g_Allocator->IsGPUUploadHeapSupported() ? 1 : 0); + ComPtr adapter3; if(SUCCEEDED(adapter->QueryInterface(IID_PPV_ARGS(&adapter3)))) { diff --git a/src/Tests.cpp b/src/Tests.cpp index 95c18e6..ed1463a 100644 --- a/src/Tests.cpp +++ b/src/Tests.cpp @@ -2856,6 +2856,14 @@ static void TestDevice10(const TestContext& ctx) { wprintf(L"Test ID3D12Device10\n"); + D3D12_FEATURE_DATA_D3D12_OPTIONS12 options12 = {}; + if(FAILED(ctx.device->CheckFeatureSupport(D3D12_FEATURE_D3D12_OPTIONS12, &options12, sizeof(options12))) || + !options12.EnhancedBarriersSupported) + { + wprintf(L" Skipped due to D3D12_FEATURE_DATA_D3D12_OPTIONS12::EnhancedBarriersSupported == FALSE.\n"); + return; + } + ComPtr dev10; CHECK_HR(ctx.device->QueryInterface(IID_PPV_ARGS(&dev10))); @@ -2914,6 +2922,152 @@ static void TestDevice10(const TestContext& ctx) } #endif // #ifdef __ID3D12Device10_INTERFACE_DEFINED__ +static void TestGPUUploadHeap(const TestContext& ctx) +{ +#if D3D12MA_OPTIONS16_SUPPORTED + using namespace D3D12MA; + + wprintf(L"Test GPU Upload Heap\n"); + + if(!ctx.allocator->IsGPUUploadHeapSupported()) + { + wprintf(L" Skipped due to GPUUploadHeap not supported.\n"); + return; + } + + Budget begLocalBudget = {}; + ctx.allocator->GetBudget(&begLocalBudget, NULL); + TotalStatistics begStats = {}; + ctx.allocator->CalculateStatistics(&begStats); + + // Create a buffer, likely placed. + ALLOCATION_DESC allocDesc = {}; + allocDesc.HeapType = D3D12_HEAP_TYPE_GPU_UPLOAD; + D3D12_RESOURCE_DESC resDesc; + FillResourceDescForBuffer(resDesc, 64 * KILOBYTE); + + ComPtr alloc; + CHECK_HR(ctx.allocator->CreateResource(&allocDesc, &resDesc, + D3D12_RESOURCE_STATE_COMMON, NULL, &alloc, IID_NULL, NULL)); + CHECK_BOOL(alloc && alloc->GetResource()); + CHECK_BOOL(alloc->GetResource()->GetGPUVirtualAddress() != 0); + + { + D3D12_HEAP_PROPERTIES heapProps = {}; + D3D12_HEAP_FLAGS heapFlags = {}; + CHECK_HR(alloc->GetResource()->GetHeapProperties(&heapProps, &heapFlags)); + CHECK_BOOL(heapProps.Type == D3D12_HEAP_TYPE_GPU_UPLOAD); + } + + // Create a committed one. + ALLOCATION_DESC committedAllocDesc = allocDesc; + committedAllocDesc.Flags |= ALLOCATION_FLAG_COMMITTED; + ComPtr committedAlloc; + CHECK_HR(ctx.allocator->CreateResource(&committedAllocDesc, &resDesc, + D3D12_RESOURCE_STATE_COMMON, NULL, &committedAlloc, IID_NULL, NULL)); + CHECK_BOOL(committedAlloc && committedAlloc->GetResource()); + CHECK_BOOL(committedAlloc->GetHeap() == NULL); // Committed, heap is implicit and inaccessible. + + // Create a custom pool and a buffer inside of it. + POOL_DESC poolDesc = {}; + poolDesc.HeapProperties.Type = D3D12_HEAP_TYPE_GPU_UPLOAD; + ComPtr pool; + CHECK_HR(ctx.allocator->CreatePool(&poolDesc, &pool)); + + ALLOCATION_DESC poolAllocDesc = {}; + poolAllocDesc.CustomPool = pool.Get(); + ComPtr poolAlloc; + CHECK_HR(ctx.allocator->CreateResource(&poolAllocDesc, &resDesc, + D3D12_RESOURCE_STATE_COMMON, NULL, &poolAlloc, IID_NULL, NULL)); + CHECK_BOOL(poolAlloc && poolAlloc->GetResource()); + + // Map the original buffer, write, then read + { + const auto res = alloc->GetResource(); + + UINT* mappedData = NULL; + CHECK_HR(res->Map(0, &EMPTY_RANGE, (void**)&mappedData)); // {0, 0} - not reading anything. + for(UINT i = 0; i < resDesc.Width / sizeof(UINT); ++i) + { + mappedData[i] = i * 3; + } + res->Unmap(0, NULL); // NULL - written everything. + + CHECK_HR(res->Map(0, NULL, (void**)&mappedData)); // NULL - reading everything. + CHECK_BOOL(mappedData[100] = 300); + res->Unmap(0, &EMPTY_RANGE); // {0, 0} - not written anything. + + } + + // Create two big buffers. + D3D12_RESOURCE_DESC bigResDesc = resDesc; + bigResDesc.Width = 128 * MEGABYTE; + + ComPtr bigAllocs[2]; + for(UINT i = 0; i < 2; ++i) + { + CHECK_HR(ctx.allocator->CreateResource(&allocDesc, &bigResDesc, + D3D12_RESOURCE_STATE_COMMON, NULL, &bigAllocs[i], IID_NULL, NULL)); + CHECK_BOOL(bigAllocs[i] && bigAllocs[i]->GetResource()); + } + + // Create a texture. + constexpr UINT texSize = 256; + D3D12_RESOURCE_DESC texDesc = {}; + texDesc.Dimension = D3D12_RESOURCE_DIMENSION_TEXTURE2D; + texDesc.Alignment = 0; + texDesc.Width = texSize; + texDesc.Height = texSize; + texDesc.DepthOrArraySize = 1; + texDesc.MipLevels = 1; + texDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM; + texDesc.SampleDesc.Count = 1; + texDesc.SampleDesc.Quality = 0; + texDesc.Layout = D3D12_TEXTURE_LAYOUT_UNKNOWN; + texDesc.Flags = D3D12_RESOURCE_FLAG_NONE; + ComPtr texAlloc; + CHECK_HR(ctx.allocator->CreateResource(&allocDesc, &texDesc, + D3D12_RESOURCE_STATE_COMMON, NULL, &texAlloc, IID_NULL, NULL)); + CHECK_BOOL(texAlloc && texAlloc->GetResource()); + + { + std::vector texPixels(texSize * texSize); + // Contents of texPixels[i] doesn't matter. + const auto texRes = texAlloc->GetResource(); + // Need to pass ppData == NULL for Map() to be used with a texture having D3D12_TEXTURE_LAYOUT_UNKNOWN. + CHECK_HR(texRes->Map(0, &EMPTY_RANGE, NULL)); // {0, 0} - not reading anything. + CHECK_HR(texRes->WriteToSubresource( + 0, // DstSubresource + NULL, // pDstBox + texPixels.data(), // pSrcData + texSize * sizeof(DWORD), // SrcRowPitch + texSize * texSize * sizeof(DWORD))); // SrcDepthPitch + texRes->Unmap(0, NULL); // NULL - written everything. + } + + // Check budget and stats + constexpr UINT totalAllocCount = 6; + Budget endLocalBudget = {}; + ctx.allocator->GetBudget(&endLocalBudget, NULL); + TotalStatistics endStats = {}; + ctx.allocator->CalculateStatistics(&endStats); + CHECK_BOOL(endLocalBudget.UsageBytes >= begLocalBudget.UsageBytes + + 2 * bigResDesc.Width + && "This can fail if GPU_UPLOAD falls back to system RAM e.g. when under PIX?"); + auto validateStats = [totalAllocCount, &bigResDesc](const Statistics& begStats, const Statistics& endStats) + { + CHECK_BOOL(endStats.BlockCount >= begStats.BlockCount); + CHECK_BOOL(endStats.BlockBytes >= begStats.BlockBytes); + CHECK_BOOL(endStats.AllocationCount == begStats.AllocationCount + totalAllocCount); + CHECK_BOOL(endStats.AllocationBytes > begStats.AllocationBytes + 2 * bigResDesc.Width); + }; + validateStats(begLocalBudget.Stats, endLocalBudget.Stats); + validateStats(begStats.Total.Stats, endStats.Total.Stats); + validateStats(begStats.MemorySegmentGroup[0].Stats, endStats.MemorySegmentGroup[0].Stats); // DXGI_MEMORY_SEGMENT_GROUP_LOCAL + validateStats(begStats.HeapType[4].Stats, endStats.HeapType[4].Stats); // D3D12_HEAP_TYPE_GPU_UPLOAD +#endif +} + static void TestVirtualBlocks(const TestContext& ctx) { wprintf(L"Test virtual blocks\n"); @@ -4180,6 +4334,8 @@ static void TestGroupBasics(const TestContext& ctx) TestDevice10(ctx); #endif + TestGPUUploadHeap(ctx); + FILE* file; fopen_s(&file, "Results.csv", "w"); assert(file != NULL);