Store benchmark category into the database

Author: Kobzol

collector/src/execute.rs

@@ -110,6 +110,19 @@ fn default_runs() -> usize {
     3
 }
 
+#[derive(Debug, Clone, serde::Deserialize)]
+#[serde(rename_all = "lowercase")]
+enum BenchmarkCategory {
+    Primary,
+    Secondary
+}
+
+impl Default for BenchmarkCategory {
+    fn default() -> Self {
+        Self::Secondary
+    }
+}
+
 /// This is the internal representation of an individual benchmark's
 /// perf-config.json file.
 #[derive(Debug, Clone, serde::Deserialize)]
@@ -130,6 +143,9 @@ struct BenchmarkConfig {
     /// directory that `Cargo.toml` is in.
     #[serde(default)]
     touch_file: Option<String>,
+
+    #[serde(default)]
+    category: BenchmarkCategory
 }
 
 impl Default for BenchmarkConfig {
@@ -142,6 +158,7 @@ impl Default for BenchmarkConfig {
             runs: default_runs(),
             supports_stable: false,
             touch_file: None,
+            category: BenchmarkCategory::Secondary
         }
     }
 }
@@ -1239,6 +1256,13 @@ impl Benchmark {
         self.config.supports_stable
     }
 
+    pub fn category_name(&self) -> &str {
+        match self.config.category {
+            BenchmarkCategory::Primary => "primary",
+            BenchmarkCategory::Secondary => "secondary"
+        }
+    }
+
     #[cfg(windows)]
     fn copy(from: &Path, to: &Path) -> anyhow::Result<()> {
         collector::robocopy(from, to, &[])

collector/src/main.rs

@@ -188,6 +188,7 @@ fn bench(
     let mut measure_and_record =
         |benchmark_name: &BenchmarkName,
          benchmark_supports_stable: bool,
+         benchmark_category: &str,
          print_intro: &dyn Fn(),
          measure: &dyn Fn(&mut BenchProcessor) -> anyhow::Result<()>| {
             let is_fresh =
@@ -200,7 +201,7 @@ fn bench(
             let mut tx = rt.block_on(conn.transaction());
             rt.block_on(
                 tx.conn()
-                    .record_benchmark(&benchmark_name.0, Some(benchmark_supports_stable)),
+                    .record_benchmark(&benchmark_name.0, Some(benchmark_supports_stable), benchmark_category),
             );
             print_intro();
 
@@ -237,6 +238,7 @@ fn bench(
         measure_and_record(
             &benchmark.name,
             benchmark.supports_stable(),
+            benchmark.category_name(),
             &|| {
                 eprintln!(
                     "{}",
@@ -252,6 +254,7 @@ fn bench(
         measure_and_record(
             &BenchmarkName("rustc".to_string()),
             /* supports_stable */ false,
+            "primary",
             &|| eprintln!("Special benchmark commencing (due to `--bench-rustc`)"),
             &|processor| processor.measure_rustc(compiler).context("measure rustc"),
         );

database/src/bin/import-sqlite.rs

@@ -41,7 +41,7 @@ async fn main() {
         for &(benchmark, profile, scenario, metric) in sqlite_idx.all_statistic_descriptions() {
             if benchmarks.insert(benchmark) {
                 postgres_conn
-                    .record_benchmark(benchmark.as_str(), None)
+                    .record_benchmark(benchmark.as_str(), None, "") // TODO
                     .await;
             }
 

database/src/pool.rs

@@ -26,7 +26,7 @@ pub trait Connection: Send + Sync {
     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_benchmark(&self, krate: &str, supports_stable: Option<bool>);
+    async fn record_benchmark(&self, krate: &str, supports_stable: Option<bool>, category: &str);
     async fn record_statistic(
         &self,
         collection: CollectionId,

database/src/pool/postgres.rs

@@ -966,35 +966,35 @@ where
             .await
             .unwrap();
     }
-    async fn record_benchmark(&self, benchmark: &str, supports_stable: Option<bool>) {
+    async fn record_benchmark(&self, benchmark: &str, supports_stable: Option<bool>, category: &str) {
         if let Some(r) = self
             .conn()
             .query_opt(
-                "select stabilized from benchmark where name = $1",
+                "select stabilized, category from benchmark where name = $1",
                 &[&benchmark],
             )
             .await
             .unwrap()
         {
-            if Some(r.get::<_, bool>(0)) == supports_stable {
+            if Some(r.get::<_, bool>(0)) == supports_stable && r.get::<_, &str>(1) == category {
                 return;
             }
         }
         if let Some(stable) = supports_stable {
             self.conn()
                 .execute(
-                    "insert into benchmark (name, stabilized) VALUES ($1, $2)
-                ON CONFLICT (name) DO UPDATE SET stabilized = EXCLUDED.stabilized",
-                    &[&benchmark, &stable],
+                    "insert into benchmark (name, stabilized, category) VALUES ($1, $2, $3)
+                ON CONFLICT (name) DO UPDATE SET stabilized = EXCLUDED.stabilized, category = EXCLUDED.category",
+                    &[&benchmark, &stable, &category],
                 )
                 .await
                 .unwrap();
         } else {
             self.conn()
                 .execute(
-                    "insert into benchmark (name, stabilized) VALUES ($1, $2)
-                ON CONFLICT DO NOTHING",
-                    &[&benchmark, &false],
+                    "insert into benchmark (name, stabilized, category) VALUES ($1, $2, $3)
+                ON CONFLICT (name) DO UPDATE SET category = EXCLUDED.category",
+                    &[&benchmark, &false, &category],
                 )
                 .await
                 .unwrap();

database/src/pool/sqlite.rs

@@ -317,6 +317,7 @@ static MIGRATIONS: &[Migration] = &[
         alter table benchmark_new rename to benchmark;
         "#,
     ),
+    Migration::new("alter table benchmark add column category text not null"),
 ];
 
 #[async_trait::async_trait]
@@ -863,21 +864,21 @@ impl Connection for SqliteConnection {
             )
             .unwrap();
     }
-    async fn record_benchmark(&self, benchmark: &str, supports_stable: Option<bool>) {
+    async fn record_benchmark(&self, benchmark: &str, supports_stable: Option<bool>, category: &str) {
         if let Some(stable) = supports_stable {
             self.raw_ref()
                 .execute(
-                    "insert into benchmark (name, stabilized) VALUES (?, ?)
-                ON CONFLICT (name) do update set stabilized = excluded.stabilized",
-                    params![benchmark, stable],
+                    "insert into benchmark (name, stabilized, category) VALUES (?, ?, ?)
+                ON CONFLICT (name) do update set stabilized = excluded.stabilized, category = excluded.category",
+                    params![benchmark, stable, category],
                 )
                 .unwrap();
         } else {
             self.raw_ref()
                 .execute(
-                    "insert into benchmark (name, stabilized) VALUES (?, ?)
-                ON CONFLICT DO NOTHING",
-                    params![benchmark, false],
+                    "insert into benchmark (name, stabilized, category) VALUES (?, ?, ?)
+                ON CONFLICT (name) do update set category = excluded.category",
+                    params![benchmark, false, category],
                 )
                 .unwrap();
         }