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++
Two GTX 1080s are a working PC: an 8 GB card starts Off only beside a bigger card, and a PC whose only NVIDIA cards are Pascal uses them on the CUDA 12 engine (#3655)
Niko12210351ecb11d02
diff --git a/apps/host/src/lib/gpu-roles.ts b/apps/host/src/lib/gpu-roles.tsindex 374e017c3..d1a4a1cd9 100644--- a/apps/host/src/lib/gpu-roles.ts+++ b/apps/host/src/lib/gpu-roles.ts@@ -89,17 +89,20 @@ export function pickMain(cs: RoleCard[]): { main: RoleCard | null; why: MainWhyexport type OffWhy = 'cannot_run' | 'igpu' | 'small' | 'helper';export interface Recommendation { roles: Roles; main: number | null; why: MainWhy; reasons: Record<number, MainWhy | OffWhy> }-/** The best card is Main; every other card starts as Helper, EXCEPT a card with 8 GB or less, built-in graphics beside a real card, and a card the engine cannot run: those start Off. */+/** The best card is Main; every other card starts as Helper, EXCEPT a card with 8 GB or less when a bigger card is there (or it has under 4 GB), built-in graphics beside a real card, and a card the engine cannot run: those start Off. */export function recommend(cards: RoleCard[] | null | undefined, vendor?: string | null): Recommendation {const cs = rows(cards, vendor);const { main, why } = pickMain(cs);const roles: Roles = {}, reasons: Recommendation['reasons'] = {};+ // An 8 GB card is a poor Helper beside a bigger card, but a perfectly good one when 8 GB is all there is: two GTX 1080s are a working+ // 16 GB pool (#3655). A card with 8 GB or less starts Off only when a bigger usable card is there, or when it is too small to help.+ const hasBigger = cs.some(c => canRun(c) && !shares(c) && rnd(mem(c)) > OFF_AT_OR_BELOW_GB);for (const c of cs) {const i = c.index;if (main && c === main) { roles[i] = 'main'; reasons[i] = why; }else if (!canRun(c)) { roles[i] = 'off'; reasons[i] = 'cannot_run'; }else if (shares(c) && main) { roles[i] = 'off'; reasons[i] = 'igpu'; }- else if (rnd(mem(c)) <= OFF_AT_OR_BELOW_GB) { roles[i] = 'off'; reasons[i] = 'small'; }+ else if (rnd(mem(c)) <= OFF_AT_OR_BELOW_GB && (hasBigger || mem(c) < MIN_CARD_GB)) { roles[i] = 'off'; reasons[i] = 'small'; }else { roles[i] = 'helper'; reasons[i] = 'helper'; }}return { roles, main: main ? main.index : null, why, reasons };diff --git a/apps/host/tests/native-gpu-roles.test.mjs b/apps/host/tests/native-gpu-roles.test.mjsindex 569b4e953..bed5e5588 100644--- a/apps/host/tests/native-gpu-roles.test.mjs+++ b/apps/host/tests/native-gpu-roles.test.mjs@@ -74,3 +74,22 @@ test('roles that make no sense are refused with a plain line', async () => {assert.match(nope.error, /detected graphics cards/);} finally { await f.cleanup(); }});++test('"Tune this model" keeps a two-card role map exactly as the person set it, in the file and in the engine it starts (#3655)', async () => {+ const f = nativeFixture();+ try {+ await f.control.refresh(true);+ const path = join(f.repo, 'strata-iq2_xs.json');+ const config = JSON.parse(readFileSync(path, 'utf8'));+ Object.assign(config, { gpu: [0, 1], gpu_order: 'as_given', gpu_roles: { 0: 'helper', 1: 'main' }, gpu_cards: { 0: 'GTX 1080', 1: 'GTX 1080' } });+ writeFileSync(path, JSON.stringify(config));+ await f.control.refresh(true);+ const tuned = await finishJob(f.control, f.control.operation('tune', { model: 'iq2_xs', profile: 'performance', calibrate: false }).id);+ assert.equal(tuned.state, 'done', tuned.error);+ const after = JSON.parse(readFileSync(path, 'utf8'));+ for (const key of ['gpu', 'gpu_order', 'gpu_roles', 'gpu_cards']) assert.deepEqual(after[key], config[key], `${key} in the settings file is untouched by Tune`);+ const started = written(f, tuned);+ assert.deepEqual(started.gpu, [0, 1], 'and the engine Tune loads runs on both cards');+ assert.deepEqual(started.gpu_roles, { 0: 'helper', 1: 'main' });+ } finally { await f.cleanup(); }+});diff --git a/docs/MULTI_GPU.md b/docs/MULTI_GPU.mdindex 5ebae7fe7..123654286 100644--- a/docs/MULTI_GPU.md+++ b/docs/MULTI_GPU.md@@ -57,7 +57,7 @@ the picture reader. (Older versions of this page said "the first is the main one**Recommended roles** (the same rule in the app, `strata launch` and setup; `strata_control/gpu_roles.py`): the faster cardis Main (speed is multiprocessors x max clock, the engine's own measure; cards within 5% are the same card, and the one withmore memory wins, then the lower number; two identical cards: the highest number is Main, so the engine order stays 0, 1 as it always was; a card with clearly more memory beats a faster one that is at least half as fast).-Every other card starts as Helper, except a card with **8 GB or less** (Off), built-in graphics beside a card with memory of+Every other card starts as Helper, except a card with **8 GB or less** when a bigger card is there (Off; with only 8 GB cards, say two GTX 1080, the second one is a Helper), built-in graphics beside a card with memory ofits own (Off) and a card the engine cannot run (Off). Every role is one click (the app), one key (`strata launch`: M, H, O;R goes back to the recommendation) or one line (below).@@ -89,7 +89,7 @@ as Main = the last card, Helper = the first, the rest Off. The recommendation itrecommended again; a card you add after choosing roles starts Off. Docker: `GPU_ROLES=1=main,0=helper` is passed as `--gpu-roles`.**One rule for which cards count** (`strata_control/gpu_fit.py` keeps the memory arithmetic): not an integrated chip beside-a real card, at least 4 GB of graphics memory to be listed, 8 GB or less starts Off. The arithmetic is the app's `fitOn`;+a real card, at least 4 GB of graphics memory to be listed, 8 GB or less starts Off beside a bigger card. The arithmetic is the app's `fitOn`;each extra card of a split costs an estimated 2 GB of its own buffers.**Choosing the cards without roles** (at setup or at any start):diff --git a/setup.py b/setup.pyindex bf800d3c3..bd058e488 100644--- a/setup.py+++ b/setup.py@@ -1663,7 +1663,7 @@ def choose_roles(a, found) -> list:roles = dict(gpu_roles.recommend(cards)["roles"])say()say(" Strata recommends a role for each graphics card. Main does the last steps of every answer; a Helper holds part of the model;")- say(" Off leaves the card alone (a card with 8 GB or less starts Off). Details: docs/MULTI_GPU.md.")+ say(" Off leaves the card alone (a card with 8 GB or less starts Off beside a bigger card). Details: docs/MULTI_GPU.md.")by = {c["index"]: c for c in cards}for i in sorted(roles):say(f" GPU {i + 1} {gpu_roles.short_name(by[i]):<22} {by[i]['vram_gb']:>4.0f} GB {roles[i].capitalize()}")diff --git a/strata_control/gpu_roles.py b/strata_control/gpu_roles.pyindex 33df9fe43..47438ddd0 100644--- a/strata_control/gpu_roles.py+++ b/strata_control/gpu_roles.py@@ -107,12 +107,15 @@ def pick_main(cs: list[dict]) -> tuple[dict | None, str]:def recommend(cards: list[dict], vendor: str | None = None) -> dict[str, Any]:"""The recommended roles: {"roles": {index: role}, "main": index|None, "why": code, "reasons": {index: code}}.- The best card is Main, every other card starts as Helper, EXCEPT a card with 8 GB or less, an integrated chip beside a card with memory of+ The best card is Main, every other card starts as Helper, EXCEPT a card with 8 GB or less when a bigger card is there (or it has under 4 GB), an integrated chip beside a card with memory ofits own, and a card the engine cannot run: those start Off."""cs = rows(cards, vendor)main, why = pick_main(cs)roles: dict[int, str] = {}reasons: dict[int, str] = {}+ # An 8 GB card is a poor Helper beside a bigger card, but a perfectly good one when 8 GB is all there is: two GTX 1080s are a working+ # 16 GB pool (#3655). A card with 8 GB or less starts Off only when a bigger usable card is there, or when it is too small to help.+ has_bigger = any(_can_run(c) and not _shares(c) and round(_mem(c)) > OFF_AT_OR_BELOW_GB for c in cs)for c in cs:i = _idx(c)if main is not None and c is main:@@ -121,7 +124,7 @@ def recommend(cards: list[dict], vendor: str | None = None) -> dict[str, Any]:roles[i], reasons[i] = "off", "cannot_run"elif _shares(c) and main is not None:roles[i], reasons[i] = "off", "igpu"- elif round(_mem(c)) <= OFF_AT_OR_BELOW_GB:+ elif round(_mem(c)) <= OFF_AT_OR_BELOW_GB and (has_bigger or _mem(c) < gpu_fit.MIN_CARD_GB):roles[i], reasons[i] = "off", "small"else:roles[i], reasons[i] = "helper", "helper"diff --git a/tests/data/gpu_roles_vectors.json b/tests/data/gpu_roles_vectors.jsonindex 45c2eff12..23555b418 100644--- a/tests/data/gpu_roles_vectors.json+++ b/tests/data/gpu_roles_vectors.json@@ -9,6 +9,8 @@"igpu_only": [{"index": 0, "name": "AMD Radeon 780M", "vram_gb": 0, "integrated": true, "speed": 12}],"bigger_slower": [{"index": 0, "name": "NVIDIA GeForce RTX 3090", "vram_gb": 24, "speed": 90}, {"index": 1, "name": "NVIDIA GeForce RTX 4070", "vram_gb": 12, "speed": 100}],"small_second": [{"index": 0, "name": "NVIDIA GeForce RTX 4070 Ti", "vram_gb": 12, "speed": 100}, {"index": 1, "name": "NVIDIA GeForce RTX 3070", "vram_gb": 8, "speed": 70}],+ "two_8gb": [{"index": 0, "name": "NVIDIA GeForce GTX 1080", "vram_gb": 8, "speed": 50}, {"index": 1, "name": "NVIDIA GeForce GTX 1080", "vram_gb": 8, "speed": 50}],+ "tiny_second": [{"index": 0, "name": "NVIDIA GeForce GTX 1080", "vram_gb": 8, "speed": 50}, {"index": 1, "name": "NVIDIA GeForce GT 1030", "vram_gb": 2, "speed": 10}],"cannot": [{"index": 0, "name": "NVIDIA GeForce GTX 1060", "vram_gb": 6, "usable": false, "problem": "too old"}, {"index": 1, "name": "NVIDIA GeForce RTX 4070 Ti", "vram_gb": 12, "speed": 100}],"nospeed": [{"index": 0, "name": "NVIDIA GeForce RTX 3060", "vram_gb": 12}, {"index": 1, "name": "NVIDIA GeForce RTX 3090", "vram_gb": 24}]},@@ -21,6 +23,8 @@{"hw": "igpu_only", "roles": {"0": "main"}, "main": 0, "why": "only"},{"hw": "bigger_slower", "roles": {"0": "main", "1": "helper"}, "main": 0, "why": "memory"},{"hw": "small_second", "roles": {"0": "main", "1": "off"}, "main": 0, "why": "faster"},+ {"hw": "two_8gb", "roles": {"0": "helper", "1": "main"}, "main": 1, "why": "same"},+ {"hw": "tiny_second", "roles": {"0": "main", "1": "off"}, "main": 0, "why": "only"},{"hw": "cannot", "roles": {"0": "off", "1": "main"}, "main": 1, "why": "only"},{"hw": "nospeed", "roles": {"0": "helper", "1": "main"}, "main": 1, "why": "memory"}],diff --git a/tests/terminal/test_make_guard.py b/tests/terminal/test_make_guard.pyindex 0337f7464..cfa0e7e8f 100644--- a/tests/terminal/test_make_guard.py+++ b/tests/terminal/test_make_guard.py@@ -147,6 +147,28 @@ class Decision(unittest.TestCase):self.assertIn("another make", str(caught.exception))+class Pascal(unittest.TestCase):+ """#3655: a GTX 1080 (sm_61) is a working machine on the CUDA 12 engine; the CUDA 13 build has no code for it and is never chosen."""++ FEED = [package("cuda", "cuda13", ("sm_75", "sm_86", "sm_89", "sm_120")),+ feedmod._engine_package({"version": "0.1.47", "platform": WIN, "backend": "cuda", "variant": "cuda12", "min_driver": {"nvidia": "525.60"},+ "archs": ["sm_60", "sm_61", "sm_70", "sm_75", "sm_80", "sm_86", "sm_89"], "min_runtime": None, "build_id": "b-12",+ "format": "zip", "url": "e-12.zip", "size": 10, "sha256": "a" * 64, "manifest_sha256": "b" * 64,+ "installed_bytes": 20, "notes": ""})]++ def hardware(self, archs):+ return {"platform": WIN, "backend": "cuda", "runtime": None, "nvidia_driver": "581.15", "cuda_archs": archs, "gfx": [], "gpu_names": []}++ def test_two_gtx_1080_get_the_cuda_12_engine(self):+ best, reasons = feedmod.select_engine(self.FEED, self.hardware(["sm_61", "sm_61"]))+ self.assertEqual(best.variant, "cuda12")+ self.assertTrue(any("cuda13" in r or "sm_75" in r for r in reasons), "the CUDA 13 build is refused for the card")++ def test_a_newer_card_still_gets_the_newest_build(self):+ best, _ = feedmod.select_engine(self.FEED, self.hardware(["sm_86"]))+ self.assertEqual(best.variant, "cuda13")++class Host(unittest.TestCase):def test_the_app_shows_the_sentence_not_the_no_engine_for_this_card_text(self):text = (Path(__file__).resolve().parents[2] / "apps" / "host" / "server" / "updates.mjs").read_text(encoding="utf-8")diff --git a/tools/strata_mcp.py b/tools/strata_mcp.pyindex defaed0aa..1b63a0f47 100644--- a/tools/strata_mcp.py+++ b/tools/strata_mcp.py@@ -922,6 +922,16 @@ class Strata:amd = []if not WIN and not amd and shutil.which("rocm-smi"):amd = rocm_smi_gpus()+ # A PC whose only NVIDIA cards are Pascal / Volta (two GTX 1080s) and that has no AMD card Strata can use: setup runs them with the+ # CUDA 12 engine (old_gpus_opt_in), so the app must not call it "no supported graphics card" and start both cards Off (#3655).+ # A PC with a newer card keeps recommending that one; naming an old card is still the opt-in.+ try:+ if S and nv and S.old_gpus_opt_in(nv, (), None, any(g.get("usable") for g in amd)):+ for g in nv:+ if S.sm60_card(g["arch"]) and g.get("problem") and "older than the RTX 20" in str(g["problem"]):+ g["problem"], g["usable"], g["engine_variant"] = None, True, "cuda12"+ except Exception: # noqa: BLE001 - the hardware page never breaks over this+ passif any(g.get("usable") for g in nv):for g in amd: # a Ryzen's integrated graphics beside an NVIDIA card: the engine runs on the NVIDIA cardif g.get("uma") and g.get("usable"):diff --git a/tools/test_strata_mcp.py b/tools/test_strata_mcp.pyindex 7716051ca..7b2292a7c 100644--- a/tools/test_strata_mcp.py+++ b/tools/test_strata_mcp.py@@ -817,6 +817,42 @@ class MixedGraphics(unittest.TestCase):with mock.patch.object(M.sys, "platform", "linux"), mock.patch.object(M, "WIN", False), mock.patch.object(S, "gpus", lambda: []), mock.patch.object(S, "amd_gpus", lambda: [dict(g) for g in igpu]), mock.patch.object(S, "amd_problem", lambda g: None):self.assertTrue(s._hardware()["gpus"][0]["usable"])+ def test_two_gtx_1080_are_a_working_pc_on_the_cuda_12_engine(self):+ """#3655: Pascal cards were flagged 'not supported' and both started Off, so the app said no card was usable. When Pascal is all the PC has+ (and no AMD card), setup runs them with the CUDA 12 engine, and the hardware report now says so; a newer card keeps the old behaviour."""+ s = M.Strata(HERE.parent)+ S = s.setup_module()+ pascal = [{"index": 0, "name": "NVIDIA GeForce GTX 1080", "vram_gb": 8.0, "arch": "61", "driver": "581.15"},+ {"index": 1, "name": "NVIDIA GeForce GTX 1080", "vram_gb": 8.0, "arch": "61", "driver": "581.15"}]+ igpu = [{"index": 0, "name": "AMD Radeon(TM) Graphics", "vram_gb": 0.5, "arch": "gfx90c", "uma": True}]+ patches = (mock.patch.object(M.sys, "platform", "linux"), mock.patch.object(M, "WIN", False),+ mock.patch.object(S, "amd_gpus", lambda: [dict(g) for g in igpu]), mock.patch.object(S, "amd_problem", lambda g: "integrated graphics"),+ mock.patch.dict(M.os.environ, {"STRATA_EXPERIMENTAL_SM60": ""}), mock.patch.object(S, "OLD_GPUS", None))+ with mock.patch.object(S, "gpus", lambda: [dict(g) for g in pascal]):+ for p in patches:+ p.start()+ try:+ hw = s._hardware()+ finally:+ for p in reversed(patches):+ p.stop()+ nv = [g for g in hw["gpus"] if g["vendor"] == "nvidia"]+ self.assertEqual([(g["usable"], g["problem"], g.get("engine_variant")) for g in nv], [(True, None, "cuda12")] * 2)+ # a newer card in the PC: Pascal stays an opt-in, the ready-made engine is recommended+ mixed = [{"index": 0, "name": "NVIDIA GeForce GTX 1080", "vram_gb": 8.0, "arch": "61", "driver": "581.15"},+ {"index": 1, "name": "NVIDIA GeForce RTX 3060", "vram_gb": 12.0, "arch": "86", "driver": "581.15"}]+ with mock.patch.object(S, "gpus", lambda: [dict(g) for g in mixed]):+ for p in patches:+ p.start()+ try:+ hw = s._hardware()+ finally:+ for p in reversed(patches):+ p.stop()+ by = {g["name"]: g for g in hw["gpus"] if g["vendor"] == "nvidia"}+ self.assertFalse(by["NVIDIA GeForce GTX 1080"]["usable"])+ self.assertTrue(by["NVIDIA GeForce RTX 3060"]["usable"])+def test_an_amd_card_the_installed_engine_has_no_code_for_is_not_usable(self):"""#3203: the engine package lists its GPU code; a card outside it is flagged unusable with the plain reason, so no list offers it."""status = {"usable": True, "engine": {"backend": "hip", "archs": ["gfx1200", "gfx1201"]}}