codspeed 4.5.0

Core instrumentation library 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

use crate::measurement;
use colored::Colorize;
use std::ffi::CString;

pub use std::hint::black_box;

pub const WARMUP_RUNS: u32 = 5;

pub fn display_native_harness() {
    eprintln!("Harness: codspeed v{}", env!("CARGO_PKG_VERSION"),);
}

#[derive(PartialEq)]
pub enum InstrumentationStatus {
    /// Instrumentation detected via inline assembly directly
    Valgrind,
    /// Instrumentation detected via InstrumentHooks
    InstrumentHooks(&'static crate::instrument_hooks::InstrumentHooks),
    NotInstrumented,
}

impl InstrumentationStatus {
    pub fn is_instrumented(&self) -> bool {
        *self != InstrumentationStatus::NotInstrumented
    }
}

pub struct CodSpeed {
    benchmarked: Vec<String>,
    current_benchmark: CString,
    group_stack: Vec<String>,
    instrumentation_status: InstrumentationStatus,
}

impl CodSpeed {
    pub fn new() -> Self {
        use crate::instrument_hooks::InstrumentHooks;
        let instrumentation_status = {
            // Always initialize InstrumentHooks for environment collection,
            // even when using Valgrind for the actual measurements.
            let hooks_instance = InstrumentHooks::instance();

            // We bypass InstrumentHooks if we detect Valgrind via inline assembly
            // Until we can reliably get rid of the inline assembly without causing breaking
            // changes in CPU simulation measurements by switching to InstrumentHooks only, we need
            // to keep this separation.
            if measurement::is_instrumented() {
                InstrumentationStatus::Valgrind
            } else if hooks_instance.is_instrumented() {
                InstrumentationStatus::InstrumentHooks(hooks_instance)
            } else {
                InstrumentationStatus::NotInstrumented
            }
        };

        if !instrumentation_status.is_instrumented() {
            eprintln!(
                "{} codspeed is enabled, but no performance measurement will be made since it's running in an unknown environment.",
                "NOTICE:".to_string().bold()
            );
        };

        measurement::set_metadata();

        Self {
            benchmarked: Vec::new(),
            current_benchmark: CString::new("").expect("CString::new failed"),
            group_stack: Vec::new(),
            instrumentation_status,
        }
    }

    pub fn push_group(&mut self, group: &str) {
        self.group_stack.push(group.to_string());
    }

    pub fn pop_group(&mut self) {
        self.group_stack.pop();
    }

    #[inline(always)]
    pub fn start_benchmark(&mut self, name: &str) {
        self.current_benchmark = CString::new(name).expect("CString::new failed");

        if let InstrumentationStatus::InstrumentHooks(hooks_instance) = &self.instrumentation_status
        {
            let _ = hooks_instance.start_benchmark();
        }

        // We intentionally do this no matter the instrumentation status.
        // The overhead in case we are not running valgrind is extremely low, and we do not want to
        // add a conditionnal branch to valgrind measurements.
        measurement::start();
    }

    #[inline(always)]
    pub fn end_benchmark(&mut self) {
        // We intentionally do this no matter the instrumentation status.
        // The overhead in case we are not running valgrind is extremely low, and we do not want to
        // add a conditionnal branch to valgrind measurements.
        measurement::stop(&self.current_benchmark);
        if let InstrumentationStatus::InstrumentHooks(hooks_instance) = &self.instrumentation_status
        {
            let _ = hooks_instance.stop_benchmark();
            let _ =
                hooks_instance.set_executed_benchmark(&self.current_benchmark.to_string_lossy());
        }
        self.benchmarked
            .push(self.current_benchmark.to_str().unwrap().to_string());

        let action_str = if self.instrumentation_status.is_instrumented() {
            "Measured"
        } else {
            "Checked"
        };

        let group_str = if self.group_stack.is_empty() {
            "".to_string()
        } else {
            format!(" (group: {})", self.group_stack.join("/"))
        };
        println!(
            "{}: {}{}",
            action_str,
            self.current_benchmark.to_string_lossy(),
            group_str
        );
    }
}

impl Default for CodSpeed {
    fn default() -> Self {
        Self::new()
    }
}