allow borrows of calloc data

update the docs and tried two passes of calloc/malloc allocators where the data was not reallocated in between

Author: danielrh

README.md

@@ -39,7 +39,7 @@ declare_stack_allocator_struct!(StackAllocatedFreelist4, 4, stack);
 ...
 
   // in the code where the memory must be used, first the array needs to be readied
-  define_allocator_memory_pool!(stack_buffer, 4, u8, [0; 65536], stack);
+  let mut stack_buffer = define_allocator_memory_pool!(4, u8, [0; 65536], stack);
   // then an allocator needs to be made and pointed to the stack_buffer on the stack
   // the final argument tells the system if free'd data should be zero'd before being
   // reused by a subsequent call to alloc_cell
@@ -66,7 +66,7 @@ at this point
 ```
 declare_stack_allocator_struct!(HeapAllocatedFreelist, heap);
 ...
-  define_allocator_memory_pool!(heap_global_buffer, 4096, u8, [0; 6 * 1024 * 1024], heap);
+  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 x = ags.alloc_cell(9999);
@@ -86,13 +86,19 @@ In this version, the number of cells are fixed to the parameter specified in the
 (4096 in this example)
 
 ```
+extern {
+  fn calloc(n_elem : usize, el_size : usize) -> *mut u8;
+  fn malloc(len : usize) -> *mut u8;
+  fn free(item : *mut u8);
+}
+
 declare_stack_allocator_struct!(CallocAllocatedFreelist4096, 4096, calloc);
 ...
 
   // the buffer is defined with 200 megs of zero'd memory from calloc
-  define_allocator_memory_pool!(calloc_global_buffer, 4096, u8, [0; 200 * 1024 * 1024], calloc);
+  let mut calloc_global_buffer = unsafe {define_allocator_memory_pool!(4096, u8, [0; 200 * 1024 * 1024], calloc)};
   // and assigned to a new_allocator
-  let mut ags = CallocAllocatedFreelist4096::<u8>::new_allocator(calloc_global_buffer, bzero);
+  let mut ags = CallocAllocatedFreelist4096::<u8>::new_allocator(&mut calloc_global_buffer.data, bzero);
   {
     let mut x = ags.alloc_cell(9999);
     x.slice_mut()[0] = 4;
@@ -118,12 +124,14 @@ since multiple allocators may get access to global_buffer.
 
 ```
 declare_stack_allocator_struct!(GlobalAllocatedFreelist, 16, global);
-define_allocator_memory_pool!(global_buffer, 16, u8, [0; 1024 * 1024 * 100], global);
+define_allocator_memory_pool!(16, u8, [0; 1024 * 1024 * 100], global, global_buffer);
 
 ...
   // this references a global buffer
   let mut ags = GlobalAllocatedFreelist::<u8>::new_allocator(bzero);
-  bind_global_buffers_to_allocator!(ags, global_buffer, u8);
+  unsafe {
+      bind_global_buffers_to_allocator!(ags, global_buffer, u8);
+  }
   {
     let mut x = ags.alloc_cell(9999);
     x.slice_mut()[0] = 4;

src/bin/example.rs

@@ -29,21 +29,11 @@ declare_stack_allocator_struct!(StackAllocatedFreelist16, 16, stack);
 declare_stack_allocator_struct!(BoxAllocatedFreelist, heap);
 
 fn main() {
-  //let mut global_buffer : [u8; 1024 * 4096] = [0;4096*1024];
-  //let max_memory_pool_size : usize = 1024 * 1024 * 200;
-
-  //// let global_buffer_vec : Vec<u8> = vec![0; max_memory_pool_size];
-  //// //let global_buffer_vec = std::iter::repeat(0u8).take(max_memory_pool_size).collect::<Vec<u8>>();
-  //// let mut global_buffer_box = global_buffer_vec.into_boxed_slice();
-
-  //// let mut global_buffer = &mut *global_buffer_box;
-  //let allocated_mem = unsafe {calloc(max_memory_pool_size, core::mem::size_of::<u8>())};
-  //let global_ptr : *mut u8 = unsafe {core::mem::transmute(allocated_mem)};
-  //let mut global_buffer = unsafe {core::slice::from_raw_parts_mut(global_ptr, max_memory_pool_size)};
-//trace_macros!(true);
-  let global_buffer = unsafe {define_allocator_memory_pool!(4, u8, [0; 1024 * 1024 * 200], calloc)};
-  //let global_buffer = alloc_no_stdlib::CallocBackingStore<u8>(1024 * 1024 * 200, alloc_no_stdlib::AllocatorC::Calloc(calloc), free, true);
-  let mut ags = CallocAllocatedFreelist4::<u8>::new_allocator(global_buffer, bzero);
+  let mut global_buffer = unsafe {define_allocator_memory_pool!(4, u8, [0; 1024 * 1024 * 200], calloc)};
+  {
+  let mut gbref = &mut global_buffer;
+{
+  let mut ags = CallocAllocatedFreelist4::<u8>::new_allocator(gbref.data, bzero);
 
   {
   let mut x = ags.alloc_cell(9999);
@@ -64,6 +54,8 @@ fn main() {
   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 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);

src/init.rs

@@ -72,7 +72,7 @@ macro_rules! define_stack_allocator_traits(
 
         impl<'a, T: 'a> Default for $name<'a, T> {
             fn default() -> Self {
-                return $name::<'a, T>{freelist : static_array!(&mut[]; $freelist_size), backing_store : None};
+                return $name::<'a, T>{freelist : static_array!(&mut[]; $freelist_size)};
             }
         }
         define_stack_allocator_traits!($name, generic);
@@ -125,7 +125,7 @@ macro_rules! declare_stack_allocator_struct(
 
     (@new_calloc_method $name : ident, $freelist_size : tt) => {
         impl<'a, T: 'a> $name<'a, T> {
-          fn new_allocator(mut global_buffer : alloc_no_stdlib::CallocBackingStore<'a, T>,
+          fn new_allocator(mut global_buffer : &'a mut [T],
                            initializer : fn(&mut[T])) -> StackAllocator<'a, T, $name<'a, T> > {
               let mut retval = StackAllocator::<T, $name<T> > {
                   nop : &mut [],
@@ -134,8 +134,7 @@ macro_rules! declare_stack_allocator_struct(
                   free_list_overflow_count : 0,
                   initialize : initializer,
               };
-              retval.free_cell(AllocatedStackMemory::<T>{mem:core::mem::replace(&mut global_buffer.data, &mut[])});
-              retval.system_resources.backing_store = Some(global_buffer);
+              retval.free_cell(AllocatedStackMemory::<T>{mem:core::mem::replace(&mut global_buffer, &mut[])});
               return retval;
           }
         }
@@ -146,7 +145,6 @@ macro_rules! declare_stack_allocator_struct(
     ($name :ident, $freelist_size : tt, calloc) => {
         struct $name<'a, T : 'a> {
             freelist : [&'a mut [T]; declare_stack_allocator_struct!(@as_expr $freelist_size)],
-            backing_store : Option<alloc_no_stdlib::CallocBackingStore<'a, T> >,
         }
         define_stack_allocator_traits!($name,
                                        $freelist_size,

src/lib.rs

@@ -1,7 +1,7 @@
 #![no_std]
 
-//#[macro_use]
-//extern crate std;
+#[macro_use]
+extern crate std;
 mod allocated_memory;
 mod stack_allocator;
 mod allocated_stack_memory;

src/stack_allocator.rs

@@ -36,6 +36,7 @@ impl<'a, T : 'a, U : allocated_memory::AllocatedSlice<&'a mut[T]> >
     type AllocatedMemory = AllocatedStackMemory<'a, T>;
     fn alloc_cell(self : &mut StackAllocator<'a, T, U>,
                   len : usize) -> AllocatedStackMemory<'a, T> {
+        println!("Allocated {:}", len);
         if len == 0 {
             return AllocatedStackMemory::<'a, T>::default();
         }
@@ -80,6 +81,7 @@ impl<'a, T : 'a, U : allocated_memory::AllocatedSlice<&'a mut[T]> >
         if val.slice().len() == 0 {
             return;
         }
+        println!("Freed {:}", val.slice().len());
         if self.free_list_start > 0 {
             self.free_list_start -=1;
             core::mem::replace(&mut self.system_resources.slice_mut()[self.free_list_start],

tests/lib.rs

@@ -164,8 +164,8 @@ fn uninitialized_heap_pool_test() {
 fn uninitialized_calloc_pool_test() {
 
   {
-  let calloc_global_buffer = unsafe{define_allocator_memory_pool!(4096, u8, [0; 200 * 1024 * 1024], calloc)};
-  let mut ags = CallocAllocatedFreelist4096::<u8>::new_allocator(calloc_global_buffer, uninitialized);
+  let mut calloc_global_buffer = unsafe{define_allocator_memory_pool!(4096, u8, [0; 200 * 1024 * 1024], calloc)};
+  let mut ags = CallocAllocatedFreelist4096::<u8>::new_allocator(&mut calloc_global_buffer.data, uninitialized);
   {
     let mut x = ags.alloc_cell(9999);
     x.slice_mut()[0] = 4;
@@ -197,7 +197,7 @@ fn uninitialized_global_pool_test() {
   {
   let mut ags = GlobalAllocatedFreelist::<u8>::new_allocator(uninitialized);
   unsafe {
-  bind_global_buffers_to_allocator!(ags, global_buffer, u8);
+      bind_global_buffers_to_allocator!(ags, global_buffer, u8);
   }
   {
     let mut x = ags.alloc_cell(9999);
@@ -362,8 +362,8 @@ fn heap_pool_test() {
 fn calloc_pool_test() {
 
   {
-  let calloc_global_buffer = unsafe {define_allocator_memory_pool!(4096, u8, [0; 200 * 1024 * 1024], calloc)};
-  let mut ags = CallocAllocatedFreelist4096::<u8>::new_allocator(calloc_global_buffer, bzero);
+  let mut calloc_global_buffer = unsafe {define_allocator_memory_pool!(4096, u8, [0; 200 * 1024 * 1024], calloc)};
+  let mut ags = CallocAllocatedFreelist4096::<u8>::new_allocator(&mut calloc_global_buffer.data, bzero);
   {
     let mut x = ags.alloc_cell(9999);
     x.slice_mut()[0] = 4;
@@ -396,8 +396,8 @@ fn calloc_pool_test() {
 fn calloc_leak_pool_test() {
 
   {
-  let calloc_global_buffer = unsafe{define_allocator_memory_pool!(4096, u8, [0; 200 * 1024 * 1024], calloc_no_free)};
-  let mut ags = CallocAllocatedFreelist4096::<u8>::new_allocator(calloc_global_buffer, bzero);
+  let mut calloc_global_buffer = unsafe{define_allocator_memory_pool!(4096, u8, [0; 200 * 1024 * 1024], calloc_no_free)};
+  let mut ags = CallocAllocatedFreelist4096::<u8>::new_allocator(&mut calloc_global_buffer.data, bzero);
   {
     let mut x = ags.alloc_cell(9999);
     x.slice_mut()[0] = 4;
@@ -429,8 +429,9 @@ fn calloc_leak_pool_test() {
 fn malloc_pool_test() {
 
   {
-  let malloc_global_buffer = unsafe {define_allocator_memory_pool!(4096, u8, [0; 200 * 1024 * 1024], malloc)};
-  let mut ags = MallocAllocatedFreelist4096::<u8>::new_allocator(malloc_global_buffer, bzero);
+  let mut malloc_global_buffer = unsafe {define_allocator_memory_pool!(4096, u8, [0; 200 * 1024 * 1024], malloc)};
+  {
+  let mut ags = MallocAllocatedFreelist4096::<u8>::new_allocator(&mut malloc_global_buffer.data, bzero);
   {
     let mut x = ags.alloc_cell(9999);
     x.slice_mut()[0] = 4;
@@ -455,6 +456,34 @@ fn malloc_pool_test() {
     let mut _z = ags.alloc_cell(1);
   }
   }
+  {
+  let mut ags = MallocAllocatedFreelist4096::<u8>::new_allocator(&mut malloc_global_buffer.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)
+    assert_eq!(x[0], 4);
+    assert_eq!(z[0], 0);
+    assert_eq!(z[1], 8);
+    assert_eq!(reget_three[0], 0);
+    assert_eq!(reget_three[1], 9);
+    let mut _z = ags.alloc_cell(1);
+  }
+  }
+  drop(malloc_global_buffer);
+  }
 }