allow optional stdlib request to get access to the builtin malloc functions within this allocator interface

Author: danielrh

Cargo.toml

@@ -11,4 +11,8 @@ license = "BSD-3-Clause"
 repository = "https://github.com/dropbox/rust-alloc-no-stdlib"
 
 [[bin]]
-name = "example"
+name = "example"
+
+[features]
+unsafe = []
+stdlib = []

src/bin/tests.rs

@@ -3,8 +3,10 @@
 extern crate core;
 use alloc_no_stdlib::Allocator;
 use super::HeapAllocator;
-
-
+#[cfg(feature="stdlib")]
+use alloc_no_stdlib::StdAlloc;
+#[cfg(all(feature="unsafe", feature="stdlib"))]
+use alloc_no_stdlib::StdAllocUninitialized;
 #[test]
 fn heap_test() {
   let mut halloc : HeapAllocator<u8> = HeapAllocator::<u8>{default_value: 0};
@@ -23,3 +25,44 @@ fn heap_test() {
   }
 
 }
+
+
+#[cfg(all(feature="unsafe", feature="stdlib"))]
+#[test]
+fn std_unsafe_heap_test() {
+  let mut halloc = unsafe{StdAllocUninitialized::<u8>::new()};
+  for _i in 1..10 { // heap test
+      let mut x = halloc.alloc_cell(100000);
+      x[0] = 4;
+      let mut y = halloc.alloc_cell(110000);
+      y[0] = 5;
+      let mut z = halloc.alloc_cell(120000);
+      z[0] = 6;
+      assert_eq!(y[0], 5);
+      halloc.free_cell(y);
+      assert_eq!(x[0], 4);
+      assert_eq!(x[9], 0);
+      assert_eq!(z[0], 6);
+  }
+
+}
+
+#[cfg(feature="stdlib")]
+#[test]
+fn std_heap_test() {
+  let mut halloc = unsafe{StdAllocUninitialized::<u8>::new()};
+  for _i in 1..10 { // heap test
+      let mut x = halloc.alloc_cell(100000);
+      x[0] = 4;
+      let mut y = halloc.alloc_cell(110000);
+      y[0] = 5;
+      let mut z = halloc.alloc_cell(120000);
+      z[0] = 6;
+      assert_eq!(y[0], 5);
+      halloc.free_cell(y);
+      assert_eq!(x[0], 4);
+      assert_eq!(x[9], 0);
+      assert_eq!(z[0], 6);
+  }
+
+}

src/heap_alloc.rs

@@ -0,0 +1,84 @@
+#![cfg(feature="stdlib")]
+use std;
+use core;
+use core::ops;
+pub struct WrapBox<T> {
+   b : std::boxed::Box<[T]>,
+}
+
+impl<T> core::default::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};
+    }
+}
+
+impl<T> ops::Index<usize> for WrapBox<T>{
+    type Output = T;
+    fn index(&self, index : usize) -> &T {
+        return &(*self.b)[index]
+    }
+}
+
+impl<T> ops::IndexMut<usize> for WrapBox<T>{
+    fn index_mut(&mut self, index : usize) -> &mut T {
+        return &mut (*self.b)[index]
+    }
+}
+
+impl<T> super::SliceWrapper<T> for WrapBox<T> {
+    fn slice(&self) -> & [T] {
+       return &*self.b
+    }
+}
+
+impl<T> super::SliceWrapperMut<T> for WrapBox<T> {
+    fn slice_mut(&mut self) -> &mut [T] {
+       return &mut*self.b
+    }
+}
+
+pub struct StdAlloc<T : core::clone::Clone>{
+   pub default_value : T,
+}
+
+impl<T : core::clone::Clone> super::Allocator<T> for StdAlloc<T> {
+   type AllocatedMemory = WrapBox<T>;
+   fn alloc_cell(self : &mut StdAlloc<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>) {
+
+   }
+}
+
+#[cfg(feature="unsafe")]
+pub struct StdAllocUninitialized<T : core::clone::Clone>{
+   #[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};
+   }
+}
+#[cfg(feature="unsafe")]
+impl<T : core::clone::Clone> super::Allocator<T> for StdAllocUninitialized<T> {
+   type AllocatedMemory = WrapBox<T>;
+   fn alloc_cell(self : &mut Self, len : usize) -> WrapBox<T> {
+
+       let mut v : std::vec::Vec<T> = std::vec::Vec::with_capacity(len);
+       unsafe {v.set_len(len)};
+       let b = v.into_boxed_slice();
+       return WrapBox::<T>{b : b};
+   }
+   fn free_cell(self : &mut Self, _data : WrapBox<T>) {
+
+   }
+}

src/lib.rs

@@ -1,19 +1,24 @@
 #![no_std]
 
+#[cfg(feature="stdlib")]
 #[macro_use]
 extern crate std;
+mod heap_alloc;
 mod allocated_memory;
 mod stack_allocator;
 mod allocated_stack_memory;
 pub mod init;
-
 pub use allocated_memory::SliceWrapper;
 pub use allocated_memory::SliceWrapperMut;
 pub use allocated_memory::AllocatedSlice;
 
 pub use allocated_stack_memory::AllocatedStackMemory;
 pub use stack_allocator::Allocator;
 pub use stack_allocator::StackAllocator;
+#[cfg(feature="stdlib")]
+pub use heap_alloc::StdAlloc;
+#[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() {
@@ -23,6 +28,8 @@ pub fn bzero<T : Default> (data : &mut [T]) {
 
 pub fn uninitialized<T> (_data : &mut[T]) {}
 
+
+
 #[derive(Debug)]
 pub struct CallocBackingStore<'a, T : 'a> {
     pub raw_data : *mut u8,

src/stack_allocator.rs

@@ -36,7 +36,6 @@ 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();
         }
@@ -81,7 +80,6 @@ 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],