Struct ItraceStart

pub struct ItraceStart {
    pub record_id: Option<RecordId>,
    pub task: Task,
}

Instruction tracing has started.

Instruction tracing is a hardware feature that identifies every branch taken by a program so that we can reconstruct the actual control flow of the program.

Only limited platforms support this feature, such as Intel PT, Intel BTS, and Arm SPE.

Examples

use std::fs::read_to_string;
use std::sync::mpsc::channel;
use std::thread;
use std::time::Duration;

use perf_event_open::config::{Cpu, Opts, Proc};
use perf_event_open::count::Counter;
use perf_event_open::event::dp::DynamicPmu;

let (tid_tx, tid_rx) = channel();
thread::spawn(move || {
    tid_tx.send(unsafe { libc::gettid() }).unwrap();
    loop {
        std::hint::spin_loop();
    }
});

// Intel PT
let ty = read_to_string("/sys/bus/event_source/devices/intel_pt/type");

let event = DynamicPmu {
    ty: ty.unwrap().lines().next().unwrap().parse().unwrap(),
    config: 0,
    config1: 0,
    config2: 0,
    config3: 0,
};
let target = (Proc(tid_rx.recv().unwrap() as _), Cpu::ALL);
let opts = Opts::default();

let counter = Counter::new(event, target, opts).unwrap();
let sampler = counter.sampler(10).unwrap();
let aux = sampler.aux_tracer(10).unwrap();

counter.enable().unwrap();
thread::sleep(Duration::from_millis(1));
counter.disable().unwrap();

for it in sampler.iter() {
    println!("{:-?}", it);
}
while let Some(it) = aux.iter().next(None) {
    let bytes = it.len();
    println!("{:.2} KB", bytes as f64 / 1000.0);
}

Since linux-4.1: https://github.com/torvalds/linux/commit/ec0d7729bbaed4b9d2d3fada693278e13a3d1368

Fields

record_id: Option<RecordId>

Record IDs.

task: Task

Task info.

Trait Implementations

impl Clone for ItraceStart

fn clone(&self) -> ItraceStart

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ItraceStart

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

Formats the value using the given formatter.