Merge pull request #38 from ZackPierce/static_array_backed

Fixed-sized backend for use with atypical targets

Author: fitzgen

CONTRIBUTING.md

@@ -141,9 +141,9 @@ Where we need help:
 
 ## Team
 
-| [<img alt="fitzgen" src="https://avatars2.githubusercontent.com/u/74571?s=117&v=4" width="117">](https://github.com/fitzgen) | [<img alt="pepyakin" src="https://avatars0.githubusercontent.com/u/2205845?s=117&v=4" width="117">](https://github.com/pepyakin) | [<img alt="DrGoldfire" src="https://avatars3.githubusercontent.com/u/1772277?s=117&v=4" width="117">](https://github.com/DrGoldfire) |
-|:---:|:---:|:---:|
-| [`fitzgen`](https://github.com/fitzgen) | [`pepyakin`](https://github.com/pepyakin) | [`DrGoldfire`](https://github.com/DrGoldfire) |
+| [<img alt="fitzgen" src="https://avatars2.githubusercontent.com/u/74571?s=117&v=4" width="117">](https://github.com/fitzgen) | [<img alt="pepyakin" src="https://avatars0.githubusercontent.com/u/2205845?s=117&v=4" width="117">](https://github.com/pepyakin) | [<img alt="DrGoldfire" src="https://avatars3.githubusercontent.com/u/1772277?s=117&v=4" width="117">](https://github.com/DrGoldfire) | [<img alt="ZackPierce" src="https://avatars0.githubusercontent.com/u/387703?s=400&v=4" width="117">](https://github.com/ZackPierce) |
+|:---:|:---:|:---:|:---:|
+| [`fitzgen`](https://github.com/fitzgen) | [`pepyakin`](https://github.com/pepyakin) | [`DrGoldfire`](https://github.com/DrGoldfire) | [`ZackPierce`](https://github.com/ZackPierce)
 
 Larger, more nuanced decisions about design, architecture, breaking changes,
 trade offs, etc are made by team consensus. In other words, decisions on things

README.md

@@ -110,6 +110,11 @@ static ALLOC: wee_alloc::WeeAlloc = wee_alloc::WeeAlloc::INIT;
   runtime overhead. It is useful when debugging a use-after-free or `wee_alloc`
   itself.
 
+- **static_array_backend**: Force the use of an OS-independent fixed-size (16 MB)
+  backing implementation. Suitable for deploying to non-WASM/Unix/Windows
+  `#![no_std]` environments, such as on embedded devices with esoteric or effectively
+  absent operating systems.
+
 ### Implementation Notes and Constraints
 
 - `wee_alloc` imposes two words of overhead on each allocation for maintaining

example/src/lib.rs

@@ -25,6 +25,15 @@ extern "C" fn panic_fmt(_args: ::core::fmt::Arguments, _file: &'static str, _lin
     }
 }
 
+// Need to provide a tiny `oom` lang-item implementation for
+// `#![no_std]`.
+#[lang = "oom"]
+extern "C" fn oom() -> ! {
+    unsafe {
+        ::core::intrinsics::abort();
+    }
+}
+
 // Now, use the allocator via `alloc` types! ///////////////////////////////////
 
 use alloc::boxed::Box;

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

@@ -1,6 +1,11 @@
 [package]
-authors = ["Nick Fitzgerald <fitzgen@gmail.com>"]
-categories = ["memory-management", "web-programming", "no-std", "wasm"]
+authors = [
+  "Nick Fitzgerald <fitzgen@gmail.com>",
+  "Sergey Pepyakin <s.pepyakin@gmail.com>",
+  "Matt Howell <mjhowell@gmail.com>",
+  "Zack Pierce <zachary.pierce@gmail.com>",
+]
+categories = ["memory-management", "web-programming", "no-std", "wasm", "embedded"]
 description = "wee_alloc: The Wasm-Enabled, Elfin Allocator"
 license = "MPL-2.0"
 name = "wee_alloc"
@@ -20,6 +25,9 @@ extra_assertions = []
 # Enable size classes for amortized *O(1)* small allocations.
 size_classes = []
 
+# Enable fixed-sized, OS-independent backing memory implementation
+static_array_backend = []
+
 # This is for internal use only.
 use_std_for_test_debugging = []
 
@@ -28,6 +36,11 @@ 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,82 @@
+use const_init::ConstInit;
+use core::alloc::{AllocErr, Opaque};
+#[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> {
+    inner: Mutex<T>,
+
+    #[cfg(feature = "extra_assertions")]
+    in_use: Cell<bool>,
+}
+
+impl<T: ConstInit> ConstInit for Exclusive<T> {
+    const INIT: Self = Exclusive {
+        inner: Mutex::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
+        for<'x> F: FnOnce(&'x mut T) -> U,
+    {
+        let mut guard = self.inner.lock();
+        assert_not_in_use(self);
+        set_in_use(self);
+        let result = f(&mut guard);
+        set_not_in_use(self);
+        result
+    }
+}

wee_alloc/src/imp_unix.rs

@@ -50,7 +50,7 @@ impl<T> Exclusive<T> {
     #[inline]
     pub(crate) unsafe fn with_exclusive_access<'a, F, U>(&'a self, f: F) -> U
     where
-        F: FnOnce(&'a mut T) -> U,
+        for<'x> F: FnOnce(&'x mut T) -> U,
     {
         let code = libc::pthread_mutex_lock(&mut *self.lock.get());
         extra_assert_eq!(code, 0, "pthread_mutex_lock should run OK");