0
# CPU Management (ESMI)
1
2
CPU power monitoring, frequency control, temperature sensors, and energy consumption tracking for AMD EPYC processors. Requires ESMI (Energy System Management Interface) support.
3
4
## Capabilities
5
6
### CPU Socket Energy Monitoring
7
8
Monitor energy consumption at the CPU socket level.
9
10
```cpp { .api }
11
amdsmi_status_t amdsmi_get_cpu_socket_energy(amdsmi_processor_handle processor_handle,
12
uint64_t* penergy);
13
```
14
15
**Usage Example:**
16
```cpp
17
uint64_t energy;
18
amdsmi_status_t status = amdsmi_get_cpu_socket_energy(cpu_handle, &energy);
19
20
if (status == AMDSMI_STATUS_SUCCESS) {
21
printf("CPU Socket Energy: %lu microjoules\n", energy);
22
}
23
```
24
25
### CPU Socket Power Monitoring
26
27
Get current power consumption at the CPU socket level.
28
29
```cpp { .api }
30
amdsmi_status_t amdsmi_get_cpu_socket_power(amdsmi_processor_handle processor_handle,
31
uint32_t* ppower);
32
```
33
34
### CPU Core Energy Monitoring
35
36
Monitor energy consumption at individual CPU core level.
37
38
```cpp { .api }
39
amdsmi_status_t amdsmi_get_cpu_core_energy(amdsmi_processor_handle processor_handle,
40
uint64_t* penergy);
41
```
42
43
### CPU Frequency Information
44
45
Get current frequency limits and operating frequencies for CPU cores.
46
47
```cpp { .api }
48
amdsmi_status_t amdsmi_get_cpu_core_current_freq_limit(amdsmi_processor_handle processor_handle,
49
uint32_t* freq);
50
```
51
52
```cpp { .api }
53
amdsmi_status_t amdsmi_get_cpu_socket_current_active_freq_limit(amdsmi_processor_handle processor_handle,
54
uint16_t* freq);
55
```
56
57
```cpp { .api }
58
amdsmi_status_t amdsmi_get_cpu_socket_freq_range(amdsmi_processor_handle processor_handle,
59
uint16_t* fmax,
60
uint16_t* fmin);
61
```
62
63
### CPU Temperature Monitoring
64
65
Monitor CPU temperatures across different sensor locations.
66
67
```cpp { .api }
68
amdsmi_status_t amdsmi_get_cpu_socket_temperature(amdsmi_processor_handle processor_handle,
69
uint32_t* ptmon);
70
```
71
72
### CPU System Information
73
74
Get CPU topology and configuration information.
75
76
```cpp { .api }
77
amdsmi_status_t amdsmi_get_threads_per_core(amdsmi_processor_handle processor_handle,
78
uint32_t* threads_per_core);
79
```
80
81
```cpp { .api }
82
amdsmi_status_t amdsmi_get_cpu_fclk_mclk(amdsmi_processor_handle processor_handle,
83
uint32_t* fclk,
84
uint32_t* mclk);
85
```
86
87
### CPU Handle Discovery
88
89
Get CPU-specific processor handles for management operations.
90
91
```cpp { .api }
92
amdsmi_status_t amdsmi_get_cpusocket_handles(uint32_t* num_sockets,
93
amdsmi_cpusocket_handle* socket_handles);
94
```
95
96
```cpp { .api }
97
amdsmi_status_t amdsmi_get_cpucore_handles(amdsmi_cpusocket_handle socket_handle,
98
uint32_t* num_cores,
99
amdsmi_cpucore_handle* core_handles);
100
```
101
102
### CPU Driver Information
103
104
Get HSMP (Host System Management Port) driver version and protocol information.
105
106
```cpp { .api }
107
amdsmi_status_t amdsmi_get_cpu_hsmp_driver_version(amdsmi_processor_handle processor_handle,
108
uint32_t* version);
109
```
110
111
```cpp { .api }
112
amdsmi_status_t amdsmi_get_cpu_hsmp_proto_ver(amdsmi_processor_handle processor_handle,
113
uint32_t* proto_ver);
114
```
115
116
### CPU Thermal Status
117
118
Monitor CPU thermal status and PROCHOT (processor hot) conditions.
119
120
```cpp { .api }
121
amdsmi_status_t amdsmi_get_cpu_prochot_status(amdsmi_processor_handle processor_handle,
122
uint32_t* prochot);
123
```
124
125
## Language Interface Examples
126
127
### Python
128
```python
129
import amdsmi
130
131
# Get CPU socket handles
132
try:
133
cpu_socket_handles = amdsmi.amdsmi_get_cpusocket_handles()
134
print(f"Found {len(cpu_socket_handles)} CPU socket(s)")
135
136
for i, socket_handle in enumerate(cpu_socket_handles):
137
print(f"CPU Socket {i}:")
138
139
# Get socket power
140
power = amdsmi.amdsmi_get_cpu_socket_power(socket_handle)
141
print(f" Power: {power}W")
142
143
# Get socket energy
144
energy = amdsmi.amdsmi_get_cpu_socket_energy(socket_handle)
145
print(f" Energy: {energy} microjoules")
146
147
# Get socket temperature
148
temp = amdsmi.amdsmi_get_cpu_socket_temperature(socket_handle)
149
print(f" Temperature: {temp / 1000}°C")
150
151
# Get frequency information
152
freq_limit = amdsmi.amdsmi_get_cpu_socket_current_active_freq_limit(socket_handle)
153
print(f" Current Frequency Limit: {freq_limit} MHz")
154
155
# Get frequency range
156
freq_range = amdsmi.amdsmi_get_cpu_socket_freq_range(socket_handle)
157
print(f" Frequency Range: {freq_range['fmin']} - {freq_range['fmax']} MHz")
158
159
# Get PROCHOT status
160
prochot = amdsmi.amdsmi_get_cpu_prochot_status(socket_handle)
161
print(f" PROCHOT Status: {'Active' if prochot else 'Inactive'}")
162
163
# Get core handles for this socket
164
core_handles = amdsmi.amdsmi_get_cpucore_handles(socket_handle)
165
print(f" CPU Cores: {len(core_handles)}")
166
167
# Get per-core information
168
for j, core_handle in enumerate(core_handles[:4]): # Show first 4 cores
169
core_energy = amdsmi.amdsmi_get_cpu_core_energy(core_handle)
170
core_freq = amdsmi.amdsmi_get_cpu_core_current_freq_limit(core_handle)
171
print(f" Core {j}: {core_freq} MHz, {core_energy} μJ")
172
173
except amdsmi.AmdSmiException as e:
174
print(f"CPU monitoring not available: {e}")
175
```
176
177
### Rust
178
```rust
179
use amdsmi::{get_cpusocket_handles, get_cpu_socket_power, get_cpu_socket_energy};
180
use amdsmi::{get_cpu_socket_temperature, get_cpucore_handles};
181
182
// Monitor CPU sockets
183
match get_cpusocket_handles() {
184
Ok(socket_handles) => {
185
println!("Found {} CPU socket(s)", socket_handles.len());
186
187
for (i, socket_handle) in socket_handles.iter().enumerate() {
188
println!("CPU Socket {}:", i);
189
190
// Get power consumption
191
if let Ok(power) = get_cpu_socket_power(*socket_handle) {
192
println!(" Power: {}W", power);
193
}
194
195
// Get energy consumption
196
if let Ok(energy) = get_cpu_socket_energy(*socket_handle) {
197
println!(" Energy: {} μJ", energy);
198
}
199
200
// Get temperature
201
if let Ok(temp) = get_cpu_socket_temperature(*socket_handle) {
202
println!(" Temperature: {}°C", temp / 1000);
203
}
204
205
// Get core handles
206
if let Ok(core_handles) = get_cpucore_handles(*socket_handle) {
207
println!(" CPU Cores: {}", core_handles.len());
208
}
209
}
210
},
211
Err(e) => println!("CPU monitoring not available: {:?}", e),
212
}
213
```
214
215
## CPU Management Requirements
216
217
1. **ESMI Support**: Requires AMD EPYC processors with ESMI support
218
2. **Driver Requirements**: Needs HSMP driver loaded and accessible
219
3. **Permissions**: May require elevated privileges for some operations
220
4. **Platform Support**: Currently limited to AMD EPYC server platforms
221
5. **Initialization**: Must initialize with `AMDSMI_INIT_AMD_CPUS` flag
222
223
## CPU Management Best Practices
224
225
1. **Energy Monitoring**: Use energy counters for accurate power profiling
226
2. **Thermal Monitoring**: Monitor PROCHOT status to detect thermal throttling
227
3. **Core-Level Granularity**: Use per-core monitoring for detailed analysis
228
4. **Driver Compatibility**: Check HSMP driver version for feature availability
229
5. **Platform Validation**: Verify ESMI support before attempting CPU operations