From 1632630cc03880afb15266fb6d729c5e58dbcf50 Mon Sep 17 00:00:00 2001 From: t Date: Tue, 10 Nov 2026 19:51:42 -0400 Subject: [PATCH] npu-pack: plan() fills a container's geometry and names the source that answered engine#1786 (item F1), slice 2 of 3 -- stacked on slice 1 (#2054), which added container_geometry(). This wires it into the container-genre arm of plan(), so a recognised NPU2 container now carries its geometry instead of only its tensor count. Plan gains container_geometry_source / _missing / _inferred, and container_note names the source inline ("geometry from dims", "geometry from config.json", or "the geometry is not known here"), plus any field derived rather than declared and any field no source states. config.json is read through load_geometry() rather than a private parse, so this genre and every other agree about what config.json means (the text_config lift and the top-level-wins rule); container_geometry() still prefers the container's own `dims` over it. Still not importable, and the note says so: what is missing now is the role map (which tensor is which projection), not the geometry. That is slice 3. Arms: dims answers and beats a disagreeing config.json; config.json answers when there is no dims; with neither, the plan reports every required field missing and says the geometry is unknown rather than reporting zeros as facts. The arm removes its fixture directories on every exit -- the defect #2024 fixes for its neighbour is not repeated here. --- npu/pack_import.cpp | 28 ++++++++++++-- npu/pack_import.h | 6 +++ tests/npu_pack_import_test.cpp | 68 ++++++++++++++++++++++++++++++++++ 3 files changed, 99 insertions(+), 3 deletions(-) diff --git a/npu/pack_import.cpp b/npu/pack_import.cpp index 429347cc3..e5c2a80f8 100644 --- a/npu/pack_import.cpp +++ b/npu/pack_import.cpp @@ -3391,11 +3391,33 @@ Plan plan(const std::string& pack_dir) { p.container_tensors = int64_t(c.tensors.size()); p.container_payload_bytes = c.payload_bytes; for (const auto& t : c.tensors) p.container_dtypes[t.dtype]++; + // slice 2: the geometry, and the name of the source that answered. config.json is read through the ordinary + // loader so this genre and every other one agree about what config.json means (text_config lift, top-level + // wins) -- the container's own `dims` still takes precedence in container_geometry(). + std::string cfg_source; + const json cfg = load_geometry(pack_dir, &cfg_source); + const ContainerGeometry g = container_geometry(c.meta, cfg); + p.dims = g.dims; + p.container_geometry_source = g.source; + p.container_geometry_missing = g.missing; + p.container_geometry_inferred = g.inferred; + std::string geom = g.source.empty() + ? "the container declares no `dims` and no config.json answered, so its geometry is not known here" + : "geometry from " + g.source; + if (!g.inferred.empty()) { + geom += " ("; + for (size_t i = 0; i < g.inferred.size(); ++i) geom += (i ? ", " : "") + g.inferred[i]; + geom += " inferred)"; + } + if (!g.missing.empty()) { + geom += "; no source states "; + for (size_t i = 0; i < g.missing.size(); ++i) geom += (i ? ", " : "") + g.missing[i]; + } p.container_note = c.why.empty() ? "the pack is a safetensors container (model.q4nx): " + std::to_string(c.tensors.size()) + - " tensors, " + std::to_string(c.payload_bytes) + " B of payload, no graph. Reading it as a" - " weights source needs the container-genre plan (engine#1786, item F1); until then this pack is" - " recognised and reported, not importable." + " tensors, " + std::to_string(c.payload_bytes) + " B of payload, no graph; " + geom + + ". Reading it as a weights source needs the container-genre plan (engine#1786, item F1); until" + " then this pack is recognised and reported, not importable." : "model.q4nx is present but unreadable: " + c.why; return p; } diff --git a/npu/pack_import.h b/npu/pack_import.h index f21dcf51b..55ffc7498 100644 --- a/npu/pack_import.h +++ b/npu/pack_import.h @@ -222,6 +222,12 @@ struct Plan { int64_t container_payload_bytes = 0; std::map container_dtypes; std::string container_note; // what the container genre still needs, empty for a non-container pack + // engine#1786 (item F1), slice 2: WHERE the container's geometry came from, and what it could not reach. + // A bare number in `dims` cannot say whether the pack declared it or a file beside it did, and those two are free to + // disagree (13 of the 29 packs measured carry a `dims` block; all 29 carry config.json). Empty for a non-container pack. + std::string container_geometry_source; // "dims", "config.json", or empty when neither answered + std::vector container_geometry_missing; // fields no source could fill, by name + std::vector container_geometry_inferred; // fields derived from another field, by name int64_t graph_matmuls = -1; // MatMulNBits nodes in the main graph int64_t graph_real_weights = 0; // of those, how many point at an initializer with dims (i.e. real weights) int64_t graph_external = 0; // initializers that declare external data (location + offset) diff --git a/tests/npu_pack_import_test.cpp b/tests/npu_pack_import_test.cpp index 2a2bca1d4..48995e826 100644 --- a/tests/npu_pack_import_test.cpp +++ b/tests/npu_pack_import_test.cpp @@ -4825,6 +4825,73 @@ void test_container_geometry() { } } +// engine#1786 (item F1), slice 2: `plan()` reports WHERE a container's geometry came from. The three genres the census +// measured are the three cases: `dims` answers (and beats a disagreeing config.json), config.json answers when there is +// no `dims`, and neither answering is reported as unknown rather than as a zero geometry. +void test_container_plan(const std::string& root) { + namespace fs = std::filesystem; + // Under ctest `root` is the source tree's tests/golden, so these three directories are removed on every way out: + // the arm is new, and leaving fixtures behind is the defect #2024 fixes for its neighbour -- not repeating it here. + struct Cleanup { + fs::path base; + ~Cleanup() { + for (const char* n : {"cg-dims", "cg-cfg", "cg-silent"}) { + std::error_code e; + fs::remove_all(base / n, e); + } + } + } cleanup{fs::path(root)}; + const auto write_pack = [&](const std::string& name, const std::string& meta_json, const std::string& config) { + const fs::path dir = fs::path(root) / name; + std::error_code ec; + fs::remove_all(dir, ec); + fs::create_directories(dir, ec); + std::string hdr = "{"; + if (!meta_json.empty()) hdr += "\"__metadata__\":" + meta_json + ","; + hdr += "\"model.embed_tokens.weight\":{\"dtype\":\"BF16\",\"shape\":[4,2],\"data_offsets\":[0,16]}}"; + std::string out(8, '\0'); + const int64_t n = int64_t(hdr.size()); + for (int i = 0; i < 8; ++i) out[size_t(i)] = char((n >> (8 * i)) & 0xFF); + out += hdr; + out.append(16, '\x22'); + std::ofstream(dir / "model.q4nx", std::ios::binary).write(out.data(), std::streamsize(out.size())); + if (!config.empty()) std::ofstream(dir / "config.json") << config; + return dir.string(); + }; + const std::string dims = "{\"dims\":{\"hidden_size\":576,\"intermediate_size\":1536,\"num_hidden_layers\":30," + "\"num_attention_heads\":9,\"num_key_value_heads\":3,\"vocab_size\":49152," + "\"head_dim\":64,\"rope_theta\":10000.0,\"model_type\":\"llama\"}}"; + + // 1. self-describing, and a config.json that disagrees: the container's own statement wins and is named. + { + const auto pl = pi::plan(write_pack("cg-dims", dims, "{\"hidden_size\": 1024}")); + check(pl.container_geometry_source == "dims", "plan: a self-describing container reports source=dims"); + check(pl.dims.hidden == 576, "plan: dims.hidden comes from the container, not the disagreeing config.json"); + check(pl.dims.layers == 30 && pl.dims.vocab == 49152, "plan: the container's geometry reaches the plan"); + check(pl.container_geometry_missing.empty(), "plan: nothing is reported missing for a complete container"); + check(pl.container_note.find("geometry from dims") != std::string::npos, + "plan: the note says which source answered"); + } + // 2. gguf-converted: no dims, so config.json answers -- and the source says so. + { + const auto pl = pi::plan(write_pack("cg-cfg", "{\"converter\":\"tools/gguf_to_q4nx.py\"}", + "{\"hidden_size\":1024,\"num_hidden_layers\":28," + "\"num_attention_heads\":16,\"num_key_value_heads\":8," + "\"vocab_size\":151936,\"intermediate_size\":3072," + "\"head_dim\":64,\"rope_theta\":1000000.0}")); + check(pl.container_geometry_source == "config.json", "plan: a converted container reports source=config.json"); + check(pl.dims.hidden == 1024 && pl.dims.layers == 28, "plan: config.json supplies the geometry"); + } + // 3. silent: neither answers, so the plan says the geometry is unknown instead of reporting zeros as facts. + { + const auto pl = pi::plan(write_pack("cg-silent", "", "")); + check(pl.container_geometry_source.empty(), "plan: the silent genre claims no source"); + check(pl.container_geometry_missing.size() == 8, "plan: every required field is reported missing, by name"); + check(pl.container_note.find("geometry is not known here") != std::string::npos, + "plan: the note says the geometry is unknown rather than printing a zero geometry"); + } +} + // engine#1786 (item F1): an NPU2 model source is a safetensors container, and this is the reader that decides whether // a pack is that genre. The failure that matters is the silent one -- a wrong header length yields an empty inventory, // which reads as "a pack with no tensors" rather than "a malformed header" -- so each arm asserts the reason, not just @@ -5551,6 +5618,7 @@ int main(int argc, char** argv) { test_text_config_geometry(golden_dir.empty() ? "." : golden_dir); test_q4nx_container(golden_dir.empty() ? "." : golden_dir); test_container_geometry(); + test_container_plan(golden_dir.empty() ? "." : golden_dir); test_hybrid_pack_import(golden_dir.empty() ? "." : golden_dir); test_rope_parameters_theta(golden_dir.empty() ? "." : golden_dir); test_three_input_matmulnbits(golden_dir.empty() ? "." : golden_dir);