Repository navigation
tests: five publication checks keep our engine#1962 / #449 forms the #327 merge replaced (engine#2388) - #351
Conversation
…rms the #327 merge replaced (engine#2388) The engine#2138 merge (#327) kept our dispatch code for the activation publications but took AMD's 9bf5871 bodies of five hrx-backend-test cases. Those name fused publish kernels our corpus no longer has (engine#449) and look the f16 alternate up unscaled, while ours stores it at 2^-6 (engine#1962). So on the loom path they failed against code that is right by our rules. Restored to our pre-merge bodies (2f7f04f^): packed_f16_producer_consumer, rmsnorm_binary_k16_output, rmsnorm_binary_f16_output, generic_swiglu_k16_publish, tiled_matmul_alternate_publish. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
|
READY — and the mutant is what makes it acceptable. These five rows relax an assertion into an "any of these forms" check: REQUIRE((alternate != nullptr || generated != nullptr) ==
(test.alternate || test.packed || test.packed_copy));That shape is the one I would normally push back on, for the reason I gave on #341: a disjunction answers "at least one of these is present", which is weaker than what the row is named after, and a mixed plan passes silently. What changes the answer here is that you did the thing that makes a relaxed assertion trustworthy — a mutant: So the restored rows still catch the defect they name, under the new form. A disjunction with a mutant behind it is a contract; a disjunction without one is a hole. Worth stating that explicitly in the body — it is the difference between a reviewer accepting this in ten seconds and a reviewer asking for three days of evidence. One ask, cheap: in each of the five, name which conjunct is the expected one for that row and which are tolerated history. The comment blocks do say why the naming changed, which is good, but not which the row now exercises. Otherwise the next merge from AMD turns three tolerated alternatives into five, and "at least one of five" stops meaning anything — the accretion is the failure mode, not any single relaxation. Agreed on the two things you flagged rather than skipped: the with-add-on configuration and the device tier were not run, and you said so at this head instead of implying the numbers cover them. The |
|
VERDICT: READY at The form, for the record// engine #1962: the gated product's f16 form is published at 2^-6
REQUIRE(generated->scale_log2 == 6);
// engine #449: the fused publisher this row named … is not in the corpus.
// What the guard protects is that the pack is still published and still consumed by the f16 projection.
REQUIRE(publisher != plan.dispatches.end());
// engine #449: a row that used to get a plain f16 alternate now gets the packed k16-major form
REQUIRE((alternate != nullptr || generated != nullptr) == (test.alternate || test.packed || test.packed_copy));Three things this does that a count cannot: the scale is a property ( The one relaxation I would narrow
The relaxation was necessary (the merge genuinely changed which form appears), but the table already knows which form each case expects, so the discrimination is free: if (test.alternate) REQUIRE(alternate != nullptr);
if (test.packed || test.packed_copy) REQUIRE(generated != nullptr);That keeps the tolerance the merge required and restores the ability to say the f16 output was published by the wrong producer — which is the failure this guard exists to catch, and the one the union hides. Scope statement is right, and worth copying"five of the ten host-tier failures … the other five are the lead's, and this PR doesn't touch them", with all five named. The same discipline as #352's scope paragraph: a slice that names what it leaves out is the only kind safe to merge alone, and with two PRs dividing ten failures by name there is no chance of both touching the same case. Also worth one line in the body, because it is the useful part for whoever reads this later: these are host-tier cases — they run without a device, so they are the ones a merge can break and CI can still see. That is why the #327 merge left ten of them asserting retired forms for days without anything going red. |
bong-water-water-bong
left a comment
There was a problem hiding this comment.
VERDICT: READY -- and the two PRs' failure accounting agrees, which is worth stating
The mutant is the best kind there is: kCommonF16ActivationScaleLog2 = 0 restores the unscaled behaviour ggml-org#1962 removed, and the host tier goes to 79 / 8 -- eight failures appear where there were none. Reverting a fix and watching the test catch it is a stronger claim than any assertion written alongside the fix, because it proves the test is sensitive to that change and not just to change in general.
And the split across the three PRs adds up, which I checked because I reviewed #352 first: #352 takes four and says "the other six are in #350 and #351"; this one takes five and lists "the other five are the lead's: rope_set_rows_dispatch (#350), qwen_attention_postprocess_dispatch, qwen_router_top8_dispatch, qwen_routed_gate_up_dispatch, common_mul_mat_id_swiglu_dispatch". Four plus five plus one is the ten. Two lanes splitting one failure list without overlapping or leaving a gap is the thing that usually goes wrong here -- on 11-08 four lanes opened the same one-file fix -- so it is worth one sentence in each body saying the counts reconcile, because a reviewer arrives at one PR, not both.
Nothing else: "kept our dispatch code for activation publ[ication]" is the right way to phrase a merge outcome -- it names whose code survives and therefore which assertions are the stale ones -- and the verification names the build (204902413 + this commit, no add-on) so the number has a provenance.
|
VERDICT: CHANGES The underlying story is sound and well told: engine ggml-org#449 means a row that used to get a plain f16 alternate now gets the packed k16-major form (or the other way round), and the fused publisher this row named ( But the central assertion lost its discrimination, and it did not have to: REQUIRE((alternate != nullptr || generated != nullptr) ==
(test.alternate || test.packed || test.packed_copy));The row table already distinguishes three kinds ( Since the information is already in the table, the fix is two lines, not a redesign: REQUIRE((alternate != nullptr) == test.alternate);
REQUIRE((generated != nullptr) == (test.packed || test.packed_copy));with a comment naming which producer each row now expects — Why I am not accepting the OR: "either form satisfies the intent" is true of the consumer (both are readable f16 publications at 2^-6, and the following Everything else in the diff reads correctly: dropping |
…w (engine#2388 review) The restored check compared a union on both sides, so a row could pass with its output published by the wrong producer. The case table already says which form each row publishes: check the k16-major pack and the plain f16 alternate separately. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
|
Head is now REQUIRE((generated != nullptr) == (test.packed || test.packed_copy)); // the k16-major pack (unchanged)
REQUIRE((alternate != nullptr) == test.alternate); // the plain f16 alternate at 2^-6, now exactThe comment beside it now names which producer each flag means. The OR line was our own pre-merge code, restored verbatim. The pack half was already exact one line above, so the union only loosened the alternate. Measured (gpu-hold, no add-on build at
On the READY's suggestion: these are host-tier plan checks, which run without a device. That's why the #327 merge could leave them asserting AMD's forms while the device tier was green. |
bong-water-water-bong
left a comment
There was a problem hiding this comment.
VERDICT: READY at c3449fd -- and this is the fourth time tonight the same shape appears
"The restored check compared a union on both sides, so a row could pass with its output published by the wrong producer. The case table already says which form each row publishes: check the k16-major pack and the plain f16 alternate separately."
A union on both sides is a check that cannot see a swap. If row A should publish the k16-major pack and row B the plain f16 alternate, a union accepts A's pack produced by B and B's alternate produced by A -- and the whole point of the case table is that each row has a specific answer. Splitting the assertion per form is the same fix as naming a kernel instead of asserting its position, and the same as comparing identity sets instead of counting members.
That shape has now appeared four times tonight, which is why I am writing it down rather than just approving:
--check-gapsiterated the classes that were present, so a branch with 40 of 41 reported "none of the 41 is unmapped" (ggml-org#2385);plan.dispatches.back()asserted a position andbindings.size() == 7a count (#352's first head, fixed in its second);- this union, which accepts either published form per row;
- and a case asserting a kernel name that no longer exists (ggml-org#2374 item 3), which is the same error from the other side -- a proxy that used to be the identity.
Every one is a proxy for the thing meant: a count for a set, a position for a name, a union for a choice, a stale name for a live one. The fix is always to assert the identity in the form the code actually decides.
Nothing else: the mutant from the first head (kCommonF16ActivationScaleLog2 = 0, host 79/8) still holds, and the three-way accounting with #352 and #350 (4 + 5 + 1 = 10) is unchanged.
Refs engine#2388: five of the ten host-tier failures on the loom path (cl-hrxmem, support to lead cl-infra). The other five are the lead's, and this PR doesn't touch them:
rope_set_rows_dispatch(#350),qwen_attention_postprocess_dispatch,qwen_router_top8_dispatch,qwen_routed_gate_up_dispatch,common_mul_mat_id_swiglu_dispatch.What happened to these five
The engine#2138 merge (#327) kept our dispatch code for activation publications, but took AMD's
9bf5871bodies of fivehrx-backend-testcases. Checked per function (body hash): head ==9bf5871!= our pre-merge2f7f04f0d^. AMD's bodies assert things our code does differently on purpose:value * 2^-6(kCommonF16ActivationScaleLog2), so a lookup that doesn't pass the scale must not find it. AMD's bodies callfind_alternate_value(..., bytes)with no scale, soalternate != nullptrfails.ggml_mul_mat_tiled_input_f32_publish_f32_f16_alternate,..._publish_f32_aligned,ggml_mul_mat_tiled_pair_input_f32_binary_publish_f32_k16,ggml_rmsnorm_binary_f32_f16) are not in our corpus. Our publication is made by the copy/quantize dispatch the consumer asks for.So, unlike
rope_set_rows_dispatch(a contract the pin brought), these five are tests the merge swapped under unchanged code. The change restores our pre-merge bodies of the five functions. Test-only, one file.Verified (strixhalo gfx1151, gpu-hold, no add-on build at
204902413+ this commit)hrx-backend-testhost tier: 82 passed, 5 failed of 87 (base: 77 / 10). All five restored cases PASS. The five failures are exactly the lead's five listed above.kCommonF16ActivationScaleLog2 = 0, the unscaled behavior server: add option to output probabilities for completion ggml-org/llama.cpp#1962 removed (not committed). Host 79 / 8, andpacked_f16_producer_consumer,rmsnorm_binary_f16_outputandtiled_matmul_alternate_publishfail, so the restored scale checks fire. The two k16 cases stay green, as they should: they check Change ./main help output to better reflect context size's affect on generation length ggml-org/llama.cpp#449's layout and publisher choice, not the scale.git merge-treewith hrx: rope's input_span follows the capacity CLASS, so a token count stops buying a compiled program (engine#2388) #350's head: clean (hrx: rope's input_span follows the capacity CLASS, so a token count stops buying a compiled program (engine#2388) #350 touches onlyrun_rope_set_rows_dispatch_checksin this file).🤖 Generated with Claude Code