replace std::* with core::* or alloc::*

Author: CrazyboyQCD

src/allocator/dedicated_block_allocator/mod.rs

@@ -4,8 +4,11 @@ use std::{backtrace::Backtrace, sync::Arc};
 
 #[cfg(feature = "visualizer")]
 pub(crate) mod visualizer;
-
-use std::{backtrace::Backtrace, sync::Arc};
+use alloc::{
+    borrow::ToOwned,
+    string::{String, ToString},
+    vec::Vec,
+};
 
 use log::{log, Level};
 
@@ -63,12 +66,12 @@ impl SubAllocator for DedicatedBlockAllocator {
         }
 
         #[allow(clippy::unwrap_used)]
-        let dummy_id = std::num::NonZeroU64::new(1).unwrap();
+        let dummy_id = core::num::NonZeroU64::new(1).unwrap();
         Ok((0, dummy_id))
     }
 
-    fn free(&mut self, chunk_id: Option<std::num::NonZeroU64>) -> Result<()> {
-        if chunk_id != std::num::NonZeroU64::new(1) {
+    fn free(&mut self, chunk_id: Option<core::num::NonZeroU64>) -> Result<()> {
+        if chunk_id != core::num::NonZeroU64::new(1) {
             Err(AllocationError::Internal("Chunk ID must be 1.".into()))
         } else {
             self.allocated = 0;
@@ -78,10 +81,10 @@ impl SubAllocator for DedicatedBlockAllocator {
 
     fn rename_allocation(
         &mut self,
-        chunk_id: Option<std::num::NonZeroU64>,
+        chunk_id: Option<core::num::NonZeroU64>,
         name: &str,
     ) -> Result<()> {
-        if chunk_id != std::num::NonZeroU64::new(1) {
+        if chunk_id != core::num::NonZeroU64::new(1) {
             Err(AllocationError::Internal("Chunk ID must be 1.".into()))
         } else {
             self.name = Some(name.into());

src/allocator/free_list_allocator/mod.rs

@@ -10,6 +10,15 @@ use std::{
     sync::Arc,
 };
 
+use alloc::{
+    borrow::ToOwned,
+    string::{String, ToString},
+    vec::Vec,
+};
+
+#[cfg(feature = "hashbrown")]
+use hashbrown::{HashMap, HashSet};
+
 use log::{log, Level};
 
 use super::{AllocationReport, AllocationType, SubAllocator, SubAllocatorBase};
@@ -27,25 +36,25 @@ fn align_up(val: u64, alignment: u64) -> u64 {
 
 #[derive(Debug)]
 pub(crate) struct MemoryChunk {
-    pub(crate) chunk_id: std::num::NonZeroU64,
+    pub(crate) chunk_id: core::num::NonZeroU64,
     pub(crate) size: u64,
     pub(crate) offset: u64,
     pub(crate) allocation_type: AllocationType,
     pub(crate) name: Option<String>,
     /// Only used if [`crate::AllocatorDebugSettings::store_stack_traces`] is [`true`]
     #[cfg(feature = "std")]
     pub(crate) backtrace: Arc<Backtrace>,
-    next: Option<std::num::NonZeroU64>,
-    prev: Option<std::num::NonZeroU64>,
+    next: Option<core::num::NonZeroU64>,
+    prev: Option<core::num::NonZeroU64>,
 }
 
 #[derive(Debug)]
 pub(crate) struct FreeListAllocator {
     size: u64,
     allocated: u64,
     pub(crate) chunk_id_counter: u64,
-    pub(crate) chunks: HashMap<std::num::NonZeroU64, MemoryChunk>,
-    free_chunks: HashSet<std::num::NonZeroU64>,
+    pub(crate) chunks: HashMap<core::num::NonZeroU64, MemoryChunk>,
+    free_chunks: HashSet<core::num::NonZeroU64>,
 }
 
 /// Test if two suballocations will overlap the same page.
@@ -70,7 +79,7 @@ fn has_granularity_conflict(type0: AllocationType, type1: AllocationType) -> boo
 impl FreeListAllocator {
     pub(crate) fn new(size: u64) -> Self {
         #[allow(clippy::unwrap_used)]
-        let initial_chunk_id = std::num::NonZeroU64::new(1).unwrap();
+        let initial_chunk_id = core::num::NonZeroU64::new(1).unwrap();
 
         let mut chunks = HashMap::default();
         chunks.insert(
@@ -103,27 +112,27 @@ impl FreeListAllocator {
     }
 
     /// Generates a new unique chunk ID
-    fn get_new_chunk_id(&mut self) -> Result<std::num::NonZeroU64> {
+    fn get_new_chunk_id(&mut self) -> Result<core::num::NonZeroU64> {
         if self.chunk_id_counter == u64::MAX {
             // End of chunk id counter reached, no more allocations are possible.
             return Err(AllocationError::OutOfMemory);
         }
 
         let id = self.chunk_id_counter;
         self.chunk_id_counter += 1;
-        std::num::NonZeroU64::new(id).ok_or_else(|| {
+        core::num::NonZeroU64::new(id).ok_or_else(|| {
             AllocationError::Internal("New chunk id was 0, which is not allowed.".into())
         })
     }
     /// Finds the specified `chunk_id` in the list of free chunks and removes if from the list
-    fn remove_id_from_free_list(&mut self, chunk_id: std::num::NonZeroU64) {
+    fn remove_id_from_free_list(&mut self, chunk_id: core::num::NonZeroU64) {
         self.free_chunks.remove(&chunk_id);
     }
     /// Merges two adjacent chunks. Right chunk will be merged into the left chunk
     fn merge_free_chunks(
         &mut self,
-        chunk_left: std::num::NonZeroU64,
-        chunk_right: std::num::NonZeroU64,
+        chunk_left: core::num::NonZeroU64,
+        chunk_right: core::num::NonZeroU64,
     ) -> Result<()> {
         // Gather data from right chunk and remove it
         let (right_size, right_next) = {
@@ -172,7 +181,7 @@ impl SubAllocator for FreeListAllocator {
             return Err(AllocationError::OutOfMemory);
         }
 
-        let mut best_fit_id: Option<std::num::NonZeroU64> = None;
+        let mut best_fit_id: Option<core::num::NonZeroU64> = None;
         let mut best_offset = 0u64;
         let mut best_aligned_size = 0u64;
         let mut best_chunk_size = 0u64;
@@ -297,7 +306,7 @@ impl SubAllocator for FreeListAllocator {
         Ok((best_offset, chunk_id))
     }
 
-    fn free(&mut self, chunk_id: Option<std::num::NonZeroU64>) -> Result<()> {
+    fn free(&mut self, chunk_id: Option<core::num::NonZeroU64>) -> Result<()> {
         let chunk_id = chunk_id
             .ok_or_else(|| AllocationError::Internal("Chunk ID must be a valid value.".into()))?;
 
@@ -337,7 +346,7 @@ impl SubAllocator for FreeListAllocator {
 
     fn rename_allocation(
         &mut self,
-        chunk_id: Option<std::num::NonZeroU64>,
+        chunk_id: Option<core::num::NonZeroU64>,
         name: &str,
     ) -> Result<()> {
         let chunk_id = chunk_id

src/allocator/mod.rs

@@ -1,5 +1,5 @@
-use std::{backtrace::Backtrace, fmt, ops::Range, sync::Arc};
-
+use alloc::{fmt, string::String, vec::Vec};
+use core::ops::Range;
 use log::*;
 #[cfg(feature = "std")]
 use std::{backtrace::Backtrace, sync::Arc};
@@ -81,15 +81,15 @@ impl fmt::Debug for AllocationReport {
 impl fmt::Debug for AllocatorReport {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         let mut allocations = self.allocations.clone();
-        allocations.sort_by_key(|alloc| std::cmp::Reverse(alloc.size));
+        allocations.sort_by_key(|alloc| core::cmp::Reverse(alloc.size));
 
         let max_num_allocations_to_print = f.precision().unwrap_or(usize::MAX);
         allocations.truncate(max_num_allocations_to_print);
 
         f.debug_struct("AllocatorReport")
             .field(
                 "summary",
-                &std::format_args!(
+                &core::format_args!(
                     "{} / {}",
                     fmt_bytes(self.total_allocated_bytes),
                     fmt_bytes(self.total_reserved_bytes)
@@ -118,11 +118,11 @@ pub(crate) trait SubAllocator: SubAllocatorBase + fmt::Debug + Sync + Send {
         #[cfg(feature = "std")] backtrace: Arc<Backtrace>,
     ) -> Result<(u64, core::num::NonZeroU64)>;
 
-    fn free(&mut self, chunk_id: Option<std::num::NonZeroU64>) -> Result<()>;
+    fn free(&mut self, chunk_id: Option<core::num::NonZeroU64>) -> Result<()>;
 
     fn rename_allocation(
         &mut self,
-        chunk_id: Option<std::num::NonZeroU64>,
+        chunk_id: Option<core::num::NonZeroU64>,
         name: &str,
     ) -> Result<()>;
 

src/d3d12/mod.rs

@@ -38,49 +38,49 @@ mod public_winapi {
 
     impl ToWinapi<winapi_d3d12::ID3D12Resource> for ID3D12Resource {
         fn as_winapi(&self) -> *const winapi_d3d12::ID3D12Resource {
-            unsafe { std::mem::transmute_copy(self) }
+            unsafe { core::mem::transmute_copy(self) }
         }
 
         fn as_winapi_mut(&mut self) -> *mut winapi_d3d12::ID3D12Resource {
-            unsafe { std::mem::transmute_copy(self) }
+            unsafe { core::mem::transmute_copy(self) }
         }
     }
 
     impl ToWinapi<winapi_d3d12::ID3D12Device> for ID3D12Device {
         fn as_winapi(&self) -> *const winapi_d3d12::ID3D12Device {
-            unsafe { std::mem::transmute_copy(self) }
+            unsafe { core::mem::transmute_copy(self) }
         }
 
         fn as_winapi_mut(&mut self) -> *mut winapi_d3d12::ID3D12Device {
-            unsafe { std::mem::transmute_copy(self) }
+            unsafe { core::mem::transmute_copy(self) }
         }
     }
 
     impl ToWindows<ID3D12Device> for *const winapi_d3d12::ID3D12Device {
         fn as_windows(&self) -> &ID3D12Device {
-            unsafe { std::mem::transmute(self) }
+            unsafe { core::mem::transmute(self) }
         }
     }
 
     impl ToWindows<ID3D12Device> for *mut winapi_d3d12::ID3D12Device {
         fn as_windows(&self) -> &ID3D12Device {
-            unsafe { std::mem::transmute(self) }
+            unsafe { core::mem::transmute(self) }
         }
     }
 
     impl ToWindows<ID3D12Device> for &mut winapi_d3d12::ID3D12Device {
         fn as_windows(&self) -> &ID3D12Device {
-            unsafe { std::mem::transmute(self) }
+            unsafe { core::mem::transmute(self) }
         }
     }
 
     impl ToWinapi<winapi_d3d12::ID3D12Heap> for ID3D12Heap {
         fn as_winapi(&self) -> *const winapi_d3d12::ID3D12Heap {
-            unsafe { std::mem::transmute_copy(self) }
+            unsafe { core::mem::transmute_copy(self) }
         }
 
         fn as_winapi_mut(&mut self) -> *mut winapi_d3d12::ID3D12Heap {
-            unsafe { std::mem::transmute_copy(self) }
+            unsafe { core::mem::transmute_copy(self) }
         }
     }
 }
@@ -208,10 +208,10 @@ impl<'a> AllocationCreateDesc<'a> {
         let device = device.as_windows();
         // Raw structs are binary-compatible
         let desc = unsafe {
-            std::mem::transmute::<&winapi_d3d12::D3D12_RESOURCE_DESC, &D3D12_RESOURCE_DESC>(desc)
+            core::mem::transmute::<&winapi_d3d12::D3D12_RESOURCE_DESC, &D3D12_RESOURCE_DESC>(desc)
         };
         let allocation_info =
-            unsafe { device.GetResourceAllocationInfo(0, std::slice::from_ref(desc)) };
+            unsafe { device.GetResourceAllocationInfo(0, core::slice::from_ref(desc)) };
         let resource_category: ResourceCategory = desc.into();
 
         AllocationCreateDesc {
@@ -234,7 +234,7 @@ impl<'a> AllocationCreateDesc<'a> {
         location: MemoryLocation,
     ) -> Self {
         let allocation_info =
-            unsafe { device.GetResourceAllocationInfo(0, std::slice::from_ref(desc)) };
+            unsafe { device.GetResourceAllocationInfo(0, core::slice::from_ref(desc)) };
         let resource_category: ResourceCategory = desc.into();
 
         AllocationCreateDesc {
@@ -259,7 +259,7 @@ pub enum ID3D12DeviceVersion {
     Device12(ID3D12Device12),
 }
 
-impl std::ops::Deref for ID3D12DeviceVersion {
+impl core::ops::Deref for ID3D12DeviceVersion {
     type Target = ID3D12Device;
 
     fn deref(&self) -> &Self::Target {
@@ -324,7 +324,7 @@ pub struct CommittedAllocationStatistics {
 
 #[derive(Debug)]
 pub struct Allocation {
-    chunk_id: Option<std::num::NonZeroU64>,
+    chunk_id: Option<core::num::NonZeroU64>,
     offset: u64,
     size: u64,
     memory_block_index: usize,
@@ -335,7 +335,7 @@ pub struct Allocation {
 }
 
 impl Allocation {
-    pub fn chunk_id(&self) -> Option<std::num::NonZeroU64> {
+    pub fn chunk_id(&self) -> Option<core::num::NonZeroU64> {
         self.chunk_id
     }
 

src/metal/mod.rs

@@ -1,6 +1,8 @@
 #[cfg(feature = "std")]
 use std::{backtrace::Backtrace, sync::Arc};
 
+use alloc::{boxed::Box, string::ToString, vec::Vec};
+
 #[cfg(feature = "visualizer")]
 mod visualizer;
 #[cfg(feature = "visualizer")]
@@ -30,7 +32,7 @@ fn memory_location_to_metal(location: MemoryLocation) -> MTLResourceOptions {
 
 #[derive(Debug)]
 pub struct Allocation {
-    chunk_id: Option<std::num::NonZeroU64>,
+    chunk_id: Option<core::num::NonZeroU64>,
     offset: u64,
     size: u64,
     memory_block_index: usize,

src/result.rs

@@ -1,3 +1,4 @@
+use alloc::string::String;
 use thiserror::Error;
 
 #[derive(Error, Debug)]
@@ -22,4 +23,4 @@ pub enum AllocationError {
     CastableFormatsRequiresAtLeastDevice12,
 }
 
-pub type Result<V, E = AllocationError> = ::std::result::Result<V, E>;
+pub type Result<V, E = AllocationError> = ::core::result::Result<V, E>;