Skip to content

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++
7.8 KB
Raw Blame
"""#2054: BUILD.json is trusted only beside a binary of the source's version.

A build that stopped (nvcc rejecting a newer host gcc) once left the old engine next to a stamp of the new source, and
every later update said "engine already built for this PC" for good.  `stale_binary` reads the version compiled into the
binary; `build_engine` refuses to stamp or install a binary of another version and compiles again when the installed
one is stale.

    python -m unittest tools.test_setup_stale_stamp
"""
from __future__ import annotations

import json
import sys
import tempfile
import unittest
from pathlib import Path
from unittest import mock

ROOT = Path(__file__).resolve().parents[1]
sys.path.insert(0, str(ROOT))
import setup  # noqa: E402

GPU = {"arch": 86, "archs": [86], "name": "RTX 3060"}


def binary(version: str | None) -> bytes:
    return b"\x7fELF....tail_role_token=0 vram_elastic=0 engine=" + version.encode() + b"\n...." if version else b"old binary"


class StaleBinary(unittest.TestCase):
    def test_reads_the_compiled_in_version(self):
        with tempfile.TemporaryDirectory() as d, mock.patch.object(setup, "source_version", lambda: "0.1.43"):
            exe = Path(d) / "strata"
            exe.write_bytes(binary("0.1.42"))
            self.assertEqual(setup.binary_engine_version(exe), "0.1.42")
            self.assertTrue(setup.stale_binary(exe))
            exe.write_bytes(binary("0.1.43"))
            self.assertFalse(setup.stale_binary(exe))

    def test_four_part_version_and_unknowns(self):
        with tempfile.TemporaryDirectory() as d, mock.patch.object(setup, "source_version", lambda: "0.1.43.1"):
            exe = Path(d) / "strata"
            exe.write_bytes(binary("0.1.43.1"))
            self.assertFalse(setup.stale_binary(exe))
            exe.write_bytes(binary("0.1.43"))
            self.assertTrue(setup.stale_binary(exe))
            exe.write_bytes(binary(None))                 # a binary that carries no version: not judged
            self.assertFalse(setup.stale_binary(exe))
            self.assertFalse(setup.stale_binary(Path(d) / "missing"))


class BuildEngineStamp(unittest.TestCase):
    def setUp(self):
        tmp = tempfile.TemporaryDirectory()
        self.addCleanup(tmp.cleanup)
        self.root = Path(tmp.name)
        self.eng = self.root / "engine"
        self.eng.mkdir()
        (self.eng / setup.EXE).write_bytes(binary("0.1.42"))
        self.old_stamp = {"source": "local", "version": "0.1.42", "archs": [86], "vision": "none",
                          "cuda_dirs": [], "src": "oldhash", "vision_src": None}
        (self.eng / "BUILD.json").write_text(json.dumps(self.old_stamp))
        self.built = binary("0.1.43")                     # what the fake compile leaves in the build folder
        self.compiles = 0
        patches = [mock.patch.object(setup, "ROOT", self.root),
                   mock.patch.object(setup, "source_hash", lambda parts: "newhash"),
                   mock.patch.object(setup, "source_version", lambda: "0.1.43"),
                   mock.patch.object(setup, "install_build_tools", lambda gpu, yes: ("nvcc", None)),
                   mock.patch.object(setup, "toolkit_root_defs", lambda nvcc: []),
                   mock.patch.object(setup, "host_compiler_defs", lambda cuda: []),
                   mock.patch.object(setup, "engine_defs", lambda archs, tk=13: []),
                   mock.patch.object(setup, "isa_floor_defs", lambda *a: []),
                   mock.patch.object(setup, "cpu_floor", lambda avx2: ""),
                   mock.patch.object(setup, "cpu_info", lambda: ("cpu", True)),
                   mock.patch.object(setup, "cmake_build", self.fake_build),
                   mock.patch.object(setup, "say", lambda *a, **k: None),
                   mock.patch.object(setup, "ok", lambda *a, **k: None)]
        for p in patches:
            p.start()
            self.addCleanup(p.stop)

    def fake_build(self, src, bdir, target, defs, vcvars, bat):
        self.compiles += 1
        self.defs = list(defs)
        bdir.mkdir(parents=True, exist_ok=True)
        (bdir / setup.EXE).write_bytes(self.built)

    def stamp(self):
        return json.loads((self.eng / "BUILD.json").read_text())

    def test_a_good_build_is_stamped(self):
        setup.build_engine(GPU, "none", True, Path("llama"), toolkit=13)
        self.assertEqual(self.compiles, 1)
        self.assertEqual(self.stamp()["src"], "newhash")
        self.assertEqual(self.stamp()["version"], "0.1.43")
        self.assertEqual((self.eng / setup.EXE).read_bytes(), self.built)

    def test_the_q6k_expert_kernels_are_pinned_on(self):
        """PR #2515: a build/ folder first configured while STRATA_Q6K_EXPERTS defaulted to OFF keeps it in CMakeCache.txt;
        the configure line names it, so Qwen3.6 UD-Q4_K_XL (Q4_K gate/up, Q6_K down) still loads."""
        setup.build_engine(GPU, "none", True, Path("llama"), toolkit=13)
        self.assertIn("-DSTRATA_Q6K_EXPERTS=ON", self.defs)
        self.assertNotIn("-DSTRATA_Q6K_EXPERTS=OFF", self.defs)
        self.assertIn("-DSTRATA_MMQ_KQUANTS=ON", self.defs)  # flipped OFF -> ON in the same commit (465cd61d)

    def test_a_build_that_leaves_the_old_binary_is_not_stamped_or_installed(self):
        self.built = binary("0.1.42")                     # the build "succeeded" without producing the new engine
        with self.assertRaises(SystemExit):
            setup.build_engine(GPU, "none", True, Path("llama"), toolkit=13)
        self.assertEqual(self.stamp(), self.old_stamp)     # still the old hash: the next update compiles again
        self.assertEqual((self.eng / setup.EXE).read_bytes(), binary("0.1.42"))

    def test_a_poisoned_stamp_is_compiled_again(self):
        """The state #2054 found: the new source hash and version in BUILD.json, the old binary beside it."""
        (self.eng / "BUILD.json").write_text(json.dumps({**self.old_stamp, "version": "0.1.43", "src": "newhash"}))
        setup.build_engine(GPU, "none", True, Path("llama"), toolkit=13)
        self.assertEqual(self.compiles, 1)
        self.assertEqual((self.eng / setup.EXE).read_bytes(), self.built)

    def test_a_healthy_install_is_left_alone(self):
        (self.eng / setup.EXE).write_bytes(binary("0.1.43"))
        (self.eng / "BUILD.json").write_text(json.dumps({**self.old_stamp, "version": "0.1.43", "src": "newhash"}))
        setup.build_engine(GPU, "none", True, Path("llama"), toolkit=13)
        self.assertEqual(self.compiles, 0)


class UpdateInstalledEngine(unittest.TestCase):
    def test_a_poisoned_stamp_makes_the_update_compile(self):
        with tempfile.TemporaryDirectory() as d:
            root = Path(d)
            eng = root / "engine"
            eng.mkdir()
            (eng / setup.EXE).write_bytes(binary("0.1.42"))
            (eng / "BUILD.json").write_text(json.dumps({"source": "local", "version": "0.1.43", "archs": [86],
                                                        "vision": "none", "src": "newhash"}))
            built = []
            with mock.patch.object(setup, "ROOT", root), \
                    mock.patch.object(setup, "source_hash", lambda parts: "newhash"), \
                    mock.patch.object(setup, "source_version", lambda: "0.1.43"), \
                    mock.patch.object(setup, "update_engine_gpu", lambda tk: dict(GPU)), \
                    mock.patch.object(setup, "get_llama_cpp", lambda: Path("llama")), \
                    mock.patch.object(setup, "build_engine", lambda *a, **k: built.append(a)), \
                    mock.patch.object(setup, "say", lambda *a, **k: None):
                setup.update_installed_engine("http://x", 13)
                self.assertEqual(len(built), 1)
                built.clear()
                (eng / setup.EXE).write_bytes(binary("0.1.43"))
                setup.update_installed_engine("http://x", 13)
                self.assertEqual(built, [])


if __name__ == "__main__":
    unittest.main()