Rename DateDate to ArtifactData

rylev · rylev · commit d05d0a7d1fac · 2021-07-09T10:56:13.000+02:00
diff --git a/site/src/api.rs b/site/src/api.rs
@@ -80,7 +80,7 @@ pub struct CommitResponse {
 }
 
 pub mod data {
-    use crate::comparison::DateData;
+    use crate::comparison::ArtifactData;
     use collector::Bound;
     use serde::{Deserialize, Serialize};
 
@@ -95,7 +95,7 @@ pub mod data {
 
     /// List of DateData's from oldest to newest
     #[derive(Debug, Clone, Serialize)]
-    pub struct Response(pub Vec<DateData>);
+    pub struct Response(pub Vec<ArtifactData>);
 }
 
 pub mod graph {
@@ -165,10 +165,11 @@ pub mod bootstrap {
     }
 }
 
-pub mod days {
-    use crate::comparison::DateData;
+pub mod comparison {
     use collector::Bound;
+    use database::Date;
     use serde::{Deserialize, Serialize};
+    use std::collections::HashMap;
 
     #[derive(Debug, PartialEq, Clone, Serialize, Deserialize)]
     pub struct Request {
@@ -183,8 +184,8 @@ pub mod days {
         /// The names for the previous artifact before `a`, if any.
         pub prev: Option<String>,
 
-        pub a: DateData,
-        pub b: DateData,
+        pub a: ArtifactData,
+        pub b: ArtifactData,
 
         /// The names for the next artifact after `b`, if any.
         pub next: Option<String>,
@@ -193,6 +194,16 @@ pub mod days {
         /// `b`).
         pub is_contiguous: bool,
     }
+
+    /// A serializable wrapper for `comparison::ArtifactData`
+    #[derive(Debug, Clone, Serialize)]
+    pub struct ArtifactData {
+        pub commit: String,
+        pub date: Option<Date>,
+        pub pr: Option<u32>,
+        pub data: HashMap<String, Vec<(String, f64)>>,
+        pub bootstrap: HashMap<String, u64>,
+    }
 }
 
 pub mod status {
diff --git a/site/src/comparison.rs b/site/src/comparison.rs
@@ -8,7 +8,6 @@ use crate::load::InputData;
 use crate::selector::{self, Tag};
 
 use collector::Bound;
-use database::Date;
 use serde::Serialize;
 
 use std::collections::HashMap;
@@ -60,8 +59,8 @@ pub async fn handle_triage(
         };
         log::info!(
             "Comparing {} to {}",
-            comparison.b.commit,
-            comparison.a.commit
+            comparison.b.artifact,
+            comparison.a.artifact
         );
 
         // handle results of comparison
@@ -84,9 +83,9 @@ pub async fn handle_triage(
 }
 
 pub async fn handle_compare(
-    body: api::days::Request,
+    body: api::comparison::Request,
     data: &InputData,
-) -> Result<api::days::Response, BoxedError> {
+) -> Result<api::comparison::Response, BoxedError> {
     let master_commits = collector::master_commits().await?;
     let end = body.end;
     let comparison =
@@ -99,10 +98,36 @@ pub async fn handle_compare(
     let next = comparison.next(&master_commits);
     let is_contiguous = comparison.is_contiguous(&*conn, &master_commits).await;
 
-    Ok(api::days::Response {
+    Ok(api::comparison::Response {
         prev,
-        a: comparison.a,
-        b: comparison.b,
+        a: api::comparison::ArtifactData {
+            commit: match comparison.a.artifact.clone() {
+                ArtifactId::Commit(c) => c.sha,
+                ArtifactId::Artifact(t) => t,
+            },
+            date: if let ArtifactId::Commit(c) = &comparison.a.artifact {
+                Some(c.date)
+            } else {
+                None
+            },
+            pr: comparison.a.pr,
+            data: comparison.a.data,
+            bootstrap: comparison.a.bootstrap,
+        },
+        b: api::comparison::ArtifactData {
+            commit: match comparison.b.artifact.clone() {
+                ArtifactId::Commit(c) => c.sha,
+                ArtifactId::Artifact(t) => t,
+            },
+            date: if let ArtifactId::Commit(c) = &comparison.b.artifact {
+                Some(c.date)
+            } else {
+                None
+            },
+            pr: comparison.b.pr,
+            data: comparison.b.data,
+            bootstrap: comparison.b.bootstrap,
+        },
         next,
         is_contiguous,
     })
@@ -197,8 +222,8 @@ impl ComparisonSummary<'_> {
         } else {
             String::from("<Unknown Change>\n")
         };
-        let start = &comparison.a.commit;
-        let end = &comparison.b.commit;
+        let start = &comparison.a.artifact;
+        let end = &comparison.b.artifact;
         let link = &compare_link(start, end);
 
         for change in self.ordered_changes() {
@@ -246,27 +271,23 @@ pub async fn compare_given_commits(
         .set::<String>(Tag::Profile, selector::Selector::All)
         .set(Tag::ProcessStatistic, selector::Selector::One(stat.clone()));
 
-    // `responses` contains a series iterators. The first element in the iterator is the data
+    // `responses` contains series iterators. The first element in the iterator is the data
     // for `a` and the second is the data for `b`
     let mut responses = data.query::<Option<f64>>(query, cids).await?;
 
     let conn = data.conn().await;
 
     Ok(Some(Comparison {
-        a: DateData::consume_one(&*conn, a.clone(), &mut responses, master_commits).await,
-        a_id: a,
-        b: DateData::consume_one(&*conn, b.clone(), &mut responses, master_commits).await,
-        b_id: b,
+        a: ArtifactData::consume_one(&*conn, a.clone(), &mut responses, master_commits).await,
+        b: ArtifactData::consume_one(&*conn, b.clone(), &mut responses, master_commits).await,
     }))
 }
 
 /// Data associated with a specific artifact
 #[derive(Debug, Clone, Serialize)]
-pub struct DateData {
+pub struct ArtifactData {
     /// The artifact in question
-    pub commit: String,
-    /// The date of the artifact if known
-    pub date: Option<Date>,
+    pub artifact: ArtifactId,
     /// The pr of the artifact if known
     pub pr: Option<u32>,
     /// Benchmark data in the form "$crate-$profile" -> Vec<("$cache", nanoseconds)>
@@ -279,14 +300,14 @@ pub struct DateData {
     pub bootstrap: HashMap<String, u64>,
 }
 
-impl DateData {
+impl ArtifactData {
     /// For the given `ArtifactId`, consume the first datapoint in each of the given `SeriesResponse`
     ///
-    /// It is assumed that the provided ArtifactId is the same as artifact id returned as the next data
-    /// point from all of the series `SeriesResponse`s. If this is not true, this function will panic.
+    /// It is assumed that the provided `ArtifactId` matches the artifact id of the next data
+    /// point for all of `SeriesResponse<T>`. If this is not true, this function will panic.
     async fn consume_one<'a, T>(
         conn: &dyn database::Connection,
-        commit: ArtifactId,
+        artifact: ArtifactId,
         series: &mut [selector::SeriesResponse<T>],
         master_commits: &[collector::MasterCommit],
     ) -> Self
@@ -297,7 +318,7 @@ impl DateData {
 
         for response in series {
             let (id, point) = response.series.next().expect("must have element");
-            assert_eq!(commit, id);
+            assert_eq!(artifact, id);
 
             let point = if let Some(pt) = point {
                 pt
@@ -313,7 +334,9 @@ impl DateData {
             .push((response.path.get::<Cache>().unwrap().to_string(), point));
         }
 
-        let bootstrap = conn.get_bootstrap(&[conn.artifact_id(&commit).await]).await;
+        let bootstrap = conn
+            .get_bootstrap(&[conn.artifact_id(&artifact).await])
+            .await;
         let bootstrap = bootstrap
             .into_iter()
             .filter_map(|(k, mut v)| {
@@ -332,25 +355,19 @@ impl DateData {
             })
             .collect::<HashMap<_, _>>();
 
-        Self {
-            date: if let ArtifactId::Commit(c) = &commit {
-                Some(c.date)
-            } else {
-                None
-            },
-            pr: if let ArtifactId::Commit(c) = &commit {
-                if let Some(m) = master_commits.iter().find(|m| m.sha == c.sha) {
-                    m.pr
-                } else {
-                    conn.pr_of(&c.sha).await
-                }
+        let pr = if let ArtifactId::Commit(c) = &artifact {
+            if let Some(m) = master_commits.iter().find(|m| m.sha == c.sha) {
+                m.pr
             } else {
-                None
-            },
-            commit: match commit {
-                ArtifactId::Commit(c) => c.sha,
-                ArtifactId::Artifact(i) => i,
-            },
+                conn.pr_of(&c.sha).await
+            }
+        } else {
+            None
+        };
+
+        Self {
+            pr,
+            artifact,
             data,
             bootstrap,
         }
@@ -359,16 +376,14 @@ impl DateData {
 
 // A comparison of two artifacts
 pub struct Comparison {
-    pub a_id: ArtifactId,
-    pub a: DateData,
-    pub b_id: ArtifactId,
-    pub b: DateData,
+    pub a: ArtifactData,
+    pub b: ArtifactData,
 }
 
 impl Comparison {
     /// Gets the previous commit before `a`
     pub fn prev(&self, master_commits: &[collector::MasterCommit]) -> Option<String> {
-        match &self.a_id {
+        match &self.a.artifact {
             ArtifactId::Commit(a) => master_commits
                 .iter()
                 .find(|c| c.sha == a.sha)
@@ -383,7 +398,7 @@ impl Comparison {
         conn: &dyn database::Connection,
         master_commits: &[collector::MasterCommit],
     ) -> bool {
-        match (&self.a_id, &self.b_id) {
+        match (&self.a.artifact, &self.b.artifact) {
             (ArtifactId::Commit(a), ArtifactId::Commit(b)) => {
                 if let Some(b) = master_commits.iter().find(|c| c.sha == b.sha) {
                     b.parent_sha == a.sha
@@ -397,7 +412,7 @@ impl Comparison {
 
     /// Gets the sha of the next commit after `b`
     pub fn next(&self, master_commits: &[collector::MasterCommit]) -> Option<String> {
-        match &self.b_id {
+        match &self.b.artifact {
             ArtifactId::Commit(b) => master_commits
                 .iter()
                 .find(|c| c.parent_sha == b.sha)
@@ -585,7 +600,15 @@ TODO: Nags
     )
 }
 
-fn compare_link(start: &str, end: &str) -> String {
+fn compare_link(start: &ArtifactId, end: &ArtifactId) -> String {
+    let start = match &start {
+        ArtifactId::Artifact(a) => a,
+        ArtifactId::Commit(c) => &c.sha,
+    };
+    let end = match &end {
+        ArtifactId::Artifact(a) => a,
+        ArtifactId::Commit(c) => &c.sha,
+    };
     format!(
         "https://perf.rust-lang.org/compare.html?start={}&end={}&stat=instructions:u",
         start, end
diff --git a/site/src/server.rs b/site/src/server.rs
@@ -39,8 +39,8 @@ type Request = http::Request<hyper::Body>;
 type Response = http::Response<hyper::Body>;
 
 pub use crate::api::{
-    self, bootstrap, dashboard, data, days, github, graph, info, self_profile, self_profile_raw,
-    status, triage, CommitResponse, ServerResult, StyledBenchmarkName,
+    self, bootstrap, comparison, dashboard, data, github, graph, info, self_profile,
+    self_profile_raw, status, triage, CommitResponse, ServerResult, StyledBenchmarkName,
 };
 use crate::db::{self, Cache, Crate, Profile};
 use crate::interpolate::Interpolated;
