Implement conversions from collector benchmark parameters to database benchmark parameters

Author: Kobzol

collector/src/compile/benchmark/codegen_backend.rs

@@ -10,3 +10,12 @@ impl CodegenBackend {
         vec![CodegenBackend::Llvm, CodegenBackend::Cranelift]
     }
 }
+
+impl From<CodegenBackend> for database::CodegenBackend {
+    fn from(value: CodegenBackend) -> Self {
+        match value {
+            CodegenBackend::Llvm => database::CodegenBackend::Llvm,
+            CodegenBackend::Cranelift => database::CodegenBackend::Cranelift,
+        }
+    }
+}

collector/src/compile/benchmark/mod.rs

@@ -334,11 +334,7 @@ impl Benchmark {
             return Ok(());
         }
 
-        eprintln!(
-            "Preparing {} (test cases: {})",
-            self.name,
-            benchmark_dirs.len()
-        );
+        eprintln!("Preparing {}", self.name);
 
         // In parallel (but with a limit to the number of CPUs), prepare all
         // profiles. This is done in parallel vs. sequentially because:
@@ -456,7 +452,7 @@ impl Benchmark {
 
                 // Rustdoc does not support incremental compilation
                 if !profile.is_doc() {
-                    // An incremental  from scratch (slowest incremental case).
+                    // An incremental build from scratch (slowest incremental case).
                     // This is required for any subsequent incremental builds.
                     if scenarios.iter().any(|s| s.is_incr()) {
                         self.mk_cargo_process(toolchain, cwd, profile, backend, target)
@@ -529,21 +525,9 @@ impl Benchmark {
         }
 
         let benchmark = database::Benchmark::from(self.name.0.as_str());
-        let profile = match profile {
-            Profile::Check => database::Profile::Check,
-            Profile::Debug => database::Profile::Debug,
-            Profile::Doc => database::Profile::Doc,
-            Profile::DocJson => database::Profile::DocJson,
-            Profile::Opt => database::Profile::Opt,
-            Profile::Clippy => database::Profile::Clippy,
-        };
-        let backend = match backend {
-            CodegenBackend::Llvm => database::CodegenBackend::Llvm,
-            CodegenBackend::Cranelift => database::CodegenBackend::Cranelift,
-        };
-        let target = match target {
-            Target::X86_64UnknownLinuxGnu => database::Target::X86_64UnknownLinuxGnu,
-        };
+        let profile: database::Profile = (*profile).into();
+        let backend: database::CodegenBackend = (*backend).into();
+        let target: database::Target = (*target).into();
 
         match scenario {
             // For these scenarios, we can simply check if they were benchmarked or not

collector/src/compile/benchmark/profile.rs

@@ -41,3 +41,16 @@ impl Profile {
         }
     }
 }
+
+impl From<Profile> for database::Profile {
+    fn from(value: Profile) -> Self {
+        match value {
+            Profile::Check => database::Profile::Check,
+            Profile::Debug => database::Profile::Debug,
+            Profile::Doc => database::Profile::Doc,
+            Profile::DocJson => database::Profile::DocJson,
+            Profile::Opt => database::Profile::Opt,
+            Profile::Clippy => database::Profile::Clippy,
+        }
+    }
+}

collector/src/compile/benchmark/target.rs

@@ -19,10 +19,20 @@ impl Target {
     pub fn all() -> Vec<Self> {
         vec![Self::X86_64UnknownLinuxGnu]
     }
+}
 
-    pub fn from_db_target(target: &database::Target) -> Target {
-        match target {
+impl From<database::Target> for Target {
+    fn from(value: database::Target) -> Self {
+        match value {
             database::Target::X86_64UnknownLinuxGnu => Self::X86_64UnknownLinuxGnu,
         }
     }
 }
+
+impl From<Target> for database::Target {
+    fn from(value: Target) -> Self {
+        match value {
+            Target::X86_64UnknownLinuxGnu => database::Target::X86_64UnknownLinuxGnu,
+        }
+    }
+}

site/src/job_queue/mod.rs

@@ -197,9 +197,7 @@ pub async fn enqueue_benchmark_request(
 
     // Target x benchmark_set x backend x profile -> BenchmarkJob
     for target in Target::all() {
-        for benchmark_set in 0..benchmark_set_count(
-            collector::compile::benchmark::target::Target::from_db_target(&target),
-        ) {
+        for benchmark_set in 0..benchmark_set_count(target.into()) {
             for backend in backends.iter() {
                 for profile in profiles.iter() {
                     tx.conn()