yab 0.2.0

Yet Another Benchmarking framework powered by `cachegrind`
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89

//! Sequential reporter implementation.

use std::{any::Any, mem, sync::Arc};

use super::{BenchmarkOutput, BenchmarkReporter, Logger, Reporter, TestReporter};
use crate::{BenchmarkId, CachegrindStats};

#[derive(Debug)]
pub(crate) struct SeqReporter {
    reporters: Vec<Box<dyn Reporter>>,
    pub(crate) logger: Arc<dyn Logger>,
}

impl SeqReporter {
    pub(crate) fn new(logger: Arc<dyn Logger>) -> Self {
        Self {
            reporters: vec![],
            logger,
        }
    }

    pub(crate) fn push(&mut self, mut reporter: Box<dyn Reporter>) {
        reporter.set_logger(&self.logger);
        self.reporters.push(reporter);
    }

    pub(crate) fn ok_all(&mut self) {
        for reporter in mem::take(&mut self.reporters) {
            reporter.ok();
        }
    }
}

impl Reporter for SeqReporter {
    fn new_test(&mut self, id: &BenchmarkId) -> Box<dyn TestReporter> {
        struct Seq(Vec<Box<dyn TestReporter>>);

        impl TestReporter for Seq {
            fn ok(self: Box<Self>) {
                for reporter in self.0 {
                    reporter.ok();
                }
            }

            fn fail(self: Box<Self>, panic_data: &dyn Any) {
                for reporter in self.0 {
                    reporter.fail(panic_data);
                }
            }
        }

        let reporters = self
            .reporters
            .iter_mut()
            .map(|reporter| reporter.new_test(id));
        Box::new(Seq(reporters.collect()))
    }

    fn new_benchmark(&mut self, id: &BenchmarkId) -> Box<dyn BenchmarkReporter> {
        #[derive(Debug)]
        struct Seq(Vec<Box<dyn BenchmarkReporter>>);

        impl BenchmarkReporter for Seq {
            fn start_execution(&mut self) {
                for reporter in &mut self.0 {
                    reporter.start_execution();
                }
            }

            fn baseline_computed(&mut self, stats: &CachegrindStats) {
                for reporter in &mut self.0 {
                    reporter.baseline_computed(stats);
                }
            }

            fn ok(self: Box<Self>, output: &BenchmarkOutput) {
                for reporter in self.0 {
                    reporter.ok(output);
                }
            }
        }

        let reporters = self
            .reporters
            .iter_mut()
            .map(|reporter| reporter.new_benchmark(id));
        Box::new(Seq(reporters.collect()))
    }
}