cargo fmt

Author: KronicDeth

liblumen_alloc/src/erts/process.rs

@@ -11,11 +11,10 @@ use core::mem;
 use core::ptr::{self, NonNull};
 use core::sync::atomic::{AtomicUsize, Ordering};
 
-use intrusive_collections::{LinkedList, UnsafeRef};
 use hashbrown::HashMap;
+use intrusive_collections::{LinkedList, UnsafeRef};
 use liblumen_core::locks::SpinLock;
 
-
 use self::gc::*;
 use super::*;
 use crate::borrow::CloneToProcess;
@@ -137,7 +136,7 @@ impl ProcessControlBlock {
 
     /// Frees stack space occupied by the last term on the stack,
     /// adjusting the stack pointer accordingly.
-    /// 
+    ///
     /// Use `stack_popn` to pop multiple terms from the stack at once
     #[inline]
     pub fn stack_pop(&mut self) -> Option<Term> {
@@ -151,7 +150,7 @@ impl ProcessControlBlock {
     }
 
     /// Pushes an immediate term or reference to term/list on top of the stack
-    /// 
+    ///
     /// Returns `Err(AllocErr)` if the process is out of stack space
     #[inline]
     pub fn stack_push(&mut self, term: Term) -> Result<(), AllocErr> {

liblumen_alloc/src/erts/process/alloc.rs

@@ -2,12 +2,12 @@ use core::alloc::{AllocErr, Layout};
 use core::mem;
 use core::ptr::NonNull;
 
-use lazy_static::lazy_static;
-use heapless::Vec;
 #[cfg(target_pointer_width = "64")]
 use heapless::consts::U152 as UHEAP_SIZES_LEN;
 #[cfg(target_pointer_width = "32")]
 use heapless::consts::U57 as UHEAP_SIZES_LEN;
+use heapless::Vec;
+use lazy_static::lazy_static;
 
 use liblumen_alloc_macros::generate_heap_sizes;
 use liblumen_core::alloc::mmap;
@@ -214,7 +214,7 @@ pub trait AllocInProcess {
     /// Perform a stack allocation of `size` words to hold a single term.
     ///
     /// Returns `Err(AllocErr)` if there is not enough space available
-    /// 
+    ///
     /// NOTE: Do not use this to allocate space for multiple terms (lists
     /// and boxes count as a single term), as the size of the stack in terms
     /// is tied to allocations. Each time `stack_alloc` is called, the stack
@@ -268,9 +268,9 @@ pub trait StackPrimitives {
     fn stack_size(&self) -> usize;
 
     /// Manually sets the stack size
-    /// 
+    ///
     /// # Safety
-    /// 
+    ///
     /// This is super unsafe, its only use is when constructing objects such as lists
     /// on the stack incrementally, thus representing a single logical term but composed
     /// of many small allocations. As `alloca_*` increments the `stack_size` value each
@@ -282,11 +282,11 @@ pub trait StackPrimitives {
     fn stack_pointer(&mut self) -> *mut Term;
 
     /// Manually sets the stack pointer to the given pointer
-    /// 
+    ///
     /// NOTE: This will panic if the stack pointer is outside the process heap
-    /// 
+    ///
     /// # Safety
-    /// 
+    ///
     /// This is obviously super unsafe, but is useful as an optimization in some
     /// cases where a stack allocated object is being constructed but fails partway,
     /// and needs to be freed
@@ -299,10 +299,10 @@ pub trait StackPrimitives {
     fn stack_available(&self) -> usize;
 
     /// This function returns the term located in the given stack slot, if it exists.
-    /// 
+    ///
     /// The stack slots are 1-indexed, where `1` is the top of the stack, or most recent
-    /// allocation, and `S` is the bottom of the stack, or oldest allocation. 
-    /// 
+    /// allocation, and `S` is the bottom of the stack, or oldest allocation.
+    ///
     /// If `S > stack_size`, then `None` is returned. Otherwise, `Some(Term)` is returned.
     #[inline]
     fn stack_slot(&mut self, n: usize) -> Option<Term>;
@@ -316,4 +316,4 @@ pub trait StackPrimitives {
     /// number of terms allocated on the stack
     #[inline]
     fn stack_popn(&mut self, n: usize);
-}
+}

liblumen_alloc/src/erts/process/gc/collector.rs

@@ -192,7 +192,7 @@ impl<'p> GarbageCollector<'p> {
         // Move the stack to the end of the new heap
         let old_stack_start = self.process.young.stack_pointer();
         let old_stack_slots = self.process.young.stack_size();
-        unsafe { 
+        unsafe {
             let new_stack_start = new_heap.alloca_unchecked(stack_size).as_ptr();
             ptr::copy_nonoverlapping(old_stack_start, new_stack_start, stack_size);
             new_heap.set_stack_pointer(new_stack_start);
@@ -425,7 +425,12 @@ impl<'p> GarbageCollector<'p> {
         // most references on the new heap point to the old heap so the next stage
         // is to scan through the new heap, evacuating data to the new heap until all
         // live references have been moved
-        new_young.sweep(&mut self.process.young, &mut self.process.old, mature, mature_end);
+        new_young.sweep(
+            &mut self.process.young,
+            &mut self.process.old,
+            mature,
+            mature_end,
+        );
 
         // If we have been tenuring (we have an old generation and have moved values into it),
         // then those newly tenured values may hold references into the old young generation
@@ -571,4 +576,4 @@ impl<'p> GarbageCollector<'p> {
     fn sanity_check(&self) {
         self.process.young.sanity_check()
     }
-}
+}

liblumen_alloc/src/erts/process/gc/old_heap.rs

@@ -1,12 +1,12 @@
+use core::fmt;
 use core::mem;
 use core::ptr;
-use core::fmt;
 
 use crate::erts::*;
 
 use liblumen_core::util::pointer::*;
 
-use super::{YoungHeap, VirtualBinaryHeap};
+use super::{VirtualBinaryHeap, YoungHeap};
 
 /// This type represents the old generation process heap
 ///
@@ -32,7 +32,7 @@ impl OldHeap {
             let top = start;
             let vheap = VirtualBinaryHeap::new(size);
             Self {
-                start, 
+                start,
                 end,
                 top,
                 vheap,
@@ -366,7 +366,8 @@ impl Drop for OldHeap {
     fn drop(&mut self) {
         unsafe {
             if self.active() {
-                // Free virtual binary heap, we can't free the memory of this heap until we've done this
+                // Free virtual binary heap, we can't free the memory of this heap until we've done
+                // this
                 self.vheap.clear();
                 // Free memory region managed by this heap instance
                 process::alloc::free(self.start, self.size());
@@ -378,7 +379,8 @@ impl fmt::Debug for OldHeap {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         f.write_fmt(format_args!(
             "OldHeap (heap: {:?}-{:?}, used: {}, unused: {}) [\n",
-            self.start, self.top,
+            self.start,
+            self.top,
             self.heap_used(),
             self.heap_available(),
         ))?;
@@ -400,4 +402,4 @@ impl fmt::Debug for OldHeap {
         f.write_fmt(format_args!("  {:?}: END OF HEAP", pos))?;
         f.write_str("]\n")
     }
-}
+}

liblumen_alloc/src/erts/process/gc/virtual_heap.rs

@@ -164,4 +164,4 @@ impl VirtualBinaryHeap {
             }
         }
     }
-}
+}