Add target column, defaulting to x86_64-unknown-linux-gnu

collector/src/bin/collector.rs

@@ -35,6 +35,7 @@ use collector::artifact_stats::{
 use collector::codegen::{codegen_diff, CodegenType};
 use collector::compile::benchmark::category::Category;
 use collector::compile::benchmark::codegen_backend::CodegenBackend;
+use collector::compile::benchmark::target::Target;
 use collector::compile::benchmark::profile::Profile;
 use collector::compile::benchmark::scenario::Scenario;
 use collector::compile::benchmark::{
@@ -99,6 +100,7 @@ struct CompileBenchmarkConfig {
     iterations: Option<usize>,
     is_self_profile: bool,
     bench_rustc: bool,
+    targets: Vec<Target>,
 }
 
 struct RuntimeBenchmarkConfig {
@@ -200,6 +202,7 @@ fn profile_compile(
     scenarios: &[Scenario],
     backends: &[CodegenBackend],
     errors: &mut BenchmarkErrors,
+    targets: &[Target]
 ) {
     eprintln!("Profiling {} with {:?}", toolchain.id, profiler);
     if let Profiler::SelfProfile = profiler {
@@ -220,6 +223,7 @@ fn profile_compile(
                 backends,
                 toolchain,
                 Some(1),
+                targets,
             ));
             eprintln!("Finished benchmark {benchmark_id}");
 
@@ -910,6 +914,7 @@ fn main_result() -> anyhow::Result<i32> {
                 iterations: Some(iterations),
                 is_self_profile: self_profile.self_profile,
                 bench_rustc: bench_rustc.bench_rustc,
+                targets: vec![Target::default()],
             };
 
             run_benchmarks(&mut rt, conn, shared, Some(config), None)?;
@@ -1024,6 +1029,7 @@ fn main_result() -> anyhow::Result<i32> {
                             iterations: runs.map(|v| v as usize),
                             is_self_profile: self_profile.self_profile,
                             bench_rustc: bench_rustc.bench_rustc,
+                            targets: vec![Target::default()],
                         };
                         let runtime_suite = rt.block_on(load_runtime_benchmarks(
                             conn.as_mut(),
@@ -1136,6 +1142,7 @@ fn main_result() -> anyhow::Result<i32> {
                         scenarios,
                         backends,
                         &mut errors,
+                        &[Target::default()],
                     );
                     Ok(id)
                 };
@@ -1734,6 +1741,7 @@ fn bench_published_artifact(
             iterations: Some(3),
             is_self_profile: false,
             bench_rustc: false,
+            targets: vec![Target::default()],
         }),
         Some(RuntimeBenchmarkConfig::new(
             runtime_suite,
@@ -1834,6 +1842,7 @@ fn bench_compile(
                     &config.backends,
                     &shared.toolchain,
                     config.iterations,
+                    &config.targets,
                 )))
                 .with_context(|| anyhow::anyhow!("Cannot compile {}", benchmark.name))
             },

collector/src/compile/benchmark/mod.rs

@@ -3,6 +3,7 @@ use crate::compile::benchmark::codegen_backend::CodegenBackend;
 use crate::compile::benchmark::patch::Patch;
 use crate::compile::benchmark::profile::Profile;
 use crate::compile::benchmark::scenario::Scenario;
+use crate::compile::benchmark::target::Target;
 use crate::compile::execute::{CargoProcess, Processor};
 use crate::toolchain::Toolchain;
 use crate::utils::wait_for_future;
@@ -20,6 +21,7 @@ pub mod codegen_backend;
 pub(crate) mod patch;
 pub mod profile;
 pub mod scenario;
+pub mod target;
 
 fn default_runs() -> usize {
     3
@@ -180,6 +182,7 @@ impl Benchmark {
         cwd: &'a Path,
         profile: Profile,
         backend: CodegenBackend,
+        target: Target,
     ) -> CargoProcess<'a> {
         let mut cargo_args = self
             .config
@@ -220,6 +223,7 @@ impl Benchmark {
                 .collect(),
             touch_file: self.config.touch_file.clone(),
             jobserver: None,
+            target,
         }
     }
 
@@ -232,6 +236,7 @@ impl Benchmark {
         backends: &[CodegenBackend],
         toolchain: &Toolchain,
         iterations: Option<usize>,
+        targets: &[Target]
     ) -> anyhow::Result<()> {
         if self.config.disabled {
             eprintln!("Skipping {}: disabled", self.name);
@@ -263,10 +268,12 @@ impl Benchmark {
         }
 
         eprintln!("Preparing {}", self.name);
-        let mut target_dirs: Vec<((CodegenBackend, Profile), TempDir)> = vec![];
+        let mut target_dirs: Vec<((CodegenBackend, Profile, Target), TempDir)> = vec![];
         for backend in backends {
             for profile in &profiles {
-                target_dirs.push(((*backend, *profile), self.make_temp_dir(&self.path)?));
+                for target in targets {
+                    target_dirs.push(((*backend, *profile, *target), self.make_temp_dir(&self.path)?));
+                }
             }
         }
 
@@ -304,12 +311,12 @@ impl Benchmark {
             )
             .context("jobserver::new")?;
             let mut threads = Vec::with_capacity(target_dirs.len());
-            for ((backend, profile), prep_dir) in &target_dirs {
+            for ((backend, profile, target), prep_dir) in &target_dirs {
                 let server = server.clone();
                 let thread = s.spawn::<_, anyhow::Result<()>>(move || {
                     wait_for_future(async move {
                         let server = server.clone();
-                        self.mk_cargo_process(toolchain, prep_dir.path(), *profile, *backend)
+                        self.mk_cargo_process(toolchain, prep_dir.path(), *profile, *backend, *target)
                             .jobserver(server)
                             .run_rustc(false)
                             .await?;
@@ -343,12 +350,13 @@ impl Benchmark {
         let mut timing_dirs: Vec<ManuallyDrop<TempDir>> = vec![];
 
         let benchmark_start = std::time::Instant::now();
-        for ((backend, profile), prep_dir) in &target_dirs {
+        for ((backend, profile, target), prep_dir) in &target_dirs {
             let backend = *backend;
             let profile = *profile;
+            let target = *target;
             eprintln!(
-                "Running {}: {:?} + {:?} + {:?}",
-                self.name, profile, scenarios, backend
+                "Running {}: {:?} + {:?} + {:?} + {:?}",
+                self.name, profile, scenarios, backend, target,
             );
 
             // We want at least two runs for all benchmarks (since we run
@@ -370,7 +378,7 @@ impl Benchmark {
 
                 // A full non-incremental build.
                 if scenarios.contains(&Scenario::Full) {
-                    self.mk_cargo_process(toolchain, cwd, profile, backend)
+                    self.mk_cargo_process(toolchain, cwd, profile, backend, target)
                         .processor(processor, Scenario::Full, "Full", None)
                         .run_rustc(true)
                         .await?;
@@ -381,7 +389,7 @@ impl Benchmark {
                     // An incremental  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)
+                        self.mk_cargo_process(toolchain, cwd, profile, backend, target)
                             .incremental(true)
                             .processor(processor, Scenario::IncrFull, "IncrFull", None)
                             .run_rustc(true)
@@ -390,7 +398,7 @@ impl Benchmark {
 
                     // An incremental build with no changes (fastest incremental case).
                     if scenarios.contains(&Scenario::IncrUnchanged) {
-                        self.mk_cargo_process(toolchain, cwd, profile, backend)
+                        self.mk_cargo_process(toolchain, cwd, profile, backend, target)
                             .incremental(true)
                             .processor(processor, Scenario::IncrUnchanged, "IncrUnchanged", None)
                             .run_rustc(true)
@@ -405,7 +413,7 @@ impl Benchmark {
                             // An incremental build with some changes (realistic
                             // incremental case).
                             let scenario_str = format!("IncrPatched{}", i);
-                            self.mk_cargo_process(toolchain, cwd, profile, backend)
+                            self.mk_cargo_process(toolchain, cwd, profile, backend, target)
                                 .incremental(true)
                                 .processor(
                                     processor,

collector/src/compile/benchmark/target.rs

@@ -0,0 +1,16 @@
+/// Target representing an Rust target tripple, for a full list of targets and 
+/// their support see;
+/// https://doc.rust-lang.org/nightly/rustc/platform-support.html
+///
+/// Presently we only support x86_64
+#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq, serde::Deserialize)]
+pub enum Target {
+    /// `x86_64-unknown-linux-gnu`
+    X86_64UnknownLinuxGnu
+}
+
+ impl Default for Target {
+    fn default() -> Self {
+        Self::X86_64UnknownLinuxGnu
+   }
+}

collector/src/compile/execute/bencher.rs

@@ -1,6 +1,7 @@
 use crate::compile::benchmark::codegen_backend::CodegenBackend;
 use crate::compile::benchmark::profile::Profile;
 use crate::compile::benchmark::scenario::Scenario;
+use crate::compile::benchmark::target::Target;
 use crate::compile::benchmark::BenchmarkName;
 use crate::compile::execute;
 use crate::compile::execute::{
@@ -91,13 +92,18 @@ impl<'a> BenchProcessor<'a> {
         scenario: database::Scenario,
         profile: database::Profile,
         backend: CodegenBackend,
+        target: Target,
         stats: Stats,
     ) {
         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 mut buf = FuturesUnordered::new();
         for (stat, value) in stats.iter() {
             buf.push(self.conn.record_statistic(
@@ -107,6 +113,7 @@ impl<'a> BenchProcessor<'a> {
                 profile,
                 scenario,
                 backend,
+                target,
                 stat,
                 value,
             ));
@@ -199,7 +206,7 @@ impl Processor for BenchProcessor<'_> {
                         res.0.stats.retain(|key, _| key.starts_with("size:"));
                     }
 
-                    self.insert_stats(collection, scenario, profile, data.backend, res.0)
+                    self.insert_stats(collection, scenario, profile, data.backend, data.target, res.0)
                         .await;
 
                     Ok(Retry::No)

collector/src/compile/execute/mod.rs

@@ -4,6 +4,7 @@ use crate::compile::benchmark::codegen_backend::CodegenBackend;
 use crate::compile::benchmark::patch::Patch;
 use crate::compile::benchmark::profile::Profile;
 use crate::compile::benchmark::scenario::Scenario;
+use crate::compile::benchmark::target::Target;
 use crate::compile::benchmark::BenchmarkName;
 use crate::toolchain::Toolchain;
 use crate::utils::fs::EnsureImmutableFile;
@@ -129,6 +130,7 @@ pub struct CargoProcess<'a> {
     pub rustc_args: Vec<String>,
     pub touch_file: Option<String>,
     pub jobserver: Option<jobserver::Client>,
+    pub target: Target,
 }
 /// Returns an optional list of Performance CPU cores, if the system has P and E cores.
 /// This list *should* be in a format suitable for the `taskset` command.
@@ -273,12 +275,13 @@ impl<'a> CargoProcess<'a> {
     // really.
     pub async fn run_rustc(&mut self, needs_final: bool) -> anyhow::Result<()> {
         log::info!(
-            "run_rustc with incremental={}, profile={:?}, scenario={:?}, patch={:?}, backend={:?}, phase={}",
+            "run_rustc with incremental={}, profile={:?}, scenario={:?}, patch={:?}, backend={:?}, target={:?}, phase={}",
             self.incremental,
             self.profile,
             self.processor_etc.as_ref().map(|v| v.1),
             self.processor_etc.as_ref().and_then(|v| v.3),
             self.backend,
+            self.target,
             if needs_final { "benchmark" } else { "dependencies" }
         );
 
@@ -420,6 +423,7 @@ impl<'a> CargoProcess<'a> {
                     scenario_str,
                     patch,
                     backend: self.backend,
+                    target: self.target,
                 };
                 match processor.process_output(&data, output).await {
                     Ok(Retry::No) => return Ok(()),
@@ -484,6 +488,7 @@ pub struct ProcessOutputData<'a> {
     scenario_str: &'a str,
     patch: Option<&'a Patch>,
     backend: CodegenBackend,
+    target: Target,
 }
 
 /// Trait used by `Benchmark::measure()` to provide different kinds of

database/schema.md

@@ -35,6 +35,7 @@ Here is the diagram for compile-time benchmarks:
   │ scenario      │  │ cid      │   │
   │ backend       │  │ value    ├───┘
   │ metric        │  └──────────┘
+  │ target        │
   └───────────────┘
 ```
 
@@ -151,9 +152,9 @@ many times in the `pstat` table.
 
 ```
 sqlite> select * from pstat_series limit 1;
-id          crate       profile     scenario    backend  metric
-----------  ----------  ----------  ----------  -------  ------------
-1           helloworld  check       full        llvm     task-clock:u
+id          crate       profile     scenario    backend  metric        target
+----------  ----------  ----------  ----------  -------  ------------  ------------
+1           helloworld  check       full        llvm     task-clock:u  x86_64-linux-unknown-gnu
 ```
 
 ### pstat

database/src/bin/import-sqlite.rs

@@ -45,7 +45,7 @@ async fn main() {
         let sqlite_aid = sqlite_conn.artifact_id(&aid).await;
         let postgres_aid = postgres_conn.artifact_id(&aid).await;
 
-        for (&(benchmark, profile, scenario, backend, metric), id) in
+        for (&(benchmark, profile, scenario, backend, target, metric), id) in
             sqlite_idx.compile_statistic_descriptions()
         {
             if benchmarks.insert(benchmark) {
@@ -74,6 +74,7 @@ async fn main() {
                         profile,
                         scenario,
                         backend,
+                        target,
                         metric.as_str(),
                         stat,
                     )

database/src/bin/postgres-to-sqlite.rs

@@ -246,11 +246,11 @@ impl Table for PstatSeries {
     }
 
     fn postgres_select_statement(&self, _since_weeks_ago: Option<u32>) -> String {
-        "select id, crate, profile, scenario, backend, metric from ".to_string() + self.name()
+        "select id, crate, profile, scenario, backend, target, metric from ".to_string() + self.name()
     }
 
     fn sqlite_insert_statement(&self) -> &'static str {
-        "insert into pstat_series (id, crate, profile, scenario, backend, metric) VALUES (?, ?, ?, ?, ?, ?)"
+        "insert into pstat_series (id, crate, profile, scenario, backend, target, metric) VALUES (?, ?, ?, ?, ?, ?, ?)"
     }
 
     fn sqlite_execute_insert(&self, statement: &mut rusqlite::Statement, row: tokio_postgres::Row) {
@@ -262,6 +262,7 @@ impl Table for PstatSeries {
                 row.get::<_, &str>(3),
                 row.get::<_, &str>(4),
                 row.get::<_, &str>(5),
+                row.get::<_, &str>(6),
             ])
             .unwrap();
     }

database/src/bin/sqlite-to-postgres.rs

@@ -322,6 +322,7 @@ struct PstatSeriesRow<'a> {
     profile: &'a str,
     scenario: &'a str,
     backend: &'a str,
+    target: &'a str,
     metric: &'a str,
 }
 
@@ -331,11 +332,11 @@ impl Table for PstatSeries {
     }
 
     fn sqlite_attributes() -> &'static str {
-        "id, crate, profile, scenario, backend, metric"
+        "id, crate, profile, scenario, backend, target, metric"
     }
 
     fn postgres_attributes() -> &'static str {
-        "id, crate, profile, scenario, backend, metric"
+        "id, crate, profile, scenario, backend, target, metric"
     }
 
     fn postgres_generated_id_attribute() -> Option<&'static str> {
@@ -350,7 +351,8 @@ impl Table for PstatSeries {
                 profile: row.get_ref(2).unwrap().as_str().unwrap(),
                 scenario: row.get_ref(3).unwrap().as_str().unwrap(),
                 backend: row.get_ref(4).unwrap().as_str().unwrap(),
-                metric: row.get_ref(5).unwrap().as_str().unwrap(),
+                target: row.get_ref(5).unwrap().as_str().unwrap(),
+                metric: row.get_ref(6).unwrap().as_str().unwrap(),
             })
             .unwrap();
     }