codspeed-divan-compat 4.2.1

Divan compatibility layer for CodSpeed
Documentation 
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
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159

//! Handpicked stubs from [divan::bench](https://github.com/nvzqz/divan/blob/main/src/bench/mod.rs)
//! Minimally reimplemented in an API compatible way to run the benches using codspeed intrumentation
#![allow(clippy::needless_lifetimes)] // We keep explicit lifetime to be as close to original API as possible

mod args;
mod options;

pub use self::{
    args::{BenchArgs, BenchArgsRunner},
    options::BenchOptions,
};

use codspeed::codspeed::CodSpeed;
use std::cell::RefCell;

/// Using this in place of `()` for `GenI` prevents `Bencher::with_inputs` from
/// working with `()` unintentionally.
#[non_exhaustive]
pub struct Unit;

pub struct BencherConfig<GenI = Unit> {
    gen_input: RefCell<GenI>,
}

pub struct Bencher<'a, 'b, C = BencherConfig> {
    pub(crate) codspeed: &'a RefCell<CodSpeed>,
    pub(crate) uri: String,
    pub(crate) config: C,
    pub(crate) _marker: std::marker::PhantomData<&'b ()>,
}

impl<'a, 'b> Bencher<'a, 'b> {
    pub(crate) fn new(codspeed: &'a RefCell<CodSpeed>, uri: String) -> Self {
        Self {
            config: BencherConfig {
                gen_input: RefCell::new(Unit),
            },
            codspeed,
            uri,
            _marker: std::marker::PhantomData,
        }
    }

    pub fn with_inputs<G>(self, gen_input: G) -> Bencher<'a, 'b, BencherConfig<G>> {
        Bencher {
            config: BencherConfig {
                gen_input: RefCell::new(gen_input),
            },
            codspeed: self.codspeed,
            uri: self.uri,
            _marker: self._marker,
        }
    }

    /// Add a counter to this benchmark (placeholder implementation).
    ///
    /// Note: Counters are not yet supported by codspeed-divan-compat.
    /// This method is provided for API compatibility but does not affect benchmarking.
    pub fn counter<C>(self, _counter: C) -> Self {
        eprintln!("Warning: Counter feature is not yet supported by codspeed-divan-compat");
        self
    }

    /// Add a counter based on input to this benchmark (placeholder implementation).
    ///
    /// Note: Counters are not yet supported by codspeed-divan-compat.
    /// This method is provided for API compatibility but does not affect benchmarking.
    pub fn input_counter<C, F>(self, _counter_fn: F) -> Self
    where
        F: Fn() -> C,
    {
        eprintln!("Warning: Counter feature is not yet supported by codspeed-divan-compat");
        self
    }
}

impl<'a, 'b> Bencher<'a, 'b> {
    pub fn bench<O, B>(self, benched: B)
    where
        B: Fn() -> O + Sync,
    {
        self.with_inputs(|| ()).bench_values(|_| benched())
    }

    pub fn bench_local<O, B>(self, mut benched: B)
    where
        B: FnMut() -> O,
    {
        self.with_inputs(|| ()).bench_local_values(|_| benched())
    }
}

impl<'a, 'b, I, GenI> Bencher<'a, 'b, BencherConfig<GenI>>
where
    GenI: FnMut() -> I,
{
    /// Add a counter to this benchmark (placeholder implementation).
    ///
    /// Note: Counters are not yet supported by codspeed-divan-compat.
    /// This method is provided for API compatibility but does not affect benchmarking.
    pub fn counter<C>(self, _counter: C) -> Self {
        eprintln!("Warning: Counter feature is not yet supported by codspeed-divan-compat");
        self
    }

    /// Add a counter based on input to this benchmark (placeholder implementation).
    ///
    /// Note: Counters are not yet supported by codspeed-divan-compat.
    /// This method is provided for API compatibility but does not affect benchmarking.
    pub fn input_counter<C, F>(self, _counter_fn: F) -> Self
    where
        F: Fn(&I) -> C,
    {
        eprintln!("Warning: Counter feature is not yet supported by codspeed-divan-compat");
        self
    }
    pub fn bench_values<O, B>(self, benched: B)
    where
        B: Fn(I) -> O + Sync,
        GenI: Fn() -> I + Sync,
    {
        self.bench_local_values(benched)
    }

    pub fn bench_refs<O, B>(self, benched: B)
    where
        B: Fn(&mut I) -> O + Sync,
        GenI: Fn() -> I + Sync,
    {
        self.bench_local_refs(benched)
    }

    pub fn bench_local_values<O, B>(self, mut benched: B)
    where
        B: FnMut(I) -> O,
    {
        let mut codspeed = self.codspeed.borrow_mut();
        let mut gen_input = self.config.gen_input.borrow_mut();
        let input = gen_input();
        codspeed.start_benchmark(self.uri.as_str());
        let output = benched(input);
        codspeed.end_benchmark();
        divan::black_box(output);
    }

    pub fn bench_local_refs<O, B>(self, mut benched: B)
    where
        B: FnMut(&mut I) -> O,
    {
        let mut codspeed = self.codspeed.borrow_mut();
        let mut gen_input = self.config.gen_input.borrow_mut();
        let mut input = gen_input();

        codspeed.start_benchmark(self.uri.as_str());
        let output = benched(&mut input);
        codspeed.end_benchmark();
        divan::black_box(output);
    }
}