Stor

Author: Kobzol

collector/src/execute.rs

@@ -4,7 +4,7 @@ use crate::{Compiler, Profile, Scenario};
 use anyhow::{bail, Context};
 use collector::command_output;
 use collector::etw_parser;
-use database::{PatchName, QueryLabel};
+use database::{Category, PatchName, QueryLabel};
 use futures::stream::FuturesUnordered;
 use futures::stream::StreamExt;
 use std::collections::HashMap;
@@ -110,27 +110,6 @@ fn default_runs() -> usize {
     3
 }
 
-#[derive(Debug, Clone, serde::Deserialize)]
-#[serde(rename_all = "lowercase")]
-pub enum Category {
-    Primary,
-    Secondary,
-}
-
-impl Default for Category {
-    fn default() -> Self {
-        Self::Secondary
-    }
-}
-
-impl fmt::Display for Category {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match self {
-            Category::Primary => f.write_str("primary"),
-            Category::Secondary => f.write_str("secondary"),
-        }
-    }
-}
 /// This is the internal representation of an individual benchmark's
 /// perf-config.json file.
 #[derive(Debug, Clone, serde::Deserialize)]

collector/src/main.rs

@@ -2,7 +2,7 @@
 
 use anyhow::{bail, Context};
 use clap::Parser;
-use database::{ArtifactId, Commit};
+use database::{ArtifactId, Category, Commit};
 use log::debug;
 use std::collections::HashSet;
 use std::fs;
@@ -15,7 +15,6 @@ use tokio::runtime::Runtime;
 mod execute;
 mod sysroot;
 
-use crate::execute::Category;
 use execute::{BenchProcessor, Benchmark, BenchmarkName, ProfileProcessor, Profiler};
 use sysroot::Sysroot;
 
@@ -189,7 +188,7 @@ fn bench(
     let mut measure_and_record =
         |benchmark_name: &BenchmarkName,
          benchmark_supports_stable: bool,
-         benchmark_category: &str,
+         benchmark_category: Category,
          print_intro: &dyn Fn(),
          measure: &dyn Fn(&mut BenchProcessor) -> anyhow::Result<()>| {
             let is_fresh =
@@ -240,7 +239,7 @@ fn bench(
         measure_and_record(
             &benchmark.name,
             benchmark.supports_stable(),
-            &benchmark.category().to_string(),
+            benchmark.category().clone(),
             &|| {
                 eprintln!(
                     "{}",
@@ -256,7 +255,7 @@ fn bench(
         measure_and_record(
             &BenchmarkName("rustc".to_string()),
             /* supports_stable */ false,
-            &Category::Primary.to_string(),
+            Category::Primary,
             &|| eprintln!("Special benchmark commencing (due to `--bench-rustc`)"),
             &|processor| processor.measure_rustc(compiler).context("measure rustc"),
         );

database/src/bin/import-sqlite.rs

@@ -1,4 +1,4 @@
-use database::{Lookup, Pool};
+use database::{Category, Lookup, Pool};
 use std::collections::HashSet;
 
 #[tokio::main]
@@ -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, "") // TODO
+                    .record_benchmark(benchmark.as_str(), None, Category::Secondary)
                     .await;
             }
 

database/src/lib.rs

@@ -767,5 +767,38 @@ impl fmt::Display for CollectionId {
 #[derive(Debug, Clone, Serialize)]
 pub struct BenchmarkData {
     name: String,
-    category: String,
+    category: Category,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "lowercase")]
+pub enum Category {
+    Primary,
+    Secondary,
+}
+
+impl Default for Category {
+    fn default() -> Self {
+        Self::Secondary
+    }
+}
+
+impl fmt::Display for Category {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Category::Primary => f.write_str("primary"),
+            Category::Secondary => f.write_str("secondary"),
+        }
+    }
+}
+impl std::str::FromStr for Category {
+    type Err = anyhow::Error;
+
+    fn from_str(input: &str) -> Result<Self, Self::Err> {
+        match input {
+            "primary" => Ok(Category::Primary),
+            "secondary" => Ok(Category::Primary),
+            _ => Err(anyhow::anyhow!("Invalid category {input}")),
+        }
+    }
 }

database/src/pool.rs

@@ -1,4 +1,4 @@
-use crate::{ArtifactId, ArtifactIdNumber, BenchmarkData};
+use crate::{ArtifactId, ArtifactIdNumber, BenchmarkData, Category};
 use crate::{CollectionId, Index, Profile, QueryDatum, QueuedCommit, Scenario, Step};
 use chrono::{DateTime, Utc};
 use hashbrown::HashMap;
@@ -27,7 +27,12 @@ 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>, category: &str);
+    async fn record_benchmark(
+        &self,
+        krate: &str,
+        supports_stable: Option<bool>,
+        category: Category,
+    );
     async fn record_statistic(
         &self,
         collection: CollectionId,

database/src/pool/postgres.rs

@@ -1,14 +1,15 @@
 use crate::pool::{Connection, ConnectionManager, ManagedConnection, Transaction};
 use crate::{
-    ArtifactId, ArtifactIdNumber, Benchmark, BenchmarkData, CollectionId, Commit, Date, Index,
-    Profile, QueuedCommit, Scenario,
+    ArtifactId, ArtifactIdNumber, Benchmark, BenchmarkData, Category, CollectionId, Commit, Date,
+    Index, Profile, QueuedCommit, Scenario,
 };
 use anyhow::Context as _;
 use chrono::{DateTime, TimeZone, Utc};
 use hashbrown::HashMap;
 use native_tls::{Certificate, TlsConnector};
 use postgres_native_tls::MakeTlsConnector;
 use std::convert::TryFrom;
+use std::str::FromStr;
 use std::sync::Arc;
 use std::time::Duration;
 use tokio_postgres::GenericClient;
@@ -611,7 +612,10 @@ where
             .map(|r| {
                 let name: String = r.get(0);
                 let category: String = r.get(1);
-                BenchmarkData { name, category }
+                BenchmarkData {
+                    name,
+                    category: Category::from_str(&category).unwrap(),
+                }
             })
             .collect()
     }
@@ -990,8 +994,9 @@ where
         &self,
         benchmark: &str,
         supports_stable: Option<bool>,
-        category: &str,
+        category: Category,
     ) {
+        let category = category.to_string();
         if let Some(r) = self
             .conn()
             .query_opt(

database/src/pool/sqlite.rs

@@ -1,12 +1,13 @@
 use crate::pool::{Connection, ConnectionManager, ManagedConnection, Transaction};
-use crate::{ArtifactId, Benchmark, BenchmarkData, CollectionId, Commit, Date, Profile};
+use crate::{ArtifactId, Benchmark, BenchmarkData, Category, CollectionId, Commit, Date, Profile};
 use crate::{ArtifactIdNumber, Index, QueryDatum, QueuedCommit};
 use chrono::{DateTime, TimeZone, Utc};
 use hashbrown::HashMap;
 use rusqlite::params;
 use rusqlite::OptionalExtension;
 use std::convert::TryFrom;
 use std::path::PathBuf;
+use std::str::FromStr;
 use std::sync::Mutex;
 use std::sync::Once;
 use std::time::Duration;
@@ -513,7 +514,7 @@ impl Connection for SqliteConnection {
             .query_map([], |row| {
                 Ok(BenchmarkData {
                     name: row.get(0)?,
-                    category: row.get(1)?,
+                    category: Category::from_str(&row.get::<_, String>(1)?).unwrap(),
                 })
             })
             .unwrap();
@@ -888,8 +889,9 @@ impl Connection for SqliteConnection {
         &self,
         benchmark: &str,
         supports_stable: Option<bool>,
-        category: &str,
+        category: Category,
     ) {
+        let category = category.to_string();
         if let Some(stable) = supports_stable {
             self.raw_ref()
                 .execute(