Consolidate apply_compile_dense and apply_compile_sparse into a single
apply_compile function. The only difference was capture_scalar_outputs
which is harmless for dense models.

Remove the _run_experts_grouped_mm separate compile boundary and EP
wrapper — no longer needed after fixing the symbolic shape issue in
_generate_permute_indices.

Fix _generate_permute_indices to use torch.arange(seg_ids.shape[0])
instead of torch.arange(total), reusing the unbacked symint from
repeat_interleave rather than creating a redundant one that produces
an Eq(u1, u2) constraint inductor cannot lower.

Remove the x[:total_tokens] slice in _run_experts_for_loop — padding
was removed in pytorch#2774, so sum(num_tokens_per_expert) == x.shape[0] and
the slice is a no-op. This also eliminates the need for torch._check
guards on the unbacked symint.

Consolidate apply_compile_dense and apply_compile_sparse into a single
apply_compile function. The only difference was capture_scalar_outputs
which is harmless for dense models.

Remove the _run_experts_grouped_mm separate compile boundary and EP
wrapper — no longer needed after fixing the symbolic shape issue in
_generate_permute_indices.

Fix _generate_permute_indices to use torch.arange(seg_ids.shape[0])
instead of torch.arange(total), reusing the unbacked symint from
repeat_interleave rather than creating a redundant one that produces
an Eq(u1, u2) constraint inductor cannot lower.

Remove the x[:total_tokens] slice in _run_experts_for_loop — padding
was removed in pytorch#2774, so sum(num_tokens_per_expert) == x.shape[0] and
the slice is a no-op. This also eliminates the need for torch._check
guards on the unbacked symint.

Consolidate apply_compile_dense and apply_compile_sparse into a single
apply_compile function. The only difference was capture_scalar_outputs
which is harmless for dense models.

Remove the _run_experts_grouped_mm separate compile boundary and EP
wrapper — no longer needed after fixing the symbolic shape issue in
_generate_permute_indices.

Fix _generate_permute_indices to use torch.arange(seg_ids.shape[0])
instead of torch.arange(total), reusing the unbacked symint from
repeat_interleave rather than creating a redundant one that produces
an Eq(u1, u2) constraint inductor cannot lower.

Remove the x[:total_tokens] slice in _run_experts_for_loop — padding
was removed in pytorch#2774, so sum(num_tokens_per_expert) == x.shape[0] and
the slice is a no-op. This also eliminates the need for torch._check
guards on the unbacked symint.

Consolidate apply_compile_dense and apply_compile_sparse into a single
apply_compile function. The only difference was capture_scalar_outputs
which is harmless for dense models.

Remove the _run_experts_grouped_mm separate compile boundary and EP
wrapper — no longer needed after fixing the symbolic shape issue in
_generate_permute_indices.

Fix _generate_permute_indices to use torch.arange(seg_ids.shape[0])
instead of torch.arange(total), reusing the unbacked symint from
repeat_interleave rather than creating a redundant one that produces
an Eq(u1, u2) constraint inductor cannot lower.

Remove the x[:total_tokens] slice in _run_experts_for_loop — padding
was removed in pytorch#2774, so sum(num_tokens_per_expert) == x.shape[0] and
the slice is a no-op. This also eliminates the need for torch._check
guards on the unbacked symint.

Consolidate apply_compile_dense and apply_compile_sparse into a single
apply_compile function. The only difference was capture_scalar_outputs
which is harmless for dense models.

Remove the _run_experts_grouped_mm separate compile boundary and EP
wrapper — no longer needed after fixing the symbolic shape issue in
_generate_permute_indices.

Fix _generate_permute_indices to use torch.arange(seg_ids.shape[0])
instead of torch.arange(total), reusing the unbacked symint from
repeat_interleave rather than creating a redundant one that produces
an Eq(u1, u2) constraint inductor cannot lower.

Remove the x[:total_tokens] slice in _run_experts_for_loop — padding
was removed in pytorch#2774, so sum(num_tokens_per_expert) == x.shape[0] and
the slice is a no-op. This also eliminates the need for torch._check
guards on the unbacked symint.

Consolidate apply_compile_dense and apply_compile_sparse into a single
apply_compile function. The only difference was capture_scalar_outputs
which is harmless for dense models.

Remove the _run_experts_grouped_mm separate compile boundary and EP
wrapper — no longer needed after fixing the symbolic shape issue in
_generate_permute_indices.

Fix _generate_permute_indices to use torch.arange(seg_ids.shape[0])
instead of torch.arange(total), reusing the unbacked symint from
repeat_interleave rather than creating a redundant one that produces
an Eq(u1, u2) constraint inductor cannot lower.

Remove the x[:total_tokens] slice in _run_experts_for_loop — padding
was removed in pytorch#2774, so sum(num_tokens_per_expert) == x.shape[0] and
the slice is a no-op. This also eliminates the need for torch._check
guards on the unbacked symint.

Consolidate apply_compile_dense and apply_compile_sparse into a single
apply_compile function. The only difference was capture_scalar_outputs
which is harmless for dense models.

Remove the _run_experts_grouped_mm separate compile boundary and EP
wrapper — no longer needed after fixing the symbolic shape issue in
_generate_permute_indices.

Fix _generate_permute_indices to use torch.arange(seg_ids.shape[0])
instead of torch.arange(total), reusing the unbacked symint from
repeat_interleave rather than creating a redundant one that produces
an Eq(u1, u2) constraint inductor cannot lower.

Remove the x[:total_tokens] slice in _run_experts_for_loop — padding
was removed in pytorch#2774, so sum(num_tokens_per_expert) == x.shape[0] and
the slice is a no-op. This also eliminates the need for torch._check
guards on the unbacked symint.

Consolidate apply_compile_dense and apply_compile_sparse into a single
apply_compile function. The only difference was capture_scalar_outputs
which is harmless for dense models.

Remove the _run_experts_grouped_mm separate compile boundary and EP
wrapper — no longer needed after fixing the symbolic shape issue in
_generate_permute_indices.

Fix _generate_permute_indices to use torch.arange(seg_ids.shape[0])
instead of torch.arange(total), reusing the unbacked symint from
repeat_interleave rather than creating a redundant one that produces
an Eq(u1, u2) constraint inductor cannot lower.

Remove the x[:total_tokens] slice in _run_experts_for_loop — padding
was removed in pytorch#2774, so sum(num_tokens_per_expert) == x.shape[0] and
the slice is a no-op. This also eliminates the need for torch._check
guards on the unbacked symint.

including
- remove triton kernel for permutation+padding as it is not required by
default bf16 grouped mm.
- replace the kernel with a torch-native `generate_permutation_indices`
impl, which doesn't do padding.
- added `TorchAOExpertParallel` to do permutation+padding during EP
using the same triton kernel moved to torchao.
- added a `llama4_debugmodel_fp8` in llama4 `config_registry` to
demonstrate
- refactored HybridEP to take `pad_multiple` as input so that it works
with MXFP8.
- flatten `common/moe/` folder by moving `moe.py` and `moe_deepep.py` to
`common/` and remove `utils.py`
- remove `dual_pipe_v.py` as it doesn't compose with SAC and is not
maintained.
- disabled `compile.enable` in llama4 and gpt-oss CI as they break the
CI even on main, tracking in
pytorch#2771 and
pytorch#2776, respectively

Numerics of before vs. after on llama4 debugmodel [dp8, ep4] are bitwise
identical.

Consolidate apply_compile_dense and apply_compile_sparse into a single
apply_compile function. The only difference was capture_scalar_outputs
which is harmless for dense models.

Remove the _run_experts_grouped_mm separate compile boundary and EP
wrapper — no longer needed after fixing the symbolic shape issue in
_generate_permute_indices.

Fix _generate_permute_indices to use torch.arange(seg_ids.shape[0])
instead of torch.arange(total), reusing the unbacked symint from
repeat_interleave rather than creating a redundant one that produces
an Eq(u1, u2) constraint inductor cannot lower.

Remove the x[:total_tokens] slice in _run_experts_for_loop — padding
was removed in pytorch#2774, so sum(num_tokens_per_expert) == x.shape[0] and
the slice is a no-op. This also eliminates the need for torch._check
guards on the unbacked symint.

Consolidate apply_compile_dense and apply_compile_sparse into a single
apply_compile function. The only difference was capture_scalar_outputs
which is harmless for dense models.

Remove the _run_experts_grouped_mm separate compile boundary and EP
wrapper — no longer needed after fixing the symbolic shape issue in
_generate_permute_indices.

Fix _generate_permute_indices to use torch.arange(seg_ids.shape[0])
instead of torch.arange(total), reusing the unbacked symint from
repeat_interleave rather than creating a redundant one that produces
an Eq(u1, u2) constraint inductor cannot lower.

Remove the x[:total_tokens] slice in _run_experts_for_loop — padding
was removed in pytorch#2774, so sum(num_tokens_per_expert) == x.shape[0] and
the slice is a no-op. This also eliminates the need for torch._check
guards on the unbacked symint.

Consolidate apply_compile_dense and apply_compile_sparse into a single
apply_compile function. The only difference was capture_scalar_outputs
which is harmless for dense models.

Remove the _run_experts_grouped_mm separate compile boundary and EP
wrapper — no longer needed after fixing the symbolic shape issue in
_generate_permute_indices.

Fix _generate_permute_indices to use torch.arange(seg_ids.shape[0])
instead of torch.arange(total), reusing the unbacked symint from
repeat_interleave rather than creating a redundant one that produces
an Eq(u1, u2) constraint inductor cannot lower.

Remove the x[:total_tokens] slice in _run_experts_for_loop — padding
was removed in pytorch#2774, so sum(num_tokens_per_expert) == x.shape[0] and
the slice is a no-op. This also eliminates the need for torch._check
guards on the unbacked symint.

Consolidate apply_compile_dense and apply_compile_sparse into a single
apply_compile function. The only difference was capture_scalar_outputs
which is harmless for dense models.

Remove the _run_experts_grouped_mm separate compile boundary and EP
wrapper — no longer needed after fixing the symbolic shape issue in
_generate_permute_indices.

Fix _generate_permute_indices to use torch.arange(seg_ids.shape[0])
instead of torch.arange(total), reusing the unbacked symint from
repeat_interleave rather than creating a redundant one that produces
an Eq(u1, u2) constraint inductor cannot lower.

Remove the x[:total_tokens] slice in _run_experts_for_loop — padding
was removed in pytorch#2774, so sum(num_tokens_per_expert) == x.shape[0] and
the slice is a no-op. This also eliminates the need for torch._check
guards on the unbacked symint.

Consolidate apply_compile_dense and apply_compile_sparse into a single
apply_compile function. The only difference was capture_scalar_outputs
which is harmless for dense models.

Remove the _run_experts_grouped_mm separate compile boundary and EP
wrapper — no longer needed after fixing the symbolic shape issue in
_generate_permute_indices.

Fix _generate_permute_indices to use torch.arange(seg_ids.shape[0])
instead of torch.arange(total), reusing the unbacked symint from
repeat_interleave rather than creating a redundant one that produces
an Eq(u1, u2) constraint inductor cannot lower.

Remove the x[:total_tokens] slice in _run_experts_for_loop — padding
was removed in pytorch#2774, so sum(num_tokens_per_expert) == x.shape[0] and
the slice is a no-op. This also eliminates the need for torch._check
guards on the unbacked symint.

Consolidate apply_compile_dense and apply_compile_sparse into a single
apply_compile function. The only difference was capture_scalar_outputs
which is harmless for dense models.

Remove the _run_experts_grouped_mm separate compile boundary and EP
wrapper — no longer needed after fixing the symbolic shape issue in
_generate_permute_indices.

Fix _generate_permute_indices to use torch.arange(seg_ids.shape[0])
instead of torch.arange(total), reusing the unbacked symint from
repeat_interleave rather than creating a redundant one that produces
an Eq(u1, u2) constraint inductor cannot lower.

Remove the x[:total_tokens] slice in _run_experts_for_loop — padding
was removed in pytorch#2774, so sum(num_tokens_per_expert) == x.shape[0] and
the slice is a no-op. This also eliminates the need for torch._check
guards on the unbacked symint.

Consolidate apply_compile_dense and apply_compile_sparse into a single
apply_compile function. The only difference was capture_scalar_outputs
which is harmless for dense models.

Remove the _run_experts_grouped_mm separate compile boundary and EP
wrapper — no longer needed after fixing the symbolic shape issue in
_generate_permute_indices.

Fix _generate_permute_indices to use torch.arange(seg_ids.shape[0])
instead of torch.arange(total), reusing the unbacked symint from
repeat_interleave rather than creating a redundant one that produces
an Eq(u1, u2) constraint inductor cannot lower.

Remove the x[:total_tokens] slice in _run_experts_for_loop — padding
was removed in pytorch#2774, so sum(num_tokens_per_expert) == x.shape[0] and
the slice is a no-op. This also eliminates the need for torch._check
guards on the unbacked symint.

Consolidate apply_compile_dense and apply_compile_sparse into a single
apply_compile function. The only difference was capture_scalar_outputs
which is harmless for dense models.

Remove the _run_experts_grouped_mm separate compile boundary and EP
wrapper — no longer needed after fixing the symbolic shape issue in
_generate_permute_indices.

Fix _generate_permute_indices to use torch.arange(seg_ids.shape[0])
instead of torch.arange(total), reusing the unbacked symint from
repeat_interleave rather than creating a redundant one that produces
an Eq(u1, u2) constraint inductor cannot lower.

Remove the x[:total_tokens] slice in _run_experts_for_loop — padding
was removed in pytorch#2774, so sum(num_tokens_per_expert) == x.shape[0] and
the slice is a no-op. This also eliminates the need for torch._check
guards on the unbacked symint.

Consolidate apply_compile_dense and apply_compile_sparse into a single
apply_compile function. The only difference was capture_scalar_outputs
which is harmless for dense models.

Remove the _run_experts_grouped_mm separate compile boundary and EP
wrapper — no longer needed after fixing the symbolic shape issue in
_generate_permute_indices.

Fix _generate_permute_indices to use torch.arange(seg_ids.shape[0])
instead of torch.arange(total), reusing the unbacked symint from
repeat_interleave rather than creating a redundant one that produces
an Eq(u1, u2) constraint inductor cannot lower.

Remove the x[:total_tokens] slice in _run_experts_for_loop — padding
was removed in pytorch#2774, so sum(num_tokens_per_expert) == x.shape[0] and
the slice is a no-op. This also eliminates the need for torch._check
guards on the unbacked symint.

Consolidate apply_compile_dense and apply_compile_sparse into a single
apply_compile function. The only difference was capture_scalar_outputs
which is harmless for dense models.

Remove the _run_experts_grouped_mm separate compile boundary and EP
wrapper — no longer needed after fixing the symbolic shape issue in
_generate_permute_indices.

Fix _generate_permute_indices to use torch.arange(seg_ids.shape[0])
instead of torch.arange(total), reusing the unbacked symint from
repeat_interleave rather than creating a redundant one that produces
an Eq(u1, u2) constraint inductor cannot lower.

Remove the x[:total_tokens] slice in _run_experts_for_loop — padding
was removed in pytorch#2774, so sum(num_tokens_per_expert) == x.shape[0] and
the slice is a no-op. This also eliminates the need for torch._check
guards on the unbacked symint.

Consolidate apply_compile_dense and apply_compile_sparse into a single
apply_compile function. The only difference was capture_scalar_outputs
which is harmless for dense models.

Remove the _run_experts_grouped_mm separate compile boundary and EP
wrapper — no longer needed after fixing the symbolic shape issue in
_generate_permute_indices.

Fix _generate_permute_indices to use torch.arange(seg_ids.shape[0])
instead of torch.arange(total), reusing the unbacked symint from
repeat_interleave rather than creating a redundant one that produces
an Eq(u1, u2) constraint inductor cannot lower.

Remove the x[:total_tokens] slice in _run_experts_for_loop — padding
was removed in pytorch#2774, so sum(num_tokens_per_expert) == x.shape[0] and
the slice is a no-op. This also eliminates the need for torch._check
guards on the unbacked symint.

Consolidate apply_compile_dense and apply_compile_sparse into a single
apply_compile function. The only difference was capture_scalar_outputs
which is harmless for dense models.

Remove the _run_experts_grouped_mm separate compile boundary and EP
wrapper — no longer needed after fixing the symbolic shape issue in
_generate_permute_indices.

Fix _generate_permute_indices to use torch.arange(seg_ids.shape[0])
instead of torch.arange(total), reusing the unbacked symint from
repeat_interleave rather than creating a redundant one that produces
an Eq(u1, u2) constraint inductor cannot lower.

Remove the x[:total_tokens] slice in _run_experts_for_loop — padding
was removed in pytorch#2774, so sum(num_tokens_per_expert) == x.shape[0] and
the slice is a no-op. This also eliminates the need for torch._check
guards on the unbacked symint.

Consolidate apply_compile_dense and apply_compile_sparse into a single
apply_compile function. The only difference was capture_scalar_outputs
which is harmless for dense models.

Remove the _run_experts_grouped_mm separate compile boundary and EP
wrapper — no longer needed after fixing the symbolic shape issue in
_generate_permute_indices.

Fix _generate_permute_indices to use torch.arange(seg_ids.shape[0])
instead of torch.arange(total), reusing the unbacked symint from
repeat_interleave rather than creating a redundant one that produces
an Eq(u1, u2) constraint inductor cannot lower.

Remove the x[:total_tokens] slice in _run_experts_for_loop — padding
was removed in pytorch#2774, so sum(num_tokens_per_expert) == x.shape[0] and
the slice is a no-op. This also eliminates the need for torch._check
guards on the unbacked symint.

Consolidate apply_compile_dense and apply_compile_sparse into a single
apply_compile function. The only difference was capture_scalar_outputs
which is harmless for dense models.

Remove the _run_experts_grouped_mm separate compile boundary and EP
wrapper — no longer needed after fixing the symbolic shape issue in
_generate_permute_indices.

Fix _generate_permute_indices to use torch.arange(seg_ids.shape[0])
instead of torch.arange(total), reusing the unbacked symint from
repeat_interleave rather than creating a redundant one that produces
an Eq(u1, u2) constraint inductor cannot lower.

Remove the x[:total_tokens] slice in _run_experts_for_loop — padding
was removed in pytorch#2774, so sum(num_tokens_per_expert) == x.shape[0] and
the slice is a no-op. This also eliminates the need for torch._check
guards on the unbacked symint.

Consolidate apply_compile_dense and apply_compile_sparse into a single
apply_compile function. The only difference was capture_scalar_outputs
which is harmless for dense models.

Remove the _run_experts_grouped_mm separate compile boundary and EP
wrapper — no longer needed after fixing the symbolic shape issue in
_generate_permute_indices.

Fix _generate_permute_indices to use torch.arange(seg_ids.shape[0])
instead of torch.arange(total), reusing the unbacked symint from
repeat_interleave rather than creating a redundant one that produces
an Eq(u1, u2) constraint inductor cannot lower.

Remove the x[:total_tokens] slice in _run_experts_for_loop — padding
was removed in pytorch#2774, so sum(num_tokens_per_expert) == x.shape[0] and
the slice is a no-op. This also eliminates the need for torch._check
guards on the unbacked symint.

Consolidate apply_compile_dense and apply_compile_sparse into a single
apply_compile function. The only difference was capture_scalar_outputs
which is harmless for dense models.

Remove the _run_experts_grouped_mm separate compile boundary and EP
wrapper — no longer needed after fixing the symbolic shape issue in
_generate_permute_indices.

Fix _generate_permute_indices to use torch.arange(seg_ids.shape[0])
instead of torch.arange(total), reusing the unbacked symint from
repeat_interleave rather than creating a redundant one that produces
an Eq(u1, u2) constraint inductor cannot lower.

Remove the x[:total_tokens] slice in _run_experts_for_loop — padding
was removed in pytorch#2774, so sum(num_tokens_per_expert) == x.shape[0] and
the slice is a no-op. This also eliminates the need for torch._check
guards on the unbacked symint.

Consolidate apply_compile_dense and apply_compile_sparse into a single
apply_compile function. The only difference was capture_scalar_outputs
which is harmless for dense models.

Remove the _run_experts_grouped_mm separate compile boundary and EP
wrapper — no longer needed after fixing the symbolic shape issue in
_generate_permute_indices.

Fix _generate_permute_indices to use torch.arange(seg_ids.shape[0])
instead of torch.arange(total), reusing the unbacked symint from
repeat_interleave rather than creating a redundant one that produces
an Eq(u1, u2) constraint inductor cannot lower.

Remove the x[:total_tokens] slice in _run_experts_for_loop — padding
was removed in pytorch#2774, so sum(num_tokens_per_expert) == x.shape[0] and
the slice is a no-op. This also eliminates the need for torch._check
guards on the unbacked symint.

Consolidate apply_compile_dense and apply_compile_sparse into a single
apply_compile function. The only difference was capture_scalar_outputs
which is harmless for dense models.

Remove the _run_experts_grouped_mm separate compile boundary and EP
wrapper — no longer needed after fixing the symbolic shape issue in
_generate_permute_indices.

Fix _generate_permute_indices to use torch.arange(seg_ids.shape[0])
instead of torch.arange(total), reusing the unbacked symint from
repeat_interleave rather than creating a redundant one that produces
an Eq(u1, u2) constraint inductor cannot lower.

Remove the x[:total_tokens] slice in _run_experts_for_loop — padding
was removed in pytorch#2774, so sum(num_tokens_per_expert) == x.shape[0] and
the slice is a no-op. This also eliminates the need for torch._check
guards on the unbacked symint.

Consolidate apply_compile_dense and apply_compile_sparse into a single
apply_compile function. The only difference was capture_scalar_outputs
which is harmless for dense models.

Remove the _run_experts_grouped_mm separate compile boundary and EP
wrapper — no longer needed after fixing the symbolic shape issue in
_generate_permute_indices.

Fix _generate_permute_indices to use torch.arange(seg_ids.shape[0])
instead of torch.arange(total), reusing the unbacked symint from
repeat_interleave rather than creating a redundant one that produces
an Eq(u1, u2) constraint inductor cannot lower.

Remove the x[:total_tokens] slice in _run_experts_for_loop — padding
was removed in pytorch#2774, so sum(num_tokens_per_expert) == x.shape[0] and
the slice is a no-op. This also eliminates the need for torch._check
guards on the unbacked symint.

Consolidate apply_compile_dense and apply_compile_sparse into a single
apply_compile function. The only difference was capture_scalar_outputs
which is harmless for dense models.

Drop the ep_enabled parameter — mark_dynamic is now applied
unconditionally (harmless without EP) and the idempotency check uses a
simple _tt_compiled attribute instead of qualname matching.

Remove the x[:total_tokens] slice in _run_experts_for_loop — padding
was removed in pytorch#2774, so sum(num_tokens_per_expert) == x.shape[0] and
the slice is a no-op.

Consolidate apply_compile_dense and apply_compile_sparse into a single
apply_compile function. The only difference was capture_scalar_outputs
which is harmless for dense models.

Remove the _run_experts_grouped_mm separate compile boundary and EP
wrapper — no longer needed after fixing the symbolic shape issue in
_generate_permute_indices.

Fix _generate_permute_indices to use torch.arange(seg_ids.shape[0])
instead of torch.arange(total), reusing the unbacked symint from
repeat_interleave rather than creating a redundant one that produces
an Eq(u1, u2) constraint inductor cannot lower.

Remove the x[:total_tokens] slice in _run_experts_for_loop — padding
was removed in pytorch#2774, so sum(num_tokens_per_expert) == x.shape[0] and
the slice is a no-op. This also eliminates the need for torch._check
guards on the unbacked symint.

Consolidate apply_compile_dense and apply_compile_sparse into a single
apply_compile function. The only difference was capture_scalar_outputs
which is harmless for dense models.

Remove the _run_experts_grouped_mm separate compile boundary and EP
wrapper — no longer needed after fixing the symbolic shape issue in
_generate_permute_indices.

Fix _generate_permute_indices to use torch.arange(seg_ids.shape[0])
instead of torch.arange(total), reusing the unbacked symint from
repeat_interleave rather than creating a redundant one that produces
an Eq(u1, u2) constraint inductor cannot lower.

Remove the x[:total_tokens] slice in _run_experts_for_loop — padding
was removed in pytorch#2774, so sum(num_tokens_per_expert) == x.shape[0] and
the slice is a no-op. This also eliminates the need for torch._check
guards on the unbacked symint.

Consolidate apply_compile_dense and apply_compile_sparse into a single
apply_compile function. The only difference was capture_scalar_outputs
which is harmless for dense models.

Remove the _run_experts_grouped_mm separate compile boundary and EP
wrapper — no longer needed now that the CI uses cu130+ nightly which
handles the unbacked-symint Eq(u1, u2) constraints in inductor.

Remove the x[:total_tokens] slice in _run_experts_for_loop — padding
was removed in pytorch#2774, so sum(num_tokens_per_expert) == x.shape[0] and
the slice is a no-op.

Consolidate apply_compile_dense and apply_compile_sparse into a single
apply_compile function. The only difference was capture_scalar_outputs
which is harmless for dense models.

Remove the _run_experts_grouped_mm separate compile boundary and EP
wrapper — no longer needed now that the CI uses cu130+ nightly which
handles the unbacked-symint Eq(u1, u2) constraints in inductor.

Remove the x[:total_tokens] slice in _run_experts_for_loop — padding
was removed in pytorch#2774, so sum(num_tokens_per_expert) == x.shape[0] and
the slice is a no-op.

including
- remove triton kernel for permutation+padding as it is not required by
default bf16 grouped mm.
- replace the kernel with a torch-native `generate_permutation_indices`
impl, which doesn't do padding.
- added `TorchAOExpertParallel` to do permutation+padding during EP
using the same triton kernel moved to torchao.
- added a `llama4_debugmodel_fp8` in llama4 `config_registry` to
demonstrate
- refactored HybridEP to take `pad_multiple` as input so that it works
with MXFP8.
- flatten `common/moe/` folder by moving `moe.py` and `moe_deepep.py` to
`common/` and remove `utils.py`
- remove `dual_pipe_v.py` as it doesn't compose with SAC and is not
maintained.
- disabled `compile.enable` in llama4 and gpt-oss CI as they break the
CI even on main, tracking in
pytorch#2771 and
pytorch#2776, respectively

Numerics of before vs. after on llama4 debugmodel [dp8, ep4] are bitwise
identical.