Store runtime benchmark names into SQLite

Author: Kobzol

collector/src/bin/collector.rs

@@ -571,6 +571,9 @@ enum Commands {
         /// How many iterations of each benchmark should be executed.
         #[clap(long, default_value = "5")]
         iterations: u32,
+
+        #[clap(flatten)]
+        db: DbOption,
     },
     /// Benchmarks a local rustc
     BenchLocal {
@@ -703,7 +706,11 @@ fn main_result() -> anyhow::Result<i32> {
     let target_triple = format!("{}-unknown-linux-gnu", std::env::consts::ARCH);
 
     match args.command {
-        Commands::BenchRuntimeLocal { local, iterations } => {
+        Commands::BenchRuntimeLocal {
+            local,
+            iterations,
+            db,
+        } => {
             let toolchain = get_local_toolchain(
                 &[Profile::Opt],
                 &local.rustc,
@@ -712,12 +719,15 @@ fn main_result() -> anyhow::Result<i32> {
                 local.id.as_deref(),
                 "",
             )?;
-            bench_runtime(
+            let pool = Pool::open(&db.db);
+            let fut = bench_runtime(
+                pool,
                 toolchain,
                 BenchmarkFilter::new(local.exclude, local.include),
                 runtime_benchmark_dir,
                 iterations,
-            )?;
+            );
+            rt.block_on(fut)?;
             Ok(0)
         }
         Commands::BenchLocal {

collector/src/runtime/benchmark.rs

@@ -45,7 +45,7 @@ impl BenchmarkSuite {
             .count() as u64
     }
 
-    fn benchmark_names(&self) -> impl Iterator<Item = &str> {
+    pub fn benchmark_names(&self) -> impl Iterator<Item = &str> {
         self.groups
             .iter()
             .flat_map(|suite| suite.benchmark_names.iter().map(|n| n.as_ref()))

collector/src/runtime/mod.rs

@@ -8,19 +8,26 @@ use std::process::{Command, Stdio};
 use thousands::Separable;
 
 pub use benchmark::BenchmarkFilter;
+use database::Pool;
 
 /// Perform a series of runtime benchmarks using the provided `rustc` compiler.
 /// The runtime benchmarks are looked up in `benchmark_dir`, which is expected to be a path
 /// to a Cargo crate. All binaries built by that crate will are expected to be runtime benchmark
 /// groups that leverage `benchlib`.
-pub fn bench_runtime(
+pub async fn bench_runtime(
+    db: Pool,
     toolchain: LocalToolchain,
     filter: BenchmarkFilter,
     benchmark_dir: PathBuf,
     iterations: u32,
 ) -> anyhow::Result<()> {
     let suite = benchmark::discover_benchmarks(&toolchain, &benchmark_dir)?;
 
+    let connection = db.connection().await;
+    for benchmark in suite.benchmark_names() {
+        connection.record_runtime_benchmark(benchmark).await;
+    }
+
     let total_benchmark_count = suite.total_benchmark_count();
     let filtered = suite.filtered_benchmark_count(&filter);
     println!(

database/src/pool.rs

@@ -15,8 +15,19 @@ pub trait Connection: Send + Sync {
     async fn transaction(&mut self) -> Box<dyn Transaction + '_>;
 
     async fn load_index(&mut self) -> Index;
+
+    /// None means that the caller doesn't know; it should be left alone if
+    /// known or set to false if unknown.
+    async fn record_compile_benchmark(
+        &self,
+        krate: &str,
+        supports_stable: Option<bool>,
+        category: String,
+    );
     async fn get_compile_benchmarks(&self) -> Vec<CompileBenchmark>;
 
+    async fn record_runtime_benchmark(&self, name: &str);
+
     async fn artifact_by_name(&self, artifact: &str) -> Option<ArtifactId>;
 
     /// This records the duration of a collection run, i.e., collecting all of
@@ -25,14 +36,7 @@ pub trait Connection: Send + Sync {
 
     async fn collection_id(&self, version: &str) -> CollectionId;
     async fn artifact_id(&self, artifact: &ArtifactId) -> ArtifactIdNumber;
-    /// None means that the caller doesn't know; it should be left alone if
-    /// known or set to false if unknown.
-    async fn record_compile_benchmark(
-        &self,
-        krate: &str,
-        supports_stable: Option<bool>,
-        category: String,
-    );
+
     async fn record_statistic(
         &self,
         collection: CollectionId,

database/src/pool/postgres.rs

@@ -922,6 +922,9 @@ where
                 .unwrap();
         }
     }
+    async fn record_runtime_benchmark(&self, _name: &str) {
+        unimplemented!()
+    }
 
     async fn collector_start(&self, aid: ArtifactIdNumber, steps: &[String]) {
         // Clean up -- we'll re-insert any missing things in the loop below.

database/src/pool/sqlite.rs

@@ -543,6 +543,15 @@ impl Connection for SqliteConnection {
         }
         benchmarks
     }
+    async fn record_runtime_benchmark(&self, name: &str) {
+        self.raw_ref()
+            .execute(
+                "insert into runtime_benchmark (name) VALUES (?)
+                ON CONFLICT (name) do nothing",
+                params![name],
+            )
+            .unwrap();
+    }
 
     async fn get_pstats(
         &self,