From 67e35561143148fcb78f2a2ea486faea24ec0979 Mon Sep 17 00:00:00 2001 From: bong-water-water-bong Date: Tue, 10 Nov 2026 12:31:28 -0400 Subject: [PATCH] npu: two cold serves of one pack both finish writing the head image (per-process temp name) (engine#1716 follow-up) q4nx_head_image_write built every image under .tmp. Two serves that started cold on the same pack opened the same temp file: the second open truncated the first writer's file, and one of the two renames found nothing to rename. Nothing wrong was ever served (a short file fails its payload hash and is repacked), but a write was lost and a reader could meet a refused file. The temp name now carries the writer's pid, as the device-form copy next to it already does. Test: a two-process arm in npu_design_grid_test (40 writes each of a 4 MiB image on one path). Before: 3 of 3 runs fail with 2-5 lost writes per process; after: 10 of 10 runs clean. Co-Authored-By: Claude Fable 5.2 --- docs/npu.md | 6 +++-- npu/forward/src/q4nx_head_image.c | 14 ++++++++++- tests/npu_design_grid_test.c | 42 +++++++++++++++++++++++++++++++ 3 files changed, 59 insertions(+), 3 deletions(-) diff --git a/docs/npu.md b/docs/npu.md index 99af6263b..c0a43e334 100644 --- a/docs/npu.md +++ b/docs/npu.md @@ -287,8 +287,10 @@ image cache, P packed (W written for the next serve) in S s`. `ONEBIT_HEAD_IMAGE the cache off (nothing is read or written). The files are `kd × nd` bytes plus `nd` scales per tile, so a head costs about `kpad × vocabulary` bytes on disk per kernel set; nothing prunes them, the same as the device-form copies next to them. Ternary (`pb16i`) heads and the gemv head do not -use it: their image already is a file. The behaviour is pinned host-side in -`tests/npu_design_grid_test.c` with a counter on the gather. +use it: their image already is a file. Each writer builds the file under its own name +(`.tmp.`) and renames it into place, so two serves that start cold on the same pack both +finish their write and a reader only ever sees a whole image. The behaviour is pinned host-side in +`tests/npu_design_grid_test.c` with a counter on the gather and a two-process write arm. **Q8 has two code layouts under the same chunk size.** Qwen3.5-4B's lm_head (tied to the embedding) stores code (row r, column k) at byte `k*32 + r`. Qwen3.6-35B-A3B's Q8 tensors diff --git a/npu/forward/src/q4nx_head_image.c b/npu/forward/src/q4nx_head_image.c index 356505da0..33751e029 100644 --- a/npu/forward/src/q4nx_head_image.c +++ b/npu/forward/src/q4nx_head_image.c @@ -21,6 +21,9 @@ #include #include +#if !defined(_WIN32) +#include +#endif // "Q4HI" then the version as four ASCII digits, so a hexdump of the first eight bytes says what the file is. #define Q4NX_HEAD_IMAGE_MAGIC "Q4HI" @@ -68,8 +71,17 @@ int q4nx_head_image_write(const char *path, const int8_t *codes, const float *sc h.hash = q4nx_head_image_hash(codes, scales, kd, nd); // Written beside the destination and renamed into place: a truncated image must never be readable as a valid one, // because the reader would then copy it into a weight BO and the model would answer wrongly with no message. + // The temp name carries the writer's pid: two serves that start cold on the same pack write the same image at the + // same time, and with one shared name the second open truncated the first writer's file under it and one of the two + // renames found nothing to rename. Each writer now renames its own complete file; the last rename wins, and both + // files are the same image. char tmp[4096]; - if (snprintf(tmp, sizeof tmp, "%s.tmp", path) <= 0) return 0; +#if !defined(_WIN32) + const int tn = snprintf(tmp, sizeof tmp, "%s.tmp.%ld", path, (long)getpid()); +#else + const int tn = snprintf(tmp, sizeof tmp, "%s.tmp", path); +#endif + if (tn <= 0 || (size_t)tn >= sizeof tmp) return 0; FILE *f = fopen(tmp, "wb"); if (!f) return 0; int ok = fwrite(&h, sizeof h, 1, f) == 1 && fwrite(codes, (size_t)kd * (size_t)nd, 1, f) == 1 && diff --git a/tests/npu_design_grid_test.c b/tests/npu_design_grid_test.c index 92c9dc1be..c39539a75 100644 --- a/tests/npu_design_grid_test.c +++ b/tests/npu_design_grid_test.c @@ -32,6 +32,8 @@ #include #include #include +#include +#include #include #include @@ -599,6 +601,46 @@ static void test_head_image(void) { "head image: a truncated image is refused"); remove(path); } + /* (e) TWO WRITERS, ONE IMAGE. Two serves that start cold on the same pack write the same file at the same + * time. Each must end with a successful write and the path must read back intact after every one of them: + * with one shared temp name the second open truncated the first writer's file and one rename found nothing. */ + { + const int bk = 2048, bn = 2048; /* 4 MiB, so a write is long enough for the two to overlap */ + int8_t* big = malloc((size_t)bk * bn); + int8_t* big_back = malloc((size_t)bk * bn); + float* bsc = malloc((size_t)bn * sizeof(float)); + float* bsc_back = malloc((size_t)bn * sizeof(float)); + check(big && big_back && bsc && bsc_back, "head image: the two-writer fixture allocates"); + if (big && big_back && bsc && bsc_back) { + for (size_t i = 0; i < (size_t)bk * bn; i++) big[i] = (int8_t)((i * 31u + 7u) % 251u - 125); + for (int n = 0; n < bn; n++) bsc[n] = 0.001f * (float)(n + 1); + const char* shared = "head_image_two_writers.bin"; + remove(shared); + const int rounds = 40; + fflush(stdout); + const pid_t child = fork(); + if (child == 0) { + int bad = 0; + for (int i = 0; i < rounds; i++) bad += q4nx_head_image_write(shared, big, bsc, bk, bn) != 1; + _exit(bad > 255 ? 255 : bad); + } + int bad_w = 0, bad_r = 0; + for (int i = 0; i < rounds; i++) { + bad_w += q4nx_head_image_write(shared, big, bsc, bk, bn) != 1; + bad_r += q4nx_head_image_read(shared, big_back, bk * bn, bsc_back, bn, &info, why, (int)sizeof why) != 1; + } + int st = 0, bad_c = -1; + if (child > 0 && waitpid(child, &st, 0) == child && WIFEXITED(st)) bad_c = WEXITSTATUS(st); + check_int(bad_w, 0, "head image: with a second writer on the same path, every write of ours lands"); + check_int(bad_c, 0, "... and so does every write of the other process"); + check_int(bad_r, 0, "... and the path reads back intact after each of them"); + check(q4nx_head_image_read(shared, big_back, bk * bn, bsc_back, bn, &info, why, (int)sizeof why) == 1 && + memcmp(big, big_back, (size_t)bk * bn) == 0, + "... and what is left is the image both wrote"); + remove(shared); + } + free(big); free(big_back); free(bsc); free(bsc_back); + } } free(bt); free(codes); free(back); free(scales); free(sc_back); }