heim-cpu 0.0.11

Cross-platform CPU information
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76

use heim_common::prelude::*;
use heim_common::sys::unix::CLOCK_TICKS;
use heim_common::units::{time, Time};

use super::bindings;

#[derive(Debug)]
pub struct CpuTime {
    user: Time,
    nice: Time,
    system: Time,
    idle: Time,
}

impl CpuTime {
    pub fn user(&self) -> Time {
        self.user
    }

    pub fn nice(&self) -> Time {
        self.nice
    }

    pub fn system(&self) -> Time {
        self.system
    }

    pub fn idle(&self) -> Time {
        self.idle
    }
}

impl From<bindings::host_cpu_load_info> for CpuTime {
    fn from(info: bindings::host_cpu_load_info) -> CpuTime {
        let ticks = *CLOCK_TICKS;

        CpuTime {
            user: Time::new::<time::second>(f64::from(info.user) / ticks),
            nice: Time::new::<time::second>(f64::from(info.nice) / ticks),
            system: Time::new::<time::second>(f64::from(info.system) / ticks),
            idle: Time::new::<time::second>(f64::from(info.idle) / ticks),
        }
    }
}

impl From<bindings::processor_cpu_load_info> for CpuTime {
    fn from(info: bindings::processor_cpu_load_info) -> CpuTime {
        let ticks = *CLOCK_TICKS;

        CpuTime {
            user: Time::new::<time::second>(f64::from(info.user) / ticks),
            nice: Time::new::<time::second>(f64::from(info.nice) / ticks),
            system: Time::new::<time::second>(f64::from(info.system) / ticks),
            idle: Time::new::<time::second>(f64::from(info.idle) / ticks),
        }
    }
}

pub fn time() -> impl Future<Output = Result<CpuTime>> {
    future::lazy(|_| {
        let info = unsafe { bindings::cpu_load_info()? };
        Ok(info.into())
    })
}

pub fn times() -> impl Stream<Item = Result<CpuTime>> {
    future::lazy(|_| {
        let processors = unsafe { bindings::processor_load_info()? };

        let stream = stream::iter(processors).map(Ok);

        Ok(stream)
    })
    .try_flatten_stream()
    .map_ok(Into::into)
}