fixup! Add infrastructure for emitting timing sections

Author: Kobzol

compiler/rustc_errors/src/emitter.rs

@@ -34,7 +34,7 @@ use crate::snippet::{
     Annotation, AnnotationColumn, AnnotationType, Line, MultilineAnnotation, Style, StyledString,
 };
 use crate::styled_buffer::StyledBuffer;
-use crate::timings::TimingSection;
+use crate::timings::TimingRecord;
 use crate::translation::{Translate, to_fluent_args};
 use crate::{
     CodeSuggestion, DiagInner, DiagMessage, ErrCode, FluentBundle, LazyFallbackBundle, Level,
@@ -165,7 +165,7 @@ impl Margin {
     }
 }
 
-pub enum TimingSectionKind {
+pub enum TimingEvent {
     Start,
     End,
 }
@@ -185,7 +185,7 @@ pub trait Emitter: Translate {
 
     /// Emit a timestamp with start/end of a timing section.
     /// Currently only supported for the JSON format.
-    fn emit_timing_section(&mut self, _section: TimingSection, _kind: TimingSectionKind) {}
+    fn emit_timing_section(&mut self, _record: TimingRecord, _event: TimingEvent) {}
 
     /// Emit a report about future breakage.
     /// Currently only supported for the JSON format.

compiler/rustc_errors/src/json.rs

@@ -13,7 +13,6 @@ use std::error::Report;
 use std::io::{self, Write};
 use std::path::Path;
 use std::sync::{Arc, Mutex};
-use std::time::Instant;
 use std::vec;
 
 use derive_setters::Setters;
@@ -29,10 +28,10 @@ use termcolor::{ColorSpec, WriteColor};
 use crate::diagnostic::IsLint;
 use crate::emitter::{
     ColorConfig, Destination, Emitter, HumanEmitter, HumanReadableErrorType, OutputTheme,
-    TimingSectionKind, should_show_source_code,
+    TimingEvent, should_show_source_code,
 };
 use crate::registry::Registry;
-use crate::timings::TimingSection;
+use crate::timings::{TimingRecord, TimingSection};
 use crate::translation::{Translate, to_fluent_args};
 use crate::{
     CodeSuggestion, FluentBundle, LazyFallbackBundle, MultiSpan, SpanLabel, Subdiag, Suggestions,
@@ -62,8 +61,6 @@ pub struct JsonEmitter {
     macro_backtrace: bool,
     track_diagnostics: bool,
     terminal_url: TerminalUrl,
-    #[setters(skip)]
-    start_timestamp: Instant,
 }
 
 impl JsonEmitter {
@@ -89,7 +86,6 @@ impl JsonEmitter {
             macro_backtrace: false,
             track_diagnostics: false,
             terminal_url: TerminalUrl::No,
-            start_timestamp: Instant::now(),
         }
     }
 
@@ -109,7 +105,7 @@ impl JsonEmitter {
 enum EmitTyped<'a> {
     Diagnostic(Diagnostic),
     Artifact(ArtifactNotification<'a>),
-    SectionTimestamp(SectionTimestamp<'a>),
+    SectionTiming(SectionTimestamp<'a>),
     FutureIncompat(FutureIncompatReport<'a>),
     UnusedExtern(UnusedExterns<'a>),
 }
@@ -141,21 +137,16 @@ impl Emitter for JsonEmitter {
         }
     }
 
-    fn emit_timing_section(&mut self, section: TimingSection, kind: TimingSectionKind) {
-        let kind = match kind {
-            TimingSectionKind::Start => "start",
-            TimingSectionKind::End => "end",
+    fn emit_timing_section(&mut self, record: TimingRecord, event: TimingEvent) {
+        let event = match event {
+            TimingEvent::Start => "start",
+            TimingEvent::End => "end",
         };
-        let name = match section {
+        let name = match record.section {
             TimingSection::Linking => "link",
         };
-        let time = Instant::now();
-        let data = SectionTimestamp {
-            name,
-            kind,
-            timestamp: time.duration_since(self.start_timestamp).as_micros(),
-        };
-        let result = self.emit(EmitTyped::SectionTimestamp(data));
+        let data = SectionTimestamp { name, event, timestamp: record.timestamp };
+        let result = self.emit(EmitTyped::SectionTiming(data));
         if let Err(e) = result {
             panic!("failed to print timing section: {e:?}");
         }
@@ -294,8 +285,8 @@ struct SectionTimestamp<'a> {
     /// Name of the section
     name: &'a str,
     /// Start/end of the section
-    kind: &'a str,
-    /// Microseconds elapsed since some predetermined point in time (~start of the rustc process).
+    event: &'a str,
+    /// Opaque timestamp.
     timestamp: u128,
 }
 

compiler/rustc_errors/src/lib.rs

@@ -74,9 +74,9 @@ pub use snippet::Style;
 pub use termcolor::{Color, ColorSpec, WriteColor};
 use tracing::debug;
 
-use crate::emitter::TimingSectionKind;
+use crate::emitter::TimingEvent;
 use crate::registry::Registry;
-use crate::timings::TimingSection;
+use crate::timings::TimingRecord;
 
 pub mod annotate_snippet_emitter_writer;
 pub mod codes;
@@ -1159,12 +1159,12 @@ impl<'a> DiagCtxtHandle<'a> {
         self.inner.borrow_mut().emitter.emit_artifact_notification(path, artifact_type);
     }
 
-    pub fn emit_timing_section_start(&self, section: TimingSection) {
-        self.inner.borrow_mut().emitter.emit_timing_section(section, TimingSectionKind::Start);
+    pub fn emit_timing_section_start(&self, record: TimingRecord) {
+        self.inner.borrow_mut().emitter.emit_timing_section(record, TimingEvent::Start);
     }
 
-    pub fn emit_timing_section_end(&self, section: TimingSection) {
-        self.inner.borrow_mut().emitter.emit_timing_section(section, TimingSectionKind::End);
+    pub fn emit_timing_section_end(&self, record: TimingRecord) {
+        self.inner.borrow_mut().emitter.emit_timing_section(record, TimingEvent::End);
     }
 
     pub fn emit_future_breakage_report(&self) {

compiler/rustc_errors/src/timings.rs

@@ -1,3 +1,5 @@
+use std::time::Instant;
+
 use crate::DiagCtxtHandle;
 
 /// A high-level section of the compilation process.
@@ -7,14 +9,39 @@ pub enum TimingSection {
     Linking,
 }
 
+/// Section with attached timestamp
+#[derive(Copy, Clone, Debug)]
+pub struct TimingRecord {
+    pub section: TimingSection,
+    /// Microseconds elapsed since some predetermined point in time (~start of the rustc process).
+    pub timestamp: u128,
+}
+
+impl TimingRecord {
+    fn from_origin(origin: Instant, section: TimingSection) -> Self {
+        Self { section, timestamp: Instant::now().duration_since(origin).as_micros() }
+    }
+
+    pub fn section(&self) -> TimingSection {
+        self.section
+    }
+
+    pub fn timestamp(&self) -> u128 {
+        self.timestamp
+    }
+}
+
 /// Manages emission of start/end section timings, enabled through `--json=timings`.
 pub struct TimingSectionHandler {
-    enabled: bool,
+    /// Time when the compilation session started.
+    /// If `None`, timing is disabled.
+    origin: Option<Instant>,
 }
 
 impl TimingSectionHandler {
     pub fn new(enabled: bool) -> Self {
-        Self { enabled }
+        let origin = if enabled { Some(Instant::now()) } else { None };
+        Self { origin }
     }
 
     /// Returns a RAII guard that will immediately emit a start the provided section, and then emit
@@ -24,29 +51,30 @@ impl TimingSectionHandler {
         diag_ctxt: DiagCtxtHandle<'a>,
         section: TimingSection,
     ) -> TimingSectionGuard<'a> {
-        TimingSectionGuard::create(diag_ctxt, section, self.enabled)
+        TimingSectionGuard::create(diag_ctxt, section, self.origin)
     }
 }
 
+/// RAII wrapper for starting and ending section timings.
 pub struct TimingSectionGuard<'a> {
     dcx: DiagCtxtHandle<'a>,
     section: TimingSection,
-    enabled: bool,
+    origin: Option<Instant>,
 }
 
 impl<'a> TimingSectionGuard<'a> {
-    fn create(dcx: DiagCtxtHandle<'a>, section: TimingSection, enabled: bool) -> Self {
-        if enabled {
-            dcx.emit_timing_section_start(section);
+    fn create(dcx: DiagCtxtHandle<'a>, section: TimingSection, origin: Option<Instant>) -> Self {
+        if let Some(origin) = origin {
+            dcx.emit_timing_section_start(TimingRecord::from_origin(origin, section));
         }
-        Self { dcx, section, enabled }
+        Self { dcx, section, origin }
     }
 }
 
 impl<'a> Drop for TimingSectionGuard<'a> {
     fn drop(&mut self) {
-        if self.enabled {
-            self.dcx.emit_timing_section_end(self.section);
+        if let Some(origin) = self.origin {
+            self.dcx.emit_timing_section_end(TimingRecord::from_origin(origin, self.section));
         }
     }
 }

compiler/rustc_session/src/config.rs

@@ -1366,7 +1366,7 @@ impl Default for Options {
             real_rust_source_base_dir: None,
             edition: DEFAULT_EDITION,
             json_artifact_notifications: false,
-            json_section_timings: false,
+            json_timings: false,
             json_unused_externs: JsonUnusedExterns::No,
             json_future_incompat: false,
             pretty: None,
@@ -1883,7 +1883,7 @@ pub struct JsonConfig {
     json_artifact_notifications: bool,
     /// Output start and end timestamps of several high-level compilation sections
     /// (frontend, backend, linker).
-    json_section_timings: bool,
+    json_timings: bool,
     pub json_unused_externs: JsonUnusedExterns,
     json_future_incompat: bool,
 }
@@ -1925,7 +1925,7 @@ pub fn parse_json(early_dcx: &EarlyDiagCtxt, matches: &getopts::Matches) -> Json
     let mut json_artifact_notifications = false;
     let mut json_unused_externs = JsonUnusedExterns::No;
     let mut json_future_incompat = false;
-    let mut json_section_timings = false;
+    let mut json_timings = false;
     for option in matches.opt_strs("json") {
         // For now conservatively forbid `--color` with `--json` since `--json`
         // won't actually be emitting any colors and anything colorized is
@@ -1942,7 +1942,7 @@ pub fn parse_json(early_dcx: &EarlyDiagCtxt, matches: &getopts::Matches) -> Json
                 }
                 "diagnostic-rendered-ansi" => json_color = ColorConfig::Always,
                 "artifacts" => json_artifact_notifications = true,
-                "timings" => json_section_timings = true,
+                "timings" => json_timings = true,
                 "unused-externs" => json_unused_externs = JsonUnusedExterns::Loud,
                 "unused-externs-silent" => json_unused_externs = JsonUnusedExterns::Silent,
                 "future-incompat" => json_future_incompat = true,
@@ -1955,7 +1955,7 @@ pub fn parse_json(early_dcx: &EarlyDiagCtxt, matches: &getopts::Matches) -> Json
         json_rendered,
         json_color,
         json_artifact_notifications,
-        json_section_timings,
+        json_timings,
         json_unused_externs,
         json_future_incompat,
     }
@@ -2483,7 +2483,7 @@ pub fn build_session_options(early_dcx: &mut EarlyDiagCtxt, matches: &getopts::M
         json_rendered,
         json_color,
         json_artifact_notifications,
-        json_section_timings,
+        json_timings,
         json_unused_externs,
         json_future_incompat,
     } = parse_json(early_dcx, matches);
@@ -2505,7 +2505,7 @@ pub fn build_session_options(early_dcx: &mut EarlyDiagCtxt, matches: &getopts::M
     let mut unstable_opts = UnstableOptions::build(early_dcx, matches, &mut target_modifiers);
     let (lint_opts, describe_lints, lint_cap) = get_cmd_lint_options(early_dcx, matches);
 
-    if !unstable_opts.unstable_options && json_section_timings {
+    if !unstable_opts.unstable_options && json_timings {
         early_dcx.early_fatal("--json=timings is unstable and requires using `-Zunstable-options`");
     }
 
@@ -2786,7 +2786,7 @@ pub fn build_session_options(early_dcx: &mut EarlyDiagCtxt, matches: &getopts::M
         real_rust_source_base_dir,
         edition,
         json_artifact_notifications,
-        json_section_timings,
+        json_timings,
         json_unused_externs,
         json_future_incompat,
         pretty,

compiler/rustc_session/src/options.rs

@@ -412,7 +412,7 @@ top_level_options!(
 
         /// `true` if we're emitting JSON timings with the start and end of
         /// high-level compilation sections
-        json_section_timings: bool [UNTRACKED],
+        json_timings: bool [UNTRACKED],
 
         /// `true` if we're emitting a JSON blob containing the unused externs
         json_unused_externs: JsonUnusedExterns [UNTRACKED],

compiler/rustc_session/src/session.rs

@@ -1130,7 +1130,7 @@ pub fn build_session(
         .as_ref()
         .map(|_| rng().next_u32().to_base_fixed_len(CASE_INSENSITIVE).to_string());
 
-    let timings = TimingSectionHandler::new(sopts.json_section_timings);
+    let timings = TimingSectionHandler::new(sopts.json_timings);
 
     let sess = Session {
         target,

src/doc/rustc/src/command-line-arguments.md

@@ -471,6 +471,9 @@ to customize the output:
 - `future-incompat` - includes a JSON message that contains a report if the
   crate contains any code that may fail to compile in the future.
 
+- `timings` - output a JSON message when a certain compilation "section"
+  (such as frontend analysis, code generation, linking) begins or ends.
+
 Note that it is invalid to combine the `--json` argument with the
 [`--color`](#option-color) argument, and it is required to combine `--json`
 with `--error-format=json`.

src/doc/rustc/src/json.md

@@ -298,6 +298,31 @@ appropriately. (This is needed by Cargo which shares the same dependencies
 across multiple build targets, so it should only report an unused dependency if
 its not used by any of the targets.)
 
+## Timings
+
+**This setting is currently unstable and requires usage of `-Zunstable-options`.**
+
+The `--timings` option will tell `rustc` to emit messages when a certain compilation
+section (such as code generation or linking) begins or ends. The messages will have
+the following format:
+
+```json
+{
+    "$message_type": "section_timing", /* Type of this message */
+    "event": "start", /* Marks the "start" or "end" of the compilation section */
+    "name": "link",  /* The name of the compilation section */
+    "time": 12345    /* Opaque timestamp when the message was emitted, in microseconds */
+}
+```
+
+Compilation sections can be nested; for example, if you encounter the start of "foo",
+then the start of "bar", then the end of "bar" and then the end of "bar", it means that the
+"bar" section happened as a part of the "foo" section.
+
+The timestamp should only be used for computing the duration of each section.
+
+We currently do not guarantee any specific section names to be emitted.
+
 [option-emit]: command-line-arguments.md#option-emit
 [option-error-format]: command-line-arguments.md#option-error-format
 [option-json]: command-line-arguments.md#option-json