Fix compilation under no_std

Author: bitwalker

liblumen_alloc/src/lib.rs

@@ -1,10 +1,17 @@
 #![recursion_limit = "128"]
+#![cfg_attr(not(test), no_std)]
+// Do not fail the build when feature flags are stabilized on recent nightlies, just warn
 #![allow(stable_features)]
+// Allow use of intrinsics, e.g. unlikely/copy_nonoverlapping/etc.
 #![feature(core_intrinsics)]
+// Allocator APIs
 #![feature(allocator_api)]
 #![feature(alloc_layout_extra)]
+// Support offset_from pointer calculation
 #![feature(ptr_offset_from)]
+// Support is_empty for ExactSizeIterator
 #![feature(exact_size_is_empty)]
+// Support use of Self and other type aliases in matches on enum variants
 #![feature(type_alias_enum_variants)]
 #![feature(alloc)]
 

liblumen_alloc/src/stats/histogram.rs

@@ -8,13 +8,16 @@
 //! # Examples
 //! 
 //! ```
-//! use liblumen_alloc::stats::define_histogram;
-//!
-//! define_histogram!(10);
+//! use liblumen_alloc::stats::Histogram;
+//! 
+//! mod stats {
+//!     use liblumen_alloc::define_histogram;
+//!     define_histogram!(10);
+//! }
 //! # fn main() {
 //! // Create a histogram that will spread the given range over 
 //! // the 10 buckets the `Histogram` type was defined with.
-//! let mut histogram = Histogram::with_const_width(0, 10_000);
+//! let mut histogram = stats::Histogram::with_const_width(0, 10_000);
 //!
 //! // Adds some samples to the histogram.
 //! for sample in 0..100 {
@@ -56,7 +59,6 @@
 //! // ```
 //! # }
 //! ```
-#![deny(missing_docs)]
 #![deny(unsafe_code)]
 
 use core::fmt;
@@ -65,7 +67,7 @@ pub use defaults::Histogram as DefaultHistogram;
 
 /// This trait represents the bare minimum functionality needed
 /// to interact with an implementation by a mutator
-pub trait Histogram: Clone + Default + fmt::Display {
+pub trait Histogram: fmt::Display {
     /// Add a sample to the histogram.
     ///
     /// Fails if the sample is out of range of the histogram.
@@ -219,9 +221,36 @@ macro_rules! define_histogram {
             pub fn range_max(&self) -> u64 {
                 self.range[Self::LEN]
             }
+
+            /// Return the minimum value observed so far
+            #[inline]
+            pub fn min(&self) -> u64 {
+                self.minmax.min().copied().unwrap_or(0)
+            }
+
+            /// Return the maximum value observed so far
+            #[inline]
+            pub fn max(&self) -> u64 {
+                self.minmax.max().copied().unwrap_or(0)
+            }
+
+            #[inline]
+            pub fn mean(&self) -> f64 {
+                self.stats.mean()
+            }
+
+            #[inline]
+            pub fn stddev(&self) -> f64 {
+                self.stats.stddev()
+            }
+
+            #[inline]
+            pub fn variance(&self) -> f64 {
+                self.stats.variance()
+            }
         }
 
-        impl $crate::stats::histogram::Histogram for Histogram {
+        impl $crate::stats::Histogram for Histogram {
             /// Add a sample to the histogram.
             ///
             /// Fails if the sample is out of range of the histogram.
@@ -274,6 +303,9 @@ macro_rules! define_histogram {
                 use core::cmp;
                 use core::fmt::Write;
 
+                #[cfg(not(test))]
+                use alloc::string::String;
+
                 let num_samples: u64 = self.bins().iter().sum();
                 writeln!(f, "# Number of samples = {}", num_samples)?;
                 if num_samples == 0 {
@@ -357,71 +389,79 @@ mod defaults {
     // This histogram will spread all allocations across 100 buckets
     define_histogram!(100);
     // Provide a default implementation which will focus on the main sizes of concern
-    impl Default for Histogram {
+    impl Default for self::Histogram {
         fn default() -> Self {
-            let mut ranges = Vec::with_capacity(100);
+            use heapless::Vec;
+            use heapless::consts::U100;
+            let mut ranges = Vec::<_, U100>::new();
             // Use the fibonnaci sequence up to 1TB
             let mut n: u64 = 1;
             let mut m: u64 = 2;
-            ranges.push(m);
+            ranges.push(m).unwrap();
             for _ in 1..57u64 {
                 let new_m = n + m;
                 n = m;
-                ranges.push(new_m);
+                ranges.push(new_m).unwrap();
                 m = new_m;
             }
             // Grow by 20% afterwards
             for _ in 57..99u64 {
                 let new_m = m + (m as f64 * 0.2).ceil() as u64;
-                ranges.push(new_m);
+                ranges.push(new_m).unwrap();
                 m = new_m;
             }
             // Add one final range that covers the remaining address space
-            ranges.push(u64::max_value());
-            Self::from_ranges(ranges.as_slice().iter().cloned()).unwrap()
+            ranges.push(u64::max_value()).unwrap();
+            Self::from_ranges(ranges.iter().cloned()).unwrap()
         }
     }
 }
 
 #[cfg(test)]
 mod tests {
-    use super::*;
+    mod defaults {
+        use crate::define_histogram;
+
+        define_histogram!(10);
+    }
 
-    define_histogram!(10);
+    use super::Histogram;
+    use self::defaults::Histogram as DefaultHistogram;
 
     #[test]
-    fn with_const_width_test() {
-        let mut h = Histogram::with_const_width(0, 100);
+    fn histogram_with_const_width_test() {
+        let mut h = DefaultHistogram::with_const_width(0, 100);
         for i in 0..100 {
-            h.add(i);
+            h.add(i).ok();
         }
         assert_eq!(h.max(), 99);
         assert_eq!(h.min(), 0);
-        assert_eq!(h.mean(), 50);
-        assert_eq!(h.bins(), &[10, 10, 10, 10, 10, 10, 10, 10, 10, 9])
+        assert_eq!(h.mean(), 49.5);
+        assert_eq!(h.bins(), &[10, 10, 10, 10, 10, 10, 10, 10, 10, 10])
     }
 
     #[test]
-    fn from_ranges_test() {
-        let ranges = [
-            (2, 4), 
-            (4, 8), 
-            (8, 16), 
-            (16, 32), 
-            (32, 64),
-            (64, 128),
-            (128, 256),
-            (256, 512),
-            (512, 1024),
-            (1024, 2048),
+    fn histogram_from_ranges_test() {
+        let ranges: [u64; 11] = [
+            2,
+            4,
+            8,
+            16,
+            32,
+            64,
+            128,
+            256,
+            512,
+            1024,
+            2048
         ];
-        let mut h = Histogram::from_ranges(&ranges);
+        let mut h = DefaultHistogram::from_ranges(ranges.iter().copied()).unwrap();
         for i in 2..2048 {
-            h.add(i);
+            h.add(i).ok();
         }
         assert_eq!(h.max(), 2047);
         assert_eq!(h.min(), 2);
-        assert_eq!(h.mean(), 50);
-        assert_eq!(h.bins(), &[10, 10, 10, 10, 10, 10, 10, 10, 10, 9])
+        assert_eq!(h.mean(), 1024.5);
+        assert_eq!(h.bins(), &[2, 4, 8, 16, 32, 64, 128, 256, 512, 1024])
     }
 }

liblumen_alloc/src/stats_alloc.rs

@@ -21,7 +21,7 @@ use crate::stats::hooks;
 /// The `StatsAlloc` can be tagged to provide useful metadata bout
 /// what type of allocator is being traced and how it is used.
 #[derive(Debug)]
-pub struct StatsAlloc<T, H: Histogram = DefaultHistogram> {
+pub struct StatsAlloc<T, H: Histogram + Clone + Default = DefaultHistogram> {
     alloc_calls: AtomicUsize,
     dealloc_calls: AtomicUsize,
     realloc_calls: AtomicUsize,
@@ -32,7 +32,7 @@ pub struct StatsAlloc<T, H: Histogram = DefaultHistogram> {
     tag: &'static str,
     allocator: T,
 }
-impl<T, H: Histogram> StatsAlloc<T, H> {
+impl<T, H: Histogram + Clone + Default> StatsAlloc<T, H> {
     #[inline]
     pub fn new(t: T) -> Self {
         Self {
@@ -77,19 +77,19 @@ impl<T, H: Histogram> StatsAlloc<T, H> {
         }
     }
 }
-impl<T: Default, H: Histogram> Default for StatsAlloc<T, H> {
+impl<T: Default, H: Histogram + Clone + Default> Default for StatsAlloc<T, H> {
     #[inline]
     fn default() -> Self {
         Self::new(T::default())
     }
 }
-unsafe impl<T: Alloc + Sync, H: Histogram> Sync for StatsAlloc<T, H> {}
-unsafe impl<T: Alloc + Send, H: Histogram> Send for StatsAlloc<T, H> {}
+unsafe impl<T: Alloc + Sync, H: Histogram + Clone + Default> Sync for StatsAlloc<T, H> {}
+unsafe impl<T: Alloc + Send, H: Histogram + Clone + Default> Send for StatsAlloc<T, H> {}
 
 /// This struct represents a snapshot of the stats gathered
 /// by an instances of `StatsAlloc`, and is used for display
 #[derive(Debug)]
-pub struct Statistics<H: Histogram> {
+pub struct Statistics<H: Histogram + Clone + Default> {
     alloc_calls: usize,
     dealloc_calls: usize,
     realloc_calls: usize,
@@ -99,7 +99,7 @@ pub struct Statistics<H: Histogram> {
     tag: &'static str,
     histogram: H,
 }
-impl<H: Histogram> fmt::Display for Statistics<H> {
+impl<H: Histogram + Clone + Default> fmt::Display for Statistics<H> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         writeln!(f, "## Allocator Statistics (tag = {})", self.tag)?;
         writeln!(f, "# Calls to alloc = {}", self.alloc_calls)?;
@@ -114,7 +114,7 @@ impl<H: Histogram> fmt::Display for Statistics<H> {
     }
 }
 
-unsafe impl<T: Alloc, H: Histogram> Alloc for StatsAlloc<T, H> {
+unsafe impl<T: Alloc, H: Histogram + Clone + Default> Alloc for StatsAlloc<T, H> {
     #[inline]
     unsafe fn alloc(&mut self, layout: Layout) -> Result<NonNull<u8>, AllocErr> {
         let size = layout.size();
@@ -195,7 +195,7 @@ unsafe impl<T: Alloc, H: Histogram> Alloc for StatsAlloc<T, H> {
     }
 }
 
-unsafe impl<T: GlobalAlloc, H: Histogram> GlobalAlloc for StatsAlloc<T, H> {
+unsafe impl<T: GlobalAlloc, H: Histogram + Clone + Default> GlobalAlloc for StatsAlloc<T, H> {
     #[inline]
     unsafe fn alloc(&self, layout: Layout) -> *mut u8 {
         let size = layout.size();

liblumen_alloc/src/std_alloc.rs

@@ -37,6 +37,9 @@ use core::alloc::{Alloc, AllocErr, Layout};
 use core::cmp;
 use core::ptr::{self, NonNull};
 
+#[cfg(not(test))]
+use alloc::vec::Vec;
+
 use cfg_if::cfg_if;
 use lazy_static::lazy_static;