0
# GPU Performance Monitoring
1

2
Real-time monitoring of GPU utilization, clock frequencies, memory usage, and performance metrics through the Go interface.
3

4
## Capabilities
5

6
### GPU Activity Monitoring
7

8
Monitor GPU and memory utilization percentages.
9

10
```go { .api }
11
func GO_gpu_dev_gpu_busy_percent_get(i int) C.uint32_t
12
func GO_gpu_dev_gpu_memory_busy_percent_get(i int) C.uint64_t
13
```
14

15
**Parameters:**
16
- `i`: GPU device index (0-based)
17

18
**Returns:**
19
- GPU busy percentage (0-100) for GPU utilization
20
- Memory busy percentage (0-100) for memory controller utilization
21
- Error value `0xFFFFFFFF` or `0xFFFFFFFFFFFFFFFF` on failure
22

23
**Usage Example:**
24

25
```go
26
// Monitor utilization for all GPUs
27
numGPUs := int(goamdsmi.GO_gpu_num_monitor_devices())
28
for i := 0; i < numGPUs; i++ {
29
    gpuBusy := goamdsmi.GO_gpu_dev_gpu_busy_percent_get(i)
30
    memBusy := goamdsmi.GO_gpu_dev_gpu_memory_busy_percent_get(i)
31
    
32
    if gpuBusy != 0xFFFFFFFF && memBusy != 0xFFFFFFFFFFFFFFFF {
33
        fmt.Printf("GPU %d: %d%% busy, Memory: %d%% busy\n", i, gpuBusy, memBusy)
34
    }
35
}
36
```
37

38
### Clock Frequency Monitoring
39

40
Get current system clock (SCLK) and memory clock (MCLK) frequencies.
41

42
```go { .api }
43
func GO_gpu_dev_gpu_clk_freq_get_sclk(i int) C.uint64_t
44
func GO_gpu_dev_gpu_clk_freq_get_mclk(i int) C.uint64_t
45
```
46

47
**Parameters:**
48
- `i`: GPU device index (0-based)
49

50
**Returns:**
51
- Clock frequency in Hz
52
- Error value `0xFFFFFFFFFFFFFFFF` on failure
53

54
**Usage Example:**
55

56
```go
57
gpuIndex := 0
58
sclkFreq := goamdsmi.GO_gpu_dev_gpu_clk_freq_get_sclk(gpuIndex)
59
mclkFreq := goamdsmi.GO_gpu_dev_gpu_clk_freq_get_mclk(gpuIndex)
60

61
if sclkFreq != 0xFFFFFFFFFFFFFFFF {
62
    fmt.Printf("GPU %d SCLK: %.0f MHz\n", gpuIndex, float64(sclkFreq)/1e6)
63
}
64
if mclkFreq != 0xFFFFFFFFFFFFFFFF {
65
    fmt.Printf("GPU %d MCLK: %.0f MHz\n", gpuIndex, float64(mclkFreq)/1e6)
66
}
67
```
68

69
### Performance Level Monitoring
70

71
Monitor GPU performance levels and overdrive settings.
72

73
```go { .api }
74
func GO_gpu_dev_perf_level_get(i int) C.uint32_t
75
func GO_gpu_dev_overdrive_level_get(i int) C.uint32_t
76
func GO_gpu_dev_mem_overdrive_level_get(i int) C.uint32_t
77
```
78

79
**Parameters:**
80
- `i`: GPU device index (0-based)
81

82
**Returns:**
83
- Performance level or overdrive percentage
84
- Error value `0xFFFFFFFF` on failure
85

86
**Usage Example:**
87

88
```go
89
gpuIndex := 0
90
perfLevel := goamdsmi.GO_gpu_dev_perf_level_get(gpuIndex)
91
overdriveLevel := goamdsmi.GO_gpu_dev_overdrive_level_get(gpuIndex)
92
memOverdrive := goamdsmi.GO_gpu_dev_mem_overdrive_level_get(gpuIndex)
93

94
if perfLevel != 0xFFFFFFFF {
95
    fmt.Printf("GPU %d Performance Level: %d\n", gpuIndex, perfLevel)
96
}
97
if overdriveLevel != 0xFFFFFFFF {
98
    fmt.Printf("GPU %d Overdrive: %d%%\n", gpuIndex, overdriveLevel)
99
}
100
if memOverdrive != 0xFFFFFFFF {
101
    fmt.Printf("GPU %d Memory Overdrive: %d%%\n", gpuIndex, memOverdrive)
102
}
103
```
104

105
## Error Handling
106

107
All Go functions return error values to indicate failure:
108

109
- **uint32 functions**: Return `0xFFFFFFFF` on failure
110
- **uint64 functions**: Return `0xFFFFFFFFFFFFFFFF` on failure
111

112
Always check return values against these error constants before using the data.