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++
"""--spec 2 for a run config on exactly two Intel Arc B-series (Battlemage) cards.
On two B-series cards the SYCL engine runs the verify windows of the two cards overlapped (--pipeline-windows 2, on by
default there). Its answers are those of a width-2 draft window whatever --spec says: on 2x Arc Pro B65 the pipelined
answers equal a serial --spec 2 in 100 of 100 agent requests, while a serial --spec 4 differs from them in 3 of 100 (an end
token against a digit at a near-tie; a serial --spec 3 differs from --spec 4 in the same way). So setup and the launcher
write `--spec 2` for such a config: the same answers as the engine gives anyway, about 20% faster than the old
`--spec 4` serial default (chat 73.9 against 60.7 tok/s), and no surprise between a serial and a pipelined start.
Only the generated default changes. Single cards, Arc A-series (Alchemist) cards, three or more cards, a config with no
draft layer, and any config where the person set --spec (in "user_args", or a value other than setup's own 4 in "args") keep
what they have. The card generation is the PCI device id from sysfs, the same id the engine's architecture enum comes from
(strata::intel_gpu_gen in sycl/include/strata/sycl_queue.hpp), never the marketing name.
"""
from __future__ import annotations
import os
from pathlib import Path
from typing import Any
from . import user_args
SETUP_DEFAULT_SPEC = "4" # what setup.py and the launcher write for every model
TWO_CARD_SPEC = "2"
# Battlemage: BMG-G21 (0xE20x: B580, B570, Pro B50) and BMG-G31 (0xE22x: Pro B70, B65, B60), driven by xe. Alchemist (0x56A0..)
# and anything else (an integrated GPU, i915) is not. Same range as sycl_queue.hpp's name-less fallback.
BATTLEMAGE_ID_RANGE = (0xE200, 0xE2FF)
def is_battlemage(driver: str, devid: str) -> bool:
"""True for an Arc B-series card: the xe driver and a PCI device id in the Battlemage range."""
if driver != "xe":
return False
try:
n = int(str(devid).lower().replace("0x", ""), 16)
except ValueError:
return False
return BATTLEMAGE_ID_RANGE[0] <= n <= BATTLEMAGE_ID_RANGE[1]
def sysfs_cards(drm: str | os.PathLike = "/sys/class/drm") -> list[dict]:
"""The Intel discrete cards in sysfs card order (the order setup's `--gpus` indexes and Level Zero follows on the tested
machines): [{"driver": "xe", "devid": "e222"}, ...]. Vendor 0x8086 under xe or i915; an i915 card with an id that is not an
Alchemist one is an integrated GPU and is left out, as in sycl/setup_intel.py."""
out = []
for card in sorted(Path(drm).glob("card[0-9]*")):
if "-" in card.name:
continue
dev = card / "device"
try:
vendor = (dev / "vendor").read_text().strip().lower()
devid = (dev / "device").read_text().strip().lower().replace("0x", "")
driver = os.path.basename(os.path.realpath(dev / "driver")) if (dev / "driver").exists() else ""
except OSError:
continue
if vendor != "0x8086" or driver not in ("xe", "i915"):
continue
if driver == "i915" and not devid.startswith("56"):
continue
out.append({"index": len(out), "driver": driver, "devid": devid})
return out
def exactly_two_battlemage(cards: list[dict]) -> bool:
return len(cards) == 2 and all(is_battlemage(c.get("driver", ""), c.get("devid", "")) for c in cards)
def _spec_group(args: list[str]) -> int:
"""Index of the value after --spec in `args`, or -1."""
for i, a in enumerate(args):
if a == "--spec" and i + 1 < len(args):
return i + 1
return -1
def plan(args: Any, user: Any, cards: list[dict], mtp_off: bool = False) -> tuple[list[str], str]:
"""(new args, note): `args` with --spec 4 turned into --spec 2 when the run is on exactly two Battlemage cards, and ""
when nothing changed. `user` is the config's "user_args"; `cards` the cards the run uses (exactly two to qualify);
`mtp_off` is the config's "mtp": false. `args` is not changed in place."""
out = [str(a) for a in args] if isinstance(args, list) else []
if not exactly_two_battlemage(cards) or mtp_off:
return out, ""
if "--mtp" not in out: # the pipeline needs the draft layer
return out, ""
if any(user_args.flag_of(g) == "--spec" for g in user_args.groups(user)):
return out, "" # the person's own --spec wins
i = _spec_group(out)
if i < 0 or out[i] != SETUP_DEFAULT_SPEC: # absent, or a value somebody chose
return out, ""
out[i] = TWO_CARD_SPEC
return out, ("Two Arc B-series cards: --spec 2 instead of 4. With both cards working on neighbouring windows the engine "
"answers as a 2-token window anyway, and --spec 2 is about 20% faster here. To keep your own value, put "
"\"--spec\" and its number in the config's \"user_args\".")
def apply_for_launch(cfg: dict, sysfs: list[dict] | None = None) -> str:
"""The launcher's run config: the cards in cfg["gpu"] (a list of two numbers after a layer split) looked up in sysfs, then
`apply_to_config`. Nothing happens for a single card, another backend or a card list that sysfs cannot place."""
if cfg.get("backend") != "sycl":
return ""
gpu = cfg.get("gpu")
if not isinstance(gpu, (list, tuple)) or len(gpu) != 2:
return ""
try:
have = sysfs if sysfs is not None else sysfs_cards()
cards = [have[int(i)] for i in gpu if 0 <= int(i) < len(have)]
except (TypeError, ValueError):
return ""
return apply_to_config(cfg, cards) if len(cards) == 2 else ""
def apply_to_config(cfg: dict, cards: list[dict]) -> str:
"""`plan` on a run config (in place): changes cfg["args"], and the copy in cfg["args_written"] so a later setup run does not
take the change for the person's own edit. Returns the note, "" when nothing changed."""
args, note = plan(cfg.get("args"), cfg.get("user_args"), cards, mtp_off=cfg.get("mtp") is False)
if not note:
return ""
cfg["args"] = args
written = cfg.get(user_args.WRITTEN_KEY)
if isinstance(written, list):
w = [str(a) for a in written]
i = _spec_group(w)
if i >= 0 and w[i] == SETUP_DEFAULT_SPEC:
w[i] = TWO_CARD_SPEC
cfg[user_args.WRITTEN_KEY] = w
return note