Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
8 changes: 8 additions & 0 deletions CMakeLists.txt
Original file line number Diff line number Diff line change
Expand Up @@ -1834,6 +1834,14 @@ 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.
# 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="<dir> M K N" to also check it against a gate vector set the NPU reproduced bit-exact.
Expand Down
58 changes: 58 additions & 0 deletions npu/target/xdna/elf_twin.h
Original file line number Diff line number Diff line change
@@ -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_<ROLE>_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 <algorithm>
#include <cstring>
#include <fstream>
#include <string>
#include <vector>

namespace onebit::npu {

// "<dir>/<stem>_m16.elf" for an ELF named "<stem>.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<char> ba(1 << 16), bb(1 << 16);
for (std::streamoff left = na; left > 0;) {
const std::streamsize n = (std::streamsize)std::min<std::streamoff>(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
29 changes: 3 additions & 26 deletions npu/target/xdna/xdna_target.cpp
Original file line number Diff line number Diff line change
Expand Up @@ -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
Expand Down Expand Up @@ -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_<ROLE>_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<char> ba(1 << 16), bb(1 << 16);
for (std::streamoff left = na; left > 0;) {
const std::streamsize n = (std::streamsize)std::min<std::streamoff>(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;
Expand Down Expand Up @@ -220,10 +199,8 @@ bool XdnaTarget::open_prefill(const Q4nxDesignGeom* designs, int n, std::string&
int md = w4_rows_ ? w4_rows_ : g->M;
if (!w4_rows_) {
// engine#2599 (the w4g32 tier opens its own M=512 ELF instead, so this does not apply to it)
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 "
Expand Down
86 changes: 86 additions & 0 deletions tests/npu_elf_twin_test.cpp
Original file line number Diff line number Diff line change
@@ -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 "<dir>/<stem>_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 <cstdio>
#include <cstdlib>
#include <fstream>
#include <string>
#include <unistd.h>
#include <vector>

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<char> 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;
}
31 changes: 31 additions & 0 deletions tests/npu_elf_twin_test.sh
Original file line number Diff line number Diff line change
@@ -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 <c++-compiler> <include-dir> <test.cpp>
#
# 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 <c++-compiler> <include-dir> <test.cpp>}
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"
Loading