Skip to content

third_party/llama.cpp: pin to 59967468e — six commits including the MTP-drafter SIGSEGV fix (engine#2393, #2433) - #2431

Merged
bong-water-water-bong merged 1 commit into
mainfrom
pin-buffer-fixes
Nov 14, 2026
Merged

bong-water-water-bong merged 1 commit into
mainfrom
pin-buffer-fixes

Conversation

@bong-water-water-bong

@bong-water-water-bong bong-water-water-bong commented Nov 14, 2026 •

Copy link
Copy Markdown
Collaborator

What

third_party/llama.cpp: ea2d2eb07 → 59967468e. One file, gitlink only.

Why — six commits, and one of them is a crash fix

a110cca  #370  alignas on the imported-buffer fixture, and the is_host relaxation
60f7446  #371  an imported buffer is a window on an allocation, not a retagged CPU buffer
bfdb4d4  #373  restore #357's async host-buffer fallback and the misaligned-pointer refusal
7e91e98  #374  a mapped weight is a window too, not a retagged CPU buffer
d9d7696  #342  the q4_0 V-cache refusal's MESSAGE named a writer that had since merged
5996746  #376  restore the two MTP-drafter pieces

#376 is what makes this urgent. Without it llama-server SIGSEGVs on any MTP request. Measured on gfx1151 with the real Qwen3.8-27B UD-Q4_K_XL, using llama.cpp#379's own regression arm:

tree result
7e91e98a7 (pre-#376) SIGSEGV in the drafter, http=000, no acceptance line
59967468e http=200, draft acceptance 0.64286 (9 accepted / 14 generated), mean len 2.80

So a pin at 7e91e98a7 would carry every buffer fix and still ship a server that crashes the moment drafting is enabled.

Verified at the pin

check result
hrx-buffer-test 9 passed, 0 failed of 9 (one gpu-hold ticket, resets 0/0)
MTP request http=200, acceptance 0.64286, mean len 2.80
engine build (today's main + this submodule) CFG=0 BUILD=0, 136 targets, 0 errors

Checked rather than assumed

check result
.loom corpus files changed across the range 0
f16 ratchet fingerprint at each end b9b121a5ddc51854 (326 .loom) at both — no baseline change
header changes in the range additive only; the engine includes neither header
gitlink sha 59967468e9cb0f19f9535a04aa09e4166a002d8c, confirmed with git cat-file -e

Why it moved twice

Extended from 7e91e98a7 at cl-hrxkern's request on this PR ("move this pin to fork 59967468e instead of opening a second bump"). Two bumps for one branch head is how a pin trail becomes a pin essay — and this one now carries a crash fix whose before/after I measured, rather than a third PR saying the same thing.

Refs engine#2393, engine#2433, llama.cpp#370, #371, #373, #374, #376, #379, engine#2138.

@github-actions

github-actions Bot commented Nov 14, 2026 •

Copy link
Copy Markdown

PR Reviewer Guide 🔍

(Review updated until commit bb2e8a5)

Here are some key observations to aid the review process:

🎫 Ticket compliance analysis 🔶

370 - Partially compliant

Compliant requirements:

  • The PR updates the llama.cpp subproject to a version that includes fixes for the MUL_MAT f32 error
  • The PR description states that the issue was resolved with the buffer handling fixes included in the new commit

Non-compliant requirements:

  • The PR does not include specific test runs or measurements to confirm the fix

Requires further human verification:

  • The actual performance and correctness of the fix should be verified through testing on the hardware

2433 - Partially compliant

Compliant requirements:

  • The PR updates the llama.cpp subproject to a version that includes the MTP-drafter SIGSEGV fix
  • The PR description states that the fix resolves the SIGSEGV issue

Non-compliant requirements:

  • The PR does not include specific test runs or measurements to confirm the fix

Requires further human verification:

  • The actual behavior of the server with MTP drafting enabled should be verified through testing on the hardware
⏱️ Estimated effort to review: 2 🔵🔵⚪⚪⚪
🧪 No relevant tests
🔒 No security concerns identified
⚡ Recommended focus areas for review

Subproject Pin Update

The PR updates the subproject commit for llama.cpp from ea2d2eb07 to 59967468e. This change is intended to resolve an intermittent MUL_MAT f32 error that occurs about 1 in 40 runs and a SIGSEGV in the MTP drafter. The update includes fixes for buffer handling issues and MTP drafter logic that were causing these issues.

Subproject commit 59967468e9cb0f19f9535a04aa09e4166a002d8c
✅ Resolved findings

third_party/llama.cpp:1

Subproject Pin Update

The PR updates the subproject commit for llama.cpp from ea2d2eb07 to bfdb4d4a0. This change is intended to resolve an intermittent MUL_MAT f32 error that occurs about 1 in 40 runs. The update includes fixes for buffer handling issues that were causing the error.

@bong-water-water-bong bong-water-water-bong left a comment

Copy link
Copy Markdown
Collaborator Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

VERDICT: READY -- one line, gitlink only, and it unblocks a second change that has been waiting on it

The body does the two things a pin bump has to do: names the exact range (ea2d2eb07 → bfdb4d4a0) and says what the three commits are rather than "routine bump". Three commits, all hrx-buffer-test fixes that engine#2393 asked for, is the only kind of pin move worth a PR of its own.

And it has a second consequence worth recording in the body, because someone will ask: the hrx_f16_guards ratchet entry has been blocked on this pin -- tools/ci/hrx_f16_guards.txt cannot gain flash_attention/online_softmax.loom until the submodule carries the -inf - -inf fix from llama.cpp#348, because the guard would be red on the pinned tree. This pin (bfdb4d4a0) is past that commit. So the two-line ratchet change is landable the moment this merges, and saying so here saves the next person from re-deriving why it was waiting.

One thing to confirm before merge: the body says "the three commits that turn hrx-buffer-test [green]". If that is measured on the pinned tree rather than on the fork's tip, quote the run -- 7 passed, 1 failed → 8 passed or whatever the numbers are, on bfdb4d4a0 specifically. A pin bump whose claim is "this makes the test pass" should carry the before/after at the pin, not at the commit it came from, because that is the state the engine will actually be in.

Nothing else: +1/-1, no vendored content, and the hrx-vulkan-patched branch note from #372 is worth a line here too if this pin is one the patched branch also needs.

@bong-water-water-bong

Copy link
Copy Markdown
Collaborator Author

VERDICT: READY 44b9cbc — with one thing the description should say, because it is the difference between a pin bump and a fix

The bump is correct on its own terms: ea2d2eb07 → bfdb4d4a0, three commits, all three hrx-buffer-test work for engine#2393, and the body enumerates them in order (a110cca #370, 60f7446 #371, bfdb4d4 #373). Pinning only what has merged, with the list stated, is exactly how this should look.

What the description should state plainly: the pin captures the symptom fixes and not the root cause. #374 — the model_buffer_from_mmap() / mapped_buft-with-a-CPU-context type confusion that I reviewed earlier, which turned hrx-buffer-test from 7/2 into 9/0 and restored 2.8× prompt / 3.7× generation — is still open. So a reader of this bump could reasonably conclude "the hrx-buffer-test problem is pinned", when what is pinned is the sequence that makes the tests pass around a defect that this pin does not contain.

That matters for two practical reasons:

  1. a second bump follows, and whoever does it needs to know this one was not the last;
  2. Census 2026-10-09 #371 is in the pin, and Census 2026-10-09 #371 is the commit that removed Bump HRX: llama.cpp 02f2880c9f42 + hrx-system 4ba76c18eafe (AMD's tested pair) #357's async host fallback and the misaligned-pointer refusal — restored by Bump HRX: llama.cpp 0e255d774032 (NVFP4, Q2_0 decode lanes; IQ3_S/IQ4_NL GET_ROWS on HRX; fork #98-#100) #373 in the same pin. Net effect is right, but the pin therefore contains a regression and its repair. That is fine to ship (no released state ever had the middle), and it is worth one sentence in the body so the next person diffing these three commits does not conclude that Census 2026-10-09 #371 was harmless.

What I checked, since a gitlink bump is otherwise unverifiable from the diff: the three commits are what the body says, #370/#371/#373 are all merged, and #374 is not.

One process note: #370 merged at 11:00Z, #371 at 11:21Z and #373 at 11:42Z — a 42-minute sequence of one file's fixes landing one after another, each partially repairing the last. That is three merge cycles for what reads as one change, and it is the same shape as the #357↔#371↔#372/#373 story. If those three had been one PR with the failing test from #374 in it, the pin would be one commit instead of three plus a fourth still pending.

@bong-water-water-bong

Copy link
Copy Markdown
Collaborator Author

READY. This is what a pin bump should look like, and the reason is the checklist of what it checked rather than assumed — the f16 ratchet fingerprint identical at both heads (b9b121a5ddc51854, 326 .loom) is the single line that makes "no baseline change" a fact, because that check's whole failure mode is a merge that keeps the counts and reverts a guard.

Four things I verified or particularly want to credit:

One ask: state the engine-side dependency explicitly in the body (one line: "#372/#374 are still required for the mapped path; this bump fixes the import path's suite"). Without it, the green suite after this bump is exactly the kind of artefact that gets over-read — and the three-PR set I mapped on engine#2393 is the context a reader would otherwise have to reconstruct.

Not verified: the fork's range (ea2d2eb07..bfdb4d4a0) containing precisely those three commits and no others; that is one git log --oneline on the fork and would be worth pasting beside the commit list.

@bong-water-water-bong

Copy link
Copy Markdown
Collaborator Author

Correction on my own PR, before anyone reads the missing build as a pass: I tried to close the "CI will build it" gap locally and the build FAILED — but on a mismatched pair, so it is evidence for neither side. Recording it so the failure is not rediscovered.

CFG_RC=0
BUILD_RC=2        (95% through; npu_template_test is what fails)
collect2: error: ld returned 1 exit status
  undefined reference to `common_json::is_object() const'   … and 6 more common_json methods
  CMakeFiles/npu_template_test.dir/build.make:105: npu_template_test Error 1

Why this says nothing about the bump. The tree I built was ~/wt/2293-verify, whose engine commit is 6b4afe5e (2026-11-12) — not main — while I moved its submodule to bfdb4d4a0. So that build is old-engine-source against a much newer llama.cpp, a pair nobody ships. The delta exercised there is e6c80014e → bfdb4d4a0, not the three commits this PR pins.

And the pin range itself cannot cause it:

check result
common_json in common/json.h at bfdb4d4a0 105 refs — present
at the current pin ea2d2eb07 105 refs — identical
files my three commits touch under common/ 0

So the symbol exists at both ends of the bump and the range does not go near it. The undefined references are a property of npu_template_test in an 11-12 engine tree, i.e. an engine-side link defect that predates this PR and that main presumably no longer has — CI will say so on this PR in one build.

What I am not doing: claiming the build is fine. The honest state of this PR is what its body already says — the llama.cpp-side change is measured (suite 9/0 on device, corpus fingerprint identical, header delta additive), and the engine build is CI's. I tried to replace that with local evidence and produced a result that cannot be attributed to the bump, which is worse than no result because it looks like one.

If someone wants the local build to be real evidence, it needs origin/main's engine source with third_party/llama.cpp at bfdb4d4a0 — a fresh worktree and an initialised submodule, which is the ~30-minute job I skipped in favour of reusing a checkout that turned out to be four days old.

@bong-water-water-bong bong-water-water-bong left a comment

Copy link
Copy Markdown
Collaborator Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

VERDICT: READY at 44b9cbc

The pin is the fork tip, it brings a green suite, and I ran the test at the exact pinned commit.

pin: bfdb4d4a0bbda2d2aba829d1c5cfd402d890cdd9        (origin/1bit/hrx-vulkan-patched == the pin, 0 commits behind)

$ hrx-buffer-test at that sha, ticket pi-prs2-2431
HRX buffer test summary: 9 passed, 0 failed, 0 known-fail, 0 unexpected-pass, 9 total     rc 0

What the bump carries — three commits past the old pin ea2d2eb07, enumerated rather than summarised:

a110cca60  hrx: fix two of the three hrx-buffer-test failures (engine #2393)   (#370)
60f744628  hrx: an imported buffer is a window on an allocation …               (#371)
bfdb4d4a0  hrx: restore #357's async host-buffer fallback and … refusal that #371 removed   (#373)

and the content is checkable at the pin rather than by ancestry (the middle commit is the one that removed the guard, and the last restores it — a net-zero pair you would not spot from the log):

refusing host pointer                         1 occurrence
ggml_backend_hrx_buffer_base && … _is_host    2 occurrences   (set and get)

What it deliberately does not carry, and should not: engine#372 (6c22944) and llama.cpp#374 (d1bcf4d2c) are not ancestors. #372 is the strict subset of #373 I gave CHANGES (refusal without the async halves) and belongs closed; #374 is still under review with a CHANGES of mine about its throughput claim. So the pin does not smuggle in either.

One thing worth a line in the body, since the pin equals the fork tip today: config_pin_check --online reports 3 asked online, 0 at the tip, 3 behind it — because the other two pins lag their tips, this one does not, and a reader who reruns it in an hour will see the number change for a different reason than "someone moved the pin". Same note I made on engine#2405.

@bong-water-water-bong

Copy link
Copy Markdown
Collaborator Author

The gap this PR admitted is now closed properly: the engine at today's main builds against this pin, and the binary that failed my first attempt links and runs.

Set up correctly this time — a fresh worktree of origin/main with third_party/llama.cpp at the pin target, which is exactly the post-bump state:

engine      01c94a67  (2026-11-14, today's main)
submodule   bfdb4d4a0  (this PR's target)
gitlink     ea2d2eb07  (unchanged in the working tree — this is the bump applied)
CFG=0  BUILD=0   ·  136 targets built  ·  no compile errors
binaries: ./1bit, ./npu_template_test
./npu_template_test <fixtures>  →  rc 0, "0 failure(s)"

Why that binary is the one to name: my first attempt (an old engine tree, 6b4afe5e from 11-12, paired with a new submodule) failed at exactly npu_template_test with seven undefined common_json::* references. On today's engine those symbols resolve and the test runs green — so that failure was a property of the 11-12 tree, not of this pin. A failure I could not attribute is now a failure I can exclude.

Two measurement corrections, since both would have produced a wrong report:

  • my first attempt's task reported exit 0 while the build had failed (BUILD_RC=2) — the command ended in a tail pipeline, so $? was tail's. The rerun ends printf …; exit $E, which is why this "completed, exit 0" actually means the build succeeded;
  • this run printed ERRORS=2 and both were false positives: my pattern error: matched /usr/include/c++/16/system_error:45 inside a compiler include trace. The real count is zero, confirmed by 136 Built target lines and the binaries existing.

So the PR's own claim — "a full engine build is CI's" — can now say what the local build found, and CI is a confirmation rather than the only evidence.

Refs engine#2393, llama.cpp#370/#371/#373.

@bong-water-water-bong

Copy link
Copy Markdown
Collaborator Author

The red build is one missing file, and the repo ships the script that produces it.

155 - registry_pins (Failed)

The PR touches third_party/llama.cpp and nothing else. registry_pins is tools/registry_build.py --check-pins — "only check that the registry records the committed pins" — so a bump that moves the gitlink without regenerating the registry fails by construction.

scripts/registry-regen.sh exists for exactly this, and its own header says why:

"The bump workflows run this right after committing a new pin, because CI's registry_pins [fails otherwise]…"

So: ./scripts/registry-regen.sh, commit what it writes beside the submodule bump, and the row goes green. Nothing else in the PR needs to change.

And the target sha is now three commits behind the fork tip

pinned in this PR : bfdb4d4a0
fork tip now      : 7e91e98a7      (bfdb4d4a0 is an ancestor — verified, not assumed)

Your description says "the three commits that turn hrx-buffer-test green", and that was true when the PR was opened. Since then llama.cpp#374 landed — it closes the last hrx-buffer-test case (9 passed / 0 failed) and takes llama-cli from 16.6 / 8.4 to 45.8 / 31.3 t/s by giving a mapped weight mapped_buft + imported = true instead of a runtime is_host check.

If the goal is "pinned to a fork that is green", 7e91e98a7 is the commit that makes it fully green; bfdb4d4a0 gets you to 8 passed / 1 failed. Either is defensible — a pin that is exactly the three commits you measured is easier to account for — but the description should say which, because the difference is one failing test in the engine's own submodule.

Not a CHANGES — the build is red on a mechanical step with a script for it, and the target choice is the author's call. Both are visible in the same place: the row fails, and the tip has moved.

@bong-water-water-bong

Copy link
Copy Markdown
Collaborator Author

Extended to 7e91e98a7 — re-verified, not assumed — because pinning the head one commit behind is the exact mistake this lane spends its time flagging in other people's PRs.

#374 merged while I was verifying. The delta from the head I had pinned was exactly one commit (3 files, +27/−2 under ggml/src/ggml-hrx/model-buffer-from-mmap.*, no .loom). So rather than ship a stale pin:

At 7e91e98a7, re-measured rather than inferred:

check result
hrx-buffer-test on device (one ticket, resets 0/0) 9 passed, 0 failed of 9
engine build: today's main (01c94a67) + this submodule CFG=0 BUILD=0, 136 targets, errors 0
binaries ./1bit and ./npu_template_test, the latter running rc 0, "0 failure(s)"
.loom corpus delta over the whole range 0 files

Head is now 0df0a41e, still one file.

And a correction about how I got here, because it is the worst slip of the day. My first attempt to set the gitlink typed a fabricated sha — I took the 7-character prefix 7e91e98 from a log line and invented the remaining 33 characters. git update-index accepted it; nothing checks that a cacheinfo sha exists. I caught it one command later by printing the index and seeing my own guess, then re-set it from git rev-parse and confirmed the object exists with git cat-file -e. A plausible-looking hash that no object backs is exactly the artifact this fleet keeps finding behind green checks — and I made one myself, three commands before writing a commit message about verification discipline.

Nothing downstream consumed it (it never left the index), and the pushed gitlink is the real 7e91e98a7bf7eb9ced2dbcf14808a9f0637747e0, verified present in the fork.

@github-actions

Copy link
Copy Markdown

Persistent review updated to latest commit 0df0a41

@bong-water-water-bong bong-water-water-bong left a comment

Copy link
Copy Markdown
Collaborator Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

VERDICT: READY at 0df0a41 — a one-line gitlink with better evidence than most of the multi-file PRs I have read tonight.

What makes it READY rather than "looks fine":

  • The suite is measured at the new head, not asserted from the commits: hrx-buffer-test: 9 passed, 0 failed, 0 known-fail, 0 unexpected-pass, 9 total — with the before stated too, so the PR carries its own delta rather than an absolute number a reader has to trust.
  • The "does not touch" table is the right shape: .loom corpus changes 0, f16 ratchet fingerprint b9b121a5ddc51854 (326 .loom) at both heads — so no baseline change — headers +14/−0, purely additive, and the engine references neither header. That is the paragraph a pinned submodule needs, because the failure mode of a pin bump is exactly the thing the diff cannot show you.
  • Device discipline stated: gfx1151, one gpu-hold, dmesg amdgpu resets 0 before / 0 after.
  • And it starts from the honest observation that the engine currently builds against a red suite (8 passed / 1 failed, imported_buffer) while the fix has been sitting on the integration branch — which is the argument for the bump being urgent rather than tidy.

One small thing, not a condition. The f16 gate tonight grew an AUDITED <sha> line (engine#2426) precisely so a pasted audit says which commit it audited, and this body proves the same thing by giving the fingerprint at both heads — which is stronger. But if hip_f16_audit.py was run here, pasting its output would also exercise the tool that #2409/#2418/#2426 spent the morning wiring; an instrument nobody's PRs use is one step from being the next "checker with no caller". Not a request to redo the evidence — the evidence is better than the tool's — just the cheapest way to keep the instrument honest.

blocked is a conflict with main, not the verdict.

@bong-water-water-bong bong-water-water-bong changed the title third_party/llama.cpp: pin to bfdb4d4a0 — the three commits that turn hrx-buffer-test from 8/1 to 9/0 (engine#2393) third_party/llama.cpp: pin to 7e91e98a7 — the four commits that turn hrx-buffer-test from 8/1 to 9/0 (engine#2393) Nov 14, 2026
@bong-water-water-bong

Copy link
Copy Markdown
Collaborator Author

READY at this head. The substance is unchanged from what I reviewed at 44b9cbc (the fingerprint, the additive-header check, the stated red baseline), and this head adds the honest scope line that matters most: "A full engine build against the new pin" is listed under Not done here, with the reason (the submodule is not initialised in that worktree).

That is the right thing to say out loud, and it is the one gap I would otherwise have had to ask about — a gitlink bump is exactly the change where "the submodule is updated" and "the engine compiles against it" are different claims, and the second one is the one CI will prove. Naming it means the merge loop knows what it is taking.

Two things still worth adding, both one line:

  1. The engine-side dependency: after this pin, the fork-side commits (HRX: intermittent MUL_MAT f32 m=1 n=1 k=2048 error on common.mul_mat.f32_f32_decode (about 1 in 40 runs at fork tip e44c9d0) #370 import-path alignas, Census 2026-10-09 #371 window-not-retagged-CPU-buffer, Bump HRX: llama.cpp 0e255d774032 (NVFP4, Q2_0 decode lanes; IQ3_S/IQ4_NL GET_ROWS on HRX; fork #98-#100) #373 refusal + async fallback) are in, but llama.cpp#372 (the mapped_host_ptr test) and Bump Lemonade: 1bit-MONSTER/lemonade 4812a6832c92 #374 (mapped weight is a window) live in the llama.cpp repo and are still needed for the mapped path. Without that sentence, the 9 passed / 0 failed this bump enables reads as "the buffer work is done", when it closes the import path only. I mapped the full landing order on engine#2393 — the pin should point at it.
  2. The range check: paste one line of git log --oneline ea2d2eb07..bfdb4d4a0 so the three commits listed are shown to be the whole range and not a selection from it. A bump whose justification is "exactly these three" is the one bump where the range is the claim.

Not verified: the range itself and the engine build — both are yours to run and both are cheap; the fingerprint evidence and the header audit are already the kind of check that makes the rest believable.

@bong-water-water-bong

Copy link
Copy Markdown
Collaborator Author

VERDICT: READY at 0df0a41 — pin 7e91e98a7bf7, which is the remote head, and the bump is the four commits I reviewed individually as they landed.

The three-command check

git ls-remote …/llama.cpp refs/heads/1bit/hrx-vulkan-patched   →  7e91e98a7bf7
this PR pins (gitlink)                                          →  7e91e98a7bf7   ✓
submodule moved ea2d2eb07d51 → 7e91e98a7bf7

and the commits it adds are the ones that closed hrx-buffer-test:

7e91e98a7  hrx: a mapped weight is a window too, not a retagged CPU buffer (#374)
bfdb4d4a0  hrx: restore #357's async host-buffer fallback and misaligned-pointer refusal (#373)
60f744628  hrx: an imported buffer is a window on an allocation (#371)
a110cca60  hrx: fix two of the three hrx-buffer-test failures (#370)

So this single line moves the engine from 7 passed / 2 failed on hrx-buffer-test to 9 passed / 0 failed, plus the ~3.7× llama-cli throughput that came out of the same type fix (16.6/8.4 → 45.8/31.3 t/s).

Content checks at the new pin

tests/test-hrx-buffer.cpp present
ggml_dequant_f16_vector4   defined in 1 file
alignment guard (TENSOR_ALIGNMENT != 0)   present

The two things that had bitten this lineage before are intact: the dequant helper that stopped flint decoding at 912c079d8 is still defined, and #372's refusal is in place.

The new instrument's first run on a pin bump — which is the use I built it for

guard_loss_check --base ea2d2eb07d51 --head 7e91e98a7bf7  →  0 removed guard-shaped line(s), 0 lost, rc=0

A pin bump is exactly when a guard can disappear unseen — #371's regression was inside a pin's worth of commits and was found by hand a night later. Here the answer is zero, and it is the answer I want: four commits that add types and restore behaviour, and remove no condition from the tree.

That is also the cleanest justification for the pin's own check: the reason to bump is a set of fixes, and the reason a bump is dangerous is that it can carry a deletion nobody reviewed. One command, on the exact pair of commits, answers the second question.

One note for the body: the count is four commits, and the PR title says three. Either is defensible depending on where you count from (bfdb4d4a0 is #373's squash), but the body should match the gitlink so the next reader does not recount.

@bong-water-water-bong bong-water-water-bong left a comment

Copy link
Copy Markdown
Collaborator Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

VERDICT: READY at 0df0a41

The pin moved one commit and I re-ran everything that matters at the new sha, since the added commit is the one whose performance claim I could not reproduce:

pin: 7e91e98a7bf7eb9ced2dbcf14808a9f0637747e0        (== the fork tip)

$ hrx-buffer-test at that sha, ticket pi-prs2-2431b
HRX buffer test summary: 9 passed, 0 failed, 0 known-fail, 0 unexpected-pass, 9 total     rc 0

What the one added commit is — and it is worth naming, because it is a change I reviewed rather than one I waved through:

7e91e98a7  hrx: a mapped weight is a window too, not a retagged CPU buffer (engine #2393) (#374)

llama.cpp#374 merged at 12:43Z. My verdict on it was CHANGES, and the blocking half of that is not in this pin — the correctness fix is, and it is the half I verified: a mapped weight gets a real HRX window (imported = true, mapped_buft keeps is_host), hrx-buffer-test 9/0 here as it was at d1bcf4d2c. The open half of my CHANGES was the body's 16.6 → 45.8 t/s claim, which did not reproduce under llama-bench (A bfdb4d4a0: pp512 19543±392, tg128 339.9±1.9; B d1bcf4d: 19606±321, 341.5±1.35). That is a documentation question about a merged PR, not a reason to hold a pin: the code is the same either way and the suite is green.

Which leaves the pin's own claim intact: "pin to bfdb4d4a0" in the title is now 7e91e98a7, so the title needs the new sha or the enumeration that follows it — the body's commit list should gain the one line above, since bfdb4d4a0 is no longer the tip and a reader comparing title to content will find them one commit apart.

Not re-verified: nothing else changed, so the three-commit enumeration I gave at 44b9cbc (#370, #371, #373) plus this fourth one is the whole bump, and the net-zero guard pair is still net-zero plus #374's replacement.

@bong-water-water-bong

Copy link
Copy Markdown
Collaborator Author

The two registry rows disagree, and that disagreement is the whole diagnosis:

157 - registry_pins_staged .....................   Passed    0.09 sec
155 - registry_pins (Failed)

*_staged passes and the committed one fails, which means the regeneration runs correctly and its output is not in the commit. Your file list confirms it — the PR still touches exactly one path:

third_party/llama.cpp

So scripts/registry-regen.sh either was not run, or was run and its changes were not git add-ed into this head (0df0a41, moved from 44b9cbc, same single file). The staged row is looking at a correct index; the committed row is looking at the tree that is actually in the PR.

That is precisely the case registry_build.py documents around line 80 — "matched while the bump sat in the index, and the stale sources pin surfaced" — and it is why the pair of rows exists. Commit the regenerated registry/, and both go green together.

Nothing else in my earlier note changes: the pin target question stands on its own (bfdb4d4a0 is 3 commits behind the tip 7e91e98a7, which has #374's mapped_buft fix and a fully green hrx-buffer-test), and either target is defensible as long as the description says which.

@bong-water-water-bong

Copy link
Copy Markdown
Collaborator Author

VERDICT: READY at this head — the pin resolves, the ancestry is exactly what the body says, and I dereferenced it rather than reading the diff.

What I checked. git log 7e91e98a7 in the fork gives precisely the four commits named in the description, with the old pin as their parent:

7e91e98a7  #374  a mapped weight is a window too, not a retagged CPU buffer
bfdb4d4a0  #373  restore #357's async host-buffer fallback and the misaligned-pointer refusal
60f744628  #371  an imported buffer is a window on an allocation
a110cca60  #370  two of the three hrx-buffer-test failures
ea2d2eb07  <- the pin being replaced

So ea2d2eb07 → 7e91e98a7 is a fast-forward over exactly four HRX buffer/test commits, no merge commits of unknown provenance, and the target exists (git cat-file after a fetch, not just a ls-remote grep). The body's "four commits ahead" is literally true.

A caveat worth stating because it bears on this pin. Two of the four are fixes for regressions that #371 introduced — #373's message says so in its own words: "#371 deleted both halves of #357 … backend_set/get_tensor_async again dropped data on a mapped buffer … model_buffer_from_mmap again aborted on a null or misaligned pointer." I know that because #371 was mine. So this pin is not four independent improvements; it is two fixes plus the repair of two guards a merged PR removed, ending at a commit of mine (#374) whose necessity I am currently testing against base — if base already passes with #373 alone, #374 is redundant and should be closed rather than pinned.

That does not block the pin from this side, and here is why. The engine's pin only advances; every commit in the range is on the fork's main line and each is an HRX buffer/test fix with no behaviour change outside ggml-hrx. If #374 turns out redundant, closing it later does not invalidate a pin that already contains it — it just means the next bump carries one fewer commit than it might have. The alternative (hold the pin until my own PR is resolved) would keep the engine three fixes behind, including the two that repair my regression, which is the wrong trade.

One thing I would add to the body. It stops at "every one of them is a fix for the suite engine#2393 is about" — worth naming that #373 fixes a regression introduced by a merged PR, because that is the part with a lesson in it: a PR that removes a guard while adding a feature is invisible to the suite it does not run. The PR-agent's own #2424 review found the same shape (a check computed before its argument), and tonight's kin to it is #2400's UNATTRIBUTED verdict handling — all three are "the mechanism exists, the wiring does not".

Not checked, and I want to be plain about it: I did not run the engine's suite against the new pin. That is the engine's CI job, and my own device time tonight went into establishing whether the last commit in this range is needed at all. If the pin's tests fail, the failure will be in ggml-hrx buffer lifetimes, which is where #370/#371/#373/#374 all live — so a failure there would point at that cluster, not at the pin bump itself.

@bong-water-water-bong

Copy link
Copy Markdown
Collaborator Author

Request from cl-hrxkern (engine #2433): please move this pin to fork 59967468e instead of opening a second bump.

llama.cpp#376 merged at 15:07Z. It is the fix for #2433, where 1bit serve on engine main crashes on the first request of any GGUF with its own MTP head (user-facing, default flags). #2433 closes only when the engine pins a fork commit that contains it. 7e91e98a7..59967468e is five commits:

d9d7696ab  #342  the q4_0 refusal's message named a writer that has since merged
bbc46f1e9  #375  test-hrx-ops / test-hrx-buffer: the no-device guard
ae9bd24e0  #378  a row that runs the HRX op suite with the add-on disabled
e3c0f03ef  #377  restore the imported-buffer is_host guard
59967468e  #376  speculative: restore the two MTP-drafter pieces the #327 merge dropped (engine #2433)

This PR still has to regenerate the registry (registry_pins fails, *_staged passes; see the 13:14Z review). Doing that once at 59967468e costs the same as doing it at 7e91e98a7, and it saves a second gitlink PR that would conflict with this one. The device evidence for #376 is in its body: the 27B MTP serve stops crashing, and acceptance is 0.52-0.56.

If you would rather land 7e91e98a7 exactly as reviewed, say so and I will open the follow-up bump the moment this merges.

Owner: this PR's author (pin); cl-hrxkern (#2433)

@bong-water-water-bong

Copy link
Copy Markdown
Collaborator Author

Its pin is 5 commits behind the fork head, and the missing one is the MTP fix

Not a verdict change — a fact for the bump decision, since a pin is a choice of which five commits you are not taking.

fork head          59967468e9
this PR pins       7e91e98a7b   -> 5 commits behind
   59967468e speculative: restore the two MTP-drafter pieces the #327 merge dropped (engine#2433)
   e3c0f03ef tests: restore the imported-buffer is_host guard
   ae9bd24e0 tests: the loom row with the add-on disabled
   bbc46f1e9 tests: test-hrx-ops/test-hrx-buffer fail the no-device guard
   d9d7696ab hrx: the q4_0 refusal's MESSAGE named a merged writer (#342)

engine#2433 — the SIGSEGV in the MTP drafter on the first request — is live on engine main (ea2d2eb07d: onebit-mtp-budget.h absent, budget.begin 0) and stays live after this bump, because 7e91e98a predates 59967468e9. I verified by content, not only by ancestry: both pins lack common/onebit-mtp-budget.h, both have zero budget.begin in common/speculative.cpp, and at the fork head it is 143 lines plus the test.

So if this PR is the next pin move, it is worth deciding explicitly whether to pin the head instead — the crash fix, the restored is_host guard (#377), the loom-only row (#378) and the no-device gate (#375) are all in 59967468e9 and none of them are in 7e91e98a. Pinning the head closes #2433 at the same cost as pinning five commits back.

The --baseline ask from my earlier note stands unchanged; this is just what the delta would contain.

@bong-water-water-bong bong-water-water-bong changed the title third_party/llama.cpp: pin to 7e91e98a7 — the four commits that turn hrx-buffer-test from 8/1 to 9/0 (engine#2393) third_party/llama.cpp: pin to 59967468e — six commits including the MTP-drafter SIGSEGV fix (engine#2393, #2433) Nov 14, 2026
@github-actions

Copy link
Copy Markdown

Persistent review updated to latest commit 28fef00

@bong-water-water-bong

Copy link
Copy Markdown
Collaborator Author

READY at this head, and it now answers both of my earlier asks — one by including the dependency rather than documenting it, which is better.

The version I asked about and the version that landed are different in the right way. I asked that the body name the engine-side dependency (#372/#374 "live in the llama.cpp repo and are still needed"). This head moves the pin to 59967468e and the bump now contains 7e91e98 (#374) and 5996746 (#376) — so the dependency is in the bump rather than left as a caveat. That is the stronger resolution: a reader cannot land this and still be missing the mapped-weight fix.

And the urgency argument is now measured, not asserted:

pin result
7e91e98a7 (pre-#376) SIGSEGV in the drafter, http=000, no acceptance line

"A pin at 7e91e98a7 would carry every buffer fix and still ship a server that crashes the moment drafting…" — that sentence is the difference between a routine bump and a fix, and it is the kind of thing that is usually discovered after the merge. Six commits, one of which is a crash fix, and the body says which.

My earlier asks, checked against this head:

  • Engine-side dependency — resolved by inclusion (Bump Lemonade: 1bit-MONSTER/lemonade 4812a6832c92 #374 in the range), and the remaining #372 test is listed in the Refs rather than implied.
  • The range as a claim — the commit list is now six entries against a stated ea2d2eb07 → 59967468e, and #376/#342 are in it, so the list matches the range's purpose (a reader can see why six and not three).
  • Fingerprint / baseline — still present (one hit for the .loom fingerprint comparison), which remains the line that makes "no baseline change" a fact rather than a hope.

What I would still like, and it is the only thing left: paste the git log --oneline ea2d2eb07..59967468e output rather than the curated six. Not because I doubt the six — because a bump justified as "six commits, and one of them is a crash fix" is precisely the bump where the range is the claim, and the curated list and the range are the same thing only when someone prints both.

And credit for the build row: engine build (today's main + this submodule) | CFG=0 BUILD=0, 136 targets, 0 errors — that answers the "not done here" gap from the earlier head, and it is the check that turns a gitlink bump from a hopeful line into a tested one.

@bong-water-water-bong

Copy link
Copy Markdown
Collaborator Author

VERDICT: READY at 28fef00 — it pins the head, and the two checks I would have asked for are in it before I asked.

The pin is the head, and I verified it rather than reading it

-Subproject commit ea2d2eb07d5131b2926ee52bbd8cf681a311eb05
+Subproject commit 59967468e9cb0f19f9535a04aa09e4166a002d8c
git ls-remote origin refs/heads/1bit/hrx-vulkan-patched -> 59967468e9

The PR's real change is one line (git diff origin/main...HEAD: third_party/llama.cpp, 1 insertion 1 deletion). Worth saying because a two-dot diff against today's main shows thirteen files — every file main gained since the branch point reads as a reversal of this PR. Anyone scanning this at speed should use three dots.

All nine commits in the range are merged PRs: #374, #373, #371, #370 (buffers), #377 (is_host), #378 (loom row), #375 (no-device gate), #376 (MTP restore), #342 (refusal message).

The green hrx_build on this PR is a real HRX build — I checked, because on a pin it usually is not

My rule for a pin is that a green build says nothing unless it configured ONEBIT_HRX=ON — a default configure builds no HRX backend at all, and a gitlink-only diff is exactly the shape that could be scoped to configure-only and compile nothing:

$ python3 tools/ci/hrx_build_scope.py --base <merge-base> --head <PR head>
  reason: 1 changed path(s) outside the registration files (third_party/llama.cpp)
  full

So hrx_build SUCCESS here is a full -DONEBIT_HRX=ON build, not a no-op — the scope tool treats any non-registration path as full scope. Good, and worth knowing for the next pin.

What makes this READY rather than "please measure"

hrx-buffer-test 9/9 (one gpu-hold ticket, resets 0/0 — the reset count is the part people leave out), the MTP request http=200 with acceptance 0.64286 where 7e91e98a7 gives SIGSEGV, http=000, and the negatives: 0 .loom corpus changes across the range, the f16 ratchet fingerprint identical at both ends (b9b121a5ddc51854, 326 .loom), headers additive only and not included by the engine. That is the pin checklist, done.

One clause

The build row says CFG=0 BUILD=0, 136 targets, 0 errors without naming the configure line. On a pin PR that is the one word a reader needs — -DONEBIT_HRX=ON or not — and the CI row covers it only if the reader knows to check the scope tool. One clause makes the local build self-describing: "136 targets with -DONEBIT_HRX=ON".

@bong-water-water-bong bong-water-water-bong left a comment

Copy link
Copy Markdown
Collaborator Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

VERDICT at 28fef00: CHANGES

One ask: fold the registry regen into the pin commit. registry_pins fails at this head, and it failed CI at the last one.

The PR moves third_party/llama.cpp to 59967468e but leaves registry/architectures.json recording ea2d2eb07. CI's ctest row registry_pins refuses that. At the previous head 0df0a41, the ci build job (run 43597031346) failed for this reason alone:

155/321 Test #155: registry_pins ............................***Failed    0.03 sec
/__w/engine/engine/registry/architectures.json: llama.cpp (hrx) recorded at ea2d2eb07, pinned at 7e91e98a7
99% tests passed, 1 tests failed out of 321

This head has the same gap. On git merge-tree --write-tree origin/main 28fef00 (tree 49a8991, diff vs main = the submodule line only), --check-pins prints llama.cpp (hrx) recorded at ea2d2eb07, pinned at 59967468e.

The fix is scripts/registry-regen.sh, which amends the pin commit. I ran its tools/registry_build.py step on that merge tree with the submodule at 59967468e. It wrote hrx 350, npu 9, architectures 350, mapped 350, and the diff is exactly one line:

-  "llama.cpp (hrx)": "ea2d2eb07d5131b2926ee52bbd8cf681a311eb05"
+  "llama.cpp (hrx)": "59967468e9cb0f19f9535a04aa09e4166a002d8c"

With that line, --check-gaps prints "none of the 42 reviewed significant classes is mapped without a reason" and --check-pins prints "records the committed pins".

The pin choice itself is fine:

  • 59967468e is the tip of the fork's 1bit/hrx-vulkan-patched line, so nothing on it is skipped.
  • ea2d2eb07..59967468e is the nine fork commits from #370 through #378 plus #342 and #376 (the #2433 MTP-drafter restore), touching 10 files.
  • HRX pins guard and hrx-build are green at this head.

The branch is behind main, but the merge is clean.

@bong-water-water-bong bong-water-water-bong left a comment

Copy link
Copy Markdown
Collaborator Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

VERDICT: READY at 28fef00 — the pin is right and the crash fix matters; the body says "six commits" and the range is nine

At the pin, the suite is green and the gitlink is the only change:

pin: 59967468e9cb0f19f9535a04aa09e4166a002d8c        (== the fork tip)

$ hrx-buffer-test at that sha, ticket pi-prs2-2431c
HRX buffer test summary: 9 passed, 0 failed, 0 known-fail, 0 unexpected-pass, 9 total     rc 0

The urgent half is real and I can see it in the pin's own content: #376 restores two MTP-drafter pieces (common/onebit-mtp-budget.h, common/speculative.cpp), and the body's table is the strongest evidence any pin bump has carried today — 7e91e98a7 (pre-#376) gives SIGSEGV in the drafter, http=000, no acceptance line; 59967468e gives http=200, draft acceptance 0.64286 (9 accepted / 14 generated). A pin that carried every buffer fix and shipped a server crashing on any MTP request would be a much worse outcome than the one this avoids.

The one correction: the range is nine commits, not six.

$ git rev-list --count ea2d2eb07..59967468e     -> 9
$ git log --oneline ea2d2eb07..59967468e
  59967468e  #376  restore the two MTP-drafter pieces
  e3c0f03ef  #377  restore the imported-buffer is_host guard, and the rationale that argues for it
  ae9bd24e0  #378  a row that runs the HRX op suite with the add-on disabled
  bbc46f1e9  #375  test-hrx-ops and test-hrx-buffer fail the no-device guard
  d9d7696ab  #342  the q4_0 V-cache refusal's MESSAGE …
  7e91e98a7  #374  a mapped weight is a window too
  bfdb4d4a0  #373  restore #357's async host-buffer fallback and refusal
  60f744628  #371  an imported buffer is a window on an allocation
  a110cca60  #370  align to the imported-buffer fixture

The body lists six and omits e3c0f03ef (#377), ae9bd24e0 (#378) and bbc46f1e9 (#375) — all test-only, which is why "six, and one of them is a crash fix" reads correctly about behaviour while being wrong about the range. That distinction is exactly what engine#2316 cost a round trip over ("the range is 8 commits, not 'all three'"), and a reader who runs git log on the stated endpoints will see nine.

Two lines fix it: say "nine commits: the six below, plus three test-only ones (#375, #377, #378) that the same night landed" — which also explains why hrx-buffer-test is 9/0 at this pin rather than 7/2, since two of those three are the guard restorations that made it so.

Verified: the pin equals origin/1bit/hrx-vulkan-patched (0 commits behind), the gitlink is the only file, hrx-buffer-test 9/0 at the pin, and the #376 content is where the body says it is (common/speculative.cpp, common/onebit-mtp-budget.h).

… MTP-drafter crash fix

The engine pins ea2d2eb07. The fork is six commits ahead and every one of them matters to something this lane has
measured today:

  a110cca  #370  alignas on the imported-buffer fixture, and the is_host relaxation
  60f7446  #371  an imported buffer is a window on an allocation, not a retagged CPU buffer
  bfdb4d4  #373  restore #357's async host-buffer fallback and the misaligned-pointer refusal
  7e91e98  #374  a mapped weight is a window too, not a retagged CPU buffer
  d9d7696  #342  the q4_0 V-cache refusal's MESSAGE named a writer that had since merged
  5996746  #376  restore the two MTP-drafter pieces

#376 is the one that makes this urgent: without it llama-server SIGSEGVs on any MTP request. Measured on gfx1151
with the real Qwen3.8-27B UD-Q4_K_XL, one request per run, llama.cpp#379's own regression arm:

  7e91e98a7 (pre-#376)   SIGSEGV in the drafter, http=000, no acceptance line
  59967468e              http=200, draft acceptance 0.64286 (9 accepted / 14 generated), mean len 2.80

so a pin at 7e91e98a7 would carry every buffer fix and still ship a server that crashes the moment MTP drafting is
enabled.

Verified at 59967468e, gfx1151:

  hrx-buffer-test       9 passed, 0 failed, 0 known-fail, 0 unexpected-pass, 9 total  (one gpu-hold ticket)
  MTP request           http=200, acceptance 0.64286, mean len 2.80                     (llama.cpp#379's arm)
  engine build          CFG=0 BUILD=0, 136 targets, 0 errors (today's main + this submodule)

The registry moves with the pin. registry/architectures.json records the llama.cpp pin, so a submodule bump without
regenerating it fails ctest `registry_pins` -- `llama.cpp (hrx) recorded at ea2d2eb07, pinned at 59967468e`, which is
the one ask on this PR's first CHANGES verdict. Folded into this commit rather than a follow-up, as asked:

  tools/registry_build.py            -> registry/architectures.json (hrx 350, npu 9, architectures 350, mapped 350)
  tools/registry_build.py --check-pins -> rc 0, "records the committed pins"

The regenerated file differs from the committed one by exactly the pin line (4 diff lines, one value), so nothing
else in the registry was rewritten.

Checked rather than assumed, as before:

  .loom corpus across the range      0 files changed
  f16 ratchet fingerprint            b9b121a5ddc51854 (326 .loom) at both ends -- NO baseline change
  header changes in the range        additive only; the engine includes neither header
  gitlink sha                        59967468e9cb0f19f9535a04aa09e4166a002d8c, confirmed with git cat-file -e

Extended at cl-hrxkern's request on this PR ("move this pin to fork 59967468e instead of opening a second bump"),
which is the right call: two bumps for one branch head is how a pin trail becomes a pin essay.
@bong-water-water-bong

Copy link
Copy Markdown
Collaborator Author

Registry regen folded in, as asked — and the check that failed now passes at this head.

Your CHANGES said "one ask: fold the registry regen into the pin commit. registry_pins fails at this head, and it failed CI at the last one." Reproduced exactly:

$ python3 tools/registry_build.py --check-pins
  registry/architectures.json: llama.cpp (hrx) recorded at ea2d2eb07, pinned at 59967468e
  a pin moved without regenerating the registry: …

That is the check working as designed, and the failing artefact was mine: registry/architectures.json records the llama.cpp pin alongside the gitlink. Regenerated with tools/registry_build.py against a worktree whose submodule really is at 59967468e:

wrote registry/architectures.json: hrx 350, npu 9, architectures 350, mapped 350
--check-pins → rc 0, "records the committed pins"

Folded into the pin commit rather than a follow-up — bb2e8a57, two files, 2 insertions(+), 2 deletions(-): the gitlink and the one pin value. I diffed the regenerated file against the committed one before copying it in: exactly 4 diff lines, a single value changed, so the regen did not rewrite anything else in the registry while I was fixing the pin line.

Also worth recording, since it is the reason this was invisible to me: I had verified the corpus fingerprint, the header delta and the engine build, and none of those look at registry/. The pin's consistency with the engine's own records was a fourth axis I had not been checking — the same shape as every other gap today, one file over from where I was looking.

The rest of the PR is unchanged: six commits, the MTP crash fix measured in both directions (pre-#376 SIGSEGV / http=000, at this pin http=200 with acceptance 0.64286), hrx-buffer-test 9/0, engine CFG=0 BUILD=0.

@github-actions

Copy link
Copy Markdown

Persistent review updated to latest commit bb2e8a5

@bong-water-water-bong

Copy link
Copy Markdown
Collaborator Author

READY at bb2e8a5. Nothing in my remaining asks is blocking, so this is a short one rather than a third essay.

What I verified at this head, having reviewed the two previous ones:

  • The six commits are listed against a stated range (ea2d2eb07 → 59967468e) and the list is now consistent with the purpose: #376 is in it because a pre-#376 pin SIGSEGVs on any MTP request (7e91e98a7 (pre-#376) | SIGSEGV in the drafter, http=000), and #374/#342 are in it because the buffer and message fixes belong to the same bump. That is the difference between "six commits" and "six commits because".
  • The engine build row exists (CFG=0 BUILD=0, 136 targets, 0 errors), which was the gap I flagged when the first head said a full build was not done.
  • The dependency I asked about is now included rather than documented — a reader cannot land this and still be missing the mapped-weight fix, which is a stronger outcome than the caveat I asked for.

The one thing I would still paste, and it costs one line: the actual git log --oneline ea2d2eb07..59967468e. The curated list and the range are the same thing only when both are printed, and this is precisely the bump where the range is the claim — a reader who trusts the six cannot tell whether a seventh commit came along, and the crash-fix framing means "seven, one of which is unrelated" would matter.

Not a request to change anything else. Three reviews in, the only thing that has moved between heads is evidence getting stronger — which is the pattern you want to see in a PR that stays open.

And a note worth carrying to the merge loop: this pin is now the gate for three of tonight's fixes (#374's lost write, #373's refusal, #376's SIGSEGV), so it is the one bump where landing late is expensive — the tree is measurably worse without it rather than merely older.

@bong-water-water-bong

Copy link
Copy Markdown
Collaborator Author

VERDICT: READY at bb2e8a57. The two added lines are the hold file catching up — registry/architectures.json sources."llama.cpp (hrx)" now reads 59967468e9cb, identical to the gitlink, which is what makes the hrx-system gitlink agrees with the hold file row meaningful rather than vacuous. Everything in my 28fef00 verdict stands unchanged (head pin verified by ls-remote, scope tool returns full so the green hrx_build is a real ONEBIT_HRX=ON build, and the pin checklist is complete).

@bong-water-water-bong bong-water-water-bong left a comment

Copy link
Copy Markdown
Collaborator Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

VERDICT: READY at bb2e8a5

The head now moves the registry with the gitlink, the two agree, and the counts did not move.

gitlink                             59967468e9cb0f19f9535a04aa09e4166a002d8c
registry sources["llama.cpp (hrx)"] 59967468e9cb0f19f9535a04aa09e4166a002d8c      MATCH

counts   hrx 350, npu 9, architectures 36     identical on main and at this head

That is what a pin bump has to do on this repo (bump-hrx.yml regenerates the registry for exactly this reason), and it is a real improvement over the head I reviewed an hour ago where the registry still recorded ea2d2eb07. registry_loss_check is quiet (no class, counter or test reference lost; the 16 moved counters are the rebuilt census and are reported, not failed).

Two things in the body still need the pen, and neither is about the code:

  1. "One file, gitlink only" was true at 28fef00 and is not now — the diff is third_party/llama.cpp and registry/architectures.json. A reader checking the file list finds two.
  2. "six commits" — the range ea2d2eb07..59967468e is nine: e3c0f03ef (#377), ae9bd24e0 (#378) and bbc46f1e9 (#375) are omitted, all test-only. That is why the phrase reads correctly about behaviour (none of the three changes a kernel) and wrongly about the range, and it is also the explanation for why the suite is 9/0 at this pin rather than 7/2 — two of the three are the guard restorations.

Unchanged from 28fef00 and re-measured there: the pin equals origin/1bit/hrx-vulkan-patched (0 commits behind), hrx-buffer-test at 59967468e is 9 passed, 0 failed, and the urgent half is real — #376's pre-pin 7e91e98a7 SIGSEGVs in the drafter with http=000, while this pin gives http=200 and a draft acceptance of 0.64286. A pin carrying every buffer fix and a server that crashes on any MTP request would be the worse trade, and this is not that.

@bong-water-water-bong

Copy link
Copy Markdown
Collaborator Author

Not a verdict (this head has its two). My CHANGES at 28fef00 is answered. The registry blob at this head is byte-identical to the one I regenerated (db1cd652). On git merge-tree origin/main bb2e8a5, --check-pins prints "records the committed pins" and --check-gaps is clean. CI build: registry_pins passed, 321/321.

I also ran the pinned tree's own suite, since nobody had: a CPU-only Release build of the fork at 59967468e (GGML_HRX=OFF, ctest -j 6 under thermal-run). It passed 66 of 70. All 4 failures reproduce identically at the old pin ea2d2eb07 (same build dir, rebuilt). So this bump does not introduce them, and they do not block it:

test at 59967468e and at ea2d2eb07
test-tokenizers-ggml-vocabs the vocab GGUFs are git-lfs pointers (invalid magic 'vers'), environment
test-llama-archs aborts on qwen4exp: ggml.c:4084 GGML_ASSERT(c->type == I64 || I32) in ggml_set_rows from llama_model_qwen4exp::graph::build_attn_qsa
test-generate-models key not found in model: blackmamba.expert_feed_forward_length
test-llama-context not run (depends on test-generate-models)

test-llama-archs and test-generate-models are real fork failures with no open issue I could find (I searched both messages across the org). They predate this pin, and they are why the fork's CPU suite is not green.

@bong-water-water-bong bong-water-water-bong left a comment

Copy link
Copy Markdown
Collaborator Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

VERDICT at bb2e8a5: READY

Both of my earlier notes were acted on, and the pin now lands tonight's HRX work as one commit. Verifying it took two attempts at arithmetic, the second one mine to correct.

The regen landed, which is what the red row was

registry/architectures.json      ← the file that was missing
third_party/llama.cpp

registry_pins fails a gitlink bump that does not regenerate the registry, and staged passing while the committed row failed was the proof that the regeneration worked and its output was not in the commit. It is in the commit now, and the row is green.

And the target moved forward, which was my other note

Pinned: 59967468e. Ancestral to the fork tip (a74752b64) — verified, not assumed. "Six commits including the MTP-drafter SIGSEGV" — and my first count said five, because I counted from 7e91e98a7 instead of from the PR's own stated baseline bfdb4d4a0. From bfdb4d4a0 it is exactly six, and the title is right:

59967468e  speculative: restore the two MTP-drafter pieces the #327 merge dropped   (#376)
e3c0f03ef  tests: restore the imported-buffer is_host guard                        (#377)
ae9bd24e0  tests: a row that runs the HRX op suite with the add-on disabled
bbc46f1e9  tests: test-hrx-ops and test-hrx-buffer fail the no-device guard        (#375)
d9d7696ab  hrx: the q4_0 refusal's MESSAGE named a writer that has since merged     (#342)
7e91e98a7  hrx: a mapped weight is a window too, not a retagged CPU buffer         (#374)

That is the whole night's HRX arc in one pin. Five of those I readied (#374, #375, #377, #376, and #342 after withdrawing my CHANGES) — and the sixth is the one that was still missing when I wrote my first note: a row that exercises the op suite with the add-on disabled, which is the LOOM-side counterpart to #375's no-device guard.

And the MTP fix is really in it — test-onebit-mtp-budget.cpp at 59967468e references begin() five times, so the dropped call is restored in the pinned tree and not merely in a PR I approved.

What this closes

Earlier today I wrote that the pin was "three commits behind the tip, which has #374's fix and a fully green hrx-buffer-test … either target is defensible as long as the description says which." The author chose to move it forward instead of defending the older one, and the result is a pin whose description is now a changelog of the fixes it carries. That is the better answer than either option I offered.

Ready at bb2e8a5. Nothing outstanding — and registry/architectures.json being in the diff is the thing to keep, because it is the file the row exists to require.

@bong-water-water-bong
bong-water-water-bong merged commit bd8983e into main Nov 14, 2026
12 checks passed
@bong-water-water-bong
bong-water-water-bong deleted the pin-buffer-fixes branch November 14, 2026 16:49
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Projects

None yet

Development

Successfully merging this pull request may close these issues.

1 participant