feat(musa): 13 reduction/normalization mudnn kernels

[lvyufeng]

Summary

Second mudnn batch: 13 reduction/normalization operators, taking MUSA coverage
90 -> 105 kernels. Same table-driven route as #60 -- 8 new templates, no framework
changes. Stacked on #60; review that one first.

New ops:

• softmax family: _log_softmax _softmax_backward_data _log_softmax_backward_data
• reductions: amax amin prod.dim_int any.dim all.dim
• statistics: var.correction std.correction linalg_vector_norm
• normalization: native_layer_norm native_layer_norm_backward

Softmax::RunBwd's operands are (gradInput, output, gradOutput), measured, and the
numbers match aten's y*(g - sum(g*y)) exactly. input_dtype only records what the
forward input was; when it differs from the gradient's dtype aten wants a converting
backward, which mudnn does not express, so that combination goes to the host instead
of silently computing in the wrong precision.

The Reduce fix (2nd commit)

The pre-existing guard only covered multi-dim reductions, where mudnn v3300 raises
SIGFPE on an input that is a broadcast of one element. A single-dim reduce over the
same input has a second, quieter failure: it intermittently writes only out[0] and
leaves the rest of the output untouched, so the answer is whatever the caching
allocator last left in that block.

It surfaces as a wrong bias gradient. linear(x, w, b).sum().backward() reduces a
grad_output that autograd builds as ones.expand(...), whose storage is a single
float, and the gradient came back as [4, 34, 38, 42, 46] -- element 0 correct,
elements 1.. left over from a previous op.

Two properties make this one worth reading carefully:

• It does not reproduce outside the allocator. Probed standalone against a
  deliberately poisoned output buffer, mudnn is correct every time. The trigger needs a
  recycled non-zero block underneath, so a C++ probe will tell you the library is fine.
• A pure-tensor reduce cannot serve as the regression test for the same reason.
  The test added here goes through the bias-gradient path, which is what actually
  leaves recycled data in the output block.

MudnnReduceWouldFault therefore becomes MudnnReduceNeedsContiguous, dropping the
dim-count argument and keying only on "fully 0-strided". The materialization it forces
reads one element, so the cost is negligible.

Note the fix lands here rather than in #60: it rewrites the guard in five templates,
and three of them (T_REDUCE_CORRECTION, T_REDUCE_DIMS_PLAIN, T_REDUCE_NORM) are
introduced by this PR, so it cannot be applied to the P1 tree.

Test plan

Environment: torch==2.10.0+cpu, 8x MTT S5000, built with --no-build-isolation.

• Numerics vs CPU for all 13 ops across float32/float16, including keepdim both
  ways, negative dims, multi-dim reductions, and correction=0/1 for var/std.
• Reduce regression: the bias-gradient path, repeated after ops that dirty the
  allocator, now returns [4, 4, 4, 4, 4] every time. Added as a test.
• Suite: pytest tests/ gives 482 passed / 209 skipped / 3 xpassed vs a
  478-passed baseline. The 4 failures are tests/manual/metax vendor tests
  AttributeError-ing on a MUSA box; the 9 errors are the known missing transformers.
• ruff==0.15.12 check + format clean.
• Only MUSA-only files change, so cuda/gcu are unaffected by construction.

Regenerating with python scripts/codegen_mudnn.py at each of the two commits
reproduces the checked-in generated files exactly.

🤖 Generated with Claude Code