| # Rule-mining brief: new CUDA mutation operators |
|
|
| ## Context |
|
|
| We run mutation testing on CUDA kernels to measure how strong a benchmark's |
| correctness check is. Mutants are produced by DETERMINISTIC rewrite rules |
| applied to correct kernel source (see ../mutator.py for the 35 current rules |
| and the Rule dataclass). Each rule is (name, category, regex pattern, |
| replacement template). Every match site yields one mutant. |
|
|
| ## What makes a rule VALUABLE (this is the objective) |
|
|
| A mutant is "high value" when it (a) compiles, (b) SURVIVES the benchmark's |
| original test inputs — which are aligned shapes, torch.rand[0,1) values, |
| compared with allclose(atol=rtol=1e-2) — and (c) IS killable by some targeted |
| input (misaligned shape, signed values, large magnitude, structured spikes). |
|
|
| Measured value rates of existing rules on our pool: |
| ceil2floor 100%, const0to1 62%, sync2syncwarp 40%, loop-bound-minus1 39%, |
| loop-start-1 35%, sync-remove 36%, lt2le 21%, store-fp16 24%, |
| mul2plus 15%, mul2div 12% <- good |
| plus2minus 3%, guard-drop-ternary 0%, expf-fast 0%, smem-index-off1 0%, |
| fmin2fmax 0%, negate-store 0%, fdividef-fast 0% <- bad, being retired |
|
|
| Pattern: rules that break BOUNDARY handling, SYNCHRONIZATION, or PRECISION |
| produce faults invisible under aligned shapes and small positive values. |
| Rules that break gross semantics (a+b -> a-b) are caught immediately by any |
| input and are near-worthless. |
|
|
| ## Known expressiveness gaps (highest priority) |
|
|
| Our regex rules CANNOT express these, yet they are the most valuable faults: |
|
|
| 1. Identity substitution: replacing a call with its own argument, e.g. |
| `fmaxf(val, 0.0f)` -> `val` (removes a ReLU; invisible on positive inputs). |
| Generalize: any activation/clamp/saturation wrapper removal. |
| 2. Numerical-stability removal: dropping the max-subtraction in softmax-like |
| code, dropping epsilon in a denominator, dropping Kahan compensation. |
| 3. Partial-tail faults: processing only a prefix of a reduction, off-by-one |
| in the LAST iteration only, dropping the remainder loop after a vectorized |
| main loop. |
| 4. Accumulator staging: using the shared-memory value before the barrier, |
| re-initializing an accumulator inside the loop, double-counting an element. |
| 5. Index arithmetic that is wrong only at edges: swapping row/col strides in |
| ONE of several index expressions, using the wrong bound variable (M vs N), |
| using blockDim where gridDim is meant. |
|
|
| ## Your task |
|
|
| Write NEW rules into a fresh file: rules/mined_rules.py |
| |
| Format (import-safe, no side effects): |
| |
| ```python |
| from mutator import Rule # dataclass(name, category, pattern, replacement, note) |
| |
| MINED_RULES = [ |
| Rule("name", "category", r"regex", r"replacement", "one-line rationale"), |
| ... |
| ] |
| ``` |
| |
| Requirements: |
| - 25+ new rules, none duplicating an existing rule in ../mutator.py. |
| - Categories: boundary | sync | precision | indexing | arithmetic | semantic. |
| - Patterns must be robust regexes that match the CUDA style used in |
| ../problems_batch2.py and ../substrates/accepted/*.py (read several of them |
| — that is the corpus these rules must fire on). |
| - Prefer rules targeting the five gap families above; a regex CAN express |
| identity substitution when the call and its first argument are both simple |
| (e.g. r"fmaxf\((\w+), 0\.0f\)" -> r"\1"). Write several such families. |
| - Every rule must produce COMPILABLE code (mind types and parens). |
| - Avoid rules whose mutants would be caught by any input (gross semantics). |
| - Add a short comment block at the top summarizing your reasoning. |
| |
| Verify before finishing: run |
| python3 -c "import sys; sys.path.insert(0,'.'); from rules.mined_rules import MINED_RULES; print(len(MINED_RULES))" |
| from the experiment directory, and also verify each pattern compiles as a |
| regex. Do not modify any existing file. |
|
|
