| """Structure-specific subtle-fault rules. |
| |
| Motivation: on elementwise / index-output kernels our generic rules degenerate |
| to gross arithmetic mutations (a*b -> a+b), which any input kills. Those |
| kernels DO admit realistic subtle faults — they just live in different |
| syntax. Each rule below models a fault an LLM-written kernel plausibly makes, |
| and each is invisible under the benchmark's default inputs (aligned shapes, |
| torch.rand[0,1)) while being killable by a deliberately constructed input. |
| |
| Fault families: |
| A. tie-breaking in max/min/argmax (ties have measure zero under continuous |
| random input; only duplicate-valued inputs expose them) |
| B. approximation-constant perturbation (relative error ~1e-3 hides under |
| atol=1e-2 at small magnitude, grows with |x|) |
| C. branch-cutoff shifts in piecewise activations (wrong only inside the |
| moved interval) |
| D. single-element tail loss in elementwise guards (needs misaligned or |
| spiked-tail input) |
| """ |
| from mutator import Rule |
|
|
| STRUCTURAL_RULES = [ |
| |
| Rule("argmax-tie-last", "semantic", |
| r"if \((\w+) > (\w+)\) \{", |
| r"if (\1 >= \2) { ", |
| "argmax keeps the LAST maximum instead of the first: differs only " |
| "when duplicate values exist (measure zero under rand)"), |
| Rule("argmin-tie-last", "semantic", |
| r"if \((\w+) < (\w+)\) \{", |
| r"if (\1 <= \2) { ", |
| "argmin keeps the last minimum instead of the first"), |
| Rule("argmax-tie-nan-form", "semantic", |
| r"if \((\w+) > (\w+) \|\| \(isnan\(", |
| r"if (\1 >= \2 || (isnan(", |
| "argmax with NaN handling: ties now keep the LAST index; only " |
| "duplicate-valued inputs differ (measure zero under rand)"), |
| Rule("argmax-nan-policy-drop", "semantic", |
| r" \|\| \(isnan\((\w+)\) && !isnan\((\w+)\)\)", |
| r"", |
| "drop the NaN-propagation branch: differs only on NaN inputs"), |
| Rule("argmax-seed-from-second", "boundary", |
| r"for \(int (\w+) = 1; \1 < (\w+); \1\+\+\)", |
| r"for (int \1 = 2; \1 < \2; \1++)", |
| "scan starts one element late: wrong only when the true extremum " |
| "sits at that position"), |
| Rule("reduce-fmax-tie-order", "semantic", |
| r"(\w+) = fmaxf\(\1, ([^;]+)\);", |
| r"\1 = (\2 > \1) ? \2 : \1;", |
| "fmaxf replaced by a strict comparison: identical except for NaN " |
| "operands, where fmaxf ignores NaN but > propagates the old value"), |
| Rule("reduce-fmin-tie-order", "semantic", |
| r"(\w+) = fminf\(\1, ([^;]+)\);", |
| r"\1 = (\2 < \1) ? \2 : \1;", |
| "fminf replaced by strict comparison: NaN semantics differ"), |
| Rule("reduce-seed-first-element", "boundary", |
| r"float (\w+) = -CUDART_INF_F;", |
| r"float \1 = 0.0f;", |
| "max-reduction seeded with 0 instead of -inf: wrong only when every " |
| "value in the row is negative"), |
| Rule("reduce-seed-first-element-min", "boundary", |
| r"float (\w+) = CUDART_INF_F;", |
| r"float \1 = 0.0f;", |
| "min-reduction seeded with 0: wrong only for all-positive rows"), |
|
|
| |
| Rule("gelu-tanh-const-perturb", "precision", |
| r"0\.044715f", |
| r"0.044615f", |
| "GELU tanh-approximation cubic coefficient off in the 4th digit"), |
| Rule("gelu-sqrt2pi-perturb", "precision", |
| r"0\.7978845608f?", |
| r"0.7968845608", |
| "sqrt(2/pi) constant mistyped: relative error ~1e-3"), |
| Rule("invsqrt2-perturb", "precision", |
| r"0\.70710678f", |
| r"0.70701678f", |
| "1/sqrt(2) mistyped in the erf-based GELU"), |
| Rule("selu-alpha-perturb", "precision", |
| r"1\.6732632423543772f", |
| r"1.6723632423543772f", |
| "SELU alpha constant digit transposition"), |
| Rule("selu-scale-perturb", "precision", |
| r"1\.0507009873554805f", |
| r"1.0057009873554805f", |
| "SELU scale constant digit transposition"), |
| Rule("erf-to-tanh-approx", "precision", |
| r"0\.5f \* (\w+) \* \(1\.0f \+ erff\((\w+) \* 0\.70710678f\)\)", |
| r"0.5f * \1 * (1.0f + tanhf(0.7978845608f * (\2 + 0.044715f * \2 * \2 * \2)))", |
| "exact erf GELU replaced by the tanh approximation (~1e-3 relative)"), |
|
|
| |
| Rule("softplus-cutoff-shift", "precision", |
| r"(\w+) > 20\.0f \?", |
| r"\1 > 8.0f ?", |
| "softplus linear-regime threshold moved: wrong inside [8,20]"), |
| Rule("relu-threshold-shift", "semantic", |
| r"(\w+) > 0\.0f \? \1 :", |
| r"\1 > 1e-6f ? \1 :", |
| "activation threshold nudged off zero: only tiny values differ"), |
| Rule("hardsigmoid-slope-perturb", "precision", |
| r"/ 6\.0f \+ 0\.5f", |
| r"/ 6.0f + 0.4995f", |
| "hardsigmoid offset off by 5e-4: hidden by atol at small outputs"), |
| Rule("clamp-bound-perturb", "precision", |
| r"fminf\(fmaxf\((\w+), -1\.0f\), 1\.0f\)", |
| r"fminf(fmaxf(\1, -1.0f), 0.999f)", |
| "saturation bound off by 1e-3: only saturated inputs differ"), |
|
|
| |
| Rule("elementwise-guard-minus1", "boundary", |
| r"if \((\w+) < (n|N|size|numel|total)\) \{", |
| r"if (\1 < \2 - 1) { ", |
| "last element of the flat range never written: needs a spiked or " |
| "misaligned tail to expose"), |
| Rule("elementwise-guard-plus1", "boundary", |
| r"if \((\w+) < (n|N|size|numel|total)\) \{", |
| r"if (\1 < \2 + 1) { ", |
| "one lane past the end writes OOB (sanitizer-visible)"), |
| Rule("grid-stride-step-double", "boundary", |
| r"idx \+= (blockDim\.x \* gridDim\.x)", |
| r"idx += 2 * \1", |
| "grid-stride loop skips every other element"), |
| ] |
|
|
