tuner: switch CPU cores on and off live, like the GPU's CUs

Adds a CPU-core grid to both the native Tuner and the web one: each box is a
physical core with its two SMT threads, click to toggle, then Apply. Presets for
all/6/4 cores and a global SMT switch. No reboot, and nothing persists — a fresh
boot brings every core back.

Core 0 is drawn locked because this kernel is built without
BOOTPARAM_HOTPLUG_CPU0, so cpu0 genuinely cannot go offline. Every other core
can, including the six that were always there — not just the two we unlocked.
The helper refuses a request that would leave no core running and never writes
to cpu0, so a bad call can't strand the machine.

Why it's useful: switching cores off frees thermal and power headroom for the
remaining ones, which matters on a board where the ceiling turned out to be the
heatsink rather than the silicon.

Verified on hardware end to end: clicking two cores and pressing Apply took the
box from 16 to 12 threads (online 0-11), the All preset brought it back to 16,
zero MCEs.

Author: MTSistemi

apps/dashboard/skillfish-dashboardd

@@ -1440,6 +1440,11 @@ class Handler(BaseHTTPRequestHandler):
             if not self._guard("tuner"):
                 return
             return self._json(200, cpu_coremap())
+        if path == "/api/tuner/cpu-cores":
+            # GET reads the live core map; the POST route below changes it
+            if not self._guard("tuner"):
+                return
+            return self._json(200, tuner_cmd([{"cmd": "cpu-cores"}]))
         if path == "/api/tuner/fan-curve":
             if not self._guard("tuner"):
                 return
@@ -1558,6 +1563,15 @@ class Handler(BaseHTTPRequestHandler):
             if not self._guard("tuner"):
                 return
             return self._json(200, tuner_cmd([{"cmd": "gov-mode", "mode": data.get("mode", "balanced")}]))
+        if path == "/api/tuner/cpu-cores":
+            # live CPU hotplug — same idea as the CU grid, but for the CPU side
+            if not self._guard("tuner"):
+                return
+            if "smt" in data:
+                return self._json(200, tuner_cmd([{"cmd": "cpu-smt", "on": bool(data["smt"])}]))
+            if "cores" in data:
+                return self._json(200, tuner_cmd([{"cmd": "cpu-cores-set", "cores": data["cores"]}]))
+            return self._json(200, tuner_cmd([{"cmd": "cpu-cores"}]))
         if path == "/api/tuner/fan":
             if not self._guard("tuner"):
                 return

apps/dashboard/web/tuner.html

@@ -101,8 +101,18 @@
   <pre class="log" id="cutestlog"></pre>
 </div>
 
-<div class="panel"><h3>🧩 Mappa core CPU</h3>
-  <div class="stub">Layout fisico dei core (per affinità/pinning dei giochi). MHz live per core.</div>
+<div class="panel"><h3>🧩 Core CPU — a caldo, senza riavvio</h3>
+  <div class="brow">
+    <span class="pill" id="cpucount">– core attivi</span>
+    <button class="btn sec" data-cores="99">Tutti</button>
+    <button class="btn sec" data-cores="6">6 core</button>
+    <button class="btn sec" data-cores="4">4 core</button>
+    <label class="pill" style="cursor:pointer"><input type="checkbox" id="smtcb" checked style="vertical-align:-2px"> SMT</label>
+  </div>
+  <div class="cugrid" id="cpugrid" style="grid-template-columns:repeat(8,1fr)"></div>
+  <div class="brow"><button class="btn" id="cpucoresapply">Applica core</button></div>
+  <div class="stub">Ogni riquadro = 1 core fisico con i suoi 2 thread. Il <b>core 0</b> resta sempre acceso: ospita la CPU di avvio, il kernel non può spegnerlo. Spegnere core libera budget termico per far salire la frequenza dei rimanenti. Al riavvio tornano tutti accesi.</div>
+  <div class="stub" style="margin-top:10px">Layout fisico dei core (per affinità/pinning dei giochi). MHz live per core.</div>
   <div id="coremap" style="margin-top:8px"></div>
 </div>
 
@@ -160,6 +170,37 @@
   $("#govbal").classList.toggle("on", m==="balanced"); $("#govperf").classList.toggle("on", m!=="balanced"); }
 function renderFanMode(mode){ $("#fanauto").classList.toggle("on", mode!=="manual"); $("#fanman").classList.toggle("on", mode==="manual"); }
 
+// ---- CPU cores (live hotplug) ----
+let CPU_CORES = [];        // [{core, online, removable, cpus:[...]}]
+let cpuWant = {};          // core -> desired state, applied on "Applica core"
+
+function renderCPUCores(){
+  const g = $("#cpugrid"); if(!g) return;
+  g.innerHTML = "";
+  CPU_CORES.forEach(c=>{
+    const on = cpuWant[c.core];
+    const locked = !c.removable;          // core 0: holds the boot CPU
+    const d = document.createElement('div');
+    d.className = 'wgp'+(on?' on':'')+(locked?' locked':'');
+    d.innerHTML = '<div class="cu"></div><div class="cu"></div>';
+    d.title = locked ? 'core di avvio — sempre acceso' : (on?'acceso':'spento');
+    if(!locked) d.onclick = ()=>{ cpuWant[c.core] = !cpuWant[c.core]; renderCPUCores(); };
+    g.appendChild(d);
+  });
+  const n = CPU_CORES.filter(c=>cpuWant[c.core]).length;
+  const thr = n * ($("#smtcb") && $("#smtcb").checked ? 2 : 1);
+  $("#cpucount").textContent = n+" / "+CPU_CORES.length+" core · "+thr+" thread";
+}
+
+async function loadCPUCores(){
+  const r = await api("/api/tuner/cpu-cores");
+  if(!r || !r.cores) return;
+  CPU_CORES = r.cores;
+  cpuWant = {}; CPU_CORES.forEach(c=> cpuWant[c.core] = c.online);
+  if($("#smtcb")) $("#smtcb").checked = (r.smt || "on") === "on";
+  renderCPUCores();
+}
+
 function renderCU(){
   const g = $("#cugrid"); g.innerHTML = '<div class="cuh"></div>' +
     [0,1,2,3,4].map(i=>'<div class="cuh">WGP'+i+'</div>').join('');
@@ -248,6 +289,20 @@
   else lg("gpulog","Nessun passo stabile."); busy(false); };
 $("#govbal").onclick=async()=>{ await api("/api/tuner/govmode",{mode:"balanced"}); STATE.gpu.gov_mode="balanced"; renderGov(); toast("Governor: bilanciato"); };
 $("#govperf").onclick=async()=>{ await api("/api/tuner/govmode",{mode:"performance"}); STATE.gpu.gov_mode="performance"; renderGov(); toast("Governor: prestazioni"); };
+document.querySelectorAll("[data-cores]").forEach(b=> b.onclick=()=>{
+  const k=+b.dataset.cores;
+  CPU_CORES.forEach(c=> cpuWant[c.core] = (k>=CPU_CORES.length) ? true : (c.core<k || !c.removable));
+  renderCPUCores(); });
+$("#cpucoresapply").onclick=async()=>{ toast("Applico i core…");
+  const cores=CPU_CORES.map(c=>({core:c.core, online:!!cpuWant[c.core]}));
+  const x=await api("/api/tuner/cpu-cores",{cores});
+  if(x && x.ok){ CPU_CORES=x.cores||CPU_CORES; cpuWant={}; CPU_CORES.forEach(c=>cpuWant[c.core]=c.online);
+    renderCPUCores(); toast("Core applicati — "+(x.nproc||"?")+" thread attivi"); }
+  else toast("Errore core: "+((x&&x.err)||"")); };
+$("#smtcb").onchange=async()=>{ const on=$("#smtcb").checked; toast("SMT "+(on?"acceso":"spento")+"…");
+  const x=await api("/api/tuner/cpu-cores",{smt:on});
+  if(x && x.ok){ toast("SMT "+(on?"acceso":"spento")+" — "+(x.nproc||"?")+" thread"); await loadCPUCores(); }
+  else toast("SMT: "+((x&&x.err)||"errore")); };
 document.querySelectorAll("[data-cu]").forEach(b=> b.onclick=()=>{ const m=+b.dataset.cu; CU_ROWS.forEach(([k])=>cuMask[k]=m|cuFloor); renderCU(); });
 $("#cuapply").onclick=async()=>{ toast("Applico CU a caldo…"); const rows=CU_ROWS.map(([k])=>cuMask[k]|cuFloor);
   const x=await api("/api/tuner/cu",{rows}); toast(x.ok?("CU applicate: "+(x.active||cuActive())+" attive"):("Errore CU: "+(x.err||x.error||""))); setTimeout(load,500); };
@@ -317,6 +372,6 @@
 $("#fcon").onclick=()=>{FC.enabled=true;fcRenderMode();fcSave();};
 $("#fcoff").onclick=()=>{FC.enabled=false;fcRenderMode();fcSave();};
 
-load(); loadProfiles(); loadCoremap(); loadFanCurve();
+load(); loadProfiles(); loadCoremap(); loadFanCurve(); loadCPUCores();
 </script>
 </body></html>

apps/tuner/skillfish-tuner

@@ -54,6 +54,9 @@ HELP = {
  "vram": (L("VRAM (memoria grafica)", "VRAM (graphics memory)"),
    L("Quantità di RAM di sistema riservata alla GPU (UMA).\n\n⚠ Scrive nel CMOS del BIOS e richiede un RIAVVIO per applicare. Reversibile azzerando il CMOS (jumper sulla scheda).\n\nNon superare valori che lascino troppo poca RAM al sistema.",
      "Amount of system RAM reserved for the GPU (UMA).\n\n⚠ Writes to the BIOS CMOS and requires a REBOOT to apply. Reversible by clearing the CMOS (jumper on the board).\n\nDon't exceed values that leave too little RAM for the system.")),
+ "cpucores": (L("Core CPU", "CPU cores"),
+   L("Accendi e spegni i core della CPU A CALDO, senza riavvio — come per le CU della GPU.\n\n• Ogni riquadro = 1 core fisico con i suoi 2 thread: VERDE = acceso, ROSSO = spento.\n• CLIC su un core per accenderlo/spegnerlo, poi «Applica».\n• Il core 0 è VERDE FISSO: ospita la CPU di avvio e il kernel non può spegnerlo.\n• «SMT» accende/spegne il multi-threading: da 2 thread per core a 1.\n\nA cosa serve: spegnere core libera budget termico e di consumo per far salire la frequenza dei core rimasti — utile nei giochi che usano pochi thread. Meno core = meno calore, ma meno potenza nei carichi multi-thread.\n\nLa scelta NON è permanente: al riavvio tornano tutti accesi.",
+     "Turn CPU cores on and off LIVE, no reboot — just like the GPU's CUs.\n\n• Each box = 1 physical core with its 2 threads: GREEN = on, RED = off.\n• CLICK a core to toggle it, then «Apply».\n• Core 0 is FIXED GREEN: it holds the boot CPU and the kernel cannot offline it.\n• «SMT» toggles multi-threading: 2 threads per core, or 1.\n\nWhy: switching cores off frees thermal and power budget so the remaining cores can clock higher — handy for games that use few threads. Fewer cores = less heat, but less multi-threaded power.\n\nThe choice is NOT permanent: everything comes back on at reboot.")),
  "cu": (L("Compute Unit (CU)", "Compute Units (CU)"),
    L("Le CU sono i core di calcolo della GPU. Qui le attivi/disattivi A CALDO, senza riavvio.\n\n• Ogni quadratino = 1 CU: VERDE = attiva, ROSSO = spenta.\n• CLIC su una coppia per accenderla/spegnerla manualmente (le coppie si gestiscono a 2 CU per volta = 1 WGP).\n• Oppure usa i PRESET (24 / 32 / 40 CU).\n• Le prime 3 coppie per fila (24 CU) sono il minimo del driver e restano sempre attive.\n• Premi «Applica a caldo» per rendere effettiva la scelta.\n\nPiù CU = più potenza grafica ma anche più calore e consumo.\n\nUsa «Test CU» per verificare che le CU attive siano stabili e senza difetti (lotteria del silicio).",
      "CUs are the GPU's compute cores. Here you enable/disable them LIVE, no reboot.\n\n• Each square = 1 CU: GREEN = active, RED = off.\n• CLICK a pair to toggle it manually (pairs are managed 2 CU at a time = 1 WGP).\n• Or use the PRESETS (24 / 32 / 40 CU).\n• The first 3 pairs per row (24 CU) are the driver minimum and stay always on.\n• Hit «Apply live» to make the choice effective.\n\nMore CU = more graphics power but also more heat and power draw.\n\nUse «Test CU» to verify the active CUs are stable and defect-free (silicon lottery).")),
@@ -148,6 +151,38 @@ class CuWgp(QFrame):
         self.on = not self.on; self._paint(); self.on_toggle(self.on)
 
 
+class CpuCore(QFrame):
+    """One physical CPU core drawn as its two SMT threads, styled like the CU grid.
+
+    Core 0 is locked: it holds cpu0, the boot CPU, which this kernel cannot offline.
+    """
+    def __init__(self, core, on, locked, on_toggle):
+        super().__init__()
+        self.core = core; self.on = on; self.locked = locked; self.on_toggle = on_toggle
+        lay = QVBoxLayout(self); lay.setContentsMargins(1, 1, 1, 1); lay.setSpacing(2)
+        row = QHBoxLayout(); row.setSpacing(2)
+        self.sq = [QFrame(), QFrame()]
+        for s in self.sq:
+            s.setFixedSize(16, 16); row.addWidget(s)
+        rw = QWidget(); rw.setLayout(row); lay.addWidget(rw)
+        cap = QLabel("C%d" % core); cap.setAlignment(Qt.AlignmentFlag.AlignHCenter)
+        cap.setStyleSheet("color:#8f7c52;font-size:9px;"); lay.addWidget(cap)
+        if not self.locked:
+            self.setCursor(Qt.CursorShape.PointingHandCursor)
+        self._paint()
+    def _paint(self):
+        if self.locked:  col, bd = "#3f7a39", "#2c571f"
+        elif self.on:    col, bd = "#5fd24f", "#36862c"
+        else:            col, bd = "#7c2424", "#4d1414"
+        for s in self.sq:
+            s.setStyleSheet("background:%s;border:1px solid %s;border-radius:3px;" % (col, bd))
+        self.setToolTip(L("core di avvio (sempre attivo)", "boot core (always on)") if self.locked
+                        else (L("attivo", "on") if self.on else L("spento", "off")))
+    def mousePressEvent(self, e):
+        if self.locked: return
+        self.on = not self.on; self._paint(); self.on_toggle(self.core, self.on)
+
+
 class Chart(QWidget):
     """A live, custom-painted line chart panel (brass / steampunk look)."""
     def __init__(self, title, unit, series):
@@ -274,6 +309,7 @@ class TunerWindow(QMainWindow):
         self.box.addWidget(self._gpu())
         self.box.addWidget(self._vram())
         self.box.addWidget(self._cu())
+        self.box.addWidget(self._sec_cpu_cores())
         self.box.addWidget(self._fan())
         self.box.addStretch(1)
 
@@ -654,6 +690,74 @@ class TunerWindow(QMainWindow):
         pw = QWidget(); pw.setLayout(pr); v.addWidget(pw)
         return g
 
+    def _sec_cpu_cores(self):
+        g, v = self._section(L("Core CPU — a caldo", "CPU cores — live"))
+        st = self.d.cmd(cmd="cpu-cores") or {}
+        self.cpu_cores = st.get("cores", [])
+        self.cpu_want = {c["core"]: c["online"] for c in self.cpu_cores}
+        grid = QGridLayout(); grid.setHorizontalSpacing(8); grid.setVerticalSpacing(5)
+        self.cpu_cells = {}
+        for i, c in enumerate(self.cpu_cores):
+            cell = CpuCore(c["core"], c["online"], not c.get("removable", True), self._cpu_toggle)
+            self.cpu_cells[c["core"]] = cell
+            grid.addWidget(cell, i // 8, i % 8)
+        gw = QWidget(); gw.setLayout(grid); v.addWidget(gw)
+        self.cpu_count_lbl = QLabel(); self.cpu_count_lbl.setStyleSheet("color:#d8a849;font-size:13px;")
+        v.addWidget(self.cpu_count_lbl); self._cpu_update_count()
+        pr = QHBoxLayout()
+        for lbl, n in ((L("Tutti", "All"), 99), ("6 core", 6), ("4 core", 4)):
+            b = QPushButton(lbl); b.clicked.connect(lambda _=False, k=n: self._cpu_preset(k)); pr.addWidget(b)
+        self.smt_cb = QCheckBox("SMT")
+        self.smt_cb.setChecked((st.get("smt") or "on") == "on")
+        self.smt_cb.setToolTip(L("Multi-threading: 2 thread per core. Spento = 1 thread per core.",
+                                 "Multi-threading: 2 threads per core. Off = 1 thread per core."))
+        self.smt_cb.toggled.connect(self._cpu_smt)
+        if not st.get("smt"): self.smt_cb.setEnabled(False)
+        pr.addWidget(self.smt_cb)
+        pr.addWidget(self._help_btn("cpucores"))
+        pr.addStretch(1)
+        ba = QPushButton(L("Applica", "Apply")); ba.clicked.connect(self._apply_cpu_cores); pr.addWidget(ba)
+        pw = QWidget(); pw.setLayout(pr); v.addWidget(pw)
+        return g
+
+    def _cpu_toggle(self, core, on):
+        self.cpu_want[core] = on; self._cpu_update_count()
+
+    def _cpu_update_count(self):
+        n = sum(1 for v in self.cpu_want.values() if v)
+        thr = n * (2 if getattr(self, "smt_cb", None) is None or self.smt_cb.isChecked() else 1)
+        self.cpu_count_lbl.setText(L("Core attivi: %d / %d  ·  %d thread", "Active cores: %d / %d  ·  %d threads")
+                                   % (n, len(self.cpu_want) or 8, thr))
+
+    def _cpu_preset(self, keep):
+        for c in self.cpu_cores:
+            want = True if keep >= len(self.cpu_cores) else (c["core"] < keep)
+            if not c.get("removable", True): want = True      # core 0 stays
+            self.cpu_want[c["core"]] = want
+            cell = self.cpu_cells.get(c["core"])
+            if cell and not cell.locked:
+                cell.on = want; cell._paint()
+        self._cpu_update_count()
+
+    def _cpu_smt(self, on):
+        res = self.d.cmd(cmd="cpu-smt", on=bool(on)) or {}
+        if res.get("ok"):
+            self.toast(L("SMT %s — %d thread", "SMT %s — %d threads")
+                       % (L("acceso", "on") if on else L("spento", "off"), res.get("nproc", 0)), 4)
+        else:
+            self.toast(L("SMT: %s", "SMT: %s") % res.get("err", "errore"), 6)
+        self._cpu_update_count()
+
+    def _apply_cpu_cores(self):
+        req = [{"core": k, "online": bool(v)} for k, v in self.cpu_want.items()]
+        res = self.d.cmd(cmd="cpu-cores-set", cores=req) or {}
+        if res.get("ok"):
+            self.cpu_cores = res.get("cores", self.cpu_cores)
+            self.toast(L("Core applicati — %d thread attivi", "Cores applied — %d active threads")
+                       % res.get("nproc", 0), 5)
+        else:
+            self.toast(L("Errore core: %s", "Core error: %s") % res.get("err", "apply failed"), 7)
+
     def _cu_toggle(self, rk, wgp, on):
         m = self.cu_rows.get(rk, 7)
         m = (m | (1 << wgp)) if on else (m & ~(1 << wgp))

apps/tuner/skillfish-tuner-helper

@@ -269,6 +269,78 @@ def cu_apply(rows):
     except Exception as e:
         return {"ok":False,"err":str(e)}
 
+def cpu_cores_get():
+    """Live CPU-core map: one entry per physical core with its SMT siblings.
+
+    Every logical CPU can be taken offline except cpu0 — it is the boot CPU and
+    this kernel is built without BOOTPARAM_HOTPLUG_CPU0 — so core 0 can drop its
+    second thread but never disappear entirely.
+    """
+    cores = {}
+    for p in sorted(glob.glob("/sys/devices/system/cpu/cpu[0-9]*")):
+        n = os.path.basename(p)[3:]
+        if not n.isdigit(): continue
+        n = int(n)
+        try:
+            core = int(_rd("%s/topology/core_id" % p).strip())
+        except Exception:
+            continue  # offline CPUs hide their topology; folded in below
+        online = True if not os.path.exists(p + "/online") else _rd(p + "/online").strip() == "1"
+        cores.setdefault(core, {"core": core, "cpus": [], "online": False, "removable": True})
+        cores[core]["cpus"].append({"cpu": n, "online": online,
+                                    "removable": os.path.exists(p + "/online")})
+        if online: cores[core]["online"] = True
+        if not os.path.exists(p + "/online"): cores[core]["removable"] = False
+    # an offline CPU loses topology/core_id, so recover it from the sibling numbering
+    for p in sorted(glob.glob("/sys/devices/system/cpu/cpu[0-9]*")):
+        n = os.path.basename(p)[3:]
+        if not n.isdigit(): continue
+        n = int(n)
+        if any(c["cpu"] == n for e in cores.values() for c in e["cpus"]): continue
+        core = n // 2   # this APU pairs threads as (2k, 2k+1)
+        cores.setdefault(core, {"core": core, "cpus": [], "online": False, "removable": True})
+        cores[core]["cpus"].append({"cpu": n, "online": False, "removable": True})
+    smt = None
+    try: smt = _rd("/sys/devices/system/cpu/smt/control").strip()
+    except Exception: pass
+    out = [cores[k] for k in sorted(cores)]
+    for e in out: e["cpus"].sort(key=lambda c: c["cpu"])
+    return {"ok": True, "cores": out, "nproc": os.cpu_count(), "smt": smt}
+
+
+def cpu_cores_set(states):
+    """states: list of {core, online}. Toggles both SMT siblings of each core.
+
+    Refuses to leave the machine with no cores and never touches cpu0, so a bad
+    request can't strand the box — the worst case is one core left running.
+    """
+    want = {}
+    for s in states or []:
+        try: want[int(s["core"])] = bool(s["online"])
+        except Exception: pass
+    if not want: return {"ok": False, "err": "nessun core specificato"}
+    cur = cpu_cores_get()["cores"]
+    if not any(want.get(e["core"], e["online"]) for e in cur):
+        return {"ok": False, "err": "almeno un core deve restare acceso"}
+    for e in cur:
+        tgt = want.get(e["core"])
+        if tgt is None: continue
+        for c in e["cpus"]:
+            if not c["removable"]: continue          # cpu0
+            _wr("/sys/devices/system/cpu/cpu%d/online" % c["cpu"], "1" if tgt else "0")
+    time.sleep(1)
+    return cpu_cores_get()
+
+
+def cpu_smt_set(on):
+    """Global SMT switch — halves or restores the thread count in one go."""
+    p = "/sys/devices/system/cpu/smt/control"
+    if not os.path.exists(p): return {"ok": False, "err": "SMT non controllabile su questo kernel"}
+    _wr(p, "on" if on else "off")
+    time.sleep(1)
+    return cpu_cores_get()
+
+
 def set_cu(unlock):
     """Abilita/disabilita lo sblocco 40 CU via parametro di boot GRUB. Richiede riavvio."""
     grub="/etc/default/grub"; param="amdgpu.bc250_cc_write_mode=3"
@@ -416,6 +488,9 @@ def handle(req):
     if c=="set-vram": return {"ok":set_vram(req["mb"]),"reboot":True}
     if c=="set-cu": return {"ok":set_cu(req["unlock"]),"reboot":True}
     if c=="cu-apply": return cu_apply(req.get("rows",[]))
+    if c=="cpu-cores": return cpu_cores_get()
+    if c=="cpu-cores-set": return cpu_cores_set(req.get("cores",[]))
+    if c=="cpu-smt": return cpu_smt_set(bool(req.get("on",True)))
     if c=="cu-test": return cu_test()
     if c=="thermal-guard": return {"ok":thermal_guard(req["limit"])}
     if c=="test-cpu": return test_cpu(req["mhz"],req["scale"],req["temp"])