Struct cpu_cycles_reader::Cycles

pub struct Cycles { /* private fields */ }

Implementations

impl Cycles

pub fn as_usage(&self, d: Duration, c: u64) -> 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 c: cpu core number Read /sys/devices/system/cpu/cpuX/cpufreq/scaling_cur_freq to get the current frequency

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

let now = Instant::now();
let cycles_former = Cycles::from_ghz(1);

// cpu进行了一些操作，假设我们记录的是cpu7

let dur = Instant::now() - now;
let cycles_later = Cycles::from_ghz(2);

let cycles = cycles_later - cycles_former;
println!("{:.2}", cycles.as_usage(dur, 7).unwrap());

pub fn as_diff(&self, d: Duration, c: c_int) -> Option<Cycles>

Similar to as_usage, but returns the difference from the current frequency self::Cycles For the same reason, diff may be negative d: record the time of cycles c: cpu core number 读取/sys/devices/system/cpu/cpuX/cpufreq/scaling_cur_freq来获取当前频率

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

let now = Instant::now();
let cycles_former = Cycles::from_ghz(1);

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

let dur = Instant::now() - now;
let cycles_later = Cycles::from_ghz(2);

let cycles = cycles_later - cycles_former;
println!("{}", cycles.as_diff(dur, 7).unwrap());

impl Cycles

pub fn from_hz(h: c_ll) -> Self

use cpu_cycles_reader::Cycles;

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

pub fn from_khz(k: c_ll) -> Self

use cpu_cycles_reader::Cycles;

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

pub fn from_mhz(m: c_ll) -> Self

use cpu_cycles_reader::Cycles;

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

pub 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 fn as_hz(&self) -> c_ll

use cpu_cycles_reader::Cycles;

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

pub fn as_khz(&self) -> c_ll

use cpu_cycles_reader::Cycles;

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

pub fn as_mhz(&self) -> c_ll

use cpu_cycles_reader::Cycles;

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

pub 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 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 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 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 Sub<Cycles> for Cycles

type Output = Cycles

The resulting type after applying the - operator.

fn sub(self, rhs: Cycles) -> 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