Skip to content

Qwen3.8-Flash-Next on any consumer hardware: one-click install for Windows / Linux. Strata inference engine, OpenAI/Anthropic API on localhost, optional image input.

C++

The Terminal on a GB10: its GPU is found, listed and planned as one unified-memory pool

Niko1221e6fd9146168d
diff --git a/strata_cli/cli.py b/strata_cli/cli.py
index 019284408..c267c5d55 100644
--- a/strata_cli/cli.py
+++ b/strata_cli/cli.py
@@ -1040,7 +1040,7 @@ def _doctor(a: argparse.Namespace) -> int:
if live_probe is not None:
print(f"Live GPU probe: {live_probe['status']}")
for card in live_probe["cards"]:
- print(f" GPU {card['index']}: {card['name']} | {card['memory_mib']} MiB | "
+ print(f" GPU {card['index']}: {card['name']} | {str(card['memory_mib']) + ' MiB' if card['memory_mib'] is not None else 'unified memory'} | "
f"driver {card['driver_version']} | {card['uuid']}")
return 0 if report["ok"] else 5
diff --git a/strata_control/doctor.py b/strata_control/doctor.py
index 610b505d4..0bd6bff7e 100644
--- a/strata_control/doctor.py
+++ b/strata_control/doctor.py
@@ -6,6 +6,7 @@ import csv
import io
import json
import os
+import platform
import re
import shutil
import subprocess
@@ -99,15 +100,16 @@ def _nvidia_cards() -> tuple[list[dict] | None, str | None]:
if len(row) != 5 or len(cards) >= 64:
raise ValueError("invalid field count")
index_raw, name, uuid, memory_raw, driver = [part.strip() for part in row]
+ unified = memory_raw == "[N/A]" and platform.machine().lower() in ("aarch64", "arm64") # a DGX Spark's GB10: no separate graphics memory
if not (re.fullmatch(r"[0-9]{1,4}", index_raw)
- and re.fullmatch(r"[0-9]{1,9}", memory_raw)
- and 0 <= int(index_raw) <= 1023 and int(memory_raw) > 0
+ and (unified or re.fullmatch(r"[0-9]{1,9}", memory_raw))
+ and 0 <= int(index_raw) <= 1023 and (unified or int(memory_raw) > 0)
and 1 <= len(name) <= 128 and 1 <= len(uuid) <= 128
and 1 <= len(driver) <= 64
and all(part.isprintable() for part in (name, uuid, driver))):
raise ValueError("invalid card fields")
cards.append({"index": int(index_raw), "name": name, "uuid": uuid,
- "memory_mib": int(memory_raw), "driver_version": driver})
+ "memory_mib": None if unified else int(memory_raw), "driver_version": driver})
except (csv.Error, ValueError):
return None, "nvidia-smi returned an unrecognized card list"
if not cards or len({card["index"] for card in cards}) != len(cards):
diff --git a/strata_control/dsv41_fit.py b/strata_control/dsv41_fit.py
index ef7f354d8..809110d12 100644
--- a/strata_control/dsv41_fit.py
+++ b/strata_control/dsv41_fit.py
@@ -83,6 +83,9 @@ UMA_RESERVE_GB = 12.0 # kept for Windows, the desktop and the en
UMA_MEASURED = ("a Ryzen AI Max+ 395 (Radeon 8060S, 128 GB unified: a 64 GB BIOS carve-out plus 64 GB seen by Windows) on Windows: answers "
"14-16 tokens a second on code in the default Faster mode (5 experts) and 10-11 on chat; a 4,000-token prompt 77-81 tokens a "
"second, 8,000 tokens 108-111")
+# A DGX Spark (GB10, Linux, 128 GB unified, no BIOS carve-out): the same one-pool plan. Measured with the 2.00 bpw set, six experts per word.
+UMA_MEASURED_GB10 = ("an NVIDIA DGX Spark (GB10, 128 GB unified) on Linux with six experts per word: about 17 tokens a second on a first short "
+ "chat and 20-23 once warm; a 1,700-token prompt read at 213-237 tokens a second, a 500-token one at 76")
def variant(model: str | None) -> dict | None:
@@ -305,10 +308,17 @@ def _plan_uma(key: str, model: str, card: dict, ram_gb: float | None, disk_free_
lines.append("The n-gram table stays on the SSD and is read a few rows for each word: use an NVMe drive for the model files (a slow "
"disk makes every word slower). The same table serves every IST-DAS set, so installing another one downloads it once.")
name = card.get("name") or "the built-in Radeon"
- lines.append(f"{name} shares this PC's memory: the RAM and the GPU's BIOS carve-out are one pool of {total:.0f} GB. About "
- f"{resident:.0f} GB of the {float(v['experts_gb']):.0f} GB of experts stay in it beside {ISTA_DENSE_GB:.1f} GB of "
- f"dense weights and {UMA_RESERVE_GB:.0f} GB kept for Windows; the other {streamed:.0f} GB are read from the SSD while it answers.")
- lines.append(f"Measured on this kind of PC: {UMA_MEASURED}.")
+ if float(card.get("dedicated_gb") or 0.0) > 0 or "GB10" not in str(card.get("name") or ""):
+ lines.append(f"{name} shares this PC's memory: the RAM and the GPU's BIOS carve-out are one pool of {total:.0f} GB. About "
+ f"{resident:.0f} GB of the {float(v['experts_gb']):.0f} GB of experts stay in it beside {ISTA_DENSE_GB:.1f} GB of "
+ f"dense weights and {UMA_RESERVE_GB:.0f} GB kept for Windows; the other {streamed:.0f} GB are read from the SSD while it answers.")
+ lines.append(f"Measured on this kind of PC: {UMA_MEASURED}.")
+ else: # a DGX Spark's GB10: one memory for the CPU and the GPU, nothing set aside in a BIOS, Linux
+ lines.append(f"{name} shares this computer's memory: the CPU and the GPU are one pool of {total:.0f} GB. About "
+ f"{resident:.0f} GB of the {float(v['experts_gb']):.0f} GB of experts stay in it beside {ISTA_DENSE_GB:.1f} GB of "
+ f"dense weights and {UMA_RESERVE_GB:.0f} GB kept for the system; the other {streamed:.0f} GB are read from the SSD while it answers.")
+ lines.append(f"Measured on this kind of computer: {UMA_MEASURED_GB10}.")
+ out["measured"] = UMA_MEASURED_GB10
if streamed > 0.5:
lines.append("Keep the model files on the NVMe drive and the machine otherwise idle while it answers: every word reads experts from it.")
if streamed <= 0.5:
diff --git a/tests/terminal/test_linux_aarch64.py b/tests/terminal/test_linux_aarch64.py
index 7ace729d9..beb69f319 100644
--- a/tests/terminal/test_linux_aarch64.py
+++ b/tests/terminal/test_linux_aarch64.py
@@ -109,5 +109,68 @@ class ReleaseTools(unittest.TestCase):
self.assertIn(b"-DSTRATA_PORTABLE=ON", raw)
+class GB10DeepSeekPlan(unittest.TestCase):
+ def test_the_plan_for_a_gb10_speaks_of_one_pool_and_the_system_not_windows_and_a_bios(self):
+ from strata_control import dsv41_fit
+ card = {"index": 0, "name": "NVIDIA GB10", "vram_gb": 115.6, "shared_gb": 115.6, "dedicated_gb": 0.0, "uma": True}
+ plan = dsv41_fit.plan([card], 121.6, 400, 8192, model="IST-DAS-2.00bpw")
+ text = " ".join(plan["lines"])
+ self.assertNotIn("Windows", text)
+ self.assertNotIn("BIOS", text)
+ self.assertIn("DGX Spark", plan["measured"])
+ self.assertIn("one pool of 122 GB", text)
+ self.assertGreater(plan["experts_in_vram"], 11000) # the engine placed 12,163 of 15,744 on the Spark itself
+
+ def test_the_windows_strix_halo_plan_is_unchanged(self):
+ from strata_control import dsv41_fit
+ card = {"index": 0, "name": "AMD Radeon(TM) 8060S Graphics", "vram_gb": 96.0, "shared_gb": 32.0, "dedicated_gb": 64.0, "uma": True}
+ plan = dsv41_fit.plan([card], 64.0, 400, 8192, model="IST-DAS-2.00bpw")
+ text = " ".join(plan["lines"])
+ self.assertIn("BIOS carve-out", text)
+ self.assertIn("kept for Windows", text)
+ self.assertEqual(plan["measured"], dsv41_fit.UMA_MEASURED)
+
+
+class GB10Probes(unittest.TestCase):
+ """nvidia-smi gives a GB10's memory.total as [N/A]: the probes the Terminal reads must neither drop the card nor invent a size."""
+ LINE = "0, NVIDIA GB10, GPU-0a1b2c3d-0000-1111-2222-333344445555, [N/A], 580.173.02\n"
+
+ def cards(self, machine):
+ from strata_control import doctor
+ done = mock.Mock(returncode=0, stdout=self.LINE)
+ with mock.patch.object(doctor.shutil, "which", return_value="/usr/bin/nvidia-smi"), \
+ mock.patch.object(doctor.subprocess, "run", return_value=done), \
+ mock.patch.object(doctor.platform, "machine", return_value=machine):
+ return doctor._nvidia_cards()
+
+ def test_doctor_lists_a_gb10_with_no_memory_figure(self):
+ cards, why = self.cards("aarch64")
+ self.assertIsNone(why)
+ self.assertEqual(cards[0]["name"], "NVIDIA GB10")
+ self.assertIsNone(cards[0]["memory_mib"])
+
+ def test_doctor_on_x86_still_refuses_a_card_without_a_memory_figure(self):
+ cards, why = self.cards("x86_64")
+ self.assertIsNone(cards)
+ self.assertIn("unrecognized", why)
+
+ def test_the_launch_probe_counts_a_gb10_as_unified_memory(self):
+ sys.path.insert(0, str(ROOT / "tools"))
+ import strata_mcp
+ smi = "0, NVIDIA GB10, [N/A], 12.1, 580.173.02\n"
+ with mock.patch.object(strata_mcp, "run_quiet", return_value=smi), \
+ mock.patch.object(strata_mcp, "own_ram_gb", return_value=121.6), \
+ mock.patch.object(strata_mcp.platform, "machine", return_value="aarch64"):
+ found = strata_mcp.own_nvidia_gpus()
+ self.assertEqual(len(found), 1)
+ self.assertTrue(found[0]["uma"])
+ self.assertEqual(found[0]["arch"], "121")
+ self.assertAlmostEqual(found[0]["vram_gb"], 115.6, places=1)
+ self.assertEqual(found[0]["dedicated_gb"], 0.0)
+ with mock.patch.object(strata_mcp, "run_quiet", return_value=smi), \
+ mock.patch.object(strata_mcp.platform, "machine", return_value="x86_64"):
+ self.assertEqual(strata_mcp.own_nvidia_gpus(), [])
+
+
if __name__ == "__main__":
unittest.main()
diff --git a/tools/strata_mcp.py b/tools/strata_mcp.py
index c6e282468..3340cd530 100644
--- a/tools/strata_mcp.py
+++ b/tools/strata_mcp.py
@@ -1771,7 +1771,18 @@ def own_nvidia_gpus() -> list:
for line in s.strip().splitlines():
try:
idx, name, mem, cc, drv = [x.strip() for x in line.split(",")]
- found.append({"index": int(idx), "name": name, "vram_gb": float(mem) / 1024.0,
+ try:
+ mem_gb = float(mem) / 1024.0
+ except ValueError:
+ if platform.machine().lower() not in ("aarch64", "arm64"):
+ raise # as before on x86: a card whose memory nvidia-smi does not report is not listed
+ # a DGX Spark (GB10): one memory for the CPU and the GPU, memory.total is [N/A]; counted as setup.py's gpus() counts it
+ # (the RAM less the OS's 6 GB, none of it room beside the RAM)
+ shared = max(0.0, own_ram_gb() - 6)
+ found.append({"index": int(idx), "name": name, "vram_gb": shared, "arch": cc.replace(".", ""), "driver": drv,
+ "uma": True, "dedicated_gb": 0.0, "shared_gb": shared})
+ continue
+ found.append({"index": int(idx), "name": name, "vram_gb": mem_gb,
"arch": cc.replace(".", ""), "driver": drv})
except ValueError:
continue