defer drop

Author: PSeitz

src/bench.rs

@@ -25,7 +25,7 @@ pub(crate) struct NamedBench<'a, I, O> {
     pub fun: CallBench<'a, I, O>,
     pub num_group_iter: usize,
 }
-impl<'a, I, O> NamedBench<'a, I, O> {
+impl<'a, I, O: OutputValue> NamedBench<'a, I, O> {
     pub fn new(bench_id: BenchId, fun: CallBench<'a, I, O>, num_group_iter: usize) -> Self {
         Self {
             bench_id,
@@ -174,7 +174,7 @@ impl<O> RunResult<O> {
     }
 }
 
-impl<'a, I, O> NamedBench<'a, I, O> {
+impl<'a, I, O: OutputValue> NamedBench<'a, I, O> {
     #[inline]
     /// Each group has its own number of iterations. This is not the final num_iter
     pub fn sample_and_get_iter(&mut self, input: &'a I) -> usize {
@@ -216,14 +216,27 @@ impl<'a, I, O> NamedBench<'a, I, O> {
         plugins.emit(PluginEvents::BenchStart {
             bench_id: &self.bench_id,
         });
+        debug_assert!(num_iter > 0);
         let start = std::time::Instant::now();
-        let mut res: Option<O> = None;
-        for _ in 0..num_iter {
-            res = Some(black_box((self.fun)(input)));
-        }
-        let elapsed = start.elapsed();
 
-        let run_result = RunResult::new(elapsed.as_nanos() as u64 / num_iter as u64, res.unwrap());
+        // Defer dropping outputs so destructor cost is not part of the measured time.
+        let run_result = if O::defer_drop() {
+            let mut outputs: Vec<O> = Vec::with_capacity(num_iter);
+            for _ in 0..num_iter {
+                outputs.push(black_box((self.fun)(input)));
+            }
+            let duration_ns = start.elapsed().as_nanos() as u64 / num_iter as u64;
+            let last_output = outputs.pop().expect("num_iter > 0");
+            RunResult::new(duration_ns, last_output)
+        } else {
+            let mut res: Option<O> = None;
+            for _ in 0..num_iter {
+                res = Some(black_box((self.fun)(input)));
+            }
+            let duration_ns = start.elapsed().as_nanos() as u64 / num_iter as u64;
+            RunResult::new(duration_ns, res.unwrap())
+        };
+
         plugins.emit(PluginEvents::BenchStop {
             bench_id: &self.bench_id,
             duration: run_result.duration_ns,

src/output_value.rs

@@ -1,4 +1,6 @@
 use crate::report::format::{format_duration, format_with_underscores};
+use core::mem::{needs_drop, size_of};
+use std::collections::HashMap;
 
 /// Every bench returns an OutputValue, which can be formatted to a string.
 ///
@@ -21,6 +23,16 @@ pub trait OutputValue {
     fn column_title() -> &'static str {
         "Output"
     }
+
+    /// Whether the output should be buffered and dropped after the measurement was recorded.
+    /// Defaults to deferring drop for types that actually need it and are not zero-sized.
+    #[inline]
+    fn defer_drop() -> bool
+    where
+        Self: Sized,
+    {
+        needs_drop::<Self>() && size_of::<Self>() > 0
+    }
 }
 
 impl OutputValue for () {
@@ -74,13 +86,59 @@ impl OutputValue for std::time::Instant {
     }
 }
 
+impl<T> OutputValue for Vec<T> {
+    fn format(&self) -> Option<String> {
+        Some(format_with_underscores(self.len() as u64))
+    }
+    fn column_title() -> &'static str {
+        "Vec(len)"
+    }
+}
+impl<K, V> OutputValue for HashMap<K, V> {
+    fn format(&self) -> Option<String> {
+        Some(format_with_underscores(self.len() as u64))
+    }
+    fn column_title() -> &'static str {
+        "Map(len)"
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
 
+    struct NeedsDrop(u8);
+    impl Drop for NeedsDrop {
+        fn drop(&mut self) {}
+    }
+    impl OutputValue for NeedsDrop {
+        fn format(&self) -> Option<String> {
+            Some(self.0.to_string())
+        }
+    }
+
     #[test]
     fn format_u64_test() {
         let value = 123456789u64;
         assert_eq!(value.format(), Some("123_456_789".to_string()));
     }
+
+    #[test]
+    fn should_buffer_outputs_respects_drop_semantics() {
+        assert!(NeedsDrop::defer_drop());
+        assert!(!bool::defer_drop());
+
+        struct ZeroSizedNeedsDrop;
+        impl Drop for ZeroSizedNeedsDrop {
+            fn drop(&mut self) {}
+        }
+        impl OutputValue for ZeroSizedNeedsDrop {
+            fn format(&self) -> Option<String> {
+                None
+            }
+        }
+
+        // Zero-sized types should not allocate buffering slots
+        assert!(!ZeroSizedNeedsDrop::defer_drop());
+    }
 }