Struct EventCounterSample 

#[non_exhaustive]
pub struct EventCounterSample {

    pub elapsed_ms: u64,
    pub select_cpu_fallback: i64,
    pub dispatch_local_dsq_offline: i64,
    pub dispatch_keep_last: i64,
    pub enq_skip_exiting: i64,
    pub enq_skip_migration_disabled: i64,
    pub reenq_immed: i64,
    pub reenq_local_repeat: i64,
    pub refill_slice_dfl: i64,
    pub bypass_duration: i64,
    pub bypass_dispatch: i64,
    pub bypass_activate: i64,
    pub insert_not_owned: i64,
    pub sub_bypass_dispatch: i64,
}

One per-monitor-tick snapshot of the 13 SCX_EV_* event counters summed across every CPU at that tick.

The kernel stores per-CPU s64 counters in scx_sched_pcpu (kernel/sched/ext.c); the monitor sampler reads them at every tick and stores per-CPU event_counters on each super::CpuSnapshot. The dump path sums across CPUs into the fields here so a downstream consumer can render the run’s counter timeline (sparkline, delta plot, …) without re-iterating the per-CPU vec.

Field semantics match super::ScxEventCounters one-to-one — see that struct’s per-field doc for kernel-source provenance. total_* naming here echoes super::ScxEventDeltas’s aggregate-across-window fields but with per-tick (not per-window) granularity.

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

elapsed_ms: u64

Milliseconds since VM start (mirrors super::MonitorSample::elapsed_ms). Zero on the first sample.

select_cpu_fallback: i64

Sum of select_cpu_fallback across all CPUs at this tick.

dispatch_local_dsq_offline: i64

Sum of dispatch_local_dsq_offline across all CPUs.

dispatch_keep_last: i64

Sum of dispatch_keep_last across all CPUs.

enq_skip_exiting: i64

Sum of enq_skip_exiting across all CPUs.

enq_skip_migration_disabled: i64

Sum of enq_skip_migration_disabled across all CPUs.

reenq_immed: i64

Sum of reenq_immed across all CPUs.

reenq_local_repeat: i64

Sum of reenq_local_repeat across all CPUs.

refill_slice_dfl: i64

Sum of refill_slice_dfl across all CPUs.

bypass_duration: i64

Sum of bypass_duration across all CPUs (ns).

bypass_dispatch: i64

Sum of bypass_dispatch across all CPUs.

bypass_activate: i64

Sum of bypass_activate across all CPUs.

insert_not_owned: i64

Sum of insert_not_owned across all CPUs.

sub_bypass_dispatch: i64

Sum of sub_bypass_dispatch across all CPUs.

Implementations

impl EventCounterSample

pub fn from_monitor_sample(sample: &MonitorSample) -> Option<Self>

Construct from a super::MonitorSample by summing every CPU’s super::ScxEventCounters. CPUs whose event_counters is None (event-stat offsets unresolved) contribute 0 to every field.

Returns None when no CPU on the sample reported event counters — propagating that to the timeline would emit a row of all zeros that’s indistinguishable from a real “every counter at zero” tick. Callers filter None out.

Trait Implementations

impl Clone for EventCounterSample

fn clone(&self) -> EventCounterSample

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for EventCounterSample

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

Formats the value using the given formatter.

impl Default for EventCounterSample

fn default() -> EventCounterSample

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for EventCounterSample

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for EventCounterSample

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

where __S: Serializer,

Serialize this value into the given Serde serializer.