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

CrazyboyQCD · CrazyboyQCD · commit a22352ab9c4f · 2025-02-12T16:20:03.000+08:00
diff --git a/src/allocator/dedicated_block_allocator/mod.rs b/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());
diff --git a/src/allocator/free_list_allocator/mod.rs b/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
diff --git a/src/allocator/mod.rs b/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<()>;
 
diff --git a/src/d3d12/mod.rs b/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
     }
 
diff --git a/src/metal/mod.rs b/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,
diff --git a/src/result.rs b/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>;
diff --git a/src/vulkan/mod.rs b/src/vulkan/mod.rs

Original file line number	Diff line number	Diff line change
`@@ -38,49 +38,49 @@ mod public_winapi {`
`38`	`38`
`39`	`39`	`impl ToWinapi<winapi_d3d12::ID3D12Resource> for ID3D12Resource {`
`40`	`40`	`fn as_winapi(&self) -> *const winapi_d3d12::ID3D12Resource {`
`41`		`- unsafe { std::mem::transmute_copy(self) }`
	`41`	`+ unsafe { core::mem::transmute_copy(self) }`
`42`	`42`	`}`
`43`	`43`
`44`	`44`	`fn as_winapi_mut(&mut self) -> *mut winapi_d3d12::ID3D12Resource {`
`45`		`- unsafe { std::mem::transmute_copy(self) }`
	`45`	`+ unsafe { core::mem::transmute_copy(self) }`
`46`	`46`	`}`
`47`	`47`	`}`
`48`	`48`
`49`	`49`	`impl ToWinapi<winapi_d3d12::ID3D12Device> for ID3D12Device {`
`50`	`50`	`fn as_winapi(&self) -> *const winapi_d3d12::ID3D12Device {`
`51`		`- unsafe { std::mem::transmute_copy(self) }`
	`51`	`+ unsafe { core::mem::transmute_copy(self) }`
`52`	`52`	`}`
`53`	`53`
`54`	`54`	`fn as_winapi_mut(&mut self) -> *mut winapi_d3d12::ID3D12Device {`
`55`		`- unsafe { std::mem::transmute_copy(self) }`
	`55`	`+ unsafe { core::mem::transmute_copy(self) }`
`56`	`56`	`}`
`57`	`57`	`}`
`58`	`58`
`59`	`59`	`impl ToWindows<ID3D12Device> for *const winapi_d3d12::ID3D12Device {`
`60`	`60`	`fn as_windows(&self) -> &ID3D12Device {`
`61`		`- unsafe { std::mem::transmute(self) }`
	`61`	`+ unsafe { core::mem::transmute(self) }`
`62`	`62`	`}`
`63`	`63`	`}`
`64`	`64`
`65`	`65`	`impl ToWindows<ID3D12Device> for *mut winapi_d3d12::ID3D12Device {`
`66`	`66`	`fn as_windows(&self) -> &ID3D12Device {`
`67`		`- unsafe { std::mem::transmute(self) }`
	`67`	`+ unsafe { core::mem::transmute(self) }`
`68`	`68`	`}`
`69`	`69`	`}`
`70`	`70`
`71`	`71`	`impl ToWindows<ID3D12Device> for &mut winapi_d3d12::ID3D12Device {`
`72`	`72`	`fn as_windows(&self) -> &ID3D12Device {`
`73`		`- unsafe { std::mem::transmute(self) }`
	`73`	`+ unsafe { core::mem::transmute(self) }`
`74`	`74`	`}`
`75`	`75`	`}`
`76`	`76`
`77`	`77`	`impl ToWinapi<winapi_d3d12::ID3D12Heap> for ID3D12Heap {`
`78`	`78`	`fn as_winapi(&self) -> *const winapi_d3d12::ID3D12Heap {`
`79`		`- unsafe { std::mem::transmute_copy(self) }`
	`79`	`+ unsafe { core::mem::transmute_copy(self) }`
`80`	`80`	`}`
`81`	`81`
`82`	`82`	`fn as_winapi_mut(&mut self) -> *mut winapi_d3d12::ID3D12Heap {`
`83`		`- unsafe { std::mem::transmute_copy(self) }`
	`83`	`+ unsafe { core::mem::transmute_copy(self) }`
`84`	`84`	`}`
`85`	`85`	`}`
`86`	`86`	`}`
`@@ -208,10 +208,10 @@ impl<'a> AllocationCreateDesc<'a> {`
`208`	`208`	`let device = device.as_windows();`
`209`	`209`	`// Raw structs are binary-compatible`
`210`	`210`	`let desc = unsafe {`
`211`		`- std::mem::transmute::<&winapi_d3d12::D3D12_RESOURCE_DESC, &D3D12_RESOURCE_DESC>(desc)`
	`211`	`+ core::mem::transmute::<&winapi_d3d12::D3D12_RESOURCE_DESC, &D3D12_RESOURCE_DESC>(desc)`
`212`	`212`	`};`
`213`	`213`	`let allocation_info =`
`214`		`- unsafe { device.GetResourceAllocationInfo(0, std::slice::from_ref(desc)) };`
	`214`	`+ unsafe { device.GetResourceAllocationInfo(0, core::slice::from_ref(desc)) };`
`215`	`215`	`let resource_category: ResourceCategory = desc.into();`
`216`	`216`
`217`	`217`	`AllocationCreateDesc {`
`@@ -234,7 +234,7 @@ impl<'a> AllocationCreateDesc<'a> {`
`234`	`234`	`location: MemoryLocation,`
`235`	`235`	`) -> Self {`
`236`	`236`	`let allocation_info =`
`237`		`- unsafe { device.GetResourceAllocationInfo(0, std::slice::from_ref(desc)) };`
	`237`	`+ unsafe { device.GetResourceAllocationInfo(0, core::slice::from_ref(desc)) };`
`238`	`238`	`let resource_category: ResourceCategory = desc.into();`
`239`	`239`
`240`	`240`	`AllocationCreateDesc {`
`@@ -259,7 +259,7 @@ pub enum ID3D12DeviceVersion {`
`259`	`259`	`Device12(ID3D12Device12),`
`260`	`260`	`}`
`261`	`261`
`262`		`-impl std::ops::Deref for ID3D12DeviceVersion {`
	`262`	`+impl core::ops::Deref for ID3D12DeviceVersion {`
`263`	`263`	`type Target = ID3D12Device;`
`264`	`264`
`265`	`265`	`fn deref(&self) -> &Self::Target {`
`@@ -324,7 +324,7 @@ pub struct CommittedAllocationStatistics {`
`324`	`324`
`325`	`325`	`#[derive(Debug)]`
`326`	`326`	`pub struct Allocation {`
`327`		`- chunk_id: Option<std::num::NonZeroU64>,`
	`327`	`+ chunk_id: Option<core::num::NonZeroU64>,`
`328`	`328`	`offset: u64,`
`329`	`329`	`size: u64,`
`330`	`330`	`memory_block_index: usize,`
`@@ -335,7 +335,7 @@ pub struct Allocation {`
`335`	`335`	`}`
`336`	`336`
`337`	`337`	`impl Allocation {`
`338`		`- pub fn chunk_id(&self) -> Option<std::num::NonZeroU64> {`
	`338`	`+ pub fn chunk_id(&self) -> Option<core::num::NonZeroU64> {`
`339`	`339`	`self.chunk_id`
`340`	`340`	`}`
`341`	`341`
Original file line number	Diff line number	Diff line change
`@@ -1,3 +1,4 @@`
	`1`	`+use alloc::string::String;`
`1`	`2`	`use thiserror::Error;`
`2`	`3`
`3`	`4`	`#[derive(Error, Debug)]`
`@@ -22,4 +23,4 @@ pub enum AllocationError {`
`22`	`23`	`CastableFormatsRequiresAtLeastDevice12,`
`23`	`24`	`}`
`24`	`25`
`25`		`-pub type Result<V, E = AllocationError> = ::std::result::Result<V, E>;`
	`26`	`+pub type Result<V, E = AllocationError> = ::core::result::Result<V, E>;`