amdgpu-sysfs 0.20.0

Library for interacting with the Linux Kernel SysFS interface for GPUs (mainly targeted at the AMDGPU driver).
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

use amdgpu_sysfs::{gpu_handle::GpuHandle, sysfs::SysFS};
use rust_embed::RustEmbed;
use std::fs;
use tempfile::{tempdir, TempDir};

#[derive(RustEmbed)]
#[folder = "tests/data/"]
struct Asset;

pub struct MockSysFs {
    temp_dir: TempDir,
}

impl MockSysFs {
    pub fn new(name: &str) -> Self {
        let temp_dir = tempdir().expect("Failed to create temp dir");
        let path = temp_dir.path();

        let path_prefix = format!("{name}/");
        for file_name in Asset::iter() {
            if let Some(stripped_name) = file_name.strip_prefix(&path_prefix) {
                let target_path = path.join(stripped_name);

                if let Some(parent) = target_path.parent() {
                    fs::create_dir_all(parent).expect("Could not create parent dir in temp dir");
                }

                let contents = Asset::get(&file_name)
                    .expect("Could not read file from embedded fs")
                    .data;
                fs::write(target_path, contents).expect("Could not write contents to temp dir");
            }
        }

        Self { temp_dir }
    }
}

impl SysFS for MockSysFs {
    fn get_path(&self) -> &std::path::Path {
        self.temp_dir.path()
    }
}

pub fn create_mock_gpu_handle(name: &str) -> (GpuHandle, MockSysFs) {
    let mockfs = MockSysFs::new(name);

    (
        GpuHandle::new_from_path(mockfs.get_path().to_path_buf())
            .expect("Failed to create GPU handle"),
        mockfs,
    )
}

#[macro_export]
macro_rules! test_with_handle {
    ($sysfs_name:expr, $($test_name:ident => {$($code:expr, $expected:expr),* $(,)?}),* $(,)?) => {
        $(
            #[test]
            fn $test_name() {
                let (handle, _mockfs) = $crate::sysfs::create_mock_gpu_handle($sysfs_name);
                $(
                    let value = $code(&handle);
                    pretty_assertions::assert_eq!(value, $expected);
                )*
            }
        )*
    };
}

#[macro_export]
macro_rules! test_with_hw_mon {
    ($sysfs_name:expr, $($test_name:ident => {$($code:expr, $expected:expr),* $(,)?}),* $(,)?) => {
        $(
            #[test]
            fn $test_name() {
                let (handle, _mockfs) = $crate::sysfs::create_mock_gpu_handle($sysfs_name);
                let hw_mon = handle.hw_monitors.first().expect("Handle has no hw monitor");
                $(
                    let value = $code(&hw_mon);
                    pretty_assertions::assert_eq!(value, $expected);
                )*
            }
        )*
    };
}