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++
hip: integrated Radeons (gfx1103/gfx1150/gfx1151, UMA flag) take the matrix-core prompt set by default; STRATA_IGPU_DEFAULTS=0 and each switch =0 turn it off; unit test with mock devices
Niko1221ce968a2fac1f
diff --git a/include/strata/core/arch_defaults.hpp b/include/strata/core/arch_defaults.hppindex cd11a0edd..359557fb0 100644--- a/include/strata/core/arch_defaults.hpp+++ b/include/strata/core/arch_defaults.hpp@@ -20,9 +20,21 @@ namespace strata::core {/// "gfx1151:sramecc-:xnack-"): empty for every other architecture.std::vector<std::pair<std::string, std::string>> arch_default_env(const char* gcn_arch);-/// Sets `arch_default_env(gcn_arch)` in this process's environment where the user has not set the variable, prints one-/// line to stderr when it set anything, and returns the names it set. Call once, before any engine code reads its-/// switches (they are read lazily, at first use).-std::vector<std::string> apply_arch_defaults(const char* gcn_arch);+/// The integrated Radeons (Phoenix / Hawk Point 780M gfx1103, Strix Point 890M / 880M gfx1150, Strix Halo gfx1151) whose+/// matrix-core prompt set is on by default (153-igpu). Pure architecture-name test; the caller adds the UMA test.+bool igpu_prompt_defaults_arch(const char* gcn_arch);++/// The matrix-core prompt set an integrated GPU takes by default: STRATA_HIP_WMMA, STRATA_PF_GEMM, STRATA_PA_FAST,+/// STRATA_SELECT_WMMA, STRATA_HC_UPMIX, all "1". Empty unless `integrated` (hipDeviceProp_t::integrated: the device+/// shares the host's memory) AND the architecture is one of `igpu_prompt_defaults_arch`: a discrete card of the same+/// architecture family (RX 7900 XTX gfx1100, R9700 gfx1201, ...) and every CUDA / SYCL build get nothing. These change+/// bits (KL-gated, notes-153-igpu.md); every switch keeps =0 as its off switch and STRATA_IGPU_DEFAULTS=0 turns the set off.+std::vector<std::pair<std::string, std::string>> igpu_default_env(const char* gcn_arch, bool integrated);++/// Sets `arch_default_env(gcn_arch)` and, when `integrated`, `igpu_default_env(gcn_arch, true)` in this process's+/// environment where the user has not set the variable, prints one line to stderr per table when it set anything, and+/// returns the names it set. `integrated` is true when every visible GPU is an integrated one. Call once, before any+/// engine code reads its switches (they are read lazily, at first use).+std::vector<std::string> apply_arch_defaults(const char* gcn_arch, bool integrated = false);} // namespace strata::corediff --git a/src/core/arch_defaults.cpp b/src/core/arch_defaults.cppindex 4cf36dafe..7cdf4108a 100644--- a/src/core/arch_defaults.cpp+++ b/src/core/arch_defaults.cpp@@ -59,15 +59,41 @@ std::vector<std::pair<std::string, std::string>> arch_default_env(const char* gcreturn t;}-std::vector<std::string> apply_arch_defaults(const char* gcn_arch) {- std::vector<std::string> set;- for (const auto& kv : arch_default_env(gcn_arch)) {- if (std::getenv(kv.first.c_str()) != nullptr) continue; // the user's setting wins, whatever it is+bool igpu_prompt_defaults_arch(const char* gcn_arch) {+ return strata::kernels::gfx_arch_is(gcn_arch, "gfx1103") || strata::kernels::gfx_arch_is(gcn_arch, "gfx1150") ||+ strata::kernels::gfx_arch_is(gcn_arch, "gfx1151");+}++std::vector<std::pair<std::string, std::string>> igpu_default_env(const char* gcn_arch, bool integrated) {+ std::vector<std::pair<std::string, std::string>> t;+ if (!integrated || !igpu_prompt_defaults_arch(gcn_arch)) return t;+ const char* off = std::getenv("STRATA_IGPU_DEFAULTS");+ if (off != nullptr && off[0] == '0') return t;+ // Measured on a Radeon 780M (gfx1103, P2006, Q2_0, notes-153-igpu.md / notes-148-amd.md): prompts 109.5 -> 214.7 tok/s+ // with the first four, 233 with HC_UPMIX, decode unchanged. Dense projections are 63% of a prompt's GPU time there.+ t = {+ {"STRATA_HIP_WMMA", "1"}, // the prompt attention on matrix cores+ {"STRATA_PF_GEMM", "1"}, // the prompt's FP16 projections on the 128 x 256 WMMA GEMM+ {"STRATA_PA_FAST", "1"}, // the prompt attention with single FP16 q and p+ {"STRATA_SELECT_WMMA", "1"}, // the block scorer on matrix cores+ {"STRATA_HC_UPMIX", "1"}, // the hyper-connection up projection with its epilogue+ };+ return t;+}++static void set_default(const std::pair<std::string, std::string>& kv) {#if defined(_WIN32)- _putenv_s(kv.first.c_str(), kv.second.c_str());+ _putenv_s(kv.first.c_str(), kv.second.c_str());#else- setenv(kv.first.c_str(), kv.second.c_str(), 0);+ setenv(kv.first.c_str(), kv.second.c_str(), 0);#endif+}++std::vector<std::string> apply_arch_defaults(const char* gcn_arch, bool integrated) {+ std::vector<std::string> set;+ for (const auto& kv : arch_default_env(gcn_arch)) {+ if (std::getenv(kv.first.c_str()) != nullptr) continue; // the user's setting wins, whatever it is+ set_default(kv);set.push_back(kv.first);}if (!set.empty()) {@@ -79,6 +105,23 @@ std::vector<std::string> apply_arch_defaults(const char* gcn_arch) {for (size_t i = 0; i < set.size(); ++i) std::fprintf(stderr, "%s%s", i ? " " : "", set[i].c_str() + 7);std::fprintf(stderr, "\n");}+ std::vector<std::string> igpu;+ for (const auto& kv : igpu_default_env(gcn_arch, integrated)) {+ if (std::getenv(kv.first.c_str()) != nullptr) continue;+ set_default(kv);+ igpu.push_back(kv.first);+ }+ if (!igpu.empty()) {+ std::fprintf(stderr, "strata: integrated GPU (%s): the matrix-core prompt set is on by default (about 2x faster prompts on a "+ "Radeon 780M, the answers differ in the last bits): ", gcn_arch);+ for (size_t i = 0; i < igpu.size(); ++i) std::fprintf(stderr, "%s%s", i ? " " : "", igpu[i].c_str() + 7);+ std::fprintf(stderr, ". Turn one off with NAME=0 (for example STRATA_HC_UPMIX=0), all of them with STRATA_IGPU_DEFAULTS=0");+#if defined(_WIN32)+ std::fprintf(stderr, ". Not yet tested on Windows");+#endif+ std::fprintf(stderr, "\n");+ set.insert(set.end(), igpu.begin(), igpu.end());+ }return set;}diff --git a/src/core/arch_defaults_test.cpp b/src/core/arch_defaults_test.cppindex 87f6246b4..8bf9adc91 100644--- a/src/core/arch_defaults_test.cpp+++ b/src/core/arch_defaults_test.cpp@@ -79,6 +79,66 @@ int main() {#elseCHECK(kGfx12PromptDefaultsOn);#endif+ // 153-igpu: the matrix-core prompt set of the integrated Radeons, chosen by the UMA flag AND the architecture.+ // Mock device properties: {gcnArchName, integrated}.+ struct Mock { const char* name; const char* gcn; bool integrated; bool expect_on; };+ const Mock mocks[] = {+ {"Radeon 780M (Phoenix, UMA)", "gfx1103", true, true},+ {"Radeon 780M with feature suffix", "gfx1103:sramecc-:xnack-", true, true},+ {"Radeon 890M (Strix Point, UMA)", "gfx1150", true, true},+ {"Radeon 8060S (Strix Halo, UMA)", "gfx1151", true, true},+ {"RX 7900 XTX (dGPU)", "gfx1100", false, false},+ {"RX 7800 XT (dGPU)", "gfx1101", false, false},+ {"R9700 (dGPU)", "gfx1201", false, false},+ {"RX 9060 (dGPU)", "gfx1200", false, false},+ {"RX 6800 (dGPU)", "gfx1030", false, false},+ {"a gfx1103 reported as a discrete card", "gfx1103", false, false},+ {"a gfx1151 reported as a discrete card", "gfx1151", false, false},+ {"Radeon 860M (Krackan, no kernels)", "gfx1152", true, false},+ {"older iGPU (gfx1036, no kernels)", "gfx1036", true, false},+ {"an integrated gfx1201 would not get it", "gfx1201", true, false},+ {"CUDA (no gcn name)", "", true, false},+ };+ unset("STRATA_IGPU_DEFAULTS");+ for (const Mock& m : mocks) {+ const auto t = igpu_default_env(m.gcn, m.integrated);+ CHECK(t.empty() == !m.expect_on);+ if (m.expect_on) {+ CHECK(t.size() == 5);+ const char* want[] = {"STRATA_HIP_WMMA", "STRATA_PF_GEMM", "STRATA_PA_FAST", "STRATA_SELECT_WMMA", "STRATA_HC_UPMIX"};+ for (const char* w : want) {+ bool found = false;+ for (const auto& kv : t) found = found || (kv.first == w && kv.second == "1");+ CHECK(found);+ }+ for (const auto& kv : t) CHECK(kv.first != "STRATA_PF_FUSED" && kv.first != "STRATA_HC_Q8" && kv.first != "STRATA_PF_HCDOWN");+ }+ if (!m.expect_on) std::printf(" (not on) %s\n", m.name);+ }+ CHECK(igpu_default_env(nullptr, true).empty());+ CHECK(igpu_prompt_defaults_arch("gfx1103") && igpu_prompt_defaults_arch("gfx1150") && igpu_prompt_defaults_arch("gfx1151"));+ CHECK(!igpu_prompt_defaults_arch("gfx11030") && !igpu_prompt_defaults_arch("gfx1100") && !igpu_prompt_defaults_arch("gfx1201"));+ // the exact tables are untouched: gfx1103 / gfx1150 stay out of arch_default_env, gfx1151 keeps no bit-changing switch+ CHECK(arch_default_env("gfx1103").empty());+ // the opt-out of the whole set+ put("STRATA_IGPU_DEFAULTS", "0");+ CHECK(igpu_default_env("gfx1103", true).empty());+ unset("STRATA_IGPU_DEFAULTS");+ // apply: a discrete card sets nothing, an iGPU sets the five, a switch the user set (even to 0) is kept+ const char* five[] = {"STRATA_HIP_WMMA", "STRATA_PF_GEMM", "STRATA_PA_FAST", "STRATA_SELECT_WMMA", "STRATA_HC_UPMIX"};+ for (const char* k : five) unset(k);+ CHECK(apply_arch_defaults("gfx1100", false).empty());+ CHECK(apply_arch_defaults("gfx1201", false).empty());+ CHECK(apply_arch_defaults("gfx1103", false).empty()); // integrated == false: a mixed box (iGPU + dGPU) keeps the old defaults+ for (const char* k : five) CHECK(std::getenv(k) == nullptr);+ put("STRATA_HC_UPMIX", "0");+ const auto on = apply_arch_defaults("gfx1103", true);+ CHECK(on.size() == 4);+ for (const char* k : {"STRATA_HIP_WMMA", "STRATA_PF_GEMM", "STRATA_PA_FAST", "STRATA_SELECT_WMMA"})+ CHECK(std::getenv(k) != nullptr && std::string(std::getenv(k)) == "1");+ CHECK(std::getenv("STRATA_HC_UPMIX") != nullptr && std::string(std::getenv("STRATA_HC_UPMIX")) == "0");+ for (const char* k : five) unset(k);+ // both platforms: no Windows guard on the iGPU set (the owner wants it there too; untested on Windows is only said in the log)std::printf(fails ? "arch_defaults_test: %d FAILED\n" : "arch_defaults_test: OK\n", fails);return fails ? 1 : 0;}diff --git a/src/program/generate.cpp b/src/program/generate.cppindex 01b99f06c..2c0589f4f 100644--- a/src/program/generate.cpp+++ b/src/program/generate.cpp@@ -2671,8 +2671,21 @@ int main(int argc, char** argv) {{ // gfx1151 (Strix Halo): the switches that are exact there are on by default (strata/core/arch_defaults.hpp); before// any engine code reads its switches (they are read at first use), and the user's own settings are keptcudaDeviceProp ad{};- if (cudaGetDeviceProperties(&ad, 0) == cudaSuccess) strata::core::apply_arch_defaults(ad.gcnArchName);- else (void) cudaGetLastError();+ if (cudaGetDeviceProperties(&ad, 0) == cudaSuccess) {+ // an integrated Radeon (UMA / APU: the device property, not the name): the matrix-core prompt set is on by+ // default. Only when EVERY visible GPU is integrated and of the same architecture, so a box that also holds a+ // discrete card (whichever the engine ends up using) keeps the old defaults.+ bool all_igpu = ad.integrated != 0;+ int ndev = 0;+ if (all_igpu && cudaGetDeviceCount(&ndev) == cudaSuccess) {+ for (int d = 1; d < ndev && d < 64; ++d) {+ cudaDeviceProp od{};+ if (cudaGetDeviceProperties(&od, d) != cudaSuccess || od.integrated == 0 ||+ std::strncmp(od.gcnArchName, ad.gcnArchName, 7) != 0) { all_igpu = false; (void) cudaGetLastError(); break; }+ }+ }+ strata::core::apply_arch_defaults(ad.gcnArchName, all_igpu);+ } else (void) cudaGetLastError();}#endif#if !defined(STRATA_USE_HIP) && !defined(STRATA_GPU_METAL)