Remove usage of the collector_progress table

Kobzol · Kobzol · commit e921cf5e8595 · 2026-02-11T09:09:50.000+01:00
diff --git a/collector/src/bin/collector.rs b/collector/src/bin/collector.rs
@@ -2231,8 +2231,6 @@ async fn bench_compile(
         print_intro: &dyn Fn(),
         measure: F,
     ) {
-        collector.start_compile_step(conn, benchmark_name).await;
-
         let mut tx = conn.transaction().await;
         let (supports_stable, category) = category.db_representation();
         tx.conn()
@@ -2259,7 +2257,6 @@ async fn bench_compile(
                 )
                 .await;
         };
-        collector.end_compile_step(tx.conn(), benchmark_name).await;
         tx.commit().await.expect("committed");
     }
 
diff --git a/collector/src/lib.rs b/collector/src/lib.rs
@@ -15,7 +15,7 @@ mod self_profile;
 pub mod toolchain;
 pub mod utils;
 
-use crate::compile::benchmark::{Benchmark, BenchmarkName};
+use crate::compile::benchmark::Benchmark;
 use crate::runtime::{BenchmarkGroup, BenchmarkSuite};
 pub use crate::self_profile::{
     LocalSelfProfileStorage, S3SelfProfileStorage, SelfProfileId, SelfProfileStorage,
@@ -342,17 +342,7 @@ impl CollectorStepBuilder {
     ) -> CollectorCtx {
         // Make sure there is no observable time when the artifact ID is available
         // but the in-progress steps are not.
-        let artifact_row_id = {
-            let mut tx = conn.transaction().await;
-            let artifact_row_id = tx.conn().artifact_id(artifact_id).await;
-            if self.job_id.is_none() {
-                tx.conn()
-                    .collector_start(artifact_row_id, &self.steps)
-                    .await;
-            }
-            tx.commit().await.unwrap();
-            artifact_row_id
-        };
+        let artifact_row_id = conn.artifact_id(artifact_id).await;
         // Find out which tests cases were already computed
         let measured_compile_test_cases = conn
             .get_compile_test_cases_with_measurements(&artifact_row_id)
@@ -385,24 +375,6 @@ pub struct CollectorCtx {
 }
 
 impl CollectorCtx {
-    pub fn is_from_job_queue(&self) -> bool {
-        self.job_id.is_some()
-    }
-
-    pub async fn start_compile_step(&self, conn: &dyn Connection, benchmark_name: &BenchmarkName) {
-        if !self.is_from_job_queue() {
-            conn.collector_start_step(self.artifact_row_id, &benchmark_name.0)
-                .await;
-        }
-    }
-
-    pub async fn end_compile_step(&self, conn: &dyn Connection, benchmark_name: &BenchmarkName) {
-        if !self.is_from_job_queue() {
-            conn.collector_end_step(self.artifact_row_id, &benchmark_name.0)
-                .await;
-        }
-    }
-
     /// Returns the names of benchmarks in the group that have not yet been measured
     /// for the given target.
     pub fn get_unmeasured_runtime_benchmarks<'a>(
@@ -422,21 +394,6 @@ impl CollectorCtx {
             .map(|s| s.as_str())
             .collect()
     }
-
-    pub async fn start_runtime_step(&self, conn: &dyn Connection, group: &BenchmarkGroup) {
-        if !self.is_from_job_queue() {
-            let step_name = runtime_group_step_name(&group.name);
-            conn.collector_start_step(self.artifact_row_id, &step_name)
-                .await;
-        }
-    }
-
-    pub async fn end_runtime_step(&self, conn: &dyn Connection, group: &BenchmarkGroup) {
-        if !self.is_from_job_queue() {
-            conn.collector_end_step(self.artifact_row_id, &runtime_group_step_name(&group.name))
-                .await;
-        }
-    }
 }
 
 pub fn runtime_group_step_name(benchmark_name: &str) -> String {
diff --git a/collector/src/runtime/mod.rs b/collector/src/runtime/mod.rs
@@ -81,7 +81,6 @@ pub async fn bench_runtime(
         }
 
         let step_name = runtime_group_step_name(&group.name);
-        collector.start_runtime_step(conn, &group).await;
 
         let mut tx = conn.transaction().await;
 
@@ -136,7 +135,6 @@ pub async fn bench_runtime(
                 .await;
         };
 
-        collector.end_runtime_step(tx.conn(), &group).await;
         tx.commit()
             .await
             .expect("Cannot commit runtime benchmark group results");
diff --git a/database/src/pool.rs b/database/src/pool.rs
@@ -124,20 +124,6 @@ pub trait Connection: Send + Sync {
     ) -> Vec<Vec<Option<f64>>>;
     async fn get_error(&self, artifact_row_id: ArtifactIdNumber) -> HashMap<String, String>;
 
-    // Collector status API
-
-    // TODO: these functions should be removed. The only useful user of them currently are runtime
-    // benchmarks, which should switch to something similar to
-    // `get_compile_test_cases_with_measurements`.
-    async fn collector_start(&self, aid: ArtifactIdNumber, steps: &[String]);
-
-    // Returns `true` if the step was started, i.e., it did not previously have
-    // an end. Otherwise returns false, indicating that we can skip it.
-    async fn collector_start_step(&self, aid: ArtifactIdNumber, step: &str) -> bool;
-    async fn collector_end_step(&self, aid: ArtifactIdNumber, step: &str);
-
-    async fn collector_remove_step(&self, aid: ArtifactIdNumber, step: &str);
-
     /// Returns the SHA of the parent of the given SHA commit, if available.
     async fn parent_of(&self, sha: &str) -> Option<String>;
 
diff --git a/database/src/pool/postgres.rs b/database/src/pool/postgres.rs
@@ -1202,60 +1202,6 @@ where
         }
     }
 
-    async fn collector_start(&self, aid: ArtifactIdNumber, steps: &[String]) {
-        // Clean up -- we'll re-insert any missing things in the loop below.
-        self.conn()
-            .execute(
-                "delete from collector_progress where start_time is null or end_time is null;",
-                &[],
-            )
-            .await
-            .unwrap();
-
-        for step in steps {
-            self.conn()
-                .execute(
-                    "insert into collector_progress(aid, step) VALUES ($1, $2)
-                    ON CONFLICT DO NOTHING",
-                    &[&(aid.0 as i32), &step],
-                )
-                .await
-                .unwrap();
-        }
-    }
-    async fn collector_start_step(&self, aid: ArtifactIdNumber, step: &str) -> bool {
-        // If we modified a row, then we populated a start time, so we're good
-        // to go. Otherwise we should just skip this step.
-        self.conn()
-            .execute(
-                "update collector_progress set start_time = statement_timestamp() \
-                where aid = $1 and step = $2 and start_time is null and end_time is null;",
-                &[&(aid.0 as i32), &step],
-            )
-            .await
-            .unwrap()
-            == 1
-    }
-    async fn collector_end_step(&self, aid: ArtifactIdNumber, step: &str) {
-        self.conn()
-            .execute(
-                "update collector_progress set end_time = statement_timestamp() \
-                where aid = $1 and step = $2 and start_time is not null;",
-                &[&(aid.0 as i32), &step],
-            )
-            .await
-            .unwrap();
-    }
-    async fn collector_remove_step(&self, aid: ArtifactIdNumber, step: &str) {
-        self.conn()
-            .execute(
-                "delete from collector_progress \
-                where aid = $1 and step = $2;",
-                &[&(aid.0 as i32), &step],
-            )
-            .await
-            .unwrap();
-    }
     async fn parent_of(&self, sha: &str) -> Option<String> {
         self.conn()
             .query_opt(
diff --git a/database/src/pool/sqlite.rs b/database/src/pool/sqlite.rs
@@ -971,52 +971,6 @@ impl Connection for SqliteConnection {
             .collect::<Result<_, _>>()
             .unwrap()
     }
-    async fn collector_start(&self, aid: ArtifactIdNumber, steps: &[String]) {
-        // Clean out any leftover unterminated steps.
-        self.raw_ref()
-            .execute_batch("delete from collector_progress where start is null or end is null;")
-            .unwrap();
-
-        // Populate unstarted and unfinished steps into collector_progress.
-        for step in steps {
-            self.raw_ref()
-                .execute(
-                    "insert or ignore into collector_progress(aid, step) VALUES (?, ?)",
-                    params![&aid.0, step],
-                )
-                .unwrap();
-        }
-    }
-    async fn collector_start_step(&self, aid: ArtifactIdNumber, step: &str) -> bool {
-        self.raw_ref()
-            .execute(
-                "update collector_progress set start = strftime('%s','now') \
-                where aid = ? and step = ? and start is null and end is null;",
-                params![&aid.0, &step],
-            )
-            .unwrap()
-            == 1
-    }
-
-    async fn collector_end_step(&self, aid: ArtifactIdNumber, step: &str) {
-        self.raw_ref()
-            .execute(
-                "update collector_progress set end = strftime('%s','now') \
-                where aid = ? and step = ? and start is not null;",
-                params![&aid.0, &step],
-            )
-            .unwrap();
-    }
-
-    async fn collector_remove_step(&self, aid: ArtifactIdNumber, step: &str) {
-        self.raw_ref()
-            .execute(
-                "delete from collector_progress \
-                where aid = ? and step = ?",
-                params![&aid.0, &step],
-            )
-            .unwrap();
-    }
 
     async fn parent_of(&self, _sha: &str) -> Option<String> {
         None
