Implement summary graphs.

Adds two graphs for release and debug modes. The current series are the
clean, initial incremental, incremental clean, and println patch. Values
are multiples of the first shown clean non-incremental build.

Future work will involve adding more lines to the graph, but currently
there's no other similar patch like "println" that would be trivial to
add.

Author: Mark-Simulacrum

collector/src/lib.rs

@@ -51,7 +51,7 @@ impl Ord for Commit {
     }
 }
 
-#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, Eq)]
+#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, Eq, Hash)]
 pub struct Patch {
     index: usize,
     name: String,
@@ -99,14 +99,43 @@ impl Patch {
 }
 
 
-#[derive(Debug, PartialEq, Clone, Deserialize, Serialize)]
+#[derive(Debug, PartialEq, Eq, Hash, Clone, Deserialize, Serialize)]
 pub enum BenchmarkState {
     Clean,
     IncrementalStart,
     IncrementalClean,
     IncrementalPatched(Patch),
 }
 
+impl BenchmarkState {
+    pub fn is_base_compile(&self) -> bool {
+        if let BenchmarkState::Clean = *self {
+            true
+        } else {
+            false
+        }
+    }
+
+    pub fn is_patch(&self) -> bool {
+        if let BenchmarkState::IncrementalPatched(_) = *self {
+            true
+        } else {
+            false
+        }
+    }
+
+    pub fn name(&self) -> String {
+        match *self {
+            BenchmarkState::Clean => format!("clean"),
+            BenchmarkState::IncrementalStart => format!("baseline incremental"),
+            BenchmarkState::IncrementalClean => format!("clean incremental"),
+            BenchmarkState::IncrementalPatched(ref patch) => {
+                format!("patched incremental: {}", patch.name)
+            }
+        }
+    }
+}
+
 #[derive(Debug, Clone, Deserialize, Serialize)]
 pub struct Benchmark {
     pub runs: Vec<Run>,
@@ -127,21 +156,20 @@ pub struct Run {
 }
 
 impl Run {
+    pub fn is_trivial(&self) -> bool {
+        if let BenchmarkState::IncrementalPatched(ref patch) = self.state {
+            return patch.name == "println";
+        }
+        false
+    }
+
     pub fn name(&self) -> String {
-        let base = match self.state {
-            BenchmarkState::Clean => format!("clean"),
-            BenchmarkState::IncrementalStart => format!("baseline incremental"),
-            BenchmarkState::IncrementalClean => format!("clean incremental"),
-            BenchmarkState::IncrementalPatched(ref patch) => {
-                format!("patched incremental: {}", patch.name)
-            }
-        };
         let opt = if self.release {
             "-opt"
         } else {
             ""
         };
-        base + opt
+        self.state.name() + opt
     }
 
     pub fn get_stat(&self, stat: &str) -> Option<f64> {

site/src/api.rs

@@ -111,8 +111,10 @@ pub mod graph {
     }
 
     #[derive(Debug, PartialEq, Clone, Serialize, Deserialize)]
-    /// Crate -> Benchmark -> [GraphData]
-    pub struct Response(pub HashMap<String, HashMap<String, Vec<GraphData>>>);
+    pub struct Response {
+        /// Crate -> Benchmark -> [GraphData]
+        pub benchmarks: HashMap<String, HashMap<String, Vec<GraphData>>>,
+    }
 }
 
 pub mod days {

site/src/server.rs

@@ -103,12 +103,23 @@ pub fn handle_graph(body: graph::Request, data: &InputData) -> ServerResult<grap
     let mut result = HashMap::with_capacity(data.crate_list.len() * 2);
     let elements = out.len();
     let mut last_commit = None;
+    let mut initial_base_compile = None;
+    let mut initial_release_base_compile = None;
     for date_data in out {
         let commit = date_data.commit;
+        let mut summary_points = HashMap::new();
         for (name, runs) in date_data.data {
-            let mut entry = result.entry(name)
+            let mut entry = result.entry(name.clone())
                 .or_insert_with(|| HashMap::with_capacity(runs.len()));
-            for (name, _, value) in runs {
+            let mut base_compile = false;
+            let mut trivial = false;
+            for (name, run, value) in runs.clone() {
+                if run.state.is_base_compile() {
+                    base_compile = true;
+                } else if run.is_trivial() {
+                    trivial = true;
+                }
+
                 let mut entry = entry.entry(name.clone())
                     .or_insert_with(|| Vec::<graph::GraphData>::with_capacity(elements));
                 let first = entry.first().map(|d| d.absolute);
@@ -130,11 +141,62 @@ pub fn handle_graph(body: graph::Request, data: &InputData) -> ServerResult<grap
                         x: date_data.date.0.timestamp() as u64, // all dates are since 1970
                     });
             }
+            if base_compile && trivial {
+                for (_, run, value) in runs {
+                    // TODO: Come up with a way to summarize non-standard patches
+                    if run.state.is_patch() && !run.is_trivial() {
+                        continue;
+                    }
+                    summary_points.entry((run.release, run.state))
+                        .or_insert_with(Vec::new)
+                        .push(value);
+                }
+            }
+        }
+        for (&(release, ref state), values) in &summary_points {
+            let value = values.iter().sum::<f64>() / (values.len() as f64);
+            if !release && state.is_base_compile() && initial_base_compile.is_none() {
+                initial_base_compile = Some(value);
+            }
+            if release && state.is_base_compile() && initial_release_base_compile.is_none() {
+                initial_release_base_compile = Some(value);
+            }
+        }
+        for ((release, state), values) in summary_points {
+            let summary = result.entry(String::from("Summary") + if release { "-opt" } else {""})
+                .or_insert_with(HashMap::new);
+            let entry = summary.entry(state.name()).or_insert_with(Vec::new);
+            let value = values.iter().sum::<f64>() / (values.len() as f64);
+            let value = value / if release {
+                initial_release_base_compile.unwrap()
+            } else {
+                initial_base_compile.unwrap()
+            };
+            let first = entry.first().map(|d: &graph::GraphData| d.absolute);
+            let percent = first.map_or(0.0, |f| (value - f) / f * 100.0);
+            let url = last_commit.as_ref().map(|c| {
+                    format!("/compare.html?start={}&end={}&stat={}",
+                        c,
+                        commit,
+                        body.stat,
+                        )
+                });
+            entry.push(graph::GraphData {
+                benchmark: state.name(),
+                commit: commit.clone(),
+                url: url,
+                absolute: value,
+                percent: percent,
+                y: if body.absolute { value } else { percent },
+                x: date_data.date.0.timestamp() as u64, // all dates are since 1970
+            });
         }
         last_commit = Some(commit);
     }
 
-    Ok(graph::Response(result))
+    Ok(graph::Response {
+        benchmarks: result,
+    })
 }
 
 pub fn handle_data(body: data::Request, data: &InputData) -> ServerResult<data::Response> {

site/static/index.html

@@ -22,8 +22,9 @@
     <script src="shared.js"></script>
 
     <script>
+    let summaryYAxis = "Multiplier of baseline non-incr";
     function init_graph(response, stat, absolute) {
-        let sorted_names = Object.keys(response);
+        let sorted_names = Object.keys(response.benchmarks);
         sorted_names.sort();
         document.getElementById("charts").style.display = "none";
         let title = "";
@@ -54,16 +55,6 @@
             return false;
         }
 
-        function formatter() {
-            let date = new Date();
-            date.setUTCMilliseconds(this.x);
-            let commit = this.point.commit.substr(0, 10);
-            return "<b>" + date.toLocaleString() + " - " + commit + "</b>" +
-                "<br>" + this.series.name + ": " + this.point.absolute.toFixed(2) + " " +
-                yAxis.toLowerCase() + " (" +
-                this.point.percent.toFixed(2) + "% from start)";
-        }
-
         let elements = [];
         for (let crate_name of sorted_names) {
             let element = document.createElement("div");
@@ -73,11 +64,11 @@
         let graphs = [];
         for (let crate_name of sorted_names) {
             graphs.push(() => {
-            let benchmark_names = Object.keys(response[crate_name]);
+            let benchmark_names = Object.keys(response.benchmarks[crate_name]);
             benchmark_names.sort();
             let datasets = [];
             for (let name of benchmark_names) {
-                let data = response[crate_name][name];
+                let data = response.benchmarks[crate_name][name];
                 datasets.push({
                     name: data[0].benchmark,
                     animation: false,
@@ -106,14 +97,23 @@
                 series: datasets,
                 tooltip: {
                     crosshairs: [true],
-                    formatter: formatter,
+                    formatter: function formatter() {
+                        let date = new Date();
+                        date.setUTCMilliseconds(this.x);
+                        let commit = this.point.commit.substr(0, 10);
+                        let yAxis = crate_name.startsWith("Summary") ? summaryYAxis : yAxis;
+                        return "<b>" + date.toLocaleString() + " - " + commit + "</b>" +
+                            "<br>" + this.series.name + ": " + this.point.absolute.toFixed(2) + " " +
+                            yAxis.toLowerCase() + " (" +
+                            this.point.percent.toFixed(2) + "% from start)";
+                    },
                 },
                 xAxis: {
                     type: "datetime",
                 },
                 yAxis: absolute ? {
                     title: {
-                        text: yAxis,
+                        text: crate_name.startsWith("Summary") ? summaryYAxis : yAxis,
                     },
                     min: 0,
                 } : {