-
GPU — Memory Load
-
-
+
+
+
+
GPU — Compute Load
+
+
+
+
+
+
GPU — Memory Load
+
+
+
+
+
+
GPU — Core Clock
+
+
+
+
+
+
GPU — Memory Clock
+
+
+
+
+
+
GPU — Power
+
+
+
+
+
+
GPU — Temperature
+
+
+
+
-
-
-
GPU — Power
-
-
-
-
-
-
GPU — Temperature
-
-
-
-
+
+
+
`
}
diff --git a/audit/internal/webui/server.go b/audit/internal/webui/server.go
index b437c49..ab85603 100644
--- a/audit/internal/webui/server.go
+++ b/audit/internal/webui/server.go
@@ -6,11 +6,13 @@ import (
"fmt"
"html"
"log/slog"
+ "math"
"mime"
"net/http"
"os"
"path/filepath"
"sort"
+ "strconv"
"strings"
"sync"
"time"
@@ -475,6 +477,26 @@ func (h *handler) handleMetricsChartSVG(w http.ResponseWriter, r *http.Request)
http.Error(w, "metrics database not available", http.StatusServiceUnavailable)
return
}
+ if idx, sub, ok := parseGPUChartPath(path); ok && sub == "overview" {
+ samples, err := h.metricsDB.LoadAll()
+ if err != nil || len(samples) == 0 {
+ http.Error(w, "metrics history unavailable", http.StatusServiceUnavailable)
+ return
+ }
+ buf, ok, err := renderGPUOverviewChartSVG(idx, samples)
+ if err != nil {
+ http.Error(w, err.Error(), http.StatusInternalServerError)
+ return
+ }
+ if !ok {
+ http.Error(w, "metrics history unavailable", http.StatusServiceUnavailable)
+ return
+ }
+ w.Header().Set("Content-Type", "image/svg+xml")
+ w.Header().Set("Cache-Control", "no-store")
+ _, _ = w.Write(buf)
+ return
+ }
datasets, names, labels, title, yMin, yMax, ok := h.chartDataFromDB(path)
if !ok {
http.Error(w, "metrics history unavailable", http.StatusServiceUnavailable)
@@ -578,15 +600,21 @@ func chartDataFromSamples(path string, samples []platform.LiveMetricSample) ([][
yMin = floatPtr(0)
yMax = autoMax120(datasets...)
+ case path == "gpu-all-clock":
+ title = "GPU Core Clock"
+ datasets, names = gpuDatasets(samples, func(g platform.GPUMetricRow) float64 { return g.ClockMHz })
+ yMin, yMax = autoBounds120(datasets...)
+
+ case path == "gpu-all-memclock":
+ title = "GPU Memory Clock"
+ datasets, names = gpuDatasets(samples, func(g platform.GPUMetricRow) float64 { return g.MemClockMHz })
+ yMin, yMax = autoBounds120(datasets...)
+
case strings.HasPrefix(path, "gpu/"):
- rest := strings.TrimPrefix(path, "gpu/")
- sub := ""
- if i := strings.LastIndex(rest, "-"); i > 0 {
- sub = rest[i+1:]
- rest = rest[:i]
+ idx, sub, ok := parseGPUChartPath(path)
+ if !ok {
+ return nil, nil, nil, "", nil, nil, false
}
- idx := 0
- fmt.Sscanf(rest, "%d", &idx)
switch sub {
case "load":
title = fmt.Sprintf("GPU %d Load", idx)
@@ -609,6 +637,24 @@ func chartDataFromSamples(path string, samples []platform.LiveMetricSample) ([][
names = []string{"Temp °C"}
yMin = floatPtr(0)
yMax = autoMax120(temp)
+ case "clock":
+ title = fmt.Sprintf("GPU %d Core Clock", idx)
+ clock := gpuDatasetByIndex(samples, idx, func(g platform.GPUMetricRow) float64 { return g.ClockMHz })
+ if clock == nil {
+ return nil, nil, nil, "", nil, nil, false
+ }
+ datasets = [][]float64{clock}
+ names = []string{"Core Clock MHz"}
+ yMin, yMax = autoBounds120(clock)
+ case "memclock":
+ title = fmt.Sprintf("GPU %d Memory Clock", idx)
+ clock := gpuDatasetByIndex(samples, idx, func(g platform.GPUMetricRow) float64 { return g.MemClockMHz })
+ if clock == nil {
+ return nil, nil, nil, "", nil, nil, false
+ }
+ datasets = [][]float64{clock}
+ names = []string{"Memory Clock MHz"}
+ yMin, yMax = autoBounds120(clock)
default:
title = fmt.Sprintf("GPU %d Power", idx)
power := gpuDatasetByIndex(samples, idx, func(g platform.GPUMetricRow) float64 { return g.PowerW })
@@ -627,6 +673,26 @@ func chartDataFromSamples(path string, samples []platform.LiveMetricSample) ([][
return datasets, names, labels, title, yMin, yMax, len(datasets) > 0
}
+func parseGPUChartPath(path string) (idx int, sub string, ok bool) {
+ if !strings.HasPrefix(path, "gpu/") {
+ return 0, "", false
+ }
+ rest := strings.TrimPrefix(path, "gpu/")
+ if rest == "" {
+ return 0, "", false
+ }
+ sub = ""
+ if i := strings.LastIndex(rest, "-"); i > 0 {
+ sub = rest[i+1:]
+ rest = rest[:i]
+ }
+ n, err := fmt.Sscanf(rest, "%d", &idx)
+ if err != nil || n != 1 {
+ return 0, "", false
+ }
+ return idx, sub, true
+}
+
func sampleTimeLabels(samples []platform.LiveMetricSample) []string {
labels := make([]string, len(samples))
if len(samples) == 0 {
@@ -852,6 +918,268 @@ func autoBounds120(datasets ...[]float64) (*float64, *float64) {
return floatPtr(low), floatPtr(high)
}
+func renderGPUOverviewChartSVG(idx int, samples []platform.LiveMetricSample) ([]byte, bool, error) {
+ temp := gpuDatasetByIndex(samples, idx, func(g platform.GPUMetricRow) float64 { return g.TempC })
+ power := gpuDatasetByIndex(samples, idx, func(g platform.GPUMetricRow) float64 { return g.PowerW })
+ coreClock := gpuDatasetByIndex(samples, idx, func(g platform.GPUMetricRow) float64 { return g.ClockMHz })
+ memClock := gpuDatasetByIndex(samples, idx, func(g platform.GPUMetricRow) float64 { return g.MemClockMHz })
+ if temp == nil && power == nil && coreClock == nil && memClock == nil {
+ return nil, false, nil
+ }
+ labels := sampleTimeLabels(samples)
+ svg, err := drawGPUOverviewChartSVG(
+ fmt.Sprintf("GPU %d Overview", idx),
+ labels,
+ []gpuOverviewSeries{
+ {Name: "Temp C", Values: coalesceDataset(temp, len(samples)), Color: "#f05a5a", AxisTitle: "Temp C"},
+ {Name: "Power W", Values: coalesceDataset(power, len(samples)), Color: "#ffb357", AxisTitle: "Power W"},
+ {Name: "Core Clock MHz", Values: coalesceDataset(coreClock, len(samples)), Color: "#73bf69", AxisTitle: "Core MHz"},
+ {Name: "Memory Clock MHz", Values: coalesceDataset(memClock, len(samples)), Color: "#5794f2", AxisTitle: "Memory MHz"},
+ },
+ )
+ if err != nil {
+ return nil, false, err
+ }
+ return svg, true, nil
+}
+
+type gpuOverviewSeries struct {
+ Name string
+ AxisTitle string
+ Color string
+ Values []float64
+}
+
+func drawGPUOverviewChartSVG(title string, labels []string, series []gpuOverviewSeries) ([]byte, error) {
+ if len(series) != 4 {
+ return nil, fmt.Errorf("gpu overview requires 4 series, got %d", len(series))
+ }
+ const (
+ width = 1400
+ height = 420
+ plotLeft = 180
+ plotRight = 1220
+ plotTop = 74
+ plotBottom = 292
+ )
+ const (
+ leftOuterAxis = 72
+ leftInnerAxis = 132
+ rightInnerAxis = 1268
+ rightOuterAxis = 1328
+ )
+ axisX := []int{leftOuterAxis, leftInnerAxis, rightInnerAxis, rightOuterAxis}
+ plotWidth := plotRight - plotLeft
+ plotHeight := plotBottom - plotTop
+
+ pointCount := len(labels)
+ if pointCount == 0 {
+ pointCount = 1
+ labels = []string{""}
+ }
+ for i := range series {
+ if len(series[i].Values) == 0 {
+ series[i].Values = make([]float64, pointCount)
+ }
+ }
+
+ type axisScale struct {
+ Min float64
+ Max float64
+ Ticks []float64
+ }
+ scales := make([]axisScale, len(series))
+ for i := range series {
+ min, max := gpuChartSeriesBounds(series[i].Values)
+ ticks := gpuChartNiceTicks(min, max, 8)
+ scales[i] = axisScale{
+ Min: ticks[0],
+ Max: ticks[len(ticks)-1],
+ Ticks: ticks,
+ }
+ }
+
+ xFor := func(index int) float64 {
+ if pointCount <= 1 {
+ return float64(plotLeft + plotWidth/2)
+ }
+ return float64(plotLeft) + float64(index)*float64(plotWidth)/float64(pointCount-1)
+ }
+ yFor := func(value float64, scale axisScale) float64 {
+ if scale.Max <= scale.Min {
+ return float64(plotTop + plotHeight/2)
+ }
+ return float64(plotBottom) - (value-scale.Min)/(scale.Max-scale.Min)*float64(plotHeight)
+ }
+
+ var b strings.Builder
+ b.WriteString(fmt.Sprintf(`
\n")
+ return []byte(b.String()), nil
+}
+
+func gpuChartSeriesBounds(values []float64) (float64, float64) {
+ if len(values) == 0 {
+ return 0, 1
+ }
+ min, max := values[0], values[0]
+ for _, value := range values[1:] {
+ if value < min {
+ min = value
+ }
+ if value > max {
+ max = value
+ }
+ }
+ if min == max {
+ if max == 0 {
+ return 0, 1
+ }
+ pad := math.Abs(max) * 0.1
+ if pad == 0 {
+ pad = 1
+ }
+ min -= pad
+ max += pad
+ }
+ if min > 0 {
+ pad := (max - min) * 0.2
+ if pad == 0 {
+ pad = max * 0.1
+ }
+ min -= pad
+ if min < 0 {
+ min = 0
+ }
+ max += pad
+ }
+ return min, max
+}
+
+func gpuChartNiceTicks(min, max float64, target int) []float64 {
+ if min == max {
+ max = min + 1
+ }
+ span := max - min
+ step := math.Pow(10, math.Floor(math.Log10(span/float64(target))))
+ for _, factor := range []float64{1, 2, 5, 10} {
+ if span/(factor*step) <= float64(target)*1.5 {
+ step = factor * step
+ break
+ }
+ }
+ low := math.Floor(min/step) * step
+ high := math.Ceil(max/step) * step
+ var ticks []float64
+ for value := low; value <= high+step*0.001; value += step {
+ ticks = append(ticks, math.Round(value*1e9)/1e9)
+ }
+ return ticks
+}
+
+func gpuChartFormatTick(value float64) string {
+ if value == math.Trunc(value) {
+ return strconv.Itoa(int(value))
+ }
+ return strconv.FormatFloat(value, 'f', 1, 64)
+}
+
+func gpuChartLabelIndices(total, target int) []int {
+ if total <= 0 {
+ return nil
+ }
+ if total == 1 {
+ return []int{0}
+ }
+ step := total / target
+ if step < 1 {
+ step = 1
+ }
+ var indices []int
+ for i := 0; i < total; i += step {
+ indices = append(indices, i)
+ }
+ if indices[len(indices)-1] != total-1 {
+ indices = append(indices, total-1)
+ }
+ return indices
+}
+
// renderChartSVG renders a line chart SVG with a fixed Y-axis range.
func renderChartSVG(title string, datasets [][]float64, names []string, labels []string, yMin, yMax *float64) ([]byte, error) {
n := len(labels)
diff --git a/audit/internal/webui/server_test.go b/audit/internal/webui/server_test.go
index 64ede77..c67954f 100644
--- a/audit/internal/webui/server_test.go
+++ b/audit/internal/webui/server_test.go
@@ -136,6 +136,53 @@ func TestChartDataFromSamplesKeepsStableGPUSeriesOrder(t *testing.T) {
}
}
+func TestChartDataFromSamplesIncludesGPUClockCharts(t *testing.T) {
+ samples := []platform.LiveMetricSample{
+ {
+ Timestamp: time.Now().Add(-2 * time.Minute),
+ GPUs: []platform.GPUMetricRow{
+ {GPUIndex: 0, ClockMHz: 1400, MemClockMHz: 2600},
+ {GPUIndex: 3, ClockMHz: 1500, MemClockMHz: 2800},
+ },
+ },
+ {
+ Timestamp: time.Now().Add(-1 * time.Minute),
+ GPUs: []platform.GPUMetricRow{
+ {GPUIndex: 0, ClockMHz: 1410, MemClockMHz: 2610},
+ {GPUIndex: 3, ClockMHz: 1510, MemClockMHz: 2810},
+ },
+ },
+ }
+
+ datasets, names, _, title, _, _, ok := chartDataFromSamples("gpu-all-clock", samples)
+ if !ok {
+ t.Fatal("gpu-all-clock returned ok=false")
+ }
+ if title != "GPU Core Clock" {
+ t.Fatalf("title=%q", title)
+ }
+ if len(names) != 2 || names[0] != "GPU 0" || names[1] != "GPU 3" {
+ t.Fatalf("names=%v", names)
+ }
+ if got := datasets[1][1]; got != 1510 {
+ t.Fatalf("GPU 3 core clock=%v want 1510", got)
+ }
+
+ datasets, names, _, title, _, _, ok = chartDataFromSamples("gpu-all-memclock", samples)
+ if !ok {
+ t.Fatal("gpu-all-memclock returned ok=false")
+ }
+ if title != "GPU Memory Clock" {
+ t.Fatalf("title=%q", title)
+ }
+ if len(names) != 2 || names[0] != "GPU 0" || names[1] != "GPU 3" {
+ t.Fatalf("names=%v", names)
+ }
+ if got := datasets[0][0]; got != 2600 {
+ t.Fatalf("GPU 0 memory clock=%v want 2600", got)
+ }
+}
+
func TestNormalizePowerSeriesHoldsLastPositive(t *testing.T) {
got := normalizePowerSeries([]float64{0, 480, 0, 0, 510, 0})
want := []float64{0, 480, 480, 480, 510, 510}
@@ -157,6 +204,21 @@ func TestRenderMetricsUsesBufferedChartRefresh(t *testing.T) {
if !strings.Contains(body, "el.dataset.loading === '1'") {
t.Fatalf("metrics page should avoid overlapping chart reloads: %s", body)
}
+ if !strings.Contains(body, `id="gpu-metrics-section" style="display:none`) {
+ t.Fatalf("metrics page should keep gpu charts in a hidden dedicated section until GPUs are detected: %s", body)
+ }
+ if !strings.Contains(body, `id="gpu-chart-toggle"`) {
+ t.Fatalf("metrics page should render GPU chart mode toggle: %s", body)
+ }
+ if !strings.Contains(body, `/api/metrics/chart/gpu-all-clock.svg`) {
+ t.Fatalf("metrics page should include GPU core clock chart: %s", body)
+ }
+ if !strings.Contains(body, `/api/metrics/chart/gpu-all-memclock.svg`) {
+ t.Fatalf("metrics page should include GPU memory clock chart: %s", body)
+ }
+ if !strings.Contains(body, `renderGPUOverviewCards(indices)`) {
+ t.Fatalf("metrics page should build per-GPU chart cards dynamically: %s", body)
+ }
}
func TestChartLegendVisible(t *testing.T) {
+ 
+ 
+ 
+ 
+