Add benchmarks for the global cache tracker.

Author: ehuss

Cargo.lock

@@ -9,7 +9,23 @@ cd benches/benchsuite
 cargo bench
 ```
 
-The tests involve downloading the index and benchmarking against some
+However, running all benchmarks would take many minutes, so in most cases it
+is recommended to just run the benchmarks relevant to whatever section of code
+you are working on.
+
+## Benchmarks
+
+There are several different kinds of benchmarks in the `benchsuite/benches` directory:
+
+* `global_cache_tracker` — Benchmarks saving data to the global cache tracker
+  database using samples of real-world data.
+* `resolve` — Benchmarks the resolver against simulations of real-world workspaces.
+* `workspace_initialization` — Benchmarks initialization of a workspace
+  against simulations of real-world workspaces.
+
+### Resolve benchmarks
+
+The resolve benchmarks involve downloading the index and benchmarking against some
 real-world and artificial workspaces located in the [`workspaces`](workspaces)
 directory.
 
@@ -21,15 +37,32 @@ faster. You can (and probably should) specify individual benchmarks to run to
 narrow it down to a more reasonable set, for example:
 
 ```sh
-cargo bench -- resolve_ws/rust
+cargo bench -p benchsuite --bench resolve -- resolve_ws/rust
 ```
 
 This will only download what's necessary for the rust-lang/rust workspace
 (which is about 330MB) and run the benchmarks against it (which should take
 about a minute). To get a list of all the benchmarks, run:
 
 ```sh
-cargo bench -- --list
+cargo bench -p benchsuite --bench resolve -- --list
+```
+
+### Global cache tracker
+
+The `global_cache_tracker` benchmark tests saving data to the global cache
+tracker database using samples of real-world data. This benchmark should run
+relatively quickly.
+
+The real-world data is based on a capture of my personal development
+environment which has accumulated a large cache. So it is somewhat arbitrary,
+but hopefully representative of a challenging environment. Capturing of the
+data is done with the `capture-last-use` binary, which you can run if you need
+to rebuild the database. Just try to run on a system with a relatively full
+cache in your cargo home directory.
+
+```sh
+cargo bench -p benchsuite --bench global_cache_tracker
 ```
 
 ## Viewing reports

benches/README.md

@@ -11,8 +11,10 @@ publish = false
 
 [dependencies]
 cargo.workspace = true
+cargo-util.workspace = true
 criterion.workspace = true
 flate2.workspace = true
+rand.workspace = true
 tar.workspace = true
 url.workspace = true
 
@@ -26,3 +28,7 @@ harness = false
 [[bench]]
 name = "workspace_initialization"
 harness = false
+
+[[bench]]
+name = "global_cache_tracker"
+harness = false

benches/benchsuite/Cargo.toml

@@ -0,0 +1,159 @@
+//! Benchmarks for the global cache tracker.
+
+use cargo::core::global_cache_tracker::{self, DeferredGlobalLastUse, GlobalCacheTracker};
+use cargo::util::cache_lock::CacheLockMode;
+use cargo::util::interning::InternedString;
+use cargo::util::Config;
+use criterion::{criterion_group, criterion_main, Criterion};
+use std::fs;
+use std::path::{Path, PathBuf};
+
+// Samples of real-world data.
+const GLOBAL_CACHE_SAMPLE: &str = "global-cache-tracker/global-cache-sample";
+const GLOBAL_CACHE_RANDOM: &str = "global-cache-tracker/random-sample";
+
+/// A scratch directory where the benchmark can place some files.
+fn root() -> PathBuf {
+    let mut p = PathBuf::from(env!("CARGO_TARGET_TMPDIR"));
+    p.push("bench_global_cache_tracker");
+    p
+}
+
+fn cargo_home() -> PathBuf {
+    let mut p = root();
+    p.push("chome");
+    p
+}
+
+fn initialize_config() -> Config {
+    // Set up config.
+    let shell = cargo::core::Shell::new();
+    let homedir = cargo_home();
+    if !homedir.exists() {
+        fs::create_dir_all(&homedir).unwrap();
+    }
+    let cwd = homedir.clone();
+    let mut config = Config::new(shell, cwd, homedir);
+    config.nightly_features_allowed = true;
+    config.set_search_stop_path(root());
+    config
+        .configure(
+            0,
+            false,
+            None,
+            false,
+            false,
+            false,
+            &None,
+            &["gc".to_string()],
+            &[],
+        )
+        .unwrap();
+    // Set up database sample.
+    let db_path = GlobalCacheTracker::db_path(&config).into_path_unlocked();
+    if db_path.exists() {
+        fs::remove_file(&db_path).unwrap();
+    }
+    let sample = Path::new(env!("CARGO_MANIFEST_DIR")).join(GLOBAL_CACHE_SAMPLE);
+    fs::copy(sample, &db_path).unwrap();
+    config
+}
+
+/// Benchmarks how long it takes to initialize `GlobalCacheTracker` with an already
+/// existing full database.
+fn global_tracker_init(c: &mut Criterion) {
+    let config = initialize_config();
+    let _lock = config
+        .acquire_package_cache_lock(CacheLockMode::DownloadExclusive)
+        .unwrap();
+    c.bench_function("global_tracker_init", |b| {
+        b.iter(|| {
+            GlobalCacheTracker::new(&config).unwrap();
+        })
+    });
+}
+
+/// Benchmarks how long it takes to save a `GlobalCacheTracker` when there are zero
+/// updates.
+fn global_tracker_empty_save(c: &mut Criterion) {
+    let config = initialize_config();
+    let _lock = config
+        .acquire_package_cache_lock(CacheLockMode::DownloadExclusive)
+        .unwrap();
+    let mut deferred = DeferredGlobalLastUse::new();
+    let mut tracker = GlobalCacheTracker::new(&config).unwrap();
+
+    c.bench_function("global_tracker_empty_save", |b| {
+        b.iter(|| {
+            deferred.save(&mut tracker).unwrap();
+        })
+    });
+}
+
+fn load_random_sample() -> Vec<(InternedString, InternedString, u64)> {
+    let path = Path::new(env!("CARGO_MANIFEST_DIR")).join(GLOBAL_CACHE_RANDOM);
+    fs::read_to_string(path)
+        .unwrap()
+        .lines()
+        .map(|s| {
+            let mut s = s.split(',');
+            (
+                s.next().unwrap().into(),
+                s.next().unwrap().into(),
+                s.next().unwrap().parse().unwrap(),
+            )
+        })
+        .collect()
+}
+
+/// Tests performance of updating the last-use timestamps in an already
+/// populated database.
+///
+/// This runs for different sizes of number of crates to update (selecting
+/// from the random sample stored on disk).
+fn global_tracker_update(c: &mut Criterion) {
+    let config = initialize_config();
+    let _lock = config
+        .acquire_package_cache_lock(CacheLockMode::DownloadExclusive)
+        .unwrap();
+    let sample = Path::new(env!("CARGO_MANIFEST_DIR")).join(GLOBAL_CACHE_SAMPLE);
+    let db_path = GlobalCacheTracker::db_path(&config).into_path_unlocked();
+
+    let random_sample = load_random_sample();
+
+    let mut group = c.benchmark_group("global_tracker_update");
+    for size in [1, 10, 100, 500] {
+        if db_path.exists() {
+            fs::remove_file(&db_path).unwrap();
+        }
+
+        fs::copy(&sample, &db_path).unwrap();
+        let mut deferred = DeferredGlobalLastUse::new();
+        let mut tracker = GlobalCacheTracker::new(&config).unwrap();
+        group.bench_with_input(size.to_string(), &size, |b, &size| {
+            b.iter(|| {
+                for (encoded_registry_name, name, size) in &random_sample[..size] {
+                    deferred.mark_registry_crate_used(global_cache_tracker::RegistryCrate {
+                        encoded_registry_name: *encoded_registry_name,
+                        crate_filename: format!("{}.crate", name).into(),
+                        size: *size,
+                    });
+                    deferred.mark_registry_src_used(global_cache_tracker::RegistrySrc {
+                        encoded_registry_name: *encoded_registry_name,
+                        package_dir: *name,
+                        size: Some(*size),
+                    });
+                }
+                deferred.save(&mut tracker).unwrap();
+            })
+        });
+    }
+}
+
+criterion_group!(
+    benches,
+    global_tracker_init,
+    global_tracker_empty_save,
+    global_tracker_update
+);
+criterion_main!(benches);