Add a cache to self-profile downloads

Author: Kobzol

Cargo.lock

@@ -48,6 +48,7 @@ uuid = { version = "1.3.0", features = ["v4"] }
 tera = "1.18"
 rust-embed = { version = "6.6.0", features = ["include-exclude", "interpolate-folder-path"] }
 humansize = "2"
+lru = "0.12.0"
 
 [target.'cfg(unix)'.dependencies]
 jemallocator = "0.5"

site/Cargo.toml

@@ -8,10 +8,12 @@ use arc_swap::{ArcSwap, Guard};
 use chrono::{Duration, Utc};
 use lazy_static::lazy_static;
 use log::error;
+use parking_lot::Mutex;
 use regex::Regex;
 use serde::{Deserialize, Serialize};
 
 use crate::db;
+use crate::self_profile::SelfProfileCache;
 use collector::compile::benchmark::category::Category;
 use collector::{Bound, MasterCommit};
 use database::Pool;
@@ -116,6 +118,9 @@ impl MasterCommitCache {
     }
 }
 
+// How many analyzed self profiles should be stored in memory
+const CACHED_SELF_PROFILE_COUNT: usize = 1000;
+
 /// Site context object that contains global data
 pub struct SiteCtxt {
     /// Site configuration
@@ -126,6 +131,8 @@ pub struct SiteCtxt {
     pub index: ArcSwap<crate::db::Index>,
     /// Cached master-branch Rust commits
     pub master_commits: Arc<ArcSwap<MasterCommitCache>>, // outer Arc enables mutation in background task
+    /// Cache for self profile data
+    pub self_profile_cache: Mutex<SelfProfileCache>,
     /// Database connection pool
     pub pool: Pool,
 }
@@ -174,6 +181,7 @@ impl SiteCtxt {
             master_commits: Arc::new(ArcSwap::new(Arc::new(master_commits))),
             pool,
             landing_page: ArcSwap::new(Arc::new(None)),
+            self_profile_cache: Mutex::new(SelfProfileCache::new(CACHED_SELF_PROFILE_COUNT)),
         })
     }
 

site/src/load.rs

@@ -1,14 +1,12 @@
 use std::collections::HashSet;
 use std::io::Read;
-use std::num::NonZeroUsize;
 use std::sync::Arc;
 use std::time::Instant;
 
 use bytes::Buf;
 use database::CommitType;
 use headers::{ContentType, Header};
 use hyper::StatusCode;
-use lru::LruCache;
 
 use crate::api::self_profile::ArtifactSizeDelta;
 use crate::api::{self_profile, self_profile_processed, self_profile_raw, ServerResult};
@@ -17,7 +15,8 @@ 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, SelfProfileWithAnalysis,
+    download_and_analyze_self_profile, get_self_profile_raw_data, SelfProfileKey,
+    SelfProfileWithAnalysis,
 };
 use crate::server::{Response, ResponseHeaders};
 
@@ -535,7 +534,35 @@ 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;
 
-    let mut self_profile = download_and_analyze_self_profile(
+    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(
         ctxt,
         commits.get(0).unwrap().clone(),
         bench_name,
@@ -546,7 +573,7 @@ pub async fn handle_self_profile(
     .await?;
     let base_self_profile = match commits.get(1) {
         Some(aid) => Some(
-            download_and_analyze_self_profile(
+            get_from_cache(
                 ctxt,
                 aid.clone(),
                 bench_name,

site/src/request_handlers/self_profile.rs

@@ -7,6 +7,8 @@ use crate::load::SiteCtxt;
 use anyhow::Context;
 use bytes::Buf;
 use database::ArtifactId;
+use lru::LruCache;
+use std::num::NonZeroUsize;
 use std::time::Duration;
 use std::{collections::HashMap, io::Read, time::Instant};
 
@@ -122,6 +124,38 @@ pub(crate) async fn get_self_profile_raw_data(url: &str) -> anyhow::Result<Vec<u
     extract(&compressed)
 }
 
+#[derive(Hash, Eq, PartialEq)]
+pub struct SelfProfileKey {
+    pub aid: ArtifactId,
+    pub benchmark: String,
+    pub profile: String,
+    pub scenario: database::Scenario,
+}
+
+/// Stores a cache of N most recently used self profiles.
+/// The profiles are downloaded from S3 and analysed on each request to the detailed compare result
+/// page, but the post-processed results aren't very large in memory (~50 KiB), so it makes sense
+/// to cache them.
+pub struct SelfProfileCache {
+    profiles: LruCache<SelfProfileKey, SelfProfileWithAnalysis>,
+}
+
+impl SelfProfileCache {
+    pub fn new(cache_size: usize) -> Self {
+        Self {
+            profiles: LruCache::new(NonZeroUsize::new(cache_size).unwrap()),
+        }
+    }
+
+    pub fn get(&mut self, key: &SelfProfileKey) -> Option<SelfProfileWithAnalysis> {
+        self.profiles.get(key).cloned()
+    }
+
+    pub fn insert(&mut self, key: SelfProfileKey, profile: SelfProfileWithAnalysis) {
+        self.profiles.put(key, profile);
+    }
+}
+
 #[derive(Clone)]
 pub struct SelfProfileWithAnalysis {
     pub profile: self_profile::SelfProfile,