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++
gfx1151 on Windows: the shared-expert fork (STRATA_SH_STREAM) is off by default
Niko1221c77292f09dbe
diff --git a/include/strata/core/arch_defaults.hpp b/include/strata/core/arch_defaults.hppindex 7062f4b22..2025af482 100644--- a/include/strata/core/arch_defaults.hpp+++ b/include/strata/core/arch_defaults.hpp@@ -21,6 +21,10 @@ namespace strata::core {/// "gfx1151:sramecc-:xnack-"): empty for every other architecture. `defaults026` (STRATA_DEFAULTS=026, defaults_026.hpp): the gfx12 table of/// v0.2.6 (the five prompt switches only, without the four 0.2.7 decode switches); the one-argument form asks the environment.std::vector<std::pair<std::string, std::string>> arch_default_env(const char* gcn_arch, bool defaults026);+/// The same with the platform given instead of read from the build (a pure rule, so a test can check both). 0.2.7: on Windows the gfx1151+/// table leaves STRATA_SH_STREAM out (the fork is off, +6.9% decode on a Strix Halo Windows PC, same ids); Linux gfx1151 and every+/// other architecture are unchanged; `defaults026` keeps it in on both. An explicit STRATA_SH_STREAM=1 turns the fork on anywhere.+std::vector<std::pair<std::string, std::string>> arch_default_env(const char* gcn_arch, bool defaults026, bool windows);std::vector<std::pair<std::string, std::string>> arch_default_env(const char* gcn_arch);/// The integrated Radeons (Phoenix / Hawk Point 780M gfx1103, Strix Point 890M / 880M gfx1150, Strix Halo gfx1151) whosediff --git a/src/core/arch_defaults.cpp b/src/core/arch_defaults.cppindex 47b9ba7ac..7f2a89fd9 100644--- a/src/core/arch_defaults.cpp+++ b/src/core/arch_defaults.cpp@@ -15,6 +15,14 @@ std::vector<std::pair<std::string, std::string>> arch_default_env(const char* gc}std::vector<std::pair<std::string, std::string>> arch_default_env(const char* gcn_arch, bool defaults026) {+#if defined(_WIN32)+ return arch_default_env(gcn_arch, defaults026, true);+#else+ return arch_default_env(gcn_arch, defaults026, false);+#endif+}++std::vector<std::pair<std::string, std::string>> arch_default_env(const char* gcn_arch, bool defaults026, bool windows) {std::vector<std::pair<std::string, std::string>> t;if (strata::kernels::gfx_arch_is_gfx12(gcn_arch)) {// gfx1200 / gfx1201 (RDNA4): the PROMPT half of the gfx1151 table (reported exact on an R9700 in #1478, re-checked@@ -71,6 +79,15 @@ std::vector<std::pair<std::string, std::string>> arch_default_env(const char* gc{"STRATA_PLE_BATCH", "1"}, // the verify window's PLE key / value projections at once (S25){"STRATA_SH_STREAM", "1"}, // the shared expert on its own stream: decode +1.8% / +6.7% (UD-Q4_K_XL) (140-m)};+ // 0.2.7: Windows gfx1151 leaves the shared-expert fork off (the HIP default). Interleaved A/B on a Strix Halo Windows PC (Qwen+ // IQ3_S, engine 0.1.51, 9 chat answers each, 4K prompt): decode 43.9 / 43.6 / 43.2 tok/s with it, 48.3 / 46.0 / 46.6 without+ // (+6.9% median), prompts unchanged, the token ids identical either way (docs/STRIX_HALO_WINDOWS.md). Linux gfx1151 keeps the+ // fork on until it is measured there. STRATA_SH_STREAM=1 turns it back on; STRATA_DEFAULTS=026 keeps v0.2.6's table.+ if (windows && !defaults026) {+ for (auto it = t.begin(); it != t.end(); ++it) {+ if (it->first == "STRATA_SH_STREAM") { t.erase(it); break; }+ }+ }return t;}diff --git a/src/core/arch_defaults_test.cpp b/src/core/arch_defaults_test.cppindex db193a7f7..51f70493b 100644--- a/src/core/arch_defaults_test.cpp+++ b/src/core/arch_defaults_test.cpp@@ -48,6 +48,66 @@ int main() {CHECK(kv.first != bits);}}+ // 0.2.7: STRATA_SH_STREAM. Windows gfx1151 leaves the shared-expert fork off (it measured slower there, same ids); Linux gfx1151,+ // the 026 master switch and every other architecture are unchanged. Pure rule: the platform is an argument.+ {+ auto find = [](const std::vector<std::pair<std::string, std::string>>& t, const char* k) -> const std::string* {+ for (const auto& kv : t) if (kv.first == k) return &kv.second;+ return static_cast<const std::string*>(nullptr);+ };+ for (const char* a : {"gfx1151", "gfx1151:sramecc-:xnack-"}) {+ const auto lin = arch_default_env(a, false, false);+ const auto win = arch_default_env(a, false, true);+ const auto lin26 = arch_default_env(a, true, false);+ const auto win26 = arch_default_env(a, true, true);+ const std::string* l = find(lin, "STRATA_SH_STREAM");+ CHECK(l != nullptr && *l == "1"); // Linux gfx1151: unchanged, the fork is on+ CHECK(find(win, "STRATA_SH_STREAM") == nullptr); // Windows gfx1151: not in the table, so the HIP default (off) applies+ CHECK(find(win26, "STRATA_SH_STREAM") != nullptr); // STRATA_DEFAULTS=026: v0.2.6's table on Windows too+ CHECK(find(lin26, "STRATA_SH_STREAM") != nullptr);+ CHECK(win26 == lin26 && win26 == lin); // under 026 and on Linux the whole table is the same+ CHECK(win.size() + 1 == lin.size()); // Windows loses that one entry and nothing else+ for (const auto& kv : win) CHECK(find(lin, kv.first.c_str()) != nullptr && *find(lin, kv.first.c_str()) == kv.second);+ }+ // other architectures: the platform changes nothing+ for (const char* a : {"gfx1100", "gfx1030", "gfx1103", "gfx1150", "gfx1152", "gfx1201", "gfx1200", ""}) {+ CHECK(arch_default_env(a, false, true) == arch_default_env(a, false, false));+ CHECK(arch_default_env(a, true, true) == arch_default_env(a, true, false));+ }+ CHECK(arch_default_env(nullptr, false, true).empty());+ // the build's own platform answers like the explicit form (the one-argument form reads STRATA_DEFAULTS, unset here)+ unset("STRATA_DEFAULTS");+#if defined(_WIN32)+ CHECK(arch_default_env("gfx1151") == arch_default_env("gfx1151", false, true));+ CHECK(find(arch_default_env("gfx1151"), "STRATA_SH_STREAM") == nullptr);+#else+ CHECK(arch_default_env("gfx1151") == arch_default_env("gfx1151", false, false));+ CHECK(find(arch_default_env("gfx1151"), "STRATA_SH_STREAM") != nullptr);+#endif+ // applying the table: an explicit STRATA_SH_STREAM=1 stays 1, an explicit 0 stays 0, and the Windows table does not set it+ unset("STRATA_QFUSE");+ put("STRATA_SH_STREAM", "1");+ apply_arch_defaults("gfx1151");+ CHECK(std::getenv("STRATA_SH_STREAM") != nullptr && std::string(std::getenv("STRATA_SH_STREAM")) == "1");+ put("STRATA_SH_STREAM", "0");+ apply_arch_defaults("gfx1151");+ CHECK(std::string(std::getenv("STRATA_SH_STREAM")) == "0");+ unset("STRATA_SH_STREAM");+ unset("STRATA_QFUSE");+ const auto applied = apply_arch_defaults("gfx1151");+ bool sh_set = false;+ for (const auto& n : applied) sh_set = sh_set || n == "STRATA_SH_STREAM";+#if defined(_WIN32)+ CHECK(!sh_set);+ CHECK(std::getenv("STRATA_SH_STREAM") == nullptr || std::string(std::getenv("STRATA_SH_STREAM")).empty());+#else+ CHECK(sh_set);+ CHECK(std::getenv("STRATA_SH_STREAM") != nullptr && std::string(std::getenv("STRATA_SH_STREAM")) == "1");+#endif+ unset("STRATA_SH_STREAM");+ unset("STRATA_QFUSE");+ unset("STRATA_TSUM");+ }// gfx12: the five prompt switches and four bit-identical decode switches, no bit-changing oneunset("STRATA_GFX12_DEFAULTS");for (const char* a : {"gfx1200", "gfx1201", "gfx1201:sramecc-:xnack-"}) {diff --git a/src/core/verify.cpp b/src/core/verify.cppindex ac3f874a1..cdb20bef1 100644--- a/src/core/verify.cpp+++ b/src/core/verify.cpp@@ -286,7 +286,9 @@ bool batch_self_commits(const int* rows, int S) { return g_batch_self_commit &&// profiler turns the fork off to time the stages, so a profiled run never showed that. #816 reports the same fall on a// gfx1030 (RX 6800, Windows, 42.5 -> 56.4 t/s). STRATA_SH_STREAM overrides either default: `=1` forks, `=0` does not.// Strix Halo (gfx1151, unified memory) is the exception: the fork pays there (+1.8% UD-IQ4_XS, +6.7% UD-Q4_K_XL decode-// at 8K, ids identical), so the gfx1151 arch table sets STRATA_SH_STREAM=1. Read on first use, after that table ran.+// at 8K, ids identical), so the gfx1151 arch table sets STRATA_SH_STREAM=1 on Linux. On Windows gfx1151 the fork is slower (0.2.7,+// Qwen IQ3_S: decode -6.4% with it, ids identical), so there the table leaves it out and this default (off on HIP) applies.+// Read on first use, after that table ran.bool sh_stream_on() {static const bool on = [] {if (const char* v = std::getenv("STRATA_SH_STREAM")) return v[0] != '0';