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.pyindex 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 5diff --git a/strata_control/doctor.py b/strata_control/doctor.pyindex 610b505d4..0bd6bff7e 100644--- a/strata_control/doctor.py+++ b/strata_control/doctor.py@@ -6,6 +6,7 @@ import csvimport ioimport jsonimport os+import platformimport reimport shutilimport 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 memoryif 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) <= 128and 1 <= len(driver) <= 64and 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.pyindex 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 enUMA_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_GB10if 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.pyindex 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.pyindex 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