gfxinfo 0.1.2

Rust library for querying GPU 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
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132

use std::{error::Error, fmt::Debug, fs::File, os::fd::AsRawFd, path::PathBuf, rc::Rc};

use libdrm_amdgpu_sys::{
  AMDGPU::{self, DeviceHandle, GPU_INFO, SENSOR_INFO::SENSOR_TYPE},
  LibDrmAmdgpu,
};

use crate::{Gpu, GpuInfo};

pub struct AmdGpu {
  path: PathBuf,
  device: Rc<DeviceHandle>,

  vendor: String,
  model: String,
  family: String,
  device_id: u32,
}

impl Debug for AmdGpu {
  fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
    f.debug_struct("AmdGpu")
      .field("path", &self.path)
      .field("vendor", &self.vendor)
      .field("model", &self.model)
      .field("family", &self.family)
      .field("device_id", &self.device_id)
      .finish()
  }
}

impl Gpu for AmdGpu {
  fn vendor(&self) -> &str {
    &self.vendor
  }

  fn model(&self) -> &str {
    &self.model
  }

  fn family(&self) -> &str {
    &self.family
  }

  fn device_id(&self) -> &u32 {
    &self.device_id
  }

  #[cfg(feature = "gpu_info")]
  fn info(&self) -> Box<dyn GpuInfo> {
    Box::new(AmdGpuInfo {
      device: self.device.clone(),
    })
  }
}

#[cfg(feature = "gpu_info")]
struct AmdGpuInfo {
  device: Rc<DeviceHandle>,
}

#[cfg(feature = "gpu_info")]
impl GpuInfo for AmdGpuInfo {
  fn total_vram(&self) -> u64 {
    let meminfo = match self.device.memory_info() {
      Ok(meminfo) => meminfo,
      Err(_) => return 0,
    };

    meminfo.vram.total_heap_size
  }

  fn used_vram(&self) -> u64 {
    let meminfo = match self.device.memory_info() {
      Ok(meminfo) => meminfo,
      Err(_) => return 0,
    };

    meminfo.vram.heap_usage
  }

  fn load_pct(&self) -> u32 {
    self
      .device
      .sensor_info(SENSOR_TYPE::GPU_LOAD)
      .unwrap_or_default()
  }

  fn temperature(&self) -> u32 {
    self
      .device
      .sensor_info(SENSOR_TYPE::GPU_TEMP)
      .unwrap_or_default()
  }
}

// https://github.com/Umio-Yasuno/libdrm-amdgpu-sys-rs/blob/main/examples/amdgpu_info.rs
pub fn active_gpu() -> Result<AmdGpu, Box<dyn Error>> {
  let drm = LibDrmAmdgpu::new().map_err(|_| "Could not initialize libdrm")?;
  let pci_devs = AMDGPU::get_all_amdgpu_pci_bus();

  if pci_devs.is_empty() {
    return Err("No AMD GPU found".into());
  }

  // TODO: first() is almost definitely not the right way to do this
  let dev_path = match pci_devs.first() {
    Some(pci_dev) => pci_dev.get_drm_render_path()?,
    None => return Err("No AMD GPU found".into()),
  };

  let (device, _, _) = {
    let fd = File::open(&dev_path)?;
    drm
      .init_device_handle(fd.as_raw_fd())
      .map_err(|e| format!("Could not init device handle: {e}"))?
  };

  let info = device
    .device_info()
    .map_err(|e| format!("Could not get device info: {e}"))?;

  Ok(AmdGpu {
    path: dev_path,
    device: Rc::new(device),

    vendor: "AMD".to_string(),
    model: info.find_device_name_or_default().to_string(),
    family: info.get_family_name().to_string(),
    device_id: info.device_id(),
  })
}