Remove gpu-allocator dependency

Delete the shared gpu-allocator glue from wgpu-hal/src/lib.rs, inline a
local AllocationSizes into the dx12 backend, drop gpu-allocator from the
workspace and wgpu-hal manifests, and add the feature changelog entry.

Author: cwfitzgerald

.deny.toml

@@ -16,9 +16,6 @@ skip = [
     # Used by hashbrown 0.15.5
     { name = "foldhash", version = "0.1.5" },
 
-    # naga depends on hashbrown 0.16 directly, while naga -> indexmap pulls hashbrown 0.17
-    { name = "hashbrown", version = "0.16.1" },
-
     # wgpu-hal -> drm -> drm-sys uses an older version, while wgpu-hal -> drm -> rustix uses a newer one
     { name = "linux-raw-sys", version = "0.9.4" },
 ]

CHANGELOG.md

@@ -42,6 +42,21 @@ Bottom level categories:
 
 ## Unreleased
 
+### Major changes
+
+#### In-tree memory allocator for Vulkan and D3D12
+
+wgpu-hal's Vulkan and D3D12 backends now suballocate device memory with an in-tree allocator, built on two new crates: `wgpu-offset-allocator` and `wgpu-block-pool`, whose algorithms and policy are derived from AMD's VulkanMemoryAllocator and D3D12MemoryAllocator. The `gpu-allocator` dependency has been removed.
+
+`MemoryBudgetThresholds::for_resource_creation` is now enforced inside the allocator, where it only gates the creation of new memory blocks and dedicated allocations. Previously it was a heuristic pre-check that could reject a resource even when it would have fit in already-allocated memory.
+
+Also fixed along the way:
+
+- On Vulkan, buffers used as acceleration-structure build inputs are now explicitly 16-byte aligned, as acceleration-structure build commands require. Previously this held only by accident of allocator layout and could be violated on some drivers (observed on AMD).
+- Device memory is no longer leaked on rare error paths during resource creation.
+
+By @cwfitzgerald in [#9794](https://github.com/gfx-rs/wgpu/pull/9794).
+
 ### Added/New Features
 
 #### Hal

Cargo.lock

@@ -295,11 +295,6 @@ mach-dxcompiler-rs = { version = "0.1.4", default-features = false } # remember
 windows-core = { version = "0.62", default-features = false }
 windows-result = { version = "0.4", default-features = false }
 
-# DX12 and Vulkan dependencies
-gpu-allocator = { version = "0.28", default-features = false, features = [
-    "hashbrown",
-] }
-
 # Gles dependencies
 khronos-egl = "6"
 glow = "0.17"

Cargo.toml

@@ -95,12 +95,6 @@ vulkan = [
     "dep:arrayvec",
     "dep:ash",
     "dep:bytemuck",
-    # The vulkan backend no longer uses gpu-allocator, but the shared
-    # `gpu_allocator`-based glue in `lib.rs` is still gated on `any(dx12, vulkan)`
-    # (the dx12 backend continues to use it). Keep the crate available - without its
-    # `vulkan` feature - so `lib.rs` compiles in vulkan-only builds. Removing that glue
-    # (and this dependency) is a follow-up once dx12 is ported too.
-    "dep:gpu-allocator",
     "dep:libc",
     "dep:libloading",
     "dep:ordered-float",
@@ -148,7 +142,6 @@ dx12 = [
     "dep:arrayvec",
     "dep:bit-set",
     "dep:bytemuck",
-    "dep:gpu-allocator",
     "dep:libloading",
     "dep:once_cell",
     "dep:ordered-float",
@@ -247,8 +240,6 @@ 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 }
 smallvec = { workspace = true, optional = true, features = ["union"] }

wgpu-hal/Cargo.toml

@@ -79,7 +79,6 @@ use windows::Win32::Graphics::{Direct3D12, Dxgi};
 use crate::{
     auxil::dxgi::{name::ObjectExt as _, result::HResult as _},
     dx12::conv,
-    AllocationSizes,
 };
 
 /// The per-allocation user data stored inside the pool.
@@ -97,10 +96,55 @@ const DEFAULT_RESOURCE_PLACEMENT_ALIGNMENT: u64 =
 
 /// D3D12MA's default preferred block size (64 MiB).
 ///
-/// We merge this with the [`AllocationSizes`] policy replicated from
-/// `wgpu_hal::lib`; see [`Pools::preferred_block_size`].
+/// We merge this with the [`AllocationSizes`] policy derived from the user's
+/// [`wgt::MemoryHints`]; see [`Pools::preferred_block_size`].
 const D3D12MA_DEFAULT_BLOCK_SIZE: u64 = 64 * 1024 * 1024;
 
+/// Block-size policy used by this backend's suballocator to decide how large each
+/// memory block should be, derived from the user's [`wgt::MemoryHints`].
+///
+/// The vulkan backend replicates the same policy locally in
+/// `vulkan::suballocation`.
+struct AllocationSizes {
+    min_device_memblock_size: u64,
+    min_host_memblock_size: u64,
+}
+
+impl AllocationSizes {
+    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,
+                min_host_memblock_size: 64 * MB,
+            },
+            wgt::MemoryHints::MemoryUsage => Self {
+                min_device_memblock_size: 8 * MB,
+                min_host_memblock_size: 4 * 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_min = device_size.start / 2;
+
+                // Clamp the sizes between 4MiB and 256MiB, since we use the sizes when
+                // detecting high memory pressure and want them to stay within a sane range.
+                Self {
+                    min_device_memblock_size: device_size.start.clamp(4 * MB, 256 * MB),
+                    min_host_memblock_size: host_min.clamp(4 * MB, 256 * MB),
+                }
+            }
+        }
+    }
+}
+
 /// Refresh the DXGI budget query at most once per this many alloc/free
 /// operations, matching D3D12MA's `ShouldUpdateBudget` cadence.
 const BUDGET_REFRESH_INTERVAL: u32 = 30;
@@ -629,8 +673,8 @@ struct Pools {
 
 impl Pools {
     /// Computes the preferred block size for a heap class, merging D3D12MA's
-    /// 64 MiB default with the [`AllocationSizes`] policy replicated from
-    /// `wgpu_hal::lib` (derived from [`wgt::MemoryHints`]).
+    /// 64 MiB default with the [`AllocationSizes`] policy derived from
+    /// [`wgt::MemoryHints`].
     ///
     /// Merge rule: we take the *larger* of D3D12MA's default and wgpu's
     /// configured min block size for the segment (device vs host), so that:

wgpu-hal/src/dx12/suballocation.rs

@@ -387,107 +387,6 @@ 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, reason = "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, reason = "may be unused on some platforms")]
 #[cold]
 fn hal_usage_error<T: fmt::Display>(txt: T) -> ! {