群を待つ投入の行へ名指しの規則を足す

Author: routersys

CONTRIBUTING.md

@@ -690,7 +690,7 @@ The Direct2D authoring projects were removed before the first release and restor
 | Language version | `preview`, so what the sources compile as changes with the SDK in use | `14.0`, the version the sources actually require; a simple lambda parameter modifier makes `13.0` insufficient | `5d5f476f` |
 | Shader compilation after a refusal | Builds the HLSL for a shader and hands it to the shader compiler whether or not the rewriter has already refused the input, so a refused construct is answered twice: once against the source the author wrote, and once by `CMPW0046` or `CMPWD2D0034` naming a line of generated code, whose text asks the author to open an issue for a shader the generator itself declined to translate. `HlslBytecodeInfoKey.IsCompilationEnabled` is documented as covering errors earlier in the pipeline, and the Direct2D generator carries a comment saying that compilation is done last so it can be skipped when errors happened before, but neither generator ever reads the diagnostics it has collected | Both read them, and disable compilation when a diagnostic of error severity is already present. The severity read is the one the descriptor declares, so a report that refuses nothing leaves compilation enabled: syntax outside the accepted set still reaches the compiler, and the failure it raises still reaches the author. An input that is not refused is unaffected, the forwarding it may produce included. Reverting the change makes 31 refusal assertions in the compute suite and 42 in the Direct2D suite carry the forwarded failure again | `26590ffd` |
 | Diagnostic titles | Six descriptors carry the title of another diagnostic. `CMPW0018` and `CMPW0019` are named after the foreach statement they follow, as are `CMPWD2D0010` and `CMPWD2D0011`; `CMPWD2D0057` is named after the missing compile options it follows, and `CMPWD2D0058` after the missing resource texture index attribute. The title is the name tooling shows for a rule, so a `lock` statement in a shader is reported under a name that says foreach. The description of `CMPWD2D0057` also writes `using` twice | Each names its own diagnostic, and the description writes the word once. The set was measured over all 199 declared descriptors by two rules: two descriptors in one assembly carrying the same title, and an identifier and a title sharing no word. Their union is the six above; the second rule alone misses `CMPWD2D0057`, whose identifier and title do share words. The first rule is held by a test on both sides, so a title copied from another descriptor cannot come back unnoticed; a title that is wrong without being a copy is caught by neither rule | `79190cd2` |
-| A dispatch under a shader that waits for its whole thread group | Rounds the dispatch up to whole thread groups and has the entry point run the body only for the threads inside the requested range. A shader that reaches one of the three barriers that synchronize the group is run that way as well, so a range that is not a multiple of the thread group size leaves the last group partly out: the threads left out never reach the barrier, and never write the group shared state the ones inside it read. Measured over a range of 100 with a group of 64, 28 of the 100 values disagreed, on both devices and on every run. The undefined dispatch also damages the device for the work that follows it: two later tests of the same run fail, and pass when run on their own | The generator marks a shader that reaches such a barrier, the descriptor carries the mark, and the dispatch refuses a range that is not a multiple of the thread group size on every axis. A range that is a multiple leaves the entry point unchanged, the check inside it being uniform across the group. The mark is written only for a shader that carries it, so the generated code of every other shader is unchanged, which was compared in full | `c2d6b452` |
+| A dispatch under a shader that waits for its whole thread group | Rounds the dispatch up to whole thread groups and has the entry point run the body only for the threads inside the requested range. A shader that reaches one of the three barriers that synchronize the group is run that way as well, so a range that is not a multiple of the thread group size leaves the last group partly out: the threads left out never reach the barrier, and never write the group shared state the ones inside it read. Measured over a range of 100 with a group of 64, 28 of the 100 values disagreed, on both devices and on every run. The undefined dispatch also damages the device for the work that follows it: two later tests of the same run fail, and pass when run on their own | The generator marks a shader that reaches such a barrier, the descriptor carries the mark, and the dispatch refuses a range that is not a multiple of the thread group size on every axis. A range that is a multiple leaves the entry point unchanged, the check inside it being uniform across the group. The mark is written only for a shader that carries it, so the generated code of every other shader is unchanged, which was compared in full. An overload taking fewer than three ranges fixes the axes it does not take at one, and those axes carry no range argument, so a refusal for one of them names the axis in the message and reports the shader argument, whose thread group is what asks for more than the fixed range holds. Every other argument refusal in the runtime names a parameter, 105 of the 106 measured, so leaving the name empty was the shape that stood apart. The axes an overload does take are named as arguments as before | `c2d6b452`, `34b73d78` |
 | The message a shader compiler failure carries | Tells the author to open an issue `an include` a working repro. The two exception types that build the message also document their argument as a `compilatin` error message, and the one for FXC attributes the message to DXC | Reads `and include`. The two documentation slips are corrected with it; those two change no behavior | `1207b5a6` |
 | Root signature size analysis | Counts the captured resources only, so a pixel shader like type is measured one DWORD short of the signature the runtime builds: the implicit output texture is bound as a descriptor table and costs a DWORD that the analysis omits. A type whose analyzed size lands on the 64 DWORD limit therefore builds without a diagnostic and fails at dispatch, where `D3D12SerializeVersionedRootSignature` returns `E_INVALIDARG` and the author sees only an invalid parameter | Counts the implicit output texture as well, so the analyzed size is the size of the signature the runtime builds. The types this newly refuses are exactly those the runtime already refused, measured by dispatching one of them before the change | `feb631da` |
 | Thread group total size | Bounds each axis on its own and never the group as a whole, in the analyzer and in the generator alike, so a size whose axes are all in range but whose threads exceed what one group may hold reaches the shader compiler. The refusal arrives as `CMPW0046`, which points at a line of generated HLSL and invites the author to open an issue, for an attribute value the hardware does not allow | Both bound the total as well, so the size is refused as `CMPW0044` at the attribute and the generator stops before the compiler, the way it already does when an axis is out of range. `CMPW0046` stays reachable through limits neither side models, and the test that covers it now uses group shared storage past its own maximum | `5b3cdeb7` |