revamp to include stdalloc

Author: danielrh

Cargo.toml

@@ -16,4 +16,3 @@ name = "example"
 
 [features]
 unsafe = []
-no-stdlib = []

alloc-stdlib/Cargo.toml

@@ -0,0 +1,21 @@
+[package]
+name = "alloc-stdlib"
+description = "A dynamic allocator example that may be used with the stdlib"
+version = "0.1.0"
+authors = ["Daniel Reiter Horn <[email protected]>"]
+documentation = "https://raw.githubusercontent.com/dropbox/rust-alloc-no-stdlib/master/alloc-stdlib/tests/lib.rs"
+homepage = "https://github.com/dropbox/rust-alloc-no-stdlib"
+readme = "README.md"
+keywords = ["custom", "allocator", "calloc", "safe", "nostd"]
+license = "BSD-3-Clause"
+repository = "https://github.com/dropbox/rust-alloc-no-stdlib"
+autobins = false
+
+[[bin]]
+name = "example"
+
+[dependencies]
+"alloc-no-stdlib" = "~1"
+
+[features]
+unsafe = []

alloc-stdlib/src/bin/example.rs

@@ -0,0 +1,122 @@
+//#![feature(trace_macros)]
+extern crate alloc_stdlib;
+#[macro_use]
+extern crate alloc_no_stdlib;
+
+extern crate core;
+use core::ops;
+
+pub use alloc_stdlib::{HeapAlloc, StandardAlloc};
+use alloc_stdlib::HeapPrealloc;
+mod tests;
+extern {
+  fn calloc(n_elem : usize, el_size : usize) -> *mut u8;
+}
+extern {
+  fn free(ptr : *mut u8);
+}
+
+
+//use alloc::AllocatedSlice;
+use alloc_no_stdlib::SliceWrapper;
+use alloc_no_stdlib::SliceWrapperMut;
+use alloc_no_stdlib::AllocatedStackMemory;
+use alloc_no_stdlib::Allocator;
+use alloc_no_stdlib::StackAllocator;
+
+use alloc_no_stdlib::bzero;
+declare_stack_allocator_struct!(CallocAllocatedFreelist4, 4, calloc);
+declare_stack_allocator_struct!(StackAllocatedFreelist16, 16, stack);
+
+fn show_heap_prealloc() {
+  let mut zero_global_buffer = define_allocator_memory_pool!(4, u8, [0; 1024 * 1024 * 20], heap);
+
+  let mut boxallocator = HeapPrealloc::<u8>::new_allocator(1024 * 1024, &mut zero_global_buffer, bzero);
+
+  {
+    let mut x = boxallocator.alloc_cell(9999);
+    x.slice_mut()[0] = 3;
+    let mut y = boxallocator.alloc_cell(4);
+    y[0] = 5;
+    boxallocator.free_cell(y);
+
+    let mut three = boxallocator.alloc_cell(3);
+    three[0] = 6;
+    boxallocator.free_cell(three);
+
+    let mut z = boxallocator.alloc_cell(4);
+    z.slice_mut()[1] = 8;
+    let mut reget_three = boxallocator.alloc_cell(4);
+    reget_three.slice_mut()[1] = 9;
+    //y.mem[0] = 6; // <-- this is an error (use after free)
+    println!("x[0] = {:?} z[0] = {:?}  z[1] = {:?} r3[0] = {:?} r3[1] = {:?}", x.mem[0], z.mem[0], z.mem[1], reget_three[0], reget_three.slice()[1]);
+    let mut _z = boxallocator.alloc_cell(1);
+  }
+}
+
+fn main() {
+  let mut global_buffer = unsafe {define_allocator_memory_pool!(4, u8, [0; 1024 * 1024 * 200], calloc)};
+  {
+  let gbref = &mut global_buffer;
+{
+  let mut ags = CallocAllocatedFreelist4::<u8>::new_allocator(gbref.data, bzero);
+
+  {
+  let mut x = ags.alloc_cell(9999);
+  x.slice_mut()[0] = 4;
+  let mut y = ags.alloc_cell(4);
+  y[0] = 5;
+  ags.free_cell(y);
+
+  let mut three = ags.alloc_cell(3);
+  three[0] = 6;
+  ags.free_cell(three);
+
+  let mut z = ags.alloc_cell(4);
+  z.slice_mut()[1] = 8;
+  let mut reget_three = ags.alloc_cell(4);
+  reget_three.slice_mut()[1] = 9;
+  //y.mem[0] = 6; // <-- this is an error (use after free)
+  println!("x[0] = {:?} z[0] = {:?}  z[1] = {:?} r3[0] = {:?} r3[1] = {:?}", x.mem[0], z.mem[0], z.mem[1], reget_three[0], reget_three.slice()[1]);
+  let mut _z = ags.alloc_cell(1);
+  }
+  }
+  }
+
+
+  let mut stack_global_buffer = define_allocator_memory_pool!(16, u8, [0; 1024 * 1024], stack);
+  let mut stackallocator = StackAllocatedFreelist16::<u8>::new_allocator(&mut stack_global_buffer, bzero);
+  {
+    let mut x = stackallocator.alloc_cell(9999);
+    x.slice_mut()[0] = 3;
+    let mut y = stackallocator.alloc_cell(4);
+    y[0] = 5;
+    stackallocator.free_cell(y);
+
+    let mut three = stackallocator.alloc_cell(3);
+    three[0] = 6;
+    stackallocator.free_cell(three);
+
+    let mut z = stackallocator.alloc_cell(4);
+    z.slice_mut()[1] = 8;
+    let mut reget_three = stackallocator.alloc_cell(4);
+    reget_three.slice_mut()[1] = 9;
+    //y.mem[0] = 6; // <-- this is an error (use after free)
+    println!("x[0] = {:?} z[0] = {:?}  z[1] = {:?} r3[0] = {:?} r3[1] = {:?}", x.mem[0], z.mem[0], z.mem[1], reget_three[0], reget_three.slice()[1]);
+    let mut _z = stackallocator.alloc_cell(1);
+  }
+
+  let mut halloc = HeapAlloc::<u8>::default();
+  for _i in 1..10 { // heap test
+      let mut x = halloc.alloc_cell(100000);
+      x.slice_mut()[0] = 4;
+      let mut y = halloc.alloc_cell(110000);
+      y.slice_mut()[0] = 5;
+      let mut z = halloc.alloc_cell(120000);
+      z.slice_mut()[0] = 6;
+      halloc.free_cell(y);
+      println!("x[0] {:?} x[9] {:?} y[0] {:?} z[0] {:?}",
+               x.slice()[0], x.slice()[9], -999, z.slice()[0]);
+  }
+  show_heap_prealloc();
+}

alloc-stdlib/src/bin/tests.rs

@@ -0,0 +1,85 @@
+#![allow(unused_imports)]
+#[cfg(test)]
+extern crate core;
+use alloc_no_stdlib::{Allocator, SliceWrapper, SliceWrapperMut};
+use super::{HeapAlloc, StandardAlloc};
+#[cfg(feature="unsafe")]
+use alloc_stdlib::HeapAllocUninitialized;
+#[test]
+fn heap_test() {
+  let mut halloc : HeapAlloc<u8> = HeapAlloc::<u8>{default_value: 0};
+  for _i in 1..10 { // heap test
+      let mut x = halloc.alloc_cell(100000);
+      x.slice_mut()[0] = 4;
+      let mut y = halloc.alloc_cell(110000);
+      y.slice_mut()[0] = 5;
+      let mut z = halloc.alloc_cell(120000);
+      z.slice_mut()[0] = 6;
+      assert_eq!(y.slice()[0], 5);
+      halloc.free_cell(y);
+      assert_eq!(x.slice()[0], 4);
+      assert_eq!(x.slice()[9], 0);
+      assert_eq!(z.slice()[0], 6);
+  }
+
+}
+
+#[test]
+fn std_test() {
+  let mut halloc = StandardAlloc::default();
+  for _i in 1..10 { // heap test
+      let mut x = <StandardAlloc as Allocator<u8>>::alloc_cell(&mut halloc, 100000);
+      x.slice_mut()[0] = 4;
+      let mut y = <StandardAlloc as Allocator<u8>>::alloc_cell(&mut halloc, 110000);
+      y.slice_mut()[0] = 5;
+      let mut z = <StandardAlloc as Allocator<u8>>::alloc_cell(&mut halloc, 120000);
+      z.slice_mut()[0] = 6;
+      assert_eq!(y.slice()[0], 5);
+      halloc.free_cell(y);
+      assert_eq!(x.slice()[0], 4);
+      assert_eq!(x.slice()[9], 0);
+      assert_eq!(z.slice()[0], 6);
+  }
+
+}
+
+
+#[cfg(feature="unsafe")]
+#[test]
+fn std_unsafe_heap_test() {
+  let mut halloc = unsafe{HeapAllocUninitialized::<u8>::new()};
+  for _i in 1..10 { // heap test
+      let mut x = halloc.alloc_cell(100000);
+      x.slice_mut()[0] = 4;
+      let mut y = halloc.alloc_cell(110000);
+      y.slice_mut()[0] = 5;
+      let mut z = halloc.alloc_cell(120000);
+      z.slice_mut()[0] = 6;
+      assert_eq!(y.slice()[0], 5);
+      halloc.free_cell(y);
+      assert_eq!(x.slice()[0], 4);
+      assert_eq!(x.slice()[9], 0);
+      assert_eq!(z.slice()[0], 6);
+  }
+
+}
+
+#[cfg(feature="stdlib")]
+#[test]
+fn std_heap_test() {
+  let mut halloc = HeapAlloc::<u8>::new(0);
+  for _i in 1..10 { // heap test
+      let mut x = halloc.alloc_cell(100000);
+      x.slice_mut()[0] = 4;
+      let mut y = halloc.alloc_cell(110000);
+      y.slice_mut()[0] = 5;
+      let mut z = halloc.alloc_cell(120000);
+      z.slice_mut()[0] = 6;
+      assert_eq!(y.slice()[0], 5);
+      halloc.free_cell(y);
+      assert_eq!(x.slice()[0], 4);
+      assert_eq!(x.slice()[9], 0);
+      assert_eq!(z.slice()[0], 6);
+  }
+
+}

src/heap_alloc.rs renamed to alloc-stdlib/src/heap_alloc.rs

@@ -4,39 +4,54 @@ use std;
 
 use super::{SliceWrapper, SliceWrapperMut, Allocator};
 
-use core;
-use core::ops;
+use std::ops;
 use std::boxed::Box;
 use std::vec::Vec;
-pub struct WrapBox<T> {
-   b : std::boxed::Box<[T]>,
+pub struct WrapBox<T>(std::boxed::Box<[T]>);
+
+impl<T> From<Vec<T>> for WrapBox<T> {
+    fn from(data: Vec<T>) -> Self {
+        WrapBox(data.into())
+    }
+}
+
+impl<T> Into<Box<[T]>> for WrapBox<T> {
+    fn into(self) -> Box<[T]> {
+        self.0
+    }
 }
 
-impl<T> core::default::Default for WrapBox<T> {
+impl<T> Default for WrapBox<T> {
     fn default() -> Self {
        let v : std::vec::Vec<T> = std::vec::Vec::new();
        let b = v.into_boxed_slice();
-       return WrapBox::<T>{b : b};
+       return WrapBox::<T>(b);
     }
 }
-define_index_ops_mut!(T, WrapBox<T>);
 
 impl<T> super::SliceWrapper<T> for WrapBox<T> {
     fn slice(&self) -> & [T] {
-       return &*self.b
+       return &*self.0
     }
 }
 
 impl<T> super::SliceWrapperMut<T> for WrapBox<T> {
     fn slice_mut(&mut self) -> &mut [T] {
-       return &mut*self.b
+       return &mut*self.0
     }
 }
 
 pub struct HeapAlloc<T : core::clone::Clone>{
    pub default_value : T,
 }
-impl<T : core::clone::Clone> HeapAlloc<T> {
+
+impl<T: Clone+Default> Default for HeapAlloc<T> {
+    fn default() -> Self {
+        Self::new(T::default())
+    }
+}
+
+impl<T : Clone> HeapAlloc<T> {
    pub fn new(data : T) -> HeapAlloc<T> {
       return HeapAlloc::<T>{default_value : data};
    }
@@ -48,7 +63,7 @@ impl<T : core::clone::Clone> super::Allocator<T> for HeapAlloc<T> {
 
        let v : std::vec::Vec<T> = vec![self.default_value.clone();len];
        let b = v.into_boxed_slice();
-       return WrapBox::<T>{b : b};
+       return WrapBox::<T>(b);
    }
    fn free_cell(self : &mut HeapAlloc<T>, _data : WrapBox<T>) {
 

alloc-stdlib/src/lib.rs

@@ -0,0 +1,10 @@
+#[macro_use]
+extern crate alloc_no_stdlib;
+pub mod heap_alloc;
+pub mod std_alloc;
+pub use self::heap_alloc::{HeapAlloc, HeapPrealloc};
+pub use self::std_alloc::{StandardAlloc};
+pub use alloc_no_stdlib::{Allocator, SliceWrapper, SliceWrapperMut};
+pub use alloc_no_stdlib::{StackAllocator, AllocatedStackMemory};
+#[cfg(feature="unsafe")]
+pub use heap_alloc::HeapAllocUninitialized;

alloc-stdlib/src/std_alloc.rs

@@ -0,0 +1,14 @@
+use super::heap_alloc::WrapBox;
+use super::{Allocator};
+#[derive(Default, Clone, Copy, Debug)]
+pub struct StandardAlloc{}
+
+impl<T: Clone+Default> Allocator<T> for StandardAlloc {
+   type AllocatedMemory = WrapBox<T>;
+   fn alloc_cell(&mut self, len : usize) -> WrapBox<T> {
+       vec![T::default().clone();len].into()
+   }
+   fn free_cell(&mut self, _data : WrapBox<T>) {
+
+   }
+}