|
| 1 | +//! This module is responsible for collecting metrics profiling information for the current build |
| 2 | +//! and dumping it to disk as JSON, to aid investigations on build and CI performance. |
| 3 | +//! |
| 4 | +//! As this module requires additional dependencies not present during local builds, it's cfg'd |
| 5 | +//! away whenever the `build.metrics` config option is not set to `true`. |
| 6 | +
|
| 7 | +use crate::builder::Step; |
| 8 | +use crate::util::t; |
| 9 | +use crate::Build; |
| 10 | +use serde::{Deserialize, Serialize}; |
| 11 | +use std::cell::RefCell; |
| 12 | +use std::fs::File; |
| 13 | +use std::io::BufWriter; |
| 14 | +use std::time::{Duration, Instant}; |
| 15 | +use sysinfo::{ProcessorExt, System, SystemExt}; |
| 16 | + |
| 17 | +pub(crate) struct BuildMetrics { |
| 18 | + state: RefCell<MetricsState>, |
| 19 | +} |
| 20 | + |
| 21 | +impl BuildMetrics { |
| 22 | + pub(crate) fn init() -> Self { |
| 23 | + let state = RefCell::new(MetricsState { |
| 24 | + finished_steps: Vec::new(), |
| 25 | + running_steps: Vec::new(), |
| 26 | + |
| 27 | + system_info: System::new(), |
| 28 | + timer_start: None, |
| 29 | + invocation_timer_start: Instant::now(), |
| 30 | + }); |
| 31 | + |
| 32 | + BuildMetrics { state } |
| 33 | + } |
| 34 | + |
| 35 | + pub(crate) fn enter_step<S: Step>(&self, step: &S) { |
| 36 | + let mut state = self.state.borrow_mut(); |
| 37 | + |
| 38 | + // Consider all the stats gathered so far as the parent's. |
| 39 | + if !state.running_steps.is_empty() { |
| 40 | + self.collect_stats(&mut *state); |
| 41 | + } |
| 42 | + |
| 43 | + state.system_info.refresh_cpu(); |
| 44 | + state.timer_start = Some(Instant::now()); |
| 45 | + |
| 46 | + state.running_steps.push(StepMetrics { |
| 47 | + type_: std::any::type_name::<S>().into(), |
| 48 | + debug_repr: format!("{step:?}"), |
| 49 | + |
| 50 | + cpu_usage_time_sec: 0.0, |
| 51 | + duration_excluding_children_sec: Duration::ZERO, |
| 52 | + |
| 53 | + children: Vec::new(), |
| 54 | + }); |
| 55 | + } |
| 56 | + |
| 57 | + pub(crate) fn exit_step(&self) { |
| 58 | + let mut state = self.state.borrow_mut(); |
| 59 | + |
| 60 | + self.collect_stats(&mut *state); |
| 61 | + |
| 62 | + let step = state.running_steps.pop().unwrap(); |
| 63 | + if state.running_steps.is_empty() { |
| 64 | + state.finished_steps.push(step); |
| 65 | + state.timer_start = None; |
| 66 | + } else { |
| 67 | + state.running_steps.last_mut().unwrap().children.push(step); |
| 68 | + |
| 69 | + // Start collecting again for the parent step. |
| 70 | + state.system_info.refresh_cpu(); |
| 71 | + state.timer_start = Some(Instant::now()); |
| 72 | + } |
| 73 | + } |
| 74 | + |
| 75 | + fn collect_stats(&self, state: &mut MetricsState) { |
| 76 | + let step = state.running_steps.last_mut().unwrap(); |
| 77 | + |
| 78 | + let elapsed = state.timer_start.unwrap().elapsed(); |
| 79 | + step.duration_excluding_children_sec += elapsed; |
| 80 | + |
| 81 | + state.system_info.refresh_cpu(); |
| 82 | + let cpu = state.system_info.processors().iter().map(|p| p.cpu_usage()).sum::<f32>(); |
| 83 | + step.cpu_usage_time_sec += cpu as f64 / 100.0 * elapsed.as_secs_f64(); |
| 84 | + } |
| 85 | + |
| 86 | + pub(crate) fn persist(&self, build: &Build) { |
| 87 | + let mut state = self.state.borrow_mut(); |
| 88 | + assert!(state.running_steps.is_empty(), "steps are still executing"); |
| 89 | + |
| 90 | + let dest = build.out.join("metrics.json"); |
| 91 | + |
| 92 | + let mut system = System::new(); |
| 93 | + system.refresh_cpu(); |
| 94 | + system.refresh_memory(); |
| 95 | + |
| 96 | + let system_stats = JsonInvocationSystemStats { |
| 97 | + cpu_threads_count: system.processors().len(), |
| 98 | + cpu_model: system.processors()[0].brand().into(), |
| 99 | + |
| 100 | + memory_total_bytes: system.total_memory() * 1024, |
| 101 | + }; |
| 102 | + let steps = std::mem::take(&mut state.finished_steps); |
| 103 | + |
| 104 | + // Some of our CI builds consist of multiple independent CI invocations. Ensure all the |
| 105 | + // previous invocations are still present in the resulting file. |
| 106 | + let mut invocations = match std::fs::read(&dest) { |
| 107 | + Ok(contents) => t!(serde_json::from_slice::<JsonRoot>(&contents)).invocations, |
| 108 | + Err(err) => { |
| 109 | + if err.kind() != std::io::ErrorKind::NotFound { |
| 110 | + panic!("failed to open existing metrics file at {}: {err}", dest.display()); |
| 111 | + } |
| 112 | + Vec::new() |
| 113 | + } |
| 114 | + }; |
| 115 | + invocations.push(JsonInvocation { |
| 116 | + duration_including_children_sec: state.invocation_timer_start.elapsed().as_secs_f64(), |
| 117 | + children: steps.into_iter().map(|step| self.prepare_json_step(step)).collect(), |
| 118 | + }); |
| 119 | + |
| 120 | + let json = JsonRoot { system_stats, invocations }; |
| 121 | + |
| 122 | + t!(std::fs::create_dir_all(dest.parent().unwrap())); |
| 123 | + let mut file = BufWriter::new(t!(File::create(&dest))); |
| 124 | + t!(serde_json::to_writer(&mut file, &json)); |
| 125 | + } |
| 126 | + |
| 127 | + fn prepare_json_step(&self, step: StepMetrics) -> JsonNode { |
| 128 | + JsonNode::RustbuildStep { |
| 129 | + type_: step.type_, |
| 130 | + debug_repr: step.debug_repr, |
| 131 | + |
| 132 | + duration_excluding_children_sec: step.duration_excluding_children_sec.as_secs_f64(), |
| 133 | + system_stats: JsonStepSystemStats { |
| 134 | + cpu_utilization_percent: step.cpu_usage_time_sec * 100.0 |
| 135 | + / step.duration_excluding_children_sec.as_secs_f64(), |
| 136 | + }, |
| 137 | + |
| 138 | + children: step |
| 139 | + .children |
| 140 | + .into_iter() |
| 141 | + .map(|child| self.prepare_json_step(child)) |
| 142 | + .collect(), |
| 143 | + } |
| 144 | + } |
| 145 | +} |
| 146 | + |
| 147 | +struct MetricsState { |
| 148 | + finished_steps: Vec<StepMetrics>, |
| 149 | + running_steps: Vec<StepMetrics>, |
| 150 | + |
| 151 | + system_info: System, |
| 152 | + timer_start: Option<Instant>, |
| 153 | + invocation_timer_start: Instant, |
| 154 | +} |
| 155 | + |
| 156 | +struct StepMetrics { |
| 157 | + type_: String, |
| 158 | + debug_repr: String, |
| 159 | + |
| 160 | + cpu_usage_time_sec: f64, |
| 161 | + duration_excluding_children_sec: Duration, |
| 162 | + |
| 163 | + children: Vec<StepMetrics>, |
| 164 | +} |
| 165 | + |
| 166 | +#[derive(Serialize, Deserialize)] |
| 167 | +#[serde(rename_all = "snake_case")] |
| 168 | +struct JsonRoot { |
| 169 | + system_stats: JsonInvocationSystemStats, |
| 170 | + invocations: Vec<JsonInvocation>, |
| 171 | +} |
| 172 | + |
| 173 | +#[derive(Serialize, Deserialize)] |
| 174 | +#[serde(rename_all = "snake_case")] |
| 175 | +struct JsonInvocation { |
| 176 | + duration_including_children_sec: f64, |
| 177 | + children: Vec<JsonNode>, |
| 178 | +} |
| 179 | + |
| 180 | +#[derive(Serialize, Deserialize)] |
| 181 | +#[serde(tag = "kind", rename_all = "snake_case")] |
| 182 | +enum JsonNode { |
| 183 | + RustbuildStep { |
| 184 | + #[serde(rename = "type")] |
| 185 | + type_: String, |
| 186 | + debug_repr: String, |
| 187 | + |
| 188 | + duration_excluding_children_sec: f64, |
| 189 | + system_stats: JsonStepSystemStats, |
| 190 | + |
| 191 | + children: Vec<JsonNode>, |
| 192 | + }, |
| 193 | +} |
| 194 | + |
| 195 | +#[derive(Serialize, Deserialize)] |
| 196 | +#[serde(rename_all = "snake_case")] |
| 197 | +struct JsonInvocationSystemStats { |
| 198 | + cpu_threads_count: usize, |
| 199 | + cpu_model: String, |
| 200 | + |
| 201 | + memory_total_bytes: u64, |
| 202 | +} |
| 203 | + |
| 204 | +#[derive(Serialize, Deserialize)] |
| 205 | +#[serde(rename_all = "snake_case")] |
| 206 | +struct JsonStepSystemStats { |
| 207 | + cpu_utilization_percent: f64, |
| 208 | +} |
0 commit comments