laddu-memory 0.21.4

Amplitude analysis tools for Rust
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 sysinfo::{ProcessRefreshKind, ProcessesToUpdate, System, get_current_pid};

use super::{CapacitySnapshot, ProbeFailure};
use crate::{CapacitySource, MemoryResource, MemoryResourceKind};

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub(crate) struct ProcessSnapshot {
    pub(crate) resident_bytes: u64,
    pub(crate) virtual_bytes: u64,
}

pub(crate) fn discover_host() -> MemoryResource {
    let mut system = System::new();
    system.refresh_memory();
    let mut snapshot = CapacitySnapshot::new(
        system.total_memory(),
        system.available_memory(),
        CapacitySource::OperatingSystem,
    )
    .unwrap_or(CapacitySnapshot {
        total_bytes: system.total_memory(),
        available_bytes: system.available_memory(),
        source: CapacitySource::OperatingSystem,
    });
    if let Ok(cgroup) = discover_cgroup_memory()
        && cgroup.total_bytes < snapshot.total_bytes
    {
        snapshot = CapacitySnapshot {
            available_bytes: snapshot.available_bytes.min(cgroup.available_bytes),
            ..cgroup
        };
    }
    MemoryResource {
        id: "host".into(),
        name: "Host memory".into(),
        kind: MemoryResourceKind::Host,
        total_bytes: Some(snapshot.total_bytes),
        available_bytes: Some(snapshot.available_bytes),
        capacity_source: snapshot.source,
        device_identity: None,
    }
}

fn discover_cgroup_memory() -> Result<CapacitySnapshot, ProbeFailure> {
    let pid = get_current_pid().map_err(|_| ProbeFailure::Unavailable)?;
    let mut system = System::new();
    system.refresh_processes_specifics(
        ProcessesToUpdate::Some(&[pid]),
        true,
        ProcessRefreshKind::nothing().with_memory(),
    );
    let limits = system
        .process(pid)
        .and_then(|process| process.cgroup_limits())
        .ok_or(ProbeFailure::Unavailable)?;
    CapacitySnapshot::new(
        limits.total_memory,
        limits.free_memory,
        CapacitySource::Cgroup,
    )
}

pub(crate) fn discover_process_memory() -> Result<ProcessSnapshot, ProbeFailure> {
    let pid = get_current_pid().map_err(|_| ProbeFailure::Unavailable)?;
    let mut system = System::new();
    system.refresh_processes_specifics(
        ProcessesToUpdate::Some(&[pid]),
        true,
        ProcessRefreshKind::nothing().with_memory(),
    );
    let process = system.process(pid).ok_or(ProbeFailure::Unavailable)?;
    Ok(ProcessSnapshot {
        resident_bytes: process.memory(),
        virtual_bytes: process.virtual_memory(),
    })
}