Enum TraceData 

pub enum TraceData {
    None,
    Task {
        task: TaskId,
        region: RegionId,
    },
    Region {
        region: RegionId,
        parent: Option<RegionId>,
    },
    Obligation {
        obligation: ObligationId,
        task: TaskId,
        region: RegionId,
        kind: ObligationKind,
        state: ObligationState,
        duration_ns: Option<u64>,
        abort_reason: Option<ObligationAbortReason>,
    },
    Cancel {
        task: TaskId,
        region: RegionId,
        reason: CancelReason,
    },
    RegionCancel {
        region: RegionId,
        reason: CancelReason,
    },
    Time {
        old: Time,
        new: Time,
    },
    Timer {
        timer_id: u64,
        deadline: Option<Time>,
    },
    IoRequested {
        token: u64,
        interest: u8,
    },
    IoReady {
        token: u64,
        readiness: u8,
    },
    IoResult {
        token: u64,
        bytes: i64,
    },
    IoError {
        token: u64,
        kind: u8,
    },
    RngSeed {
        seed: u64,
    },
    RngValue {
        value: u64,
    },
    Checkpoint {
        sequence: u64,
        active_tasks: u32,
        active_regions: u32,
    },
    Futurelock {
        task: TaskId,
        region: RegionId,
        idle_steps: u64,
        held: Vec<(ObligationId, ObligationKind)>,
    },
    Monitor {
        monitor_ref: u64,
        watcher: TaskId,
        watcher_region: RegionId,
        monitored: TaskId,
    },
    Down {
        monitor_ref: u64,
        watcher: TaskId,
        monitored: TaskId,
        completion_vt: Time,
        reason: DownReason,
    },
    Link {
        link_ref: u64,
        task_a: TaskId,
        region_a: RegionId,
        task_b: TaskId,
        region_b: RegionId,
    },
    Exit {
        link_ref: u64,
        from: TaskId,
        to: TaskId,
        failure_vt: Time,
        reason: DownReason,
    },
    Message(String),
    Chaos {
        kind: String,
        task: Option<TaskId>,
        detail: String,
    },
}

Additional data carried by a trace event.

Variants

None

No additional data.

Task

Task-related data.

Fields

task: TaskId

The task involved.

region: RegionId

The region the task belongs to.

Region

Region-related data.

Fields

region: RegionId

The region involved.

parent: Option<RegionId>

The parent region, if any.

Obligation

Obligation-related data.

Fields

obligation: ObligationId

The obligation involved.

task: TaskId

The task holding the obligation.

region: RegionId

The region that owns the obligation.

kind: ObligationKind

The kind of obligation.

state: ObligationState

The obligation state at this event.

duration_ns: Option<u64>

Duration held in nanoseconds, if resolved.

abort_reason: Option<ObligationAbortReason>

Abort reason, if aborted.

Cancel

Cancellation data.

Fields

task: TaskId

The task involved.

region: RegionId

The region involved.

reason: CancelReason

The reason for cancellation.

RegionCancel

Region cancellation data.

Fields

region: RegionId

The region involved.

reason: CancelReason

The reason for cancellation.

Time

Time data.

Fields

old: Time

The previous time.

new: Time

The new time.

Timer

Timer data.

Fields

timer_id: u64

Timer identifier.

deadline: Option<Time>

Deadline, if applicable.

IoRequested

I/O interest request data.

Fields

token: u64

I/O token.

interest: u8

Interest bitflags (readable=1, writable=2, error=4, hangup=8).

IoReady

I/O readiness data.

Fields

token: u64

I/O token.

readiness: u8

Readiness bitflags (readable=1, writable=2, error=4, hangup=8).

IoResult

I/O result data.

Fields

token: u64

I/O token.

bytes: i64

Bytes transferred (negative for errors).

IoError

I/O error data.

Fields

token: u64

I/O token.

kind: u8

Error kind as u8 (maps to io::ErrorKind).

RngSeed

RNG seed data.

Fields

seed: u64

Seed value.

RngValue

RNG value data.

Fields

value: u64

Generated value.

Checkpoint

Checkpoint data.

Fields

sequence: u64

Monotonic sequence number.

active_tasks: u32

Active task count.

active_regions: u32

Active region count.

Futurelock

Futurelock detection data.

Fields

task: TaskId

The task that futurelocked.

region: RegionId

The owning region of the task.

idle_steps: u64

How many lab steps since the task was last polled.

held: Vec<(ObligationId, ObligationKind)>

Obligations held by the task at detection time.

Monitor

Monitor lifecycle event.

Fields

monitor_ref: u64

Monitor reference id.

watcher: TaskId

The task watching for termination.

watcher_region: RegionId

The region owning the watcher (for region-close cleanup).

monitored: TaskId

The task being monitored.

Down

Down notification delivery.

Includes the deterministic ordering key (completion_vt, monitored).

Fields

monitor_ref: u64

Monitor reference id from establishment.

watcher: TaskId

The task receiving the notification.

monitored: TaskId

The task that terminated.

completion_vt: Time

Virtual time of monitored task completion.

reason: DownReason

Why it terminated.

Link

Link lifecycle event.

Fields

link_ref: u64

Link reference id.

task_a: TaskId

One side of the link.

region_a: RegionId

Region owning task_a (for region-close cleanup).

task_b: TaskId

The other side of the link.

region_b: RegionId

Region owning task_b (for region-close cleanup).

Exit

Exit signal delivery to a linked task.

Includes the deterministic ordering key (failure_vt, from).

Fields

link_ref: u64

Link reference id.

from: TaskId

The task that terminated (source of the exit).

to: TaskId

The linked task receiving the exit signal.

failure_vt: Time

Virtual time of failure used for deterministic ordering.

reason: DownReason

Why it terminated.

Message(String)

User message.

Chaos

Chaos injection data.

Fields

kind: String

Kind of chaos injected (e.g., “cancel”, “delay”, “budget_exhaust”, “wakeup_storm”).

task: Option<TaskId>

The task affected, if any.

detail: String

Additional detail.

Trait Implementations

impl Clone for TraceData

fn clone(&self) -> TraceData

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for TraceData

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

Formats the value using the given formatter.

impl PartialEq for TraceData

fn eq(&self, other: &TraceData) -> 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 Eq for TraceData

impl StructuralPartialEq for TraceData