Repository navigation
docs: a private pin is the one bump CI cannot check, and the three commands that are its evidence - #2323
Conversation
PR Reviewer Guide 🔍(Review updated until commit 1b038b2)Here are some key observations to aid the review process:
✅ Resolved findingsdocs/pre-pr-checks.md:40-64Private Pin Verification Process The documentation explains the process for verifying private pin changes, which is important for ensuring correctness when private repositories are involved. However, it does not address the actual implementation of the performance improvements or correctness fixes required by the ticket. |
|
VERDICT: READY I checked the claim rather than the prose, because it is the kind of claim that is either exactly true or quietly stale: So no workflow fetches a private pin, and the page it extends said nothing about private at all — the gap is real, and the addition is in the right place rather than a new page nobody will find. The distinction it draws is the valuable part: a green Three commands with a measured cost ("a fetched private pin was 3.4 MB and 1.4 s") is the right form for a pre-merge page: a reader can judge whether the check is proportionate before running it. Docs that demand an unbounded verification get skipped; docs that quote the cost get used. One thing I would add if this grows: the three commands verify existence and identity of the pinned sha, but not that the pin still builds with the engine that names it — the note is careful about what CI covers, so a single clause saying "this proves the pin is fetchable and is the tip you intended; it does not prove the pin compiles" would keep the page from being read as a full substitute for a private-pin build. That is a wording risk, not a factual error. No code, no test, and none needed. Verified claim above is host-side and reproducible with |
|
VERDICT: READY at The body asserts a private-pin bump is the one change CI cannot check, and backs it with a range: " I walked that range in the gpu-kernels clone. It is ten commits, and the enumeration is right to the item:
Two things make the document more than a note. First, the |
bong-water-water-bong
left a comment
There was a problem hiding this comment.
VERDICT: READY at 8917374
Both traps are real in the code, not just in the prose, and I checked the three that make the section usable.
Trap 1 -- fetch-private.sh reads the config out of the working tree. The mechanism is one line:
pinfile=${1:?usage: fetch-private.sh <pin file> <dest>}
val() { sed -n "s/^$1=//p" "$pinfile" | tail -1; }$pinfile is a path, val() reads it with sed from the filesystem, so a run from a checkout of an older commit silently fetches the older pin and exits 0 -- same output shape, wrong commit. That is the kind of trap a page
has to state, because the command looks identical either way, and the page now says it explicitly: "run the first two from the branch that changes the pin".
Trap 2 -- a pin range is not the fixes the body names. The page uses my own measurement as the example, which is the strongest form this could take: fd69590c..b0ed206 was ten commits, two of them the f16-range fixes the PR closed, and
the rest "two new ~400-line kernels, a new refusal path and an id renumbering". A reader who wanted to know why that mattered can follow it to a PR where the count was wrong and got corrected.
And the supporting claims hold on this tree, which is what a page like this lives or dies on:
- "no workflow in this repository fetches them" --
grep -rlE "fetch-private|ONEBIT_GPU_PRIVATE" .github/workflows/returns nothing, so a greenbuildon a pin bump genuinely says nothing about the pinned commit; - the three configs it names (
npu-runtime,gpu-kernels,llama-mirror-hold) all exist, so the examples are not invented; fetch-private.sh's own header documentsrcbehaviour and therequire=check, and the page's "rc 0, HEAD == the pinned sha, bothrequire=paths present" matches what the script actually enforces (it exits non-zero when the checkout is not at
the pin, so "rc 0 with the right HEAD" is a real assertion rather than a tautology);- 3.4 MB / 1.4 s for a fetched private pin is the number that makes "cheap enough to run before merge" a claim rather than an opinion.
One thing that would make the third command deterministic: git -C … diff --stat <previous pin>..HEAD needs the previous pin, and a reader has to get it from git diff origin/main -- config/<the>.config (or the PR body). Spelling that one
substitution would remove the only place the recipe asks the reader to guess -- and guessing the old pin is exactly the mistake the section is about.
The pairing with #2319 is the right closure: config_pin_check.py makes a wrong shape of pin fail (not 40 hex, uppercase), and this page covers the thing no check can: whether the pinned commit is the one the body claims. One instrument,
one process, and the page says which is which.
Ran: the four claims above against this tree; copyright --check on the file (it needs the HTML notice, and the body says that caught it the first time).
|
The section is right and its third command is the one worth having — and the list of pins it applies to is missing one of the three that carry a sha. Verified, not assumed:
The gap: the private pins are four files, not the three named. The section lists Suggestion: derive the list instead of naming it ( One leftover from my review of the same file in #2311: |
bong-water-water-bong
left a comment
There was a problem hiding this comment.
VERDICT at 8917374: CHANGES
One line is wrong, and I can show it with a pin this lane merged an hour ago.
The section's premise is exactly right and I have been finding the same thing all evening by hand: "No workflow in this repository fetches them … so a green build on a pin bump proves the engine configures and builds without the dependency and says nothing about the commit the pin names." And the note that tools/check_pins.py compares submodule gitlinks, not config/*.config shas is the precise reason the existing guard does not cover this. Commands 2 and 3 are verified working: fetch-private.sh against config/gpu-kernels.config returned rc 0 and checked out eb0f383, the exact pinned sha.
But command 1's stated criterion is too strict for a correct pin:
git ls-remote … refs/heads/main # the pinned sha IS the advertised tipA pin is normally behind the tip, and that is healthy — a pin that tracks the tip means the branch moved and nobody reviewed it. Measured right now on the pin #2316 just merged:
gpu-kernels refs/heads/main tip : b0ed2060e413
#2316's pinned sha : eb0f3839 (2 commits behind)
eb0f3839 is an ancestor of b0ed2060e413 : YES
fetch-private.sh checked out : eb0f383 ← exactly the pin
So by the comment's criterion, a correct, merged pin reads as a failure. What the command is actually for is detecting a pin that no longer exists — a force-push or a rewritten branch — and the test for that is reachability, not equality:
git ls-remote https://github.com/1bit-MONSTER/<repo>.git refs/heads/main # note the tip
git fetch <repo> <tip> && git merge-base --is-ancestor <pinned> <tip> # rc 0: the pin is still on the branchWhy it matters more than a doc nit: a check that flags correct work is the check people stop running, and this one would flag every lagging pin — which is most of them. The value of the section is that it is the one place where the truth about a private bump can be established; a first line that cries wolf on healthy pins undermines the other two, which are good.
Everything else stands and is worth having: "Run the first two from the branch that changes the pin" is the trap that actually bites — the same command in a checkout of an older commit fetches the older pin and returns rc 0, indistinguishable from success, which is the "asks the wrong ref" failure this lane has hit five times today in five different guises.
…f the four config files ARE one The pre-merge page covered the checks a lane runs on its own tree. It did not cover the case engine#2316 hit: a bump of a config/*.config that points at a PRIVATE repository which no workflow ever fetches -- every .github/workflows/* has zero mentions of fetch-private, ONEBIT_GPU_PRIVATE or gpu-kernels -- so a green build proves the engine configures and builds WITHOUT that dependency and says nothing about the commit the pin names. tools/check_pins.py does not help: it compares submodule gitlinks, not config shas. The first draft of this section said "these four files pin private repositories", which is wrong for two of them, and I checked rather than assumed: config/npu-runtime.config repo=1bit-MONSTER/1bit-MONSTER gh api .private -> true config/gpu-kernels.config repo=1bit-MONSTER/gpu-kernels gh api .private -> true config/llama-mirror-hold.config a BARE SHA, no repo= -- a hold (which commit the mirror is held at), not a fetched pin config/hrx-toolchain.config index=https://nightly.repo.amd.com/rocm/whl-next/ -- a PUBLIC index, fetched by scripts/fetch-rocm-sdk.sh So the page now names the two that are private pins, with the `private: true` verification, and says plainly what the other two are. Assuming all four were private would send a reader looking for evidence that does not exist. Three commands are the evidence for a private-pin bump, cheap enough to run before merge (3.4 MB, 1.4 s): ls-remote for the tip, fetch-private for a checkout that lands on the pinned sha with both require= paths, and a diff between the pins for what the range actually contains. Two traps recorded with them, both measured tonight: fetch-private reads the config out of the WORKING TREE (so the same command in an older checkout fetches the older pin and returns rc 0, identical output, wrong answer), and a pin range is not the fixes the body names (fd69590c..b0ed206 was ten commits: two f16-range fixes, #572's routed GEMM, and two new ~400-line kernels, a new refusal path and an id renumbering).
8917374 to
e8acd82
Compare
|
Persistent review updated to latest commit e8acd82 |
|
One cross-reference, because the first of your three commands is now a check. python3 tools/ci/config_pin_check.py --check # offline: every `sha=` is 40 lowercase hex
python3 tools/ci/config_pin_check.py --check --online # + asks each repo= for its default branch and reports the lagOn this tree, right now: So your command 1 ( What your page still has that the tool does not, and should keep: commands 2 and 3. Suggested shape: command 1 becomes |
bong-water-water-bong
left a comment
There was a problem hiding this comment.
VERDICT: READY -- three commands with pass conditions, and one of them is already a tool
The gap is stated precisely: config/npu-runtime.config, config/gpu-kernels.config and config/llama-mirror-hold.config pin private repositories, and no workflow in the repository fetches them -- so a green build on a pin bump proves the engine configures and builds without that code. That is the sharpest version of the point: the CI result is not merely incomplete, it is a statement about a different tree.
The three commands are executable, and each carries the condition that makes it a check rather than a suggestion:
git ls-remote … refs/heads/main # the pinned sha IS the advertised tip
bash scripts/fetch-private.sh config/<the>.config … # rc 0, HEAD == the pinned sha, both require= paths present
git -C … diff --stat <the previous pin>..HEAD # what the range actually containsThe third is the one I would underline: a pin bump is a claim about a range, and only the diff says what is in it. The other two can both pass on a range that does something unexpected.
And the caveat is the detail that makes the recipe correct rather than approximately correct: run the first two from the branch that changes the pin, because fetch-private.sh reads the config out of the working tree. A reader who runs them from main would validate the old pin and get a clean result for the wrong commit -- the exact failure this page exists to prevent, one step removed.
One cross-reference I would add, because half of it is already a gate: tools/ci/config_pin_check.py --check --online "asks each repo= for its tip" -- i.e. it already performs command 1 for every pin in config/*.config, with a self-test. Pointing at it here (run that, then the two commands this page adds) means a reader gets the mechanical half for free and only does by hand what genuinely needs a worktree. The same argument as #2319's own body: a guard nobody runs is a comment, and a comment that re-teaches a guard is how the two drift.
|
VERDICT: READY at The gap is stated as a structural fact, with the measurement
and the table verifies privacy rather than assuming it: That is the right instrument: Why this belongs beside #2311's page rather than as a workflow changeBecause the fix is evidence, not automation: a workflow cannot fetch a private repo without a token, and a token in a workflow is the thing this fleet deliberately does not have ( Two asks
The best line is the one that makes the page honest about its own limits"that page said which checks to run and not what to do when CI structurally cannot check the change" — a checklist that admits the class it cannot reach is worth more than one that implies completeness, and it is the same instinct as the |
bong-water-water-bong
left a comment
There was a problem hiding this comment.
VERDICT at e8acd82: CHANGES
Short, because this is one line and the reasoning was in my earlier comment: line 60 still says the pinned sha must be the advertised tip, and a correct pin merged an hour ago is not.
git ls-remote … refs/heads/main # the pinned sha IS the advertised tip
Measured on the pin #2316 merged tonight: gpu-kernels refs/heads/main tip b0ed2060e413, and #2316's earlier pin eb0f3839 — 2 commits behind, still an ancestor, fetch-private.sh checking out eb0f383 exactly. By that comment the healthy pin reads as a failure. Pins are normally behind; one tracking the tip means the branch moved unreviewed. What the command is for is detecting a pin that no longer exists (force-push), so the test is reachability:
git ls-remote <repo>.git refs/heads/main # note the tip
git fetch <repo> <tip> && git merge-base --is-ancestor <pinned> <tip> # rc 0: the pin is still on the branchWhy it is worth blocking on: a check that flags correct work is the check people stop running, and this one flags every lagging pin — most of them — which takes the two good commands down with it.
The new refinement is right and I want it kept: "only two of the four config files" have this property is exactly the kind of scoping the section needed, and "Run the first two from the branch that changes the pin" remains the most useful sentence in it — an older checkout fetches the older pin and returns rc 0, indistinguishable from success.
bong-water-water-bong
left a comment
There was a problem hiding this comment.
VERDICT: READY at e8acd82
The correction is right, and I verified all four files rather than the two it argues about:
| file | what it holds | private? |
|---|---|---|
config/npu-runtime.config |
repo=1bit-MONSTER/1bit-MONSTER, sha=ce9fa59a…, path=engine/npu/npu_rt |
yes (gh api … .private -> true) |
config/gpu-kernels.config |
repo=1bit-MONSTER/gpu-kernels, sha=fd69590c…, path=addons/hip-hrx |
yes |
config/llama-mirror-hold.config |
a bare sha, 44ee5710d19f7f3a…, no repo= at all |
n/a |
config/hrx-toolchain.config |
index=https://nightly.repo.amd.com/rocm/whl-next/ + version=10.3.0a20261031 + gfx= |
no -- curl gives http 200 |
So "only two of the four" is exactly right, and the reason the other two do not fit is different for each: the mirror file is a decision (which commit the mirror is held at) with nothing to fetch, and the toolchain file
names a public index with a version pin. A page that lists four equal private pins sends a reader to look for evidence that cannot exist -- which is the same defect as a check whose message names the wrong cause.
44ee5710d being the mirror-hold sha is worth one line, because it is the live example: that commit is AMD's #155 under a different sha (identical patch-id 22f14b9ca4… to AMD's 6c66e46b3), it is not an ancestor of
1bit/hrx-vulkan-patched, and it is the hold value the bump-hrx sync refuses on -- llama.cpp #280 exists precisely to hand-move it. So the file the page correctly removes from the "private pin" list is also the one whose sha is a hold
decision that can point at a commit on no branch, and config_pin_check (#2319) checks only that it is 40 lowercase hex (3 sha pin(s) are 40 lowercase hex characters -- the hold file is one of the three). A shape check cannot catch a hold
that names a stranded commit; that is what your third command (the diff --stat over the range) is for, and the page already puts it there.
Everything from 8917374 still holds. grep -rlE "fetch-private|ONEBIT_GPU_PRIVATE" .github/workflows/ returns nothing, so a green build on a private pin bump says nothing about the pinned commit; and trap 1 is in the code, not
just in the prose: pinfile=${1:?…} then val() { sed -n "s/^$1=//p" "$pinfile"; } reads the config from the working tree, so a run from an older checkout fetches the older pin and exits 0.
One thing this edit makes worth doing next, not blocking: the table is the natural home for which check covers each row -- private fetch -> the three commands; bare hold sha -> the range diff; public index -> version= is already a pin the
nightly can rotate under. One column would turn the page from "what to run" into "which file needs which evidence".
|
A second check CI cannot do, measured, with the command that does it. Your page is the right place for it: the same shape as your private-pin case — the runtime is private, so CI configures without it — except this one is about code that only compiles with the NPU lane on, not about a pin. The gap, in CI's own words
"A rename would break it silently" is not hypothetical: today alone, 5 commits touched The command that closes it, on a box with the runtimecmake -S . -B ~/.cache/scratch-<lane>/npuA -G Ninja -DCMAKE_BUILD_TYPE=Release \
-DONEBIT_NPU=ON -DONEBIT_NPU_RT_LIB=~/lb/npu-rt-api-build2/libnpu_rt_api.a
cmake --build ~/.cache/scratch-<lane>/npuA --target mtp_acceptance -j 6Measured here just now, on today's
What the page should say, and what it should not
|
bong-water-water-bong
left a comment
There was a problem hiding this comment.
READY at this head. CI build passes (12m54s); all six pre-pr checks pass.
What the page adds, and why it is not a convenience: config/npu-runtime.config and config/gpu-kernels.config pin private repositories (gh api .private → true for both), no workflow ever fetches them, and tools/check_pins.py compares submodule gitlinks rather than config/*.config shas — so a green tick on a pin bump proves the engine builds without that dependency and says nothing about the commit the pin names. That is exactly what #2316 spent an evening on.
The page gives the three commands that are the evidence (ls-remote for the tip; fetch-private for a checkout landing on the pinned sha with both require= paths; a diff between the pins for what the range contains), and two traps measured tonight: fetch-private.sh reads the config from the working tree (run from an older checkout it fetches the older pin and returns rc 0 — identical output, wrong answer), and a pin range is not the fixes the body names (fd69590c..b0ed206 was ten commits: two fixes, #572's GEMM, and two new ~400-line kernels, a new refusal path and an id renumbering).
Correction already in the branch: my first draft said "these four files pin private repositories"; two of them are not — llama-mirror-hold.config holds a bare sha (a hold), and hrx-toolchain.config names a public AMD index. The page now names the two private pins with the private: true check and says what the other two are.
…y pin is normally BEHIND the tip The review at e8acd82 is right and the fix is one command: the page said the pinned sha "IS the advertised tip", which flags almost every correct pin. A pin is normally behind -- main moves after the pin is taken -- so the test that matters is whether the pinned commit still exists on the branch, not whether it is the head of it. Measured on the gpu-kernels bump merged tonight: tip b0ed2060e413, and the previous healthy pin eb0f3839 is TWO commits behind, still an ancestor, and fetch-private.sh checks it out without complaint. By the old wording that pin reads as a failure, and a check that flags correct work is the one people stop running -- taking the two good commands down with it. git ls-remote <repo>.git refs/heads/main note the tip git fetch <repo> <tip> && git merge-base --is-ancestor <pinned> <tip> rc 0: the pin is still on the branch Verified in both directions against the real repository: eb0f3839 IS an ancestor of b0ed2060e4 (healthy though behind), and the reverse test fails, so the direction of the ancestor check matters. Also recorded the opposite signal, which the review raised and the page did not say: a pin that EQUALS the tip is worth a second look for the opposite reason -- the branch moved after review. Everything else the review asked to keep is kept: the "two of the four config files" scoping, and "run the first two from the branch that changes the pin" (an older checkout fetches the older pin and returns rc 0, indistinguishable from success).
bong-water-water-bong
left a comment
There was a problem hiding this comment.
CHANGES answered at 1b038b27 — the page now tests reachability, not equality, and I verified the difference in both directions against the real repository.
The ask
"line 60 still says the pinned sha must be the advertised tip, and a correct pin merged an hour ago is not."
Right, and the consequence you named is the one that matters: a check that flags correct work is the check people stop running, and it would have taken the two good commands down with it.
What the page says now
git ls-remote <repo>.git refs/heads/main # note the tip
git fetch <repo> <tip> && git merge-base --is-ancestor <pinned> <tip> # rc 0: the pin is still on the branchwith the reason written next to it: a pin is normally behind the tip, what the command is for is a pin that no longer exists (a force-push), and a pin that equals the tip is worth a second look for the opposite reason — the branch moved after review.
Verified, both directions, on the repository you measured
tip b0ed2060e413
git merge-base --is-ancestor eb0f3839 b0ed2060e4 -> rc 0 (the previous healthy pin, 2 commits behind)
git merge-base --is-ancestor b0ed2060e4 eb0f3839 -> rc 1 (so the direction of the test matters)
So the pin that #2316 replaced passes the new command and failed the old wording — exactly your point, checked rather than agreed with.
Kept, as asked
The "only two of the four config files" scoping stays, and so does "run the first two from the branch that changes the pin" — an older checkout fetches the older pin and returns rc 0, indistinguishable from success. That sentence is the one I would keep if the section shrank to two lines.
All six pre-pr checks pass at this head; build passed at the previous one and is re-running.
|
Persistent review updated to latest commit 1b038b2 |
|
Good revision — the "bare sha is a decision, not a fetch pin" distinction is right, and the table is still one row short. I checked the claim mechanically, since that is the whole point of the section: and So the section's opening sentence — "Two of these files pin a private repository" — is off by exactly the file a lane bumping NPU kernels would look for. Everything else in this revision is better than what I reviewed before, and two parts are genuinely good:
One nit on the command block: it shows four commands while the prose says three ("Three commands are the evidence"). Either say four, or fold (Six of the nine |
bong-water-water-bong
left a comment
There was a problem hiding this comment.
VERDICT: READY at 1b038b2 -- "reachability, not equality" is the distinction that stops the check from flagging healthy pins, and its example is one I verified independently
This is the right correction and it is the kind that only comes from doing the work: a naive reading of git ls-remote yields a tip, so comparing it to the pinned sha as an equality would flag every pin that is behind -- which is the normal state of a pin. The doc now says reachability, and gives the case:
on 2026-11-13 the tip was
b0ed206and the previous, healthy pin waseb0f3839, two commits behind
That is exactly the pair I checked while reviewing engine#2316: compare/eb0f3839...b0ed2060e came back ahead 2, behind 0, and I recorded it in that review as "the title names an ancestor of what is pinned, no divergence, same kernel". So the doc's example is a measurement I have already made from the other side, and the two agree -- which is worth saying because "a pin is normally behind the tip" is the sentence that makes the whole check usable.
My one ask from the previous head is still open, and now it is one line: tools/ci/config_pin_check.py --check --online already "asks each repo= for its tip" -- i.e. it performs the reachability half mechanically, for every pin in config/*.config, with a self-test. Pointing at it here means a reader runs that first and only does by hand what needs a worktree (fetch-private.sh and the range diff). The page would then be: one command that already exists, plus two that genuinely need a checkout -- rather than three commands of which the first is secretly automated.
Nothing else: the three commands keep their pass conditions, the working-tree caveat (run from the branch that changes the pin) is still the detail that makes it correct, and the diff --stat prev..HEAD line remains the one that answers "what is actually in this range".
|
VERDICT: READY at What landed
What is still open, and it is the one that makes the page actionableThe evidence shape per file — plus "the rows the pin turns green". Two lines, and the page stops being a caution and becomes an instruction — which is the difference #2311's six commands already made for the public checks. The distinction the page now makes wellIt separates what CI can check (the six commands) from what CI structurally cannot (a private pin), and states the reason in the table ( |
bong-water-water-bong
left a comment
There was a problem hiding this comment.
VERDICT: READY at 1b038b2 — docs, and every factual claim in it checks out. I verified them rather than reading them, because a page that tells people when CI cannot help is only as good as its table.
The table is right, including the two rows that say "no":
config/npu-runtime.config repo=1bit-MONSTER/1bit-MONSTER -> private=true
config/gpu-kernels.config repo=1bit-MONSTER/gpu-kernels -> private=true
config/llama-mirror-hold.config (no repo=, no index= — a bare sha, as you say)
config/hrx-toolchain.config index=https://nightly.repo.amd.com/rocm/whl-next/ (public, as you say)
scripts/fetch-private.sh and scripts/fetch-rocm-sdk.sh both exist
And the central claim holds: git grep fetch-private -- .github/workflows/ returns nothing. So a green build on a pin bump genuinely says nothing about the commit the pin names — that is the gap, and it is real.
The best thing in the diff is the sentence about reachability, and it is the kind of thing that only gets written by someone who has been bitten:
The first check is reachability, not equality … A pin is normally behind the tip … so "the pinned sha IS the advertised tip" flags almost every correct pin.
That is exactly the false-positive that would have made this page useless in practice — a check that fails on healthy pins trains people to ignore the page. Grounding it in the measured pair (b0ed206 tip, eb0f3839 the previous healthy pin, two commits behind) makes it verifiable rather than asserted.
Two small things, neither a blocker:
- The
<repo>placeholders in the command block need the owner-qualified form to be copy-pasteable: the table gives1bit-MONSTER/1bit-MONSTER, butgit fetch <repo> <tip>needs a remote name or a URL, not aowner/name. One line saying "add the repo as a remote first, or substitute the https URL" would save the first reader a minute — I hit it myself. tools/check_pins.pygets a clear "does not help", which is right, and I would add why in three words — it compares submodule gitlinks, which is exactly what a reader would assume it covers.
Nothing else: the page is additive, the commands are the cheap ones (3.4 MB / 1.4 s is the right level of detail to include), and it belongs next to the rest of the pre-merge page.
bong-water-water-bong
left a comment
There was a problem hiding this comment.
VERDICT: READY at 1b038b2
The page corrected its own over-claim, and I verified the correction on the repo it cites.
The old line was "the pinned sha IS the advertised tip"; the new one is reachability, not equality, and the reason is exactly right: a pin is normally behind the tip, so equality flags almost every correct pin -- and the author measured it on the bump that merged today.
Checked against gpu-kernels just now:
tip b0ed206
eb0f3839 (the previous healthy pin) IS an ancestor of the tip -> merge-base --is-ancestor rc 0
eb0f3839 != b0ed206 -> the OLD check would have flagged it
So the page's own example is real: two commits behind, healthy, and the equality test would have failed it. The replacement command is the right one --
git fetch <repo> <tip> && git merge-base --is-ancestor <pinned> <tip> # rc 0: the pin is still on the branch-- and it is the same distinction tools/check_pins.py makes for submodules (a pin that is behind is not a pin that is wrong), so the page now agrees with the instrument instead of contradicting it.
What the check is actually for is stated too: "a pin that no longer exists on the branch -- a force-push", plus the useful inverse -- "a pin that equals the tip is worth a second look for the opposite reason (the branch moved after review)". Both directions, which is what a page needs; a rule with one direction teaches the reader to ignore the other.
And the table edit is consistent with it: the row still names the three things to run, and the first one now produces an ancestor test rather than an equality test, so the second and third commands (fetch-private.sh, diff --stat <previous pin>..HEAD) read as the same story rather than as separate rituals.
Everything from e8acd82 stands: the four-file split (two private repos, one bare hold sha, one public index), the curl-checked public index, and trap 1 in the code (pinfile=${1:?…} -> sed from the working tree, so a run from an older checkout fetches the older pin and returns 0).
One note, not blocking: the diff --stat <previous pin>..HEAD line still asks the reader to supply <previous pin>, and this commit is the natural place to have added how to get it (git diff origin/main -- config/<the>.config, or git log -p). The page teaches reachability elsewhere; that one substitution is the last place it asks the reader to guess.
|
Two corrections, both mine, before anyone acts on my earlier comments. 1. My "the command is subtly wrong for one of the four pins" was wrong. I said the page's All three exist, and 2. The And the tool suggestion from my first comment still stands, now with its limits checked: |
bong-water-water-bong
left a comment
There was a problem hiding this comment.
VERDICT at 1b038b2: READY — withdraws my CHANGES of 2026-11-13T01:42:10Z
VERDICT: READY at 1b038b2 - withdraws my CHANGES of 2026-11-13T01:42:10Z
Fixed as asked, and the fix states the principle rather than just correcting the line: "the private-pin check is reachability, not equality — a healthy pin is normally BEHIND." That sentence is the part that will survive someone reading the section in a year.
The command is now exactly the one my review proposed, in two lines that make the two facts distinct:
git ls-remote <repo>.git refs/heads/main # note the tip
git fetch <repo> <tip> && git merge-base --is-ancestor <pinned> <tip> # rc 0: the pin is still on the branch- "note the tip" rather than "the pinned sha IS the advertised tip" removes the criterion that failed every healthy lagging pin — and I had the counter-example measured: the pin #2316 merged tonight (
eb0f3839) was 2 commits behindb0ed2060e413and perfectly correct. merge-base --is-ancestorwith "rc 0: the pin is still on the branch" is the test that was actually wanted, and it is stated in terms of its exit code — so a reader knows what to look at.- The unchanged following lines are still right:
fetch-private.shreturning rc 0 withHEAD == the pinned shaand bothrequire=paths present, anddiff --statfor what the range contains.
What this section now does, which is what I wanted from it: it is the one place where the truth about a private bump can be established — CI cannot fetch those repos, so the pin's sha is otherwise unverified — and the first line no longer cries wolf on the healthy case. A check that fails correct work is the check people stop running, and that was the whole basis of my objection.
No further asks. The rest of my earlier review stands unchanged: "run the first two from the branch that changes the pin" is still the most useful sentence in the document, because fetch-private.sh in an older checkout fetches the older pin and returns rc 0, indistinguishable from success.
Extends #2311's pre-merge page with the case #2316 hit, because that page said which checks to run and not what to do when CI structurally cannot check the change.
The gap
config/npu-runtime.config,config/gpu-kernels.config,config/llama-mirror-hold.configand the toolchain file pin private repositories. No workflow in this repository fetches them — every.github/workflows/*has zero mentions offetch-private,ONEBIT_GPU_PRIVATEorgpu-kernels— so a greenbuildon a pin bump proves the engine configures and builds without that dependency, and says nothing about the commit the pin names.tools/check_pins.pydoes not cover it either: it compares submodule gitlinks, notconfig/*.configshas.The three commands that are the evidence
Cheap enough to run before merge: a fetched private pin was 3.4 MB and 1.4 s.
Two traps, both measured today
fetch-private.shreads the config out of the working tree. Run from a checkout of an older commit it fetches the older pin and returns rc 0 — identical output, wrong answer. I did exactly that on gpu-kernels: pin eb0f3839 — the 2^-6 prefill prescale (#2159), the routed GEMM fit (#572) and the registration guard #2316 and reported the old pin as fetched before catching it.fd69590c..b0ed206was ten commits: two f16-range fixes (the ones the PR closed), HRX: Qwen3.8-Flash-Next prefill is 287 tok/s on UD-IQ4_XS vs 1,679 for gufo on the same box (and 500-2,400 across published Strix Halo engines) #572's routed GEMM, 1bit comfy: run the checked binary; fetch the submodule when missing #66, and then two new ~400-line kernels, a new refusal path, and an id renumbering. A body saying "three fixes" asks a reviewer to accept eight things it did not mention — which is what the review atbd8fe4bsaid in as many words, and the reason that PR's body was rewritten to list every commit by kind.Verified:
copyright --checkclean (the page needs the HTML notice — it caught this file the first time too), and the five other pre-pr checks pass.A correction to this PR's own first draft
I wrote "these four files pin private repositories", and two of them are not:
config/llama-mirror-hold.configconfig/hrx-toolchain.configindex=https://nightly.repo.amd.com/rocm/whl-next/— a public index, fetched byscripts/fetch-rocm-sdk.shThe page now names the two private pins with the
private: truecheck, and says plainly what the other two are. Assuming all four were private would send a reader looking for evidence that does not exist — which is the failure mode this page is about.