Load self profile data from cache if possible

Author: Kobzol

site/src/request_handlers/graph.rs

@@ -10,7 +10,7 @@ use crate::db::{self, ArtifactId, Profile, Scenario};
 use crate::interpolate::IsInterpolated;
 use crate::load::SiteCtxt;
 use crate::selector::{CompileBenchmarkQuery, CompileTestCase, Selector, SeriesResponse};
-use crate::self_profile::download_and_analyze_self_profile;
+use crate::self_profile::get_or_download_self_profile;
 
 /// Returns data for a detailed information when comparing a single test result comparison
 /// for a compile-time benchmark.
@@ -49,19 +49,14 @@ pub async fn handle_compile_detail(
         scenario: Scenario,
     ) -> Option<CompilationSections> {
         match aid {
-            Some(aid) => download_and_analyze_self_profile(
-                ctxt,
-                aid.clone(),
-                benchmark,
-                profile,
-                scenario,
-                None,
-            )
-            .await
-            .ok()
-            .map(|profile| CompilationSections {
-                sections: profile.compilation_sections,
-            }),
+            Some(aid) => {
+                get_or_download_self_profile(ctxt, aid.clone(), benchmark, profile, scenario, None)
+                    .await
+                    .ok()
+                    .map(|profile| CompilationSections {
+                        sections: profile.compilation_sections,
+                    })
+            }
             None => None,
         }
     }

site/src/request_handlers/self_profile.rs

@@ -14,10 +14,7 @@ use crate::comparison::Metric;
 use crate::db::ArtifactId;
 use crate::load::SiteCtxt;
 use crate::selector::{self};
-use crate::self_profile::{
-    download_and_analyze_self_profile, get_self_profile_raw_data, SelfProfileKey,
-    SelfProfileWithAnalysis,
-};
+use crate::self_profile::{get_or_download_self_profile, get_self_profile_raw_data};
 use crate::server::{Response, ResponseHeaders};
 
 pub async fn handle_self_profile_processed_download(
@@ -535,35 +532,7 @@ pub async fn handle_self_profile(
     assert_eq!(cpu_responses.len(), 1, "all selectors are exact");
     let mut cpu_response = cpu_responses.remove(0).series;
 
-    async fn get_from_cache(
-        ctxt: &SiteCtxt,
-        aid: ArtifactId,
-        benchmark: &str,
-        profile: &str,
-        scenario: database::Scenario,
-        metric: Option<f64>,
-    ) -> ServerResult<SelfProfileWithAnalysis> {
-        let key = SelfProfileKey {
-            aid: aid.clone(),
-            benchmark: benchmark.to_string(),
-            profile: profile.to_string(),
-            scenario,
-        };
-        let cache_result = ctxt.self_profile_cache.lock().get(&key);
-        match cache_result {
-            Some(res) => Ok(res),
-            None => {
-                let profile = download_and_analyze_self_profile(
-                    ctxt, aid, benchmark, profile, scenario, metric,
-                )
-                .await?;
-                ctxt.self_profile_cache.lock().insert(key, profile.clone());
-                Ok(profile)
-            }
-        }
-    }
-
-    let mut self_profile = get_from_cache(
+    let mut self_profile = get_or_download_self_profile(
         ctxt,
         commits.get(0).unwrap().clone(),
         bench_name,
@@ -574,7 +543,7 @@ pub async fn handle_self_profile(
     .await?;
     let base_self_profile = match commits.get(1) {
         Some(aid) => Some(
-            get_from_cache(
+            get_or_download_self_profile(
                 ctxt,
                 aid.clone(),
                 bench_name,

site/src/self_profile.rs

@@ -202,7 +202,7 @@ pub struct SelfProfileWithAnalysis {
     pub compilation_sections: Vec<CompilationSection>,
 }
 
-pub(crate) async fn download_and_analyze_self_profile(
+async fn download_and_analyze_self_profile(
     ctxt: &SiteCtxt,
     aid: ArtifactId,
     benchmark: &str,
@@ -292,6 +292,33 @@ fn compute_compilation_sections(profile: &ProfilingData) -> Vec<CompilationSecti
     sections
 }
 
+pub(crate) async fn get_or_download_self_profile(
+    ctxt: &SiteCtxt,
+    aid: ArtifactId,
+    benchmark: &str,
+    profile: &str,
+    scenario: database::Scenario,
+    metric: Option<f64>,
+) -> ServerResult<SelfProfileWithAnalysis> {
+    let key = SelfProfileKey {
+        aid: aid.clone(),
+        benchmark: benchmark.to_string(),
+        profile: profile.to_string(),
+        scenario,
+    };
+    let cache_result = ctxt.self_profile_cache.lock().get(&key);
+    match cache_result {
+        Some(res) => Ok(res),
+        None => {
+            let profile =
+                download_and_analyze_self_profile(ctxt, aid, benchmark, profile, scenario, metric)
+                    .await?;
+            ctxt.self_profile_cache.lock().insert(key, profile.clone());
+            Ok(profile)
+        }
+    }
+}
+
 fn get_self_profile_data(
     cpu_clock: Option<f64>,
     profile: &analyzeme::AnalysisResults,