Add Metal implementation (#199)

* Add skeleton for Metal Allocator

* Implement allocating/freeing buffers and textures

* Fetch size and align from metal device for buffer allocations

* Implement allocating acceleration structures

* Add function to get all metal heaps

Use this function in `encoder.use_heaps(gpu_allocator.get_heaps())`

* Fixes & clean up

* Specify linear or non-linear allocation

Similar to how the Vulkan implementation does it

* Revert "Specify linear or non-linear allocation"

I wasn't sure about this change, so I'm reverting it for now

* Put metal behind feature toggle

Author: FlannyH

Cargo.toml

@@ -33,6 +33,9 @@ ash = { version = ">=0.34, <=0.37", optional = true, default-features = false, f
 egui = { version = ">=0.24, <=0.26", optional = true, default-features = false }
 egui_extras = { version = ">=0.24, <=0.26", optional = true, default-features = false }
 
+[target.'cfg(any(target_os = "macos", target_os = "ios"))'.dependencies]
+metal = { version = "0.27.0", default-features = false, features = ["link", "dispatch",] }
+
 [target.'cfg(windows)'.dependencies]
 # Only needed for public-winapi interop helpers
 winapi = { version = "0.3.9", features = ["d3d12", "winerror", "impl-default", "impl-debug"], optional = true }
@@ -80,11 +83,19 @@ required-features = ["d3d12", "public-winapi"]
 name = "d3d12-buffer-winrs"
 required-features = ["d3d12"]
 
+[[example]]
+name = "metal-buffer"
+required-features = ["metal"]
+
 [features]
 visualizer = ["egui", "egui_extras"]
 vulkan = ["ash"]
 d3d12 = ["windows"]
+metal = []
 # Expose helper functionality for winapi types to interface with gpu-allocator, which is primarily windows-rs driven
 public-winapi = ["dep:winapi"]
 
 default = ["d3d12", "vulkan"]
+
+[patch.crates-io]
+metal = { git = "https://github.com/Traverse-Research/metal-rs", rev = "a354c33" }

examples/metal-buffer.rs

@@ -0,0 +1,93 @@
+use std::sync::Arc;
+
+use gpu_allocator::metal::{AllocationCreateDesc, Allocator, AllocatorCreateDesc};
+use log::info;
+
+fn main() {
+    env_logger::Builder::from_env(env_logger::Env::default().default_filter_or("trace")).init();
+
+    let device = Arc::new(metal::Device::system_default().unwrap());
+
+    // Setting up the allocator
+    let mut allocator = Allocator::new(&AllocatorCreateDesc {
+        device: device.clone(),
+        debug_settings: Default::default(),
+        allocation_sizes: Default::default(),
+    })
+    .unwrap();
+
+    // Test allocating Gpu Only memory
+    {
+        let allocation_desc = AllocationCreateDesc::buffer(
+            &device,
+            "Test allocation (Gpu Only)",
+            512,
+            gpu_allocator::MemoryLocation::GpuOnly,
+        );
+        let allocation = allocator.allocate(&allocation_desc).unwrap();
+        let _buffer = allocation.make_buffer().unwrap();
+        allocator.free(&allocation).unwrap();
+        info!("Allocation and deallocation of GpuOnly memory was successful.");
+    }
+
+    // Test allocating Cpu to Gpu memory
+    {
+        let allocation_desc = AllocationCreateDesc::buffer(
+            &device,
+            "Test allocation (Cpu to Gpu)",
+            512,
+            gpu_allocator::MemoryLocation::CpuToGpu,
+        );
+        let allocation = allocator.allocate(&allocation_desc).unwrap();
+        let _buffer = allocation.make_buffer().unwrap();
+        allocator.free(&allocation).unwrap();
+        info!("Allocation and deallocation of CpuToGpu memory was successful.");
+    }
+
+    // Test allocating Gpu to Cpu memory
+    {
+        let allocation_desc = AllocationCreateDesc::buffer(
+            &device,
+            "Test allocation (Gpu to Cpu)",
+            512,
+            gpu_allocator::MemoryLocation::GpuToCpu,
+        );
+        let allocation = allocator.allocate(&allocation_desc).unwrap();
+        let _buffer = allocation.make_buffer().unwrap();
+        allocator.free(&allocation).unwrap();
+        info!("Allocation and deallocation of GpuToCpu memory was successful.");
+    }
+
+    // Test allocating texture
+    {
+        let texture_desc = metal::TextureDescriptor::new();
+        texture_desc.set_pixel_format(metal::MTLPixelFormat::RGBA8Unorm);
+        texture_desc.set_width(64);
+        texture_desc.set_height(64);
+        texture_desc.set_storage_mode(metal::MTLStorageMode::Private);
+        let allocation_desc =
+            AllocationCreateDesc::texture(&device, "Test allocation (Texture)", &texture_desc);
+        let allocation = allocator.allocate(&allocation_desc).unwrap();
+        let _texture = allocation.make_texture(&texture_desc).unwrap();
+        allocator.free(&allocation).unwrap();
+        info!("Allocation and deallocation of Texture was successful.");
+    }
+
+    // Test allocating acceleration structure
+    {
+        let empty_array = metal::Array::from_slice(&[]);
+        let acc_desc = metal::PrimitiveAccelerationStructureDescriptor::descriptor();
+        acc_desc.set_geometry_descriptors(&empty_array);
+        let sizes = device.acceleration_structure_sizes_with_descriptor(&acc_desc);
+        let allocation_desc = AllocationCreateDesc::acceleration_structure_with_size(
+            &device,
+            "Test allocation (Acceleration structure)",
+            sizes.acceleration_structure_size,
+            gpu_allocator::MemoryLocation::GpuOnly,
+        );
+        let allocation = allocator.allocate(&allocation_desc).unwrap();
+        let _acc_structure = allocation.make_acceleration_structure();
+        allocator.free(&allocation).unwrap();
+        info!("Allocation and deallocation of Acceleration structure was successful.");
+    }
+}

src/lib.rs

@@ -170,6 +170,9 @@ pub mod vulkan;
 #[cfg(all(windows, feature = "d3d12"))]
 pub mod d3d12;
 
+#[cfg(all(any(target_os = "macos", target_os = "ios"), feature = "metal"))]
+pub mod metal;
+
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
 pub enum MemoryLocation {
     /// The allocated resource is stored at an unknown memory location; let the driver decide what's the best location