Add option to filter compile benchmarks based on the artifact that they produce (binary/library)

Author: Kobzol

site/frontend/src/pages/compare/compile/common.ts

@@ -18,6 +18,10 @@ export type CompileBenchmarkFilter = {
     primary: boolean;
     secondary: boolean;
   };
+  artifact: {
+    binary: boolean;
+    library: boolean;
+  };
 } & BenchmarkFilter;
 export const defaultCompileFilter: CompileBenchmarkFilter = {
   name: null,
@@ -39,16 +43,21 @@ export const defaultCompileFilter: CompileBenchmarkFilter = {
     primary: true,
     secondary: true,
   },
+  artifact: {
+    binary: true,
+    library: true,
+  },
 };
 
 export type Profile = "check" | "debug" | "opt" | "doc";
 export type Category = "primary" | "secondary";
 
-export type CompileBenchmarkMap = Dict<{category: Category}>;
+export type CompileBenchmarkMap = Dict<CompileBenchmarkMetadata>;
 
-export interface CompileBenchmarkDescription {
+export interface CompileBenchmarkMetadata {
   name: string;
   category: Category;
+  binary: boolean | null;
 }
 
 export interface CompileBenchmarkComparison {
@@ -99,6 +108,17 @@ export function computeCompileComparisonsWithNonRelevant(
     }
   }
 
+  function artifactFilter(metadata: CompileBenchmarkMetadata | null): boolean {
+    if (metadata?.binary === null) return true;
+
+    const isBinary = metadata.binary;
+    const isLibrary = !isBinary;
+    if (isBinary && !filter.artifact.binary) return false;
+    if (isLibrary && !filter.artifact.library) return false;
+
+    return true;
+  }
+
   function categoryFilter(category: Category) {
     if (category === "primary" && !filter.category.primary) return false;
     if (category === "secondary" && !filter.category.secondary) return false;
@@ -114,6 +134,7 @@ export function computeCompileComparisonsWithNonRelevant(
       profileFilter(comparison.testCase.profile) &&
       scenarioFilter(comparison.testCase.scenario) &&
       categoryFilter(comparison.testCase.category) &&
+      artifactFilter(benchmarkMap[comparison.testCase.benchmark] ?? null) &&
       nameFiltered
     );
   }
@@ -147,10 +168,8 @@ export function createCompileBenchmarkMap(
   data: CompareResponse
 ): CompileBenchmarkMap {
   const benchmarks = {};
-  for (const benchmark of data.compile_benchmark_data) {
-    benchmarks[benchmark.name] = {
-      category: benchmark.category,
-    };
+  for (const benchmark of data.compile_benchmark_metadata) {
+    benchmarks[benchmark.name] = {...benchmark};
   }
   return benchmarks;
 }

site/frontend/src/pages/compare/compile/compile-page.vue

@@ -64,6 +64,10 @@ function loadFilterFromUrl(
         defaultFilter.category.secondary
       ),
     },
+    artifact: {
+      binary: getBoolOrDefault("binary", defaultFilter.artifact.binary),
+      library: getBoolOrDefault("library", defaultFilter.artifact.library),
+    },
   };
 }
 
@@ -123,6 +127,12 @@ function storeFilterToUrl(
     filter.category.secondary,
     defaultFilter.category.secondary
   );
+  storeOrReset("binary", filter.artifact.binary, defaultFilter.artifact.binary);
+  storeOrReset(
+    "library",
+    filter.artifact.library,
+    defaultFilter.artifact.library
+  );
 
   changeUrl(urlParams);
 }

site/frontend/src/pages/compare/compile/filters.vue

@@ -203,6 +203,31 @@ const opened = createPersistedRef(PREF_FILTERS_OPENED);
               </li>
             </ul>
           </div>
+          <div class="section section-list-wrapper">
+            <div class="section-heading">
+              <div style="width: 160px">
+                <span>Artifacts</span>
+                <Tooltip>
+                  Select benchmarks based on the artifact that they produce
+                  (either a binary or a library).
+                </Tooltip>
+              </div>
+            </div>
+            <ul class="states-list">
+              <li>
+                <label>
+                  <input type="checkbox" v-model="filter.artifact.binary" />
+                  <span class="cache-label">binary</span>
+                </label>
+              </li>
+              <li>
+                <label>
+                  <input type="checkbox" v-model="filter.artifact.library" />
+                  <span class="cache-label">library</span>
+                </label>
+              </li>
+            </ul>
+          </div>
           <div class="section">
             <div class="section-heading">
               <span>Show non-relevant results</span>

site/frontend/src/pages/compare/types.ts

@@ -1,6 +1,6 @@
 import {
   CompileBenchmarkComparison,
-  CompileBenchmarkDescription,
+  CompileBenchmarkMetadata,
 } from "./compile/common";
 import {RuntimeBenchmarkComparison} from "./runtime/common";
 
@@ -42,7 +42,7 @@ export interface CompareResponse {
   new_errors: Array<[string, string]>;
 
   compile_comparisons: CompileBenchmarkComparison[];
-  compile_benchmark_data: CompileBenchmarkDescription[];
+  compile_benchmark_metadata: CompileBenchmarkMetadata[];
 
   runtime_comparisons: RuntimeBenchmarkComparison[];
 }

site/src/api.rs

@@ -133,7 +133,7 @@ pub mod bootstrap {
 pub mod comparison {
     use crate::comparison::Metric;
     use collector::Bound;
-    use database::{CompileBenchmark, Date};
+    use database::Date;
     use serde::{Deserialize, Serialize};
     use std::collections::HashMap;
 
@@ -145,18 +145,14 @@ pub mod comparison {
     }
 
     #[derive(Debug, Clone, Serialize, Deserialize)]
-    pub struct BenchmarkInfo {
+    pub struct CompileBenchmarkMetadata {
         pub name: String,
         pub category: String,
-    }
-
-    impl From<CompileBenchmark> for BenchmarkInfo {
-        fn from(data: CompileBenchmark) -> Self {
-            Self {
-                name: data.name,
-                category: data.category,
-            }
-        }
+        // We need to keep the data below as optional, because we get the data from information
+        // gathered from the actual state of the compile benchmarks. But if we remove a compile
+        // benchmark, the metadata for it will no longer be available, so we might not always have
+        // access to the metadata.
+        pub binary: Option<bool>,
     }
 
     #[derive(Debug, Clone, Serialize)]
@@ -174,10 +170,10 @@ pub mod comparison {
         /// The names for the next artifact after `b`, if any.
         pub next: Option<String>,
 
-        /// If `a` and `b` are adjacent artifacts (i.e., `a` is the parent of
-        /// `b`).
+        /// If `a` and `b` are adjacent artifacts (i.e., `a` is the parent of `b`).
         pub is_contiguous: bool,
-        pub compile_benchmark_data: Vec<BenchmarkInfo>,
+
+        pub compile_benchmark_metadata: Vec<CompileBenchmarkMetadata>,
     }
 
     #[derive(Debug, Clone, Serialize)]

site/src/comparison.rs

@@ -14,8 +14,11 @@ use collector::compile::benchmark::category::Category;
 use collector::Bound;
 use serde::{Deserialize, Serialize};
 
+use crate::api::comparison::CompileBenchmarkMetadata;
+use crate::benchmark_metadata::get_compile_benchmarks_metadata;
 use crate::server::comparison::StatComparison;
-use database::CommitType;
+use collector::compile::benchmark::ArtifactType;
+use database::{CommitType, CompileBenchmark};
 use serde::de::IntoDeserializer;
 use std::cmp;
 use std::collections::{HashMap, HashSet};
@@ -167,6 +170,23 @@ pub async fn handle_compare(
         .into_iter()
         .collect::<Vec<_>>();
     new_errors.sort();
+
+    let compile_metadata = get_compile_benchmarks_metadata();
+    // Enrich data from the DB with metadata generated by the build script
+    let compile_benchmark_metadata = compile_benchmark_map
+        .into_iter()
+        .map(|benchmark| {
+            let CompileBenchmark { name, category } = benchmark;
+            let metadata = compile_metadata.get(&name);
+
+            CompileBenchmarkMetadata {
+                name,
+                category,
+                binary: metadata.map(|m| m.perf_config.artifact() == ArtifactType::Binary),
+            }
+        })
+        .collect();
+
     Ok(api::comparison::Response {
         prev,
         a: comparison.a.into(),
@@ -176,10 +196,7 @@ pub async fn handle_compare(
         new_errors,
         next,
         is_contiguous,
-        compile_benchmark_data: compile_benchmark_map
-            .into_iter()
-            .map(|bench| bench.into())
-            .collect(),
+        compile_benchmark_metadata,
     })
 }