Display progress of current benchmark

Author: Mark-Simulacrum

database/src/lib.rs

@@ -674,5 +674,14 @@ impl Index {
     }
 }
 
+#[derive(Debug)]
+pub struct Step {
+    pub name: String,
+    pub is_done: bool,
+    // The amount of time this step has been ongoing (or took, if completed).
+    pub duration: Duration,
+    pub expected: Duration,
+}
+
 #[derive(Debug, PartialEq, Eq, Copy, Clone)]
 pub struct CollectionId(i32);

database/src/pool.rs

@@ -1,5 +1,5 @@
 use crate::{ArtifactId, ArtifactIdNumber};
-use crate::{Cache, CollectionId, Index, Profile, QueryDatum, QueuedCommit};
+use crate::{Cache, CollectionId, Index, Profile, QueryDatum, QueuedCommit, Step};
 use hashbrown::HashMap;
 use std::sync::{Arc, Mutex};
 use std::time::Duration;
@@ -73,6 +73,8 @@ pub trait Connection: Send + Sync {
 
     // Returns an artifact that is in progress.
     async fn in_progress_artifact(&self) -> Option<ArtifactId>;
+
+    async fn in_progress_steps(&self, aid: &ArtifactId) -> Vec<Step>;
 }
 
 #[async_trait::async_trait]

database/src/pool/postgres.rs

@@ -240,6 +240,7 @@ pub struct CachedStatements {
     get_error: Statement,
     collection_id: Statement,
     record_duration: Statement,
+    in_progress_steps: Statement,
 }
 
 pub struct PostgresTransaction<'a> {
@@ -361,6 +362,23 @@ impl PostgresConnection {
                         duration
                     ) VALUES ($1, CURRENT_TIMESTAMP, $2)
                 ").await.unwrap(),
+                in_progress_steps: conn.prepare("
+                select step,
+                    end_time is not null,
+                    extract(epoch from interval '0 seconds'::interval +
+                        coalesce(end_time, statement_timestamp()) - start_time)::int4,
+                    extract(
+                        epoch from interval '0 seconds'::interval +
+                        (select end_time - start_time
+                        from collector_progress as cp
+                            where
+                                cp.step = collector_progress.step
+                                and cp.start_time is not null
+                                and cp.end_time is not null
+                            limit 1
+                        ))::int4
+                from collector_progress where aid = $1 order by step
+                ").await.unwrap(),
             }),
             conn,
         }
@@ -879,4 +897,23 @@ where
             }
         })
     }
+    async fn in_progress_steps(&self, artifact: &ArtifactId) -> Vec<crate::Step> {
+        let aid = self.artifact_id(artifact).await;
+
+        let steps = self
+            .conn()
+            .query(&self.statements().in_progress_steps, &[&(aid.0 as i16)])
+            .await
+            .unwrap();
+
+        steps
+            .into_iter()
+            .map(|row| crate::Step {
+                name: row.get(0),
+                is_done: row.get(1),
+                duration: Duration::from_secs(row.get::<_, Option<i32>>(2).unwrap_or(0) as u64),
+                expected: Duration::from_secs(row.get::<_, i32>(3) as u64),
+            })
+            .collect()
+    }
 }

database/src/pool/sqlite.rs

@@ -716,4 +716,38 @@ impl Connection for SqliteConnection {
             }
         })
     }
+    async fn in_progress_steps(&self, artifact: &ArtifactId) -> Vec<crate::Step> {
+        let aid = self.artifact_id(artifact).await;
+
+        self.raw_ref()
+            .prepare(
+                "
+                select
+                    step,
+                    end_time is not null,
+                    coalesce(end, strftime('%s', 'now')) - start,
+                    (select end - start
+                        from collector_progress as cp
+                            where
+                                cp.step = collector_progress.step
+                                and cp.start is not null
+                                and cp.end is not null
+                            limit 1
+                    )
+                from collector_progress where aid = ? order by step
+            ",
+            )
+            .unwrap()
+            .query_map(params![&aid.0], |row| {
+                Ok(crate::Step {
+                    name: row.get(0)?,
+                    is_done: row.get(1)?,
+                    duration: Duration::from_secs(row.get::<_, i64>(2)? as u64),
+                    expected: Duration::from_secs(row.get::<_, i64>(3)? as u64),
+                })
+            })
+            .unwrap()
+            .map(|r| r.unwrap())
+            .collect()
+    }
 }

site/src/api.rs

@@ -160,7 +160,8 @@ pub mod days {
 }
 
 pub mod status {
-    use crate::load::{CurrentState, MissingReason};
+    use crate::load::MissingReason;
+    use database::ArtifactId;
     use database::Commit;
     use serde::{Deserialize, Serialize};
 
@@ -171,7 +172,23 @@ pub mod status {
         pub error: Option<String>,
     }
 
-    #[derive(Debug, Clone, Serialize, Deserialize)]
+    #[derive(Serialize, Debug)]
+    pub struct Step {
+        pub step: String,
+        pub is_done: bool,
+        // Seconds
+        pub expected_duration: u64,
+        // Seconds since start
+        pub current_progress: u64,
+    }
+
+    #[derive(Serialize, Debug)]
+    pub struct CurrentState {
+        pub artifact: ArtifactId,
+        pub progress: Vec<Step>,
+    }
+
+    #[derive(Serialize, Debug)]
     pub struct Response {
         pub last_commit: Commit,
         pub benchmarks: Vec<BenchmarkStatus>,

site/src/load.rs

@@ -37,13 +37,6 @@ pub enum MissingReason {
     InProgress,
 }
 
-#[derive(Clone, Deserialize, Serialize, Debug)]
-pub struct CurrentState {
-    pub commit: Commit,
-    pub issue: Option<github::Issue>,
-    pub benchmarks: Vec<Crate>,
-}
-
 #[derive(Clone, Deserialize, Serialize, Debug, PartialEq, Eq)]
 pub struct TryCommit {
     pub sha: String,

site/src/server.rs

@@ -276,7 +276,27 @@ pub async fn handle_status_page(data: Arc<InputData>) -> status::Response {
 
     let missing = data.missing_commits().await;
     // FIXME: no current builds
-    let current = None;
+    let conn = data.conn().await;
+    let current = if let Some(artifact) = conn.in_progress_artifact().await {
+        let steps = conn
+            .in_progress_steps(&artifact)
+            .await
+            .into_iter()
+            .map(|s| crate::api::status::Step {
+                step: s.name,
+                is_done: s.is_done,
+                expected_duration: s.expected.as_secs(),
+                current_progress: s.duration.as_secs(),
+            })
+            .collect();
+
+        Some(crate::api::status::CurrentState {
+            artifact,
+            progress: steps,
+        })
+    } else {
+        None
+    };
 
     status::Response {
         last_commit,

site/static/status.html

@@ -56,11 +56,57 @@
         }
         let missing_div = document.querySelector("#missing-commits");
         if (data.current !== null) {
+            let table = document.createElement("table");
+            let tr = document.createElement("tr");
+            let th = document.createElement("th");
+            th.innerText = "Step";
+            tr.appendChild(th);
+            th = document.createElement("th");
+            tr.appendChild(th);
+            th = document.createElement("th");
+            th.innerText = "Took";
+            tr.appendChild(th);
+            th = document.createElement("th");
+            th.innerText = "Expected";
+            tr.appendChild(th);
+            table.appendChild(tr);
+
+            let left = 0;
+            for (let step of data.current.progress) {
+                let tr = document.createElement("tr");
+                let td = document.createElement("td");
+                td.innerText = step.step;
+                tr.appendChild(td);
+                td = document.createElement("td");
+                let progress = document.createElement("progress");
+                progress.setAttribute("max", step.expected_duration);
+                progress.setAttribute("value", step.is_done ?
+                step.expected_duration : step.current_progress);
+                td.appendChild(progress);
+                tr.appendChild(td);
+                td = document.createElement("td");
+                td.innerHTML = step.current_progress == 0 ? "" :
+                    format_duration(step.current_progress);
+                tr.appendChild(td);
+                td = document.createElement("td");
+                td.innerHTML = format_duration(step.expected_duration);
+                tr.appendChild(td);
+                if (!step.is_done) {
+                    left += step.expected_duration - step.current_progress;
+                }
+                table.appendChild(tr);
+            }
             let element = document.createElement("p");
-            element.innerHTML = `Currently benchmarking:
-            ${commit_url(data.current.commit)}<br>${data.current.benchmarks.length} benchmarks \
-            left out of ${data.benchmarks.length} total: ${data.current.benchmarks.join(", ")}.`;
+            let artifact_desc = "";
+            if (data.current.artifact.Commit) {
+                artifact_desc = commit_url(data.current.artifact.Commit);
+            } else {
+                artifact_desc = data.current.Artifact;
+            }
+            element.innerHTML = `Currently benchmarking: ${artifact_desc}.
+                <br>Time left: ${format_duration(left)}`;
             missing_div.appendChild(element);
+            missing_div.appendChild(table);
         } else {
             let element = document.createElement("p");
             element.innerHTML = `(Current work is not currently displayed; this is being worked on)`;
@@ -109,6 +155,19 @@
         return `<a href="https://github.com/rust-lang/rust/commit/${commit.sha}">${commit.sha.substr(0, 13)}</a>`;
     }
 
+    function format_duration(seconds) {
+        let secs = seconds % 60;
+        let mins = Math.trunc(seconds / 60);
+        let hours = Math.trunc(mins / 60);
+        mins -= hours*60;
+
+        let s = `${mins < 10 ? "&nbsp;" + mins : mins}m${secs < 10 ? "0" + secs : secs}s`;
+        if (hours > 0) {
+            s = `${hours}h ${s}`;
+        }
+        return s;
+    }
+
     function addHours(date, hours) {
         let ret = new Date(date);
         ret.setTime(ret.getTime() + (hours*60*60*1000));