Vendor dependencies for 0.3.0 release

vendor/gpu-allocator/examples/d3d12-buffer-winrs.rs

@@ -0,0 +1,243 @@
+//! Example showcasing [`gpu-allocator`] with types and functions from the [`windows`] crate.
+use gpu_allocator::{
+    d3d12::{
+        AllocationCreateDesc, Allocator, AllocatorCreateDesc, ID3D12DeviceVersion, ResourceCategory,
+    },
+    MemoryLocation,
+};
+use log::*;
+use windows::{
+    core::{Interface, Result},
+    Win32::{
+        Foundation::E_NOINTERFACE,
+        Graphics::{
+            Direct3D::{D3D_FEATURE_LEVEL_11_0, D3D_FEATURE_LEVEL_11_1, D3D_FEATURE_LEVEL_12_0},
+            Direct3D12::{
+                D3D12CreateDevice, ID3D12Device, ID3D12Resource,
+                D3D12_DEFAULT_RESOURCE_PLACEMENT_ALIGNMENT, D3D12_RESOURCE_DESC,
+                D3D12_RESOURCE_DIMENSION_BUFFER, D3D12_RESOURCE_FLAG_NONE,
+                D3D12_RESOURCE_STATE_COMMON, D3D12_TEXTURE_LAYOUT_ROW_MAJOR,
+            },
+            Dxgi::{
+                Common::{DXGI_FORMAT_UNKNOWN, DXGI_SAMPLE_DESC},
+                CreateDXGIFactory2, IDXGIAdapter4, IDXGIFactory6, DXGI_ADAPTER_FLAG3_SOFTWARE,
+                DXGI_ERROR_NOT_FOUND,
+            },
+        },
+    },
+};
+
+fn create_d3d12_device(dxgi_factory: &IDXGIFactory6) -> Option<ID3D12Device> {
+    for idx in 0.. {
+        // TODO: Might as well return Result<> from this function
+        let adapter1 = match unsafe { dxgi_factory.EnumAdapters1(idx) } {
+            Ok(a) => a,
+            Err(e) if e.code() == DXGI_ERROR_NOT_FOUND => break,
+            Err(e) => panic!("{:?}", e),
+        };
+        let adapter4: IDXGIAdapter4 = adapter1.cast().unwrap();
+
+        let desc = unsafe { adapter4.GetDesc3() }.unwrap();
+        // Skip software adapters
+        // Vote for https://github.com/microsoft/windows-rs/issues/793!
+        if (desc.Flags & DXGI_ADAPTER_FLAG3_SOFTWARE) == DXGI_ADAPTER_FLAG3_SOFTWARE {
+            continue;
+        }
+
+        let feature_levels = [
+            (D3D_FEATURE_LEVEL_11_0, "D3D_FEATURE_LEVEL_11_0"),
+            (D3D_FEATURE_LEVEL_11_1, "D3D_FEATURE_LEVEL_11_1"),
+            (D3D_FEATURE_LEVEL_12_0, "D3D_FEATURE_LEVEL_12_0"),
+        ];
+
+        let device =
+            feature_levels
+                .iter()
+                .rev()
+                .find_map(|&(feature_level, feature_level_name)| {
+                    let mut device = None;
+                    match unsafe { D3D12CreateDevice(&adapter4, feature_level, &mut device) } {
+                        Ok(()) => {
+                            info!("Using D3D12 feature level: {}", feature_level_name);
+                            Some(device.unwrap())
+                        }
+                        Err(e) if e.code() == E_NOINTERFACE => {
+                            error!("ID3D12Device interface not supported");
+                            None
+                        }
+                        Err(e) => {
+                            info!(
+                                "D3D12 feature level {} not supported: {}",
+                                feature_level_name, e
+                            );
+                            None
+                        }
+                    }
+                });
+        if device.is_some() {
+            return device;
+        }
+    }
+
+    None
+}
+
+fn main() -> Result<()> {
+    env_logger::Builder::from_env(env_logger::Env::default().default_filter_or("trace")).init();
+
+    let dxgi_factory = unsafe {
+        CreateDXGIFactory2(windows::Win32::Graphics::Dxgi::DXGI_CREATE_FACTORY_FLAGS::default())
+    }?;
+
+    let device = create_d3d12_device(&dxgi_factory).expect("Failed to create D3D12 device.");
+
+    // Setting up the allocator
+    let mut allocator = Allocator::new(&AllocatorCreateDesc {
+        device: ID3D12DeviceVersion::Device(device.clone()),
+        debug_settings: Default::default(),
+        allocation_sizes: Default::default(),
+    })
+    .unwrap();
+
+    // Test allocating Gpu Only memory
+    {
+        let test_buffer_desc = D3D12_RESOURCE_DESC {
+            Dimension: D3D12_RESOURCE_DIMENSION_BUFFER,
+            Alignment: D3D12_DEFAULT_RESOURCE_PLACEMENT_ALIGNMENT as u64,
+            Width: 512,
+            Height: 1,
+            DepthOrArraySize: 1,
+            MipLevels: 1,
+            Format: DXGI_FORMAT_UNKNOWN,
+            SampleDesc: DXGI_SAMPLE_DESC {
+                Count: 1,
+                Quality: 0,
+            },
+            Layout: D3D12_TEXTURE_LAYOUT_ROW_MAJOR,
+            Flags: D3D12_RESOURCE_FLAG_NONE,
+        };
+
+        let allocation_desc = AllocationCreateDesc::from_d3d12_resource_desc(
+            allocator.device(),
+            &test_buffer_desc,
+            "Test allocation (Gpu only)",
+            MemoryLocation::GpuOnly,
+        );
+        let allocation = allocator.allocate(&allocation_desc).unwrap();
+
+        let mut resource: Option<ID3D12Resource> = None;
+        unsafe {
+            device.CreatePlacedResource(
+                allocation.heap(),
+                allocation.offset(),
+                &test_buffer_desc,
+                D3D12_RESOURCE_STATE_COMMON,
+                None,
+                &mut resource,
+            )
+        }?;
+
+        drop(resource);
+
+        allocator.free(allocation).unwrap();
+        info!("Allocation and deallocation of GpuOnly memory was successful.");
+    }
+
+    // Test allocating Cpu to Gpu memory
+    {
+        let test_buffer_desc = D3D12_RESOURCE_DESC {
+            Dimension: D3D12_RESOURCE_DIMENSION_BUFFER,
+            Alignment: D3D12_DEFAULT_RESOURCE_PLACEMENT_ALIGNMENT as u64,
+            Width: 512,
+            Height: 1,
+            DepthOrArraySize: 1,
+            MipLevels: 1,
+            Format: DXGI_FORMAT_UNKNOWN,
+            SampleDesc: DXGI_SAMPLE_DESC {
+                Count: 1,
+                Quality: 0,
+            },
+            Layout: D3D12_TEXTURE_LAYOUT_ROW_MAJOR,
+            Flags: D3D12_RESOURCE_FLAG_NONE,
+        };
+
+        let alloc_info = unsafe { device.GetResourceAllocationInfo(0, &[test_buffer_desc]) };
+
+        let allocation = allocator
+            .allocate(&AllocationCreateDesc {
+                name: "Test allocation (Cpu To Gpu)",
+                location: MemoryLocation::CpuToGpu,
+                size: alloc_info.SizeInBytes,
+                alignment: alloc_info.Alignment,
+                resource_category: ResourceCategory::Buffer,
+            })
+            .unwrap();
+
+        let mut resource: Option<ID3D12Resource> = None;
+        unsafe {
+            device.CreatePlacedResource(
+                allocation.heap(),
+                allocation.offset(),
+                &test_buffer_desc,
+                D3D12_RESOURCE_STATE_COMMON,
+                None,
+                &mut resource,
+            )
+        }?;
+
+        drop(resource);
+
+        allocator.free(allocation).unwrap();
+        info!("Allocation and deallocation of CpuToGpu memory was successful.");
+    }
+
+    // Test allocating Gpu to Cpu memory
+    {
+        let test_buffer_desc = D3D12_RESOURCE_DESC {
+            Dimension: D3D12_RESOURCE_DIMENSION_BUFFER,
+            Alignment: D3D12_DEFAULT_RESOURCE_PLACEMENT_ALIGNMENT as u64,
+            Width: 512,
+            Height: 1,
+            DepthOrArraySize: 1,
+            MipLevels: 1,
+            Format: DXGI_FORMAT_UNKNOWN,
+            SampleDesc: DXGI_SAMPLE_DESC {
+                Count: 1,
+                Quality: 0,
+            },
+            Layout: D3D12_TEXTURE_LAYOUT_ROW_MAJOR,
+            Flags: D3D12_RESOURCE_FLAG_NONE,
+        };
+
+        let alloc_info = unsafe { device.GetResourceAllocationInfo(0, &[test_buffer_desc]) };
+
+        let allocation = allocator
+            .allocate(&AllocationCreateDesc {
+                name: "Test allocation (Gpu to Cpu)",
+                location: MemoryLocation::GpuToCpu,
+                size: alloc_info.SizeInBytes,
+                alignment: alloc_info.Alignment,
+                resource_category: ResourceCategory::Buffer,
+            })
+            .unwrap();
+
+        let mut resource: Option<ID3D12Resource> = None;
+        unsafe {
+            device.CreatePlacedResource(
+                allocation.heap(),
+                allocation.offset(),
+                &test_buffer_desc,
+                D3D12_RESOURCE_STATE_COMMON,
+                None,
+                &mut resource,
+            )
+        }?;
+
+        drop(resource);
+
+        allocator.free(allocation).unwrap();
+        info!("Allocation and deallocation of CpuToGpu memory was successful.");
+    }
+
+    Ok(())
+}

vendor/gpu-allocator/examples/d3d12-buffer.rs

@@ -0,0 +1,283 @@
+//! Example showcasing [`winapi`] interop with [`gpu-allocator`] which is driven by the [`windows`] crate.
+use winapi::{
+    shared::{dxgiformat, winerror},
+    um::{d3d12, d3dcommon},
+    Interface,
+};
+
+mod all_dxgi {
+    pub use winapi::shared::{dxgi1_3::*, dxgi1_6::*, dxgitype::*};
+}
+
+use gpu_allocator::{
+    d3d12::{
+        AllocationCreateDesc, Allocator, AllocatorCreateDesc, ID3D12DeviceVersion,
+        ResourceCategory, ToWinapi, ToWindows,
+    },
+    MemoryLocation,
+};
+use log::*;
+
+fn create_d3d12_device(
+    dxgi_factory: *mut all_dxgi::IDXGIFactory6,
+) -> Option<*mut d3d12::ID3D12Device> {
+    for idx in 0.. {
+        let mut adapter4: *mut all_dxgi::IDXGIAdapter4 = std::ptr::null_mut();
+        let hr = unsafe {
+            dxgi_factory.as_ref().unwrap().EnumAdapters1(
+                idx,
+                <*mut *mut all_dxgi::IDXGIAdapter4>::cast(&mut adapter4),
+            )
+        };
+
+        if hr == winerror::DXGI_ERROR_NOT_FOUND {
+            break;
+        }
+
+        assert_eq!(hr, winerror::S_OK);
+
+        let mut desc = all_dxgi::DXGI_ADAPTER_DESC3::default();
+        let hr = unsafe { adapter4.as_ref().unwrap().GetDesc3(&mut desc) };
+        if hr != winerror::S_OK {
+            error!("Failed to get adapter description for adapter");
+            continue;
+        }
+
+        // Skip software adapters
+        if (desc.Flags & all_dxgi::DXGI_ADAPTER_FLAG3_SOFTWARE)
+            == all_dxgi::DXGI_ADAPTER_FLAG3_SOFTWARE
+        {
+            continue;
+        }
+
+        let feature_levels = [
+            (d3dcommon::D3D_FEATURE_LEVEL_11_0, "D3D_FEATURE_LEVEL_11_0"),
+            (d3dcommon::D3D_FEATURE_LEVEL_11_1, "D3D_FEATURE_LEVEL_11_1"),
+            (d3dcommon::D3D_FEATURE_LEVEL_12_0, "D3D_FEATURE_LEVEL_12_0"),
+        ];
+
+        let device =
+            feature_levels
+                .iter()
+                .rev()
+                .find_map(|&(feature_level, feature_level_name)| {
+                    let mut device: *mut d3d12::ID3D12Device = std::ptr::null_mut();
+                    let hr = unsafe {
+                        d3d12::D3D12CreateDevice(
+                            adapter4.cast(),
+                            feature_level,
+                            &d3d12::ID3D12Device::uuidof(),
+                            <*mut *mut d3d12::ID3D12Device>::cast(&mut device),
+                        )
+                    };
+                    match hr {
+                        winerror::S_OK => {
+                            info!("Using D3D12 feature level: {}.", feature_level_name);
+                            Some(device)
+                        }
+                        winerror::E_NOINTERFACE => {
+                            error!("ID3D12Device interface not supported.");
+                            None
+                        }
+                        _ => {
+                            info!(
+                                "D3D12 feature level: {} not supported: {:x}",
+                                feature_level_name, hr
+                            );
+                            None
+                        }
+                    }
+                });
+        if device.is_some() {
+            return device;
+        }
+    }
+
+    None
+}
+
+fn main() {
+    env_logger::Builder::from_env(env_logger::Env::default().default_filter_or("trace")).init();
+
+    let dxgi_factory = {
+        let mut dxgi_factory: *mut all_dxgi::IDXGIFactory6 = std::ptr::null_mut();
+        let hr = unsafe {
+            all_dxgi::CreateDXGIFactory2(
+                0,
+                &all_dxgi::IID_IDXGIFactory6,
+                <*mut *mut all_dxgi::IDXGIFactory6>::cast(&mut dxgi_factory),
+            )
+        };
+
+        assert_eq!(hr, winerror::S_OK, "Failed to create DXGI factory");
+        dxgi_factory
+    };
+
+    let device = create_d3d12_device(dxgi_factory).expect("Failed to create D3D12 device.");
+
+    // Setting up the allocator
+    let mut allocator = Allocator::new(&AllocatorCreateDesc {
+        device: ID3D12DeviceVersion::Device(device.as_windows().clone()),
+        debug_settings: Default::default(),
+        allocation_sizes: Default::default(),
+    })
+    .unwrap();
+
+    let device = unsafe { device.as_ref() }.unwrap();
+
+    // Test allocating Gpu Only memory
+    {
+        let test_buffer_desc = d3d12::D3D12_RESOURCE_DESC {
+            Dimension: d3d12::D3D12_RESOURCE_DIMENSION_BUFFER,
+            Alignment: d3d12::D3D12_DEFAULT_RESOURCE_PLACEMENT_ALIGNMENT as u64,
+            Width: 512,
+            Height: 1,
+            DepthOrArraySize: 1,
+            MipLevels: 1,
+            Format: dxgiformat::DXGI_FORMAT_UNKNOWN,
+            SampleDesc: all_dxgi::DXGI_SAMPLE_DESC {
+                Count: 1,
+                Quality: 0,
+            },
+            Layout: d3d12::D3D12_TEXTURE_LAYOUT_ROW_MAJOR,
+            Flags: d3d12::D3D12_RESOURCE_FLAG_NONE,
+        };
+
+        let allocation_desc = AllocationCreateDesc::from_winapi_d3d12_resource_desc(
+            device,
+            &test_buffer_desc,
+            "Test allocation (Gpu Only)",
+            MemoryLocation::GpuOnly,
+        );
+        let allocation = allocator.allocate(&allocation_desc).unwrap();
+
+        let mut resource: *mut d3d12::ID3D12Resource = std::ptr::null_mut();
+        let hr = unsafe {
+            device.CreatePlacedResource(
+                allocation.heap().as_winapi() as *mut _,
+                allocation.offset(),
+                &test_buffer_desc,
+                d3d12::D3D12_RESOURCE_STATE_COMMON,
+                std::ptr::null(),
+                &d3d12::IID_ID3D12Resource,
+                <*mut *mut d3d12::ID3D12Resource>::cast(&mut resource),
+            )
+        };
+        if hr != winerror::S_OK {
+            panic!("Failed to create placed resource.");
+        }
+
+        unsafe { resource.as_ref().unwrap().Release() };
+
+        allocator.free(allocation).unwrap();
+        info!("Allocation and deallocation of GpuOnly memory was successful.");
+    }
+
+    // Test allocating Cpu to Gpu memory
+    {
+        let test_buffer_desc = d3d12::D3D12_RESOURCE_DESC {
+            Dimension: d3d12::D3D12_RESOURCE_DIMENSION_BUFFER,
+            Alignment: d3d12::D3D12_DEFAULT_RESOURCE_PLACEMENT_ALIGNMENT as u64,
+            Width: 512,
+            Height: 1,
+            DepthOrArraySize: 1,
+            MipLevels: 1,
+            Format: dxgiformat::DXGI_FORMAT_UNKNOWN,
+            SampleDesc: all_dxgi::DXGI_SAMPLE_DESC {
+                Count: 1,
+                Quality: 0,
+            },
+            Layout: d3d12::D3D12_TEXTURE_LAYOUT_ROW_MAJOR,
+            Flags: d3d12::D3D12_RESOURCE_FLAG_NONE,
+        };
+
+        let alloc_info = unsafe { device.GetResourceAllocationInfo(0, 1, &test_buffer_desc) };
+
+        let allocation = allocator
+            .allocate(&AllocationCreateDesc {
+                name: "Test allocation (Cpu to Gpu)",
+                location: MemoryLocation::CpuToGpu,
+                size: alloc_info.SizeInBytes,
+                alignment: alloc_info.Alignment,
+                resource_category: ResourceCategory::Buffer,
+            })
+            .unwrap();
+
+        let mut resource: *mut d3d12::ID3D12Resource = std::ptr::null_mut();
+        let hr = unsafe {
+            device.CreatePlacedResource(
+                allocation.heap().as_winapi() as *mut _,
+                allocation.offset(),
+                &test_buffer_desc,
+                d3d12::D3D12_RESOURCE_STATE_COMMON,
+                std::ptr::null(),
+                &d3d12::IID_ID3D12Resource,
+                <*mut *mut d3d12::ID3D12Resource>::cast(&mut resource),
+            )
+        };
+        if hr != winerror::S_OK {
+            panic!("Failed to create placed resource.");
+        }
+
+        unsafe { resource.as_ref().unwrap().Release() };
+
+        allocator.free(allocation).unwrap();
+        info!("Allocation and deallocation of CpuToGpu memory was successful.");
+    }
+
+    // Test allocating Gpu to Cpu memory
+    {
+        let test_buffer_desc = d3d12::D3D12_RESOURCE_DESC {
+            Dimension: d3d12::D3D12_RESOURCE_DIMENSION_BUFFER,
+            Alignment: d3d12::D3D12_DEFAULT_RESOURCE_PLACEMENT_ALIGNMENT as u64,
+            Width: 512,
+            Height: 1,
+            DepthOrArraySize: 1,
+            MipLevels: 1,
+            Format: dxgiformat::DXGI_FORMAT_UNKNOWN,
+            SampleDesc: all_dxgi::DXGI_SAMPLE_DESC {
+                Count: 1,
+                Quality: 0,
+            },
+            Layout: d3d12::D3D12_TEXTURE_LAYOUT_ROW_MAJOR,
+            Flags: d3d12::D3D12_RESOURCE_FLAG_NONE,
+        };
+
+        let alloc_info = unsafe { device.GetResourceAllocationInfo(0, 1, &test_buffer_desc) };
+
+        let allocation = allocator
+            .allocate(&AllocationCreateDesc {
+                name: "Test allocation (Gpu to Cpu)",
+                location: MemoryLocation::GpuToCpu,
+                size: alloc_info.SizeInBytes,
+                alignment: alloc_info.Alignment,
+                resource_category: ResourceCategory::Buffer,
+            })
+            .unwrap();
+
+        let mut resource: *mut d3d12::ID3D12Resource = std::ptr::null_mut();
+        let hr = unsafe {
+            device.CreatePlacedResource(
+                allocation.heap().as_winapi() as *mut _,
+                allocation.offset(),
+                &test_buffer_desc,
+                d3d12::D3D12_RESOURCE_STATE_COMMON,
+                std::ptr::null(),
+                &d3d12::IID_ID3D12Resource,
+                <*mut *mut d3d12::ID3D12Resource>::cast(&mut resource),
+            )
+        };
+        if hr != winerror::S_OK {
+            panic!("Failed to create placed resource.");
+        }
+
+        unsafe { resource.as_ref().unwrap().Release() };
+
+        allocator.free(allocation).unwrap();
+        info!("Allocation and deallocation of CpuToGpu memory was successful.");
+    }
+
+    drop(allocator); // Explicitly drop before destruction of device.
+    unsafe { device.Release() };
+    unsafe { dxgi_factory.as_ref().unwrap().Release() };
+}

vendor/gpu-allocator/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.");
+    }
+}

vendor/gpu-allocator/examples/vulkan-buffer.rs

@@ -0,0 +1,198 @@
+use std::default::Default;
+
+use ash::vk;
+use gpu_allocator::{
+    vulkan::{AllocationCreateDesc, AllocationScheme, Allocator, AllocatorCreateDesc},
+    MemoryLocation,
+};
+use log::info;
+
+fn main() {
+    env_logger::Builder::from_env(env_logger::Env::default().default_filter_or("trace")).init();
+
+    let entry = unsafe { ash::Entry::load() }.unwrap();
+
+    // Create Vulkan instance
+    let instance = {
+        let app_name = c"Vulkan gpu-allocator test";
+
+        let appinfo = vk::ApplicationInfo::default()
+            .application_name(app_name)
+            .application_version(0)
+            .engine_name(app_name)
+            .engine_version(0)
+            .api_version(vk::make_api_version(0, 1, 0, 0));
+
+        let layer_names_raw = [c"VK_LAYER_KHRONOS_validation".as_ptr()];
+
+        let create_info = vk::InstanceCreateInfo::default()
+            .application_info(&appinfo)
+            .enabled_layer_names(&layer_names_raw);
+
+        unsafe {
+            entry
+                .create_instance(&create_info, None)
+                .expect("Instance creation error")
+        }
+    };
+
+    // Look for vulkan physical device
+    let (pdevice, queue_family_index) = {
+        let pdevices = unsafe {
+            instance
+                .enumerate_physical_devices()
+                .expect("Physical device error")
+        };
+        pdevices
+            .iter()
+            .find_map(|pdevice| {
+                unsafe { instance.get_physical_device_queue_family_properties(*pdevice) }
+                    .iter()
+                    .enumerate()
+                    .find_map(|(index, &info)| {
+                        let supports_graphics = info.queue_flags.contains(vk::QueueFlags::GRAPHICS);
+                        if supports_graphics {
+                            Some((*pdevice, index))
+                        } else {
+                            None
+                        }
+                    })
+            })
+            .expect("Couldn't find suitable device.")
+    };
+
+    // Create vulkan device
+    let device = {
+        let device_extension_names_raw = vec![];
+        let features = vk::PhysicalDeviceFeatures {
+            shader_clip_distance: 1,
+            ..Default::default()
+        };
+        let priorities = [1.0];
+
+        let queue_info = vk::DeviceQueueCreateInfo::default()
+            .queue_family_index(queue_family_index as u32)
+            .queue_priorities(&priorities);
+
+        let create_info = vk::DeviceCreateInfo::default()
+            .queue_create_infos(std::slice::from_ref(&queue_info))
+            .enabled_extension_names(&device_extension_names_raw)
+            .enabled_features(&features);
+
+        unsafe { instance.create_device(pdevice, &create_info, None).unwrap() }
+    };
+
+    // Setting up the allocator
+    let mut allocator = Allocator::new(&AllocatorCreateDesc {
+        instance: instance.clone(),
+        device: device.clone(),
+        physical_device: pdevice,
+        debug_settings: Default::default(),
+        buffer_device_address: false,
+        allocation_sizes: Default::default(),
+    })
+    .unwrap();
+
+    // Test allocating Gpu Only memory
+    {
+        let test_buffer_info = vk::BufferCreateInfo::default()
+            .size(512)
+            .usage(vk::BufferUsageFlags::STORAGE_BUFFER)
+            .sharing_mode(vk::SharingMode::EXCLUSIVE);
+        let test_buffer = unsafe { device.create_buffer(&test_buffer_info, None) }.unwrap();
+        let requirements = unsafe { device.get_buffer_memory_requirements(test_buffer) };
+        let location = MemoryLocation::GpuOnly;
+
+        let allocation = allocator
+            .allocate(&AllocationCreateDesc {
+                requirements,
+                location,
+                linear: true,
+                allocation_scheme: AllocationScheme::GpuAllocatorManaged,
+                name: "Test allocation (Gpu Only)",
+            })
+            .unwrap();
+
+        unsafe {
+            device
+                .bind_buffer_memory(test_buffer, allocation.memory(), allocation.offset())
+                .unwrap()
+        };
+
+        allocator.free(allocation).unwrap();
+
+        unsafe { device.destroy_buffer(test_buffer, None) };
+
+        info!("Allocation and deallocation of GpuOnly memory was successful.");
+    }
+
+    // Test allocating Cpu to Gpu memory
+    {
+        let test_buffer_info = vk::BufferCreateInfo::default()
+            .size(512)
+            .usage(vk::BufferUsageFlags::STORAGE_BUFFER)
+            .sharing_mode(vk::SharingMode::EXCLUSIVE);
+        let test_buffer = unsafe { device.create_buffer(&test_buffer_info, None) }.unwrap();
+        let requirements = unsafe { device.get_buffer_memory_requirements(test_buffer) };
+        let location = MemoryLocation::CpuToGpu;
+
+        let allocation = allocator
+            .allocate(&AllocationCreateDesc {
+                requirements,
+                location,
+                linear: true,
+                allocation_scheme: AllocationScheme::GpuAllocatorManaged,
+                name: "Test allocation (Cpu to Gpu)",
+            })
+            .unwrap();
+
+        unsafe {
+            device
+                .bind_buffer_memory(test_buffer, allocation.memory(), allocation.offset())
+                .unwrap()
+        };
+
+        allocator.free(allocation).unwrap();
+
+        unsafe { device.destroy_buffer(test_buffer, None) };
+
+        info!("Allocation and deallocation of CpuToGpu memory was successful.");
+    }
+
+    // Test allocating Gpu to Cpu memory
+    {
+        let test_buffer_info = vk::BufferCreateInfo::default()
+            .size(512)
+            .usage(vk::BufferUsageFlags::STORAGE_BUFFER)
+            .sharing_mode(vk::SharingMode::EXCLUSIVE);
+        let test_buffer = unsafe { device.create_buffer(&test_buffer_info, None) }.unwrap();
+        let requirements = unsafe { device.get_buffer_memory_requirements(test_buffer) };
+        let location = MemoryLocation::GpuToCpu;
+
+        let allocation = allocator
+            .allocate(&AllocationCreateDesc {
+                requirements,
+                location,
+                linear: true,
+                allocation_scheme: AllocationScheme::GpuAllocatorManaged,
+                name: "Test allocation (Gpu to Cpu)",
+            })
+            .unwrap();
+
+        unsafe {
+            device
+                .bind_buffer_memory(test_buffer, allocation.memory(), allocation.offset())
+                .unwrap()
+        };
+
+        allocator.free(allocation).unwrap();
+
+        unsafe { device.destroy_buffer(test_buffer, None) };
+
+        info!("Allocation and deallocation of GpuToCpu memory was successful.");
+    }
+
+    drop(allocator); // Explicitly drop before destruction of device and instance.
+    unsafe { device.destroy_device(None) };
+    unsafe { instance.destroy_instance(None) };
+}