Refactor HeapAlloc to be called HeapPrealloc and be defined in code if stdlib feature is active rather than as a macro. Bumped verison to 1.1

Author: danielrh

Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "alloc-no-stdlib"
 description = "A dynamic allocator that may be used with or without the stdlib. This allows a package with nostd to allocate memory dynamically and be used either with a custom allocator, items on the stack, or by a package that wishes to simply use Box<>. It also provides options to use calloc or a mutable global variable for pre-zeroed memory"
-version = "1.0.0"
+version = "1.1.0"
 authors = ["Daniel Reiter Horn <[email protected]>"]
 documentation = "https://raw.githubusercontent.com/dropbox/rust-alloc-no-stdlib/master/tests/lib.rs"
 homepage = "https://github.com/dropbox/rust-alloc-no-stdlib"

src/bin/example.rs

@@ -6,7 +6,8 @@ use core::ops;
 mod heap_alloc;
 
 pub use heap_alloc::HeapAllocator;
-
+#[cfg(feature="stdlib")]
+use alloc_no_stdlib::HeapPrealloc;
 mod tests;
 extern {
   fn calloc(n_elem : usize, el_size : usize) -> *mut u8;
@@ -26,7 +27,36 @@ use alloc_no_stdlib::StackAllocator;
 use alloc_no_stdlib::bzero;
 declare_stack_allocator_struct!(CallocAllocatedFreelist4, 4, calloc);
 declare_stack_allocator_struct!(StackAllocatedFreelist16, 16, stack);
-declare_stack_allocator_struct!(BoxAllocatedFreelist, heap);
+#[cfg(not(feature="stdlib"))]
+fn show_heap_prealloc() {
+
+}
+#[cfg(feature="stdlib")]
+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)};
@@ -56,29 +86,7 @@ fn main() {
   }
   }
   }
-  let mut zero_global_buffer = define_allocator_memory_pool!(4, u8, [0; 1024 * 1024 * 20], heap);
-
-  let mut boxallocator = BoxAllocatedFreelist::<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);
-  }
 
   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);
@@ -102,8 +110,6 @@ fn main() {
     let mut _z = stackallocator.alloc_cell(1);
   }
 
-
-
   let mut halloc : HeapAllocator<u8> = HeapAllocator::<u8>{default_value: 0};
   for _i in 1..10 { // heap test
       let mut x = halloc.alloc_cell(100000);
@@ -116,4 +122,5 @@ fn main() {
       println!("x[0] {:?} x[9] {:?} y[0] {:?} z[0] {:?}",
                x[0], x[9], -999, z[0]);
   }
+  show_heap_prealloc();
 }

src/bin/tests.rs

@@ -4,9 +4,9 @@ extern crate core;
 use alloc_no_stdlib::Allocator;
 use super::HeapAllocator;
 #[cfg(feature="stdlib")]
-use alloc_no_stdlib::StdAlloc;
+use alloc_no_stdlib::HeapAlloc;
 #[cfg(all(feature="unsafe", feature="stdlib"))]
-use alloc_no_stdlib::StdAllocUninitialized;
+use alloc_no_stdlib::HeapAllocUninitialized;
 #[test]
 fn heap_test() {
   let mut halloc : HeapAllocator<u8> = HeapAllocator::<u8>{default_value: 0};
@@ -30,7 +30,7 @@ fn heap_test() {
 #[cfg(all(feature="unsafe", feature="stdlib"))]
 #[test]
 fn std_unsafe_heap_test() {
-  let mut halloc = unsafe{StdAllocUninitialized::<u8>::new()};
+  let mut halloc = unsafe{HeapAllocUninitialized::<u8>::new()};
   for _i in 1..10 { // heap test
       let mut x = halloc.alloc_cell(100000);
       x[0] = 4;
@@ -50,7 +50,7 @@ fn std_unsafe_heap_test() {
 #[cfg(feature="stdlib")]
 #[test]
 fn std_heap_test() {
-  let mut halloc = unsafe{StdAllocUninitialized::<u8>::new()};
+  let mut halloc = unsafe{HeapAllocUninitialized::<u8>::new()};
   for _i in 1..10 { // heap test
       let mut x = halloc.alloc_cell(100000);
       x[0] = 4;

src/heap_alloc.rs

@@ -1,7 +1,13 @@
 #![cfg(feature="stdlib")]
 use std;
+
+
+use super::{SliceWrapper, SliceWrapperMut, Allocator};
+
 use core;
 use core::ops;
+use std::boxed::Box;
+use std::vec::Vec;
 pub struct WrapBox<T> {
    b : std::boxed::Box<[T]>,
 }
@@ -39,37 +45,38 @@ impl<T> super::SliceWrapperMut<T> for WrapBox<T> {
     }
 }
 
-pub struct StdAlloc<T : core::clone::Clone>{
+pub struct HeapAlloc<T : core::clone::Clone>{
    pub default_value : T,
 }
 
-impl<T : core::clone::Clone> super::Allocator<T> for StdAlloc<T> {
+impl<T : core::clone::Clone> super::Allocator<T> for HeapAlloc<T> {
    type AllocatedMemory = WrapBox<T>;
-   fn alloc_cell(self : &mut StdAlloc<T>, len : usize) -> WrapBox<T> {
+   fn alloc_cell(self : &mut HeapAlloc<T>, len : usize) -> WrapBox<T> {
 
        let v : std::vec::Vec<T> = vec![self.default_value.clone();len];
        let b = v.into_boxed_slice();
        return WrapBox::<T>{b : b};
    }
-   fn free_cell(self : &mut StdAlloc<T>, _data : WrapBox<T>) {
+   fn free_cell(self : &mut HeapAlloc<T>, _data : WrapBox<T>) {
 
    }
 }
 
 #[cfg(feature="unsafe")]
-pub struct StdAllocUninitialized<T : core::clone::Clone>{
+pub struct HeapAllocUninitialized<T>{
    #[allow(dead_code)]
    default_value : Option<T>,
 }
 
 #[cfg(feature="unsafe")]
-impl<T : core::clone::Clone> StdAllocUninitialized<T>{
-   pub unsafe fn new() -> StdAllocUninitialized<T> {
-       return StdAllocUninitialized::<T>{default_value:None};
+impl<T> HeapAllocUninitialized<T>{
+   pub unsafe fn new() -> HeapAllocUninitialized<T> {
+       return HeapAllocUninitialized::<T>{default_value:None};
    }
 }
+
 #[cfg(feature="unsafe")]
-impl<T : core::clone::Clone> super::Allocator<T> for StdAllocUninitialized<T> {
+impl<T> super::Allocator<T> for HeapAllocUninitialized<T> {
    type AllocatedMemory = WrapBox<T>;
    fn alloc_cell(self : &mut Self, len : usize) -> WrapBox<T> {
 
@@ -82,3 +89,41 @@ impl<T : core::clone::Clone> super::Allocator<T> for StdAllocUninitialized<T> {
 
    }
 }
+
+
+pub struct HeapPrealloc<'a, T : 'a> {
+   freelist : std::boxed::Box<[&'a mut [T]]>,
+}
+define_stack_allocator_traits!(HeapPrealloc, heap);
+
+impl<'a, T : core::clone::Clone+'a> HeapPrealloc<'a, T> {
+    fn make_freelist(freelist_size : usize) -> std::boxed::Box<[&'a mut[T]]> {
+        let mut retval = Vec::<&'a mut[T]>::with_capacity(freelist_size);
+        for _i in 0..freelist_size {
+            retval.push(&mut[]);
+        }
+        return retval.into_boxed_slice();
+    }
+    pub fn new_allocator(freelist_size : usize,
+                     memory_pool : &'a mut Box<[T]>,
+                     initializer : fn(&mut[T])) -> super::StackAllocator<'a, T, HeapPrealloc<'a, T> > {
+        let mut retval = super::StackAllocator::<T, HeapPrealloc<T> > {
+            nop : &mut [],
+            system_resources : HeapPrealloc::<T> {
+                freelist : Self::make_freelist(freelist_size),
+            },
+            free_list_start : freelist_size,
+            free_list_overflow_count : 0,
+            initialize : initializer,
+        };
+        retval.free_cell(super::AllocatedStackMemory::<T>{mem:&mut*memory_pool});
+        return retval;
+    }
+    #[cfg(feature="unsafe")]
+    pub unsafe fn new_uninitialized_memory_pool(len : usize) -> Box<[T]> {
+        let mut v : std::vec::Vec<T> = std::vec::Vec::with_capacity(len);
+        v.set_len(len);
+        return v.into_boxed_slice();
+    }
+}
+

src/init.rs

@@ -151,34 +151,6 @@ macro_rules! declare_stack_allocator_struct(
                                        calloc);
         declare_stack_allocator_struct!( @new_calloc_method $name, $freelist_size);
     };
-    ($name :ident, heap) => {
-        struct $name<'a, T : 'a> {freelist : Box<[&'a mut [T]]>,}
-        define_stack_allocator_traits!($name, heap);
-        impl<'a, T: 'a> $name<'a, T> {
-          fn make_freelist(freelist_size : usize) -> Box<[&'a mut[T]]> {
-              let mut retval = Vec::<&'a mut[T]>::with_capacity(freelist_size);
-              for _i in 0..freelist_size {
-                  retval.push(&mut[]);
-              }
-              return retval.into_boxed_slice();
-          }
-          fn new_allocator(freelist_size : usize,
-                           memory_pool : &'a mut Box<[T]>,
-                           initializer : fn(&mut[T])) -> StackAllocator<'a, T, $name<'a, T> > {
-              let mut retval = StackAllocator::<T, $name<T> > {
-                  nop : &mut [],
-                  system_resources : $name::<T> {
-                      freelist : Self::make_freelist(freelist_size),
-                  },
-                  free_list_start : freelist_size,
-                  free_list_overflow_count : 0,
-                  initialize : initializer,
-              };
-              retval.free_cell(AllocatedStackMemory::<T>{mem:&mut*memory_pool});
-              return retval;
-          }
-        }
-    };
     ($name :ident, $freelist_size : tt, stack) => {
         struct $name<'a, T : 'a> {
             freelist : [&'a mut [T];declare_stack_allocator_struct!(@as_expr $freelist_size)],
@@ -249,21 +221,3 @@ macro_rules! define_allocator_memory_pool(
 );
 
 
-/*
-#[macro_export]
-macro_rules! initialize_allocator(
-    (@as_expr $expr:expr) => {$expr};
-
-
-    ($name : ident, $freelist_size : tt, $T : ty, calloc) => {
-        StackAllocator::<$T, $name<$T> > {
-            nop : &mut [],
-            system_resources : $name::<$T> {
-                freelist : static_array!(&mut[]; $freelist_size),
-            },
-            free_list_start : $freelist_size,
-            free_list_overflow_count : 0,
-        }
-    };
-);
-*/

src/lib.rs

@@ -3,10 +3,10 @@
 #[cfg(feature="stdlib")]
 #[macro_use]
 extern crate std;
-mod heap_alloc;
 mod allocated_memory;
 mod stack_allocator;
 mod allocated_stack_memory;
+#[macro_use]
 pub mod init;
 pub use allocated_memory::SliceWrapper;
 pub use allocated_memory::SliceWrapperMut;
@@ -15,10 +15,15 @@ pub use allocated_memory::AllocatedSlice;
 pub use allocated_stack_memory::AllocatedStackMemory;
 pub use stack_allocator::Allocator;
 pub use stack_allocator::StackAllocator;
+mod heap_alloc;
+#[cfg(feature="stdlib")]
+pub use heap_alloc::HeapAlloc;
 #[cfg(feature="stdlib")]
-pub use heap_alloc::StdAlloc;
+pub use heap_alloc::HeapPrealloc;
 #[cfg(all(feature="stdlib", feature="unsafe"))]
-pub use heap_alloc::StdAllocUninitialized;
+pub use heap_alloc::HeapAllocUninitialized;
+//#[cfg(all(feature="stdlib", feature="unsafe"))]
+//pub use heap_alloc::StdAllocUninitialized;
 use core::default::Default;
 pub fn bzero<T : Default> (data : &mut [T]) {
     for iter in data.iter_mut() {

tests/lib.rs

@@ -12,7 +12,12 @@ use core::ops;
 use alloc_no_stdlib::{Allocator, SliceWrapperMut, SliceWrapper,
             StackAllocator, AllocatedStackMemory, uninitialized, bzero};
 
-declare_stack_allocator_struct!(HeapAllocatedFreelist, heap);
+#[cfg(feature="stdlib")]
+use alloc_no_stdlib::{HeapPrealloc, HeapAlloc};
+
+#[cfg(all(feature="stdlib", feature="unsafe"))]
+use alloc_no_stdlib::{HeapAllocUninitialized};
+
 declare_stack_allocator_struct!(CallocAllocatedFreelist4096, 4096, calloc);
 declare_stack_allocator_struct!(MallocAllocatedFreelist4096, 4096, malloc);
 declare_stack_allocator_struct!(StackAllocatedFreelist4, 4, stack);
@@ -131,10 +136,11 @@ fn uninitialized_stack_pool_free_null() {
 
 }
 #[test]
+#[cfg(all(feature="stdlib",feature="unsafe"))]
 fn uninitialized_heap_pool_test() {
   {
-  let mut heap_global_buffer = define_allocator_memory_pool!(4096, u8, [0; 6 * 1024 * 1024], heap);
-  let mut ags = HeapAllocatedFreelist::<u8>::new_allocator(4096, &mut heap_global_buffer, uninitialized);
+  let mut heap_global_buffer = unsafe{HeapPrealloc::<u8>::new_uninitialized_memory_pool(6 * 1024 * 1024)};
+  let mut ags = HeapPrealloc::<u8>::new_allocator(4096, &mut heap_global_buffer, uninitialized);
   {
     let mut x = ags.alloc_cell(9999);
     x.slice_mut()[0] = 4;
@@ -329,10 +335,11 @@ fn stack_pool_free_null() {
 
 }
 #[test]
+#[cfg(feature="stdlib")]
 fn heap_pool_test() {
   {
   let mut heap_global_buffer = define_allocator_memory_pool!(4096, u8, [0; 6 * 1024 * 1024], heap);
-  let mut ags = HeapAllocatedFreelist::<u8>::new_allocator(4096, &mut heap_global_buffer, bzero);
+  let mut ags = HeapPrealloc::<u8>::new_allocator(4096, &mut heap_global_buffer, bzero);
   {
     let mut x = ags.alloc_cell(9999);
     x.slice_mut()[0] = 4;