refactor(timings): clarify unblocked units

Unblocked is a better term than unlocked

Author: weihanglo

src/cargo/core/compiler/job_queue/mod.rs

@@ -1122,10 +1122,10 @@ impl<'gctx> DrainState<'gctx> {
                 unit.show_warnings(build_runner.bcx.gctx),
             )?;
         }
-        let unlocked = self.queue.finish(unit, &artifact);
+        let unblocked = self.queue.finish(unit, &artifact);
         match artifact {
-            Artifact::All => self.timings.unit_finished(build_runner, id, unlocked),
-            Artifact::Metadata => self.timings.unit_rmeta_finished(id, unlocked),
+            Artifact::All => self.timings.unit_finished(build_runner, id, unblocked),
+            Artifact::Metadata => self.timings.unit_rmeta_finished(id, unblocked),
         }
         Ok(())
     }

src/cargo/core/compiler/timings/mod.rs

@@ -89,10 +89,10 @@ struct UnitTime {
     /// The time when the `.rmeta` file was generated, an offset in seconds
     /// from `start`.
     rmeta_time: Option<f64>,
-    /// Reverse deps that are freed to run after this unit finished.
-    unlocked_units: Vec<Unit>,
-    /// Same as `unlocked_units`, but unlocked by rmeta.
-    unlocked_rmeta_units: Vec<Unit>,
+    /// Reverse deps that are unblocked and ready to run after this unit finishes.
+    unblocked_units: Vec<Unit>,
+    /// Same as `unblocked_units`, but unblocked by rmeta.
+    unblocked_rmeta_units: Vec<Unit>,
     /// Individual compilation section durations, gathered from `--json=timings`.
     ///
     /// IndexMap is used to keep original insertion order, we want to be able to tell which
@@ -127,8 +127,8 @@ struct UnitData {
     start: f64,
     duration: f64,
     rmeta_time: Option<f64>,
-    unlocked_units: Vec<usize>,
-    unlocked_rmeta_units: Vec<usize>,
+    unblocked_units: Vec<usize>,
+    unblocked_rmeta_units: Vec<usize>,
     sections: Option<Vec<(String, report::SectionData)>>,
 }
 
@@ -216,15 +216,15 @@ impl<'gctx> Timings<'gctx> {
             start: self.start.elapsed().as_secs_f64(),
             duration: 0.0,
             rmeta_time: None,
-            unlocked_units: Vec::new(),
-            unlocked_rmeta_units: Vec::new(),
+            unblocked_units: Vec::new(),
+            unblocked_rmeta_units: Vec::new(),
             sections: Default::default(),
         };
         assert!(self.active.insert(id, unit_time).is_none());
     }
 
     /// Mark that the `.rmeta` file as generated.
-    pub fn unit_rmeta_finished(&mut self, id: JobId, unlocked: Vec<&Unit>) {
+    pub fn unit_rmeta_finished(&mut self, id: JobId, unblocked: Vec<&Unit>) {
         if !self.enabled {
             return;
         }
@@ -236,18 +236,18 @@ impl<'gctx> Timings<'gctx> {
         };
         let t = self.start.elapsed().as_secs_f64();
         unit_time.rmeta_time = Some(t - unit_time.start);
-        assert!(unit_time.unlocked_rmeta_units.is_empty());
+        assert!(unit_time.unblocked_rmeta_units.is_empty());
         unit_time
-            .unlocked_rmeta_units
-            .extend(unlocked.iter().cloned().cloned());
+            .unblocked_rmeta_units
+            .extend(unblocked.iter().cloned().cloned());
     }
 
     /// Mark that a unit has finished running.
     pub fn unit_finished(
         &mut self,
         build_runner: &BuildRunner<'_, '_>,
         id: JobId,
-        unlocked: Vec<&Unit>,
+        unblocked: Vec<&Unit>,
     ) {
         if !self.enabled {
             return;
@@ -258,10 +258,10 @@ impl<'gctx> Timings<'gctx> {
         };
         let t = self.start.elapsed().as_secs_f64();
         unit_time.duration = t - unit_time.start;
-        assert!(unit_time.unlocked_units.is_empty());
+        assert!(unit_time.unblocked_units.is_empty());
         unit_time
-            .unlocked_units
-            .extend(unlocked.iter().cloned().cloned());
+            .unblocked_units
+            .extend(unblocked.iter().cloned().cloned());
         if self.report_json {
             let msg = machine_message::TimingInfo {
                 package_id: unit_time.unit.pkg.package_id().to_spec(),

src/cargo/core/compiler/timings/report.rs

@@ -373,13 +373,13 @@ fn to_unit_data(unit_times: &[UnitTime]) -> Vec<UnitData> {
             // These filter on the unlocked units because not all unlocked
             // units are actually "built". For example, Doctest mode units
             // don't actually generate artifacts.
-            let unlocked_units: Vec<usize> = ut
-                .unlocked_units
+            let unblocked_units: Vec<usize> = ut
+                .unblocked_units
                 .iter()
                 .filter_map(|unit| unit_map.get(unit).copied())
                 .collect();
-            let unlocked_rmeta_units: Vec<usize> = ut
-                .unlocked_rmeta_units
+            let unblocked_rmeta_units: Vec<usize> = ut
+                .unblocked_rmeta_units
                 .iter()
                 .filter_map(|unit| unit_map.get(unit).copied())
                 .collect();
@@ -419,8 +419,8 @@ fn to_unit_data(unit_times: &[UnitTime]) -> Vec<UnitData> {
                 start: round(ut.start),
                 duration: round(ut.duration),
                 rmeta_time: ut.rmeta_time.map(round),
-                unlocked_units,
-                unlocked_rmeta_units,
+                unblocked_units,
+                unblocked_rmeta_units,
                 sections,
             }
         })

src/doc/src/reference/timings.md

@@ -22,7 +22,7 @@ version information of the currently used compiler.
 
 The "unit" graph shows the duration of each unit over time.
 A "unit" is a single compiler invocation.
-There are lines that show which additional units are "unlocked" when a unit finishes.
+There are lines that show which additional units are "unblocked" when a unit finishes.
 That is, it shows the new units that are now allowed to run because their dependencies are all finished.
 Hover the mouse over a unit to highlight the lines.
 This can help visualize the critical path of dependencies.