Struct perf_event::Counts

pub struct Counts { /* fields omitted */ }

A collection of counts from a Group of counters.

This is the type returned by calling read on a Group. You can index it with a reference to a specific Counter:

let counts = group.read()?;
println!("cycles / instructions: {} / {} ({:.2} cpi)",
         counts[&cycles],
         counts[&insns],
         (counts[&cycles] as f64 / counts[&insns] as f64));

Or you can iterate over the results it contains:

for (id, value) in &counts {
    println!("Counter id {} has value {}", id, value);
}

The id values produced by this iteration are internal identifiers assigned by the kernel. You can use the Counter::id method to find a specific counter's id.

For some kinds of events, the kernel may use timesharing to give all counters access to scarce hardware registers. You can see how long a group was actually running versus the entire time it was enabled using the time_enabled and time_running methods:

let scale = counts.time_enabled() as f64 /
            counts.time_running() as f64;
for (id, value) in &counts {
    print!("Counter id {} has value {}",
           id, (*value as f64 * scale) as u64);
    if scale > 1.0 {
        print!(" (estimated)");
    }
    println!();
}

Implementations

impl Counts

pub fn len(&self) -> usize

Return the number of counters this Counts holds results for.

pub fn time_enabled(&self) -> u64

Return the number of nanoseconds the Group was enabled that contributed to this Counts' contents.

pub fn time_running(&self) -> u64

Return the number of nanoseconds the Group was actually collecting counts that contributed to this Counts' contents.

impl Counts

pub fn get(&self, member: &Counter) -> Option<&u64>

Return the value recorded for member in self, or None if member is not present.

If you know that member is in the group, you can simply index:

let cycles = counts[&cycle_counter];

pub fn iter(&self) -> CountsIter<'_>

Return an iterator over the counts in self.

for (id, value) in &counts {
    println!("Counter id {} has value {}", id, value);
}

Each item is a pair (id, &value), where id is the number assigned to the counter by the kernel (see Counter::id), and value is that counter's value.

Trait Implementations

impl Debug for Counts

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

Formats the value using the given formatter.

impl<'_> Index<&'_ Counter> for Counts

type Output = u64

The returned type after indexing.

pub fn index(&self, index: &Counter) -> &u64

Performs the indexing (container[index]) operation.

impl<'c> IntoIterator for &'c Counts

type Item = (u64, &'c u64)

The type of the elements being iterated over.

type IntoIter = CountsIter<'c>

Which kind of iterator are we turning this into?

pub fn into_iter(self) -> CountsIter<'c>

Creates an iterator from a value.