[D3D12] Non-zeroed heaps on 2004

src/xenia/ui/d3d12/d3d12_immediate_drawer.cc

@@ -33,7 +33,7 @@ class D3D12ImmediateTexture : public ImmediateTexture {
                         ImmediateTextureFilter filter, bool repeat);
   ~D3D12ImmediateTexture() override;
 
-  bool Initialize(ID3D12Device* device);
+  bool Initialize(D3D12Provider& provider);
   void Shutdown();
 
   ID3D12Resource* GetResource() const { return resource_; }
@@ -59,7 +59,7 @@ D3D12ImmediateTexture::D3D12ImmediateTexture(uint32_t width, uint32_t height,
 
 D3D12ImmediateTexture::~D3D12ImmediateTexture() { Shutdown(); }
 
-bool D3D12ImmediateTexture::Initialize(ID3D12Device* device) {
+bool D3D12ImmediateTexture::Initialize(D3D12Provider& provider) {
   // The first operation will likely be copying the contents.
   state_ = D3D12_RESOURCE_STATE_COPY_DEST;
 
@@ -75,9 +75,9 @@ bool D3D12ImmediateTexture::Initialize(ID3D12Device* device) {
   resource_desc.SampleDesc.Quality = 0;
   resource_desc.Layout = D3D12_TEXTURE_LAYOUT_UNKNOWN;
   resource_desc.Flags = D3D12_RESOURCE_FLAG_NONE;
-  if (FAILED(device->CreateCommittedResource(
-          &util::kHeapPropertiesDefault, D3D12_HEAP_FLAG_NONE, &resource_desc,
-          state_, nullptr, IID_PPV_ARGS(&resource_)))) {
+  if (FAILED(provider.GetDevice()->CreateCommittedResource(
+          &util::kHeapPropertiesDefault, provider.GetHeapFlagCreateNotZeroed(),
+          &resource_desc, state_, nullptr, IID_PPV_ARGS(&resource_)))) {
     XELOGE("Failed to create a {}x{} texture for immediate drawing", width,
            height);
     return false;
@@ -288,7 +288,7 @@ bool D3D12ImmediateDrawer::Initialize() {
 
   // Create pools for draws.
   vertex_buffer_pool_ =
-      std::make_unique<UploadBufferPool>(device, 2 * 1024 * 1024);
+      std::make_unique<UploadBufferPool>(provider, 2 * 1024 * 1024);
   texture_descriptor_pool_ = std::make_unique<DescriptorHeapPool>(
       device, D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV, 2048);
   texture_descriptor_pool_heap_index_ = DescriptorHeapPool::kHeapIndexInvalid;
@@ -326,7 +326,7 @@ std::unique_ptr<ImmediateTexture> D3D12ImmediateDrawer::CreateTexture(
     const uint8_t* data) {
   auto texture =
       std::make_unique<D3D12ImmediateTexture>(width, height, filter, repeat);
-  texture->Initialize(context_.GetD3D12Provider().GetDevice());
+  texture->Initialize(context_.GetD3D12Provider());
   if (data != nullptr) {
     UpdateTexture(texture.get(), data);
   }
@@ -343,7 +343,8 @@ void D3D12ImmediateDrawer::UpdateTexture(ImmediateTexture* texture,
   }
   uint32_t width = d3d_texture->width, height = d3d_texture->height;
 
-  auto device = context_.GetD3D12Provider().GetDevice();
+  auto& provider = context_.GetD3D12Provider();
+  auto device = provider.GetDevice();
 
   // Create and fill the upload buffer.
   D3D12_RESOURCE_DESC texture_desc = texture_resource->GetDesc();
@@ -356,8 +357,9 @@ void D3D12ImmediateDrawer::UpdateTexture(ImmediateTexture* texture,
                                D3D12_RESOURCE_FLAG_NONE);
   ID3D12Resource* buffer;
   if (FAILED(device->CreateCommittedResource(
-          &util::kHeapPropertiesUpload, D3D12_HEAP_FLAG_NONE, &buffer_desc,
-          D3D12_RESOURCE_STATE_GENERIC_READ, nullptr, IID_PPV_ARGS(&buffer)))) {
+          &util::kHeapPropertiesUpload, provider.GetHeapFlagCreateNotZeroed(),
+          &buffer_desc, D3D12_RESOURCE_STATE_GENERIC_READ, nullptr,
+          IID_PPV_ARGS(&buffer)))) {
     XELOGE(
         "Failed to create an upload buffer for a {}x{} texture for "
         "immediate drawing",

src/xenia/ui/d3d12/d3d12_provider.cc

@@ -409,17 +409,29 @@ bool D3D12Provider::Initialize() {
     virtual_address_bits_per_resource_ =
         virtual_address_support.MaxGPUVirtualAddressBitsPerResource;
   }
+  // D3D12_HEAP_FLAG_CREATE_NOT_ZEROED requires Windows 10 2004 (indicated by
+  // the availability of ID3D12Device8 or D3D12_FEATURE_D3D12_OPTIONS7).
+  heap_flag_create_not_zeroed_ = D3D12_HEAP_FLAG_NONE;
+  D3D12_FEATURE_DATA_D3D12_OPTIONS7 options7;
+  if (SUCCEEDED(device->CheckFeatureSupport(D3D12_FEATURE_D3D12_OPTIONS7,
+                                            &options7, sizeof(options7)))) {
+    heap_flag_create_not_zeroed_ = D3D12_HEAP_FLAG_CREATE_NOT_ZEROED;
+  }
   XELOGD3D(
-      "Direct3D 12 device features:\n"
-      "Max GPU virtual address bits per resource: {}\n"
-      "Programmable sample positions: tier {}\n"
-      "Rasterizer-ordered views: {}\n"
-      "Resource binding: tier {}\n"
-      "Tiled resources: tier {}\n",
+      "Direct3D 12 device and OS features:\n"
+      "* Max GPU virtual address bits per resource: {}\n"
+      "* Programmable sample positions: tier {}\n"
+      "* Rasterizer-ordered views: {}\n"
+      "* Resource binding: tier {}\n"
+      "* Tiled resources: tier {}\n"
+      "* Non-zeroed heap creation: {}\n",
       virtual_address_bits_per_resource_,
       uint32_t(programmable_sample_positions_tier_),
       rasterizer_ordered_views_supported_ ? "yes" : "no",
-      uint32_t(resource_binding_tier_), uint32_t(tiled_resources_tier_));
+      uint32_t(resource_binding_tier_), uint32_t(tiled_resources_tier_),
+      (heap_flag_create_not_zeroed_ & D3D12_HEAP_FLAG_CREATE_NOT_ZEROED)
+          ? "yes"
+          : "no");
 
   // Get the graphics analysis interface, will silently fail if PIX is not
   // attached.

src/xenia/ui/d3d12/d3d12_provider.h

@@ -84,6 +84,9 @@ class D3D12Provider : public GraphicsProvider {
   uint32_t GetVirtualAddressBitsPerResource() const {
     return virtual_address_bits_per_resource_;
   }
+  D3D12_HEAP_FLAGS GetHeapFlagCreateNotZeroed() const {
+    return heap_flag_create_not_zeroed_;
+  }
 
   // Proxies for Direct3D 12 functions since they are loaded dynamically.
   inline HRESULT SerializeRootSignature(const D3D12_ROOT_SIGNATURE_DESC* desc,
@@ -164,6 +167,7 @@ class D3D12Provider : public GraphicsProvider {
   D3D12_RESOURCE_BINDING_TIER resource_binding_tier_;
   D3D12_TILED_RESOURCES_TIER tiled_resources_tier_;
   uint32_t virtual_address_bits_per_resource_;
+  D3D12_HEAP_FLAGS heap_flag_create_not_zeroed_;
 };
 
 }  // namespace d3d12

src/xenia/ui/d3d12/pools.cc

@@ -19,8 +19,8 @@ namespace xe {
 namespace ui {
 namespace d3d12 {
 
-UploadBufferPool::UploadBufferPool(ID3D12Device* device, uint32_t page_size)
-    : device_(device), page_size_(page_size) {}
+UploadBufferPool::UploadBufferPool(D3D12Provider& provider, uint32_t page_size)
+    : provider_(provider), page_size_(page_size) {}
 
 UploadBufferPool::~UploadBufferPool() { ClearCache(); }
 
@@ -101,9 +101,10 @@ uint8_t* UploadBufferPool::Request(uint64_t submission_index, uint32_t size,
       util::FillBufferResourceDesc(new_buffer_desc, page_size_,
                                    D3D12_RESOURCE_FLAG_NONE);
       ID3D12Resource* new_buffer;
-      if (FAILED(device_->CreateCommittedResource(
-              &util::kHeapPropertiesUpload, D3D12_HEAP_FLAG_NONE,
-              &new_buffer_desc, D3D12_RESOURCE_STATE_GENERIC_READ, nullptr,
+      if (FAILED(provider_.GetDevice()->CreateCommittedResource(
+              &util::kHeapPropertiesUpload,
+              provider_.GetHeapFlagCreateNotZeroed(), &new_buffer_desc,
+              D3D12_RESOURCE_STATE_GENERIC_READ, nullptr,
               IID_PPV_ARGS(&new_buffer)))) {
         XELOGE("Failed to create a D3D upload buffer with {} bytes",
                page_size_);

src/xenia/ui/d3d12/pools.h

@@ -12,7 +12,7 @@
 
 #include <cstdint>
 
-#include "xenia/ui/d3d12/d3d12_api.h"
+#include "xenia/ui/d3d12/d3d12_provider.h"
 
 namespace xe {
 namespace ui {
@@ -23,7 +23,7 @@ namespace d3d12 {
 
 class UploadBufferPool {
  public:
-  UploadBufferPool(ID3D12Device* device, uint32_t page_size);
+  UploadBufferPool(D3D12Provider& provider, uint32_t page_size);
   ~UploadBufferPool();
 
   void Reclaim(uint64_t completed_submission_index);
@@ -41,7 +41,7 @@ class UploadBufferPool {
                           D3D12_GPU_VIRTUAL_ADDRESS* gpu_address_out);
 
  private:
-  ID3D12Device* device_;
+  D3D12Provider& provider_;
   uint32_t page_size_;
 
   struct Page {