hal/vulkan: Replace gpu-alloc by gpu-allocator (#8158)

Author: DeltaEvo

CHANGELOG.md

@@ -43,6 +43,14 @@ Bottom level categories:
 
 ### Major Changes
 
+#### Switch from `gpu-alloc` to `gpu-allocator` in the `vulkan` backend
+
+`gpu-allocator` is the allocator used in the `dx12` backend, allowing to configure
+the allocator the same way in those two backends converging their behavior.
+
+This also brings the `Device::generate_allocator_report` feature to
+the vulkan backend.
+
 #### `wgpu::Instance::enumerate_adapters` is now `async` & available on WebGPU
 
 BREAKING CHANGE: `enumerate_adapters` is now `async`:

Cargo.lock

@@ -208,17 +208,18 @@ objc = "0.2.5"
 # Vulkan dependencies
 android_system_properties = "0.1.1"
 ash = "0.38"
-gpu-alloc = "0.6"
 gpu-descriptor = "0.3.2"
 
 # DX12 dependencies
-gpu-allocator = { version = "0.28", default-features = false, features = [
-    "hashbrown",
-] }
 range-alloc = "0.1"
 mach-dxcompiler-rs = { version = "0.1.4", default-features = false } # remember to increase max_shader_model if applicable
 windows-core = { version = "0.62", default-features = false }
 
+# DX12 and Vulkan dependencies
+gpu-allocator = { version = "0.28", default-features = false, features = [
+    "hashbrown",
+] }
+
 # Gles dependencies
 khronos-egl = "6"
 glow = "0.16"

Cargo.toml

@@ -92,7 +92,6 @@ vulkan = [
     "dep:arrayvec",
     "dep:ash",
     "dep:bytemuck",
-    "dep:gpu-alloc",
     "dep:gpu-descriptor",
     "dep:hashbrown",
     "dep:libc",
@@ -103,6 +102,7 @@ vulkan = [
     "dep:profiling",
     "dep:smallvec",
     "dep:windows",
+    "gpu-allocator/vulkan",
     "windows/Win32",
 ]
 gles = [
@@ -224,9 +224,10 @@ glow = { workspace = true, optional = true }
 ########################
 
 [target.'cfg(not(target_arch = "wasm32"))'.dependencies]
+# Backend: Vulkan and Dx12
+gpu-allocator = { workspace = true, optional = true }
 # Backend: Vulkan
 ash = { workspace = true, optional = true }
-gpu-alloc = { workspace = true, optional = true }
 gpu-descriptor = { workspace = true, optional = true }
 smallvec = { workspace = true, optional = true, features = ["union"] }
 # Backend: GLES
@@ -253,7 +254,6 @@ windows-core = { workspace = true, optional = true }
 # Backend: Dx12
 bit-set = { workspace = true, optional = true }
 range-alloc = { workspace = true, optional = true }
-gpu-allocator = { workspace = true, optional = true, features = ["d3d12"] }
 once_cell = { workspace = true, optional = true }
 # backend: GLES
 glutin_wgl_sys = { workspace = true, optional = true }

wgpu-hal/Cargo.toml

@@ -7,6 +7,7 @@ use windows::Win32::Graphics::{Direct3D12, Dxgi};
 use crate::{
     auxil::dxgi::{name::ObjectExt as _, result::HResult as _},
     dx12::conv,
+    AllocationSizes,
 };
 
 #[derive(Debug)]
@@ -74,36 +75,14 @@ impl Allocator {
         memory_hints: &wgt::MemoryHints,
         memory_budget_thresholds: wgt::MemoryBudgetThresholds,
     ) -> Result<Self, crate::DeviceError> {
-        // TODO: the allocator's configuration should take hardware capability into
-        // account.
-        const MB: u64 = 1024 * 1024;
-        let (device_memblock_size, host_memblock_size) = match memory_hints {
-            wgt::MemoryHints::Performance => (256 * MB, 64 * MB),
-            wgt::MemoryHints::MemoryUsage => (8 * MB, 4 * MB),
-            wgt::MemoryHints::Manual {
-                suballocated_device_memory_block_size,
-            } => {
-                // TODO: Would it be useful to expose the host size in memory hints
-                // instead of always using half of the device size?
-                let device_size = suballocated_device_memory_block_size.start;
-                let host_size = device_size / 2;
-                (device_size, host_size)
-            }
-        };
-
-        // gpu_allocator clamps the sizes between 4MiB and 256MiB, but we clamp them ourselves since we use
-        // the sizes when detecting high memory pressure and there is no way to query the values otherwise.
-
-        let device_memblock_size = device_memblock_size.clamp(4 * MB, 256 * MB);
-        let host_memblock_size = host_memblock_size.clamp(4 * MB, 256 * MB);
-
-        let allocation_sizes =
-            gpu_allocator::AllocationSizes::new(device_memblock_size, host_memblock_size);
+        let allocation_sizes = AllocationSizes::from_memory_hints(memory_hints);
+        let device_memblock_size = allocation_sizes.min_device_memblock_size;
+        let host_memblock_size = allocation_sizes.min_host_memblock_size;
 
         let allocator_desc = gpu_allocator::d3d12::AllocatorCreateDesc {
             device: gpu_allocator::d3d12::ID3D12DeviceVersion::Device(raw.clone()),
             debug_settings: Default::default(),
-            allocation_sizes,
+            allocation_sizes: allocation_sizes.into(),
         };
 
         let allocator = gpu_allocator::d3d12::Allocator::new(&allocator_desc).inspect_err(|e| {
@@ -622,37 +601,3 @@ impl<'a> DeviceAllocationContext<'a> {
         Ok(allocation_info)
     }
 }
-
-impl From<gpu_allocator::AllocationError> for crate::DeviceError {
-    fn from(result: gpu_allocator::AllocationError) -> Self {
-        match result {
-            gpu_allocator::AllocationError::OutOfMemory => Self::OutOfMemory,
-            gpu_allocator::AllocationError::FailedToMap(e) => {
-                log::error!("DX12 gpu-allocator: Failed to map: {e}");
-                Self::Lost
-            }
-            gpu_allocator::AllocationError::NoCompatibleMemoryTypeFound => {
-                log::error!("DX12 gpu-allocator: No Compatible Memory Type Found");
-                Self::Lost
-            }
-            gpu_allocator::AllocationError::InvalidAllocationCreateDesc => {
-                log::error!("DX12 gpu-allocator: Invalid Allocation Creation Description");
-                Self::Lost
-            }
-            gpu_allocator::AllocationError::InvalidAllocatorCreateDesc(e) => {
-                log::error!("DX12 gpu-allocator: Invalid Allocator Creation Description: {e}");
-                Self::Lost
-            }
-
-            gpu_allocator::AllocationError::Internal(e) => {
-                log::error!("DX12 gpu-allocator: Internal Error: {e}");
-                Self::Lost
-            }
-            gpu_allocator::AllocationError::BarrierLayoutNeedsDevice10
-            | gpu_allocator::AllocationError::CastableFormatsRequiresEnhancedBarriers
-            | gpu_allocator::AllocationError::CastableFormatsRequiresAtLeastDevice12 => {
-                unreachable!()
-            }
-        }
-    }
-}

wgpu-hal/src/dx12/suballocation.rs

@@ -381,6 +381,107 @@ pub enum DeviceError {
     Unexpected,
 }
 
+#[cfg(any(dx12, vulkan))]
+impl From<gpu_allocator::AllocationError> for DeviceError {
+    fn from(result: gpu_allocator::AllocationError) -> Self {
+        match result {
+            gpu_allocator::AllocationError::OutOfMemory => Self::OutOfMemory,
+            gpu_allocator::AllocationError::FailedToMap(e) => {
+                log::error!("gpu-allocator: Failed to map: {e}");
+                Self::Lost
+            }
+            gpu_allocator::AllocationError::NoCompatibleMemoryTypeFound => {
+                log::error!("gpu-allocator: No Compatible Memory Type Found");
+                Self::Lost
+            }
+            gpu_allocator::AllocationError::InvalidAllocationCreateDesc => {
+                log::error!("gpu-allocator: Invalid Allocation Creation Description");
+                Self::Lost
+            }
+            gpu_allocator::AllocationError::InvalidAllocatorCreateDesc(e) => {
+                log::error!("gpu-allocator: Invalid Allocator Creation Description: {e}");
+                Self::Lost
+            }
+
+            gpu_allocator::AllocationError::Internal(e) => {
+                log::error!("gpu-allocator: Internal Error: {e}");
+                Self::Lost
+            }
+            gpu_allocator::AllocationError::BarrierLayoutNeedsDevice10
+            | gpu_allocator::AllocationError::CastableFormatsRequiresEnhancedBarriers
+            | gpu_allocator::AllocationError::CastableFormatsRequiresAtLeastDevice12 => {
+                unreachable!()
+            }
+        }
+    }
+}
+
+// A copy of gpu_allocator::AllocationSizes, allowing to read the configured value for
+// the dx12 backend, we should instead add getters to gpu_allocator::AllocationSizes
+// and remove this type.
+// https://github.com/Traverse-Research/gpu-allocator/issues/295
+#[cfg_attr(not(any(dx12, vulkan)), expect(dead_code))]
+pub(crate) struct AllocationSizes {
+    pub(crate) min_device_memblock_size: u64,
+    pub(crate) max_device_memblock_size: u64,
+    pub(crate) min_host_memblock_size: u64,
+    pub(crate) max_host_memblock_size: u64,
+}
+
+impl AllocationSizes {
+    #[allow(dead_code)] // may be unused on some platforms
+    pub(crate) fn from_memory_hints(memory_hints: &wgt::MemoryHints) -> Self {
+        // TODO: the allocator's configuration should take hardware capability into
+        // account.
+        const MB: u64 = 1024 * 1024;
+
+        match memory_hints {
+            wgt::MemoryHints::Performance => Self {
+                min_device_memblock_size: 128 * MB,
+                max_device_memblock_size: 256 * MB,
+                min_host_memblock_size: 64 * MB,
+                max_host_memblock_size: 128 * MB,
+            },
+            wgt::MemoryHints::MemoryUsage => Self {
+                min_device_memblock_size: 8 * MB,
+                max_device_memblock_size: 64 * MB,
+                min_host_memblock_size: 4 * MB,
+                max_host_memblock_size: 32 * MB,
+            },
+            wgt::MemoryHints::Manual {
+                suballocated_device_memory_block_size,
+            } => {
+                // TODO: https://github.com/gfx-rs/wgpu/issues/8625
+                // Would it be useful to expose the host size in memory hints
+                // instead of always using half of the device size?
+                let device_size = suballocated_device_memory_block_size;
+                let host_size = device_size.start / 2..device_size.end / 2;
+
+                // gpu_allocator clamps the sizes between 4MiB and 256MiB, but we clamp them ourselves since we use
+                // the sizes when detecting high memory pressure and there is no way to query the values otherwise.
+                Self {
+                    min_device_memblock_size: device_size.start.clamp(4 * MB, 256 * MB),
+                    max_device_memblock_size: device_size.end.clamp(4 * MB, 256 * MB),
+                    min_host_memblock_size: host_size.start.clamp(4 * MB, 256 * MB),
+                    max_host_memblock_size: host_size.end.clamp(4 * MB, 256 * MB),
+                }
+            }
+        }
+    }
+}
+
+#[cfg(any(dx12, vulkan))]
+impl From<AllocationSizes> for gpu_allocator::AllocationSizes {
+    fn from(value: AllocationSizes) -> gpu_allocator::AllocationSizes {
+        gpu_allocator::AllocationSizes::new(
+            value.min_device_memblock_size,
+            value.min_host_memblock_size,
+        )
+        .with_max_device_memblock_size(value.max_device_memblock_size)
+        .with_max_host_memblock_size(value.max_host_memblock_size)
+    }
+}
+
 #[allow(dead_code)] // may be unused on some platforms
 #[cold]
 fn hal_usage_error<T: fmt::Display>(txt: T) -> ! {