Tuner: GPU governor Performance mode + safe multi-point voltage curve

apps/tuner/skillfish-tuner(+helper) 26.06.5:
- New "Governor mode: Balanced / Performance" toggle in the GPU section.
  Performance lowers the cyan-skillfish-governor load-target (0.08-0.20) + uses a
  snappier ramp so the GPU holds its top safe-point under any gaming load (still
  idles to 350 MHz). Default stays Balanced. Wukong benchmark 1080p: 100 -> 111
  FPS avg (+11%), 92 -> 102 FPS 5%-low.
- Fix BC-250 GPU hard-freeze on clock transitions: write a SMOOTH multi-point
  voltage curve (350/700, 1500/900, 2000/1000, 2200/1000) instead of a 2-point
  line; cap GPU max at the validated-stable 2200 MHz @ 1000 mV (2230 @ 1000 mV is
  undervolted and can hang the box); reload the governor gently (stop -> settle
  -> start). Helper safe-point parsing is comment-robust + de-duplicated.

system/etc/cyan-skillfish-governor/config.toml: new safe default (multi-point,
max 2200). docs/OPTIMIZATIONS.md + CHANGELOG: corrected the 2000=2230 claim with
the new GPU-bound benchmark data and documented the voltage-curve root cause.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: MTSistemi

CHANGELOG.md

@@ -9,6 +9,7 @@ All notable changes to SkillFishOS. Dates are ISO-8601.
   - **Discover-style app pages**: a hero (96 px icon, title, developer, summary, star rating, Install / Remove / Open) over a metadata strip (source · version · size · licence · sandbox + website link), a full-width **screenshot carousel** with arrows and dots, then description, "What's new", permissions and ODRS reviews.
   - **Sidebar sub-categories** that expand/collapse under each top category (with a disclosure caret and an "All" entry), matching Discover; clicking the open category collapses it again.
 - **In-distro app catalogue (MetaInfo)**: each SkillFishOS app now ships its own `/usr/share/metainfo/*.metainfo.xml` plus local screenshots, so the Hub (and any AppStream client) shows full app pages for **Tuner, AI, Monitor, Kernel Manager and Hub** themselves — bundled into `skillfish-tuner` 26.06.4, `skillfish-ai-panel` 26.06.4, `skillfish-monitor` 26.06.4, `skillfish-kernel-manager` 26.06.1 and `skillfish-hub` 26.06.7.
+- **GPU governor "Performance" mode** in the **Tuner** (`skillfish-tuner` 26.06.5): a *Balanced / Performance* toggle in the GPU section. Performance lowers the `cyan-skillfish-governor` load-target so the GPU **holds its top safe-point under any gaming load** (still idling to 350 MHz on the desktop). Measured on the Black Myth: Wukong benchmark (1080p): **100 → 111 FPS average (+11%)**, 92 → 102 FPS on the 5% slowest frames. Default stays Balanced.
 
 ### Changed
 - **Kernel Switch → Kernel Manager** (`skillfish-kernel-manager`, replaces `skillfish-kernel-switch`): besides choosing the boot kernel (default / boot-once), it now lists every installed kernel with flavour, size and running/default badges, and can **completely uninstall** a kernel (`apt purge` image + headers + modules) so kernels don't pile up. Guardrails: never removes the running kernel or the last remaining one, and moves the GRUB default off a kernel before removing it; a confirmation dialog shows the packages removed and the space freed.
@@ -18,6 +19,7 @@ All notable changes to SkillFishOS. Dates are ISO-8601.
 - Hub: three async view-clobber races fixed with a per-view token — a slow **search**, **updates check** or **snap-category** fetch can no longer overwrite the view after the user has navigated elsewhere (e.g. searching right after opening a category now shows the search results, not the category).
 - Hub: starting a search now clears any selected category/sub-category highlight (Discover behaviour), and duplicate Flatpak remotes (system + user) are de-duplicated in Sources.
 - Cleared all CodeQL code-scanning alerts (file-not-closed, empty-except, unused-import, a duplicate `closeEvent`, and two overly-permissive `chmod`s) across the native apps.
+- **GPU hard-freeze on clock transitions** (BC-250): the default governor voltage curve used a 2-point line topping out at **2230 MHz @ 1000 mV**, which is *undervolted* — abrupt clock transitions there could hard-hang the whole machine. The Tuner now writes a **smooth multi-point curve** (`350/700, 1500/900, 2000/1000, 2200/1000`), caps the GPU max at the validated-stable **2200 MHz @ 1000 mV**, and reloads the governor gently (stop → settle → start) to avoid the abrupt SMU jump.
 
 ## [26.06 "Aetherium"] — 2026-06-07
 

apps/tuner/skillfish-tuner

@@ -7,7 +7,7 @@ from PyQt6.QtCore import Qt, QThread, pyqtSignal, QTimer
 from PyQt6.QtGui import QIcon, QPainter, QColor, QPen, QBrush, QLinearGradient, QPainterPath, QFont
 from PyQt6.QtWidgets import (QApplication, QMainWindow, QWidget, QVBoxLayout, QHBoxLayout,
                              QLabel, QGroupBox, QSlider, QPushButton, QToolButton, QCheckBox,
-                             QComboBox, QScrollArea, QMessageBox, QFrame, QGridLayout)
+                             QComboBox, QScrollArea, QMessageBox, QFrame, QGridLayout, QButtonGroup)
 
 HELPER  = "/usr/local/bin/skillfish-tuner-helper"
 PRESETS = "/usr/share/skillfish/tuner-presets.json"
@@ -40,11 +40,14 @@ HELP = {
    L("Soglia termica oltre la quale l'SMU limita la frequenza.\n\nConsigliato 85 °C. Oltre, il sistema riduce automaticamente il clock per proteggere l'hardware.",
      "Thermal threshold above which the SMU throttles frequency.\n\nRecommended 85 °C. Above it, the system automatically lowers the clock to protect the hardware.")),
  "gpu_freq": (L("Frequenza massima GPU", "Max GPU frequency"),
-   L("Clock massimo della GPU (governor SMU).\n\n• 1500 = risparmio\n• 2000 = bilanciato\n• 2230 = massimo supportato\n\nLa GPU sale a questa frequenza solo sotto carico, poi torna a 350 MHz a riposo.",
-     "Maximum GPU clock (SMU governor).\n\n• 1500 = power saving\n• 2000 = balanced\n• 2230 = maximum supported\n\nThe GPU reaches this frequency only under load, then returns to 350 MHz at idle.")),
+   L("Clock massimo della GPU (governor SMU).\n\n• 1500 = risparmio\n• 2000 = bilanciato (sicuro su tutte le schede)\n• 2200 = massimo stabile a 1000 mV su raffreddamento stock\n\nLa GPU sale a questa frequenza solo sotto carico, poi torna a 350 MHz a riposo. Oltre i 2200 MHz a 1000 mV il BC-250 può bloccarsi: serve più voltaggio e la lotteria del silicio.",
+     "Maximum GPU clock (SMU governor).\n\n• 1500 = power saving\n• 2000 = balanced (safe on every board)\n• 2200 = max stable at 1000 mV on stock cooling\n\nThe GPU reaches this frequency only under load, then returns to 350 MHz at idle. Above 2200 MHz at 1000 mV the BC-250 can hard-freeze: it needs more voltage and depends on the silicon lottery.")),
  "gpu_volt": (L("Voltaggio massimo GPU", "Max GPU voltage"),
    L("Voltaggio associato alla frequenza massima GPU (mV).\n\nPiù alto = più stabile ad alte frequenze ma più caldo. Range 700-1129 mV.",
      "Voltage tied to the max GPU frequency (mV).\n\nHigher = more stable at high frequency but hotter. Range 700-1129 mV.")),
+ "gov_mode": (L("Modalità governor GPU", "GPU governor mode"),
+   L("Come il governor sceglie il clock GPU sotto carico:\n\n• Bilanciato: alza il clock solo quanto serve — più fresco e silenzioso (default).\n• Performance: tiene la GPU al clock massimo sotto qualsiasi carico di gioco (massimi FPS nei giochi GPU-bound, più calore e consumo). A riposo torna comunque a 350 MHz.\n\nNel benchmark di Black Myth: Wukong, Performance dà circa +12% di FPS medi e +13% sui frame più lenti, senza scendere a compromessi sulla stabilità (usa la via SMU sicura del governor).",
+     "How the governor picks the GPU clock under load:\n\n• Balanced: raises the clock only as much as needed — cooler and quieter (default).\n• Performance: holds the GPU at max clock under any gaming load (best FPS in GPU-bound games, more heat and power). It still returns to 350 MHz at idle.\n\nIn the Black Myth: Wukong benchmark, Performance gives about +12% average FPS and +13% on the slowest frames, with no stability trade-off (it uses the governor's safe SMU path).")),
  "fan": (L("Ventola", "Fan"),
    L("Controllo manuale: imposti tu la velocità in %.\nAutomatico: la curva del chip gestisce la velocità in base alla temperatura.\n\nUsa «Test» per sentire la ventola alla velocità scelta per qualche secondo.",
      "Manual control: you set the speed in %.\nAutomatic: the chip's curve manages the speed based on temperature.\n\nUse «Test» to hear the fan at the chosen speed for a few seconds.")),
@@ -411,10 +414,24 @@ class TunerWindow(QMainWindow):
     # ---------- GPU ----------
     def _gpu(self):
         g, v = self._section("GPU"); gp = self.cfg.get("gpu", {})
-        self.gf = Stepper(350, 2230, gp.get("max_mhz", 2230), "MHz")
+        self.gf = Stepper(350, 2200, min(gp.get("max_mhz", 2200), 2200), "MHz")
         self.gv = Stepper(700, 1129, gp.get("max_mv", 1000), "mV")
         v.addWidget(self._row(L("Frequenza massima", "Max frequency"), self.gf, "gpu_freq"))
         v.addWidget(self._row(L("Voltaggio massimo", "Max voltage"), self.gv, "gpu_volt"))
+        # governor mode: Balanced (default) / Performance
+        self.gov_bal  = QPushButton(L("Bilanciato", "Balanced"))
+        self.gov_perf = QPushButton(L("Performance", "Performance"))
+        _gmg = QButtonGroup(self); _gmg.setExclusive(True)
+        for _b in (self.gov_bal, self.gov_perf):
+            _b.setCheckable(True); _b.setCursor(Qt.CursorShape.PointingHandCursor); _gmg.addButton(_b)
+        (self.gov_perf if gp.get("gov_mode") == "performance" else self.gov_bal).setChecked(True)
+        self.gov_bal.clicked.connect(lambda: (self.d.cmd(cmd="gov-mode", mode="balanced"),
+            self.toast(L("Governor: Bilanciato", "Governor: Balanced"))))
+        self.gov_perf.clicked.connect(lambda: (self.d.cmd(cmd="gov-mode", mode="performance"),
+            self.toast(L("Governor: Performance — 2230 MHz sotto carico", "Governor: Performance — 2230 MHz under load"))))
+        _gmw = QWidget(); _gmh = QHBoxLayout(_gmw); _gmh.setContentsMargins(0, 0, 0, 0); _gmh.setSpacing(6)
+        _gmh.addWidget(self.gov_bal); _gmh.addWidget(self.gov_perf)
+        v.addWidget(self._row(L("Modalità governor", "Governor mode"), _gmw, "gov_mode"))
         vals = lambda: (self.gf.value(), self.gv.value())
         v.addWidget(self._btns(
             (L("Test (benchmark)", "Test (benchmark)"), lambda: self._test_gpu(*vals()), False),

apps/tuner/skillfish-tuner-helper

@@ -71,6 +71,7 @@ def get():
             gpu["min_mhz"],gpu["min_mv"]=int(pts[0][0]),int(pts[0][1])
             gpu["max_mhz"],gpu["max_mv"]=int(pts[-1][0]),int(pts[-1][1])
     except Exception: pass  # best-effort: governor conf may be missing -> keep defaults
+    gpu["gov_mode"]=current_gov_mode()
     out["gpu"]=gpu
     vram={"uma_mb":0}
     if os.path.exists(MEMCFG):
@@ -105,12 +106,74 @@ def apply_cpu(mhz,scale,tmp):
 def persist_cpu():
     sh("python3 %s/bc250_apply.py --install %s"%(OC_DIR,OC_CONF)); sh("systemctl enable bc250-smu-oc.service")
 
+def _gpu_curve(minmhz,minmv,maxmhz,maxmv):
+    # Build a SMOOTH multi-point voltage curve (gentle clock/voltage transitions).
+    # The BC-250 SMU can hard-hang on abrupt jumps, so insert validated mid-points
+    # (1500/900, 2000/1000) between idle and the requested max instead of a 2-point line.
+    pts=[(int(minmhz),int(minmv))]
+    for f,v in ((1500,900),(2000,1000)):
+        if minmhz < f < maxmhz: pts.append((f,v))
+    pts.append((int(maxmhz),int(maxmv)))
+    # de-dup by frequency, keep ascending
+    seen=set(); out=[]
+    for f,v in pts:
+        if f in seen: continue
+        seen.add(f); out.append((f,v))
+    return out
+
 def apply_gpu(minmhz,minmv,maxmhz,maxmv):
     txt=_rd(GOV_CONF)
-    txt=re.sub(r'(\[\[safe-points\]\]\s*\nfrequency\s*=\s*\d+\s*\nvoltage\s*=\s*\d+\s*\n?)+','',txt)
-    txt=txt.rstrip()+"\n[[safe-points]]\nfrequency = %d\nvoltage = %d\n[[safe-points]]\nfrequency = %d\nvoltage = %d\n"%(minmhz,minmv,maxmhz,maxmv)
+    txt=re.sub(r'(\[\[safe-points\]\]\s*\nfrequency[^\n]*\nvoltage[^\n]*\n?)+','',txt)
+    txt=txt.rstrip()+"\n"
+    for f,v in _gpu_curve(minmhz,minmv,maxmhz,maxmv):
+        txt+="[[safe-points]]\nfrequency = %d\nvoltage = %d\n"%(f,v)
     _wr(GOV_CONF,txt)
-    return sh("systemctl restart cyan-skillfish-governor").returncode==0
+    # gentle reload (stop, settle, start) — avoids SMU hard-hang on abrupt transition
+    sh("systemctl stop cyan-skillfish-governor"); sh("sleep 2")
+    return sh("systemctl start cyan-skillfish-governor").returncode==0
+
+# ---------- GPU governor mode (balanced / performance) ----------
+# Balanced = upstream load-target (cooler, only clocks up as needed).
+# Performance = low load-target band + snappier ramp -> holds the top safe-point
+# under any real gaming load (best FPS in GPU-bound titles); still idles to 350.
+GOV_BAL  = {"sample":2000,"adjust":20000,"normal":1,"burst":200,"bsamples":48,"fadj":100,"upper":"0.95","lower":"0.7"}
+GOV_PERF = {"sample":1000,"adjust":10000,"normal":6,"burst":250,"bsamples":16,"fadj":50, "upper":"0.20","lower":"0.08"}
+
+def _gov_safepoints():
+    try:
+        pts=re.findall(r'frequency\s*=\s*(\d+)[^\n]*\n\s*voltage\s*=\s*(\d+)', _rd(GOV_CONF))
+        if len(pts)>=2:
+            d={}
+            for f,v in pts: d[int(f)]=int(v)   # de-dup by frequency
+            return sorted(d.items())           # ascending
+    except Exception: pass  # best-effort: keep safe defaults
+    return [(350,700),(1500,900),(2000,1000),(2200,1000)]
+
+def current_gov_mode():
+    try:
+        m=re.search(r'\[load-target\][^\[]*?upper\s*=\s*([0-9.]+)', _rd(GOV_CONF), re.S)
+        if m and float(m.group(1))<=0.5: return "performance"
+    except Exception: pass  # best-effort
+    return "balanced"
+
+def gov_mode(mode):
+    p = GOV_PERF if mode=="performance" else GOV_BAL
+    sp = _gov_safepoints()  # preserve the user's max-freq/voltage safe-points
+    txt = ("# SkillFishOS Tuner - cyan-skillfish-governor (mode: %s). Managed via the Tuner.\n"
+           "[timing.intervals]\nsample = %d\nadjust = %d\nfinetune = 1000000000\n\n"
+           "[timing.ramp-rates]\nnormal = %d\nburst = %d\n\n"
+           "[timing]\nburst-samples = %d\n\n"
+           "[frequency-thresholds]\nadjust = %d\nfinetune = 10\n\n"
+           "[load-target]\nupper = %s\nlower = %s\n"
+          ) % (mode, p["sample"], p["adjust"], p["normal"], p["burst"], p["bsamples"], p["fadj"], p["upper"], p["lower"])
+    for f,v in sp:
+        txt += "\n[[safe-points]]\nfrequency = %d\nvoltage = %d\n" % (f,v)
+    _wr(GOV_CONF, txt)
+    # Gentle reload: the BC-250 SMU can hard-hang on an abrupt clock transition,
+    # so stop the governor, let the GPU settle to idle, then start with the new config.
+    sh("systemctl stop cyan-skillfish-governor")
+    sh("sleep 2")
+    return sh("systemctl start cyan-skillfish-governor").returncode==0
 
 def fan_set(mode,pct):
     nd=nct_dir()
@@ -295,6 +358,7 @@ def handle(req):
     if c=="apply-cpu": return {"ok":apply_cpu(req["mhz"],req["scale"],req["temp"])}
     if c=="persist-cpu": apply_cpu(req["mhz"],req["scale"],req["temp"]); persist_cpu(); return {"ok":True}
     if c=="apply-gpu": return {"ok":apply_gpu(req["minmhz"],req["minmv"],req["maxmhz"],req["maxmv"])}
+    if c=="gov-mode": return {"ok":gov_mode(req["mode"]),"mode":current_gov_mode()}
     if c=="apply-fan":
         ok,rpm=fan_set(req["mode"],req.get("pct",50)); return {"ok":ok,"rpm":rpm}
     if c=="set-vram": return {"ok":set_vram(req["mb"]),"reboot":True}

docs/OPTIMIZATIONS.md

@@ -24,10 +24,16 @@ Recipe and patches: [`kernel-build/`](../kernel-build/). Build instructions: [BU
 
 ## 2. GPU clock control — the governor
 
-⚠️ The standard amdgpu sysfs (`power_dpm_force_performance_level`) **does not control the BC‑250** — only the SMU does. SkillFishOS uses the [`cyan-skillfish-governor`](https://github.com/Magnap/cyan-skillfish-governor) (Rust), installed as a systemd service with safe‑points in `/etc/cyan-skillfish-governor/config.toml`:
+⚠️ The standard amdgpu sysfs (`power_dpm_force_performance_level`) **does not control the BC‑250** — only the SMU does, through the OD voltage curve. SkillFishOS uses the [`cyan-skillfish-governor`](https://github.com/Magnap/cyan-skillfish-governor) (Rust), installed as a systemd service with safe‑points in `/etc/cyan-skillfish-governor/config.toml`.
 
-- Idle **350 MHz**, ramp to a **2000 MHz** safe‑point under load.
-- **Why 2000 and not 2230?** In real games (benchmarked with *Black Myth: Wukong*), 2000 and 2230 MHz produce the **same FPS** while 2000 runs cooler with better frame‑time minimums — the GPU clock is **not** the bottleneck (the engine is CPU/draw‑call bound). 2230 is reserved for pure compute (vkpeak/LLM), where it does help.
+It is **load‑based**: it settles on the *lowest* frequency that keeps GPU utilisation inside the `[load-target]` band, idling to **350 MHz** when the GPU is unused. Two profiles, switchable from the **SkillFishOS Tuner** (GPU → *Governor mode*):
+
+- **Balanced** (default, band `0.70–0.95`): raises the clock only as much as the workload needs — cooler and quieter.
+- **Performance** (band `0.08–0.20` + snappier ramp): holds the **top safe‑point under any gaming load**, for the best FPS in GPU‑bound titles. Still idles to 350 MHz on the desktop.
+
+**Measured (Black Myth: Wukong Benchmark Tool, 1080p):** Balanced ≈ **100 FPS** avg / 92 FPS 5%‑low; Performance ≈ **111 FPS** avg / 102 FPS 5%‑low — **+11%**. (An earlier note claimed 2000 ≈ 2230 MHz gave identical FPS; that held for *gameplay*, which is more CPU/draw‑call bound. The benchmark **flythrough** is heavier and *is* GPU‑bound, so holding a high clock clearly helps there.)
+
+⚠️ **The voltage curve must be a smooth multi‑point ladder — `350/700, 1500/900, 2000/1000, 2200/1000`.** On the BC‑250, **1000 mV is the practical stable ceiling at ~2150–2200 MHz**; **2230 MHz @ 1000 mV is undervolted**, and an abrupt clock transition there can **hard‑freeze the whole machine** (reproduced: a 2‑point `350/700 → 2230/1000` curve hung the box on the load→idle transition, with nothing in the logs). The Tuner therefore caps the max at **2200 MHz** and inserts the mid‑points so transitions are gentle; governor reloads stop → settle → start to avoid the abrupt SMU jump. 2230 needs 1000–1060 mV and the silicon lottery.
 
 Memory bandwidth was *measured* (clpeak/OpenCL) at **~350–367 GB/s** — healthy, not a bottleneck. The `Memory Clock 450 MHz` the driver reports is a reporting convention, not a 1/4 clock. Memory clock is **not** adjustable on the BC‑250.
 

system/etc/cyan-skillfish-governor/config.toml

@@ -1,12 +1,27 @@
+# SkillFishOS default cyan-skillfish-governor config (Balanced).
+# Switch to Performance from the SkillFishOS Tuner (GPU section -> Governor mode):
+# Performance lowers the load-target so the GPU holds its top safe-point under any
+# gaming load (best FPS in GPU-bound titles), while still idling to 350 MHz.
+#
+# The voltage curve is a SMOOTH multi-point ladder. Do NOT use a 2-point line or a
+# 2230 MHz / 1000 mV top point: on the BC-250 (Cyan Skillfish) 1000 mV is the
+# practical stable ceiling at ~2150-2200 MHz; 2230 @ 1000 mV is undervolted and an
+# abrupt clock transition there can hard-freeze the machine. 2200 @ 1000 mV is the
+# validated safe maximum on stock cooling.
+
+# us
 [timing.intervals]
 sample = 2000
 adjust = 20_000
 finetune = 1_000_000_000
+# MHz/ms
 [timing.ramp-rates]
 normal = 1
 burst = 200
+# number of samples
 [timing]
 burst-samples = 48
+# MHz
 [frequency-thresholds]
 adjust = 100
 finetune = 10
@@ -17,5 +32,11 @@ lower = 0.7
 frequency = 350
 voltage = 700
 [[safe-points]]
+frequency = 1500
+voltage = 900
+[[safe-points]]
 frequency = 2000
 voltage = 1000
+[[safe-points]]
+frequency = 2200
+voltage = 1000