From 6e8c86d46a4e74d14b835eb816a552adb0ccca39 Mon Sep 17 00:00:00 2001 From: bong-water-water-bong Date: Sun, 15 Nov 2026 22:45:01 -0400 Subject: [PATCH 1/2] npu: the engine#2599 twin decision gets its test arm (elf_twin.h, CTest npu_elf_twin) #2611 merged without a test for its new decision branch, which both of its reviewers asked for. The decision moves unchanged into npu/target/xdna/elf_twin.h (m16_twin_path, same_artifact). tests/npu_elf_twin_test covers every arm on files it writes itself: - identical bytes -> twin; - a difference in the last byte, or in the second 64 KiB block -> not a twin; - a size difference -> not a twin; - no twin on disk, or two empty files -> not a twin; - G identical to U (same shape) is not G's twin. Three header mutants each fail it: no byte compare, no size check, a wrong twin name. No behaviour change in open_prefill. Co-Authored-By: Claude Opus 5.5 --- CMakeLists.txt | 5 ++ npu/target/xdna/elf_twin.h | 58 ++++++++++++++++++++++ npu/target/xdna/xdna_target.cpp | 29 ++--------- tests/npu_elf_twin_test.cpp | 86 +++++++++++++++++++++++++++++++++ 4 files changed, 152 insertions(+), 26 deletions(-) create mode 100644 npu/target/xdna/elf_twin.h create mode 100644 tests/npu_elf_twin_test.cpp diff --git a/CMakeLists.txt b/CMakeLists.txt index 1727a99b2..7e343c0b6 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -1834,6 +1834,11 @@ add_test(NAME npu_pb16i_layout COMMAND ${CMAKE_SOURCE_DIR}/tests/npu_pb16i_layout_test.sh ${CMAKE_CXX_COMPILER} ${CMAKE_SOURCE_DIR}/npu/forward/include ${CMAKE_SOURCE_DIR}/tests/npu_pb16i_layout_test.cpp) +# engine#2599's decision (npu/target/xdna/elf_twin.h): a prefill ELF runs at 16 rows only when it is byte-identical to +# the _m16 twin of its own stem. Every arm, on files it writes itself; no device. +add_executable(npu_elf_twin_test tests/npu_elf_twin_test.cpp) +target_include_directories(npu_elf_twin_test PRIVATE ${CMAKE_SOURCE_DIR}/npu) +add_test(NAME npu_elf_twin COMMAND npu_elf_twin_test) # The t2s weight stream (q4nx_weight_layout "t2s"): the same integer-exact weights at 2.125 b/w, # expanded on the core. Its host-side contract is the file size, so the test pins the tile against # the numbers tools/q4nx_t2s.py measured on a real image (50,135,040 -> 23,674,880 B for gate/up). diff --git a/npu/target/xdna/elf_twin.h b/npu/target/xdna/elf_twin.h new file mode 100644 index 000000000..81c2cd415 --- /dev/null +++ b/npu/target/xdna/elf_twin.h @@ -0,0 +1,58 @@ +// Copyright 2026 bong-water-water-bong +// SPDX-License-Identifier: Apache-2.0 +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +// elf_twin.h -- engine#2599: is a prefill ELF the very same artifact as its own M=16 decode twin? +// +// bonsai2-27b-NPU shipped kernels/full_i8__K*_N*.elf byte-identical to the matching _m16.elf: its "prefill" set +// was the 16-row design. The artifact cannot say how many rows it computes (its declared widths are per tile), so a +// context sized from the design geometry (M=128) computed the first 16 rows of every 128-row chunk. The evidence is +// equal size and equal bytes against the twin of the SAME stem -- two roles of one shape (G and U) are legitimately +// identical and are never compared with each other. tests/npu_elf_twin_test.cpp pins both functions. +#pragma once + +#include +#include +#include +#include +#include + +namespace onebit::npu { + +// "/_m16.elf" for an ELF named ".elf" (a name without ".elf" keeps its whole name as the stem). +inline std::string m16_twin_path(const std::string& dir, const std::string& elf_name) { + std::string stem(elf_name); + if (stem.size() > 4 && stem.compare(stem.size() - 4, 4, ".elf") == 0) stem.resize(stem.size() - 4); + return dir + "/" + stem + "_m16.elf"; +} + +// True only when both files open, are the same non-zero size and hold the same bytes. +inline bool same_artifact(const std::string& a, const std::string& b) { + std::ifstream fa(a, std::ios::binary | std::ios::ate), fb(b, std::ios::binary | std::ios::ate); + if (!fa || !fb) return false; + const std::streamoff na = fa.tellg(), nb = fb.tellg(); + if (na <= 0 || na != nb) return false; + fa.seekg(0); + fb.seekg(0); + std::vector ba(1 << 16), bb(1 << 16); + for (std::streamoff left = na; left > 0;) { + const std::streamsize n = (std::streamsize)std::min(left, (std::streamoff)ba.size()); + if (!fa.read(ba.data(), n) || !fb.read(bb.data(), n)) return false; + if (std::memcmp(ba.data(), bb.data(), (size_t)n) != 0) return false; + left -= n; + } + return true; +} + +} // namespace onebit::npu diff --git a/npu/target/xdna/xdna_target.cpp b/npu/target/xdna/xdna_target.cpp index 622710d1a..22b1022d7 100644 --- a/npu/target/xdna/xdna_target.cpp +++ b/npu/target/xdna/xdna_target.cpp @@ -20,6 +20,7 @@ // // docs/npu-p4-target-split.md records what moved in A1 and what A2 (plan-driven setup) still owes. #include "target/xdna/xdna_target.h" +#include "target/xdna/elf_twin.h" // engine#2599: a prefill ELF that is its own _m16 twin #include "target/xdna/launch_fit.h" // engine#1783: refuse a launch its context cannot hold #include "batch_width.h" #include "file_create.h" // dumps are created 0600, never through a symlink @@ -83,28 +84,6 @@ static const char* role_tag(Q4nxDesign r) { // The forward's own probe, kept identical (exists and non-empty): an ELF that is present but zero bytes // is the failure this catches, and a target that decided differently from its caller would be a second // definition of "the kernel is there". -// engine#2599: is the prefill ELF the very same artifact as its M=16 decode twin? bonsai2-27b-NPU ships -// kernels/full_i8__K*_N*.elf byte-identical (md5) to the matching _m16.elf, i.e. its "prefill" set IS the -// 16-row design. Nothing in the artifact says how many rows it computes (its declared widths are per-tile, and a -// narrower declared width than the buffer is legal), so a context sized from the design geometry (M=128) chunked the -// prompt at 128 rows and the kernel computed the first 16 of each: 112 rows of every chunk came back as 0. Equal size -// and equal bytes is the evidence; anything else (a real M=128 build, or no twin in the directory) changes nothing. -static bool same_artifact(const std::string& a, const std::string& b) { - std::ifstream fa(a, std::ios::binary | std::ios::ate), fb(b, std::ios::binary | std::ios::ate); - if (!fa || !fb) return false; - const std::streamoff na = fa.tellg(), nb = fb.tellg(); - if (na <= 0 || na != nb) return false; - fa.seekg(0); fb.seekg(0); - std::vector ba(1 << 16), bb(1 << 16); - for (std::streamoff left = na; left > 0;) { - const std::streamsize n = (std::streamsize)std::min(left, (std::streamoff)ba.size()); - if (!fa.read(ba.data(), n) || !fb.read(bb.data(), n)) return false; - if (std::memcmp(ba.data(), bb.data(), (size_t)n) != 0) return false; - left -= n; - } - return true; -} - static bool elf_present(const std::string& p) { FILE* f = std::fopen(p.c_str(), "rb"); if (!f) return false; @@ -187,10 +166,8 @@ bool XdnaTarget::open_prefill(const Q4nxDesignGeom* designs, int n, std::string& } int md = g->M; { - std::string twin(g->elf_name); - if (twin.size() > 4 && twin.compare(twin.size() - 4, 4, ".elf") == 0) twin.resize(twin.size() - 4); - twin = dir + "/" + twin + "_m16.elf"; - if (md > Q4NX_DESIGN_M_DECODE && same_artifact(elf, twin)) { + const std::string twin = onebit::npu::m16_twin_path(dir, g->elf_name); + if (md > Q4NX_DESIGN_M_DECODE && onebit::npu::same_artifact(elf, twin)) { md = Q4NX_DESIGN_M_DECODE; prefill_is_decode_design_ = true; std::fprintf(stderr, " [forward] %-3s %s is byte-identical to its _m16 twin: it is the %d-row design, so " diff --git a/tests/npu_elf_twin_test.cpp b/tests/npu_elf_twin_test.cpp new file mode 100644 index 000000000..6c03608bc --- /dev/null +++ b/tests/npu_elf_twin_test.cpp @@ -0,0 +1,86 @@ +// Copyright 2026 bong-water-water-bong +// SPDX-License-Identifier: Apache-2.0 +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +// npu_elf_twin_test -- engine#2599's decision, pinned without a device: open_prefill() runs a role at 16 rows only when +// its prefill ELF is byte-identical to the _m16 twin of the SAME stem. Every arm of that decision: +// 1. the twin path is "/_m16.elf"; +// 2. identical bytes -> twin (the bonsai2-27b-NPU case); +// 3. one byte different, same size -> not a twin (a real M=128 build of equal size); +// 4. a different size -> not a twin; +// 5. no twin on disk, or an empty file -> not a twin (nothing changes); +// 6. two ROLES of one shape (G and U) are identical by design, and the rule never compares them: G's twin is G_m16. +#include "target/xdna/elf_twin.h" + +#include +#include +#include +#include +#include +#include + +static int fails = 0; +#define CHECK(c, m) do { if (!(c)) { std::printf("FAIL: %s\n", m); ++fails; } } while (0) + +static void put(const std::string& p, const std::string& bytes) { std::ofstream(p, std::ios::binary) << bytes; } + +int main() { + char tmpl[] = "/tmp/npu-elf-twin.XXXXXX"; + const char* tmp = std::getenv("TMPDIR"); + std::string base = tmp && *tmp ? std::string(tmp) + "/npu-elf-twin.XXXXXX" : std::string(tmpl); + std::vector buf(base.begin(), base.end()); + buf.push_back('\0'); + if (!mkdtemp(buf.data())) { std::printf("mkdtemp failed\n"); return 1; } + const std::string d(buf.data()); + using onebit::npu::m16_twin_path; + using onebit::npu::same_artifact; + + CHECK(m16_twin_path(d, "full_i8_U_K5120_N17408.elf") == d + "/full_i8_U_K5120_N17408_m16.elf", "1. twin path"); + CHECK(m16_twin_path(d, "noext") == d + "/noext_m16.elf", "1. twin path without .elf"); + + const std::string big(200000, 'x'); // spans several 64 KiB compare blocks + put(d + "/U.elf", big); + put(d + "/U_m16.elf", big); + CHECK(same_artifact(d + "/U.elf", m16_twin_path(d, "U.elf")), "2. identical bytes are a twin"); + + std::string last = big; last.back() = 'y'; + put(d + "/D.elf", big); + put(d + "/D_m16.elf", last); + CHECK(!same_artifact(d + "/D.elf", m16_twin_path(d, "D.elf")), "3. a last-byte difference is not a twin"); + std::string mid = big; mid[70000] = 'z'; + put(d + "/O_m16.elf", mid); + put(d + "/O.elf", big); + CHECK(!same_artifact(d + "/O.elf", m16_twin_path(d, "O.elf")), "3. a difference in the second block is not a twin"); + + put(d + "/Z.elf", big); + put(d + "/Z_m16.elf", big + "x"); + CHECK(!same_artifact(d + "/Z.elf", m16_twin_path(d, "Z.elf")), "4. a size difference is not a twin"); + + put(d + "/Q.elf", big); + CHECK(!same_artifact(d + "/Q.elf", m16_twin_path(d, "Q.elf")), "5. no twin on disk is not a twin"); + put(d + "/E.elf", ""); + put(d + "/E_m16.elf", ""); + CHECK(!same_artifact(d + "/E.elf", m16_twin_path(d, "E.elf")), "5. two empty files are not a twin"); + + // 6. G and U: same shape, same bytes, no _m16 for G here -> G is not reported as a twin of U. + put(d + "/G.elf", big); + CHECK(!same_artifact(d + "/G.elf", m16_twin_path(d, "G.elf")), "6. G identical to U is not G's twin"); + + for (const char* f : {"U", "U_m16", "D", "D_m16", "O", "O_m16", "Z", "Z_m16", "Q", "E", "E_m16", "G"}) + std::remove((d + "/" + f + ".elf").c_str()); + rmdir(d.c_str()); + if (fails) { std::printf("npu_elf_twin_test: %d failure(s)\n", fails); return 1; } + std::printf("npu_elf_twin_test: OK\n"); + return 0; +} From a7be0e0f98a6b3a6b07184d2b29eaa3c8a4bf90b Mon Sep 17 00:00:00 2001 From: bong-water-water-bong Date: Sun, 15 Nov 2026 23:54:42 -0400 Subject: [PATCH 2/2] npu_elf_twin: self-compiling test, so CI's explicit target list runs it CI at eb99be4: ci_targets failed and npu_elf_twin was 'Not Run', because ci.yml builds an explicit target list and npu_elf_twin_test was a plain add_executable. It now compiles itself at test time with the build's own compiler (tests/npu_elf_twin_test.sh), as npu_pb16i_layout and npu_w4g32_layout already do. Local: ci_targets, ci_targets_self, npu_elf_twin and npu_w4g32_layout pass. Co-Authored-By: Claude Opus 5.5 --- CMakeLists.txt | 9 ++++++--- tests/npu_elf_twin_test.sh | 31 +++++++++++++++++++++++++++++++ 2 files changed, 37 insertions(+), 3 deletions(-) create mode 100755 tests/npu_elf_twin_test.sh diff --git a/CMakeLists.txt b/CMakeLists.txt index c43a5f8c7..6239fb2ea 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -1836,9 +1836,12 @@ add_test(NAME npu_pb16i_layout ${CMAKE_SOURCE_DIR}/tests/npu_pb16i_layout_test.cpp) # engine#2599's decision (npu/target/xdna/elf_twin.h): a prefill ELF runs at 16 rows only when it is byte-identical to # the _m16 twin of its own stem. Every arm, on files it writes itself; no device. -add_executable(npu_elf_twin_test tests/npu_elf_twin_test.cpp) -target_include_directories(npu_elf_twin_test PRIVATE ${CMAKE_SOURCE_DIR}/npu) -add_test(NAME npu_elf_twin COMMAND npu_elf_twin_test) +# Self-compiling (like npu_pb16i_layout): CI builds an explicit target list, so a plain add_executable would be "Not Run" +# there and trip ci_targets. +add_test(NAME npu_elf_twin + COMMAND ${CMAKE_SOURCE_DIR}/tests/npu_elf_twin_test.sh + ${CMAKE_CXX_COMPILER} ${CMAKE_SOURCE_DIR}/npu + ${CMAKE_SOURCE_DIR}/tests/npu_elf_twin_test.cpp) # The w4g32 weight image (q4nx_w4g32.h): the large-M int4-weight prefill tier's contract -- the b4 tile # order, the per-32 signed magnitudes, the A pack and the int64 reference. No device; set # W4G32_VEC=" M K N" to also check it against a gate vector set the NPU reproduced bit-exact. diff --git a/tests/npu_elf_twin_test.sh b/tests/npu_elf_twin_test.sh new file mode 100755 index 000000000..72fa4c025 --- /dev/null +++ b/tests/npu_elf_twin_test.sh @@ -0,0 +1,31 @@ +#!/bin/bash +# Copyright 2026 bong-water-water-bong +# SPDX-License-Identifier: Apache-2.0 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +# npu_elf_twin_test.sh +# +# engine#2599's twin decision (npu/target/xdna/elf_twin.h) is pure index math: no +# runtime, no device, no NPU toolchain. Same reason as npu_blocked_layout_test.sh: +# the check compiles itself with the build's own compiler at test time, so it cannot +# become "Not Run" by being absent from CI's explicit target list. +set -u +CXX=${1:?usage: npu_elf_twin_test.sh } +INC=${2:?} +SRC=${3:?} +work=$(mktemp -d "${TMPDIR:-/tmp}/npu-elf-twin.XXXXXX") +trap 'rm -rf "$work"' EXIT +"$CXX" -std=c++17 -O1 -Wall -Wextra -I "$INC" "$SRC" -o "$work/t" || { + echo "npu_elf_twin_test: compile failed"; exit 1; } +"$work/t"