Struct Timings 

pub struct Timings<'gctx> {

    gctx: &'gctx GlobalContext,
    enabled: bool,
    report_html: bool,
    report_json: bool,
    start: Instant,
    start_str: String,
    root_targets: Vec<(String, Vec<String>)>,
    profile: String,
    total_fresh: u32,
    total_dirty: u32,
    unit_times: Vec<UnitTime>,
    active: HashMap<JobId, UnitTime>,
    concurrency: Vec<Concurrency>,
    last_cpu_state: Option<State>,
    last_cpu_recording: Instant,
    cpu_usage: Vec<(f64, f64)>,
}

Tracking information for the entire build.

Methods on this structure are generally called from the main thread of a running JobQueue instance (DrainState in specific) when the queue receives messages from spawned off threads.

Fields

gctx: &'gctx GlobalContext

enabled: bool

Whether or not timings should be captured.

report_html: bool

If true, saves an HTML report to disk.

report_json: bool

If true, emits JSON information with timing information.

start: Instant

When Cargo started.

start_str: String

A rendered string of when compilation started.

root_targets: Vec<(String, Vec<String>)>

A summary of the root units.

Tuples of (package_description, target_descriptions).

profile: String

The build profile.

total_fresh: u32

Total number of fresh units.

total_dirty: u32

Total number of dirty units.

unit_times: Vec<UnitTime>

Time tracking for each individual unit.

active: HashMap<JobId, UnitTime>

Units that are in the process of being built. When they finished, they are moved to unit_times.

concurrency: Vec<Concurrency>

Concurrency-tracking information. This is periodically updated while compilation progresses.

last_cpu_state: Option<State>

Last recorded state of the system’s CPUs and when it happened

last_cpu_recording: Instant

cpu_usage: Vec<(f64, f64)>

Recorded CPU states, stored as tuples. First element is when the recording was taken and second element is percentage usage of the system.

Implementations

impl<'gctx> Timings<'gctx>

pub fn new(bcx: &BuildContext<'_, 'gctx>, root_units: &[Unit]) -> Timings<'gctx>

pub fn unit_start(&mut self, id: JobId, unit: Unit)

Mark that a unit has started running.

pub fn unit_rmeta_finished(&mut self, id: JobId, unlocked: Vec<&Unit>)

Mark that the .rmeta file as generated.

pub fn unit_finished( &mut self, build_runner: &BuildRunner<'_, '_>, id: JobId, unlocked: Vec<&Unit>, )

Mark that a unit has finished running.

pub fn unit_section_timing(&mut self, id: JobId, section_timing: &SectionTiming)

Handle the start/end of a compilation section.

pub fn mark_concurrency( &mut self, active: usize, waiting: usize, inactive: usize, )

This is called periodically to mark the concurrency of internal structures.

pub fn add_fresh(&mut self)

Mark that a fresh unit was encountered. (No re-compile needed)

pub fn add_dirty(&mut self)

Mark that a dirty unit was encountered. (Re-compile needed)

pub fn record_cpu(&mut self)

Take a sample of CPU usage

pub fn finished( &mut self, build_runner: &BuildRunner<'_, '_>, error: &Option<Error>, ) -> CargoResult<()>

Call this when all units are finished.

fn report_html( &self, build_runner: &BuildRunner<'_, '_>, error: &Option<Error>, ) -> CargoResult<()>

Save HTML report to disk.

fn write_summary_table( &self, f: &mut impl Write, duration: f64, bcx: &BuildContext<'_, '_>, error: &Option<Error>, ) -> CargoResult<()>

Render the summary table.

fn write_js_data(&self, f: &mut impl Write) -> CargoResult<()>

Write timing data in JavaScript. Primarily for timings.js to put data in a <script> HTML element to draw graphs.

fn write_unit_table(&self, f: &mut impl Write) -> CargoResult<()>

Render the table of all units.

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 336 bytes