rt(d3d12): use gpu_allocator instead of CreateCommittedResource

Author: chyyran

Cargo.lock

@@ -29,6 +29,8 @@ array-concat = "0.5.2"
 mach-siegbert-vogt-dxcsa = "0.1.3"
 
 rayon = "1.6.1"
+gpu-allocator = { version = "0.27.0", features = ["d3d12"], default-features = false}
+parking_lot = "0.12.3"
 
 [target.'cfg(windows)'.dependencies.windows]
 workspace = true

librashader-runtime-d3d12/Cargo.toml

@@ -1,19 +1,25 @@
 use crate::error;
-use crate::error::assume_d3d12_init;
+use gpu_allocator::d3d12::{
+    Allocator, Resource, ResourceCategory, ResourceCreateDesc, ResourceStateOrBarrierLayout,
+    ResourceType,
+};
+use gpu_allocator::MemoryLocation;
+use parking_lot::Mutex;
 use std::ffi::c_void;
 use std::mem::ManuallyDrop;
 use std::ops::{Deref, DerefMut, Range};
 use std::ptr::NonNull;
+use std::sync::Arc;
 use windows::Win32::Graphics::Direct3D12::{
-    ID3D12Device, ID3D12GraphicsCommandList, ID3D12Resource, D3D12_CPU_PAGE_PROPERTY_UNKNOWN,
-    D3D12_HEAP_FLAG_NONE, D3D12_HEAP_PROPERTIES, D3D12_HEAP_TYPE_UPLOAD, D3D12_MEMORY_POOL_UNKNOWN,
-    D3D12_RANGE, D3D12_RESOURCE_DESC, D3D12_RESOURCE_DIMENSION_BUFFER,
-    D3D12_RESOURCE_STATE_GENERIC_READ, D3D12_TEXTURE_LAYOUT_ROW_MAJOR,
+    ID3D12GraphicsCommandList, ID3D12Resource, D3D12_RANGE, D3D12_RESOURCE_DESC,
+    D3D12_RESOURCE_DIMENSION_BUFFER, D3D12_RESOURCE_STATE_GENERIC_READ,
+    D3D12_TEXTURE_LAYOUT_ROW_MAJOR,
 };
 use windows::Win32::Graphics::Dxgi::Common::DXGI_SAMPLE_DESC;
 
 pub struct D3D12Buffer {
-    handle: ID3D12Resource,
+    resource: ManuallyDrop<Resource>,
+    allocator: Arc<Mutex<Allocator>>,
     size: usize,
 }
 
@@ -28,51 +34,51 @@ impl<'a> Drop for D3D12BufferMapHandle<'a> {
     }
 }
 
+impl Drop for D3D12Buffer {
+    fn drop(&mut self) {
+        let resource = unsafe { ManuallyDrop::take(&mut self.resource) };
+        if let Err(e) = self.allocator.lock().free_resource(resource) {
+            println!("librashader-runtime-d3d12: [warn] failed to deallocate buffer memory {e}")
+        }
+    }
+}
+
 impl D3D12Buffer {
-    pub fn new(device: &ID3D12Device, size: usize) -> error::Result<D3D12Buffer> {
-        unsafe {
-            let mut buffer: Option<ID3D12Resource> = None;
-            device.CreateCommittedResource(
-                &D3D12_HEAP_PROPERTIES {
-                    Type: D3D12_HEAP_TYPE_UPLOAD,
-                    CPUPageProperty: D3D12_CPU_PAGE_PROPERTY_UNKNOWN,
-                    MemoryPoolPreference: D3D12_MEMORY_POOL_UNKNOWN,
-                    ..Default::default()
-                },
-                D3D12_HEAP_FLAG_NONE,
-                &D3D12_RESOURCE_DESC {
-                    Dimension: D3D12_RESOURCE_DIMENSION_BUFFER,
-                    Width: size as u64,
-                    Height: 1,
-                    DepthOrArraySize: 1,
-                    MipLevels: 1,
-                    Layout: D3D12_TEXTURE_LAYOUT_ROW_MAJOR,
-                    SampleDesc: DXGI_SAMPLE_DESC {
-                        Count: 1,
-                        Quality: 0,
-                    },
-                    ..Default::default()
+    pub fn new(allocator: &Arc<Mutex<Allocator>>, size: usize) -> error::Result<D3D12Buffer> {
+        let resource = allocator.lock().create_resource(&ResourceCreateDesc {
+            name: "d3d12buffer",
+            memory_location: MemoryLocation::CpuToGpu,
+            resource_category: ResourceCategory::Buffer,
+            resource_desc: &D3D12_RESOURCE_DESC {
+                Dimension: D3D12_RESOURCE_DIMENSION_BUFFER,
+                Width: size as u64,
+                Height: 1,
+                DepthOrArraySize: 1,
+                MipLevels: 1,
+                Layout: D3D12_TEXTURE_LAYOUT_ROW_MAJOR,
+                SampleDesc: DXGI_SAMPLE_DESC {
+                    Count: 1,
+                    Quality: 0,
                 },
+                ..Default::default()
+            },
+            castable_formats: &[],
+            clear_value: None,
+            initial_state_or_layout: ResourceStateOrBarrierLayout::ResourceState(
                 D3D12_RESOURCE_STATE_GENERIC_READ,
-                None,
-                &mut buffer,
-            )?;
-
-            assume_d3d12_init!(buffer, "CreateCommittedResource");
-
-            Ok(D3D12Buffer {
-                handle: buffer,
-                size,
-            })
-        }
+            ),
+            resource_type: &ResourceType::Placed,
+        })?;
+
+        Ok(Self {
+            resource: ManuallyDrop::new(resource),
+            size,
+            allocator: Arc::clone(&allocator),
+        })
     }
 
     pub fn gpu_address(&self) -> u64 {
-        unsafe { self.handle.GetGPUVirtualAddress() }
-    }
-
-    pub fn into_raw(self) -> ID3D12Resource {
-        self.handle
+        unsafe { self.resource.resource().GetGPUVirtualAddress() }
     }
 
     pub fn map(&mut self, range: Option<Range<usize>>) -> error::Result<D3D12BufferMapHandle> {
@@ -88,10 +94,12 @@ impl D3D12Buffer {
 
         unsafe {
             let mut ptr = std::ptr::null_mut();
-            self.handle.Map(0, Some(&range), Some(&mut ptr))?;
+            self.resource
+                .resource()
+                .Map(0, Some(&range), Some(&mut ptr))?;
             let slice = std::slice::from_raw_parts_mut(ptr.cast(), size);
             Ok(D3D12BufferMapHandle {
-                handle: &self.handle,
+                handle: &self.resource.resource(),
                 slice,
             })
         }
@@ -115,7 +123,10 @@ impl RawD3D12Buffer {
         let range = D3D12_RANGE { Begin: 0, End: 0 };
         let mut ptr = std::ptr::null_mut();
         unsafe {
-            buffer.handle.Map(0, Some(&range), Some(&mut ptr))?;
+            buffer
+                .resource
+                .resource()
+                .Map(0, Some(&range), Some(&mut ptr))?;
         }
 
         // panic-safety: If Map returns Ok then ptr is not null
@@ -134,7 +145,7 @@ impl RawD3D12Buffer {
 impl Drop for RawD3D12Buffer {
     fn drop(&mut self) {
         unsafe {
-            self.buffer.handle.Unmap(0, None);
+            self.buffer.resource.resource().Unmap(0, None);
             ManuallyDrop::drop(&mut self.buffer);
         }
     }

librashader-runtime-d3d12/src/buffer.rs

@@ -2,11 +2,14 @@ use crate::buffer::D3D12Buffer;
 use crate::error;
 use array_concat::concat_arrays;
 use bytemuck::offset_of;
+use gpu_allocator::d3d12::Allocator;
 use librashader_runtime::quad::{QuadType, VertexInput};
+use parking_lot::Mutex;
+use std::sync::Arc;
 use windows::core::PCSTR;
 use windows::Win32::Graphics::Direct3D::D3D_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP;
 use windows::Win32::Graphics::Direct3D12::{
-    ID3D12Device, ID3D12GraphicsCommandList, ID3D12GraphicsCommandList4, ID3D12Resource,
+    ID3D12GraphicsCommandList, ID3D12GraphicsCommandList4,
     D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA, D3D12_INPUT_ELEMENT_DESC, D3D12_VERTEX_BUFFER_VIEW,
 };
 use windows::Win32::Graphics::Dxgi::Common::DXGI_FORMAT_R32G32_FLOAT;
@@ -52,15 +55,15 @@ const FINAL_VBO_DATA: [VertexInput; 4] = [
 static VBO_DATA: &[VertexInput; 8] = &concat_arrays!(OFFSCREEN_VBO_DATA, FINAL_VBO_DATA);
 
 pub(crate) struct DrawQuad {
-    _buffer: ID3D12Resource,
+    _buffer: D3D12Buffer,
     view: D3D12_VERTEX_BUFFER_VIEW,
 }
 
 impl DrawQuad {
-    pub fn new(device: &ID3D12Device) -> error::Result<DrawQuad> {
+    pub fn new(allocator: &Arc<Mutex<Allocator>>) -> error::Result<DrawQuad> {
         let stride = std::mem::size_of::<VertexInput>() as u32;
         let size = 2 * std::mem::size_of::<[VertexInput; 4]>() as u32;
-        let mut buffer = D3D12Buffer::new(device, size as usize)?;
+        let mut buffer = D3D12Buffer::new(allocator, size as usize)?;
         buffer
             .map(None)?
             .slice
@@ -72,7 +75,6 @@ impl DrawQuad {
             StrideInBytes: stride,
         };
 
-        let buffer = buffer.into_raw();
         Ok(DrawQuad {
             _buffer: buffer,
             view,

librashader-runtime-d3d12/src/draw_quad.rs

@@ -5,7 +5,7 @@ use thiserror::Error;
 /// Cumulative error type for Direct3D12 filter chains.
 #[derive(Error, Debug)]
 pub enum FilterChainError {
-    #[error("invariant assumption about d3d11 did not hold. report this as an issue.")]
+    #[error("invariant assumption about d3d12 did not hold. report this as an issue.")]
     Direct3DOperationError(&'static str),
     #[error("direct3d driver error")]
     Direct3DError(#[from] windows::core::Error),
@@ -21,6 +21,8 @@ pub enum FilterChainError {
     LutLoadError(#[from] ImageError),
     #[error("heap overflow")]
     DescriptorHeapOverflow(usize),
+    #[error("allocation error")]
+    AllocationError(#[from] gpu_allocator::AllocationError),
 }
 
 /// Result type for Direct3D 12 filter chains.