Enum WorkPhase 

pub enum WorkPhase {
    Spin(Duration),
    Sleep(Duration),
    Yield(Duration),
    Io(Duration),
    AluHot {
        width: AluWidth,
        duration: Duration,
    },
}

A single phase in a WorkType::Sequence compound work pattern.

Workers loop through all phases in order, then repeat. Each phase runs for its specified duration before advancing to the next.

Variants

Spin(Duration)

CPU spin for the given duration.

Sleep(Duration)

Sleep (thread::sleep) for the given duration.

Yield(Duration)

Yield (sched_yield) repeatedly for the given duration.

Io(Duration)

Simulated I/O (write 64 KB to a tempfile + 100 us sleep) for the given duration. The tempfile lives on whatever filesystem std::env::temp_dir() returns; on the ktstr guest’s tmpfs the write is a page-cache memcpy and the sleep provides the blocking behavior that real disk fsync would cause. WorkType::IoSyncWrite (the standalone variant) is the disk-IO counterpart that opens /dev/vda directly.

AluHot

ALU-bound multiply chain for the given duration. The width selector picks the data path the same way as WorkType::AluHot — see AluWidth for the resolution rules and the AVX-512 / AMX caveats. Each visit runs alu_hot_chain in 1024-step batches in a deadline-bounded loop so shutdown latency stays bounded by one batch.

The composable counterpart to WorkType::AluHot: use this inside a Sequence to express duty-cycle patterns (“ALU 90 % / Sleep 10 %”) that the standalone WorkType::AluHot cannot, since the standalone variant runs ALU work for the entire scenario duration.

Fields

width: AluWidth

SIMD / scalar width selector for the multiply chain; resolved per phase visit via resolve_alu_width. See AluWidth for the per-variant data-path width and the runtime resolution rules.

duration: Duration

Wall-clock duration of the ALU phase. Workers retire alu_hot_chain batches until this deadline passes.

Implementations

impl WorkPhase

pub const fn alu_hot(width: AluWidth, duration: Duration) -> Self

Construct a WorkPhase::AluHot variant. Sugar for the struct-literal form that brings the struct variant in line with the tuple-variant constructors — every other WorkPhase variant takes a single Duration and reads as WorkPhase::Spin(d) etc.; the struct variant needs an explicit WorkPhase::AluHot { width: ..., duration: ... } block at every call site, breaking the visual symmetry. WorkPhase::alu_hot(w, d) restores it so vec![WorkPhase::Spin(d1), WorkPhase::alu_hot(w, d2), WorkPhase::Sleep(d3)] reads consistently.

Trait Implementations

impl Clone for WorkPhase

fn clone(&self) -> WorkPhase

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for WorkPhase

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for WorkPhase

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Hash for WorkPhase

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for WorkPhase

fn eq(&self, other: &WorkPhase) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for WorkPhase

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for WorkPhase

impl StructuralPartialEq for WorkPhase