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++
// src/core/arch_defaults_test.cpp - the per-architecture default table (no GPU needed).
#include "strata/core/arch_defaults.hpp"
#include "strata/core/gfx12_platform_defaults.hpp"
#include "strata/core/sm120_series.hpp"
#include "strata/core/defaults_026.hpp"
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <string>
static int fails = 0;
#define CHECK(c) do { if (!(c)) { std::printf("FAIL line %d: %s\n", __LINE__, #c); ++fails; } } while (0)
static void unset(const char* k) {
#if defined(_WIN32)
_putenv_s(k, "");
#else
unsetenv(k);
#endif
}
static void put(const char* k, const char* v) {
#if defined(_WIN32)
_putenv_s(k, v);
#else
setenv(k, v, 1);
#endif
}
int main() {
using namespace strata::core;
unset("STRATA_GFX1151_DEFAULTS");
// other architectures (and CUDA, which passes an empty name): nothing
CHECK(arch_default_env("gfx1100").empty());
CHECK(arch_default_env("gfx1150").empty());
CHECK(arch_default_env("gfx1152").empty());
CHECK(arch_default_env("gfx11510").empty()); // not a prefix match
CHECK(arch_default_env("").empty());
CHECK(arch_default_env(nullptr).empty());
// gfx1151, plain and with its feature suffix: the table, and no bit-changing switch in it
for (const char* a : {"gfx1151", "gfx1151:sramecc-:xnack-"}) {
const auto t = arch_default_env(a);
CHECK(t.size() >= 10);
for (const auto& kv : t) {
CHECK(kv.first.rfind("STRATA_", 0) == 0);
for (const char* bits : {"STRATA_PF_GEMM", "STRATA_PF_FUSED", "STRATA_HC_UPMIX", "STRATA_PA_FAST", "STRATA_HIP_WMMA",
"STRATA_SELECT_WMMA", "STRATA_HC_Q8", "STRATA_PF_HCDOWN", "STRATA_WMMA_GEMM"})
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 one
unset("STRATA_GFX12_DEFAULTS");
for (const char* a : {"gfx1200", "gfx1201", "gfx1201:sramecc-:xnack-"}) {
const auto t = arch_default_env(a);
CHECK(t.size() == 9);
bool attn_lane = false, attn_merge = false, tsum = false, expdec = false;
for (const auto& kv : t) {
if (kv.first == "STRATA_ATTN_LANECELL") attn_lane = kv.second == "1";
if (kv.first == "STRATA_ATTN_MERGE_V2") attn_merge = kv.second == "1";
if (kv.first == "STRATA_TSUM") tsum = kv.second == "1";
if (kv.first == "STRATA_EXPDEC") expdec = kv.second == "1";
}
CHECK(attn_lane && attn_merge && tsum && expdec); // the 0.2.7 R9700 decode measurement, bit-identical
for (const auto& kv : t) CHECK(kv.first != "STRATA_HCD_EXACT");
for (const auto& kv : t) {
CHECK(kv.first != "STRATA_Q8_PACKED" && kv.first != "STRATA_SH_STREAM" && kv.first != "STRATA_PF_GEMM" &&
kv.first != "STRATA_PF_FUSED");
}
}
CHECK(arch_default_env("gfx12010").empty());
put("STRATA_GFX12_DEFAULTS", "0");
CHECK(arch_default_env("gfx1201").empty());
unset("STRATA_GFX12_DEFAULTS");
// a user's setting wins, whatever it is; the rest are set
put("STRATA_TSUM", "0");
unset("STRATA_QFUSE");
const auto set = apply_arch_defaults("gfx1151");
CHECK(std::getenv("STRATA_TSUM") != nullptr && std::string(std::getenv("STRATA_TSUM")) == "0");
CHECK(std::getenv("STRATA_QFUSE") != nullptr && std::string(std::getenv("STRATA_QFUSE")) == "1");
for (const auto& n : set) CHECK(n != "STRATA_TSUM");
// the opt-out
put("STRATA_GFX1151_DEFAULTS", "0");
CHECK(arch_default_env("gfx1151").empty());
CHECK(apply_arch_defaults("gfx1151").empty());
// the two approved gfx12 prompt defaults (WMMA attention, Q2_0 fused experts): on for Linux, off for Windows
CHECK(gfx12_prompt_defaults_on(false));
CHECK(!gfx12_prompt_defaults_on(true));
#if defined(_WIN32)
CHECK(!kGfx12PromptDefaultsOn);
#else
CHECK(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");
unset("STRATA_IGPU_PROMPT_SET");
// 021-minipc: with nothing set the prompt set is the default of the Radeon 780M only (gfx1103, integrated, not Windows)
CHECK(kIgpuPromptSetDefaultOn);
CHECK(igpu_prompt_set_enabled("gfx1103", false));
CHECK(igpu_prompt_set_enabled("gfx1103:sramecc-:xnack-", false));
CHECK(!igpu_prompt_set_enabled("gfx1103", true)); // Windows: not tested
for (const char* g : {"gfx1150", "gfx1151", "gfx1100", "gfx1201", "gfx1152", "", "gfx11030"}) CHECK(!igpu_prompt_set_enabled(g, false));
CHECK(!igpu_prompt_set_enabled(nullptr, false));
for (const Mock& m : mocks) {
const bool want = m.expect_on && std::string(m.gcn).rfind("gfx1103", 0) == 0;
#if defined(_WIN32)
CHECK(igpu_default_env(m.gcn, m.integrated).empty());
#else
CHECK(igpu_default_env(m.gcn, m.integrated).size() == (want ? 5u : 0u));
#endif
}
#if !defined(_WIN32)
for (const char* k : {"STRATA_HIP_WMMA", "STRATA_PF_GEMM", "STRATA_PA_FAST", "STRATA_SELECT_WMMA", "STRATA_HC_UPMIX"}) unset(k);
CHECK(apply_arch_defaults("gfx1103", true).size() == 5); // a 780M gets the set with nothing set
for (const char* k : {"STRATA_HIP_WMMA", "STRATA_PF_GEMM", "STRATA_PA_FAST", "STRATA_SELECT_WMMA", "STRATA_HC_UPMIX"}) unset(k);
CHECK(apply_arch_defaults("gfx1150", true).empty()); // 880M / 890M: no hardware, stays as it was
for (const char* k : {"STRATA_HIP_WMMA", "STRATA_PF_GEMM", "STRATA_PA_FAST", "STRATA_SELECT_WMMA", "STRATA_HC_UPMIX"}) unset(k);
#endif
// the off switches
put("STRATA_IGPU_PROMPT_SET", "0");
CHECK(!igpu_prompt_set_enabled("gfx1103", false));
CHECK(igpu_default_env("gfx1103", true).empty());
unset("STRATA_IGPU_PROMPT_SET");
put("STRATA_IGPU_DEFAULTS", "0");
CHECK(!igpu_prompt_set_enabled("gfx1103", false));
unset("STRATA_IGPU_DEFAULTS");
// opt-in per run for the other arches: STRATA_IGPU_PROMPT_SET=1; the checks below run with it on (every mock arch of the list)
put("STRATA_IGPU_PROMPT_SET", "1");
CHECK(igpu_prompt_set_enabled("gfx1150", false));
put("STRATA_IGPU_DEFAULTS", "0");
CHECK(!igpu_prompt_set_enabled("gfx1150", false)); // the whole-set off switch wins
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");
put("STRATA_IGPU_PROMPT_SET", "0");
CHECK(igpu_default_env("gfx1103", true).empty());
put("STRATA_IGPU_PROMPT_SET", "1");
// 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());
// gfx12: a discrete RDNA4 card gets its own nine switches (five prompt, four decode); a second call has nothing to do
const char* g12[] = {"STRATA_GDN_HEAD", "STRATA_GDN_PP", "STRATA_GDN_CONVL2", "STRATA_GDN_NOY", "STRATA_CVEC_FUSE",
"STRATA_ATTN_LANECELL", "STRATA_ATTN_MERGE_V2", "STRATA_TSUM", "STRATA_EXPDEC"};
for (const char* k : g12) unset(k);
const auto g12set = apply_arch_defaults("gfx1201", false);
CHECK(g12set.size() == 9);
for (const char* k : g12) {
CHECK(std::getenv(k) != nullptr);
CHECK(std::string(std::getenv(k)) == (std::strcmp(k, "STRATA_GDN_PP") == 0 ? "2" : "1"));
}
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);
unset("STRATA_IGPU_PROMPT_SET");
// 021-minipc: UMA mode is NOT a default (slower, resets not fixed): off with nothing asked; the logic below runs with on=true
CHECK(!kIgpuUmaArenaDefaultOn);
CHECK(!igpu_uma_arena_default("gfx1103", true, false));
// 021-minipc: UMA mode (the expert arena stays unregistered) is chosen for the Radeon 780M only: gfx1103 + integrated + not Windows
unset("STRATA_UMA_REGISTER");
CHECK(igpu_uma_arena_default("gfx1103", true, false, true));
CHECK(igpu_uma_arena_default("gfx1103:sramecc-:xnack-", true, false, true));
CHECK(!igpu_uma_arena_default("gfx1103", true, true, true)); // Windows: not measured
CHECK(!igpu_uma_arena_default("gfx1103", false, false, true)); // a gfx1103 that is not integrated
for (const char* g : {"gfx1150", "gfx1151", "gfx1152", "gfx1100", "gfx1101", "gfx1200", "gfx1201", "gfx1030", "gfx11030", "", "gfx90a"})
CHECK(!igpu_uma_arena_default(g, true, false, true));
// 0.2.1.2: Strix Halo on Windows is unregistered by default (on or off), nothing else on Windows; Linux gfx1151 unchanged
CHECK(igpu_uma_arena_default("gfx1151", true, true));
CHECK(igpu_uma_arena_default("gfx1151:sramecc+:xnack-", true, true));
CHECK(!igpu_uma_arena_default("gfx1151", false, true)); // not integrated
CHECK(!igpu_uma_arena_default("gfx1151", true, false)); // Linux
for (const char* g : {"gfx1150", "gfx1152", "gfx1103", "gfx1100", "gfx1101", "gfx1102", "gfx1200", "gfx1201", "gfx1030", "", "gfx90a"})
CHECK(!igpu_uma_arena_default(g, true, true));
CHECK(!igpu_uma_arena_default(nullptr, true, true));
put("STRATA_UMA_REGISTER", "1");
CHECK(!igpu_uma_arena_default("gfx1151", true, true));
unset("STRATA_UMA_REGISTER");
CHECK(!igpu_uma_arena_default(nullptr, true, false, true));
put("STRATA_UMA_REGISTER", "1");
CHECK(!igpu_uma_arena_default("gfx1103", true, false, true)); // the user registers the arena as before
unset("STRATA_UMA_REGISTER");
// both platforms: no Windows guard on the iGPU set (the owner wants it there too; untested on Windows is only said in the log)
// ---- STRATA_DEFAULTS=026 (defaults_026.hpp): every 0.2.7 Qwen default gives v0.2.6's answer; an explicit variable is decided by the caller first
{
const double GiB = 1073741824.0;
using namespace strata;
CHECK(is_026_token("026") && is_026_token("0.2.6") && is_026_token("v0.2.6"));
CHECK(!is_026_token(nullptr) && !is_026_token("") && !is_026_token("0") && !is_026_token("027"));
// residency-biased routing: 0 with the master switch on or off (0.2.8: off by default on every card, 026 or not)
CHECK(route_prior_default(false, false, 12.0 * GiB, false) == 0.0f);
CHECK(route_prior_default(false, false, 12.0 * GiB, true) == 0.0f);
CHECK(route_prior_default(false, false, 8.0 * GiB, true) == 0.0f);
// an explicit STRATA_ROUTE_PRIOR=1.5 wins over 026 as well
CHECK(route_prior_resolve("1.5", false, false, 12.0 * GiB, true) == 1.5f);
// the wide HC up read: on for a 12.0 card on CUDA, off under 026, off in HIP, off on sm_86 / sm_121
CHECK(gr_up_wide_default(false, 12, 0));
CHECK(!gr_up_wide_default(false, 12, 0, true));
CHECK(!gr_up_wide_default(true, 12, 0));
CHECK(!gr_up_wide_default(false, 8, 6));
CHECK(!gr_up_wide_default(false, 12, 1));
// #3453: the sm_89 MMVQ-IL tables: on by default for compute capability 8.9 only, off under 026 and in HIP; "1" and "0" win
CHECK(mmvq_il_89_default(false, 89));
CHECK(!mmvq_il_89_default(false, 86) && !mmvq_il_89_default(false, 80) && !mmvq_il_89_default(false, 90) &&
!mmvq_il_89_default(false, 120) && !mmvq_il_89_default(false, 75) && !mmvq_il_89_default(false, 70) &&
!mmvq_il_89_default(false, 60) && !mmvq_il_89_default(false, 0));
CHECK(!mmvq_il_89_default(true, 89));
CHECK(!mmvq_il_89_default(false, 89, true)); // STRATA_DEFAULTS=026
CHECK(mmvq_il_89_resolve(nullptr, false, 89, false)); // unset: the rule
CHECK(!mmvq_il_89_resolve(nullptr, false, 89, true)); // unset + 026: off
CHECK(!mmvq_il_89_resolve(nullptr, false, 86, false)); // another card: off
CHECK(!mmvq_il_89_resolve("0", false, 89, false)); // STRATA_MMVQ_IL_89=0 turns it off
CHECK(mmvq_il_89_resolve("1", false, 89, true)); // an explicit =1 wins over the master switch
CHECK(mmvq_il_89_resolve("1", false, 86, false)); // (the tables are only looked up for cc 89 anyway)
CHECK(mmvq_il_89_resolve("", false, 89, false) && !mmvq_il_89_resolve("", false, 89, true)); // empty text: the rule
// #3779: the two sm_80-only defaults (wide dequant, MMVQ-IL sm_80 tables): on unless STRATA_DEFAULTS=026; "1" and "0" win
CHECK(sm80_default_on(nullptr, false) && !sm80_default_on(nullptr, true));
CHECK(!sm80_default_on("0", false) && sm80_default_on("1", true));
CHECK(sm80_default_on("", false) && !sm80_default_on("", true));
// GR_V3 and IMMA
CHECK(gr_v3_default(false, 12, 0, false, 72.0 * GiB, false));
CHECK(!gr_v3_default(false, 12, 0, false, 72.0 * GiB, true));
CHECK(prompt_attn_imma_default(false, 86, false));
CHECK(!prompt_attn_imma_default(false, 86, true));
CHECK(!prompt_attn_imma_default(false, 120, true));
// the gfx12 decode switches: the arch table is v0.2.6's five prompt switches under 026, nine otherwise; gfx1151 and the others do not move
{
const auto t26 = strata::core::arch_default_env("gfx1201", true);
const auto t27 = strata::core::arch_default_env("gfx1201", false);
auto has = [](const std::vector<std::pair<std::string, std::string>>& t, const char* k) {
for (const auto& kv : t) if (kv.first == k) return true;
return false;
};
CHECK(t26.size() == 5 && t27.size() == 9);
CHECK(has(t26, "STRATA_GDN_HEAD") && has(t26, "STRATA_CVEC_FUSE"));
CHECK(!has(t26, "STRATA_ATTN_LANECELL") && !has(t26, "STRATA_ATTN_MERGE_V2") && !has(t26, "STRATA_TSUM") && !has(t26, "STRATA_EXPDEC"));
CHECK(has(t27, "STRATA_ATTN_LANECELL") && has(t27, "STRATA_ATTN_MERGE_V2") && has(t27, "STRATA_TSUM") && has(t27, "STRATA_EXPDEC"));
CHECK(strata::core::arch_default_env("gfx1200", true).size() == 5);
CHECK(strata::core::arch_default_env("gfx1151", true) == strata::core::arch_default_env("gfx1151", false));
CHECK(strata::core::arch_default_env("gfx1100", true).empty() && strata::core::arch_default_env("gfx1100", false).empty());
}
// the decode miss split start value: 0.15 on gfx12 native packs, 0.55 under 026 or STRATA_PCIE_FRAC_DEFAULT=old; the others do not move
CHECK(pcie_start_frac(false, true, true, false, false) == 0.15);
CHECK(pcie_start_frac(false, true, true, false, true) == 0.55);
CHECK(pcie_start_frac(false, true, true, true, false) == 0.55);
CHECK(pcie_start_frac(false, true, false, false, false) == 0.55);
CHECK(pcie_start_frac(true, true, true, false, true) == 0.25);
CHECK(pcie_start_frac(true, true, true, false, false) == 0.25);
CHECK(pcie_start_frac(false, false, true, false, true) == 0.2);
CHECK(pcie_start_frac(false, false, true, false, false) == 0.2);
}
std::printf(fails ? "arch_defaults_test: %d FAILED\n" : "arch_defaults_test: OK\n", fails);
// ---- 0.2.7 CUDA defaults (sm120_series.hpp): which cards get which, and which never do
{
const double GiB = 1073741824.0;
using namespace strata;
// residency-biased routing (owner decision of 2026-10-29, #4402): OFF by default on every card, the 0.2.6 / STRATA_ROUTE_PRIOR=0 answer.
// 0.2.7 gave 1.5 to a discrete CUDA card of 13 GiB or less; the same cards are listed so the table says where the default went.
const double cards[] = {0.0, 4.0 * GiB, 8.0 * GiB, 11.9 * GiB, 12.0 * GiB, 13.0 * GiB, 13.5 * GiB, 15.7 * GiB, 24.0 * GiB, 31.4 * GiB, 48.0 * GiB, 72.0 * GiB};
for (const double bytes : cards)
for (const bool hip : {false, true})
for (const bool integrated : {false, true})
for (const bool v026 : {false, true}) {
CHECK(route_prior_default(hip, integrated, bytes, v026) == 0.0f);
CHECK(route_prior_resolve(nullptr, hip, integrated, bytes, v026) == 0.0f); // nothing set: off, = STRATA_ROUTE_PRIOR=0
CHECK(route_prior_resolve(nullptr, hip, integrated, bytes, v026) == route_prior_resolve("0", hip, integrated, bytes, v026));
}
CHECK(route_prior_default(false, false, 11.9 * GiB) == 0.0f); // RTX 3060 / 5070 12 GB: was 1.5 in 0.2.7
CHECK(route_prior_default(false, false, 13.0 * GiB) == 0.0f); // the old boundary
// the explicit opt-in still works: any set value wins on every card (the Expert-settings row writes 1.5)
CHECK(strata::kRoutePriorSmallCard == 1.5f); // the one place the opt-in value lives
CHECK(route_prior_resolve("1.5", false, false, 12.0 * GiB) == 1.5f);
CHECK(route_prior_resolve("1.5", false, false, 12.0 * GiB) == strata::kRoutePriorSmallCard);
CHECK(route_prior_resolve("1.5", false, false, 8.0 * GiB, true) == 1.5f); // also under STRATA_DEFAULTS=026
CHECK(route_prior_resolve("1.5", false, false, 72.0 * GiB) == 1.5f); // and on a card the 0.2.7 default never touched
CHECK(route_prior_resolve("1.5", true, false, 12.0 * GiB) == 1.5f); // the variable is the user's own on any build
CHECK(route_prior_resolve("2.0", false, false, 12.0 * GiB) == 2.0f);
CHECK(route_prior_resolve("0.5", false, false, 12.0 * GiB) == 0.5f);
CHECK(route_prior_resolve("0", false, false, 12.0 * GiB) == 0.0f);
CHECK(route_prior_resolve("", false, false, 12.0 * GiB) == 0.0f); // set but empty reads as 0, as atof always did here
CHECK(route_prior_resolve("off", false, false, 12.0 * GiB) == 0.0f);
// the stream-split hyper-connection read: a discrete 12.0 card above 13 GiB (RTX PRO 5000 72 GB, RTX 5090 32 GB), nothing else
CHECK(gr_v3_default(false, 12, 0, false, 72.0 * GiB));
CHECK(gr_v3_default(false, 12, 0, false, 31.4 * GiB)); // RTX 5090
CHECK(!gr_v3_default(false, 12, 0, false, 11.9 * GiB)); // RTX 5070 12 GB: streams most experts, unmeasured
CHECK(gr_v3_default(false, 12, 0, false, 15.6 * GiB)); // a 16 GB sm_120 card (RTX 5060 Ti / 5070 Ti): above 13 GiB, on (unmeasured size, same arch)
CHECK(!gr_v3_default(false, 8, 6, false, 15.7 * GiB)); // 2x RTX A4000 (sm_86): measured -3.0% / -5.9%
CHECK(!gr_v3_default(false, 8, 6, false, 72.0 * GiB)); // any sm_86
CHECK(!gr_v3_default(false, 8, 9, false, 24.0 * GiB)); // sm_89
CHECK(!gr_v3_default(false, 12, 1, false, 128.0 * GiB)); // sm_121 (DGX Spark class): not 12.0
CHECK(!gr_v3_default(false, 12, 0, true, 128.0 * GiB)); // integrated
CHECK(!gr_v3_default(true, 12, 0, false, 32.0 * GiB)); // a HIP build: gfx1201 reports 12.0 too
CHECK(!gr_v3_default(false, 6, 0, false, 16.0 * GiB)); // P100
}
{
using namespace strata;
// the prompt attention on int8 tensor cores: every CUDA card from sm_80 on, not Turing / Volta / Pascal, not HIP
CHECK(prompt_attn_imma_default(false, 120)); // RTX PRO 5000 / RTX 50: measured +1.6-1.8%
CHECK(prompt_attn_imma_default(false, 86)); // 2x RTX A4000 / RTX 3060: measured +1.1-1.3%
CHECK(prompt_attn_imma_default(false, 80));
CHECK(prompt_attn_imma_default(false, 89));
CHECK(!prompt_attn_imma_default(false, 75)); // Turing (also a forced STRATA_QSA_WARP=1 card)
CHECK(!prompt_attn_imma_default(false, 70)); // Volta
CHECK(!prompt_attn_imma_default(false, 60)); // Pascal (P100)
CHECK(!prompt_attn_imma_default(true, 120)); // HIP
}
{
using namespace strata;
// the layer-major prompt walk (#3976): on by default for a CUDA layer split only
CHECK(prefill_layer_major_default(false, 2)); // 2x RTX A4000 / A6000: measured 5x time to first token
CHECK(prefill_layer_major_default(false, 4));
CHECK(!prefill_layer_major_default(false, 1)); // one GPU: opt-in only
CHECK(!prefill_layer_major_default(false, 0));
CHECK(!prefill_layer_major_default(true, 2)); // HIP builds
CHECK(!prefill_layer_major_default(false, 2, true)); // STRATA_DEFAULTS=026
CHECK(!prefill_layer_major_default(true, 1, true));
// the variable wins in both directions, whatever the rule says
CHECK(!prefill_layer_major_resolve("0", false, 2)); // the off switch
CHECK(prefill_layer_major_resolve("1", false, 1)); // the opt-in of the first ports: one GPU too
CHECK(prefill_layer_major_resolve("1", false, 2, true)); // explicit beats STRATA_DEFAULTS=026
CHECK(!prefill_layer_major_resolve("0", false, 2, false));
CHECK(!prefill_layer_major_resolve("0", true, 2));
CHECK(prefill_layer_major_resolve("2", false, 1)); // any non-zero number is on
CHECK(!prefill_layer_major_resolve("off", false, 2)); // text that reads as 0 is off (atoi), as before this rule existed
// unset or empty: the rule
CHECK(prefill_layer_major_resolve(nullptr, false, 2));
CHECK(prefill_layer_major_resolve("", false, 2));
CHECK(!prefill_layer_major_resolve(nullptr, false, 1));
CHECK(!prefill_layer_major_resolve(nullptr, false, 2, true));
CHECK(!prefill_layer_major_resolve(nullptr, true, 2));
}
return fails ? 1 : 0;
}