Add a fixed-sized backend for experimental use with non-traditional targets

Author: ZackPierce

test.sh

@@ -15,4 +15,9 @@ time cargo test --release --features "extra_assertions size_classes"
 time cargo test --release --features "extra_assertions"
 time cargo test --release --features "size_classes"
 time cargo test --release
+
+time cargo test --release --features "static_array_backend extra_assertions size_classes"
+time cargo test --release --features "static_array_backend extra_assertions"
+time cargo test --release --features "static_array_backend size_classes"
+time cargo test --release --features "static_array_backend"
 cd -

test/Cargo.toml

@@ -7,6 +7,7 @@ version = "0.1.0"
 rand = "0.4.2"
 quickcheck = "0.6.0"
 histo = "0.1.0"
+cfg-if = "0.1.2"
 
 [dependencies.wee_alloc]
 path = "../wee_alloc"
@@ -16,3 +17,4 @@ features = ["use_std_for_test_debugging"]
 [features]
 size_classes = ["wee_alloc/size_classes"]
 extra_assertions = ["wee_alloc/extra_assertions"]
+static_array_backend = ["wee_alloc/static_array_backend"]

test/benches/bench.rs

@@ -8,7 +8,7 @@ use std::io;
 use wee_alloc_test::*;
 
 macro_rules! bench_trace {
-    ( $name:ident, $trace:expr ) => {
+    ($name:ident, $trace:expr) => {
         #[bench]
         #[cfg(not(feature = "extra_assertions"))]
         fn $name(b: &mut test::Bencher) {
@@ -18,7 +18,10 @@ macro_rules! bench_trace {
                 let stdout = io::stdout();
                 let _stdout = stdout.lock();
 
-                println!("################## {} ##################", stringify!($name));
+                println!(
+                    "################## {} ##################",
+                    stringify!($name)
+                );
                 println!("#");
                 println!("# Allocations by log2(Size)");
                 println!("#");
@@ -34,15 +37,18 @@ macro_rules! bench_trace {
                 operations.run_with_allocator(a);
             });
         }
-    }
+    };
 }
 
 bench_trace!(bench_trace_cpp_demangle, "../traces/cpp-demangle.trace");
 bench_trace!(bench_trace_dogfood, "../traces/dogfood.trace");
 bench_trace!(bench_trace_ffmpeg, "../traces/ffmpeg.trace");
 bench_trace!(bench_trace_find, "../traces/find.trace");
 bench_trace!(bench_trace_gcc_hello, "../traces/gcc-hello.trace");
-bench_trace!(bench_trace_grep_random_data, "../traces/grep-random-data.trace");
+bench_trace!(
+    bench_trace_grep_random_data,
+    "../traces/grep-random-data.trace"
+);
 bench_trace!(bench_trace_grep_recursive, "../traces/grep-recursive.trace");
 bench_trace!(bench_trace_ls, "../traces/ls.trace");
 bench_trace!(bench_trace_source_map, "../traces/source-map.trace");

test/src/lib.rs

@@ -4,6 +4,8 @@ extern crate alloc;
 extern crate histo;
 #[macro_use]
 extern crate quickcheck;
+#[macro_use]
+extern crate cfg_if;
 extern crate rand;
 extern crate wee_alloc;
 
@@ -257,10 +259,10 @@ impl Operations {
         let handle2 = thread::spawn(move || ops2.run_with_allocator(&WEE));
         let handle3 = thread::spawn(move || ops3.run_with_allocator(&WEE));
 
-        handle0.join().unwrap();
-        handle1.join().unwrap();
-        handle2.join().unwrap();
-        handle3.join().unwrap();
+        handle0.join().expect("Thread 0 Failed");
+        handle1.join().expect("Thread 1 Failed");
+        handle2.join().expect("Thread 2 Failed");
+        handle3.join().expect("Thread 3 Failed");
     }
 
     pub fn run_with_allocator<A: Alloc>(&self, mut a: A) {
@@ -344,12 +346,17 @@ macro_rules! run_quickchecks {
 // with each other.
 run_quickchecks!(quickchecks_0);
 run_quickchecks!(quickchecks_1);
-run_quickchecks!(quickchecks_2);
-run_quickchecks!(quickchecks_3);
-run_quickchecks!(quickchecks_4);
-run_quickchecks!(quickchecks_5);
-run_quickchecks!(quickchecks_6);
-run_quickchecks!(quickchecks_7);
+// Limit the extent of the stress testing for the limited-size static backend
+cfg_if! {
+    if #[cfg(not(feature = "static_array_backend"))] {
+        run_quickchecks!(quickchecks_2);
+        run_quickchecks!(quickchecks_3);
+        run_quickchecks!(quickchecks_4);
+        run_quickchecks!(quickchecks_5);
+        run_quickchecks!(quickchecks_6);
+        run_quickchecks!(quickchecks_7);
+    }
+}
 
 #[test]
 fn multi_threaded_quickchecks() {
@@ -389,7 +396,10 @@ test_trace!(test_trace_dogfood, "../traces/dogfood.trace");
 test_trace!(test_trace_ffmpeg, "../traces/ffmpeg.trace");
 test_trace!(test_trace_find, "../traces/find.trace");
 test_trace!(test_trace_gcc_hello, "../traces/gcc-hello.trace");
-test_trace!(test_trace_grep_random_data, "../traces/grep-random-data.trace");
+test_trace!(
+    test_trace_grep_random_data,
+    "../traces/grep-random-data.trace"
+);
 test_trace!(test_trace_grep_recursive, "../traces/grep-recursive.trace");
 test_trace!(test_trace_ls, "../traces/ls.trace");
 test_trace!(test_trace_source_map, "../traces/source-map.trace");
@@ -408,13 +418,7 @@ fn regression_test_1() {
 
 #[test]
 fn regression_test_2() {
-    Operations(vec![
-        Alloc(168),
-        Free(0),
-        Alloc(0),
-        Alloc(168),
-        Free(2),
-    ]).run_single_threaded();
+    Operations(vec![Alloc(168), Free(0), Alloc(0), Alloc(168), Free(2)]).run_single_threaded();
 }
 
 #[test]
@@ -472,15 +476,17 @@ fn smoke() {
     let mut a = &wee_alloc::WeeAlloc::INIT;
     unsafe {
         let layout = Layout::new::<u8>();
-        let ptr = a.alloc(layout.clone()).unwrap();
+        let ptr = a.alloc(layout.clone())
+            .expect("Should be able to alloc a fresh Layout clone");
         {
             let ptr = ptr.as_ptr() as *mut u8;
             *ptr = 9;
             assert_eq!(*ptr, 9);
         }
         a.dealloc(ptr, layout.clone());
 
-        let ptr = a.alloc(layout.clone()).unwrap();
+        let ptr = a.alloc(layout.clone())
+            .expect("Should be able to alloc from a second clone");
         {
             let ptr = ptr.as_ptr() as *mut u8;
             *ptr = 10;
@@ -490,9 +496,10 @@ fn smoke() {
     }
 }
 
-// This takes too long with our extra assertion checks enabled.
+// This takes too long with our extra assertion checks enabled,
+// and the fixed-sized static array backend is too small.
 #[test]
-#[cfg(not(feature = "extra_assertions"))]
+#[cfg(not(any(feature = "extra_assertions", feature = "static_array_backend")))]
 fn stress() {
     use rand::Rng;
     use std::cmp;

wee_alloc/Cargo.toml

@@ -23,11 +23,18 @@ size_classes = []
 # This is for internal use only.
 use_std_for_test_debugging = []
 
+static_array_backend = []
+
 [dependencies]
 memory_units = "0.4.0"
 cfg-if = "0.1.2"
 unreachable = "1.0.0"
 
+[dependencies.spin]
+version = "0.4"
+default-features = false
+features = ["const_fn"]
+
 [target.'cfg(all(unix, not(target_arch = "wasm32")))'.dependencies.libc]
 default-features = false
 version = "0.2"

wee_alloc/src/imp_static_array.rs

@@ -0,0 +1,86 @@
+use const_init::ConstInit;
+use core::alloc::{AllocErr, Opaque};
+use core::cell::UnsafeCell;
+#[cfg(feature = "extra_assertions")]
+use core::cell::Cell;
+use core::ptr::NonNull;
+use memory_units::{Bytes, Pages};
+use spin::Mutex;
+
+const SCRATCH_LEN_BYTES: usize = 1024 * 1024 * 32;
+static mut SCRATCH_HEAP: [u8; SCRATCH_LEN_BYTES] = [0; SCRATCH_LEN_BYTES];
+static mut OFFSET: Mutex<usize> = Mutex::new(0);
+
+pub(crate) unsafe fn alloc_pages(pages: Pages) -> Result<NonNull<Opaque>, AllocErr> {
+    let bytes: Bytes = pages.into();
+    let mut offset = OFFSET.lock();
+    let end = bytes.0 + *offset;
+    if end < SCRATCH_LEN_BYTES {
+        let ptr = SCRATCH_HEAP[*offset..end].as_mut_ptr() as *mut u8 as *mut Opaque;
+        *offset = end;
+        NonNull::new(ptr).ok_or_else(|| AllocErr)
+    } else {
+        Err(AllocErr)
+    }
+}
+
+pub(crate) struct Exclusive<T> {
+    lock: Mutex<bool>,
+    inner: UnsafeCell<T>,
+
+    #[cfg(feature = "extra_assertions")]
+    in_use: Cell<bool>,
+}
+
+impl<T: ConstInit> ConstInit for Exclusive<T> {
+    const INIT: Self = Exclusive {
+        lock: Mutex::new(false),
+        inner: UnsafeCell::new(T::INIT),
+
+        #[cfg(feature = "extra_assertions")]
+        in_use: Cell::new(false),
+    };
+}
+
+extra_only! {
+    fn assert_not_in_use<T>(excl: &Exclusive<T>) {
+        assert!(!excl.in_use.get(), "`Exclusive<T>` is not re-entrant");
+    }
+}
+
+extra_only! {
+    fn set_in_use<T>(excl: &Exclusive<T>) {
+        excl.in_use.set(true);
+    }
+}
+
+extra_only! {
+    fn set_not_in_use<T>(excl: &Exclusive<T>) {
+        excl.in_use.set(false);
+    }
+}
+
+impl<T> Exclusive<T> {
+    /// Get exclusive, mutable access to the inner value.
+    ///
+    /// # Safety
+    ///
+    /// It is the callers' responsibility to ensure that `f` does not re-enter
+    /// this method for this `Exclusive` instance.
+    //
+    // XXX: If we don't mark this function inline, then it won't be, and the
+    // code size also blows up by about 200 bytes.
+    #[inline]
+    pub(crate) unsafe fn with_exclusive_access<'a, F, U>(&'a self, f: F) -> U
+    where
+        F: FnOnce(&'a mut T) -> U,
+    {
+        let _l = self.lock.lock();
+        assert_not_in_use(self);
+        set_in_use(self);
+        let data = &mut *self.inner.get();
+        let result = f(data);
+        set_not_in_use(self);
+        result
+    }
+}

wee_alloc/src/lib.rs

@@ -224,6 +224,8 @@ extern crate alloc;
 
 #[cfg(feature = "use_std_for_test_debugging")]
 extern crate core;
+#[cfg(feature = "static_array_backend")]
+extern crate spin;
 
 extern crate memory_units;
 extern crate unreachable;
@@ -232,7 +234,10 @@ extern crate unreachable;
 mod extra_assert;
 
 cfg_if! {
-    if #[cfg(target_arch = "wasm32")] {
+    if #[cfg(feature = "static_array_backend")]{
+        mod imp_static_array;
+        use imp_static_array as imp;
+    } else if #[cfg(target_arch = "wasm32")] {
         mod imp_wasm32;
         use imp_wasm32 as imp;
     } else if #[cfg(unix)] {
@@ -946,7 +951,9 @@ unsafe fn alloc_first_fit<'a>(
 
         if let Some(allocated) = current.try_alloc(previous, size, align, policy) {
             assert_aligned_to(allocated.data(), align);
-            return Some(unchecked_unwrap(NonNull::new(allocated.data() as *mut Opaque)));
+            return Some(unchecked_unwrap(
+                NonNull::new(allocated.data() as *mut Opaque),
+            ));
         }
 
         None
@@ -1055,7 +1062,7 @@ impl<'a> WeeAlloc<'a> {
 
 unsafe impl<'a, 'b> Alloc for &'b WeeAlloc<'a>
 where
-    'a: 'b
+    'a: 'b,
 {
     unsafe fn alloc(&mut self, layout: Layout) -> Result<NonNull<Opaque>, AllocErr> {
         let size = Bytes(layout.size());

wee_alloc/src/neighbors.rs

@@ -185,16 +185,12 @@ where
 
     #[inline]
     pub fn next(&self) -> Option<&'a T> {
-        unsafe {
-            T::next_checked(self, self.next_unchecked())
-        }
+        unsafe { T::next_checked(self, self.next_unchecked()) }
     }
 
     #[inline]
     pub fn prev(&self) -> Option<&'a T> {
-        unsafe {
-            T::prev_checked(self, self.prev_unchecked())
-        }
+        unsafe { T::prev_checked(self, self.prev_unchecked()) }
     }
 }
 

wee_alloc/src/size_classes.rs

@@ -1,6 +1,6 @@
 use super::{alloc_with_refill, AllocPolicy, CellHeader, FreeCell, LargeAllocPolicy};
-use core::alloc::AllocErr;
 use const_init::ConstInit;
+use core::alloc::AllocErr;
 use core::cell::Cell;
 use core::cmp;
 use imp;
@@ -75,7 +75,10 @@ where
             self as &AllocPolicy,
         );
         let next_cell = (new_cell.as_ptr() as *const u8).offset(new_cell_size.0 as isize);
-        (*free_cell).header.neighbors.set_next(next_cell as *const CellHeader);
+        (*free_cell)
+            .header
+            .neighbors
+            .set_next(next_cell as *const CellHeader);
         CellHeader::set_next_cell_is_invalid(&(*free_cell).header.neighbors);
         Ok(free_cell)
     }