ruda-runtime 0.1.33

Ruda portable host runtime.
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

#[cfg(all(feature = "monitoring-amdgpu-busy-percent", target_os = "linux"))]
use super::amdgpu_busy_percent::AmdgpuBusyPercentFile;
#[cfg(all(feature = "monitoring-gpu-engine-counters", target_os = "windows"))]
use super::gpu_engine_counters::GpuEngineCounters;
#[cfg(all(feature = "monitoring-intel-idle-residency", target_os = "linux"))]
use super::intel_idle_residency::IntelIdleResidencyFiles;
#[cfg(all(feature = "monitoring-io-accelerator", target_os = "macos"))]
use super::io_accelerator::IoAcceleratorStatistics;
#[cfg(all(feature = "monitoring-nvml", target_os = "linux"))]
use super::nvml::NvmlUtilizationCounter;
use super::source::UtilizationSource;
use crate::runtime::monitoring::{DeviceUtilization, UtilizationUnavailable};

/// A device's counter once opened: a counter that would not open keeps the reason, so a device is
/// only ever opened once.
#[derive(Debug)]
pub enum OpenedCounter {
    #[cfg(all(feature = "monitoring-nvml", target_os = "linux"))]
    Nvml(NvmlUtilizationCounter),
    #[cfg(all(feature = "monitoring-amdgpu-busy-percent", target_os = "linux"))]
    AmdgpuBusyPercentFile(AmdgpuBusyPercentFile),
    #[cfg(all(feature = "monitoring-intel-idle-residency", target_os = "linux"))]
    IntelIdleResidencyFiles(IntelIdleResidencyFiles),
    #[cfg(all(feature = "monitoring-gpu-engine-counters", target_os = "windows"))]
    GpuEngineCounters(GpuEngineCounters),
    #[cfg(all(feature = "monitoring-io-accelerator", target_os = "macos"))]
    IoAcceleratorStatistics(IoAcceleratorStatistics),
    Unavailable(UtilizationUnavailable),
}

impl OpenedCounter {
    pub fn open(source: UtilizationSource) -> Self {
        let opened = match source {
            #[cfg(all(feature = "monitoring-nvml", target_os = "linux"))]
            UtilizationSource::Nvml(pci_address) => {
                NvmlUtilizationCounter::new(pci_address).map(Self::Nvml)
            }
            #[cfg(all(feature = "monitoring-amdgpu-busy-percent", target_os = "linux"))]
            UtilizationSource::AmdgpuBusyPercentFile(pci_address) => Ok(
                Self::AmdgpuBusyPercentFile(AmdgpuBusyPercentFile::new(pci_address)),
            ),
            #[cfg(all(feature = "monitoring-intel-idle-residency", target_os = "linux"))]
            UtilizationSource::IntelIdleResidencyFiles(pci_address) => {
                IntelIdleResidencyFiles::new(pci_address).map(Self::IntelIdleResidencyFiles)
            }
            #[cfg(all(feature = "monitoring-gpu-engine-counters", target_os = "windows"))]
            UtilizationSource::GpuEngineCounters(luid) => {
                GpuEngineCounters::new(luid).map(Self::GpuEngineCounters)
            }
            #[cfg(all(feature = "monitoring-io-accelerator", target_os = "macos"))]
            UtilizationSource::IoAcceleratorStatistics(registry_entry_id) => {
                IoAcceleratorStatistics::new(registry_entry_id).map(Self::IoAcceleratorStatistics)
            }
            UtilizationSource::Unavailable(reason) => Err(reason),
        };
        opened.unwrap_or_else(Self::Unavailable)
    }

    pub fn read(&self) -> Result<DeviceUtilization, UtilizationUnavailable> {
        match self {
            #[cfg(all(feature = "monitoring-nvml", target_os = "linux"))]
            Self::Nvml(counter) => counter.read(),
            #[cfg(all(feature = "monitoring-amdgpu-busy-percent", target_os = "linux"))]
            Self::AmdgpuBusyPercentFile(file) => file.read(),
            #[cfg(all(feature = "monitoring-intel-idle-residency", target_os = "linux"))]
            Self::IntelIdleResidencyFiles(files) => files.read(),
            #[cfg(all(feature = "monitoring-gpu-engine-counters", target_os = "windows"))]
            Self::GpuEngineCounters(counters) => counters.read(),
            #[cfg(all(feature = "monitoring-io-accelerator", target_os = "macos"))]
            Self::IoAcceleratorStatistics(statistics) => statistics.read(),
            Self::Unavailable(reason) => Err(reason.clone()),
        }
    }
}