DeviceInfo

test_smi_rs

Struct DeviceInfo 

Source 
pub struct DeviceInfo { /* private fields */ }
Expand description

A struct for device information

Implementations§

Source§

impl DeviceInfo

Source

pub fn arch(&self) -> Arch

Get a architecture of device

Examples found in repository?
examples/list_device.rs (line 19)
5fn main() -> SmiResult<()> {
6    let devices = list_devices()?;
7    match driver_info() {
8        Ok(version_info) => {
9            println!("Driver Version: {}", version_info);
10        }
11        Err(_) => {
12            println!("Error: Failed to retrieve driver information.")
13        }
14    }
15
16    for device in devices.iter() {
17        let device_info = device.device_info()?;
18        println!("Device Info");
19        println!("\t\tDevice Arch: {:?}", device_info.arch());
20        println!("\t\tDevice Cores: {:?}", device_info.core_num());
21        println!("\t\tDevice NUMA Node: {:?}", device_info.numa_node());
22        println!("\t\tDevice Name: {:?}", device_info.name());
23        println!("\t\tDevice Serial: {:?}", device_info.serial());
24        println!("\t\tDevice UUID: {:?}", device_info.uuid());
25        println!("\t\tDevice BDF: {:?}", device_info.bdf());
26        println!("\t\tDevice Major: {:?}", device_info.major());
27        println!("\t\tDevice Minor: {:?}", device_info.minor());
28        println!(
29            "\t\tDevice Firmware Version: {}",
30            device_info.firmware_version()
31        );
32
33        let device_file = device.device_files()?;
34        println!("Device Files");
35        for file in device_file.iter() {
36            println!("\t\tDevice File Cores: {:?}", file.cores());
37            println!("\t\tDevice File Path: {:?}", file.path());
38        }
39
40        //core status
41        let core_status = device.core_status()?;
42        println!("Core Status");
43        for (core_id, status) in core_status.iter() {
44            println!("\t\tCore ID: {:?}", core_id);
45            println!("\t\tCore Status: {:?}", status);
46        }
47
48        //error info
49        let error_info = device.device_error_info()?;
50        println!("Device Error Info");
51        println!(
52            "\t\tDevice axi post error count: {:?}",
53            error_info.axi_doorbell_error_count()
54        );
55        println!(
56            "\t\tDevice axi fetch error count: {:?}",
57            error_info.axi_fetch_error_count()
58        );
59        println!(
60            "\t\tDevice axi discard error count: {:?}",
61            error_info.axi_discard_error_count()
62        );
63        println!(
64            "\t\tDevice axi doorbell error count: {:?}",
65            error_info.axi_doorbell_error_count()
66        );
67        println!(
68            "\t\tDevice pcie post error count: {:?}",
69            error_info.pcie_post_error_count()
70        );
71        println!(
72            "\t\tDevice pcie fetch error count: {:?}",
73            error_info.pcie_fetch_error_count()
74        );
75        println!(
76            "\t\tDevice pcie discard error count: {:?}",
77            error_info.pcie_discard_error_count()
78        );
79        println!(
80            "\t\tDevice pcie doorbell error count: {:?}",
81            error_info.pcie_doorbell_error_count()
82        );
83        println!(
84            "\t\tDevice device error count: {:?}",
85            error_info.device_error_count()
86        );
87
88        //liveness
89        println!("Device Liveness: {:?}", device.liveness()?);
90
91        //power consumption
92        println!(
93            "Device Power Consumption: {:?}",
94            device.power_consumption()?
95        );
96
97        //temperature
98        let device_temperature = device.device_temperature()?;
99        println!("Device Temperature");
100        println!("\t\tDevice SOC Peak: {:?}", device_temperature.soc_peak());
101        println!("\t\tDevice Ambient: {:?}", device_temperature.ambient());
102
103        //performance
104        let core_utilization = device.core_utilization()?;
105        let device_performance_counter = device.device_performance_counter()?;
106        println!("Device Utilization");
107        let pe_performance_counter = device_performance_counter.pe_performance_counters();
108        let pe_utilization = core_utilization.pe_utilization();
109        for (pe_util, pe_performance_counter) in
110            pe_utilization.iter().zip(pe_performance_counter.iter())
111        {
112            println!("\t\tPE Core: {:?}", pe_util.core());
113            println!("\t\tPE Time Window Mill: {:?}", pe_util.time_window_mill());
114            println!(
115                "\t\tPE Usage Percentage: {:?}",
116                pe_util.pe_usage_percentage()
117            );
118            let timestamp = pe_performance_counter.timestamp();
119            let datetime: DateTime<Local> = timestamp.into();
120            println!("\t\tPE Timestamp: {}", datetime);
121            println!(
122                "\t\tPE Task Execution Cycle: {:?}",
123                pe_performance_counter.task_execution_cycle()
124            );
125            println!(
126                "\t\tPE Cycle Count: {:?}",
127                pe_performance_counter.cycle_count()
128            );
129        }
130
131        let memory_utilization = match device.memory_utilization() {
132            Ok(memory_utilization) => memory_utilization,
133            Err(test_smi_rs::SmiError::NotSupportedError) => {
134                println!("Memory Utilization is not supported yet");
135                continue;
136            }
137            Err(e) => return Err(e),
138        };
139        println!("Memory Utilization");
140        println!(
141            "\t\tMemory Total Bytes: {:?}",
142            memory_utilization.total_bytes()
143        );
144        println!(
145            "\t\tMemory In Use Bytes: {:?}",
146            memory_utilization.in_use_bytes()
147        );
148    }
149    Ok(())
150}
Source

pub fn core_num(&self) -> u32

Get a number of cores

Examples found in repository?
examples/list_device.rs (line 20)
5fn main() -> SmiResult<()> {
6    let devices = list_devices()?;
7    match driver_info() {
8        Ok(version_info) => {
9            println!("Driver Version: {}", version_info);
10        }
11        Err(_) => {
12            println!("Error: Failed to retrieve driver information.")
13        }
14    }
15
16    for device in devices.iter() {
17        let device_info = device.device_info()?;
18        println!("Device Info");
19        println!("\t\tDevice Arch: {:?}", device_info.arch());
20        println!("\t\tDevice Cores: {:?}", device_info.core_num());
21        println!("\t\tDevice NUMA Node: {:?}", device_info.numa_node());
22        println!("\t\tDevice Name: {:?}", device_info.name());
23        println!("\t\tDevice Serial: {:?}", device_info.serial());
24        println!("\t\tDevice UUID: {:?}", device_info.uuid());
25        println!("\t\tDevice BDF: {:?}", device_info.bdf());
26        println!("\t\tDevice Major: {:?}", device_info.major());
27        println!("\t\tDevice Minor: {:?}", device_info.minor());
28        println!(
29            "\t\tDevice Firmware Version: {}",
30            device_info.firmware_version()
31        );
32
33        let device_file = device.device_files()?;
34        println!("Device Files");
35        for file in device_file.iter() {
36            println!("\t\tDevice File Cores: {:?}", file.cores());
37            println!("\t\tDevice File Path: {:?}", file.path());
38        }
39
40        //core status
41        let core_status = device.core_status()?;
42        println!("Core Status");
43        for (core_id, status) in core_status.iter() {
44            println!("\t\tCore ID: {:?}", core_id);
45            println!("\t\tCore Status: {:?}", status);
46        }
47
48        //error info
49        let error_info = device.device_error_info()?;
50        println!("Device Error Info");
51        println!(
52            "\t\tDevice axi post error count: {:?}",
53            error_info.axi_doorbell_error_count()
54        );
55        println!(
56            "\t\tDevice axi fetch error count: {:?}",
57            error_info.axi_fetch_error_count()
58        );
59        println!(
60            "\t\tDevice axi discard error count: {:?}",
61            error_info.axi_discard_error_count()
62        );
63        println!(
64            "\t\tDevice axi doorbell error count: {:?}",
65            error_info.axi_doorbell_error_count()
66        );
67        println!(
68            "\t\tDevice pcie post error count: {:?}",
69            error_info.pcie_post_error_count()
70        );
71        println!(
72            "\t\tDevice pcie fetch error count: {:?}",
73            error_info.pcie_fetch_error_count()
74        );
75        println!(
76            "\t\tDevice pcie discard error count: {:?}",
77            error_info.pcie_discard_error_count()
78        );
79        println!(
80            "\t\tDevice pcie doorbell error count: {:?}",
81            error_info.pcie_doorbell_error_count()
82        );
83        println!(
84            "\t\tDevice device error count: {:?}",
85            error_info.device_error_count()
86        );
87
88        //liveness
89        println!("Device Liveness: {:?}", device.liveness()?);
90
91        //power consumption
92        println!(
93            "Device Power Consumption: {:?}",
94            device.power_consumption()?
95        );
96
97        //temperature
98        let device_temperature = device.device_temperature()?;
99        println!("Device Temperature");
100        println!("\t\tDevice SOC Peak: {:?}", device_temperature.soc_peak());
101        println!("\t\tDevice Ambient: {:?}", device_temperature.ambient());
102
103        //performance
104        let core_utilization = device.core_utilization()?;
105        let device_performance_counter = device.device_performance_counter()?;
106        println!("Device Utilization");
107        let pe_performance_counter = device_performance_counter.pe_performance_counters();
108        let pe_utilization = core_utilization.pe_utilization();
109        for (pe_util, pe_performance_counter) in
110            pe_utilization.iter().zip(pe_performance_counter.iter())
111        {
112            println!("\t\tPE Core: {:?}", pe_util.core());
113            println!("\t\tPE Time Window Mill: {:?}", pe_util.time_window_mill());
114            println!(
115                "\t\tPE Usage Percentage: {:?}",
116                pe_util.pe_usage_percentage()
117            );
118            let timestamp = pe_performance_counter.timestamp();
119            let datetime: DateTime<Local> = timestamp.into();
120            println!("\t\tPE Timestamp: {}", datetime);
121            println!(
122                "\t\tPE Task Execution Cycle: {:?}",
123                pe_performance_counter.task_execution_cycle()
124            );
125            println!(
126                "\t\tPE Cycle Count: {:?}",
127                pe_performance_counter.cycle_count()
128            );
129        }
130
131        let memory_utilization = match device.memory_utilization() {
132            Ok(memory_utilization) => memory_utilization,
133            Err(test_smi_rs::SmiError::NotSupportedError) => {
134                println!("Memory Utilization is not supported yet");
135                continue;
136            }
137            Err(e) => return Err(e),
138        };
139        println!("Memory Utilization");
140        println!(
141            "\t\tMemory Total Bytes: {:?}",
142            memory_utilization.total_bytes()
143        );
144        println!(
145            "\t\tMemory In Use Bytes: {:?}",
146            memory_utilization.in_use_bytes()
147        );
148    }
149    Ok(())
150}
Source

pub fn numa_node(&self) -> u32

Get a numa node of device

Examples found in repository?
examples/list_device.rs (line 21)
5fn main() -> SmiResult<()> {
6    let devices = list_devices()?;
7    match driver_info() {
8        Ok(version_info) => {
9            println!("Driver Version: {}", version_info);
10        }
11        Err(_) => {
12            println!("Error: Failed to retrieve driver information.")
13        }
14    }
15
16    for device in devices.iter() {
17        let device_info = device.device_info()?;
18        println!("Device Info");
19        println!("\t\tDevice Arch: {:?}", device_info.arch());
20        println!("\t\tDevice Cores: {:?}", device_info.core_num());
21        println!("\t\tDevice NUMA Node: {:?}", device_info.numa_node());
22        println!("\t\tDevice Name: {:?}", device_info.name());
23        println!("\t\tDevice Serial: {:?}", device_info.serial());
24        println!("\t\tDevice UUID: {:?}", device_info.uuid());
25        println!("\t\tDevice BDF: {:?}", device_info.bdf());
26        println!("\t\tDevice Major: {:?}", device_info.major());
27        println!("\t\tDevice Minor: {:?}", device_info.minor());
28        println!(
29            "\t\tDevice Firmware Version: {}",
30            device_info.firmware_version()
31        );
32
33        let device_file = device.device_files()?;
34        println!("Device Files");
35        for file in device_file.iter() {
36            println!("\t\tDevice File Cores: {:?}", file.cores());
37            println!("\t\tDevice File Path: {:?}", file.path());
38        }
39
40        //core status
41        let core_status = device.core_status()?;
42        println!("Core Status");
43        for (core_id, status) in core_status.iter() {
44            println!("\t\tCore ID: {:?}", core_id);
45            println!("\t\tCore Status: {:?}", status);
46        }
47
48        //error info
49        let error_info = device.device_error_info()?;
50        println!("Device Error Info");
51        println!(
52            "\t\tDevice axi post error count: {:?}",
53            error_info.axi_doorbell_error_count()
54        );
55        println!(
56            "\t\tDevice axi fetch error count: {:?}",
57            error_info.axi_fetch_error_count()
58        );
59        println!(
60            "\t\tDevice axi discard error count: {:?}",
61            error_info.axi_discard_error_count()
62        );
63        println!(
64            "\t\tDevice axi doorbell error count: {:?}",
65            error_info.axi_doorbell_error_count()
66        );
67        println!(
68            "\t\tDevice pcie post error count: {:?}",
69            error_info.pcie_post_error_count()
70        );
71        println!(
72            "\t\tDevice pcie fetch error count: {:?}",
73            error_info.pcie_fetch_error_count()
74        );
75        println!(
76            "\t\tDevice pcie discard error count: {:?}",
77            error_info.pcie_discard_error_count()
78        );
79        println!(
80            "\t\tDevice pcie doorbell error count: {:?}",
81            error_info.pcie_doorbell_error_count()
82        );
83        println!(
84            "\t\tDevice device error count: {:?}",
85            error_info.device_error_count()
86        );
87
88        //liveness
89        println!("Device Liveness: {:?}", device.liveness()?);
90
91        //power consumption
92        println!(
93            "Device Power Consumption: {:?}",
94            device.power_consumption()?
95        );
96
97        //temperature
98        let device_temperature = device.device_temperature()?;
99        println!("Device Temperature");
100        println!("\t\tDevice SOC Peak: {:?}", device_temperature.soc_peak());
101        println!("\t\tDevice Ambient: {:?}", device_temperature.ambient());
102
103        //performance
104        let core_utilization = device.core_utilization()?;
105        let device_performance_counter = device.device_performance_counter()?;
106        println!("Device Utilization");
107        let pe_performance_counter = device_performance_counter.pe_performance_counters();
108        let pe_utilization = core_utilization.pe_utilization();
109        for (pe_util, pe_performance_counter) in
110            pe_utilization.iter().zip(pe_performance_counter.iter())
111        {
112            println!("\t\tPE Core: {:?}", pe_util.core());
113            println!("\t\tPE Time Window Mill: {:?}", pe_util.time_window_mill());
114            println!(
115                "\t\tPE Usage Percentage: {:?}",
116                pe_util.pe_usage_percentage()
117            );
118            let timestamp = pe_performance_counter.timestamp();
119            let datetime: DateTime<Local> = timestamp.into();
120            println!("\t\tPE Timestamp: {}", datetime);
121            println!(
122                "\t\tPE Task Execution Cycle: {:?}",
123                pe_performance_counter.task_execution_cycle()
124            );
125            println!(
126                "\t\tPE Cycle Count: {:?}",
127                pe_performance_counter.cycle_count()
128            );
129        }
130
131        let memory_utilization = match device.memory_utilization() {
132            Ok(memory_utilization) => memory_utilization,
133            Err(test_smi_rs::SmiError::NotSupportedError) => {
134                println!("Memory Utilization is not supported yet");
135                continue;
136            }
137            Err(e) => return Err(e),
138        };
139        println!("Memory Utilization");
140        println!(
141            "\t\tMemory Total Bytes: {:?}",
142            memory_utilization.total_bytes()
143        );
144        println!(
145            "\t\tMemory In Use Bytes: {:?}",
146            memory_utilization.in_use_bytes()
147        );
148    }
149    Ok(())
150}
Source

pub fn name(&self) -> String

Get a name of device

Examples found in repository?
examples/show_topology.rs (line 13)
5fn main() -> SmiResult<()> {
6    let devices = list_devices()?;
7
8    let mut rows = Vec::with_capacity(devices.len() + 1);
9    let mut header = Vec::with_capacity(devices.len() + 1);
10    header.push("Device".cell().bold(true));
11
12    for device in devices.iter() {
13        let name = device.device_info()?.name();
14        header.push(name.cell().bold(true));
15    }
16    rows.push(header);
17
18    for device1 in devices.iter() {
19        let mut row = Vec::with_capacity(devices.len() + 1);
20        row.push(device1.device_info()?.name().cell());
21        for device2 in devices.iter() {
22            let link_type = device1.device_to_device_link_type(device2)?;
23            row.push(link_type.cell());
24        }
25        rows.push(row);
26    }
27
28    let table = rows.table();
29    print_stdout(table).expect("couldn't print table");
30
31    Ok(())
32}
More examples
Hide additional examples
examples/show_p2p.rs (line 13)
5fn main() -> SmiResult<()> {
6    let devices = list_devices()?;
7
8    let mut rows = Vec::with_capacity(devices.len() + 1);
9    let mut header = Vec::with_capacity(devices.len() + 1);
10    header.push("Device".cell().bold(true));
11
12    for device in devices.iter() {
13        let name = device.device_info()?.name();
14        header.push(name.cell().bold(true));
15    }
16    rows.push(header);
17
18    for device1 in devices.iter() {
19        let mut row = Vec::with_capacity(devices.len() + 1);
20        row.push(device1.device_info()?.name().cell());
21        for device2 in devices.iter() {
22            let p2p_accessibility = match device1.p2p_accessible(device2)? {
23                true => "Accessible".to_string(),
24                false => "Inaccessible".to_string(),
25            };
26            row.push(p2p_accessibility.cell());
27        }
28        rows.push(row);
29    }
30
31    let table = rows.table();
32    print_stdout(table).expect("couldn't print table");
33
34    Ok(())
35}
examples/list_device.rs (line 22)
5fn main() -> SmiResult<()> {
6    let devices = list_devices()?;
7    match driver_info() {
8        Ok(version_info) => {
9            println!("Driver Version: {}", version_info);
10        }
11        Err(_) => {
12            println!("Error: Failed to retrieve driver information.")
13        }
14    }
15
16    for device in devices.iter() {
17        let device_info = device.device_info()?;
18        println!("Device Info");
19        println!("\t\tDevice Arch: {:?}", device_info.arch());
20        println!("\t\tDevice Cores: {:?}", device_info.core_num());
21        println!("\t\tDevice NUMA Node: {:?}", device_info.numa_node());
22        println!("\t\tDevice Name: {:?}", device_info.name());
23        println!("\t\tDevice Serial: {:?}", device_info.serial());
24        println!("\t\tDevice UUID: {:?}", device_info.uuid());
25        println!("\t\tDevice BDF: {:?}", device_info.bdf());
26        println!("\t\tDevice Major: {:?}", device_info.major());
27        println!("\t\tDevice Minor: {:?}", device_info.minor());
28        println!(
29            "\t\tDevice Firmware Version: {}",
30            device_info.firmware_version()
31        );
32
33        let device_file = device.device_files()?;
34        println!("Device Files");
35        for file in device_file.iter() {
36            println!("\t\tDevice File Cores: {:?}", file.cores());
37            println!("\t\tDevice File Path: {:?}", file.path());
38        }
39
40        //core status
41        let core_status = device.core_status()?;
42        println!("Core Status");
43        for (core_id, status) in core_status.iter() {
44            println!("\t\tCore ID: {:?}", core_id);
45            println!("\t\tCore Status: {:?}", status);
46        }
47
48        //error info
49        let error_info = device.device_error_info()?;
50        println!("Device Error Info");
51        println!(
52            "\t\tDevice axi post error count: {:?}",
53            error_info.axi_doorbell_error_count()
54        );
55        println!(
56            "\t\tDevice axi fetch error count: {:?}",
57            error_info.axi_fetch_error_count()
58        );
59        println!(
60            "\t\tDevice axi discard error count: {:?}",
61            error_info.axi_discard_error_count()
62        );
63        println!(
64            "\t\tDevice axi doorbell error count: {:?}",
65            error_info.axi_doorbell_error_count()
66        );
67        println!(
68            "\t\tDevice pcie post error count: {:?}",
69            error_info.pcie_post_error_count()
70        );
71        println!(
72            "\t\tDevice pcie fetch error count: {:?}",
73            error_info.pcie_fetch_error_count()
74        );
75        println!(
76            "\t\tDevice pcie discard error count: {:?}",
77            error_info.pcie_discard_error_count()
78        );
79        println!(
80            "\t\tDevice pcie doorbell error count: {:?}",
81            error_info.pcie_doorbell_error_count()
82        );
83        println!(
84            "\t\tDevice device error count: {:?}",
85            error_info.device_error_count()
86        );
87
88        //liveness
89        println!("Device Liveness: {:?}", device.liveness()?);
90
91        //power consumption
92        println!(
93            "Device Power Consumption: {:?}",
94            device.power_consumption()?
95        );
96
97        //temperature
98        let device_temperature = device.device_temperature()?;
99        println!("Device Temperature");
100        println!("\t\tDevice SOC Peak: {:?}", device_temperature.soc_peak());
101        println!("\t\tDevice Ambient: {:?}", device_temperature.ambient());
102
103        //performance
104        let core_utilization = device.core_utilization()?;
105        let device_performance_counter = device.device_performance_counter()?;
106        println!("Device Utilization");
107        let pe_performance_counter = device_performance_counter.pe_performance_counters();
108        let pe_utilization = core_utilization.pe_utilization();
109        for (pe_util, pe_performance_counter) in
110            pe_utilization.iter().zip(pe_performance_counter.iter())
111        {
112            println!("\t\tPE Core: {:?}", pe_util.core());
113            println!("\t\tPE Time Window Mill: {:?}", pe_util.time_window_mill());
114            println!(
115                "\t\tPE Usage Percentage: {:?}",
116                pe_util.pe_usage_percentage()
117            );
118            let timestamp = pe_performance_counter.timestamp();
119            let datetime: DateTime<Local> = timestamp.into();
120            println!("\t\tPE Timestamp: {}", datetime);
121            println!(
122                "\t\tPE Task Execution Cycle: {:?}",
123                pe_performance_counter.task_execution_cycle()
124            );
125            println!(
126                "\t\tPE Cycle Count: {:?}",
127                pe_performance_counter.cycle_count()
128            );
129        }
130
131        let memory_utilization = match device.memory_utilization() {
132            Ok(memory_utilization) => memory_utilization,
133            Err(test_smi_rs::SmiError::NotSupportedError) => {
134                println!("Memory Utilization is not supported yet");
135                continue;
136            }
137            Err(e) => return Err(e),
138        };
139        println!("Memory Utilization");
140        println!(
141            "\t\tMemory Total Bytes: {:?}",
142            memory_utilization.total_bytes()
143        );
144        println!(
145            "\t\tMemory In Use Bytes: {:?}",
146            memory_utilization.in_use_bytes()
147        );
148    }
149    Ok(())
150}
Source

pub fn serial(&self) -> String

Get a serial of device

Examples found in repository?
examples/list_device.rs (line 23)
5fn main() -> SmiResult<()> {
6    let devices = list_devices()?;
7    match driver_info() {
8        Ok(version_info) => {
9            println!("Driver Version: {}", version_info);
10        }
11        Err(_) => {
12            println!("Error: Failed to retrieve driver information.")
13        }
14    }
15
16    for device in devices.iter() {
17        let device_info = device.device_info()?;
18        println!("Device Info");
19        println!("\t\tDevice Arch: {:?}", device_info.arch());
20        println!("\t\tDevice Cores: {:?}", device_info.core_num());
21        println!("\t\tDevice NUMA Node: {:?}", device_info.numa_node());
22        println!("\t\tDevice Name: {:?}", device_info.name());
23        println!("\t\tDevice Serial: {:?}", device_info.serial());
24        println!("\t\tDevice UUID: {:?}", device_info.uuid());
25        println!("\t\tDevice BDF: {:?}", device_info.bdf());
26        println!("\t\tDevice Major: {:?}", device_info.major());
27        println!("\t\tDevice Minor: {:?}", device_info.minor());
28        println!(
29            "\t\tDevice Firmware Version: {}",
30            device_info.firmware_version()
31        );
32
33        let device_file = device.device_files()?;
34        println!("Device Files");
35        for file in device_file.iter() {
36            println!("\t\tDevice File Cores: {:?}", file.cores());
37            println!("\t\tDevice File Path: {:?}", file.path());
38        }
39
40        //core status
41        let core_status = device.core_status()?;
42        println!("Core Status");
43        for (core_id, status) in core_status.iter() {
44            println!("\t\tCore ID: {:?}", core_id);
45            println!("\t\tCore Status: {:?}", status);
46        }
47
48        //error info
49        let error_info = device.device_error_info()?;
50        println!("Device Error Info");
51        println!(
52            "\t\tDevice axi post error count: {:?}",
53            error_info.axi_doorbell_error_count()
54        );
55        println!(
56            "\t\tDevice axi fetch error count: {:?}",
57            error_info.axi_fetch_error_count()
58        );
59        println!(
60            "\t\tDevice axi discard error count: {:?}",
61            error_info.axi_discard_error_count()
62        );
63        println!(
64            "\t\tDevice axi doorbell error count: {:?}",
65            error_info.axi_doorbell_error_count()
66        );
67        println!(
68            "\t\tDevice pcie post error count: {:?}",
69            error_info.pcie_post_error_count()
70        );
71        println!(
72            "\t\tDevice pcie fetch error count: {:?}",
73            error_info.pcie_fetch_error_count()
74        );
75        println!(
76            "\t\tDevice pcie discard error count: {:?}",
77            error_info.pcie_discard_error_count()
78        );
79        println!(
80            "\t\tDevice pcie doorbell error count: {:?}",
81            error_info.pcie_doorbell_error_count()
82        );
83        println!(
84            "\t\tDevice device error count: {:?}",
85            error_info.device_error_count()
86        );
87
88        //liveness
89        println!("Device Liveness: {:?}", device.liveness()?);
90
91        //power consumption
92        println!(
93            "Device Power Consumption: {:?}",
94            device.power_consumption()?
95        );
96
97        //temperature
98        let device_temperature = device.device_temperature()?;
99        println!("Device Temperature");
100        println!("\t\tDevice SOC Peak: {:?}", device_temperature.soc_peak());
101        println!("\t\tDevice Ambient: {:?}", device_temperature.ambient());
102
103        //performance
104        let core_utilization = device.core_utilization()?;
105        let device_performance_counter = device.device_performance_counter()?;
106        println!("Device Utilization");
107        let pe_performance_counter = device_performance_counter.pe_performance_counters();
108        let pe_utilization = core_utilization.pe_utilization();
109        for (pe_util, pe_performance_counter) in
110            pe_utilization.iter().zip(pe_performance_counter.iter())
111        {
112            println!("\t\tPE Core: {:?}", pe_util.core());
113            println!("\t\tPE Time Window Mill: {:?}", pe_util.time_window_mill());
114            println!(
115                "\t\tPE Usage Percentage: {:?}",
116                pe_util.pe_usage_percentage()
117            );
118            let timestamp = pe_performance_counter.timestamp();
119            let datetime: DateTime<Local> = timestamp.into();
120            println!("\t\tPE Timestamp: {}", datetime);
121            println!(
122                "\t\tPE Task Execution Cycle: {:?}",
123                pe_performance_counter.task_execution_cycle()
124            );
125            println!(
126                "\t\tPE Cycle Count: {:?}",
127                pe_performance_counter.cycle_count()
128            );
129        }
130
131        let memory_utilization = match device.memory_utilization() {
132            Ok(memory_utilization) => memory_utilization,
133            Err(test_smi_rs::SmiError::NotSupportedError) => {
134                println!("Memory Utilization is not supported yet");
135                continue;
136            }
137            Err(e) => return Err(e),
138        };
139        println!("Memory Utilization");
140        println!(
141            "\t\tMemory Total Bytes: {:?}",
142            memory_utilization.total_bytes()
143        );
144        println!(
145            "\t\tMemory In Use Bytes: {:?}",
146            memory_utilization.in_use_bytes()
147        );
148    }
149    Ok(())
150}
Source

pub fn uuid(&self) -> String

Get a uuid of device

Examples found in repository?
examples/list_device.rs (line 24)
5fn main() -> SmiResult<()> {
6    let devices = list_devices()?;
7    match driver_info() {
8        Ok(version_info) => {
9            println!("Driver Version: {}", version_info);
10        }
11        Err(_) => {
12            println!("Error: Failed to retrieve driver information.")
13        }
14    }
15
16    for device in devices.iter() {
17        let device_info = device.device_info()?;
18        println!("Device Info");
19        println!("\t\tDevice Arch: {:?}", device_info.arch());
20        println!("\t\tDevice Cores: {:?}", device_info.core_num());
21        println!("\t\tDevice NUMA Node: {:?}", device_info.numa_node());
22        println!("\t\tDevice Name: {:?}", device_info.name());
23        println!("\t\tDevice Serial: {:?}", device_info.serial());
24        println!("\t\tDevice UUID: {:?}", device_info.uuid());
25        println!("\t\tDevice BDF: {:?}", device_info.bdf());
26        println!("\t\tDevice Major: {:?}", device_info.major());
27        println!("\t\tDevice Minor: {:?}", device_info.minor());
28        println!(
29            "\t\tDevice Firmware Version: {}",
30            device_info.firmware_version()
31        );
32
33        let device_file = device.device_files()?;
34        println!("Device Files");
35        for file in device_file.iter() {
36            println!("\t\tDevice File Cores: {:?}", file.cores());
37            println!("\t\tDevice File Path: {:?}", file.path());
38        }
39
40        //core status
41        let core_status = device.core_status()?;
42        println!("Core Status");
43        for (core_id, status) in core_status.iter() {
44            println!("\t\tCore ID: {:?}", core_id);
45            println!("\t\tCore Status: {:?}", status);
46        }
47
48        //error info
49        let error_info = device.device_error_info()?;
50        println!("Device Error Info");
51        println!(
52            "\t\tDevice axi post error count: {:?}",
53            error_info.axi_doorbell_error_count()
54        );
55        println!(
56            "\t\tDevice axi fetch error count: {:?}",
57            error_info.axi_fetch_error_count()
58        );
59        println!(
60            "\t\tDevice axi discard error count: {:?}",
61            error_info.axi_discard_error_count()
62        );
63        println!(
64            "\t\tDevice axi doorbell error count: {:?}",
65            error_info.axi_doorbell_error_count()
66        );
67        println!(
68            "\t\tDevice pcie post error count: {:?}",
69            error_info.pcie_post_error_count()
70        );
71        println!(
72            "\t\tDevice pcie fetch error count: {:?}",
73            error_info.pcie_fetch_error_count()
74        );
75        println!(
76            "\t\tDevice pcie discard error count: {:?}",
77            error_info.pcie_discard_error_count()
78        );
79        println!(
80            "\t\tDevice pcie doorbell error count: {:?}",
81            error_info.pcie_doorbell_error_count()
82        );
83        println!(
84            "\t\tDevice device error count: {:?}",
85            error_info.device_error_count()
86        );
87
88        //liveness
89        println!("Device Liveness: {:?}", device.liveness()?);
90
91        //power consumption
92        println!(
93            "Device Power Consumption: {:?}",
94            device.power_consumption()?
95        );
96
97        //temperature
98        let device_temperature = device.device_temperature()?;
99        println!("Device Temperature");
100        println!("\t\tDevice SOC Peak: {:?}", device_temperature.soc_peak());
101        println!("\t\tDevice Ambient: {:?}", device_temperature.ambient());
102
103        //performance
104        let core_utilization = device.core_utilization()?;
105        let device_performance_counter = device.device_performance_counter()?;
106        println!("Device Utilization");
107        let pe_performance_counter = device_performance_counter.pe_performance_counters();
108        let pe_utilization = core_utilization.pe_utilization();
109        for (pe_util, pe_performance_counter) in
110            pe_utilization.iter().zip(pe_performance_counter.iter())
111        {
112            println!("\t\tPE Core: {:?}", pe_util.core());
113            println!("\t\tPE Time Window Mill: {:?}", pe_util.time_window_mill());
114            println!(
115                "\t\tPE Usage Percentage: {:?}",
116                pe_util.pe_usage_percentage()
117            );
118            let timestamp = pe_performance_counter.timestamp();
119            let datetime: DateTime<Local> = timestamp.into();
120            println!("\t\tPE Timestamp: {}", datetime);
121            println!(
122                "\t\tPE Task Execution Cycle: {:?}",
123                pe_performance_counter.task_execution_cycle()
124            );
125            println!(
126                "\t\tPE Cycle Count: {:?}",
127                pe_performance_counter.cycle_count()
128            );
129        }
130
131        let memory_utilization = match device.memory_utilization() {
132            Ok(memory_utilization) => memory_utilization,
133            Err(test_smi_rs::SmiError::NotSupportedError) => {
134                println!("Memory Utilization is not supported yet");
135                continue;
136            }
137            Err(e) => return Err(e),
138        };
139        println!("Memory Utilization");
140        println!(
141            "\t\tMemory Total Bytes: {:?}",
142            memory_utilization.total_bytes()
143        );
144        println!(
145            "\t\tMemory In Use Bytes: {:?}",
146            memory_utilization.in_use_bytes()
147        );
148    }
149    Ok(())
150}
Source

pub fn bdf(&self) -> String

Get a bdf of device

Examples found in repository?
examples/list_device.rs (line 25)
5fn main() -> SmiResult<()> {
6    let devices = list_devices()?;
7    match driver_info() {
8        Ok(version_info) => {
9            println!("Driver Version: {}", version_info);
10        }
11        Err(_) => {
12            println!("Error: Failed to retrieve driver information.")
13        }
14    }
15
16    for device in devices.iter() {
17        let device_info = device.device_info()?;
18        println!("Device Info");
19        println!("\t\tDevice Arch: {:?}", device_info.arch());
20        println!("\t\tDevice Cores: {:?}", device_info.core_num());
21        println!("\t\tDevice NUMA Node: {:?}", device_info.numa_node());
22        println!("\t\tDevice Name: {:?}", device_info.name());
23        println!("\t\tDevice Serial: {:?}", device_info.serial());
24        println!("\t\tDevice UUID: {:?}", device_info.uuid());
25        println!("\t\tDevice BDF: {:?}", device_info.bdf());
26        println!("\t\tDevice Major: {:?}", device_info.major());
27        println!("\t\tDevice Minor: {:?}", device_info.minor());
28        println!(
29            "\t\tDevice Firmware Version: {}",
30            device_info.firmware_version()
31        );
32
33        let device_file = device.device_files()?;
34        println!("Device Files");
35        for file in device_file.iter() {
36            println!("\t\tDevice File Cores: {:?}", file.cores());
37            println!("\t\tDevice File Path: {:?}", file.path());
38        }
39
40        //core status
41        let core_status = device.core_status()?;
42        println!("Core Status");
43        for (core_id, status) in core_status.iter() {
44            println!("\t\tCore ID: {:?}", core_id);
45            println!("\t\tCore Status: {:?}", status);
46        }
47
48        //error info
49        let error_info = device.device_error_info()?;
50        println!("Device Error Info");
51        println!(
52            "\t\tDevice axi post error count: {:?}",
53            error_info.axi_doorbell_error_count()
54        );
55        println!(
56            "\t\tDevice axi fetch error count: {:?}",
57            error_info.axi_fetch_error_count()
58        );
59        println!(
60            "\t\tDevice axi discard error count: {:?}",
61            error_info.axi_discard_error_count()
62        );
63        println!(
64            "\t\tDevice axi doorbell error count: {:?}",
65            error_info.axi_doorbell_error_count()
66        );
67        println!(
68            "\t\tDevice pcie post error count: {:?}",
69            error_info.pcie_post_error_count()
70        );
71        println!(
72            "\t\tDevice pcie fetch error count: {:?}",
73            error_info.pcie_fetch_error_count()
74        );
75        println!(
76            "\t\tDevice pcie discard error count: {:?}",
77            error_info.pcie_discard_error_count()
78        );
79        println!(
80            "\t\tDevice pcie doorbell error count: {:?}",
81            error_info.pcie_doorbell_error_count()
82        );
83        println!(
84            "\t\tDevice device error count: {:?}",
85            error_info.device_error_count()
86        );
87
88        //liveness
89        println!("Device Liveness: {:?}", device.liveness()?);
90
91        //power consumption
92        println!(
93            "Device Power Consumption: {:?}",
94            device.power_consumption()?
95        );
96
97        //temperature
98        let device_temperature = device.device_temperature()?;
99        println!("Device Temperature");
100        println!("\t\tDevice SOC Peak: {:?}", device_temperature.soc_peak());
101        println!("\t\tDevice Ambient: {:?}", device_temperature.ambient());
102
103        //performance
104        let core_utilization = device.core_utilization()?;
105        let device_performance_counter = device.device_performance_counter()?;
106        println!("Device Utilization");
107        let pe_performance_counter = device_performance_counter.pe_performance_counters();
108        let pe_utilization = core_utilization.pe_utilization();
109        for (pe_util, pe_performance_counter) in
110            pe_utilization.iter().zip(pe_performance_counter.iter())
111        {
112            println!("\t\tPE Core: {:?}", pe_util.core());
113            println!("\t\tPE Time Window Mill: {:?}", pe_util.time_window_mill());
114            println!(
115                "\t\tPE Usage Percentage: {:?}",
116                pe_util.pe_usage_percentage()
117            );
118            let timestamp = pe_performance_counter.timestamp();
119            let datetime: DateTime<Local> = timestamp.into();
120            println!("\t\tPE Timestamp: {}", datetime);
121            println!(
122                "\t\tPE Task Execution Cycle: {:?}",
123                pe_performance_counter.task_execution_cycle()
124            );
125            println!(
126                "\t\tPE Cycle Count: {:?}",
127                pe_performance_counter.cycle_count()
128            );
129        }
130
131        let memory_utilization = match device.memory_utilization() {
132            Ok(memory_utilization) => memory_utilization,
133            Err(test_smi_rs::SmiError::NotSupportedError) => {
134                println!("Memory Utilization is not supported yet");
135                continue;
136            }
137            Err(e) => return Err(e),
138        };
139        println!("Memory Utilization");
140        println!(
141            "\t\tMemory Total Bytes: {:?}",
142            memory_utilization.total_bytes()
143        );
144        println!(
145            "\t\tMemory In Use Bytes: {:?}",
146            memory_utilization.in_use_bytes()
147        );
148    }
149    Ok(())
150}
Source

pub fn major(&self) -> u16

Get a major part of pci device

Examples found in repository?
examples/list_device.rs (line 26)
5fn main() -> SmiResult<()> {
6    let devices = list_devices()?;
7    match driver_info() {
8        Ok(version_info) => {
9            println!("Driver Version: {}", version_info);
10        }
11        Err(_) => {
12            println!("Error: Failed to retrieve driver information.")
13        }
14    }
15
16    for device in devices.iter() {
17        let device_info = device.device_info()?;
18        println!("Device Info");
19        println!("\t\tDevice Arch: {:?}", device_info.arch());
20        println!("\t\tDevice Cores: {:?}", device_info.core_num());
21        println!("\t\tDevice NUMA Node: {:?}", device_info.numa_node());
22        println!("\t\tDevice Name: {:?}", device_info.name());
23        println!("\t\tDevice Serial: {:?}", device_info.serial());
24        println!("\t\tDevice UUID: {:?}", device_info.uuid());
25        println!("\t\tDevice BDF: {:?}", device_info.bdf());
26        println!("\t\tDevice Major: {:?}", device_info.major());
27        println!("\t\tDevice Minor: {:?}", device_info.minor());
28        println!(
29            "\t\tDevice Firmware Version: {}",
30            device_info.firmware_version()
31        );
32
33        let device_file = device.device_files()?;
34        println!("Device Files");
35        for file in device_file.iter() {
36            println!("\t\tDevice File Cores: {:?}", file.cores());
37            println!("\t\tDevice File Path: {:?}", file.path());
38        }
39
40        //core status
41        let core_status = device.core_status()?;
42        println!("Core Status");
43        for (core_id, status) in core_status.iter() {
44            println!("\t\tCore ID: {:?}", core_id);
45            println!("\t\tCore Status: {:?}", status);
46        }
47
48        //error info
49        let error_info = device.device_error_info()?;
50        println!("Device Error Info");
51        println!(
52            "\t\tDevice axi post error count: {:?}",
53            error_info.axi_doorbell_error_count()
54        );
55        println!(
56            "\t\tDevice axi fetch error count: {:?}",
57            error_info.axi_fetch_error_count()
58        );
59        println!(
60            "\t\tDevice axi discard error count: {:?}",
61            error_info.axi_discard_error_count()
62        );
63        println!(
64            "\t\tDevice axi doorbell error count: {:?}",
65            error_info.axi_doorbell_error_count()
66        );
67        println!(
68            "\t\tDevice pcie post error count: {:?}",
69            error_info.pcie_post_error_count()
70        );
71        println!(
72            "\t\tDevice pcie fetch error count: {:?}",
73            error_info.pcie_fetch_error_count()
74        );
75        println!(
76            "\t\tDevice pcie discard error count: {:?}",
77            error_info.pcie_discard_error_count()
78        );
79        println!(
80            "\t\tDevice pcie doorbell error count: {:?}",
81            error_info.pcie_doorbell_error_count()
82        );
83        println!(
84            "\t\tDevice device error count: {:?}",
85            error_info.device_error_count()
86        );
87
88        //liveness
89        println!("Device Liveness: {:?}", device.liveness()?);
90
91        //power consumption
92        println!(
93            "Device Power Consumption: {:?}",
94            device.power_consumption()?
95        );
96
97        //temperature
98        let device_temperature = device.device_temperature()?;
99        println!("Device Temperature");
100        println!("\t\tDevice SOC Peak: {:?}", device_temperature.soc_peak());
101        println!("\t\tDevice Ambient: {:?}", device_temperature.ambient());
102
103        //performance
104        let core_utilization = device.core_utilization()?;
105        let device_performance_counter = device.device_performance_counter()?;
106        println!("Device Utilization");
107        let pe_performance_counter = device_performance_counter.pe_performance_counters();
108        let pe_utilization = core_utilization.pe_utilization();
109        for (pe_util, pe_performance_counter) in
110            pe_utilization.iter().zip(pe_performance_counter.iter())
111        {
112            println!("\t\tPE Core: {:?}", pe_util.core());
113            println!("\t\tPE Time Window Mill: {:?}", pe_util.time_window_mill());
114            println!(
115                "\t\tPE Usage Percentage: {:?}",
116                pe_util.pe_usage_percentage()
117            );
118            let timestamp = pe_performance_counter.timestamp();
119            let datetime: DateTime<Local> = timestamp.into();
120            println!("\t\tPE Timestamp: {}", datetime);
121            println!(
122                "\t\tPE Task Execution Cycle: {:?}",
123                pe_performance_counter.task_execution_cycle()
124            );
125            println!(
126                "\t\tPE Cycle Count: {:?}",
127                pe_performance_counter.cycle_count()
128            );
129        }
130
131        let memory_utilization = match device.memory_utilization() {
132            Ok(memory_utilization) => memory_utilization,
133            Err(test_smi_rs::SmiError::NotSupportedError) => {
134                println!("Memory Utilization is not supported yet");
135                continue;
136            }
137            Err(e) => return Err(e),
138        };
139        println!("Memory Utilization");
140        println!(
141            "\t\tMemory Total Bytes: {:?}",
142            memory_utilization.total_bytes()
143        );
144        println!(
145            "\t\tMemory In Use Bytes: {:?}",
146            memory_utilization.in_use_bytes()
147        );
148    }
149    Ok(())
150}
Source

pub fn minor(&self) -> u16

Get a minor part of pci device

Examples found in repository?
examples/list_device.rs (line 27)
5fn main() -> SmiResult<()> {
6    let devices = list_devices()?;
7    match driver_info() {
8        Ok(version_info) => {
9            println!("Driver Version: {}", version_info);
10        }
11        Err(_) => {
12            println!("Error: Failed to retrieve driver information.")
13        }
14    }
15
16    for device in devices.iter() {
17        let device_info = device.device_info()?;
18        println!("Device Info");
19        println!("\t\tDevice Arch: {:?}", device_info.arch());
20        println!("\t\tDevice Cores: {:?}", device_info.core_num());
21        println!("\t\tDevice NUMA Node: {:?}", device_info.numa_node());
22        println!("\t\tDevice Name: {:?}", device_info.name());
23        println!("\t\tDevice Serial: {:?}", device_info.serial());
24        println!("\t\tDevice UUID: {:?}", device_info.uuid());
25        println!("\t\tDevice BDF: {:?}", device_info.bdf());
26        println!("\t\tDevice Major: {:?}", device_info.major());
27        println!("\t\tDevice Minor: {:?}", device_info.minor());
28        println!(
29            "\t\tDevice Firmware Version: {}",
30            device_info.firmware_version()
31        );
32
33        let device_file = device.device_files()?;
34        println!("Device Files");
35        for file in device_file.iter() {
36            println!("\t\tDevice File Cores: {:?}", file.cores());
37            println!("\t\tDevice File Path: {:?}", file.path());
38        }
39
40        //core status
41        let core_status = device.core_status()?;
42        println!("Core Status");
43        for (core_id, status) in core_status.iter() {
44            println!("\t\tCore ID: {:?}", core_id);
45            println!("\t\tCore Status: {:?}", status);
46        }
47
48        //error info
49        let error_info = device.device_error_info()?;
50        println!("Device Error Info");
51        println!(
52            "\t\tDevice axi post error count: {:?}",
53            error_info.axi_doorbell_error_count()
54        );
55        println!(
56            "\t\tDevice axi fetch error count: {:?}",
57            error_info.axi_fetch_error_count()
58        );
59        println!(
60            "\t\tDevice axi discard error count: {:?}",
61            error_info.axi_discard_error_count()
62        );
63        println!(
64            "\t\tDevice axi doorbell error count: {:?}",
65            error_info.axi_doorbell_error_count()
66        );
67        println!(
68            "\t\tDevice pcie post error count: {:?}",
69            error_info.pcie_post_error_count()
70        );
71        println!(
72            "\t\tDevice pcie fetch error count: {:?}",
73            error_info.pcie_fetch_error_count()
74        );
75        println!(
76            "\t\tDevice pcie discard error count: {:?}",
77            error_info.pcie_discard_error_count()
78        );
79        println!(
80            "\t\tDevice pcie doorbell error count: {:?}",
81            error_info.pcie_doorbell_error_count()
82        );
83        println!(
84            "\t\tDevice device error count: {:?}",
85            error_info.device_error_count()
86        );
87
88        //liveness
89        println!("Device Liveness: {:?}", device.liveness()?);
90
91        //power consumption
92        println!(
93            "Device Power Consumption: {:?}",
94            device.power_consumption()?
95        );
96
97        //temperature
98        let device_temperature = device.device_temperature()?;
99        println!("Device Temperature");
100        println!("\t\tDevice SOC Peak: {:?}", device_temperature.soc_peak());
101        println!("\t\tDevice Ambient: {:?}", device_temperature.ambient());
102
103        //performance
104        let core_utilization = device.core_utilization()?;
105        let device_performance_counter = device.device_performance_counter()?;
106        println!("Device Utilization");
107        let pe_performance_counter = device_performance_counter.pe_performance_counters();
108        let pe_utilization = core_utilization.pe_utilization();
109        for (pe_util, pe_performance_counter) in
110            pe_utilization.iter().zip(pe_performance_counter.iter())
111        {
112            println!("\t\tPE Core: {:?}", pe_util.core());
113            println!("\t\tPE Time Window Mill: {:?}", pe_util.time_window_mill());
114            println!(
115                "\t\tPE Usage Percentage: {:?}",
116                pe_util.pe_usage_percentage()
117            );
118            let timestamp = pe_performance_counter.timestamp();
119            let datetime: DateTime<Local> = timestamp.into();
120            println!("\t\tPE Timestamp: {}", datetime);
121            println!(
122                "\t\tPE Task Execution Cycle: {:?}",
123                pe_performance_counter.task_execution_cycle()
124            );
125            println!(
126                "\t\tPE Cycle Count: {:?}",
127                pe_performance_counter.cycle_count()
128            );
129        }
130
131        let memory_utilization = match device.memory_utilization() {
132            Ok(memory_utilization) => memory_utilization,
133            Err(test_smi_rs::SmiError::NotSupportedError) => {
134                println!("Memory Utilization is not supported yet");
135                continue;
136            }
137            Err(e) => return Err(e),
138        };
139        println!("Memory Utilization");
140        println!(
141            "\t\tMemory Total Bytes: {:?}",
142            memory_utilization.total_bytes()
143        );
144        println!(
145            "\t\tMemory In Use Bytes: {:?}",
146            memory_utilization.in_use_bytes()
147        );
148    }
149    Ok(())
150}
Source

pub fn firmware_version(&self) -> VersionInfo

Get a firmware version of device

Examples found in repository?
examples/list_device.rs (line 30)
5fn main() -> SmiResult<()> {
6    let devices = list_devices()?;
7    match driver_info() {
8        Ok(version_info) => {
9            println!("Driver Version: {}", version_info);
10        }
11        Err(_) => {
12            println!("Error: Failed to retrieve driver information.")
13        }
14    }
15
16    for device in devices.iter() {
17        let device_info = device.device_info()?;
18        println!("Device Info");
19        println!("\t\tDevice Arch: {:?}", device_info.arch());
20        println!("\t\tDevice Cores: {:?}", device_info.core_num());
21        println!("\t\tDevice NUMA Node: {:?}", device_info.numa_node());
22        println!("\t\tDevice Name: {:?}", device_info.name());
23        println!("\t\tDevice Serial: {:?}", device_info.serial());
24        println!("\t\tDevice UUID: {:?}", device_info.uuid());
25        println!("\t\tDevice BDF: {:?}", device_info.bdf());
26        println!("\t\tDevice Major: {:?}", device_info.major());
27        println!("\t\tDevice Minor: {:?}", device_info.minor());
28        println!(
29            "\t\tDevice Firmware Version: {}",
30            device_info.firmware_version()
31        );
32
33        let device_file = device.device_files()?;
34        println!("Device Files");
35        for file in device_file.iter() {
36            println!("\t\tDevice File Cores: {:?}", file.cores());
37            println!("\t\tDevice File Path: {:?}", file.path());
38        }
39
40        //core status
41        let core_status = device.core_status()?;
42        println!("Core Status");
43        for (core_id, status) in core_status.iter() {
44            println!("\t\tCore ID: {:?}", core_id);
45            println!("\t\tCore Status: {:?}", status);
46        }
47
48        //error info
49        let error_info = device.device_error_info()?;
50        println!("Device Error Info");
51        println!(
52            "\t\tDevice axi post error count: {:?}",
53            error_info.axi_doorbell_error_count()
54        );
55        println!(
56            "\t\tDevice axi fetch error count: {:?}",
57            error_info.axi_fetch_error_count()
58        );
59        println!(
60            "\t\tDevice axi discard error count: {:?}",
61            error_info.axi_discard_error_count()
62        );
63        println!(
64            "\t\tDevice axi doorbell error count: {:?}",
65            error_info.axi_doorbell_error_count()
66        );
67        println!(
68            "\t\tDevice pcie post error count: {:?}",
69            error_info.pcie_post_error_count()
70        );
71        println!(
72            "\t\tDevice pcie fetch error count: {:?}",
73            error_info.pcie_fetch_error_count()
74        );
75        println!(
76            "\t\tDevice pcie discard error count: {:?}",
77            error_info.pcie_discard_error_count()
78        );
79        println!(
80            "\t\tDevice pcie doorbell error count: {:?}",
81            error_info.pcie_doorbell_error_count()
82        );
83        println!(
84            "\t\tDevice device error count: {:?}",
85            error_info.device_error_count()
86        );
87
88        //liveness
89        println!("Device Liveness: {:?}", device.liveness()?);
90
91        //power consumption
92        println!(
93            "Device Power Consumption: {:?}",
94            device.power_consumption()?
95        );
96
97        //temperature
98        let device_temperature = device.device_temperature()?;
99        println!("Device Temperature");
100        println!("\t\tDevice SOC Peak: {:?}", device_temperature.soc_peak());
101        println!("\t\tDevice Ambient: {:?}", device_temperature.ambient());
102
103        //performance
104        let core_utilization = device.core_utilization()?;
105        let device_performance_counter = device.device_performance_counter()?;
106        println!("Device Utilization");
107        let pe_performance_counter = device_performance_counter.pe_performance_counters();
108        let pe_utilization = core_utilization.pe_utilization();
109        for (pe_util, pe_performance_counter) in
110            pe_utilization.iter().zip(pe_performance_counter.iter())
111        {
112            println!("\t\tPE Core: {:?}", pe_util.core());
113            println!("\t\tPE Time Window Mill: {:?}", pe_util.time_window_mill());
114            println!(
115                "\t\tPE Usage Percentage: {:?}",
116                pe_util.pe_usage_percentage()
117            );
118            let timestamp = pe_performance_counter.timestamp();
119            let datetime: DateTime<Local> = timestamp.into();
120            println!("\t\tPE Timestamp: {}", datetime);
121            println!(
122                "\t\tPE Task Execution Cycle: {:?}",
123                pe_performance_counter.task_execution_cycle()
124            );
125            println!(
126                "\t\tPE Cycle Count: {:?}",
127                pe_performance_counter.cycle_count()
128            );
129        }
130
131        let memory_utilization = match device.memory_utilization() {
132            Ok(memory_utilization) => memory_utilization,
133            Err(test_smi_rs::SmiError::NotSupportedError) => {
134                println!("Memory Utilization is not supported yet");
135                continue;
136            }
137            Err(e) => return Err(e),
138        };
139        println!("Memory Utilization");
140        println!(
141            "\t\tMemory Total Bytes: {:?}",
142            memory_utilization.total_bytes()
143        );
144        println!(
145            "\t\tMemory In Use Bytes: {:?}",
146            memory_utilization.in_use_bytes()
147        );
148    }
149    Ok(())
150}

Auto Trait Implementations§

Blanket Implementations§

Source§

impl<T> Any for T
where T: 'static + ?Sized,

Source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
Source§

impl<T> Borrow<T> for T
where T: ?Sized,

Source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
Source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

Source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
Source§

impl<T> From<T> for T

Source§

fn from(t: T) -> T

Returns the argument unchanged.

Source§

impl<T, U> Into<U> for T
where U: From<T>,

Source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

Source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

Source§

type Error = Infallible

The type returned in the event of a conversion error.
Source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
Source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

Source§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
Source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.