Struct ThreadStats 

pub struct ThreadStats {
    pub syscall_count: u64,
    pub regs_sample_index: u64,
    pub signal_count: u64,
    pub timeslice_syscall_count: u64,
    pub timeslice_signal_count: u64,
    pub timeslice_count: u64,
    pub last_recorded_slice: Option<u64>,
    pub timeslice_stats: TimesliceStats,
    pub timeslice_start_ns: Option<LogicalTime>,
}

Various measurements of one guest thread’s execution. This is useful for printing context in logs as we go and printing a final summary.

Fields

syscall_count: u64

A simple count of how many syscalls have been handled on this thread.

regs_sample_index: u64

How many register-file samples this thread has CONSIDERED for --detlog-regs.

This is the cadence index, and it exists because no pre-existing counter is a clean zero-based count of control points: the logged syscall ordinal starts at 2, and syscall_count also counts points this sampler never reaches. Keying the cadence on either let a short guest whose points never landed on a multiple of N emit ZERO samples while the run still reported PASS – a spot-tier green backed by nothing. Counting the samples themselves makes index 0 the first control point of every thread, so a spot-tier run always samples at least once.

signal_count: u64

A count of how many signals have arrived at this thread, total.

timeslice_syscall_count: u64

How many syscalls this time slice (since last preemption)?

timeslice_signal_count: u64

How many signals this time slice (since last preemption)?

timeslice_count: u64

How many logical timeslices have we completed before the current one? These correspond to when we are preempted at the end_of_timeslice.

last_recorded_slice: Option<u64>

The timeslice_count for the timeslice which was the last one that had a recorded end time in the --replay-preemptions-from log.

timeslice_stats: TimesliceStats

Distribution (min/max/sum/count) of completed timeslice durations for this thread, in virtual nanoseconds. A slice’s duration is the delta of thread_logical_time between two consecutive next_timeslice resets.

timeslice_start_ns: Option<LogicalTime>

The per-thread logical time (virtual ns) at which the current timeslice began. None until the first slice is opened. Used to compute the duration of a slice when the next reset occurs.

Implementations

impl ThreadStats

pub fn new() -> Self

Create a new thread stats with zero counters.

pub fn count_syscall(&mut self)

Increment the count of system calls

pub fn count_signal(&mut self)

Increment the count of signals.

pub fn close_final_timeslice(&mut self, now: LogicalTime)

Close the final, in-progress timeslice at thread exit, recording its virtual-ns duration. This captures short-lived or I/O-bound threads that exit (or block until exit) before ever exhausting a slice, so they still contribute one sample. Idempotent: consumes timeslice_start_ns.

Trait Implementations

impl Clone for ThreadStats

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for ThreadStats

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for ThreadStats

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for ThreadStats

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for ThreadStats

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.