Struct cpu_cycles_reader::Cycles

pub struct Cycles { /* private fields */ }

Cycles provides a way to represent the number of cycles

Implementations

impl Cycles

pub fn as_usage(&self, d: Duration, f: Self) -> Result<f64, Box<dyn Error>>

Returns the average number of cpu usage within a specified time

May be >100%, because the current frequency read is only a suggested frequency, not a real frequency, but the cycles are real

d: record the time of cycles

f: frequencey of this cpu core as Cycles

Suggestion: Read /sys/devices/system/cpu/cpuX/cpufreq/scaling_cur_freq to get the current frequency

Errors

Divide by zero or fail to trans u128 to i64

use std::{fs, time::{Duration, Instant}};
use cpu_cycles_reader::Cycles;

let now = Instant::now();
let cycles_former = Cycles::from_ghz(1); // Suppose it is 1ghz at this time

// The cpu has performed some operations, assuming we are recording cpu7

let dur = Instant::now() - now;
let cycles_later = Cycles::from_ghz(2); // Suppose it is 2ghz at this time

let path = format!("/sys/devices/system/cpu/cpu{}/cpufreq/scaling_cur_freq", 7);
let cur_freq = fs::read_to_string(&path).unwrap();
let cur_freq = cur_freq.parse().unwrap();
let freq_cycles = Cycles::from_khz(cur_freq);

let cycles = cycles_later - cycles_former;
println!("{:.2}", cycles.as_usage(dur, freq_cycles).unwrap()); // Suppose you read cycles on cpu7

pub fn as_diff(&self, d: Duration, f: Self) -> Result<Self, Box<dyn Error>>

Similar to as_usage, but returns the difference from the current frequency Cycles

For the same reason, diff may be negative

d: record the time of cycles

f: frequencey of this cpu core as Cycles

Suggestion: Read /sys/devices/system/cpu/cpuX/cpufreq/scaling_cur_freq to get the current frequency

Errors

Divide by zero

use std::{fs, time::{Duration, Instant}};
use cpu_cycles_reader::Cycles;

let now = Instant::now();
let cycles_former = Cycles::from_ghz(1); // Suppose it is 1ghz at this time

// The cpu has performed some operations, assuming we are recording the cpu7

let dur = Instant::now() - now;
let cycles_later = Cycles::from_ghz(2); // Suppose it is 2ghz at this time

let cycles = cycles_later - cycles_former;

let path = format!("/sys/devices/system/cpu/cpu{}/cpufreq/scaling_cur_freq", 7);
let cur_freq = fs::read_to_string(&path).unwrap();
let cur_freq = cur_freq.parse().unwrap();
let freq_cycles = Cycles::from_khz(cur_freq);

println!("{}", cycles.as_diff(dur, freq_cycles).unwrap());

impl Cycles

pub const fn from_hz(h: c_ll) -> Self

use cpu_cycles_reader::Cycles;

assert_eq!(Cycles::new(1000), Cycles::from_hz(1000));

pub const fn from_khz(k: c_ll) -> Self

use cpu_cycles_reader::Cycles;

assert_eq!(Cycles::new(1000), Cycles::from_khz(1));

pub const fn from_mhz(m: c_ll) -> Self

use cpu_cycles_reader::Cycles;

assert_eq!(Cycles::new(2_000_000), Cycles::from_mhz(2));

pub const fn from_ghz(g: c_ll) -> Self

use cpu_cycles_reader::Cycles;

assert_eq!(Cycles::new(3_000_000_000), Cycles::from_ghz(3));

pub const fn as_hz(&self) -> c_ll

use cpu_cycles_reader::Cycles;

assert_eq!(Cycles::new(1000).as_hz(), 1000);

pub const fn as_khz(&self) -> c_ll

use cpu_cycles_reader::Cycles;

assert_eq!(Cycles::new(1_000_000).as_khz(), 1000);

pub const fn as_mhz(&self) -> c_ll

use cpu_cycles_reader::Cycles;

assert_eq!(Cycles::new(1_000_000_000).as_mhz(), 1000);

pub const fn as_ghz(&self) -> c_ll

use cpu_cycles_reader::Cycles;

assert_eq!(Cycles::new(1_000_000_000_000).as_ghz(), 1000);

impl Cycles

pub fn new(raw: c_ll) -> Cycles

Trait Implementations

impl Add<Cycles> for Cycles

type Output = Cycles

The resulting type after applying the + operator.

fn add(self, rhs: Cycles) -> Cycles

Performs the + operation.

impl AddAssign<Cycles> for Cycles

fn add_assign(&mut self, rhs: Cycles)

Performs the += operation.

impl Clone for Cycles

fn clone(&self) -> Cycles

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Cycles

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

Formats the value using the given formatter.

impl Display for Cycles

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

Formats the value using the given formatter.

impl<__RhsT> Div<__RhsT> for Cycleswhere c_ll: Div<__RhsT, Output = c_ll>,

type Output = Cycles

The resulting type after applying the / operator.

fn div(self, rhs: __RhsT) -> Cycles

Performs the / operation.

impl<__RhsT> DivAssign<__RhsT> for Cycleswhere c_ll: DivAssign<__RhsT>,

fn div_assign(&mut self, rhs: __RhsT)

Performs the /= operation.

impl From<Cycles> for c_ll

fn from(original: Cycles) -> Self

Converts to this type from the input type.

impl From<i64> for Cycles

fn from(original: c_ll) -> Cycles

Converts to this type from the input type.

impl<__RhsT> Mul<__RhsT> for Cycleswhere c_ll: Mul<__RhsT, Output = c_ll>,

type Output = Cycles

The resulting type after applying the * operator.

fn mul(self, rhs: __RhsT) -> Cycles

Performs the * operation.

impl<__RhsT> MulAssign<__RhsT> for Cycleswhere c_ll: MulAssign<__RhsT>,

fn mul_assign(&mut self, rhs: __RhsT)

Performs the *= operation.

impl Neg for Cycles

type Output = Cycles

The resulting type after applying the - operator.

fn neg(self) -> Cycles

Performs the unary - operation.

impl Ord for Cycles

fn cmp(&self, other: &Cycles) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Selfwhere Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Selfwhere Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Selfwhere Self: Sized + PartialOrd<Self>,

Restrict a value to a certain interval.

impl PartialEq<Cycles> for Cycles

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl PartialOrd<Cycles> for Cycles

fn partial_cmp(&self, other: &Cycles) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

This method tests less than (for self and other) and is used by the < operator.

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

This method tests less than or equal to (for self and other) and is used by the <= operator.

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

This method tests greater than (for self and other) and is used by the > operator.

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

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<__RhsT> Rem<__RhsT> for Cycleswhere c_ll: Rem<__RhsT, Output = c_ll>,

type Output = Cycles

The resulting type after applying the % operator.

fn rem(self, rhs: __RhsT) -> Cycles

Performs the % operation.

impl<__RhsT> RemAssign<__RhsT> for Cycleswhere c_ll: RemAssign<__RhsT>,

fn rem_assign(&mut self, rhs: __RhsT)

Performs the %= operation.

impl Sub<Cycles> for Cycles

type Output = Cycles

The resulting type after applying the - operator.

fn sub(self, rhs: Cycles) -> Cycles

Performs the - operation.

impl SubAssign<Cycles> for Cycles

fn sub_assign(&mut self, rhs: Cycles)

Performs the -= operation.

impl Sum<Cycles> for Cycles

fn sum<I: Iterator<Item = Self>>(iter: I) -> Self

Method which takes an iterator and generates Self from the elements by “summing up” the items.

impl Copy for Cycles

impl Eq for Cycles

impl StructuralEq for Cycles

impl StructuralPartialEq for Cycles