Struct AccessTraceWriter 

pub struct AccessTraceWriter { /* private fields */ }

Writes the trace as the scheduler records events. It lives in the scheduler, so records are numbered and ordered under the scheduler’s lock.

Implementations

impl AccessTraceWriter

pub fn create( path: &Path, from: EventIndex, max_records: Option<u64>, max_bytes: Option<u64>, ) -> Result<Self>

Create the trace at path and write its header.

pub fn observe( &mut self, index: EventIndex, event: &SchedEvent, payload: Option<AccessPayload>, groups: &dyn ProcessGroups, )

Take the event the scheduler just recorded at index, and its payload.

pub fn note_wake( &mut self, kind: EdgeKind, waker: DetTid, waiter: DetTid, object: SyncObject, )

waker’s operation released waiter through object: a futex wake or requeue (from the waker’s syscall) or an exit’s wake (from the exiting thread’s last event). The edge ends at the waiter’s next posthook, the return of the wait it was released from.

pub fn note_thread_gone(&mut self, tid: DetTid)

tid is gone: the scheduler retired it, after the wakes its exit makes. Forget what the writer keeps for it, so a later task that reuses its id ends none of its edges and is not taken for it: the edges waiting for its next posthook or first event, its first and latest events, its process, and the sends to it alone, which Linux discards with it. Its open syscall, which no posthook will end, is kept for the end of the trace, where every open record is written. So is its first event while no clone’s return has claimed it: a child can run and be gone before its parent’s clone returns (a forked child that exits at once), and that return still starts its creation edge.

pub fn rekey_thread(&mut self, former: DetTid, leader: DetTid)

former exec’d from a thread other than its process’s leader and goes on as leader. Linux keeps the exec caller’s task and gives it the leader’s thread id, and the signals pending for that task alone stay queued on it. So the sends to former alone, pending or evicted, now target leader. The scheduler calls this after it has retired the old leader, whose own sends Linux discards with it, and before it retires former’s id (Self::note_thread_gone), which would otherwise drop them: a sigqueue send to itself that keeps its process’s deliveries of that signal without an edge (SendKind::Queue), and a tkill whose delivery to the leader it causes.

pub fn finish(self, events: u64) -> Result<()>

Write the calls that never returned and the end line, and flush. events is the number of events the run recorded.

Trait Implementations

impl Debug for AccessTraceWriter

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

Formats the value using the given formatter.