Remove Option from Timings.

Author: ehuss

src/cargo/core/compiler/job_queue.rs

@@ -40,7 +40,7 @@ pub struct JobQueue<'a, 'cfg> {
     is_release: bool,
     progress: Progress<'cfg>,
     next_id: u32,
-    timings: Option<Timings<'a, 'cfg>>,
+    timings: Timings<'a, 'cfg>,
 }
 
 pub struct JobState<'a> {
@@ -132,10 +132,7 @@ impl<'a, 'cfg> JobQueue<'a, 'cfg> {
     pub fn new(bcx: &BuildContext<'a, 'cfg>, root_units: &[Unit<'a>]) -> JobQueue<'a, 'cfg> {
         let (tx, rx) = channel();
         let progress = Progress::with_style("Building", ProgressStyle::Ratio, bcx.config);
-        let timings = match bcx.config.cli_unstable().timings {
-            Some(..) => Some(Timings::new(bcx, root_units)),
-            None => None,
-        };
+        let timings = Timings::new(bcx, root_units);
         JobQueue {
             queue: DependencyQueue::new(),
             tx,
@@ -322,9 +319,8 @@ impl<'a, 'cfg> JobQueue<'a, 'cfg> {
             // to the jobserver itself.
             tokens.truncate(self.active.len() - 1);
 
-            if let Some(t) = &mut self.timings {
-                t.mark_concurrency(self.active.len(), queue.len(), self.queue.len());
-            }
+            self.timings
+                .mark_concurrency(self.active.len(), queue.len(), self.queue.len());
 
             // Drain all events at once to avoid displaying the progress bar
             // unnecessarily.
@@ -343,9 +339,7 @@ impl<'a, 'cfg> JobQueue<'a, 'cfg> {
                             .config
                             .shell()
                             .verbose(|c| c.status("Running", &cmd))?;
-                        if let Some(t) = &mut self.timings {
-                            t.unit_start(id, self.active[&id]);
-                        }
+                        self.timings.unit_start(id, self.active[&id]);
                     }
                     Message::BuildPlanMsg(module_name, cmd, filenames) => {
                         plan.update(&module_name, &cmd, &filenames)?;
@@ -437,9 +431,7 @@ impl<'a, 'cfg> JobQueue<'a, 'cfg> {
             if !cx.bcx.build_config.build_plan {
                 cx.bcx.config.shell().status("Finished", message)?;
             }
-            if let Some(t) = &mut self.timings {
-                t.finished()?;
-            }
+            self.timings.finished()?;
             Ok(())
         } else {
             debug!("queue: {:#?}", self.queue);
@@ -535,15 +527,11 @@ impl<'a, 'cfg> JobQueue<'a, 'cfg> {
 
         match fresh {
             Freshness::Fresh => {
-                if let Some(t) = &mut self.timings {
-                    t.add_fresh();
-                }
+                self.timings.add_fresh();
                 doit()
             }
             Freshness::Dirty => {
-                if let Some(t) = &mut self.timings {
-                    t.add_dirty();
-                }
+                self.timings.add_dirty();
                 scope.spawn(move |_| doit());
             }
         }
@@ -590,11 +578,9 @@ impl<'a, 'cfg> JobQueue<'a, 'cfg> {
             self.emit_warnings(None, unit, cx)?;
         }
         let unlocked = self.queue.finish(unit, &artifact);
-        if let Some(t) = &mut self.timings {
-            match artifact {
-                Artifact::All => t.unit_finished(id, unlocked),
-                Artifact::Metadata => t.unit_rmeta_finished(id, unlocked),
-            }
+        match artifact {
+            Artifact::All => self.timings.unit_finished(id, unlocked),
+            Artifact::Metadata => self.timings.unit_rmeta_finished(id, unlocked),
         }
         Ok(())
     }

src/cargo/core/compiler/timings.rs

@@ -14,6 +14,8 @@ use std::time::{Duration, Instant, SystemTime};
 
 pub struct Timings<'a, 'cfg> {
     config: &'cfg Config,
+    /// Whether or not timings should be captured.
+    enabled: bool,
     /// If true, saves an HTML report to disk.
     report_html: bool,
     /// If true, reports unit completion to stderr.
@@ -80,6 +82,18 @@ struct Concurrency {
 
 impl<'a, 'cfg> Timings<'a, 'cfg> {
     pub fn new(bcx: &BuildContext<'a, 'cfg>, root_units: &[Unit<'_>]) -> Timings<'a, 'cfg> {
+        let has_report = |what| {
+            bcx.config
+                .cli_unstable()
+                .timings
+                .as_ref()
+                .map_or(false, |t| t.iter().any(|opt| opt == what))
+        };
+        let report_html = has_report("html");
+        let report_info = has_report("info");
+        let report_json = has_report("json");
+        let enabled = report_html | report_info | report_json;
+
         let mut root_map: HashMap<PackageId, Vec<String>> = HashMap::new();
         for unit in root_units {
             let target_desc = unit.target.description_named();
@@ -96,13 +110,6 @@ impl<'a, 'cfg> Timings<'a, 'cfg> {
             })
             .collect();
         let start_str = humantime::format_rfc3339_seconds(SystemTime::now()).to_string();
-        let has_report = |what| {
-            bcx.config
-                .cli_unstable()
-                .timings
-                .as_ref()
-                .map_or(false, |t| t.iter().any(|opt| opt == what))
-        };
         let rustc_info = render_rustc_info(bcx);
         let profile = if bcx.build_config.release {
             "release"
@@ -113,9 +120,10 @@ impl<'a, 'cfg> Timings<'a, 'cfg> {
 
         Timings {
             config: bcx.config,
-            report_html: has_report("html"),
-            report_info: has_report("info"),
-            report_json: has_report("json"),
+            enabled,
+            report_html,
+            report_info,
+            report_json,
             start: bcx.config.creation_time(),
             start_str,
             rustc_info,
@@ -131,6 +139,9 @@ impl<'a, 'cfg> Timings<'a, 'cfg> {
 
     /// Mark that a unit has started running.
     pub fn unit_start(&mut self, id: u32, unit: Unit<'a>) {
+        if !self.enabled {
+            return;
+        }
         let mut target = if unit.target.is_lib() && unit.mode == CompileMode::Build {
             // Special case for brevity, since most dependencies hit
             // this path.
@@ -162,6 +173,9 @@ impl<'a, 'cfg> Timings<'a, 'cfg> {
 
     /// Mark that the `.rmeta` file as generated.
     pub fn unit_rmeta_finished(&mut self, id: u32, unlocked: Vec<&Unit<'a>>) {
+        if !self.enabled {
+            return;
+        }
         // `id` may not always be active. "fresh" units unconditionally
         // generate `Message::Finish`, but this active map only tracks dirty
         // units.
@@ -175,6 +189,9 @@ impl<'a, 'cfg> Timings<'a, 'cfg> {
 
     /// Mark that a unit has finished running.
     pub fn unit_finished(&mut self, id: u32, unlocked: Vec<&Unit<'a>>) {
+        if !self.enabled {
+            return;
+        }
         // See note above in `unit_rmeta_finished`, this may not always be active.
         if let Some(mut unit_time) = self.active.remove(&id) {
             let t = d_as_f64(self.start.elapsed());
@@ -210,6 +227,9 @@ impl<'a, 'cfg> Timings<'a, 'cfg> {
 
     /// This is called periodically to mark the concurrency of internal structures.
     pub fn mark_concurrency(&mut self, active: usize, waiting: usize, inactive: usize) {
+        if !self.enabled {
+            return;
+        }
         let c = Concurrency {
             t: d_as_f64(self.start.elapsed()),
             active,
@@ -231,6 +251,9 @@ impl<'a, 'cfg> Timings<'a, 'cfg> {
 
     /// Call this when all units are finished.
     pub fn finished(&mut self) -> CargoResult<()> {
+        if !self.enabled {
+            return Ok(());
+        }
         self.mark_concurrency(0, 0, 0);
         self.unit_times
             .sort_unstable_by(|a, b| a.start.partial_cmp(&b.start).unwrap());
@@ -241,7 +264,7 @@ impl<'a, 'cfg> Timings<'a, 'cfg> {
     }
 
     /// Save HTML report to disk.
-    pub fn report_html(&self) -> CargoResult<()> {
+    fn report_html(&self) -> CargoResult<()> {
         let duration = self.start.elapsed().as_secs() as u32 + 1;
         let timestamp = self.start_str.replace(&['-', ':'][..], "");
         let filename = format!("cargo-timing-{}.html", timestamp);