Benchmark runs generate a human-readable TXT report and machine-readable result bundle. Tasks continue in the background — view progress in Tasks.
Benchmark Output
@@ -1754,6 +1777,115 @@ benchmarkLoadGPUs();
`
}
+func renderBenchmarkResultsCard(exportDir string) string {
+ columns, runs := loadBenchmarkHistory(exportDir)
+ if len(runs) == 0 {
+ return `
Benchmark Results
No saved benchmark runs yet.
`
+ }
+
+ var b strings.Builder
+ b.WriteString(`
Benchmark Results
`)
+ b.WriteString(`
Composite score by saved benchmark run and GPU.
`)
+ b.WriteString(`
`)
+ b.WriteString(`
| Test | Time | `)
+ for _, col := range columns {
+ b.WriteString(`` + html.EscapeString(col.label) + ` | `)
+ }
+ b.WriteString(`
|---|
`)
+ for i, run := range runs {
+ b.WriteString(``)
+ b.WriteString(`| #` + strconv.Itoa(i+1) + ` | `)
+ b.WriteString(`` + html.EscapeString(run.displayTime) + ` | `)
+ for _, col := range columns {
+ cell, ok := run.cells[col.key]
+ if !ok || !cell.present {
+ b.WriteString(`- | `)
+ continue
+ }
+ b.WriteString(`` + fmt.Sprintf("%.2f", cell.score) + ` | `)
+ }
+ b.WriteString(`
`)
+ }
+ b.WriteString(`
`)
+ return b.String()
+}
+
+func loadBenchmarkHistory(exportDir string) ([]benchmarkHistoryColumn, []benchmarkHistoryRun) {
+ baseDir := app.DefaultBenchmarkBaseDir
+ if strings.TrimSpace(exportDir) != "" {
+ baseDir = filepath.Join(exportDir, "bee-benchmark")
+ }
+ paths, err := filepath.Glob(filepath.Join(baseDir, "gpu-benchmark-*", "result.json"))
+ if err != nil || len(paths) == 0 {
+ return nil, nil
+ }
+ sort.Strings(paths)
+
+ columnByKey := make(map[string]benchmarkHistoryColumn)
+ runs := make([]benchmarkHistoryRun, 0, len(paths))
+ for _, path := range paths {
+ raw, err := os.ReadFile(path)
+ if err != nil {
+ continue
+ }
+ var result platform.NvidiaBenchmarkResult
+ if err := json.Unmarshal(raw, &result); err != nil {
+ continue
+ }
+ run := benchmarkHistoryRun{
+ generatedAt: result.GeneratedAt,
+ displayTime: result.GeneratedAt.Local().Format("2006-01-02 15:04:05"),
+ cells: make(map[string]benchmarkHistoryCell),
+ }
+ for _, gpu := range result.GPUs {
+ key := benchmarkHistoryColumnKey(gpu.Name, gpu.Index)
+ columnByKey[key] = benchmarkHistoryColumn{
+ key: key,
+ label: benchmarkHistoryColumnLabel(gpu.Name, gpu.Index),
+ name: strings.TrimSpace(gpu.Name),
+ index: gpu.Index,
+ }
+ run.cells[key] = benchmarkHistoryCell{
+ score: gpu.Scores.CompositeScore,
+ present: true,
+ }
+ }
+ runs = append(runs, run)
+ }
+
+ columns := make([]benchmarkHistoryColumn, 0, len(columnByKey))
+ for _, col := range columnByKey {
+ columns = append(columns, col)
+ }
+ sort.Slice(columns, func(i, j int) bool {
+ leftName := strings.ToLower(strings.TrimSpace(columns[i].name))
+ rightName := strings.ToLower(strings.TrimSpace(columns[j].name))
+ if leftName != rightName {
+ return leftName < rightName
+ }
+ if columns[i].index != columns[j].index {
+ return columns[i].index < columns[j].index
+ }
+ return columns[i].key < columns[j].key
+ })
+ sort.Slice(runs, func(i, j int) bool {
+ return runs[i].generatedAt.After(runs[j].generatedAt)
+ })
+ return columns, runs
+}
+
+func benchmarkHistoryColumnKey(name string, index int) string {
+ return strings.TrimSpace(name) + "|" + strconv.Itoa(index)
+}
+
+func benchmarkHistoryColumnLabel(name string, index int) string {
+ name = strings.TrimSpace(name)
+ if name == "" {
+ return fmt.Sprintf("GPU %d", index)
+ }
+ return fmt.Sprintf("%s / GPU %d", name, index)
+}
+
// ── Burn ──────────────────────────────────────────────────────────────────────
func renderBurn() string {
diff --git a/audit/internal/webui/server_test.go b/audit/internal/webui/server_test.go
index 89d9735..2d0c7e0 100644
--- a/audit/internal/webui/server_test.go
+++ b/audit/internal/webui/server_test.go
@@ -1,6 +1,7 @@
package webui
import (
+ "encoding/json"
"net/http"
"net/http/httptest"
"os"
@@ -636,6 +637,66 @@ func TestBenchmarkPageRendersGPUSelectionControls(t *testing.T) {
}
}
+func TestBenchmarkPageRendersSavedResultsTable(t *testing.T) {
+ dir := t.TempDir()
+ exportDir := filepath.Join(dir, "export")
+ runDir := filepath.Join(exportDir, "bee-benchmark", "gpu-benchmark-20260406-120000")
+ if err := os.MkdirAll(runDir, 0755); err != nil {
+ t.Fatal(err)
+ }
+ result := platform.NvidiaBenchmarkResult{
+ GeneratedAt: time.Date(2026, time.April, 6, 12, 0, 0, 0, time.UTC),
+ BenchmarkProfile: "standard",
+ OverallStatus: "OK",
+ GPUs: []platform.BenchmarkGPUResult{
+ {
+ Index: 0,
+ Name: "NVIDIA H100 PCIe",
+ Scores: platform.BenchmarkScorecard{
+ CompositeScore: 1176.25,
+ },
+ },
+ {
+ Index: 1,
+ Name: "NVIDIA H100 PCIe",
+ Scores: platform.BenchmarkScorecard{
+ CompositeScore: 1168.50,
+ },
+ },
+ },
+ }
+ raw, err := json.Marshal(result)
+ if err != nil {
+ t.Fatal(err)
+ }
+ if err := os.WriteFile(filepath.Join(runDir, "result.json"), raw, 0644); err != nil {
+ t.Fatal(err)
+ }
+
+ handler := NewHandler(HandlerOptions{ExportDir: exportDir})
+ rec := httptest.NewRecorder()
+ handler.ServeHTTP(rec, httptest.NewRequest(http.MethodGet, "/benchmark", nil))
+ if rec.Code != http.StatusOK {
+ t.Fatalf("status=%d", rec.Code)
+ }
+ body := rec.Body.String()
+ wantTime := result.GeneratedAt.Local().Format("2006-01-02 15:04:05")
+ for _, needle := range []string{
+ `Benchmark Results`,
+ `Composite score by saved benchmark run and GPU.`,
+ `NVIDIA H100 PCIe / GPU 0`,
+ `NVIDIA H100 PCIe / GPU 1`,
+ `#1`,
+ wantTime,
+ `1176.25`,
+ `1168.50`,
+ } {
+ if !strings.Contains(body, needle) {
+ t.Fatalf("benchmark page missing %q: %s", needle, body)
+ }
+ }
+}
+
func TestValidatePageRendersNvidiaTargetedStressCard(t *testing.T) {
handler := NewHandler(HandlerOptions{})
rec := httptest.NewRecorder()
diff --git a/iso/overlay/usr/local/bin/bee-nvidia-load b/iso/overlay/usr/local/bin/bee-nvidia-load
index 8aeaa14..fea3ecf 100755
--- a/iso/overlay/usr/local/bin/bee-nvidia-load
+++ b/iso/overlay/usr/local/bin/bee-nvidia-load
@@ -209,6 +209,18 @@ fi
ldconfig 2>/dev/null || true
log "ldconfig refreshed"
+# Keep persistence mode enabled across the session so dcgmi / stress tools do
+# not fail with deployment warnings on otherwise healthy GPUs.
+if command -v nvidia-smi >/dev/null 2>&1; then
+ if nvidia-smi -pm 1 >/dev/null 2>&1; then
+ log "enabled NVIDIA persistence mode"
+ else
+ log "WARN: failed to enable NVIDIA persistence mode"
+ fi
+else
+ log "WARN: nvidia-smi not found — cannot enable persistence mode"
+fi
+
# Start DCGM host engine so dcgmi can discover GPUs.
# nv-hostengine must run after the NVIDIA modules and device nodes are ready.
# If it started too early (for example via systemd before bee-nvidia-load), it can