Document the switch to HW counters

Author: Kobzol

site/frontend/templates/pages/detailed-query.html

@@ -80,6 +80,8 @@ <h4>Artifact Size</h4>
             </tbody>
         </table>
         <p>'Instructions (%)' is the percentage of instructions executed on this query.</p>
+        <p><b>Note: self-profile measurements have been <a href="https://github.com/rust-lang/rustc-perf/pull/1647">recently switched</a>
+          from wall-time to HW counters (instruction count). If comparing with an older artifact, the timings might not be directly comparable.</b></p>
         <p>Executions do not include cached executions.</p>
         <table>
             <thead>

site/src/api.rs

@@ -333,19 +333,22 @@ pub mod self_profile {
         pub artifact_sizes: Option<Vec<ArtifactSize>>,
     }
 
+    // Due to backwards compatibility, self profile event timing data is represented as durations,
+    // however since https://github.com/rust-lang/rustc-perf/pull/1647 it actually represents
+    // HW counter data (instruction counts).
     #[derive(Serialize, Deserialize, Clone, Debug)]
     pub struct QueryData {
+        // Instruction count
+        pub self_instructions: u64,
         pub label: QueryLabel,
-        // Nanoseconds
-        pub self_time: u64,
         pub percent_total_time: f32,
         pub number_of_cache_misses: u32,
         pub number_of_cache_hits: u32,
         pub invocation_count: u32,
-        // Nanoseconds
-        pub blocked_time: u64,
-        // Nanoseconds
-        pub incremental_load_time: u64,
+        // Instruction count
+        pub blocked_instructions: u64,
+        // Instruction count
+        pub incremental_load_instructions: u64,
     }
 
     #[derive(Serialize, Deserialize, Clone, Debug)]

site/src/request_handlers/self_profile.rs

@@ -155,7 +155,7 @@ pub async fn handle_self_profile_processed_download(
 }
 
 fn get_self_profile_data(
-    cpu_clock: Option<f64>,
+    total_instructions: Option<f64>,
     profile: &analyzeme::AnalysisResults,
 ) -> ServerResult<self_profile::SelfProfile> {
     let total_time: Duration = profile.query_data.iter().map(|qd| qd.self_time).sum();
@@ -165,22 +165,22 @@ fn get_self_profile_data(
         .iter()
         .map(|qd| self_profile::QueryData {
             label: qd.label.as_str().into(),
-            self_time: qd.self_time.as_nanos() as u64,
+            self_instructions: qd.self_time.as_nanos() as u64,
             percent_total_time: ((qd.self_time.as_secs_f64() / total_time.as_secs_f64()) * 100.0)
                 as f32,
             number_of_cache_misses: qd.number_of_cache_misses as u32,
             number_of_cache_hits: qd.number_of_cache_hits as u32,
             invocation_count: qd.invocation_count as u32,
-            blocked_time: qd.blocked_time.as_nanos() as u64,
-            incremental_load_time: qd.incremental_load_time.as_nanos() as u64,
+            blocked_instructions: qd.blocked_time.as_nanos() as u64,
+            incremental_load_instructions: qd.incremental_load_time.as_nanos() as u64,
         })
         .collect();
 
     let totals = self_profile::QueryData {
         label: "Totals".into(),
-        self_time: total_time.as_nanos() as u64,
+        self_instructions: total_time.as_nanos() as u64,
         // TODO: check against wall-time from perf stats
-        percent_total_time: cpu_clock
+        percent_total_time: total_instructions
             .map(|w| ((total_time.as_secs_f64() / w) * 100.0) as f32)
             // sentinel "we couldn't compute this time"
             .unwrap_or(-100.0),
@@ -199,12 +199,12 @@ fn get_self_profile_data(
             .iter()
             .map(|qd| qd.invocation_count as u32)
             .sum(),
-        blocked_time: profile
+        blocked_instructions: profile
             .query_data
             .iter()
             .map(|qd| qd.blocked_time.as_nanos() as u64)
             .sum(),
-        incremental_load_time: profile
+        incremental_load_instructions: profile
             .query_data
             .iter()
             .map(|qd| qd.incremental_load_time.as_nanos() as u64)
@@ -249,13 +249,13 @@ fn add_uninvoked_base_profile_queries(
         if !profile_queries.contains(qd.label.as_str()) {
             let uninvoked_query_data = self_profile::QueryData {
                 label: qd.label,
-                self_time: 0,
+                self_instructions: 0,
                 percent_total_time: 0.0,
                 number_of_cache_misses: 0,
                 number_of_cache_hits: 0,
                 invocation_count: 0,
-                blocked_time: 0,
-                incremental_load_time: 0,
+                blocked_instructions: 0,
+                incremental_load_instructions: 0,
             };
 
             profile.query_data.push(uninvoked_query_data);
@@ -272,11 +272,12 @@ fn get_self_profile_delta(
     let base_profile = base_profile.as_ref()?;
 
     let totals = self_profile::QueryDataDelta {
-        self_time: profile.totals.self_time as i64 - base_profile.totals.self_time as i64,
+        self_time: profile.totals.self_instructions as i64
+            - base_profile.totals.self_instructions as i64,
         invocation_count: profile.totals.invocation_count as i32
             - base_profile.totals.invocation_count as i32,
-        incremental_load_time: profile.totals.incremental_load_time as i64
-            - base_profile.totals.incremental_load_time as i64,
+        incremental_load_time: profile.totals.incremental_load_instructions as i64
+            - base_profile.totals.incremental_load_instructions as i64,
     };
 
     let mut query_data = Vec::new();
@@ -289,19 +290,19 @@ fn get_self_profile_delta(
         {
             Some(base_qd) => {
                 let delta = self_profile::QueryDataDelta {
-                    self_time: qd.self_time as i64 - base_qd.self_time as i64,
+                    self_time: qd.self_instructions as i64 - base_qd.self_instructions as i64,
                     invocation_count: qd.invocation_count as i32 - base_qd.invocation_count as i32,
-                    incremental_load_time: qd.incremental_load_time as i64
-                        - base_qd.incremental_load_time as i64,
+                    incremental_load_time: qd.incremental_load_instructions as i64
+                        - base_qd.incremental_load_instructions as i64,
                 };
 
                 query_data.push(delta);
             }
             None => {
                 let delta = self_profile::QueryDataDelta {
-                    self_time: qd.self_time as i64,
+                    self_time: qd.self_instructions as i64,
                     invocation_count: qd.invocation_count as i32,
-                    incremental_load_time: qd.incremental_load_time as i64,
+                    incremental_load_time: qd.incremental_load_instructions as i64,
                 };
 
                 query_data.push(delta);
@@ -339,12 +340,12 @@ fn sort_self_profile(
 
     match sort_idx.abs() {
         1 => indices.sort_by_key(|&i| qd[i].label),
-        2 => indices.sort_by_key(|&i| qd[i].self_time),
+        2 => indices.sort_by_key(|&i| qd[i].self_instructions),
         3 => indices.sort_by_key(|&i| qd[i].number_of_cache_misses),
         4 => indices.sort_by_key(|&i| qd[i].number_of_cache_hits),
         5 => indices.sort_by_key(|&i| qd[i].invocation_count),
-        6 => indices.sort_by_key(|&i| qd[i].blocked_time),
-        7 => indices.sort_by_key(|&i| qd[i].incremental_load_time),
+        6 => indices.sort_by_key(|&i| qd[i].blocked_instructions),
+        7 => indices.sort_by_key(|&i| qd[i].incremental_load_instructions),
         9 => indices.sort_by_key(|&i| {
             // convert to displayed percentage
             ((qd[i].number_of_cache_hits as f64 / qd[i].invocation_count as f64) * 10_000.0) as u64
@@ -602,9 +603,9 @@ pub async fn handle_self_profile(
     }
     let commits = Arc::new(commits);
 
-    let mut cpu_responses = ctxt.statistic_series(query, commits.clone()).await?;
-    assert_eq!(cpu_responses.len(), 1, "all selectors are exact");
-    let mut cpu_response = cpu_responses.remove(0).series;
+    let mut instructions_responses = ctxt.statistic_series(query, commits.clone()).await?;
+    assert_eq!(instructions_responses.len(), 1, "all selectors are exact");
+    let mut instructions_response = instructions_responses.remove(0).series;
 
     let mut self_profile_data = Vec::new();
     let conn = ctxt.conn().await;
@@ -623,12 +624,16 @@ pub async fn handle_self_profile(
         }
     }
     let profiling_data = self_profile_data.remove(0).perform_analysis();
-    let mut profile = get_self_profile_data(cpu_response.next().unwrap().1, &profiling_data)
-        .map_err(|e| format!("{}: {}", body.commit, e))?;
+    let mut profile =
+        get_self_profile_data(instructions_response.next().unwrap().1, &profiling_data)
+            .map_err(|e| format!("{}: {}", body.commit, e))?;
     let (base_profile, base_raw_data) = if body.base_commit.is_some() {
         let base_profiling_data = self_profile_data.remove(0).perform_analysis();
-        let profile = get_self_profile_data(cpu_response.next().unwrap().1, &base_profiling_data)
-            .map_err(|e| format!("{}: {}", body.base_commit.as_ref().unwrap(), e))?;
+        let profile = get_self_profile_data(
+            instructions_response.next().unwrap().1,
+            &base_profiling_data,
+        )
+        .map_err(|e| format!("{}: {}", body.base_commit.as_ref().unwrap(), e))?;
         (Some(profile), Some(base_profiling_data))
     } else {
         (None, None)