Upload folder using huggingface_hub

tile_kernels_src/.editorconfig

@@ -0,0 +1,58 @@
+# https://editorconfig.org/
+
+root = true
+
+[*]
+charset = utf-8
+end_of_line = lf
+indent_style = space
+indent_size = 4
+trim_trailing_whitespace = true
+insert_final_newline = true
+
+[*.{py,pyi}]
+indent_size = 4
+
+[*.{cpp,hpp,cxx,cc,c,h,cu,cuh}]
+indent_size = 4
+
+[*.rs]
+indent_size = 4
+
+[*.go]
+indent_style = tab
+
+[*.{yaml,yml}]
+indent_size = 2
+
+[.clang-{format,tidy}]
+indent_size = 2
+
+[Makefile]
+indent_style = tab
+
+[*.sh]
+indent_size = 4
+
+[*.bat]
+indent_size = 4
+end_of_line = crlf
+
+[*.md]
+indent_size = 2
+x-soft-wrap-text = true
+
+[*.rst]
+indent_size = 4
+x-soft-wrap-text = true
+
+[*.{html,xml,css,scss,js,jsx,ts,tsx,vue}]
+indent_size = 2
+
+[**/test{,s,ing}/**/*.txt]
+trim_trailing_whitespace = false
+insert_final_newline = false
+
+[**/example{,s}/**/*.txt]
+trim_trailing_whitespace = false
+insert_final_newline = false

tile_kernels_src/.gitignore

@@ -0,0 +1,20 @@
+.DS_Store
+build
+dist
+*.egg-info
+*.pyc
+__pycache__/
+
+# PyCharm Settings
+.idea/
+*.iml
+*.iws
+
+# Python packaging version file
+_version.py
+
+# VSCode Settings
+/.vscode
+
+# workspace
+workspace

tile_kernels_src/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 DeepSeek
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

tile_kernels_src/README.md

@@ -0,0 +1,88 @@
+# Tile Kernels
+
+Optimized GPU kernels for LLM operations, built with [TileLang](https://github.com/tile-ai/tilelang). TileLang is a domain-specific language for expressing high-performance GPU kernels in Python, featuring easy migration, agile development, and automatic optimization.
+
+Most kernels in this project approach the limit of hardware performance regarding the compute intensity and memory bandwidth. Some of them have already been used in internal training and inference scenarios. However, they do not represent best practices and we are actively working on improving the code quality and documentation.
+
+## Features
+
+- **Gating** — Top-k expert selection and scoring for Mixture of Experts routing
+- **MoE Routing** — Token-to-expert mapping, fused expansion/reduction and weight normalization
+- **Quantization** — Per-token, per-block, and per-channel FP8/FP4/E5M6 casting with fused SwiGLU+quantization ops
+- **Transpose** — Batched transpose operations
+- **Engram** — Engram gating kernels with fused RMSNorm, forward/backward passes and weight gradient reduction
+- **Manifold HyperConnection** — Hyper-connection kernels including Sinkhorn normalization and mix splitting/application
+- **Modeling** — High-level `torch.autograd.Function` wrappers composing low-level kernels into trainable layers (engram gate, mHC pipeline)
+
+## Requirements
+
+- Python 3.10 or higher
+- PyTorch 2.10 or higher
+- TileLang 0.1.9 or higher
+- NVIDIA SM90 or SM100 architecture GPU
+- CUDA Toolkit 13.1 or higher
+
+## Installation
+
+### Install a local development version
+
+```bash
+pip install -e ".[dev]"
+```
+
+### Install a release version
+
+```bash
+pip install tile-kernels
+```
+
+## Testing
+
+Tests using pytest:
+
+### Test single test file
+
+```bash
+pytest tests/transpose/test_transpose.py -n 4 # Correctness only with 4 workers
+pytest tests/transpose/test_transpose.py --run-benchmark # Correctness + Benchmarking
+```
+
+### Pressure test
+
+```bash
+TK_FULL_TEST=1 pytest -n 4 --count 2
+```
+
+## Project Structure
+
+```txt
+tile_kernels/
+├── moe/        # Mixture of Experts routing related kernels
+├── quant/      # FP8/FP4/E5M6 quantization
+├── transpose/  # Batched transpose
+├── engram/     # Engram gating kernels
+├── mhc/        # Manifold HyperConnection kernels
+├── modeling/   # High-level autograd modeling layers (engram, mHC)
+├── torch/      # PyTorch reference implementations
+└── testing/    # Test and benchmark utilities
+```
+
+## Acknowledgement
+
+This project is built on [TileLang](https://github.com/tile-ai/tilelang). Thanks and respect to the developers!
+
+## License
+
+This code repository is released under [the MIT License](LICENSE).
+
+## Citation
+
+```bibtex
+@misc{tilekernels,
+      title={TileKernels},
+      author={Xiangwen Wang, Chenhao Xu, Huanqi Cao, Rui Tian, Weilin Zhao, Kuai Yu and Chenggang Zhao},
+      year={2026},
+      publisher = {GitHub},
+      howpublished = {\url{https://github.com/deepseek-ai/TileKernels}},
+}
+```

tile_kernels_src/UNKNOWN.egg-info/PKG-INFO

@@ -0,0 +1,11 @@
+Metadata-Version: 2.1
+Name: UNKNOWN
+Version: 0.1.dev3+g36d9e45d3
+Summary: UNKNOWN
+Home-page: UNKNOWN
+License: UNKNOWN
+Platform: UNKNOWN
+License-File: LICENSE
+
+UNKNOWN
+

tile_kernels_src/UNKNOWN.egg-info/SOURCES.txt

@@ -0,0 +1,131 @@
+.editorconfig
+.gitignore
+LICENSE
+README.md
+pyproject.toml
+UNKNOWN.egg-info/PKG-INFO
+UNKNOWN.egg-info/SOURCES.txt
+UNKNOWN.egg-info/dependency_links.txt
+UNKNOWN.egg-info/top_level.txt
+tests/__init__.py
+tests/conftest.py
+tests/pytest_benchmark_plugin.py
+tests/pytest_random_plugin.py
+tests/engram/test_engram_fused_weight.py
+tests/engram/test_engram_gate_bwd.py
+tests/engram/test_engram_gate_fwd.py
+tests/engram/test_engram_grad_w_reduce.py
+tests/engram/test_engram_hash.py
+tests/mhc/test_expand.py
+tests/mhc/test_head_compute_mix.py
+tests/mhc/test_multilayer_recompute.py
+tests/mhc/test_norm_fn.py
+tests/mhc/test_post.py
+tests/mhc/test_pre_apply_mix.py
+tests/mhc/test_pre_big_fuse.py
+tests/mhc/test_pre_split_mixes.py
+tests/mhc/test_sinkhorn.py
+tests/moe/test_aux_fi.py
+tests/moe/test_expand_to_fused.py
+tests/moe/test_get_fused_mapping.py
+tests/moe/test_group_count.py
+tests/moe/test_inplace_unique_group_indices.py
+tests/moe/test_mask_indices_by_tp.py
+tests/moe/test_normalize_weight.py
+tests/moe/test_reduce_fused.py
+tests/moe/test_top2_sum_gate.py
+tests/moe/test_topk_gate.py
+tests/moe/test_topk_sum_and_topk_idx.py
+tests/quant/test_cast_back.py
+tests/quant/test_cast_back_e5m6.py
+tests/quant/test_per_block_cast.py
+tests/quant/test_per_block_cast_lossless.py
+tests/quant/test_per_channel_cast.py
+tests/quant/test_per_channel_cast_and_transpose.py
+tests/quant/test_per_channel_cast_fused.py
+tests/quant/test_per_token_cast.py
+tests/quant/test_per_token_cast_to_e5m6.py
+tests/quant/test_swiglu_backward_and_per_token_cast.py
+tests/quant/test_swiglu_forward_and_per_channel_cast_and_transpose.py
+tests/quant/test_swiglu_forward_and_per_token_cast.py
+tests/transpose/test_transpose.py
+tile_kernels/__init__.py
+tile_kernels/config.py
+tile_kernels/utils.py
+tile_kernels/engram/__init__.py
+tile_kernels/engram/engram_fused_weight_kernel.py
+tile_kernels/engram/engram_gate_kernel.py
+tile_kernels/engram/engram_grad_w_reduce_kernel.py
+tile_kernels/engram/engram_hash_kernel.py
+tile_kernels/mhc/__init__.py
+tile_kernels/mhc/expand_kernel.py
+tile_kernels/mhc/head_compute_mix_kernel.py
+tile_kernels/mhc/multilayer_recompute_kernel.py
+tile_kernels/mhc/norm_fn_kernel.py
+tile_kernels/mhc/post_kernel.py
+tile_kernels/mhc/pre_apply_mix_kernel.py
+tile_kernels/mhc/pre_big_fuse_kernel.py
+tile_kernels/mhc/pre_split_mixes_kernel.py
+tile_kernels/mhc/sinkhorn_kernel.py
+tile_kernels/modeling/__init__.py
+tile_kernels/modeling/engram/__init__.py
+tile_kernels/modeling/engram/engram_gate.py
+tile_kernels/modeling/mhc/__init__.py
+tile_kernels/modeling/mhc/functional.py
+tile_kernels/modeling/mhc/ops/__init__.py
+tile_kernels/modeling/mhc/ops/expand.py
+tile_kernels/modeling/mhc/ops/head_compute_mix.py
+tile_kernels/modeling/mhc/ops/multilayer_recompute.py
+tile_kernels/modeling/mhc/ops/norm_fn.py
+tile_kernels/modeling/mhc/ops/post.py
+tile_kernels/modeling/mhc/ops/pre_apply_mix.py
+tile_kernels/modeling/mhc/ops/pre_big_fuse.py
+tile_kernels/modeling/mhc/ops/pre_split_mixes.py
+tile_kernels/modeling/mhc/ops/sinkhorn.py
+tile_kernels/moe/__init__.py
+tile_kernels/moe/aux_fi_kernel.py
+tile_kernels/moe/common.py
+tile_kernels/moe/expand_to_fused_kernel.py
+tile_kernels/moe/get_fused_mapping_kernel.py
+tile_kernels/moe/group_count_kernel.py
+tile_kernels/moe/inplace_unique_group_indices_kernel.py
+tile_kernels/moe/mask_indices_by_tp_kernel.py
+tile_kernels/moe/normalize_weight_kernel.py
+tile_kernels/moe/reduce_fused_kernel.py
+tile_kernels/moe/scoring.py
+tile_kernels/moe/top2_sum_gate_kernel.py
+tile_kernels/moe/topk_gate_kernel.py
+tile_kernels/moe/topk_sum_and_topk_group_idx_kernel.py
+tile_kernels/quant/__init__.py
+tile_kernels/quant/cast_back_e5m6_kernel.py
+tile_kernels/quant/cast_back_kernel.py
+tile_kernels/quant/common.py
+tile_kernels/quant/per_block_cast_kernel.py
+tile_kernels/quant/per_block_cast_lossless_kernel.py
+tile_kernels/quant/per_channel_cast_and_transpose_kernel.py
+tile_kernels/quant/per_channel_cast_fused_kernel.py
+tile_kernels/quant/per_channel_cast_kernel.py
+tile_kernels/quant/per_token_cast_kernel.py
+tile_kernels/quant/per_token_cast_to_e5m6_kernel.py
+tile_kernels/quant/swiglu_backward_and_per_token_cast_kernel.py
+tile_kernels/quant/swiglu_forward_and_per_channel_cast_and_transpose_kernel.py
+tile_kernels/quant/swiglu_forward_and_per_token_cast_kernel.py
+tile_kernels/quant/types.py
+tile_kernels/testing/__init__.py
+tile_kernels/testing/bench.py
+tile_kernels/testing/generator.py
+tile_kernels/testing/numeric.py
+tile_kernels/testing/quant.py
+tile_kernels/torch/__init__.py
+tile_kernels/torch/cast.py
+tile_kernels/torch/cast_e5m6.py
+tile_kernels/torch/engram.py
+tile_kernels/torch/expand_to_fused.py
+tile_kernels/torch/mhc.py
+tile_kernels/torch/moe.py
+tile_kernels/torch/per_channel_cast_fused.py
+tile_kernels/torch/reduce_fused.py
+tile_kernels/torch/swiglu.py
+tile_kernels/torch/topk.py
+tile_kernels/transpose/__init__.py
+tile_kernels/transpose/batched_transpose_kernel.py

tile_kernels_src/UNKNOWN.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

tile_kernels_src/UNKNOWN.egg-info/top_level.txt

@@ -0,0 +1 @@
+

tile_kernels_src/pyproject.toml

@@ -0,0 +1,58 @@
+[build-system]
+requires = ["setuptools", "wheel", "setuptools-scm>=8"]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools_scm]
+version_file = "tile_kernels/_version.py"
+
+[project]
+name = "tile_kernels"
+dynamic = ["version"]
+description = "Tilelang-based kernels."
+readme = "README.md"
+license = "MIT"
+authors = [
+    { name = "Chenhao Xu", email = "xch@deepseek.com" },
+    { name = "Xiangwen Wang", email = "xiangwen.wang@deepseek.com" },
+    { name = "Huanqi Cao", email = "caohuanqi@deepseek.com" },
+    { name = "Rui Tian", email = "tianr22@deepseek.com"},
+    { name = "Weilin Zhao", email = "zhaoweilin@deepseek.com" },
+    { name = "Kuai Yu", email = "yukuai@deepseek.com" },
+    { name = "Chenggang Zhao", email = "chenggangz@deepseek.com"}
+]
+dependencies = [
+    "torch>=2.10",
+    "tilelang>=0.1.9"
+]
+requires-python = ">=3.10"
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+]
+
+[project.optional-dependencies]
+dev = ["setuptools", "wheel", "setuptools-scm>=8", "pytest", "pytest-xdist", "pytest-repeat"]
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["tile_kernels*"]
+
+[project.urls]
+Homepage = "https://github.com/deepseek-ai/TileKernels"
+
+# Linter tools
+
+[tool.ruff]
+line-length = 150
+
+[tool.ruff.lint]
+select = ["Q000"]
+fixable = ["Q000"]
+
+[tool.ruff.lint.flake8-quotes]
+inline-quotes = "single"

tile_kernels_src/tests/conftest.py

@@ -0,0 +1,10 @@
+# Root-level conftest
+#
+# Loads the benchmark plugin (CLI options, markers, fixtures).
+# The plugin lives in a file deliberately NOT named conftest.py to
+# avoid pluggy's duplicate-registration error.
+
+pytest_plugins = [
+    'tests.pytest_random_plugin',
+    'tests.pytest_benchmark_plugin',
+]

tile_kernels_src/tests/engram/test_engram_fused_weight.py

@@ -0,0 +1,56 @@
+import os
+import pytest
+import torch
+
+from tile_kernels.engram import fused_weight
+from tile_kernels.testing.numeric import assert_equal, count_bytes
+from tile_kernels.testing.generator import generate_hidden_sizes
+from tile_kernels.testing.bench import make_param_id
+
+# Disable TileLang prints
+os.environ['TILELANG_PRINT_ON_COMPILATION'] = '0'
+
+
+def generate_test_data(params):
+    hc_mult = params['hc']
+    hidden_size = params['hidden']
+    wh_data = torch.randn(hc_mult, hidden_size, dtype=torch.bfloat16, device='cuda')
+    we_data = torch.randn(hc_mult, hidden_size, dtype=torch.bfloat16, device='cuda')
+    return (wh_data, we_data)
+
+
+def generate_test_params(is_benchmark: bool) -> list[dict]:
+    return [
+        {'hc': hc, 'hidden': hidden_size}
+        for hc in (4,)
+        for hidden_size in generate_hidden_sizes(128)
+    ]
+
+
+@pytest.mark.parametrize('params', generate_test_params(is_benchmark=False), ids=make_param_id)
+def test_engram_fused_weight(params):
+    wh_data, we_data = generate_test_data(params)
+
+    ref = wh_data.float() * we_data.float()
+    out = fused_weight(wh_data, we_data)
+
+    assert_equal(out, ref)
+
+
+@pytest.mark.benchmark
+@pytest.mark.parametrize('params', generate_test_params(is_benchmark=True), ids=make_param_id)
+def test_engram_fused_weight_benchmark(benchmark_timer, benchmark_record, params):
+    wh_data, we_data = generate_test_data(params)
+    out = fused_weight(wh_data, we_data)
+
+    t_us = benchmark_timer(lambda: fused_weight(wh_data, we_data))
+
+    num_bytes = count_bytes(wh_data, we_data, out)
+    bandwidth_gbs = num_bytes / t_us / 1e3
+    benchmark_record(
+        kernel='fused_weight',
+        operation='fwd',
+        params=params,
+        time_us=t_us,
+        bandwidth_gbs=bandwidth_gbs,
+    )

tile_kernels_src/tests/engram/test_engram_gate_bwd.py

@@ -0,0 +1,112 @@
+import os
+import pytest
+import torch
+
+from tile_kernels.engram import engram_gate_bwd
+from tile_kernels.torch.engram import engram_gate_ref
+from tile_kernels.testing.numeric import calc_diff, count_bytes
+from tile_kernels.testing.generator import generate_hidden_sizes, generate_num_tokens
+from tile_kernels.testing.bench import make_param_id
+
+# Disable TileLang prints
+os.environ['TILELANG_PRINT_ON_COMPILATION'] = '0'
+
+
+def generate_test_data(params):
+    num_tokens = params['num_tokens']
+    hc_mult = params['hc']
+    hidden_size = params['hidden']
+    eps = 1e-20
+    clamp_value = 1e-6
+    x_data = torch.randn(num_tokens, hc_mult, hidden_size, dtype=torch.bfloat16, device='cuda')
+    k_data = torch.randn(num_tokens, hc_mult, hidden_size, dtype=torch.bfloat16, device='cuda')
+    v_data = torch.randn(num_tokens, hidden_size, dtype=torch.bfloat16, device='cuda')
+    wh_data = torch.randn(hc_mult, hidden_size, dtype=torch.bfloat16, device='cuda')
+    we_data = torch.randn(hc_mult, hidden_size, dtype=torch.bfloat16, device='cuda')
+    weight_fused = wh_data.float() * we_data.float()
+    grad_out = torch.randn(num_tokens, hc_mult, hidden_size, dtype=torch.bfloat16, device='cuda')
+    return (x_data, k_data, v_data, wh_data, we_data, weight_fused, grad_out, eps, clamp_value)
+
+
+def generate_test_params(is_benchmark: bool) -> list[dict]:
+    return [
+        {'num_tokens': t, 'hc': hc, 'hidden': hidden_size}
+        for t in generate_num_tokens(is_benchmark=is_benchmark)
+        for hc in (4,)
+        for hidden_size in generate_hidden_sizes(128)
+    ]
+
+
+@pytest.mark.parametrize('params', generate_test_params(is_benchmark=False), ids=make_param_id)
+def test_engram_gate_bwd(params):
+    (x_data, k_data, v_data, wh_data, we_data, weight_fused, grad_out, eps, clamp_value) = generate_test_data(params)
+
+    # Reference: forward with intermediates + autograd backward
+    x_ref = x_data.clone().requires_grad_(True)
+    k_ref = k_data.clone().requires_grad_(True)
+    v_ref = v_data.clone().requires_grad_(True)
+    # Cast to float32 so autograd produces fp32 gradients matching the kernel
+    wh_ref = wh_data.float().requires_grad_(True)
+    we_ref = we_data.float().requires_grad_(True)
+    o_ref, dot_ref, gate_score_ref, rstd_x_ref, rstd_k_ref = engram_gate_ref(
+        x_ref, k_ref, v_ref, wh_ref, we_ref, clamp_value, eps, save_for_backward=True,
+    )
+    o_ref.backward(grad_out)
+
+    # Kernel backward using ref intermediates
+    grad_x, grad_k, grad_v, grad_w_partial = engram_gate_bwd(
+        grad_out, x_data, k_data, v_data, weight_fused,
+        dot_ref, gate_score_ref, rstd_x_ref, rstd_k_ref, clamp_value,
+    )
+    grad_w_fused = grad_w_partial.sum(0)
+    grad_wh = grad_w_fused * we_data.float()
+    grad_we = grad_w_fused * wh_data.float()
+
+    # Correctness
+    diff_x = calc_diff(grad_x, x_ref.grad)
+    assert diff_x < 1e-8, f'grad_x mismatch: {diff_x:.6e}'
+    diff_k = calc_diff(grad_k, k_ref.grad)
+    assert diff_k < 1e-8, f'grad_k mismatch: {diff_k:.6e}'
+    diff_v = calc_diff(grad_v, v_ref.grad)
+    assert diff_v < 1e-8, f'grad_v mismatch: {diff_v:.6e}'
+    diff_wh = calc_diff(grad_wh, wh_ref.grad)
+    assert diff_wh < 1e-8, f'grad_wh mismatch: {diff_wh:.6e}'
+    diff_we = calc_diff(grad_we, we_ref.grad)
+    assert diff_we < 1e-8, f'grad_we mismatch: {diff_we:.6e}'
+
+
+@pytest.mark.benchmark
+@pytest.mark.parametrize('params', generate_test_params(is_benchmark=True), ids=make_param_id)
+def test_engram_gate_bwd_benchmark(benchmark_timer, benchmark_record, params):
+    (x_data, k_data, v_data, wh_data, we_data, weight_fused, grad_out, eps, clamp_value) = generate_test_data(params)
+
+    # Forward to get intermediates
+    o_ref, dot_ref, gate_score_ref, rstd_x_ref, rstd_k_ref = engram_gate_ref(
+        x_data, k_data, v_data, wh_data, we_data, clamp_value, eps, save_for_backward=True,
+    )
+
+    grad_x, grad_k, grad_v, grad_w_partial = engram_gate_bwd(
+        grad_out, x_data, k_data, v_data, weight_fused,
+        dot_ref, gate_score_ref, rstd_x_ref, rstd_k_ref, clamp_value,
+    )
+    grad_w_fused = grad_w_partial.sum(0)
+    grad_wh = grad_w_fused * we_data.float()
+    grad_we = grad_w_fused * wh_data.float()
+
+    func_bwd = lambda: engram_gate_bwd(
+        grad_out, x_data, k_data, v_data, weight_fused,
+        dot_ref, gate_score_ref, rstd_x_ref, rstd_k_ref, clamp_value,
+    )
+    t_us = benchmark_timer(func_bwd)
+    num_bytes = count_bytes(
+        grad_out, x_data, k_data, v_data, weight_fused,
+        dot_ref, gate_score_ref, rstd_x_ref, rstd_k_ref,
+        grad_x, grad_k, grad_v, grad_wh, grad_we,
+    )
+    benchmark_record(
+        kernel='engram_gate_bwd',
+        operation='bwd',
+        params=params,
+        time_us=t_us,
+        bandwidth_gbs=num_bytes / t_us / 1e3,
+    )

tile_kernels_src/tests/engram/test_engram_gate_fwd.py

@@ -0,0 +1,108 @@
+import os
+import pytest
+import torch
+
+from tile_kernels.engram import engram_gate_fwd
+from tile_kernels.torch.engram import engram_gate_ref
+from tile_kernels.testing.numeric import assert_equal, calc_diff, count_bytes
+from tile_kernels.testing.generator import generate_hidden_sizes, generate_num_tokens
+from tile_kernels.testing.bench import make_param_id
+
+# Disable TileLang prints
+os.environ['TILELANG_PRINT_ON_COMPILATION'] = '0'
+
+
+def generate_test_data(params):
+    num_tokens = params['num_tokens']
+    hc_mult = params['hc']
+    hidden_size = params['hidden']
+    eps = 1e-20
+    clamp_value = 1e-6
+    x_data = torch.randn(num_tokens, hc_mult, hidden_size, dtype=torch.bfloat16, device='cuda')
+    k_data = torch.randn(num_tokens, hc_mult, hidden_size, dtype=torch.bfloat16, device='cuda')
+    v_data = torch.randn(num_tokens, hidden_size, dtype=torch.bfloat16, device='cuda')
+    wh_data = torch.randn(hc_mult, hidden_size, dtype=torch.bfloat16, device='cuda')
+    we_data = torch.randn(hc_mult, hidden_size, dtype=torch.bfloat16, device='cuda')
+    weight_fused = wh_data.float() * we_data.float()
+    return (x_data, k_data, v_data, wh_data, we_data, weight_fused, eps, clamp_value)
+
+
+def generate_test_params(is_benchmark: bool) -> list[dict]:
+    return [
+        {'num_tokens': t, 'hc': hc, 'hidden': hidden_size}
+        for t in generate_num_tokens(is_benchmark=is_benchmark)
+        for hc in (4,)
+        for hidden_size in generate_hidden_sizes(128)
+    ]
+
+
+@pytest.mark.parametrize('params', generate_test_params(is_benchmark=False), ids=make_param_id)
+def test_engram_gate_fwd(params):
+    (x_data, k_data, v_data, wh_data, we_data, weight_fused, eps, clamp_value) = generate_test_data(params)
+
+    out_ref, dot_ref, gate_score_ref, rstd_x_ref, rstd_k_ref = engram_gate_ref(
+        x_data, k_data, v_data, wh_data, we_data, clamp_value, eps, save_for_backward=True,
+    )
+
+    # Correctness: save_for_backward=True
+    out_save, dot, gate_score, rstd_x, rstd_k = engram_gate_fwd(
+        x_data, k_data, v_data, weight_fused, eps, clamp_value, save_for_backward=True,
+    )
+    assert dot is not None and gate_score is not None and rstd_x is not None and rstd_k is not None
+    diff_out = calc_diff(out_save, out_ref)
+    assert diff_out < 2e-10, f'out_save mismatch: {diff_out:.6e}'
+    diff_dot = calc_diff(dot, dot_ref)
+    assert diff_dot < 2e-10, f'dot mismatch: {diff_dot:.6e}'
+    diff_gate = calc_diff(gate_score, gate_score_ref)
+    assert diff_gate < 2e-10, f'gate_score mismatch: {diff_gate:.6e}'
+    diff_rstd_x = calc_diff(rstd_x, rstd_x_ref)
+    assert diff_rstd_x < 2e-10, f'rstd_x mismatch: {diff_rstd_x:.6e}'
+    diff_rstd_k = calc_diff(rstd_k, rstd_k_ref)
+    assert diff_rstd_k < 2e-10, f'rstd_k mismatch: {diff_rstd_k:.6e}'
+
+    # Correctness: save_for_backward=False
+    out_no_save, dot_n, gate_score_n, rstd_x_n, rstd_k_n = engram_gate_fwd(
+        x_data, k_data, v_data, weight_fused, eps, clamp_value, save_for_backward=False,
+    )
+    assert dot_n is None and gate_score_n is None and rstd_x_n is None and rstd_k_n is None
+    diff_out = calc_diff(out_no_save, out_ref)
+    assert diff_out < 2e-10, f'out_no_save mismatch: {diff_out:.6e}'
+    assert_equal(out_no_save, out_save)
+
+
+@pytest.mark.benchmark
+@pytest.mark.parametrize('params', generate_test_params(is_benchmark=True), ids=make_param_id)
+def test_engram_gate_fwd_benchmark(benchmark_timer, benchmark_record, params):
+    (x_data, k_data, v_data, _, _, weight_fused, eps, clamp_value) = generate_test_data(params)
+
+    # Benchmark save_for_backward=True
+    out_save, dot, gate_score, rstd_x, rstd_k = engram_gate_fwd(
+        x_data, k_data, v_data, weight_fused, eps, clamp_value, save_for_backward=True,
+    )
+    t_save_us = benchmark_timer(lambda: engram_gate_fwd(
+        x_data, k_data, v_data, weight_fused, eps, clamp_value, save_for_backward=True,
+    ))
+    num_bytes_save = count_bytes(x_data, k_data, v_data, weight_fused, out_save, dot, gate_score, rstd_x, rstd_k)
+    benchmark_record(
+        kernel='engram_gate_fwd',
+        operation='fwd',
+        params={**params, 'save': True},
+        time_us=t_save_us,
+        bandwidth_gbs=num_bytes_save / t_save_us / 1e3,
+    )
+
+    # Benchmark save_for_backward=False
+    out_no_save = engram_gate_fwd(
+        x_data, k_data, v_data, weight_fused, eps, clamp_value, save_for_backward=False,
+    )[0]
+    t_no_save_us = benchmark_timer(lambda: engram_gate_fwd(
+        x_data, k_data, v_data, weight_fused, eps, clamp_value, save_for_backward=False,
+    ))
+    num_bytes_no_save = count_bytes(x_data, k_data, v_data, weight_fused, out_no_save)
+    benchmark_record(
+        kernel='engram_gate_fwd',
+        operation='fwd',
+        params={**params, 'save': False},
+        time_us=t_no_save_us,
+        bandwidth_gbs=num_bytes_no_save / t_no_save_us / 1e3,
+    )

tile_kernels_src/tests/engram/test_engram_grad_w_reduce.py

@@ -0,0 +1,76 @@
+import os
+import pytest
+import torch
+
+from tile_kernels.config import get_num_sms
+from tile_kernels.engram import grad_w_reduce
+from tile_kernels.testing.numeric import calc_diff, count_bytes
+from tile_kernels.testing.generator import generate_hidden_sizes
+from tile_kernels.testing.bench import make_param_id
+
+# Disable TileLang prints
+os.environ['TILELANG_PRINT_ON_COMPILATION'] = '0'
+
+
+def grad_w_reduce_ref(grad_w_partial, weight_hidden, weight_embed, grad_weight_hidden, grad_weight_embed):
+    grad_w_sum = grad_w_partial.sum(0)
+    grad_weight_hidden += grad_w_sum * weight_embed.float()
+    grad_weight_embed += grad_w_sum * weight_hidden.float()
+
+
+def generate_test_data(params):
+    hidden_size = params['hidden']
+    hc_mult = 4
+    num_persistent_blocks = get_num_sms()
+    grad_w_partial = torch.randn(num_persistent_blocks, hc_mult, hidden_size, dtype=torch.float32, device='cuda')
+    weight_hidden = torch.randn(hc_mult, hidden_size, dtype=torch.bfloat16, device='cuda')
+    weight_embed = torch.randn(hc_mult, hidden_size, dtype=torch.bfloat16, device='cuda')
+    return (grad_w_partial, weight_hidden, weight_embed)
+
+
+def generate_test_params(is_benchmark: bool) -> list[dict]:
+    return [
+        {'hidden': hidden_size}
+        for hidden_size in generate_hidden_sizes(128)
+    ]
+
+
+@pytest.mark.parametrize('params', generate_test_params(is_benchmark=False), ids=make_param_id)
+def test_engram_grad_w_reduce(params):
+    hidden_size = params['hidden']
+    grad_w_partial, weight_hidden, weight_embed = generate_test_data(params)
+    hc_mult = grad_w_partial.shape[1]
+
+    # Correctness
+    grad_wh_ref = torch.randn(hc_mult, hidden_size, dtype=torch.float32, device='cuda')
+    grad_we_ref = torch.randn(hc_mult, hidden_size, dtype=torch.float32, device='cuda')
+    grad_weight_hidden = grad_wh_ref.clone()
+    grad_weight_embed = grad_we_ref.clone()
+    grad_w_reduce_ref(grad_w_partial, weight_hidden, weight_embed, grad_wh_ref, grad_we_ref)
+    grad_w_reduce(grad_w_partial, weight_hidden, weight_embed, grad_weight_hidden, grad_weight_embed)
+    diff_wh = calc_diff(grad_weight_hidden, grad_wh_ref)
+    assert diff_wh < 1e-10, f'grad_wh mismatch: {diff_wh:.6e}'
+    diff_we = calc_diff(grad_weight_embed, grad_we_ref)
+    assert diff_we < 1e-10, f'grad_we mismatch: {diff_we:.6e}'
+
+
+@pytest.mark.benchmark
+@pytest.mark.parametrize('params', generate_test_params(is_benchmark=True), ids=make_param_id)
+def test_engram_grad_w_reduce_benchmark(benchmark_timer, benchmark_record, params):
+    hidden_size = params['hidden']
+    grad_w_partial, weight_hidden, weight_embed = generate_test_data(params)
+    hc_mult = grad_w_partial.shape[1]
+    grad_weight_hidden = torch.randn(hc_mult, hidden_size, dtype=torch.float32, device='cuda')
+    grad_weight_embed = torch.randn(hc_mult, hidden_size, dtype=torch.float32, device='cuda')
+
+    t_us = benchmark_timer(lambda: grad_w_reduce(grad_w_partial, weight_hidden, weight_embed, grad_weight_hidden, grad_weight_embed))
+
+    num_bytes = count_bytes(grad_w_partial, weight_hidden, weight_embed, grad_weight_hidden, grad_weight_embed)
+    bandwidth_gbs = num_bytes / t_us / 1e3
+    benchmark_record(
+        kernel='grad_w_reduce',
+        operation='fwd',
+        params=params,
+        time_us=t_us,
+        bandwidth_gbs=bandwidth_gbs,
+    )

tile_kernels_src/tests/engram/test_engram_hash.py

@@ -0,0 +1,71 @@
+import os
+import pytest
+import torch
+
+from tile_kernels.engram import engram_hash
+from tile_kernels.torch.engram import engram_hash_ref, make_offsets
+from tile_kernels.testing.generator import generate_num_tokens
+from tile_kernels.testing.numeric import assert_equal, count_bytes
+from tile_kernels.testing.bench import make_param_id
+
+# Disable TileLang prints
+os.environ['TILELANG_PRINT_ON_COMPILATION'] = '0'
+
+
+def generate_test_data(params):
+    num_tokens = params['num_tokens']
+    max_ngram_size = params['ngram']
+    num_ngram_layers = params['layers']
+    num_embed_table_per_ngram = params['tables']
+    ngram_token_ids = torch.randint(0, 100000, (num_tokens, max_ngram_size), dtype=torch.int32, device='cuda')
+    multipliers = torch.randint(0, 100000, (num_ngram_layers, max_ngram_size), dtype=torch.int64, device='cuda')
+    vocab_sizes = torch.randint(100000, 1000000, (num_ngram_layers, max_ngram_size - 1, num_embed_table_per_ngram), dtype=torch.int32, device='cuda')
+    offsets = make_offsets(vocab_sizes)
+    return (ngram_token_ids, multipliers, vocab_sizes, offsets)
+
+
+def generate_test_params(is_benchmark: bool) -> list[dict]:
+    return [
+        {'num_tokens': t}
+        for t in generate_num_tokens(is_benchmark=is_benchmark)
+    ]
+
+
+@pytest.mark.parametrize('params', generate_test_params(is_benchmark=False), ids=make_param_id)
+def test_engram_hash(params):
+    num_tokens = params['num_tokens']
+    max_ngram_size = 3
+    num_ngram_layers = 2
+    num_embed_table_per_ngram = 8
+
+    ngram_token_ids, multipliers, vocab_sizes, offsets = generate_test_data(
+        {'num_tokens': num_tokens, 'ngram': max_ngram_size, 'layers': num_ngram_layers, 'tables': num_embed_table_per_ngram})
+
+    # Correctness
+    output = engram_hash(ngram_token_ids, multipliers, vocab_sizes, offsets)
+    output_ref = engram_hash_ref(ngram_token_ids, multipliers, vocab_sizes, offsets)
+    assert_equal(output, output_ref)
+
+
+@pytest.mark.benchmark
+@pytest.mark.parametrize('params', generate_test_params(is_benchmark=True), ids=make_param_id)
+def test_engram_hash_benchmark(benchmark_timer, benchmark_record, params):
+    max_ngram_size = 3
+    num_ngram_layers = 2
+    num_embed_table_per_ngram = 8
+
+    ngram_token_ids, multipliers, vocab_sizes, offsets = generate_test_data(
+        {**params, 'ngram': max_ngram_size, 'layers': num_ngram_layers, 'tables': num_embed_table_per_ngram})
+    output = engram_hash(ngram_token_ids, multipliers, vocab_sizes, offsets)
+
+    t_us = benchmark_timer(lambda: engram_hash(ngram_token_ids, multipliers, vocab_sizes, offsets))
+
+    num_bytes = count_bytes(ngram_token_ids, multipliers, vocab_sizes, offsets, output)
+    bandwidth_gbs = num_bytes / t_us / 1e3
+    benchmark_record(
+        kernel='engram_hash',
+        operation='fwd',
+        params={**params, 'ngram': max_ngram_size, 'layers': num_ngram_layers, 'tables': num_embed_table_per_ngram},
+        time_us=t_us,
+        bandwidth_gbs=bandwidth_gbs,
+    )

tile_kernels_src/tests/mhc/test_expand.py

@@ -0,0 +1,45 @@
+from typing import Callable
+
+import pytest
+import torch
+from tile_kernels.modeling.mhc.ops import expand_to_mhc
+from tile_kernels.torch.mhc import expand_to_mhc_ref
+
+
+def generate_expand_test_data(
+    n0: int, n1: int, mhc_mult: int, h: int, device: str = 'cuda'
+) -> dict[str, torch.Tensor]:
+    torch.random.manual_seed(42)
+
+    x = torch.randn(n0, n1, h, dtype=torch.bfloat16, device=device)
+    o_grad = torch.randn(n0, n1, mhc_mult, h, dtype=torch.bfloat16, device=device)
+
+    return {'x': x, 'o_grad': o_grad, 'mhc_mult': mhc_mult}
+
+
+@pytest.mark.parametrize('n0', [1, 2])
+@pytest.mark.parametrize('n1', [1024, 4096])
+@pytest.mark.parametrize('mhc_mult', [2, 4, 8])
+@pytest.mark.parametrize('h', [1280, 2560, 7168])
+def test_expand_comprehensive(n0: int, n1: int, mhc_mult: int, h: int) -> None:
+    test_data = generate_expand_test_data(n0=n0, n1=n1, mhc_mult=mhc_mult, h=h)
+
+    with torch.no_grad():
+        out_tl = expand_to_mhc(test_data['x'], test_data['mhc_mult'])
+        out_ref = expand_to_mhc_ref(test_data['x'], test_data['mhc_mult'])
+
+    torch.testing.assert_close(out_tl, out_ref)
+
+    def _tester(
+        impl: Callable[[torch.Tensor, int], torch.Tensor],
+    ) -> tuple[torch.Tensor, torch.Tensor | None]:
+        x_ = test_data['x'].clone().requires_grad_()
+        o_ = impl(x_, test_data['mhc_mult'])
+        torch.autograd.backward([o_], [test_data['o_grad']])
+        return o_, x_.grad
+
+    o_tl, x_grad_tl = _tester(expand_to_mhc)
+    o_ref, x_grad_ref = _tester(expand_to_mhc_ref)
+
+    torch.testing.assert_close(o_tl, o_ref)
+    torch.testing.assert_close(x_grad_tl, x_grad_ref)

tile_kernels_src/tests/mhc/test_head_compute_mix.py

@@ -0,0 +1,54 @@
+from typing import Callable
+
+import pytest
+import torch
+from tile_kernels.modeling.mhc.ops import mhc_head_compute_mix
+from tile_kernels.torch.mhc import mhc_head_compute_mix_ref
+
+
+def generate_head_compute_mix_test_data(
+    n0: int, n1: int, mhc_mult: int, device: str = 'cuda'
+) -> dict[str, torch.Tensor]:
+    input_mix = torch.randn((n0, n1, mhc_mult), dtype=torch.float, device=device)
+    mhc_scale = torch.randn(1, dtype=torch.float, device=device)
+    mhc_base = torch.randn(mhc_mult, dtype=torch.float, device=device)
+    output_mix_grad = torch.randn((n0, n1, mhc_mult), dtype=torch.float, device=device)
+
+    return {
+        'input_mix': input_mix,
+        'mhc_scale': mhc_scale,
+        'mhc_base': mhc_base,
+        'output_mix_grad': output_mix_grad,
+        'mhc_pre_eps': 1e-2,
+    }
+
+
+def _tester(
+    impl: Callable[[torch.Tensor, torch.Tensor, torch.Tensor, float], torch.Tensor],
+    test_data: dict[str, torch.Tensor],
+) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor]:
+    input_mix_ = test_data['input_mix'].clone().requires_grad_()
+    mhc_scale_ = test_data['mhc_scale'].clone().requires_grad_()
+    mhc_base_ = test_data['mhc_base'].clone().requires_grad_()
+    output_mix_ = impl(input_mix_, mhc_scale_, mhc_base_, test_data['mhc_pre_eps'])
+    torch.autograd.backward([output_mix_], [test_data['output_mix_grad']])
+    return output_mix_, input_mix_.grad, mhc_scale_.grad, mhc_base_.grad
+
+
+@pytest.mark.parametrize('n0', [1, 2])
+@pytest.mark.parametrize('n1', [1024, 4096])
+@pytest.mark.parametrize('mhc_mult', [4])
+def test_head_compute_mix_comprehensive(n0: int, n1: int, mhc_mult: int) -> None:
+    test_data = generate_head_compute_mix_test_data(n0=n0, n1=n1, mhc_mult=mhc_mult)
+
+    output_mix_tl, grad_input_mix_tl, grad_mhc_scale_tl, grad_mhc_base_tl = _tester(
+        mhc_head_compute_mix, test_data
+    )
+    output_mix_ref, grad_input_mix_ref, grad_mhc_scale_ref, grad_mhc_base_ref = _tester(
+        mhc_head_compute_mix_ref, test_data
+    )
+
+    torch.testing.assert_close(output_mix_tl, output_mix_ref, rtol=1e-4, atol=1e-5)
+    torch.testing.assert_close(grad_input_mix_tl, grad_input_mix_ref, rtol=1e-4, atol=1e-5)
+    torch.testing.assert_close(grad_mhc_scale_tl, grad_mhc_scale_ref, rtol=1e-4, atol=1e-5)
+    torch.testing.assert_close(grad_mhc_base_tl, grad_mhc_base_ref, rtol=1e-4, atol=1e-5)

tile_kernels_src/tests/mhc/test_multilayer_recompute.py

@@ -0,0 +1,157 @@
+import pytest
+import torch
+from tile_kernels.modeling.mhc.ops.multilayer_recompute import mhc_multilayer_recompute
+from tile_kernels.modeling.mhc.ops.post import mhc_post
+from tile_kernels.modeling.mhc.ops.pre_apply_mix import mhc_pre_apply_mix
+
+
+_CORRECTNESS_CASES = [
+    (1, 1, 2560),
+    (3, 2, 2560),
+    (3, 3, 2560),
+    (10, 9, 2560),
+    (10, 10, 2560),
+    (10, 9, 4096),
+    (10, 10, 4096),
+    (10, 9, 7168),
+    (10, 10, 7168),
+    (10, 9, 8192),
+    (10, 10, 8192),
+]
+
+_BENCH_CASES = [
+    (10, 9, 1, 8192, 4, 2560),
+    (10, 10, 1, 8192, 4, 2560),
+    (10, 9, 1, 8192, 4, 4096),
+    (10, 10, 1, 8192, 4, 4096),
+    (10, 9, 1, 8192, 4, 7168),
+    (10, 10, 1, 8192, 4, 7168),
+    (10, 9, 1, 8192, 4, 8192),
+    (10, 10, 1, 8192, 4, 8192),
+]
+
+
+def generate_multilayer_recompute_test_data(
+    bs: int,
+    seq: int,
+    mhc_mult: int,
+    hidden: int,
+    num_layers: int,
+    num_post: int,
+) -> tuple[
+    torch.Tensor,
+    list[torch.Tensor],
+    list[torch.Tensor],
+    list[torch.Tensor],
+    list[torch.Tensor],
+    list[torch.Tensor],
+    list[torch.Tensor],
+]:
+    initial_residual = torch.randn(bs, seq, mhc_mult, hidden, device='cuda', dtype=torch.bfloat16)
+    pre_mix_list = [torch.randn(bs, seq, mhc_mult, 1, device='cuda', dtype=torch.float32) for _ in range(num_layers)]
+    layer_output_list = [torch.randn(bs, seq, hidden, device='cuda', dtype=torch.bfloat16) for _ in range(num_post)]
+    post_mix_list = [torch.randn(bs, seq, mhc_mult, 1, device='cuda', dtype=torch.float32) for _ in range(num_post)]
+    comb_mix_list = [torch.randn(bs, seq, mhc_mult, mhc_mult, device='cuda', dtype=torch.float32) for _ in range(num_post)]
+    layer_input_list = [torch.empty(bs, seq, hidden, device='cuda', dtype=torch.bfloat16) for _ in range(num_layers)]
+    residual_list = [torch.empty(bs, seq, mhc_mult, hidden, device='cuda', dtype=torch.bfloat16) for _ in range(num_post)]
+    return initial_residual, pre_mix_list, layer_output_list, post_mix_list, comb_mix_list, layer_input_list, residual_list
+
+
+def _mhc_multilayer_recompute_ref(
+    initial_residual: torch.Tensor,
+    pre_mix_list: list[torch.Tensor],
+    layer_output_list: list[torch.Tensor],
+    post_mix_list: list[torch.Tensor],
+    comb_mix_list: list[torch.Tensor],
+) -> tuple[list[torch.Tensor], list[torch.Tensor]]:
+    layer_input_refs: list[torch.Tensor] = []
+    residual_refs: list[torch.Tensor] = []
+    residual = initial_residual
+    for i in range(len(pre_mix_list)):
+        layer_input = mhc_pre_apply_mix(residual, pre_mix_list[i])
+        layer_input_refs.append(layer_input)
+        if i < len(layer_output_list):
+            residual = mhc_post(layer_output_list[i], residual, post_mix_list[i], comb_mix_list[i])
+            residual_refs.append(residual)
+    return layer_input_refs, residual_refs
+
+
+def _compute_io_bytes(n: int, mhc_mult: int, hidden: int, num_layers: int, num_post: int) -> tuple[int, int]:
+    io_pre = n * mhc_mult * hidden * 2 + n * mhc_mult * 4 + n * hidden * 2
+    io_post = n * hidden * 2 + n * mhc_mult * hidden * 2 + n * mhc_mult * 4 + n * mhc_mult * mhc_mult * 4 + n * mhc_mult * hidden * 2
+    io_ref = num_layers * io_pre + num_post * io_post
+    io_fused = (
+        n * mhc_mult * hidden * 2
+        + num_layers * (n * mhc_mult * 4 + n * hidden * 2)
+        + num_post * (n * hidden * 2 + n * mhc_mult * 4 + n * mhc_mult * mhc_mult * 4 + n * mhc_mult * hidden * 2)
+    )
+    return io_ref, io_fused
+
+
+@pytest.mark.parametrize('num_layers,num_post,hidden', _CORRECTNESS_CASES)
+def test_mhc_multilayer_recompute_correctness(num_layers: int, num_post: int, hidden: int) -> None:
+    torch.manual_seed(0)
+    initial_residual, pre_mix_list, layer_output_list, post_mix_list, comb_mix_list, layer_input_list, residual_list = (
+        generate_multilayer_recompute_test_data(1, 8192, 4, hidden, num_layers, num_post)
+    )
+    layer_input_ref, residual_ref = _mhc_multilayer_recompute_ref(initial_residual, pre_mix_list, layer_output_list, post_mix_list, comb_mix_list)
+    mhc_multilayer_recompute(initial_residual, pre_mix_list, layer_output_list, post_mix_list, comb_mix_list, layer_input_list, residual_list)
+
+    for i in range(num_layers):
+        assert torch.equal(layer_input_list[i], layer_input_ref[i]), (
+            f'layer_input[{i}] mismatch! max diff = {(layer_input_list[i].float() - layer_input_ref[i].float()).abs().max().item()}'
+        )
+    for i in range(num_post):
+        assert torch.equal(residual_list[i], residual_ref[i]), (
+            f'residual[{i}] mismatch! max diff = {(residual_list[i].float() - residual_ref[i].float()).abs().max().item()}'
+        )
+
+
+@pytest.mark.benchmark
+@pytest.mark.parametrize('num_layers,num_post,bs,seq,mhc_mult,hidden', _BENCH_CASES)
+def test_mhc_multilayer_recompute_benchmark(
+    num_layers: int,
+    num_post: int,
+    bs: int,
+    seq: int,
+    mhc_mult: int,
+    hidden: int,
+    benchmark_record,
+    benchmark_timer,
+) -> None:
+    torch.manual_seed(0)
+    n = bs * seq
+    io_ref, io_fused = _compute_io_bytes(n, mhc_mult, hidden, num_layers, num_post)
+    theory = io_ref / io_fused
+    initial_residual, pre_mix_list, layer_output_list, post_mix_list, comb_mix_list, layer_input_list, residual_list = (
+        generate_multilayer_recompute_test_data(bs, seq, mhc_mult, hidden, num_layers, num_post)
+    )
+
+    def fn_ref() -> tuple[list[torch.Tensor], list[torch.Tensor]]:
+        return _mhc_multilayer_recompute_ref(initial_residual, pre_mix_list, layer_output_list, post_mix_list, comb_mix_list)
+
+    def fn_fused() -> None:
+        mhc_multilayer_recompute(initial_residual, pre_mix_list, layer_output_list, post_mix_list, comb_mix_list, layer_input_list, residual_list)
+
+    fn_ref()
+    fn_fused()
+    t_ref_us = benchmark_timer(fn_ref)
+    t_fused_us = benchmark_timer(fn_fused)
+    speedup = t_ref_us / t_fused_us
+    bw_ref_gbs = io_ref / t_ref_us / 1e3
+    bw_fused_gbs = io_fused / t_fused_us / 1e3
+
+    benchmark_record(
+        kernel='mhc_multilayer_recompute',
+        operation='recompute',
+        params={'num_layers': num_layers, 'num_post': num_post, 'bs': bs, 'seq': seq, 'mhc_mult': mhc_mult, 'hidden': hidden},
+        time_us=t_fused_us,
+        bandwidth_gbs=bw_fused_gbs,
+        extras={
+            'ref_time_us': t_ref_us,
+            'speedup': speedup,
+            'bw_ref_gbs': bw_ref_gbs,
+            'theory': theory,
+            'efficiency': speedup / theory,
+        },
+    )

tile_kernels_src/tests/mhc/test_norm_fn.py

@@ -0,0 +1,130 @@
+import pytest
+import torch
+from tile_kernels.modeling.mhc.ops import mhc_pre_norm_fn
+from tile_kernels.torch.mhc import mhc_pre_norm_fn_ref
+
+
+def generate_norm_fn_test_data(
+    n1: int,
+    mhc_mult: int,
+    hidden_size: int,
+    generate_normw: bool,
+) -> dict[str, torch.Tensor]:
+    n0 = 1
+    mhc_mult3 = mhc_mult * (2 + mhc_mult)
+    mhc_hidden_size = mhc_mult * hidden_size
+    device = 'cuda'
+
+    residual = (
+        torch.randn((n0, n1, mhc_mult, hidden_size), dtype=torch.float, device=device)
+        .mul(1 + torch.arange(mhc_mult, device=device).mul(0.01).view(1, 1, -1, 1))
+        .bfloat16()
+    )
+
+    fn = (
+        torch.randn((mhc_mult3, mhc_mult, hidden_size), dtype=torch.float, device=device)
+        * 1e-4
+        * (1 + torch.arange(mhc_mult, device=device).mul(0.01).view(1, -1, 1))
+    ).flatten(1, 2)
+
+    if generate_normw:
+        normw = torch.randn((mhc_hidden_size,), dtype=torch.float, device=device) * 0.1 + 1.0
+    else:
+        normw = None
+
+    out_grad = torch.randn((n0, n1, mhc_mult3), dtype=torch.float, device=device)
+
+    return {
+        'residual': residual,
+        'fn': fn,
+        'normw': normw,
+        'out_grad': out_grad,
+        'mhc_norm_eps': 1e-6,
+    }
+
+
+@pytest.mark.parametrize('n1', [4096, 8192])
+@pytest.mark.parametrize('hidden_size', [1280, 2560, 7168])
+@pytest.mark.parametrize('generate_normw', [False, True])
+def test_correctness(
+    n1: int,
+    hidden_size: int,
+    generate_normw: bool,
+) -> None:
+    mhc_mult = 4
+
+    test_data = generate_norm_fn_test_data(
+        n1=n1,
+        mhc_mult=mhc_mult,
+        hidden_size=hidden_size,
+        generate_normw=generate_normw,
+    )
+
+    residual_tl = test_data['residual'].clone().requires_grad_()
+    fn_tl = test_data['fn'].clone().requires_grad_()
+    normw_tl = test_data['normw'].clone().requires_grad_() if test_data['normw'] is not None else None
+
+    residual_ref = test_data['residual'].clone().requires_grad_()
+    fn_ref = test_data['fn'].clone().requires_grad_()
+    normw_ref = test_data['normw'].clone().requires_grad_() if test_data['normw'] is not None else None
+
+    out_tl = mhc_pre_norm_fn(
+        residual_tl,
+        fn_tl,
+        normw_tl,
+        test_data['mhc_norm_eps'],
+    )
+    residual_tl_grad = residual_tl.untyped_storage().grad_from_mhc_post = torch.zeros_like(residual_tl)
+    torch.autograd.backward([out_tl], [test_data['out_grad']])
+
+    torch.backends.cuda.matmul.allow_tf32 = True
+    out_ref = mhc_pre_norm_fn_ref(
+        residual_ref,
+        fn_ref,
+        normw_ref,
+        test_data['mhc_norm_eps'],
+    )
+    torch.autograd.backward([out_ref], [test_data['out_grad']])
+    torch.backends.cuda.matmul.allow_tf32 = False
+
+    torch.testing.assert_close(out_tl, out_ref, atol=1e-3, rtol=1e-3)
+    torch.testing.assert_close(residual_tl_grad, residual_ref.grad)
+    torch.testing.assert_close(fn_tl.grad, fn_ref.grad, atol=3e-2, rtol=1e-3)
+
+
+@pytest.mark.parametrize('n1', [13, 48, 512])
+@pytest.mark.parametrize('hidden_size', [1280, 2560, 4096, 7168])
+def test_split_k_correctness(n1: int, hidden_size: int) -> None:
+    mhc_mult = 4
+
+    test_data = generate_norm_fn_test_data(
+        n1=n1,
+        mhc_mult=mhc_mult,
+        hidden_size=hidden_size,
+        generate_normw=False,
+    )
+
+    residual_tl = test_data['residual'].clone().requires_grad_()
+    fn_tl = test_data['fn'].clone().requires_grad_()
+
+    residual_ref = test_data['residual'].clone().requires_grad_()
+    fn_ref = test_data['fn'].clone().requires_grad_()
+
+    out_tl = mhc_pre_norm_fn(
+        residual_tl,
+        fn_tl,
+        None,
+        test_data['mhc_norm_eps'],
+        n_splits=16,
+    )
+
+    torch.backends.cuda.matmul.allow_tf32 = True
+    out_ref = mhc_pre_norm_fn_ref(
+        residual_ref,
+        fn_ref,
+        None,
+        test_data['mhc_norm_eps'],
+    )
+    torch.backends.cuda.matmul.allow_tf32 = False
+
+    torch.testing.assert_close(out_tl, out_ref, atol=1e-3, rtol=1e-3)

tile_kernels_src/tests/mhc/test_post.py

@@ -0,0 +1,72 @@
+from typing import Callable
+
+import pytest
+import torch
+from tile_kernels.modeling.mhc.ops import mhc_post
+from tile_kernels.torch.mhc import mhc_post_ref
+
+
+def generate_mhc_post_test_data(
+    n0: int,
+    n1: int,
+    h: int,
+    mhc_mult: int,
+    device: str = 'cuda',
+) -> dict[str, torch.Tensor]:
+    x = torch.randn((n0, n1, h), dtype=torch.bfloat16, device=device)
+    residual = torch.randn((n0, n1, mhc_mult, h), dtype=torch.bfloat16, device=device)
+    post_layer_mix = torch.randn((n0, n1, mhc_mult, 1), dtype=torch.float32, device=device)
+    comb_res_mix = torch.randn((n0, n1, mhc_mult, mhc_mult), dtype=torch.float32, device=device)
+
+    o_grad = torch.randn((n0, n1, mhc_mult, h), dtype=torch.bfloat16, device=device)
+
+    return {
+        'x': x,
+        'residual': residual,
+        'post_layer_mix': post_layer_mix,
+        'comb_res_mix': comb_res_mix,
+        'o_grad': o_grad,
+    }
+
+
+def _tester(
+    impl: Callable[[torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor], torch.Tensor],
+    test_data: dict[str, torch.Tensor],
+) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
+    x_ = test_data['x'].clone().requires_grad_()
+    residual_ = test_data['residual'].clone().requires_grad_()
+    post_layer_mix_ = test_data['post_layer_mix'].clone().requires_grad_()
+    comb_res_mix_ = test_data['comb_res_mix'].clone().requires_grad_()
+    out_ = impl(x_, residual_, post_layer_mix_, comb_res_mix_)
+    torch.autograd.backward([out_], [test_data['o_grad']])
+    return out_, x_.grad, residual_.grad, post_layer_mix_.grad, comb_res_mix_.grad
+
+
+@pytest.mark.parametrize('n0', [1, 2])
+@pytest.mark.parametrize('n1', [4096])
+@pytest.mark.parametrize('h', [1280, 2560, 7168])
+def test_mhc_post_comprehensive(n0: int, n1: int, h: int) -> None:
+    test_data = generate_mhc_post_test_data(n0=n0, n1=n1, h=h, mhc_mult=4)
+
+    out_tl, grad_x_tl, grad_residual_tl, grad_post_layer_mix_tl, grad_comb_res_mix_tl = _tester(
+        mhc_post, test_data
+    )
+    out_ref, grad_x_ref, grad_residual_ref, grad_post_layer_mix_ref, grad_comb_res_mix_ref = _tester(
+        mhc_post_ref, test_data
+    )
+
+    torch.testing.assert_close(out_tl, out_ref)
+    torch.testing.assert_close(grad_x_tl, grad_x_ref)
+    torch.testing.assert_close(grad_residual_tl, grad_residual_ref)
+    torch.testing.assert_close(
+        grad_post_layer_mix_tl,
+        grad_post_layer_mix_ref,
+        atol=1e-4,
+        rtol=1e-4,
+    )
+    torch.testing.assert_close(
+        grad_comb_res_mix_tl,
+        grad_comb_res_mix_ref,
+        atol=1e-4,
+        rtol=1e-4,
+    )

tile_kernels_src/tests/mhc/test_pre_apply_mix.py

@@ -0,0 +1,52 @@
+from typing import Callable
+
+import pytest
+import torch
+from tile_kernels.modeling.mhc.ops import mhc_pre_apply_mix
+from tile_kernels.torch.mhc import mhc_pre_apply_mix_ref
+
+
+def generate_pre_apply_mix_test_data(
+    n0: int, n1: int, mhc: int, h: int, device: str = 'cuda'
+) -> dict[str, torch.Tensor]:
+    x = torch.randn(n0, n1, mhc, h, dtype=torch.bfloat16, device=device).sigmoid()
+    mix = torch.randn(n0, n1, mhc, 1, dtype=torch.float32, device=device).softmax(-2)
+    o_grad = torch.randn(n0, n1, h, dtype=torch.bfloat16, device=device)
+
+    return {
+        'x': x,
+        'mix': mix,
+        'o_grad': o_grad,
+    }
+
+
+def _tester(
+    impl: Callable[[torch.Tensor, torch.Tensor], torch.Tensor],
+    test_data: dict[str, torch.Tensor],
+) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
+    x_ = test_data['x'].clone().requires_grad_()
+    mix_ = test_data['mix'].clone().requires_grad_()
+    o_ = impl(x_, mix_)
+    x_.untyped_storage().grad_from_mhc_post = torch.zeros_like(x_)
+    torch.autograd.backward([o_], [test_data['o_grad']])
+    return (
+        o_,
+        x_.untyped_storage().grad_from_mhc_post if x_.grad is None else x_.grad,
+        mix_.grad,
+    )
+
+
+@pytest.mark.parametrize('n0', [1, 2])
+@pytest.mark.parametrize('n1', [1024, 4096])
+@pytest.mark.parametrize('h', [1280, 2560, 7680])
+def test_pre_apply_mix_comprehensive(n0: int, n1: int, h: int) -> None:
+    mhc = 4
+
+    test_data = generate_pre_apply_mix_test_data(n0=n0, n1=n1, mhc=mhc, h=h)
+
+    o_tl, x_grad_tl, mix_grad_tl = _tester(mhc_pre_apply_mix, test_data)
+    o_ref, x_grad_ref, mix_grad_ref = _tester(mhc_pre_apply_mix_ref, test_data)
+
+    torch.testing.assert_close(o_tl, o_ref, atol=1e-2, rtol=1e-3)
+    torch.testing.assert_close(x_grad_tl, x_grad_ref, atol=1e-2, rtol=1e-3)
+    torch.testing.assert_close(mix_grad_tl, mix_grad_ref, atol=1e-2, rtol=1e-3)

tile_kernels_src/tests/mhc/test_pre_big_fuse.py

@@ -0,0 +1,138 @@
+import pytest
+import torch
+from tile_kernels.modeling.mhc.ops import (
+    mhc_pre_apply_mix,
+    mhc_pre_big_fuse,
+    mhc_pre_norm_fn,
+    mhc_pre_split_mixes,
+    sinkhorn_normalize,
+)
+
+
+def generate_big_fuse_test_data(
+    n1: int,
+    mhc_mult: int,
+    hidden_size: int,
+    rms_eps: float = 1e-6,
+    mhc_pre_eps: float = 1e-6,
+    mhc_sinkhorn_eps: float = 1e-6,
+    mhc_post_mult_value: float = 1.0,
+    sinkhorn_repeat: int = 10,
+    n_splits: int = 16,
+) -> dict[str, torch.Tensor | float]:
+    n0 = 1
+    mhc_mult2 = mhc_mult * mhc_mult
+    mhc_mult3 = mhc_mult * 2 + mhc_mult2
+    device = 'cuda'
+
+    residual = (
+        torch.randn((n0, n1, mhc_mult, hidden_size), dtype=torch.float, device=device)
+        .mul(1 + torch.arange(mhc_mult, device=device).mul(0.01).view(1, 1, -1, 1))
+        .bfloat16()
+    )
+
+    fn = (
+        torch.randn((mhc_mult3, mhc_mult, hidden_size), dtype=torch.float, device=device)
+        * 1e-4
+        * (1 + torch.arange(mhc_mult, device=device).mul(0.01).view(1, -1, 1))
+    ).flatten(1, 2)
+
+    mhc_scale = torch.randn((3,), dtype=torch.float, device=device) * 0.1
+    mhc_base = torch.randn((mhc_mult3,), dtype=torch.float, device=device) * 0.1
+
+    return {
+        'residual': residual,
+        'fn': fn,
+        'mhc_scale': mhc_scale,
+        'mhc_base': mhc_base,
+        'rms_eps': rms_eps,
+        'mhc_pre_eps': mhc_pre_eps,
+        'mhc_sinkhorn_eps': mhc_sinkhorn_eps,
+        'mhc_post_mult_value': mhc_post_mult_value,
+        'sinkhorn_repeat': sinkhorn_repeat,
+        'n_splits': n_splits,
+    }
+
+
+def big_fuse_reference(
+    residual: torch.Tensor,
+    fn: torch.Tensor,
+    mhc_scale: torch.Tensor,
+    mhc_base: torch.Tensor,
+    rms_eps: float,
+    mhc_pre_eps: float,
+    mhc_sinkhorn_eps: float,
+    mhc_post_mult_value: float,
+    sinkhorn_repeat: int,
+    n_splits: int,
+) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
+    mhc_mult = residual.shape[-2]
+
+    mixes = mhc_pre_norm_fn(
+        residual,
+        fn,
+        None,
+        rms_eps,
+        fuse_grad_acc=False,
+        n_splits=n_splits,
+    )
+
+    pre_mix, post_mix, comb_mix = mhc_pre_split_mixes(
+        mixes,
+        mhc_scale,
+        mhc_base,
+        mhc_mult,
+        mhc_post_mult_value,
+        mhc_pre_eps,
+    )
+
+    comb_mix = sinkhorn_normalize(comb_mix, repeat=sinkhorn_repeat, eps=mhc_sinkhorn_eps)
+
+    layer_input = mhc_pre_apply_mix(residual, pre_mix)
+
+    return post_mix, comb_mix, layer_input
+
+
+@pytest.mark.parametrize('n1', [512, 1024, 2048, 8192])
+@pytest.mark.parametrize('hidden_size', [1280, 2560, 4096])
+@pytest.mark.parametrize('mhc_mult', [4])
+def test_correctness(
+    n1: int,
+    hidden_size: int,
+    mhc_mult: int,
+) -> None:
+    test_data = generate_big_fuse_test_data(
+        n1=n1,
+        mhc_mult=mhc_mult,
+        hidden_size=hidden_size,
+    )
+
+    post_mix_fused, comb_mix_fused, layer_input_fused = mhc_pre_big_fuse(
+        test_data['residual'],
+        test_data['fn'],
+        test_data['mhc_scale'],
+        test_data['mhc_base'],
+        rms_eps=test_data['rms_eps'],
+        mhc_pre_eps=test_data['mhc_pre_eps'],
+        mhc_sinkhorn_eps=test_data['mhc_sinkhorn_eps'],
+        mhc_post_mult_value=test_data['mhc_post_mult_value'],
+        sinkhorn_repeat=test_data['sinkhorn_repeat'],
+        n_splits=test_data['n_splits'],
+    )
+
+    post_mix_ref, comb_mix_ref, layer_input_ref = big_fuse_reference(
+        test_data['residual'],
+        test_data['fn'],
+        test_data['mhc_scale'],
+        test_data['mhc_base'],
+        test_data['rms_eps'],
+        test_data['mhc_pre_eps'],
+        test_data['mhc_sinkhorn_eps'],
+        test_data['mhc_post_mult_value'],
+        test_data['sinkhorn_repeat'],
+        test_data['n_splits'],
+    )
+
+    assert torch.equal(post_mix_fused, post_mix_ref)
+    assert torch.equal(comb_mix_fused, comb_mix_ref)
+    assert torch.equal(layer_input_fused, layer_input_ref)

tile_kernels_src/tests/mhc/test_pre_split_mixes.py

@@ -0,0 +1,103 @@
+from typing import Callable
+
+import pytest
+import torch
+from tile_kernels.modeling.mhc.ops import mhc_pre_split_mixes
+from tile_kernels.torch.mhc import mhc_pre_split_mixes_ref
+
+
+def generate_pre_split_mixes_test_data(
+    n0: int, n1: int, mhc_mult: int, device: str = 'cuda'
+) -> dict[str, torch.Tensor]:
+    mhc_mult3 = mhc_mult * 2 + mhc_mult * mhc_mult
+
+    input_mixes = torch.randn((n0, n1, mhc_mult3), dtype=torch.float, device=device)
+    mhc_scale = torch.randn((3,), dtype=torch.float, device=device)
+    mhc_base = torch.randn((mhc_mult3,), dtype=torch.float, device=device)
+
+    pre_layer_mix_grad = torch.randn((n0, n1, mhc_mult, 1), dtype=torch.float, device=device)
+    post_layer_mix_grad = torch.randn((n0, n1, mhc_mult, 1), dtype=torch.float, device=device)
+    comb_res_mix_grad = torch.randn((n0, n1, mhc_mult, mhc_mult), dtype=torch.float, device=device)
+
+    return {
+        'input_mixes': input_mixes,
+        'mhc_scale': mhc_scale,
+        'mhc_base': mhc_base,
+        'pre_layer_mix_grad': pre_layer_mix_grad,
+        'post_layer_mix_grad': post_layer_mix_grad,
+        'comb_res_mix_grad': comb_res_mix_grad,
+        'mhc_post_mult_value': 2.0,
+        'mhc_pre_eps': 1e-2,
+    }
+
+
+def _tester(
+    impl: Callable[
+        [torch.Tensor, torch.Tensor, torch.Tensor, int, float, float],
+        tuple[torch.Tensor, torch.Tensor, torch.Tensor],
+    ],
+    test_data: dict[str, torch.Tensor],
+    mhc_mult: int,
+) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor]:
+    input_mixes_ = test_data['input_mixes'].clone().requires_grad_()
+    mhc_scale_ = test_data['mhc_scale'].clone().requires_grad_()
+    mhc_base_ = test_data['mhc_base'].clone().requires_grad_()
+
+    pre_layer_mix_, post_layer_mix_, comb_res_mix_ = impl(
+        input_mixes_,
+        mhc_scale_,
+        mhc_base_,
+        mhc_mult,
+        test_data['mhc_post_mult_value'],
+        test_data['mhc_pre_eps'],
+    )
+
+    torch.autograd.backward(
+        [pre_layer_mix_, post_layer_mix_, comb_res_mix_],
+        [
+            test_data['pre_layer_mix_grad'],
+            test_data['post_layer_mix_grad'],
+            test_data['comb_res_mix_grad'],
+        ],
+    )
+
+    return (
+        pre_layer_mix_,
+        post_layer_mix_,
+        comb_res_mix_,
+        input_mixes_.grad,
+        mhc_scale_.grad,
+        mhc_base_.grad,
+    )
+
+
+@pytest.mark.parametrize('n0', [1, 2])
+@pytest.mark.parametrize('n1', [1024, 4096])
+@pytest.mark.parametrize('mhc_mult', [4])
+def test_pre_split_mixes_comprehensive(n0: int, n1: int, mhc_mult: int) -> None:
+    test_data = generate_pre_split_mixes_test_data(n0=n0, n1=n1, mhc_mult=mhc_mult)
+
+    (
+        pre_layer_mix_tl,
+        post_layer_mix_tl,
+        comb_res_mix_tl,
+        grad_input_mixes_tl,
+        grad_mhc_scale_tl,
+        grad_mhc_base_tl,
+    ) = _tester(mhc_pre_split_mixes, test_data, mhc_mult)
+
+    (
+        pre_layer_mix_ref,
+        post_layer_mix_ref,
+        comb_res_mix_ref,
+        grad_input_mixes_ref,
+        grad_mhc_scale_ref,
+        grad_mhc_base_ref,
+    ) = _tester(mhc_pre_split_mixes_ref, test_data, mhc_mult)
+
+    torch.testing.assert_close(pre_layer_mix_tl, pre_layer_mix_ref, rtol=1e-5, atol=2e-5)
+    torch.testing.assert_close(post_layer_mix_tl, post_layer_mix_ref, rtol=1e-5, atol=2e-5)
+    torch.testing.assert_close(comb_res_mix_tl, comb_res_mix_ref, rtol=1e-5, atol=2e-5)
+    torch.testing.assert_close(grad_input_mixes_tl, grad_input_mixes_ref, rtol=1e-5, atol=2e-5)
+    torch.testing.assert_close(grad_mhc_scale_tl, grad_mhc_scale_ref, rtol=1e-5, atol=2e-5)
+    torch.testing.assert_close(grad_mhc_base_tl, grad_mhc_base_ref, rtol=1e-5, atol=2e-5)

tile_kernels_src/tests/mhc/test_sinkhorn.py

@@ -0,0 +1,43 @@
+from typing import Callable
+
+import pytest
+import torch
+from tile_kernels.modeling.mhc.ops import sinkhorn_normalize
+from tile_kernels.torch.mhc import sinkhorn_normalize_ref
+
+
+def generate_sinkhorn_test_data(
+    n0: int, n1: int, mhc: int, device: str = 'cuda'
+) -> dict[str, torch.Tensor]:
+    comb_res_mix = torch.randn((n0, n1, mhc, mhc), dtype=torch.float32, device=device)
+    out_grad = torch.randn((n0, n1, mhc, mhc), dtype=torch.float32, device=device)
+
+    return {
+        'comb_res_mix': comb_res_mix,
+        'out_grad': out_grad,
+        'repeat': 10,
+        'eps': 1e-6,
+    }
+
+
+def _tester(
+    impl: Callable[[torch.Tensor, int, float], torch.Tensor],
+    test_data: dict[str, torch.Tensor],
+) -> tuple[torch.Tensor, torch.Tensor]:
+    comb_res_mix_ = test_data['comb_res_mix'].clone().requires_grad_()
+    out_ = impl(comb_res_mix_, test_data['repeat'], test_data['eps'])
+    torch.autograd.backward([out_], [test_data['out_grad']])
+    return out_, comb_res_mix_.grad
+
+
+@pytest.mark.parametrize('n0', [1, 2])
+@pytest.mark.parametrize('n1', [1, 1024, 4096])
+@pytest.mark.parametrize('mhc', [4])
+def test_sinkhorn_comprehensive(n0: int, n1: int, mhc: int) -> None:
+    test_data = generate_sinkhorn_test_data(n0=n0, n1=n1, mhc=mhc)
+
+    out_tl, grad_tl = _tester(sinkhorn_normalize, test_data)
+    out_ref, grad_ref = _tester(sinkhorn_normalize_ref, test_data)
+
+    torch.testing.assert_close(out_tl, out_ref)
+    torch.testing.assert_close(grad_tl, grad_ref)

tile_kernels_src/tests/moe/test_aux_fi.py

@@ -0,0 +1,65 @@
+import os
+import torch
+
+import pytest
+
+import tile_kernels
+from tile_kernels.config import set_num_sms
+from tile_kernels.testing.generator import generate_topk_idx, generate_moe_params, generate_num_sms
+from tile_kernels.testing.numeric import calc_diff, count_bytes
+from tile_kernels.torch import aux_fi as torch_aux_fi
+from tile_kernels.testing.bench import make_param_id
+
+# Disable TileLang prints
+os.environ['TILELANG_PRINT_ON_COMPILATION'] = '0'
+
+
+def generate_test_data(params):
+    topk_idx = generate_topk_idx(params)
+    num_tokens = topk_idx.shape[0]
+
+    return (topk_idx, num_tokens)
+
+
+def generate_test_params(is_benchmark: bool) -> list[dict]:
+    return [
+        {**moe, 'num_aux_topk': num_aux_topk}
+        for moe in generate_moe_params(is_benchmark=is_benchmark)
+        for num_aux_topk in (1, moe['num_topk'])
+    ]
+
+
+@pytest.mark.parametrize('params', generate_test_params(is_benchmark=False), ids=make_param_id)
+def test_aux_fi(params):
+    topk_idx, num_tokens = generate_test_data(params)
+    num_experts = params['num_experts']
+    num_aux_topk = params['num_aux_topk']
+
+    # Test correctness
+    fi_ref = torch_aux_fi(topk_idx, num_experts, num_aux_topk)
+
+    for num_sms in generate_num_sms():
+        set_num_sms(num_sms)
+        fi = tile_kernels.moe.aux_fi(topk_idx, num_experts, num_aux_topk)
+        assert calc_diff(fi, fi_ref) < 2e-7, f'aux_fi mismatch\n{fi}\nvs\n{fi_ref}'
+
+
+@pytest.mark.benchmark
+@pytest.mark.parametrize('params', generate_test_params(is_benchmark=True), ids=make_param_id)
+def test_aux_fi_benchmark(benchmark_timer, benchmark_record, params):
+    topk_idx, num_tokens = generate_test_data(params)
+    num_experts = params['num_experts']
+    num_aux_topk = params['num_aux_topk']
+
+    t_us = benchmark_timer(lambda: tile_kernels.moe.aux_fi(topk_idx, num_experts, num_aux_topk))
+    num_bytes = count_bytes(topk_idx)
+    bandwidth_gbs = num_bytes / t_us / 1e3
+
+    params.pop('num_send_tokens')
+    benchmark_record(
+        kernel='aux_fi',
+        operation='fwd',
+        params={'num_tokens': num_tokens, **params},
+        time_us=t_us,
+        bandwidth_gbs=bandwidth_gbs,
+    )

tile_kernels_src/tests/moe/test_expand_to_fused.py

@@ -0,0 +1,150 @@
+import os
+import torch
+
+import pytest
+
+import tile_kernels
+from tile_kernels.testing.generator import generate_topk_idx, generate_hidden_sizes, generate_moe_params
+from tile_kernels.testing.numeric import assert_equal, count_bytes
+from tile_kernels.testing.bench import make_param_id
+
+# Disable TileLang prints
+os.environ['TILELANG_PRINT_ON_COMPILATION'] = '0'
+
+
+def generate_test_data_expand_to_fused(params):
+    num_experts = params['num_experts']
+    num_ep_ranks = params['num_ep_ranks']
+    hidden = params['hidden']
+
+    topk_idx = generate_topk_idx(params)
+    num_tokens = topk_idx.shape[0]
+    x = torch.randn((num_tokens, hidden), dtype=torch.bfloat16, device='cuda')
+    pos_to_expert, _, _, token_topk_to_pos, _, _, _, _ = tile_kernels.moe.get_fused_mapping(topk_idx, num_experts, 0, 16)
+
+    return (x, pos_to_expert, token_topk_to_pos, num_tokens)
+
+
+def generate_test_params_expand(is_benchmark: bool) -> list[dict]:
+    return [
+        {**moe, 'hidden': hidden}
+        for moe in generate_moe_params(is_benchmark=is_benchmark)
+        for hidden in generate_hidden_sizes()
+    ]
+
+
+@pytest.mark.parametrize('params', generate_test_params_expand(is_benchmark=False), ids=make_param_id)
+def test_expand_to_fused(params):
+    x, pos_to_expert, token_topk_to_pos, num_tokens = generate_test_data_expand_to_fused(params)
+
+    expanded_x = tile_kernels.moe.expand_to_fused(x, token_topk_to_pos, pos_to_expert)
+
+    # Test correctness: torch reference
+    expanded_x_ref = tile_kernels.torch.expand_to_fused(x, token_topk_to_pos, pos_to_expert)
+    assert_equal(expanded_x, expanded_x_ref)
+
+
+@pytest.mark.benchmark
+@pytest.mark.parametrize('params', generate_test_params_expand(is_benchmark=True), ids=make_param_id)
+def test_expand_to_fused_benchmark(benchmark_timer, benchmark_record, params):
+    x, pos_to_expert, token_topk_to_pos, num_tokens = generate_test_data_expand_to_fused(params)
+
+    expanded_x = tile_kernels.moe.expand_to_fused(x, token_topk_to_pos, pos_to_expert)
+
+    t_us = benchmark_timer(lambda: tile_kernels.moe.expand_to_fused(x, token_topk_to_pos, pos_to_expert))
+
+    num_bytes = count_bytes(x, token_topk_to_pos, pos_to_expert, expanded_x)
+    bandwidth_gbs = num_bytes / t_us / 1e3
+
+    params.pop('num_send_tokens')
+    benchmark_record(
+        kernel='expand_to_fused',
+        operation='fwd',
+        params={'num_tokens': num_tokens, **params},
+        time_us=t_us,
+        bandwidth_gbs=bandwidth_gbs,
+    )
+
+
+def generate_test_data_expand_to_fused_with_sf(params):
+    num_experts = params['num_experts']
+    num_ep_ranks = params['num_ep_ranks']
+    hidden = params['hidden']
+    num_per_channels = params['num_per_channels']
+    use_tma_aligned_col_major_sf = params['use_tma_aligned_col_major_sf']
+    round_sf = params['round_sf']
+    use_packed_ue8m0 = params['use_packed_ue8m0']
+
+    topk_idx = generate_topk_idx(params)
+    num_tokens = topk_idx.shape[0]
+    x = torch.randn((num_tokens, hidden), dtype=torch.bfloat16, device='cuda')
+    x_fp8, x_sf = tile_kernels.quant.per_token_cast(
+        x, 'e4m3',
+        num_per_channels=num_per_channels,
+        use_tma_aligned_col_major_sf=use_tma_aligned_col_major_sf,
+        round_sf=round_sf,
+        use_packed_ue8m0=use_packed_ue8m0,
+    )
+    pos_to_expert, _, _, token_topk_to_pos, _, _, _, _ = tile_kernels.moe.get_fused_mapping(topk_idx, num_experts, 0, 16)
+
+    return (x_fp8, x_sf, pos_to_expert, token_topk_to_pos, num_tokens)
+
+
+def generate_test_params_expand_with_sf(is_benchmark: bool) -> list[dict]:
+    return [
+        {**moe, 'hidden': hidden, 'num_per_channels': num_per_channels,
+         'use_tma_aligned_col_major_sf': col_major, 'round_sf': round_sf,
+         'use_packed_ue8m0': packed_ue8m0}
+        for moe in generate_moe_params(is_benchmark=is_benchmark)
+        for hidden in generate_hidden_sizes()
+        for num_per_channels in (32, 128)
+        for col_major, round_sf, packed_ue8m0 in [(False, True, False), (True, True, True)]
+    ]
+
+
+@pytest.mark.parametrize('params', generate_test_params_expand_with_sf(is_benchmark=False), ids=make_param_id)
+def test_expand_to_fused_with_sf(params):
+    x_fp8, x_sf, pos_to_expert, token_topk_to_pos, num_tokens = generate_test_data_expand_to_fused_with_sf(params)
+    num_per_channels = params['num_per_channels']
+    use_tma_aligned_col_major_sf = params['use_tma_aligned_col_major_sf']
+
+    func = lambda: tile_kernels.moe.expand_to_fused_with_sf(
+        (x_fp8, x_sf.contiguous()), num_per_channels, token_topk_to_pos, pos_to_expert, use_tma_aligned_col_major_sf,
+    )
+
+    expanded_x, expanded_x_sf = func()
+
+    # Test correctness: torch reference
+    expanded_x_ref, expanded_x_sf_ref = tile_kernels.torch.expand_to_fused_with_sf(
+        (x_fp8, x_sf.contiguous()), num_per_channels, token_topk_to_pos, pos_to_expert, use_tma_aligned_col_major_sf,
+    )
+    assert_equal(expanded_x, expanded_x_ref)
+    assert_equal(expanded_x_sf, expanded_x_sf_ref, check_stride=num_tokens > 0)
+
+
+@pytest.mark.benchmark
+@pytest.mark.parametrize('params', generate_test_params_expand_with_sf(is_benchmark=True), ids=make_param_id)
+def test_expand_to_fused_with_sf_benchmark(benchmark_timer, benchmark_record, params):
+    x_fp8, x_sf, pos_to_expert, token_topk_to_pos, num_tokens = generate_test_data_expand_to_fused_with_sf(params)
+    num_per_channels = params['num_per_channels']
+    use_tma_aligned_col_major_sf = params['use_tma_aligned_col_major_sf']
+
+    func = lambda: tile_kernels.moe.expand_to_fused_with_sf(
+        (x_fp8, x_sf.contiguous()), num_per_channels, token_topk_to_pos, pos_to_expert, use_tma_aligned_col_major_sf,
+    )
+
+    expanded_x, expanded_x_sf = func()
+
+    t_us = benchmark_timer(func)
+
+    num_bytes = count_bytes(x_fp8, x_sf, token_topk_to_pos, pos_to_expert, expanded_x, expanded_x_sf)
+    bandwidth_gbs = num_bytes / t_us / 1e3
+
+    params.pop('num_send_tokens')
+    benchmark_record(
+        kernel='expand_to_fused_with_sf',
+        operation='fwd',
+        params={'num_tokens': num_tokens, **params},
+        time_us=t_us,
+        bandwidth_gbs=bandwidth_gbs,
+    )

tile_kernels_src/tests/moe/test_get_fused_mapping.py

@@ -0,0 +1,103 @@
+import os
+
+import pytest
+
+import torch
+
+import tile_kernels
+from tile_kernels.config import set_num_sms
+from tile_kernels.testing.generator import generate_topk_idx, generate_moe_params, generate_num_sms
+from tile_kernels.testing.numeric import count_bytes
+from tile_kernels.testing.bench import make_param_id
+
+# Disable TileLang prints
+os.environ['TILELANG_PRINT_ON_COMPILATION'] = '0'
+
+
+def generate_test_data(params):
+    num_experts = params['num_experts']
+
+    topk_idx = generate_topk_idx(params)
+    num_tokens = topk_idx.shape[0]
+
+    return (topk_idx, num_tokens)
+
+
+def generate_test_params(is_benchmark: bool) -> list[dict]:
+    params = [
+        {**moe, 'alignment': alignment}
+        for moe in generate_moe_params(is_benchmark=is_benchmark)
+        for alignment in (64, 128)
+    ]
+    if is_benchmark:
+        params = [{**param, 'alignment': 128} for param in params]
+    return params
+
+
+@pytest.mark.parametrize('params', generate_test_params(is_benchmark=False), ids=make_param_id)
+def test_get_fused_mapping(params):
+    alignment = params['alignment']
+
+    topk_idx, num_tokens = generate_test_data(params)
+    num_topk = params['num_topk']
+    num_experts = params['num_experts']
+
+    func = lambda: tile_kernels.moe.get_fused_mapping(topk_idx, num_experts, 0, alignment)
+
+    for num_sms in generate_num_sms():
+        set_num_sms(num_sms)
+
+        pos_to_expert, pos_to_token, pos_to_token_topk, token_topk_to_pos, expert_start, expert_end, num_tokens_per_expert, num_tokens_per_expert_list = func()
+        assert num_tokens_per_expert.tolist() == num_tokens_per_expert_list
+        start = 0
+
+        # Check `pos_to_expert`, `num_tokens_per_expert`, `expert_start`, `expert_end` correctness
+        for i in range(num_experts):
+            assert start == expert_start[i].item()
+            s = pos_to_expert[start:start + num_tokens_per_expert_list[i]]
+            assert (s == i).int().sum().item() == (topk_idx == i).int().sum().item()
+            s = (s == i) + (s == -1)
+            assert s.int().sum().item() == s.numel()
+            start += num_tokens_per_expert_list[i]
+            assert start == expert_end[i].item()
+
+        non_negative_mask = pos_to_expert >= 0
+
+        if non_negative_mask.any():
+            t_values = pos_to_token_topk[non_negative_mask]
+            token_indices = t_values // num_topk
+            topk_indices = t_values % num_topk
+            expected_indices = torch.arange(pos_to_token_topk.numel(), device='cuda')[non_negative_mask]
+            actual_indices = token_topk_to_pos[token_indices, topk_indices]
+            assert torch.equal(actual_indices, expected_indices)
+            assert torch.equal(topk_idx[token_indices, topk_indices], pos_to_expert[non_negative_mask])
+            assert torch.equal(pos_to_token_topk[non_negative_mask] // num_topk, pos_to_token[non_negative_mask])
+
+        negative_mask = pos_to_expert < 0
+        assert torch.equal(negative_mask, pos_to_token < 0)
+        assert torch.equal(negative_mask, pos_to_token_topk < 0)
+
+
+@pytest.mark.benchmark
+@pytest.mark.parametrize('params', generate_test_params(is_benchmark=True), ids=make_param_id)
+def test_get_fused_mapping_benchmark(benchmark_timer, benchmark_record, params):
+    alignment = params['alignment']
+
+    topk_idx, num_tokens = generate_test_data(params)
+    num_experts = params['num_experts']
+
+    func = lambda: tile_kernels.moe.get_fused_mapping(topk_idx, num_experts, 0, alignment)
+
+    t_us = benchmark_timer(func)
+    result = func()
+    num_bytes = count_bytes(topk_idx, *result[:7])
+    bandwidth_gbs = num_bytes / t_us / 1e3
+
+    params.pop('num_send_tokens')
+    benchmark_record(
+        kernel='get_fused_mapping',
+        operation='fwd',
+        params={'num_tokens': num_tokens, **params},
+        time_us=t_us,
+        bandwidth_gbs=bandwidth_gbs,
+    )

tile_kernels_src/tests/moe/test_group_count.py

@@ -0,0 +1,55 @@
+import os
+import torch
+
+import pytest
+
+import tile_kernels
+from tile_kernels.config import set_num_sms
+from tile_kernels.testing.generator import generate_topk_idx, generate_moe_params, generate_num_sms
+from tile_kernels.testing.numeric import assert_equal, count_bytes
+from tile_kernels.torch import group_count as torch_group_count
+from tile_kernels.testing.bench import make_param_id
+
+# Disable TileLang prints
+os.environ['TILELANG_PRINT_ON_COMPILATION'] = '0'
+
+
+def generate_test_data(params):
+    topk_idx = generate_topk_idx(params)
+    num_tokens = topk_idx.shape[0]
+
+    return (topk_idx, num_tokens)
+
+
+@pytest.mark.parametrize('params', list(generate_moe_params(is_benchmark=False)), ids=make_param_id)
+def test_group_count(params):
+    topk_idx, num_tokens = generate_test_data(params)
+    num_experts = params['num_experts']
+
+    # Test correctness
+    count_ref = torch_group_count(topk_idx, num_experts)
+
+    for num_sms in generate_num_sms():
+        set_num_sms(num_sms)
+        count = tile_kernels.moe.group_count(topk_idx, num_experts)
+        assert_equal(count, count_ref)
+
+
+@pytest.mark.benchmark
+@pytest.mark.parametrize('params', list(generate_moe_params(is_benchmark=True)), ids=make_param_id)
+def test_group_count_benchmark(benchmark_timer, benchmark_record, params):
+    topk_idx, num_tokens = generate_test_data(params)
+    num_experts = params['num_experts']
+
+    t_us = benchmark_timer(lambda: tile_kernels.moe.group_count(topk_idx, num_experts))
+    num_bytes = count_bytes(topk_idx)
+    bandwidth_gbs = num_bytes / t_us / 1e3
+
+    params.pop('num_send_tokens')
+    benchmark_record(
+        kernel='group_count',
+        operation='fwd',
+        params={'num_tokens': num_tokens, **params},
+        time_us=t_us,
+        bandwidth_gbs=bandwidth_gbs,
+    )

tile_kernels_src/tests/moe/test_inplace_unique_group_indices.py

@@ -0,0 +1,79 @@
+import os
+import torch
+
+import pytest
+
+import tile_kernels
+from tile_kernels.torch import inplace_unique_group_indices as torch_inplace_unique_group_indices
+from tile_kernels.config import set_num_sms
+from tile_kernels.testing.numeric import assert_equal, count_bytes
+from tile_kernels.testing.generator import generate_moe_params, generate_topk_idx, generate_num_sms
+from tile_kernels.testing.bench import make_param_id
+
+# Disable TileLang prints
+os.environ['TILELANG_PRINT_ON_COMPILATION'] = '0'
+
+
+def generate_test_data(params):
+    num_experts = params['num_experts']
+    num_ep_ranks = params['num_ep_ranks']
+    num_groups = params['num_groups']
+
+    topk_idx = generate_topk_idx(params)
+    num_tokens = topk_idx.shape[0]
+    _group_indices = topk_idx // (num_experts * num_ep_ranks // num_groups)
+
+    return (_group_indices, num_tokens)
+
+
+def generate_test_params(is_benchmark: bool) -> list[dict]:
+    return [
+        {**moe, 'num_groups': num_groups}
+        for moe in generate_moe_params(is_benchmark=is_benchmark)
+        for num_groups in (8, 16, 72) if moe['num_experts'] * moe['num_ep_ranks'] % num_groups == 0
+    ]
+
+
+@pytest.mark.parametrize('params', generate_test_params(is_benchmark=False), ids=make_param_id)
+def test_inplace_unique_group_indices(params):
+    _group_indices, num_tokens = generate_test_data(params)
+    num_groups = params['num_groups']
+
+    func = lambda group_indices: tile_kernels.moe.inplace_unique_group_indices(group_indices, num_groups)
+    func_ref = lambda group_indices: torch_inplace_unique_group_indices(group_indices, num_groups)
+
+    group_indices_ref = _group_indices.clone()
+    func_ref(group_indices_ref)
+
+    for num_sms in generate_num_sms():
+        set_num_sms(num_sms)
+        group_indices = _group_indices.clone()
+        func(group_indices)
+        assert_equal(group_indices, group_indices_ref)
+
+
+@pytest.mark.benchmark
+@pytest.mark.parametrize('params', generate_test_params(is_benchmark=True), ids=make_param_id)
+def test_inplace_unique_group_indices_benchmark(benchmark_timer, benchmark_record, params):
+    _group_indices, num_tokens = generate_test_data(params)
+    num_groups = params['num_groups']
+
+    func = lambda group_indices: tile_kernels.moe.inplace_unique_group_indices(group_indices, num_groups)
+
+    group_indices = _group_indices.clone()
+    func(group_indices)
+
+    num_bytes = count_bytes(group_indices)
+    num_bytes += torch.count_nonzero(group_indices != _group_indices).item() * 4
+
+    t_us = benchmark_timer(lambda: func(_group_indices.clone()))
+    bandwidth_gbs = num_bytes / t_us / 1e3
+
+    params.pop('num_send_tokens')
+    benchmark_record(
+        kernel='inplace_unique_group_indices',
+        operation='fwd',
+        params={'num_tokens': num_tokens, **params},
+        time_us=t_us,
+        bandwidth_gbs=bandwidth_gbs,
+    )

tile_kernels_src/tests/moe/test_mask_indices_by_tp.py

@@ -0,0 +1,70 @@
+import os
+
+import torch
+import pytest
+
+import tile_kernels
+from tile_kernels.testing.numeric import assert_equal, count_bytes
+from tile_kernels.testing.generator import generate_moe_params, generate_topk_idx
+from tile_kernels.torch import mask_indices_by_tp as torch_mask_indices_by_tp
+from tile_kernels.testing.bench import make_param_id
+
+# Disable TileLang prints
+os.environ['TILELANG_PRINT_ON_COMPILATION'] = '0'
+
+
+def generate_test_data(params):
+    num_experts = params['num_experts']
+    num_ep_ranks = params['num_ep_ranks']
+    num_tp_ranks = params['num_tp_ranks']
+
+    topk_idx = generate_topk_idx(params)
+    num_tokens = topk_idx.shape[0]
+    tp_rank = torch.randint(0, num_tp_ranks, (1,)).item()
+    n = num_experts * num_ep_ranks
+
+    return (topk_idx, num_tokens, tp_rank, n)
+
+
+def generate_test_params(is_benchmark: bool) -> list[dict]:
+    return [
+        {**moe, 'num_tp_ranks': num_tp_ranks}
+        for moe in generate_moe_params(is_benchmark=is_benchmark)
+        for num_tp_ranks in (2, 4, 8)
+    ]
+
+
+@pytest.mark.parametrize('params', generate_test_params(is_benchmark=False), ids=make_param_id)
+def test_mask_indices_by_tp(params):
+    topk_idx, num_tokens, tp_rank, n = generate_test_data(params)
+    num_ep_ranks = params['num_ep_ranks']
+    num_tp_ranks = params['num_tp_ranks']
+
+    masked_indices = tile_kernels.moe.mask_indices_by_tp(topk_idx, n, num_ep_ranks, tp_rank, num_tp_ranks)
+
+    # Test correctness: torch reference
+    masked_ref = torch_mask_indices_by_tp(topk_idx, n, num_ep_ranks, tp_rank, num_tp_ranks)
+    assert_equal(masked_indices, masked_ref)
+
+
+@pytest.mark.benchmark
+@pytest.mark.parametrize('params', generate_test_params(is_benchmark=True), ids=make_param_id)
+def test_mask_indices_by_tp_benchmark(benchmark_timer, benchmark_record, params):
+    topk_idx, num_tokens, tp_rank, n = generate_test_data(params)
+    num_ep_ranks = params['num_ep_ranks']
+    num_tp_ranks = params['num_tp_ranks']
+
+    masked_indices = tile_kernels.moe.mask_indices_by_tp(topk_idx, n, num_ep_ranks, tp_rank, num_tp_ranks)
+
+    t_us = benchmark_timer(lambda: tile_kernels.moe.mask_indices_by_tp(topk_idx, n, num_ep_ranks, tp_rank, num_tp_ranks))
+    num_bytes = count_bytes(topk_idx, masked_indices)
+    bandwidth_gbs = num_bytes / t_us / 1e3
+
+    params.pop('num_send_tokens')
+    benchmark_record(
+        kernel='mask_indices_by_tp',
+        operation='fwd',
+        params={'num_tokens': num_tokens, **params, 'tp_rank': tp_rank},
+        time_us=t_us,
+        bandwidth_gbs=bandwidth_gbs,
+    )

tile_kernels_src/tests/moe/test_normalize_weight.py

@@ -0,0 +1,57 @@
+import os
+import torch
+
+import pytest
+
+import tile_kernels
+from tile_kernels.testing.generator import generate_topk_idx, generate_moe_params
+from tile_kernels.testing.numeric import assert_equal, count_bytes
+from tile_kernels.torch import normalize_weight as torch_normalize_weight
+from tile_kernels.testing.bench import make_param_id
+
+# Disable TileLang prints
+os.environ['TILELANG_PRINT_ON_COMPILATION'] = '0'
+
+
+def generate_test_data(params):
+    num_topk = params['num_topk']
+
+    topk_idx = generate_topk_idx(params)
+    num_tokens = topk_idx.shape[0]
+    topk_weights = torch.rand((num_tokens, num_topk), dtype=torch.float32, device='cuda')
+
+    return (topk_weights, num_tokens)
+
+
+@pytest.mark.parametrize('params', list(generate_moe_params(is_benchmark=False)), ids=make_param_id)
+def test_normalize_weight(params):
+    (topk_weights, _) = generate_test_data(params)
+
+    denominator, normalized_weights = tile_kernels.moe.normalize_weight(topk_weights)
+
+    # Test correctness: torch reference
+    denom_ref, norm_ref = torch_normalize_weight(topk_weights)
+    assert_equal(denominator, denom_ref)
+    assert_equal(normalized_weights, norm_ref)
+
+
+@pytest.mark.benchmark
+@pytest.mark.parametrize('params', list(generate_moe_params(is_benchmark=True)), ids=make_param_id)
+def test_normalize_weight_benchmark(benchmark_timer, benchmark_record, params):
+    topk_weights, num_tokens = generate_test_data(params)
+    num_topk = params['num_topk']
+
+    denominator, normalized_weights = tile_kernels.moe.normalize_weight(topk_weights)
+
+    t_us = benchmark_timer(lambda: tile_kernels.moe.normalize_weight(topk_weights))
+    num_bytes = count_bytes(topk_weights, denominator, normalized_weights)
+    bandwidth_gbs = num_bytes / t_us / 1e3
+
+    params.pop('num_send_tokens')
+    benchmark_record(
+        kernel='normalize_weight',
+        operation='fwd',
+        params={'num_tokens': num_tokens, **params, 'num_topk': num_topk},
+        time_us=t_us,
+        bandwidth_gbs=bandwidth_gbs,
+    )

tile_kernels_src/tests/moe/test_reduce_fused.py

@@ -0,0 +1,112 @@
+import os
+import torch
+
+import pytest
+
+import tile_kernels
+from tile_kernels.testing.bench import dtype_to_str, make_param_id
+from tile_kernels.testing.generator import generate_topk_idx, generate_hidden_sizes, generate_moe_params
+from tile_kernels.testing.numeric import assert_equal, count_bytes
+
+# Disable TileLang prints
+os.environ['TILELANG_PRINT_ON_COMPILATION'] = '0'
+
+
+def generate_test_data(params):
+    hidden = params['hidden']
+    with_weights = params['with_weights']
+    in_dtype = params['in_dtype']
+    out_dtype = params['out_dtype']
+    with_sf = params['with_sf']
+    num_experts = params['num_experts']
+    num_ep_ranks = params['num_ep_ranks']
+    num_topk = params['num_topk']
+
+    topk_idx = generate_topk_idx(params)
+    num_tokens = topk_idx.shape[0]
+    num_expanded_tokens = num_tokens * num_topk
+    expanded = torch.randn((num_expanded_tokens, hidden), dtype=in_dtype, device='cuda')
+    _, _, _, token_topk_to_pos, _, _, _, _ = tile_kernels.moe.get_fused_mapping(topk_idx, num_experts, 0, 1)
+
+    topk_weights = torch.rand((num_tokens, num_topk), dtype=torch.float32, device='cuda') if with_weights else None
+    if out_dtype == torch.float8_e4m3fn:
+        sf = torch.randn((1,), dtype=torch.float32, device='cuda')
+    else:
+        sf = None
+    if with_sf:
+        x_sf = torch.randn((num_expanded_tokens,), dtype=torch.float32, device='cuda')
+    else:
+        x_sf = None
+    fp8_format = 'e4m3' if out_dtype == torch.float8_e4m3fn else ''
+
+    x_input = (expanded, x_sf) if x_sf is not None else expanded
+
+    return (expanded, token_topk_to_pos, topk_weights, sf, x_sf, fp8_format, x_input, num_tokens)
+
+
+def generate_test_params(is_benchmark: bool) -> list[dict]:
+    params = [
+        {**moe, 'hidden': hidden, 'with_weights': with_weights,
+         'in_dtype': in_dtype, 'out_dtype': out_dtype, 'with_sf': with_sf}
+        for moe in generate_moe_params(is_benchmark=is_benchmark)
+        for hidden in generate_hidden_sizes(256)
+        for with_weights in (True, False)
+        for in_dtype in (torch.float32, torch.bfloat16)
+        for out_dtype in (in_dtype, torch.float8_e4m3fn)
+        for with_sf in (True, False)
+    ]
+    if is_benchmark:
+        params = [p for p in params if p['num_topk'] == 6 and p['with_weights']]
+    return params
+
+
+@pytest.mark.parametrize('params', generate_test_params(is_benchmark=False), ids=make_param_id)
+def test_reduce_fused(params):
+    (expanded, token_topk_to_pos, topk_weights, sf, x_sf, fp8_format, x_input,
+     _) = generate_test_data(params)
+
+    # Test correctness: tile_kernels kernel
+    func = lambda: tile_kernels.moe.reduce_fused(
+        x_input, topk_weights, token_topk_to_pos, fp8_format, sf, None
+    )
+    r_tk = func()
+
+    # Test correctness: torch reference
+    r_ref = tile_kernels.torch.reduce_fused(
+        x_input, topk_weights, token_topk_to_pos, fp8_format, sf
+    )
+    assert_equal(r_tk, r_ref)
+
+
+@pytest.mark.benchmark
+@pytest.mark.parametrize('params', generate_test_params(is_benchmark=True), ids=make_param_id)
+def test_reduce_fused_benchmark(benchmark_timer, benchmark_record, params):
+    hidden = params['hidden']
+    out_dtype = params['out_dtype']
+
+    (expanded, token_topk_to_pos, topk_weights, sf, x_sf, fp8_format, x_input,
+     num_tokens) = generate_test_data(params)
+    in_dtype = params['in_dtype']
+
+    func = lambda: tile_kernels.moe.reduce_fused(
+        x_input, topk_weights, token_topk_to_pos, fp8_format, sf, None
+    )
+    r_tk = func()
+
+    num_bytes = count_bytes(token_topk_to_pos, x_sf, r_tk)
+    num_bytes += torch.count_nonzero(token_topk_to_pos != -1).item() * hidden * (torch.finfo(in_dtype).bits // 8)
+    if topk_weights is not None:
+        num_bytes += count_bytes(topk_weights)
+
+    t_us = benchmark_timer(func)
+
+    bandwidth_gbs = num_bytes / t_us / 1e3
+
+    params.pop('num_send_tokens')
+    benchmark_record(
+        kernel='reduce_fused',
+        operation='fwd',
+        params={'num_tokens': num_tokens, **params, 'in_dtype': dtype_to_str(in_dtype), 'out_dtype': dtype_to_str(out_dtype)},
+        time_us=t_us,
+        bandwidth_gbs=bandwidth_gbs,
+    )

tile_kernels_src/tests/moe/test_top2_sum_gate.py

@@ -0,0 +1,359 @@
+import os
+
+import torch
+import torch.nn.functional as F
+import pytest
+
+import tile_kernels
+from tile_kernels.moe.scoring import ScoringFunc
+from tile_kernels.testing.generator import generate_num_tokens
+from tile_kernels.testing.numeric import count_bytes, assert_equal
+from tile_kernels.testing.bench import make_param_id
+
+from tile_kernels.torch import topk_sum_and_topk_group_idx as torch_topk_sum_and_topk_group_idx
+from tile_kernels.torch import top2_sum_gate as torch_top2_sum_gate
+
+# Disable TileLang prints
+os.environ['TILELANG_PRINT_ON_COMPILATION'] = '0'
+
+
+_CONFIGS = [
+    (0, 0, 72, 1, 6),
+    (0, 0, 32, 2, 6),
+    (0, 0, 64, 2, 6),
+    (0, 0, 96, 2, 6),
+    (0, 0, 16, 2, 6),
+    (0, 0, 36, 2, 6),
+    (0, 0, 108, 2, 6),
+    (0, 0, 128, 2, 6),
+    (0, 0, 144, 2, 6),
+    (8, 8, 256, 2, 8),
+    (8, 4, 256, 2, 8),
+]
+
+
+def generate_test_params(is_benchmark: bool) -> list[dict]:
+    params = [
+        {
+            'num_groups': num_groups,
+            'num_topk_groups': num_topk_groups,
+            'num_routed_experts': num_routed_experts,
+            'num_shared_experts': num_shared_experts,
+            'num_topk': num_topk,
+        }
+        for num_groups, num_topk_groups, num_routed_experts, num_shared_experts, num_topk in _CONFIGS
+    ]
+    if is_benchmark:
+        scoring_funcs = [sf for sf in ScoringFunc if sf != ScoringFunc.IDENTITY]
+        params = [
+            {**p, 'scoring_func': sf}
+            for p in params
+            for sf in scoring_funcs
+        ]
+    return params
+
+
+@pytest.mark.parametrize('params', generate_test_params(is_benchmark=False), ids=make_param_id)
+def test_top2_sum_gate(params):
+    num_groups = params['num_groups']
+    num_topk_groups = params['num_topk_groups']
+    num_routed_experts = params['num_routed_experts']
+    num_shared_experts = params['num_shared_experts']
+    num_topk = params['num_topk']
+
+    num_extra_experts = 32  # Only enabled for `use_shared_as_routed`
+    num_group_sum_topk = 2
+    routed_scaling_factor = 1.5
+    num_ep_ranks, num_tp_ranks = 4, 2
+    ep_rank = 0
+    assert num_routed_experts % num_ep_ranks == 0 and (num_routed_experts + num_extra_experts) % num_ep_ranks == 0
+
+    def get_group_masked_scores(scores: torch.Tensor, bias: torch.Tensor) -> torch.Tensor:
+        scores.add_(bias.unsqueeze(0))
+        if num_topk_groups != num_groups:
+            group_idx = torch_topk_sum_and_topk_group_idx(scores.view(num_tokens, num_groups, num_routed_experts // num_groups), num_group_sum_topk, num_topk_groups)
+            group_mask = scores.new_ones(num_tokens, num_groups, dtype=torch.bool).scatter_(1, group_idx, False)
+            score_mask = group_mask.unsqueeze(-1).expand(num_tokens, num_groups, num_routed_experts // num_groups).reshape(scores.size(0), num_routed_experts)
+            scores = scores.masked_fill(score_mask, float('-inf'))
+        return scores
+
+    def get_scores(logits: torch.Tensor, scoring_func: ScoringFunc) -> torch.Tensor:
+        if scoring_func == ScoringFunc.SIGMOID:
+            return logits.sigmoid()
+        elif scoring_func == ScoringFunc.SOFTMAX:
+            return logits.softmax(dim=-1)
+        elif scoring_func == ScoringFunc.SQRTSOFTPLUS:
+            return F.softplus(logits).sqrt()
+        else:
+            raise ValueError(f'Unknown scoring function: {scoring_func}')
+
+    def construct_input(scoring_func: ScoringFunc):
+        while True:
+            logits = torch.randn((num_tokens + num_padded_tokens, num_routed_experts), dtype=torch.float, device='cuda')
+            bias = torch.randn(num_routed_experts, dtype=torch.float, device='cuda')
+            scores = get_scores(logits[:num_tokens], scoring_func)
+
+            # NOTES: We expect the top-k group to be stable, and since the internal kernel uses low-precision operations,
+            # the generated data needs to have a sufficient gap between the k-th largest and
+            # the (k+1)-th largest values to ensure that the selected top-k groups are definitive
+            if num_topk_groups != num_groups:
+                # NOTES: softmax has different behavior than other functions, so we need to handle it separately
+                if scoring_func != ScoringFunc.SOFTMAX:
+                    scores_ref = scores + bias.unsqueeze(0)
+                else:
+                    scores_ref = logits[:num_tokens] + bias.unsqueeze(0)
+
+                group_scores_ref = scores_ref.view(num_tokens, num_groups, num_routed_experts // num_groups).topk(num_group_sum_topk, dim=-1, sorted=False).values.sum(-1)
+                group_scores_ref, _ = group_scores_ref.sort(dim=-1, descending=True)
+                not_equal = group_scores_ref[:, num_topk_groups - 1] - group_scores_ref[:, num_topk_groups] > 1e-6
+                if not torch.all(not_equal):
+                    continue
+
+            scores = get_group_masked_scores(scores, bias)
+            topk_weights_ref, _ = torch.topk(scores, k=num_topk + 1, dim=-1, sorted=True)
+
+            # NOTES: We expect the top-k results to be stable, and since the internal kernel uses low-precision operations,
+            # the generated data needs to have a sufficient gap between the top-k values.
+            not_equal = topk_weights_ref[:, : num_topk - 1] - topk_weights_ref[:, 1:num_topk] > 2e-6
+            if torch.all(not_equal):
+                break
+        return logits, bias
+
+    # noinspection PyShadowingNames
+    def get_kwargs(use_shared_as_routed: bool, num_extra_experts: int, num_tokens: int, num_padded_tokens: int, fix_routing: bool):
+        mask = None
+        if num_padded_tokens > 0:
+            mask = torch.ones(num_tokens + num_padded_tokens, dtype=torch.bool, device='cuda')
+            mask[-num_padded_tokens:] = False
+
+        to_physical_map = None
+        logical_count = None
+        fix_routing_mask = None
+        unmapped_topk_idx = torch.zeros((num_tokens + num_padded_tokens, num_topk), dtype=torch.int64, device='cuda')
+
+        # Test to physical map
+        if use_shared_as_routed:
+            assert num_shared_experts <= num_extra_experts
+            to_physical_map = torch.arange(0, num_routed_experts + num_shared_experts, dtype=torch.int, device='cuda')
+            to_physical_map = to_physical_map.view(-1, 1).expand(-1, num_extra_experts + 1).contiguous()
+            logical_count = torch.ones((num_routed_experts + num_shared_experts,), dtype=torch.int, device='cuda')
+
+        # Test fix routing mask
+        if fix_routing:
+            fix_routing_mask = torch.ones((num_tokens + num_padded_tokens,), dtype=torch.bool, device='cuda')
+            # NOTES: Use separate generator to generate the same value for same (num_tokens, num_topk)
+            unmapped_topk_idx_generator = torch.Generator(device='cuda').manual_seed(42)
+            unmapped_topk_idx = torch.randint(
+                0,
+                num_routed_experts,
+                (num_tokens + num_padded_tokens, num_topk),
+                generator=unmapped_topk_idx_generator,
+                dtype=torch.int64,
+                device='cuda',
+            )
+        return dict(
+            mask=mask,
+            fix_routing_mask=fix_routing_mask,
+            to_physical_map=to_physical_map,
+            logical_count=logical_count,
+            unmapped_topk_idx=unmapped_topk_idx,
+        )
+
+    # Correctness test
+    use_shared_as_routed_valid = num_topk % num_shared_experts == 0 and num_routed_experts % (num_topk // num_shared_experts) == 0
+    for num_tokens in generate_num_tokens():
+        for num_padded_tokens in (0, 10):
+            for tp_rank in range(0, num_tp_ranks):
+                for use_shared_as_routed in (False, True) if use_shared_as_routed_valid else (False,):
+                    for scoring_func in ScoringFunc:
+                        if scoring_func == ScoringFunc.IDENTITY:
+                            continue
+                        for fix_routing in (False, True):
+                            logits, bias = construct_input(scoring_func)
+                            args = (
+                                logits,
+                                bias,
+                                num_topk,
+                                num_topk_groups,
+                                num_groups,
+                                use_shared_as_routed,
+                                num_shared_experts,
+                                routed_scaling_factor,
+                                ep_rank,
+                                num_ep_ranks,
+                                tp_rank,
+                                num_tp_ranks,
+                                str(scoring_func),
+                            )
+                            kwargs = get_kwargs(use_shared_as_routed, num_extra_experts, num_tokens, num_padded_tokens, fix_routing)
+                            kwargs_ref = get_kwargs(use_shared_as_routed, num_extra_experts, num_tokens, num_padded_tokens, fix_routing)
+
+                            topk_idx, topk_weights= tile_kernels.moe.top2_sum_gate(*args, **kwargs)
+                            topk_idx_ref, topk_weights_ref = torch_top2_sum_gate(*args, **kwargs_ref)
+
+                            unmapped_topk_idx = kwargs['unmapped_topk_idx']
+                            unmapped_topk_idx_ref = kwargs_ref['unmapped_topk_idx']
+
+                            sorted_topk_idx, _ = topk_idx.sort(dim=1)
+                            sorted_topk_idx_ref, _ = topk_idx_ref.sort(dim=1)
+
+                            sorted_unmapped_topk_idx = unmapped_topk_idx.sort(dim=1)[0]
+                            sorted_unmapped_topk_idx_ref = unmapped_topk_idx_ref.sort(dim=1)[0]
+
+                            sorted_topk_weights, _ = topk_weights.sort(dim=1)
+                            sorted_topk_weights_ref, _ = topk_weights_ref.sort(dim=1)
+
+                            assert_equal(sorted_topk_idx, sorted_topk_idx_ref)
+                            assert_equal(sorted_unmapped_topk_idx, sorted_unmapped_topk_idx_ref)
+                            assert torch.allclose(sorted_topk_weights, sorted_topk_weights_ref), (
+                                f'{sorted_topk_weights=}\n'
+                                f'{sorted_topk_weights_ref=}\n'
+                                f'{scoring_func=}, {num_groups=}, {num_topk_groups=}, {num_routed_experts=}, {num_shared_experts=}, {num_topk=}, {fix_routing=}\n'
+                                f'Different topk weights: \n'
+                                f'{[(sorted_topk_weights[i], sorted_topk_weights_ref[i]) for i in range(topk_weights.size(0)) if not torch.equal(sorted_topk_weights[i], sorted_topk_weights_ref[i])]}'
+                            )
+
+    # Check sort stability
+    tp_rank = 0
+    logits = torch.zeros((num_tokens + num_padded_tokens, num_routed_experts), dtype=torch.float, device='cuda')
+    bias = torch.zeros(num_routed_experts, dtype=torch.float, device='cuda')
+    args = (
+        logits,
+        bias,
+        num_topk,
+        num_topk_groups,
+        num_groups,
+        use_shared_as_routed,
+        num_shared_experts,
+        routed_scaling_factor,
+        ep_rank,
+        num_ep_ranks,
+        tp_rank,
+        num_tp_ranks,
+        str(ScoringFunc.SIGMOID),
+    )
+    fix_routing = False
+    kwargs = get_kwargs(use_shared_as_routed, num_extra_experts, num_tokens, num_padded_tokens, fix_routing)
+    topk_idx, topk_weights = tile_kernels.moe.top2_sum_gate(*args, **kwargs)
+    num_experts_on_rank = min(num_routed_experts // num_ep_ranks, num_topk)
+    assert torch.all(
+        topk_idx[:num_tokens, :num_experts_on_rank] == torch.arange(0, num_experts_on_rank, dtype=topk_idx.dtype, device=topk_idx.device)
+    )
+
+
+def generate_benchmark_test_case(params):
+    num_groups = params['num_groups']
+    num_topk_groups = params['num_topk_groups']
+    num_routed_experts = params['num_routed_experts']
+    num_shared_experts = params['num_shared_experts']
+    num_topk = params['num_topk']
+
+    num_extra_experts = 32
+    num_group_sum_topk = 2
+    routed_scaling_factor = 1.5
+    num_ep_ranks, num_tp_ranks = 4, 2
+    ep_rank = 0
+
+    use_shared_as_routed_valid = num_topk % num_shared_experts == 0 and num_routed_experts % (num_topk // num_shared_experts) == 0
+    use_shared_as_routed = use_shared_as_routed_valid
+
+    num_tokens, num_padded_tokens = 32, 4
+    tp_rank = num_tp_ranks - 1
+    fix_routing = False
+
+    logits = torch.randn((num_tokens + num_padded_tokens, num_routed_experts), dtype=torch.float, device='cuda')
+    bias = torch.randn(num_routed_experts, dtype=torch.float, device='cuda')
+
+    # noinspection PyShadowingNames
+    def get_kwargs(use_shared_as_routed, num_extra_experts, num_tokens, num_padded_tokens, fix_routing):
+        mask = None
+        if num_padded_tokens > 0:
+            mask = torch.ones(num_tokens + num_padded_tokens, dtype=torch.bool, device='cuda')
+            mask[-num_padded_tokens:] = False
+
+        to_physical_map = None
+        logical_count = None
+        fix_routing_mask = None
+        unmapped_topk_idx = torch.zeros((num_tokens + num_padded_tokens, num_topk), dtype=torch.int64, device='cuda')
+
+        if use_shared_as_routed:
+            assert num_shared_experts <= num_extra_experts
+            to_physical_map = torch.arange(0, num_routed_experts + num_shared_experts, dtype=torch.int, device='cuda')
+            to_physical_map = to_physical_map.view(-1, 1).expand(-1, num_extra_experts + 1).contiguous()
+            logical_count = torch.ones((num_routed_experts + num_shared_experts,), dtype=torch.int, device='cuda')
+
+        if fix_routing:
+            fix_routing_mask = torch.ones((num_tokens + num_padded_tokens,), dtype=torch.bool, device='cuda')
+            unmapped_topk_idx_generator = torch.Generator(device='cuda').manual_seed(42)
+            unmapped_topk_idx = torch.randint(
+                0,
+                num_routed_experts,
+                (num_tokens + num_padded_tokens, num_topk),
+                generator=unmapped_topk_idx_generator,
+                dtype=torch.int64,
+                device='cuda',
+            )
+        return dict(
+            mask=mask,
+            fix_routing_mask=fix_routing_mask,
+            to_physical_map=to_physical_map,
+            logical_count=logical_count,
+            unmapped_topk_idx=unmapped_topk_idx,
+        )
+
+    kwargs = get_kwargs(use_shared_as_routed, num_extra_experts, num_tokens, num_padded_tokens, fix_routing)
+
+    return {
+        'logits': logits,
+        'bias': bias,
+        'num_topk': num_topk,
+        'num_topk_groups': num_topk_groups,
+        'num_groups': num_groups,
+        'use_shared_as_routed_valid': use_shared_as_routed_valid,
+        'num_shared_experts': num_shared_experts,
+        'routed_scaling_factor': routed_scaling_factor,
+        'ep_rank': ep_rank,
+        'num_ep_ranks': num_ep_ranks,
+        'tp_rank': tp_rank,
+        'num_tp_ranks': num_tp_ranks,
+        'kwargs': kwargs,
+    }
+
+
+@pytest.mark.benchmark
+@pytest.mark.parametrize('params', generate_test_params(is_benchmark=True), ids=make_param_id)
+def test_top2_sum_gate_benchmark(benchmark_timer, benchmark_record, params):
+    scoring_func = params['scoring_func']
+
+    tc = generate_benchmark_test_case(params)
+    logits = tc['logits']
+    bias = tc['bias']
+    kwargs = tc['kwargs']
+
+    args = (
+        logits,
+        bias,
+        tc['num_topk'],
+        tc['num_topk_groups'],
+        tc['num_groups'],
+        tc['use_shared_as_routed_valid'],
+        tc['num_shared_experts'],
+        tc['routed_scaling_factor'],
+        tc['ep_rank'],
+        tc['num_ep_ranks'],
+        tc['tp_rank'],
+        tc['num_tp_ranks'],
+        str(scoring_func),
+    )
+
+    t_us = benchmark_timer(lambda: tile_kernels.moe.top2_sum_gate(*args, **kwargs))
+    num_bytes = count_bytes(logits, bias)
+    bandwidth_gbs = num_bytes / t_us / 1e3
+
+    benchmark_record(
+        kernel='top2_sum_gate',
+        operation='fwd',
+        params={**params, 'scoring_func': str(scoring_func)},
+        time_us=t_us,
+        bandwidth_gbs=bandwidth_gbs,
+    )

tile_kernels_src/tests/moe/test_topk_gate.py

@@ -0,0 +1,75 @@
+import os
+import torch
+import pytest
+
+import tile_kernels
+from tile_kernels.testing.generator import generate_num_tokens
+from tile_kernels.testing.numeric import assert_equal, count_bytes
+from tile_kernels.testing.bench import make_param_id
+from tile_kernels.torch import stable_topk as torch_stable_topk
+# Disable TileLang prints
+os.environ['TILELANG_PRINT_ON_COMPILATION'] = '0'
+
+
+_EXPERT_CONFIGS = [
+    (72, 6),
+    (32, 6),
+    (64, 6),
+    (96, 6),
+    (16, 6),
+    (36, 6),
+    (108, 6),
+    (128, 6),
+    (144, 6),
+    (256, 8),
+]
+
+
+def generate_test_data(params):
+    num_tokens = params['num_tokens']
+    num_experts = params['num_experts']
+    scores = torch.randn((num_tokens, num_experts), dtype=torch.float, device='cuda')
+    return scores
+
+
+def generate_test_params(is_benchmark: bool) -> list[dict]:
+    return [
+        {
+            'num_tokens': num_tokens,
+            'num_experts': num_experts,
+            'num_topk': num_topk,
+        }
+        for num_tokens in generate_num_tokens(is_benchmark=is_benchmark)
+        for num_experts, num_topk in _EXPERT_CONFIGS
+    ]
+
+
+@pytest.mark.parametrize('params', generate_test_params(is_benchmark=False), ids=make_param_id)
+def test_topk_gate(params):
+    scores = generate_test_data(params)
+    num_topk = params['num_topk']
+
+    topk_idx_ref = torch_stable_topk(scores, num_topk)
+    topk_idx = tile_kernels.moe.topk_gate(scores, num_topk)
+    assert_equal(topk_idx, topk_idx_ref)
+
+
+@pytest.mark.benchmark
+@pytest.mark.parametrize('params', generate_test_params(is_benchmark=True), ids=make_param_id)
+def test_topk_gate_benchmark(benchmark_timer, benchmark_record, params):
+    scores = generate_test_data(params)
+    num_topk = params['num_topk']
+
+    topk_idx = tile_kernels.moe.topk_gate(scores, num_topk)
+
+    t_us = benchmark_timer(lambda: tile_kernels.moe.topk_gate(scores, num_topk))
+    num_bytes = count_bytes(scores, topk_idx)
+    bandwidth_gbs = num_bytes / t_us / 1e3
+
+    benchmark_record(
+        kernel='topk_gate',
+        operation='fwd',
+        params=params,
+        time_us=t_us,
+        bandwidth_gbs=bandwidth_gbs,
+    )

tile_kernels_src/tests/moe/test_topk_sum_and_topk_idx.py

@@ -0,0 +1,86 @@
+import os
+
+import torch
+import pytest
+
+import tile_kernels
+from tile_kernels.testing.generator import generate_num_tokens
+from tile_kernels.testing.numeric import count_bytes, assert_equal
+from tile_kernels.testing.bench import make_param_id
+
+from tile_kernels.torch import topk_sum_and_topk_group_idx as torch_topk_sum_and_topk_group_idx
+
+# Disable TileLang prints
+os.environ['TILELANG_PRINT_ON_COMPILATION'] = '0'
+
+
+def torch_stable_topk(scores: torch.Tensor, num_topk: int):
+    _, sorted_indices = torch.sort(scores, dim=1, descending=True, stable=True)
+    return sorted_indices[:, :num_topk].contiguous()
+
+
+def generate_test_data(params):
+    num_tokens = params['num_tokens']
+    num_experts = params['num_experts']
+    num_groups = params['num_groups']
+
+    num_experts_per_group = num_experts // num_groups
+    scores = torch.randn((num_tokens, num_groups, num_experts_per_group), dtype=torch.float, device='cuda')
+
+    return (scores,)
+
+
+def generate_test_params(is_benchmark: bool) -> list[dict]:
+    return [
+        {
+            'num_tokens': num_tokens,
+            'num_experts': num_experts,
+            'num_groups': num_groups,
+            'num_group_sum_topk': num_group_sum_topk,
+            'num_topk_groups': num_topk_groups,
+        }
+        for num_tokens in generate_num_tokens(is_benchmark=is_benchmark)
+        for num_experts in (72, 256)
+        for num_groups in (4, 8, 12, 16)
+        if num_experts % num_groups == 0
+        for num_group_sum_topk in (1, 2)
+        for num_topk_groups in (2, 4)
+    ]
+
+
+@pytest.mark.parametrize('params', generate_test_params(is_benchmark=False), ids=make_param_id)
+def test_topk_sum_and_topk_group_idx(params):
+    (scores,) = generate_test_data(params)
+    num_group_sum_topk = params['num_group_sum_topk']
+    num_topk_groups = params['num_topk_groups']
+
+    func = lambda: tile_kernels.moe.topk_sum_and_topk_group_idx(scores, num_group_sum_topk, num_topk_groups)
+
+    group_idx_ref = torch_topk_sum_and_topk_group_idx(scores, num_group_sum_topk, num_topk_groups)
+    group_idx = func()
+
+    assert_equal(group_idx, group_idx_ref)
+
+
+@pytest.mark.benchmark
+@pytest.mark.parametrize('params', generate_test_params(is_benchmark=True), ids=make_param_id)
+def test_topk_sum_and_topk_group_idx_benchmark(benchmark_timer, benchmark_record, params):
+    (scores,) = generate_test_data(params)
+    num_group_sum_topk = params['num_group_sum_topk']
+    num_topk_groups = params['num_topk_groups']
+
+    func = lambda: tile_kernels.moe.topk_sum_and_topk_group_idx(scores, num_group_sum_topk, num_topk_groups)
+
+    group_idx = func()
+
+    t_us = benchmark_timer(func)
+    num_bytes = count_bytes(scores, group_idx)
+    bandwidth_gbs = num_bytes / t_us / 1e3
+
+    benchmark_record(
+        kernel='topk_sum_and_topk_group_idx',
+        operation='fwd',
+        params=params,
+        time_us=t_us,
+        bandwidth_gbs=bandwidth_gbs,
+    )

tile_kernels_src/tests/pytest_benchmark_plugin.py

@@ -0,0 +1,477 @@
+"""Benchmark & GPU memory profiling pytest plugin for tile_kernels.
+
+CLI options, markers, fixtures, and regression reporting for kernel
+benchmarks and GPU memory profiling.
+
+This file is deliberately NOT named ``conftest.py`` — it is loaded via
+``pytest_plugins`` in the root ``conftest.py``.  A non-conftest name
+prevents pluggy's duplicate-registration error.
+"""
+
+import json
+import math
+import os
+import threading
+
+import pytest
+import torch
+
+from tile_kernels.testing.bench import make_param_key
+
+# Baseline file, co-located with this plugin
+_BASELINES_PATH = os.path.join(os.path.dirname(__file__), 'benchmark_baselines.jsonl')
+
+
+# Prefix stripped from pytest node IDs to form stable, short keys
+_TILE_KERNELS_PREFIX = os.path.join('tests', '')
+
+
+# ---------------------------------------------------------------------------
+# CLI options
+# ---------------------------------------------------------------------------
+
+def pytest_addoption(parser):
+    parser.addoption(
+        '--run-benchmark',
+        action='store_true',
+        default=False,
+        help='Run benchmark tests (skipped by default)',
+    )
+    parser.addoption(
+        '--benchmark-output',
+        default=None,
+        help='Path to write benchmark results as JSONL (one JSON object per line)',
+    )
+    parser.addoption(
+        '--benchmark-regression-threshold',
+        default=0.15,
+        type=float,
+        help='Fraction of slowdown that triggers a regression warning (default: 0.15 = 15%%)',
+    )
+    parser.addoption(
+        '--benchmark-verbose',
+        action='store_true',
+        default=False,
+        help='Show extras columns (e.g., speedup, …) in the benchmark regression report',
+    )
+
+
+# ---------------------------------------------------------------------------
+# Marker registration & GPU binding
+# ---------------------------------------------------------------------------
+
+def pytest_configure(config):
+    config.addinivalue_line('markers', 'benchmark: mark test as benchmark (skip by default)')
+    # Bind each xdist worker to a GPU via CUDA_VISIBLE_DEVICES and restrict
+    # per-process GPU memory so that concurrent workers don't OOM.
+    worker_id = os.environ.get('PYTEST_XDIST_WORKER', None)
+    if worker_id is not None:
+        gpu_id = int(worker_id.replace('gw', ''))
+        num_gpus = torch.cuda.device_count()
+        os.environ['CUDA_VISIBLE_DEVICES'] = str(gpu_id % num_gpus)
+
+        # Restrict each worker's GPU memory to (total - 10 GB) / workers_per_gpu.
+        # PYTEST_XDIST_WORKER_COUNT is set by pytest-xdist automatically.
+        total_workers = int(os.environ.get('PYTEST_XDIST_WORKER_COUNT', '1'))
+        workers_per_gpu = math.ceil(total_workers / num_gpus)
+        _reserve_bytes = 10 * (1024 ** 3)  # 10 GB reserved for system / frameworks
+        total_mem = torch.cuda.mem_get_info(0)[1]
+        usable_mem = max(total_mem - _reserve_bytes, 0)
+        mem_per_worker = usable_mem / workers_per_gpu
+        fraction = mem_per_worker / total_mem
+        fraction = max(min(fraction, 1.0), 0.0)
+        torch.cuda.set_per_process_memory_fraction(fraction)
+
+    # Shared state for collecting benchmark results across this session
+    config._benchmark_results = []
+    config._benchmark_results_lock = threading.Lock()
+
+    # Disable warnings during benchmark setting
+    if config.getoption('--run-benchmark', default=None):
+        config.option.disable_warnings = True
+
+
+def pytest_collection_modifyitems(config, items):
+    if not config.getoption('--run-benchmark'):
+        # Without --run-benchmark, skip all benchmark tests
+        skip_bench = pytest.mark.skip(reason='need --run-benchmark to run')
+        for item in items:
+            if 'benchmark' in item.keywords:
+                item.add_marker(skip_bench)
+    # With --run-benchmark, benchmark tests run alongside correctness tests
+    # (e.g. `pytest kernel.py --run-benchmark`).
+    # Use `-m benchmark` explicitly if you want ONLY benchmarks.
+
+
+
+# ---------------------------------------------------------------------------
+# Regression detection & exit code
+# ---------------------------------------------------------------------------
+
+
+def _detect_regressions(config):
+    """Check benchmark results against baselines and return regressions.
+
+    Returns:
+        A tuple ``(results, baselines, regressions, improvements, missing)``
+        or ``None`` if no results were collected.
+    """
+    results = getattr(config, '_benchmark_results', [])
+    if not results:
+        output_path = config.getoption('--benchmark-output', default=None)
+        if output_path and os.path.exists(output_path):
+            with open(output_path) as f:
+                results = [json.loads(line) for line in f if line.strip()]
+        return None
+
+    threshold = config.getoption('--benchmark-regression-threshold')
+    baselines = _load_baselines()
+
+    regressions = []
+    improvements = []
+    missing = []
+
+    for rec in results:
+        key = _make_key(rec)
+        if key not in baselines:
+            missing.append((key, rec['time_us']))
+            continue
+        baseline_us = baselines[key]['time_us']
+        current_us = rec['time_us']
+        ratio = current_us / baseline_us
+        if ratio > 1.0 + threshold:
+            regressions.append((key, baseline_us, current_us, ratio))
+        elif ratio < 1.0 - threshold:
+            improvements.append((key, baseline_us, current_us, ratio))
+
+    return results, baselines, regressions, improvements, missing
+
+
+def pytest_sessionfinish(session, exitstatus):
+    """Set non-zero exit code when benchmark regressions are detected.
+
+    Runs before ``pytest_terminal_summary``, so regression detection is
+    performed here and stashed on ``config`` for the terminal report.
+    """
+    result = _detect_regressions(session.config)
+    if result is None:
+        return
+    results, baselines, regressions, improvements, missing = result
+    # Stash for pytest_terminal_summary
+    session.config._benchmark_detection = result
+    if (regressions or missing) and exitstatus == 0:
+        session.exitstatus = 1
+
+
+# ---------------------------------------------------------------------------
+# Terminal summary: regression report
+# ---------------------------------------------------------------------------
+
+def pytest_terminal_summary(terminalreporter, config):
+    """Print a benchmark regression report at the end of the pytest session."""
+    # Use pre-computed results from pytest_sessionfinish if available,
+    # otherwise compute now
+    detection = getattr(config, '_benchmark_detection', None)
+    if detection is None:
+        detection = _detect_regressions(config)
+    if detection is None:
+        # No benchmark results — nothing to report
+        return
+
+    results, baselines, regressions, improvements, missing = detection
+    threshold = config.getoption('--benchmark-regression-threshold')
+    verbose = config.getoption('--benchmark-verbose')
+
+    tr = terminalreporter
+    tr.section('Benchmark Regression Report')
+
+    if baselines:
+        # Collect extras column names when verbose
+        extras_keys = []
+        if verbose:
+            extras_keys = _collect_extras_keys(results, baselines)
+
+        # Compute dynamic Kernel column width
+        matched_keys = [
+            _make_key(r) for r in results if _make_key(r) in baselines
+        ]
+        kw = max((len(k) for k in matched_keys), default=20) + 2
+
+        # Extras column widths: fit header label or widest value
+        ek_widths = {}
+        for ek in extras_keys:
+            cur_label = ek + '(cur)'
+            ref_label = ek + '(ref)'
+            w = max(len(cur_label), len(ref_label), 8)
+            for rec in results:
+                rk = _make_key(rec)
+                if rk not in baselines:
+                    continue
+                for src in (rec, baselines[rk]):
+                    v = (src.get('extras') or {}).get(ek)
+                    w = max(w, len(_fmt_extra(v)))
+            ek_widths[ek] = w
+
+        # Header
+        hdr = (
+            f"{'Kernel':<{kw}} {'Latency':>11} {'Bandwidth':>11} {'Ratio':>8} {'Stat':>4}"
+        )
+        for ek in extras_keys:
+            w = ek_widths[ek]
+            hdr += f"  {(ek + '(cur)'):>{w}}  {(ek + '(ref)'):>{w}}"
+        tr.write_line(hdr)
+        tr.write_line('-' * len(hdr))
+
+        for rec in results:
+            key = _make_key(rec)
+            if key not in baselines:
+                continue
+            baseline_rec = baselines[key]
+            baseline_us = baseline_rec['time_us']
+            current_us = rec['time_us']
+            ratio = current_us / baseline_us
+            if ratio > 1.0 + threshold:
+                status = '--'
+            elif ratio < 1.0 - threshold:
+                status = '++'
+            else:
+                status = '='
+            cur_bw = rec['bandwidth_gbs']
+            line = (
+                f'{key:<{kw}} {current_us:>8.1f} us {_fmt_bw(cur_bw):>11} '
+                f'{ratio:>7.2f}x {status:>4}'
+            )
+            for ek in extras_keys:
+                w = ek_widths[ek]
+                cur_v = (rec.get('extras') or {}).get(ek)
+                ref_v = (baseline_rec.get('extras') or {}).get(ek)
+                line += f'  {_fmt_extra(cur_v):>{w}}  {_fmt_extra(ref_v):>{w}}'
+            tr.write_line(line)
+    else:
+        tr.write_line('No baseline file found — skipping regression comparison.')
+        tr.write_line(f'  (looked at: {_BASELINES_PATH})')
+
+    # New benchmarks without baselines
+    if missing:
+        new_recs = [r for r in results if _make_key(r) not in baselines]
+        tr.write_line('')
+
+        # Dynamic column widths
+        new_keys = [_make_key(r) for r in new_recs]
+        nkw = max((len(k) for k in new_keys), default=20) + 2
+
+        # Bandwidth column width for new-benchmarks table
+        new_bw_col_w = 9
+        for r in new_recs:
+            v = r.get('bandwidth_gbs', None)
+            new_bw_col_w = max(new_bw_col_w, len(_fmt_bw(v)))
+
+        new_extras_keys = []
+        new_ek_widths = {}
+        if verbose:
+            ek_set = set()
+            for r in new_recs:
+                ek_set.update((r.get('extras') or {}).keys())
+            new_extras_keys = sorted(ek_set)
+            for ek in new_extras_keys:
+                w = len(ek)
+                for r in new_recs:
+                    v = (r.get('extras') or {}).get(ek)
+                    w = max(w, len(_fmt_extra(v)))
+                new_ek_widths[ek] = max(w, 8)
+
+        # Header
+        nhdr = f"{'Kernel':<{nkw}} {'Current':>11}  {'Bandwidth':>{new_bw_col_w}}"
+        for ek in new_extras_keys:
+            nhdr += f'  {ek:>{new_ek_widths[ek]}}'
+        tr.write_line(nhdr)
+        tr.write_line('-' * len(nhdr))
+
+        for r in new_recs:
+            key = _make_key(r)
+            bw = r.get('bandwidth_gbs', None)
+            line = f"{key:<{nkw}} {r['time_us']:>8.1f} us  {_fmt_bw(bw):>{new_bw_col_w}}"
+            for ek in new_extras_keys:
+                w = new_ek_widths[ek]
+                v = (r.get('extras') or {}).get(ek)
+                line += f'  {_fmt_extra(v):>{w}}'
+            tr.write_line(line)
+
+    # Summary
+    matched = sum(1 for r in results if baselines and _make_key(r) in baselines)
+    tr.write_line('')
+    tr.write_line(
+        f'Total: {len(results)} benchmarks, {matched} with baselines, '
+        f'{len(missing)} missing, '
+        f'{len(regressions)} regressions, {len(improvements)} improvements '
+        f'(threshold: {threshold:.0%})'
+    )
+
+    if regressions:
+        tr.write_line('')
+        tr.write_line('!! REGRESSIONS DETECTED !!')
+        for key, baseline_us, current_us, ratio in regressions:
+            tr.write_line(
+                f'  {key}: {current_us:.1f} us vs baseline {baseline_us:.1f} us '
+                f'({ratio:.2f}x slower)'
+            )
+
+
+
+def _fmt_extra(v):
+    """Format an extras value for display."""
+    if v is None:
+        return '-'
+    if isinstance(v, float):
+        return f'{v:.2f}'
+    return str(v)
+
+
+def _fmt_bw(v):
+    """Format a bandwidth_gbs value for display (e.g. '1234.56 GB/s')."""
+    if v is None:
+        return '-'
+    return f'{v:6.1f} GB/s'
+
+
+def _collect_extras_keys(results, baselines):
+    """Return a sorted list of extras keys across results and baselines,
+    excluding bandwidth_gbs (reported as a dedicated column)."""
+    keys = set()
+    for rec in results:
+        key = _make_key(rec)
+        if key not in baselines:
+            continue
+        for e in (rec.get('extras') or {}, (baselines[key].get('extras') or {})):
+            keys.update(e.keys())
+    return sorted(keys)
+
+
+# ---------------------------------------------------------------------------
+# Fixtures
+# ---------------------------------------------------------------------------
+
+# Lock for concurrent JSONL writes from xdist workers
+_jsonl_write_lock = threading.Lock()
+
+
+@pytest.fixture
+def benchmark_record(request):
+    """Record a benchmark result for regression tracking.
+
+    Prints a human-readable summary, appends a JSONL record to
+    ``--benchmark-output`` (if given), collects the result for the terminal
+    regression report, and emits a pytest warning on regressions.
+
+    JSONL schema::
+
+        {
+            "kernel":         str,
+            "operation":      str,
+            "params":         dict,
+            "time_us":        float,
+            "bandwidth_gbs":  float | None,
+            "extras":         dict | None,
+        }
+    """
+    output_path = request.config.getoption('--benchmark-output')
+
+    def _record(*, kernel, operation, params, time_us, bandwidth_gbs=None, extras=None):
+        # Build a unique key: kernel/operation[k1=v1,k2=v2]
+        # Keys are sorted for deterministic ordering
+        if params:
+            param_str = make_param_key(params)
+            key = f'{kernel}/{operation}[{param_str}]'
+        else:
+            key = f'{kernel}/{operation}'
+
+        # Human-readable print
+        parts = [f'  BENCH {key}: {time_us:.1f} us']
+        if bandwidth_gbs is not None:
+            parts.append(f', bandwidth_gbs={bandwidth_gbs:.2f}')
+        if extras:
+            for ek, ev in extras.items():
+                if isinstance(ev, float):
+                    parts.append(f', {ek}={ev:.2f}')
+                else:
+                    parts.append(f', {ek}={ev}')
+        print(''.join(parts))
+
+        # Write JSONL
+        record = {
+            'kernel': kernel,
+            'operation': operation,
+            'params': dict(sorted(params.items())) if params else params,
+            'time_us': round(time_us, 2),
+        }
+        if bandwidth_gbs is not None:
+            record['bandwidth_gbs'] = round(bandwidth_gbs, 4)
+        if extras:
+            record['extras'] = {
+                k: round(v, 4) if isinstance(v, float) else v
+                for k, v in extras.items()
+            }
+        if output_path:
+            line = json.dumps(record, ensure_ascii=False)
+            with _jsonl_write_lock:
+                with open(output_path, 'a') as f:
+                    f.write(line + '\n')
+
+        # Collect for terminal summary
+        with request.config._benchmark_results_lock:
+            request.config._benchmark_results.append(record)
+
+
+    return _record
+
+
+@pytest.fixture
+def benchmark_timer():
+    """Return a callable that measures kernel execution time in microseconds.
+
+    Wraps ``tilelang.profiler.bench.do_bench`` with CUPTI backend by default.
+    Keyword arguments are forwarded to ``do_bench``, allowing per-test
+    overrides (e.g. ``benchmark_timer(fn, rep=30)``).
+
+    Returns:
+        A callable ``(fn, **overrides) -> float`` returning time in
+        microseconds.
+    """
+    from tilelang.profiler.bench import do_bench
+
+    def _timer(fn, **overrides):
+        kwargs = dict(backend='cupti', warmup=0, rep=30)
+        kwargs.update(overrides)
+        return do_bench(fn, **kwargs) * 1e3  # ms → us
+
+    return _timer
+
+
+def _make_key(rec):
+    """Build a baseline-compatible key from a benchmark record."""
+    kernel, operation = rec['kernel'], rec['operation']
+    params = rec.get('params')
+    if params:
+        param_str = make_param_key(params)
+        return f'{kernel}/{operation}[{param_str}]'
+    return f'{kernel}/{operation}'
+
+
+def _load_baselines():
+    """Load the baseline JSONL file into a ``{key: record}`` dict.
+
+    Returns ``None`` if the file does not exist.
+    """
+    if not os.path.exists(_BASELINES_PATH):
+        return {}
+    baselines = {}
+    with open(_BASELINES_PATH) as f:
+        for line in f:
+            line = line.strip()
+            if not line:
+                continue
+            rec = json.loads(line)
+            baselines[_make_key(rec)] = rec
+    return baselines
+
+

tile_kernels_src/tests/pytest_random_plugin.py

@@ -0,0 +1,18 @@
+import hashlib
+
+import pytest
+import torch
+
+
+def pytest_addoption(parser):
+    parser.addoption('--seed', type=int, default=0)
+
+@pytest.fixture(autouse=True)
+def seed(request):
+    base = request.config.getoption('--seed')
+    node_hash = int(hashlib.sha256(
+        request.node.nodeid.encode()
+    ).hexdigest(), 16) % (2**31)
+    seed = base + node_hash
+    torch.manual_seed(seed)
+    return seed

tile_kernels_src/tests/quant/test_cast_back.py

@@ -0,0 +1,157 @@
+import os
+import pytest
+import torch
+
+import tile_kernels
+from tile_kernels.testing.bench import dtype_to_str, make_param_id
+from tile_kernels.testing.generator import generate_hidden_sizes, generate_num_tokens
+from tile_kernels.testing.numeric import assert_equal, calc_diff, count_bytes
+
+# Disable TileLang prints
+os.environ['TILELANG_PRINT_ON_COMPILATION'] = '0'
+
+
+def generate_test_data_per_token(params):
+    num_tokens = params['num_tokens']
+    hidden = params['hidden']
+    fmt = params['fmt']
+    use_tma_aligned_col_major_sf = params['use_tma_aligned_col_major_sf']
+    round_sf = params['round_sf']
+    use_packed_ue8m0 = params['use_packed_ue8m0']
+    num_per_channels = params['num_per_channels']
+    out_dtype = params['out_dtype']
+
+    x = torch.randn((num_tokens, hidden), dtype=out_dtype, device='cuda')
+    x_fp8, x_sf = tile_kernels.quant.per_token_cast(
+        x, fmt, num_per_channels=num_per_channels,
+        use_tma_aligned_col_major_sf=use_tma_aligned_col_major_sf,
+        round_sf=round_sf,
+        use_packed_ue8m0=use_packed_ue8m0,
+    )
+    out_dtype_str = dtype_to_str(out_dtype)
+    func = lambda: tile_kernels.quant.per_token_cast_back((x_fp8, x_sf), out_dtype_str, num_per_channels=num_per_channels)
+
+    return (x, x_fp8, x_sf, out_dtype_str, func)
+
+
+def generate_test_data(params):
+    num_tokens = params['num_tokens']
+    hidden = params['hidden']
+    round_sf = params['round_sf']
+    fmt = params['fmt']
+    out_dtype = params['out_dtype']
+    num_per_tokens = params['num_per_tokens']
+    num_per_channels = params['num_per_channels']
+
+    x = torch.randn((num_tokens, hidden), dtype=out_dtype, device='cuda')
+    x_casted, x_sf = tile_kernels.torch.cast(x, fmt, (num_per_tokens, num_per_channels), round_sf=round_sf)
+    out_dtype_str = dtype_to_str(out_dtype)
+    func = lambda: tile_kernels.quant.cast_back(
+        (x_casted, x_sf), out_dtype_str, (num_per_tokens, num_per_channels)
+    )
+
+    return (x, x_casted, x_sf, out_dtype_str, func)
+
+
+def generate_test_params_per_token(is_benchmark: bool) -> list[dict]:
+    return [
+        {
+            'num_tokens': num_tokens,
+            'hidden': hidden_size,
+            'fmt': fmt,
+            'use_tma_aligned_col_major_sf': use_tma_aligned_col_major_sf,
+            'round_sf': round_sf,
+            'use_packed_ue8m0': use_packed_ue8m0,
+            'num_per_channels': num_per_channels,
+            'out_dtype': out_dtype,
+        }
+        for num_tokens in generate_num_tokens(is_benchmark=is_benchmark)
+        for hidden_size in generate_hidden_sizes()
+        for fmt in ('e2m1', 'e4m3')
+        for use_tma_aligned_col_major_sf, round_sf, use_packed_ue8m0 in [(False, True, False), (True, True, True)]
+        for num_per_channels in (128, hidden_size)
+        for out_dtype in (torch.float32, torch.bfloat16)
+    ]
+
+
+def generate_test_params(is_benchmark: bool) -> list[dict]:
+    return [
+        {
+            'num_tokens': num_tokens,
+            'hidden': hidden_size,
+            'round_sf': round_sf,
+            'fmt': fmt,
+            'out_dtype': out_dtype,
+            'num_per_tokens': num_per_tokens,
+            'num_per_channels': num_per_channels,
+        }
+        for num_tokens in generate_num_tokens(is_benchmark=is_benchmark)
+        for hidden_size in generate_hidden_sizes()
+        for round_sf in (False, True)
+        for fmt in ('e4m3',)
+        for out_dtype in (torch.bfloat16, torch.float32)
+        for num_per_tokens, num_per_channels in ((128, 1), (128, 128))
+    ]
+
+
+@pytest.mark.parametrize('params', generate_test_params_per_token(is_benchmark=False), ids=make_param_id)
+def test_cast_back_per_token(params):
+    hidden = params['hidden']
+    fmt = params['fmt']
+    num_per_channels = params['num_per_channels']
+
+    # Test correctness
+    x, x_fp8, x_sf, out_dtype_str, func = generate_test_data_per_token(params)
+    x_fp8_bf16 = func()
+    x_fp8_bf16_ref = tile_kernels.torch.cast_back((x_fp8, x_sf), out_dtype_str, (1, num_per_channels))
+
+    diff = calc_diff(x, x_fp8_bf16)
+    assert diff < (2e-2 if fmt == 'e2m1' else 1e-3), f'{x}, {x_fp8_bf16}, {fmt=}, {hidden=}, {num_per_channels=}, {diff=}'
+
+    assert_equal(x_fp8_bf16, x_fp8_bf16_ref)
+
+
+@pytest.mark.benchmark
+@pytest.mark.parametrize('params', generate_test_params_per_token(is_benchmark=True), ids=make_param_id)
+def test_cast_back_per_token_benchmark(benchmark_timer, benchmark_record, params):
+    x, x_fp8, x_sf, out_dtype_str, func = generate_test_data_per_token(params)
+
+    t_us = benchmark_timer(func)
+    num_bytes = count_bytes(x, x_fp8, x_sf)
+
+    benchmark_record(
+        kernel='cast_back_per_token',
+        operation='fwd',
+        params={**params, 'out_dtype': out_dtype_str},
+        time_us=t_us,
+        bandwidth_gbs=num_bytes / t_us / 1e3,
+    )
+
+
+@pytest.mark.parametrize('params', generate_test_params(is_benchmark=False), ids=make_param_id)
+def test_cast_back(params):
+    num_per_tokens = params['num_per_tokens']
+    num_per_channels = params['num_per_channels']
+
+    _, x_casted, x_sf, out_dtype_str, func = generate_test_data(params)
+    x_casted_back = func()
+    x_casted_back_ref = tile_kernels.torch.cast_back((x_casted, x_sf), out_dtype_str, (num_per_tokens, num_per_channels))
+
+    assert_equal(x_casted_back, x_casted_back_ref)
+
+
+@pytest.mark.benchmark
+@pytest.mark.parametrize('params', generate_test_params(is_benchmark=True), ids=make_param_id)
+def test_cast_back_benchmark(benchmark_timer, benchmark_record, params):
+    x, x_casted, x_sf, out_dtype_str, func = generate_test_data(params)
+
+    t_us = benchmark_timer(func)
+    num_bytes = count_bytes(x, x_casted, x_sf)
+
+    benchmark_record(
+        kernel='cast_back',
+        operation='fwd',
+        params={**params, 'out_dtype': out_dtype_str},
+        time_us=t_us,
+        bandwidth_gbs=num_bytes / t_us / 1e3,
+    )

tile_kernels_src/tests/quant/test_cast_back_e5m6.py

@@ -0,0 +1,120 @@
+import os
+import pytest
+import torch
+
+import tile_kernels
+from tile_kernels.testing.bench import dtype_to_str, make_param_id
+from tile_kernels.testing.generator import generate_hidden_sizes, generate_num_tokens, generate_e5m6_inputs
+from tile_kernels.testing.numeric import assert_equal, calc_diff, count_bytes
+from tile_kernels.torch import cast_back_from_e5m6
+
+# Disable TileLang prints
+os.environ['TILELANG_PRINT_ON_COMPILATION'] = '0'
+
+
+def generate_test_data(params):
+    x = params['x']
+    hidden = params['hidden']
+    num_per_channels = params['num_per_channels']
+    use_tma_aligned_col_major_sf = params['use_tma_aligned_col_major_sf']
+    round_sf = params['round_sf']
+    use_packed_ue8m0 = params['use_packed_ue8m0']
+    out_dtype = params['out_dtype']
+
+    x_e5m6, x_sf = tile_kernels.quant.per_token_cast(
+        x, 'e5m6', num_per_channels=num_per_channels,
+        use_tma_aligned_col_major_sf=use_tma_aligned_col_major_sf,
+        round_sf=round_sf,
+        use_packed_ue8m0=use_packed_ue8m0,
+    )
+    out_dtype_str = dtype_to_str(out_dtype)
+    func = lambda: tile_kernels.quant.cast_back((x_e5m6, x_sf), out_dtype_str, (1, hidden), x_special_fmt='e5m6')
+    torch_ref_func = lambda: cast_back_from_e5m6((x_e5m6, x_sf), out_dtype_str, (1, hidden))
+
+    return (x_e5m6, x_sf, out_dtype_str, func, torch_ref_func)
+
+
+def generate_test_params(is_benchmark: bool) -> list[dict]:
+    return [
+        {
+            'num_tokens': num_tokens,
+            'hidden': hidden_size,
+            'num_per_channels': num_per_channels,
+            'use_tma_aligned_col_major_sf': use_tma_aligned_col_major_sf,
+            'round_sf': round_sf,
+            'use_packed_ue8m0': use_packed_ue8m0,
+            'out_dtype': out_dtype,
+        }
+        for num_tokens in generate_num_tokens(is_benchmark=is_benchmark)
+        for hidden_size in generate_hidden_sizes()
+        for num_per_channels in (hidden_size, )
+        for use_tma_aligned_col_major_sf, round_sf, use_packed_ue8m0 in [(False, True, False), (True, True, True)]
+        for out_dtype in (torch.bfloat16, torch.float32)
+    ]
+
+
+@pytest.mark.parametrize('params', generate_test_params(is_benchmark=False), ids=make_param_id)
+def test_cast_back_e5m6(params):
+    num_tokens = params['num_tokens']
+    hidden = params['hidden']
+    use_tma_aligned_col_major_sf = params['use_tma_aligned_col_major_sf']
+    round_sf = params['round_sf']
+    use_packed_ue8m0 = params['use_packed_ue8m0']
+    out_dtype = params['out_dtype']
+    num_per_channels = params['num_per_channels']
+
+    for x, is_special in generate_e5m6_inputs(num_tokens, hidden, out_dtype):
+        x_e5m6, x_sf, out_dtype_str, func, torch_ref_func = generate_test_data({
+            'x': x,
+            'hidden': hidden,
+            'num_per_channels': num_per_channels,
+            'use_tma_aligned_col_major_sf': use_tma_aligned_col_major_sf,
+            'round_sf': round_sf,
+            'use_packed_ue8m0': use_packed_ue8m0,
+            'out_dtype': out_dtype,
+        })
+        x_back = func()
+
+        # Check accuracy vs original input
+        diff = calc_diff(x, x_back)
+        threshold = 5e-6 if is_special else 1e-4
+        assert diff < threshold, f'{hidden=}, {round_sf=}, {out_dtype_str=}, {diff=}'
+
+        # Check against torch/cast reference (always runs)
+        x_back_ref = torch_ref_func()
+        assert_equal(x_back, x_back_ref)
+
+
+@pytest.mark.benchmark
+@pytest.mark.parametrize('params', generate_test_params(is_benchmark=True), ids=make_param_id)
+def test_cast_back_e5m6_benchmark(benchmark_timer, benchmark_record, params):
+    hidden = params['hidden']
+    use_tma_aligned_col_major_sf = params['use_tma_aligned_col_major_sf']
+    out_dtype = params['out_dtype']
+
+    num_per_channels = hidden
+    for x, is_special in generate_e5m6_inputs(params['num_tokens'], hidden, out_dtype):
+        if is_special:
+            continue
+
+        x_e5m6, x_sf, out_dtype_str, func, torch_ref_func = generate_test_data({
+            'x': x,
+            'hidden': hidden,
+            'num_per_channels': num_per_channels,
+            'use_tma_aligned_col_major_sf': use_tma_aligned_col_major_sf,
+            'round_sf': params['round_sf'],
+            'use_packed_ue8m0': params['use_packed_ue8m0'],
+            'out_dtype': out_dtype,
+        })
+        x_back = func()
+
+        t_us = benchmark_timer(func)
+        num_bytes = count_bytes(x_e5m6, x_sf, x_back)
+
+        benchmark_record(
+            kernel='cast_back_e5m6',
+            operation='fwd',
+            params={**params, 'num_per_channels': num_per_channels, 'out_dtype': out_dtype_str},
+            time_us=t_us,
+            bandwidth_gbs=num_bytes / t_us / 1e3,
+        )

tile_kernels_src/tests/quant/test_per_block_cast.py

@@ -0,0 +1,110 @@
+import os
+import pytest
+import torch
+
+import tile_kernels
+from tile_kernels.testing.bench import dtype_to_str, make_param_id
+from tile_kernels.testing.numeric import assert_equal, count_bytes, check_bias
+from tile_kernels.testing.generator import generate_hidden_sizes, generate_num_tokens
+from tile_kernels.testing.quant import clear_unused_sf
+
+# Disable TileLang prints
+os.environ['TILELANG_PRINT_ON_COMPILATION'] = '0'
+
+
+def generate_test_data(params):
+    num_tokens = params['num_tokens']
+    hidden = params['hidden']
+    in_dtype = params['in_dtype']
+    fmt = params['fmt']
+    block_size = params['block_size']
+    use_tma_aligned_col_major_sf = params['use_tma_aligned_col_major_sf']
+    round_sf = params['round_sf']
+    use_packed_ue8m0 = params['use_packed_ue8m0']
+
+    x = torch.randn((num_tokens, hidden), dtype=in_dtype, device='cuda')
+    base_args = dict(
+        x=x, fmt=fmt, block_size=block_size,
+        use_tma_aligned_col_major_sf=use_tma_aligned_col_major_sf,
+        round_sf=round_sf,
+        use_packed_ue8m0=use_packed_ue8m0,
+    )
+
+    return (x, base_args)
+
+
+def generate_test_params(is_benchmark: bool) -> list[dict]:
+    return [
+        {
+            'num_tokens': num_tokens,
+            'hidden': hidden_size,
+            'in_dtype': in_dtype,
+            'fmt': fmt,
+            'use_tma_aligned_col_major_sf': use_tma_aligned_col_major_sf,
+            'round_sf': round_sf,
+            'use_packed_ue8m0': use_packed_ue8m0,
+            'block_size': block_size,
+        }
+        for num_tokens in generate_num_tokens(is_benchmark=is_benchmark)
+        for hidden_size in generate_hidden_sizes()
+        for in_dtype in (torch.bfloat16, torch.float32)
+        for fmt in ('e4m3', 'e2m1')
+        for use_tma_aligned_col_major_sf, round_sf, use_packed_ue8m0 in [(False, True, False), (True, True, True)]
+        for block_size in ((128, 128), (32, 32))
+    ]
+
+
+@pytest.mark.parametrize('params', generate_test_params(is_benchmark=False), ids=make_param_id)
+def test_per_block_cast(params):
+    hidden = params['hidden']
+    use_tma_aligned_col_major_sf = params['use_tma_aligned_col_major_sf']
+    use_packed_ue8m0 = params['use_packed_ue8m0']
+    block_size = params['block_size']
+
+    x, base_args = generate_test_data(params)
+
+    # Test cast
+    x_casted, per_block_sf_inv = tile_kernels.quant.per_block_cast(**base_args)
+    x_casted_ref, per_block_sf_inv_ref = tile_kernels.torch.cast(**base_args)
+    x_casted_back = tile_kernels.torch.cast_back((x_casted, per_block_sf_inv), 'fp32', block_size)
+    if use_packed_ue8m0:
+        per_block_sf_inv = clear_unused_sf(per_block_sf_inv, hidden, block_size[1])
+        per_block_sf_inv_ref = clear_unused_sf(per_block_sf_inv_ref, hidden, block_size[1])
+    assert_equal(per_block_sf_inv, per_block_sf_inv_ref)
+    assert_equal(x_casted, x_casted_ref)
+
+    # Check bias
+    check_bias(x_casted_back, x)
+
+    # Test cast only mode
+    if not use_tma_aligned_col_major_sf:
+        # TMA aligned or packed ue8m0 sf is used for FP8/FP4 GEMM, not for other cast
+        x_casted = tile_kernels.quant.per_block_cast_with_precomputed_sf(**base_args, sf=per_block_sf_inv)
+        x_casted_ref = tile_kernels.torch.cast(**base_args, sf=per_block_sf_inv)
+        assert_equal(x_casted, x_casted_ref)
+
+    # Test sf only mode
+    twice_per_block_sf_inv = tile_kernels.quant.per_block_cast_with_sf_only(**base_args)
+    if use_packed_ue8m0:
+        twice_per_block_sf_inv = clear_unused_sf(twice_per_block_sf_inv, hidden, block_size[1])
+    assert_equal(twice_per_block_sf_inv, per_block_sf_inv_ref)
+
+
+@pytest.mark.benchmark
+@pytest.mark.parametrize('params', generate_test_params(is_benchmark=True), ids=make_param_id)
+def test_per_block_cast_benchmark(benchmark_timer, benchmark_record, params):
+    x, args = generate_test_data(params)
+
+    x_casted, per_block_sf_inv = tile_kernels.quant.per_block_cast(**args)
+
+    t_us = benchmark_timer(lambda: tile_kernels.quant.per_block_cast(**args))
+    num_bytes = count_bytes(x, x_casted, per_block_sf_inv)
+
+    params['in_dtype'] = dtype_to_str(params['in_dtype'])
+    benchmark_record(
+        kernel='per_block_cast',
+        operation='fwd',
+        params=params,
+        time_us=t_us,
+        bandwidth_gbs=num_bytes / t_us / 1e3,
+    )

tile_kernels_src/tests/quant/test_per_block_cast_lossless.py

@@ -0,0 +1,114 @@
+import os
+import pytest
+import torch
+
+
+import tile_kernels
+from tile_kernels.testing.numeric import assert_equal, count_bytes
+from tile_kernels.testing.generator import generate_hidden_sizes, generate_num_tokens, generate_rand_float
+from tile_kernels.testing.bench import make_param_id
+
+# Disable TileLang prints
+os.environ['TILELANG_PRINT_ON_COMPILATION'] = '0'
+
+
+def clamp_abs_ratio(t: torch.Tensor, max_ratio: float = 2**9):
+    if t.numel() == 0:
+        return t
+    floor_val = t.abs().max() / max_ratio
+    t = torch.sign(t) * torch.max(t.abs(), floor_val)
+    return t
+
+
+def generate_test_data(params):
+    num_tokens = params['num_tokens']
+    hidden = params['hidden']
+    in_use_tma_aligned_col_major_sf = params['in_use_tma_aligned_col_major_sf']
+    in_round_sf = params['in_round_sf']
+    in_use_packed_ue8m0 = params['in_use_packed_ue8m0']
+    out_use_tma_aligned_col_major_sf = params['out_use_tma_aligned_col_major_sf']
+    out_round_sf = params['out_round_sf']
+    out_use_packed_ue8m0 = params['out_use_packed_ue8m0']
+    in_sf_block_m = params['in_sf_block'][0]
+    in_sf_block_k = params['in_sf_block'][1]
+    out_sf_block_m = params['out_sf_block'][0]
+    out_sf_block_k = params['out_sf_block'][1]
+
+    x = generate_rand_float((num_tokens, hidden))
+    x = clamp_abs_ratio(x)
+    x_fp4 = tile_kernels.torch.cast(
+        x, 'e2m1', (in_sf_block_m, in_sf_block_k),
+        use_tma_aligned_col_major_sf=in_use_tma_aligned_col_major_sf,
+        round_sf=in_round_sf,
+        use_packed_ue8m0=in_use_packed_ue8m0,
+    )
+    cast_func = lambda: tile_kernels.quant.per_block_cast_lossless(
+        x_fp4, 'e4m3',
+        x_block_size=(in_sf_block_m, in_sf_block_k),
+        out_block_size=(out_sf_block_m, out_sf_block_k),
+        use_tma_aligned_col_major_sf=out_use_tma_aligned_col_major_sf,
+        round_sf=out_round_sf,
+        use_packed_ue8m0=out_use_packed_ue8m0,
+    )
+
+    return (x, x_fp4, cast_func)
+
+
+def generate_test_params(is_benchmark: bool) -> list[dict]:
+    params = [
+        {
+            'num_tokens': num_tokens,
+            'hidden': hidden_size,
+            'in_use_tma_aligned_col_major_sf': in_use_tma_aligned_col_major_sf,
+            'in_round_sf': in_round_sf,
+            'in_use_packed_ue8m0': in_use_packed_ue8m0,
+            'out_use_tma_aligned_col_major_sf': out_use_tma_aligned_col_major_sf,
+            'out_round_sf': out_round_sf,
+            'out_use_packed_ue8m0': out_use_packed_ue8m0,
+            'out_sf_block': (out_sf_block_m, out_sf_block_k),
+            'in_sf_block': (in_sf_block_m, in_sf_block_k),
+        }
+        for num_tokens in generate_num_tokens(is_benchmark=is_benchmark)
+        for hidden_size in generate_hidden_sizes()
+        for in_use_tma_aligned_col_major_sf, in_round_sf, in_use_packed_ue8m0 in [(False, True, False), (True, True, True)]
+        for out_use_tma_aligned_col_major_sf, out_round_sf, out_use_packed_ue8m0 in [(False, True, False), (True, True, True)]
+        for out_sf_block_m, out_sf_block_k in ((1, 128), (32, 32), (128, 128))
+        for in_sf_block_m, in_sf_block_k in ((1, 32),)
+        if out_sf_block_m % in_sf_block_m == 0 and out_sf_block_k % in_sf_block_k == 0
+    ]
+    return params
+
+
+@pytest.mark.parametrize('params', generate_test_params(is_benchmark=False), ids=make_param_id)
+def test_per_block_cast_lossless(params):
+    out_sf_block = params['out_sf_block']
+    in_sf_block = params['in_sf_block']
+
+    out_sf_block_m, out_sf_block_k = out_sf_block
+    in_sf_block_m, in_sf_block_k = in_sf_block
+
+    # Test Correctness
+    _, x_fp4, cast_func = generate_test_data(params)
+    x_fp8 = cast_func()
+
+    x_fp8_fp32_ref = tile_kernels.torch.cast_back(x_fp4, 'fp32', (in_sf_block_m, in_sf_block_k))
+    x_fp8_fp32 = tile_kernels.torch.cast_back(x_fp8, 'fp32', (out_sf_block_m, out_sf_block_k))
+    assert_equal(x_fp8_fp32, x_fp8_fp32_ref)
+
+
+@pytest.mark.benchmark
+@pytest.mark.parametrize('params', generate_test_params(is_benchmark=True), ids=make_param_id)
+def test_per_block_cast_lossless_benchmark(benchmark_timer, benchmark_record, params):
+    _, x_fp4, cast_func = generate_test_data(params)
+
+    x_fp8 = cast_func()
+
+    t_us = benchmark_timer(cast_func)
+    num_bytes = count_bytes(x_fp4, x_fp8)
+    benchmark_record(
+        kernel='per_block_cast_lossless',
+        operation='fwd',
+        params=params,
+        time_us=t_us,
+        bandwidth_gbs=num_bytes / t_us / 1e3,
+    )

tile_kernels_src/tests/quant/test_per_channel_cast.py

@@ -0,0 +1,75 @@
+import os
+import pytest
+import torch
+
+import tile_kernels
+from tile_kernels.testing.bench import dtype_to_str, make_param_id
+from tile_kernels.testing.generator import generate_hidden_sizes, generate_num_tokens
+from tile_kernels.testing.numeric import assert_equal, count_bytes, check_bias
+
+# Disable TileLang prints
+os.environ['TILELANG_PRINT_ON_COMPILATION'] = '0'
+
+
+def generate_test_data(params):
+    num_tokens = params['num_tokens']
+    hidden = params['hidden']
+    dtype = params['dtype']
+    x = torch.randn((num_tokens, hidden), dtype=dtype, device='cuda')
+    return x
+
+
+def generate_test_params(is_benchmark: bool) -> list[dict]:
+    return [
+        {
+            'num_per_tokens': num_per_tokens,
+            'num_tokens': num_tokens,
+            'hidden': hidden_size,
+            'round_sf': round_sf,
+            'dtype': dtype,
+        }
+        for num_per_tokens in (128,)
+        for num_tokens in generate_num_tokens(128, is_benchmark=is_benchmark)
+        for hidden_size in generate_hidden_sizes()
+        for round_sf in (False, True)
+        for dtype in (torch.bfloat16,)
+    ]
+
+
+@pytest.mark.parametrize('params', generate_test_params(is_benchmark=False), ids=make_param_id)
+def test_per_channel_cast(params):
+    num_per_tokens = params['num_per_tokens']
+    round_sf = params['round_sf']
+
+    x = generate_test_data(params)
+    x_fp8, per_channel_sf_inv = tile_kernels.quant.per_channel_cast(x, 'e4m3', num_per_tokens, round_sf)
+    x_fp8_ref, per_channel_sf_inv_ref = tile_kernels.torch.cast(x, 'e4m3', block_size=(num_per_tokens, 1), round_sf=round_sf)
+
+    assert_equal(x_fp8, x_fp8_ref)
+    assert_equal(per_channel_sf_inv, per_channel_sf_inv_ref)
+
+    # Check bias
+    x_casted_back = tile_kernels.torch.cast_back((x_fp8_ref, per_channel_sf_inv_ref), 'fp32', (num_per_tokens, 1))
+    check_bias(x_casted_back, x)
+
+
+@pytest.mark.benchmark
+@pytest.mark.parametrize('params', generate_test_params(is_benchmark=True), ids=make_param_id)
+def test_per_channel_cast_benchmark(benchmark_timer, benchmark_record, params):
+    num_per_tokens = params['num_per_tokens']
+    round_sf = params['round_sf']
+    dtype = params['dtype']
+
+    x = generate_test_data(params)
+    x_fp8, per_channel_sf_inv = tile_kernels.quant.per_channel_cast(x, 'e4m3', num_per_tokens, round_sf)
+
+    t_us = benchmark_timer(lambda: tile_kernels.quant.per_channel_cast(x, 'e4m3', num_per_tokens, round_sf))
+    num_bytes = count_bytes(x, x_fp8, per_channel_sf_inv)
+
+    benchmark_record(
+        kernel='per_channel_cast',
+        operation='fwd',
+        params={**params, 'dtype': dtype_to_str(dtype)},
+        time_us=t_us,
+        bandwidth_gbs=num_bytes / t_us / 1e3,
+    )

tile_kernels_src/tests/quant/test_per_channel_cast_and_transpose.py

@@ -0,0 +1,77 @@
+import os
+import pytest
+import torch
+
+import tile_kernels
+from tile_kernels.testing.bench import dtype_to_str, make_param_id
+from tile_kernels.testing.generator import generate_hidden_sizes, generate_num_tokens
+from tile_kernels.testing.numeric import assert_equal, count_bytes
+
+# Disable TileLang prints
+os.environ['TILELANG_PRINT_ON_COMPILATION'] = '0'
+
+
+def generate_test_data(params):
+    num_tokens = params['num_tokens']
+    hidden = params['hidden']
+    dtype = params['dtype']
+
+    x = torch.randn((num_tokens, hidden), dtype=dtype, device='cuda')
+
+    return x
+
+
+def generate_test_params(is_benchmark: bool) -> list[dict]:
+    return [
+        {
+            'num_tokens': num_tokens,
+            'hidden': hidden_size,
+            'round_sf': round_sf,
+            'dtype': dtype,
+            'num_per_channels': num_per_channels,
+        }
+        for num_tokens in generate_num_tokens(128, is_benchmark=is_benchmark)
+        for hidden_size in generate_hidden_sizes()
+        for round_sf in (True, False)
+        for dtype in (torch.bfloat16,)
+        for num_per_channels in (32, 128)
+    ]
+
+
+@pytest.mark.parametrize('params', generate_test_params(is_benchmark=False), ids=make_param_id)
+def test_per_channel_cast_and_transpose(params):
+    round_sf = params['round_sf']
+    num_per_channels = params['num_per_channels']
+
+    x = generate_test_data(params)
+
+    x_fp8, x_sf = tile_kernels.quant.per_channel_cast_and_transpose(x, 'e4m3', num_per_channels, round_sf)
+    x_fp8_ref, x_sf_ref = tile_kernels.torch.cast(x, 'e4m3', block_size=(num_per_channels, 1), round_sf=round_sf)
+    x_fp8_ref = x_fp8_ref.T.contiguous()
+    assert_equal(x_fp8, x_fp8_ref)
+    assert_equal(x_sf, x_sf_ref)
+
+
+@pytest.mark.benchmark
+@pytest.mark.parametrize('params', generate_test_params(is_benchmark=True), ids=make_param_id)
+def test_per_channel_cast_and_transpose_benchmark(benchmark_timer, benchmark_record, params):
+    round_sf = params['round_sf']
+    num_per_channels = params['num_per_channels']
+
+    x = generate_test_data(params)
+
+    x_fp8, x_sf = tile_kernels.quant.per_channel_cast_and_transpose(x, 'e4m3', num_per_channels, round_sf)
+    num_bytes = count_bytes(x, x_fp8, x_sf)
+
+    t_us = benchmark_timer(
+        lambda: tile_kernels.quant.per_channel_cast_and_transpose(x, 'e4m3', num_per_channels, round_sf)
+    )
+
+    params['dtype'] = dtype_to_str(x.dtype)
+    benchmark_record(
+        kernel='per_channel_cast_and_transpose',
+        operation='fwd',
+        params=params,
+        time_us=t_us,
+        bandwidth_gbs=num_bytes / t_us / 1e3,
+    )

tile_kernels_src/tests/quant/test_per_channel_cast_fused.py

@@ -0,0 +1,104 @@
+import itertools
+import os
+import pytest
+import torch
+
+import tile_kernels
+from tile_kernels.testing.generator import generate_topk_idx, generate_hidden_sizes, generate_moe_params
+from tile_kernels.testing.numeric import assert_equal, count_bytes
+from tile_kernels.testing.bench import make_param_id
+from tile_kernels.torch.per_channel_cast_fused import per_channel_cast_fused as torch_ref_per_channel_cast_fused
+
+# Disable TileLang prints
+os.environ['TILELANG_PRINT_ON_COMPILATION'] = '0'
+
+
+def generate_test_data(params):
+    num_send_tokens = params['num_send_tokens']
+    num_topk = params['num_topk']
+    num_experts = params['num_experts']
+    hidden = params['hidden']
+    num_per_tokens = params['num_per_tokens']
+    num_per_channels = params['num_per_channels']
+    is_fused_cast_back = params['is_fused_cast_back']
+    round_sf = params['round_sf']
+
+    pos_to_token = None
+    if num_topk > 0:
+        topk_idx = generate_topk_idx(params)
+        num_tokens = topk_idx.shape[0]
+        _, pos_to_token, _, token_topk_to_pos, _, _, _, _ = (
+            tile_kernels.moe.get_fused_mapping(topk_idx, num_experts, 0, 128)
+        )
+        x = torch.randn((num_tokens, hidden), dtype=torch.bfloat16, device='cuda')
+        x = tile_kernels.moe.expand_to_fused(x, token_topk_to_pos, pos_to_token)
+    else:
+        num_tokens = num_send_tokens
+        x = torch.randn((num_tokens, hidden), dtype=torch.bfloat16, device='cuda')
+
+    if is_fused_cast_back:
+        x = tile_kernels.quant.per_token_cast(x, 'e4m3', num_per_channels)
+
+    func = lambda: tile_kernels.quant.per_channel_cast_fused(
+        x, 'e4m3', num_per_tokens=num_per_tokens, round_sf=round_sf,
+        num_per_channels=num_per_channels if is_fused_cast_back else None,
+        pos_to_token=pos_to_token,
+    )
+    func_ref = lambda: torch_ref_per_channel_cast_fused(x, num_per_tokens, num_per_channels, round_sf, pos_to_token)
+
+    return (x, num_tokens, pos_to_token, func, func_ref)
+
+
+def generate_test_params(is_benchmark: bool) -> list[dict]:
+    params = [
+        {
+            **moe,
+            'hidden': hidden_size,
+            'num_per_tokens': num_per_tokens,
+            'num_per_channels': num_per_channels,
+            'is_fused_cast_back': is_fused_cast_back,
+            'round_sf': round_sf,
+        }
+        for moe in itertools.chain(
+            iter([{'num_send_tokens': 4096, 'num_topk': 0, 'num_experts': 0, 'num_ep_ranks': 0}]),
+            generate_moe_params(),
+        )
+        for hidden_size in generate_hidden_sizes(128)
+        for num_per_tokens, num_per_channels in [(128, 128)]
+        for is_fused_cast_back in (False, True)
+        for round_sf in (False, True)
+    ]
+    if is_benchmark:
+        params = [p for p in params if p['num_topk'] in (0, 6)]
+    return params
+
+
+@pytest.mark.parametrize('params', generate_test_params(is_benchmark=False), ids=make_param_id)
+def test_per_channel_cast_fused(params):
+    _, _, _, func, func_ref = generate_test_data(params)
+
+    x_fp8, x_fp8_sf = func()
+    x_fp8_ref, x_fp8_sf_ref = func_ref()
+
+    assert_equal(x_fp8, x_fp8_ref)
+    assert_equal(x_fp8_sf, x_fp8_sf_ref)
+
+
+@pytest.mark.benchmark
+@pytest.mark.parametrize('params', generate_test_params(is_benchmark=True), ids=make_param_id)
+def test_per_channel_cast_fused_benchmark(benchmark_timer, benchmark_record, params):
+    x, num_tokens, pos_to_token, func, func_ref = generate_test_data(params)
+
+    x_fp8, x_fp8_sf = func()
+
+    t_us = benchmark_timer(func)
+    num_bytes = count_bytes(x, pos_to_token, x_fp8, x_fp8_sf)
+
+    params.pop('num_send_tokens')
+    benchmark_record(
+        kernel='per_channel_cast_fused',
+        operation='fwd',
+        params={'num_tokens': num_tokens, **params},
+        time_us=t_us,
+        bandwidth_gbs=num_bytes / t_us / 1e3,
+    )

tile_kernels_src/tests/quant/test_per_token_cast.py

@@ -0,0 +1,166 @@
+import os
+import pytest
+import torch
+
+import tile_kernels
+from tile_kernels.testing.bench import dtype_to_str, make_param_id
+from tile_kernels.testing.numeric import assert_equal, count_bytes, check_bias
+from tile_kernels.testing.generator import generate_hidden_sizes, generate_num_tokens
+from tile_kernels.testing.quant import clear_unused_sf
+
+# Disable TileLang prints
+os.environ['TILELANG_PRINT_ON_COMPILATION'] = '0'
+
+
+def generate_test_data(params):
+    num_tokens = params['num_tokens']
+    hidden = params['hidden']
+    in_dtype = params['in_dtype']
+    fmt = params['fmt']
+    use_tma_aligned_col_major_sf = params['use_tma_aligned_col_major_sf']
+    round_sf = params['round_sf']
+    use_packed_ue8m0 = params['use_packed_ue8m0']
+    x_block_size = params.get('x_block_size')
+
+    in_with_sf_factor = in_dtype in (torch.float8_e4m3fn, torch.int8)
+
+    if in_with_sf_factor:
+        x = torch.randn((num_tokens, hidden), dtype=torch.bfloat16, device='cuda')
+        original_x = x
+        in_fmt = 'e4m3' if in_dtype == torch.float8_e4m3fn else 'e2m1'
+        x = tile_kernels.torch.cast(
+            x, in_fmt, x_block_size,
+            use_tma_aligned_col_major_sf=use_tma_aligned_col_major_sf,
+            round_sf=round_sf,
+            use_packed_ue8m0=use_packed_ue8m0,
+        )
+    else:
+        x = torch.randn((num_tokens, hidden), dtype=in_dtype, device='cuda')
+        original_x = x
+
+    base_args = dict(
+        x=x, fmt=fmt, x_block_size=x_block_size,
+        use_tma_aligned_col_major_sf=use_tma_aligned_col_major_sf,
+        round_sf=round_sf,
+        use_packed_ue8m0=use_packed_ue8m0,
+    )
+
+    return (x, original_x, base_args, in_with_sf_factor)
+
+
+def generate_test_params(is_benchmark: bool) -> list[dict]:
+    params = [
+        {
+            'num_tokens': num_tokens,
+            'hidden': hidden_size,
+            'use_tma_aligned_col_major_sf': use_tma_aligned_col_major_sf,
+            'round_sf': round_sf,
+            'use_packed_ue8m0': use_packed_ue8m0,
+            'in_dtype': in_dtype,
+            'num_per_channels': num_per_channels,
+            'x_block_size': x_block_size,
+            'fmt': fmt,
+        }
+        for num_tokens in generate_num_tokens(is_benchmark=is_benchmark)
+        for hidden_size in generate_hidden_sizes()
+        for use_tma_aligned_col_major_sf, round_sf, use_packed_ue8m0 in [(False, True, False), (True, True, True)]
+        for in_dtype in (torch.float32, torch.bfloat16, torch.float8_e4m3fn, torch.int8)
+        for num_per_channels in ((32, 128) if in_dtype in (torch.float8_e4m3fn, torch.int8) else (32, 64, 128, hidden_size))
+        for x_block_size in (((128, 128), (32, 32)) if in_dtype in (torch.float8_e4m3fn, torch.int8) else (None,))
+        for fmt in ('e4m3', 'e2m1')
+    ]
+    if is_benchmark:
+        params = [p for p in params if p['use_packed_ue8m0']]
+    return params
+
+
+@pytest.mark.parametrize('params', generate_test_params(is_benchmark=False), ids=make_param_id)
+def test_per_token_cast(params):
+    num_tokens = params['num_tokens']
+    hidden = params['hidden']
+    use_tma_aligned_col_major_sf = params['use_tma_aligned_col_major_sf']
+    round_sf = params['round_sf']
+    use_packed_ue8m0 = params['use_packed_ue8m0']
+    in_dtype = params['in_dtype']
+    num_per_channels = params['num_per_channels']
+    x_block_size = params.get('x_block_size')
+    fmt = params['fmt']
+
+    in_with_sf_factor = in_dtype in (torch.float8_e4m3fn, torch.int8)
+    # Test correctness
+    x, original_x, base_args, in_with_sf_factor = generate_test_data(params)
+    func = lambda: tile_kernels.quant.per_token_cast(
+        **base_args,
+        num_per_channels=num_per_channels,
+    )
+    func_ref = lambda: tile_kernels.torch.cast(
+        **base_args,
+        block_size=(1, num_per_channels),
+    )
+    x_casted, x_sf = func()
+    x_casted_ref, x_sf_ref = func_ref()
+    x_casted_back = tile_kernels.torch.cast_back((x_casted, x_sf), 'fp32', (1, num_per_channels))
+
+    if use_packed_ue8m0:
+        x_sf = clear_unused_sf(x_sf, hidden, num_per_channels)
+        x_sf_ref = clear_unused_sf(x_sf_ref, hidden, num_per_channels)
+
+    assert_equal(x_casted, x_casted_ref)
+    assert_equal(x_sf, x_sf_ref)
+
+    # Check bias
+    check_bias(x_casted_back, original_x)
+
+    # Test non-contiguous input (stride(0) != hidden)
+    if not in_with_sf_factor and fmt == 'e4m3' and not use_packed_ue8m0 and num_tokens > 0:
+        x_non_contiguous = torch.randn((num_tokens, hidden * 2), dtype=in_dtype, device='cuda')[:, :hidden]
+        x_non_contiguous.copy_(original_x)
+        x_non_contiguous_casted, x_non_contiguous_sf = tile_kernels.quant.per_token_cast(
+            x=x_non_contiguous, fmt=fmt, x_block_size=x_block_size,
+            use_tma_aligned_col_major_sf=use_tma_aligned_col_major_sf,
+            round_sf=round_sf, use_packed_ue8m0=use_packed_ue8m0,
+            num_per_channels=num_per_channels,
+        )
+        assert_equal(x_non_contiguous_casted, x_casted)
+        assert_equal(x_non_contiguous_sf, x_sf)
+
+    if not in_with_sf_factor and num_per_channels != hidden:
+        # Test cast only mode
+        if not use_tma_aligned_col_major_sf:
+            # TMA aligned or packed ue8m0 sf is used for FP8/FP4 GEMM, not for other cast
+            x_casted = tile_kernels.quant.per_token_cast_with_precomputed_sf(
+                **base_args, num_per_channels=num_per_channels, sf=x_sf
+            )
+            x_casted_ref = tile_kernels.torch.cast(**base_args, block_size=(1, num_per_channels), sf=x_sf)
+            assert_equal(x_casted, x_casted_ref)
+
+        # Test sf only mode
+        twice_sf_inv = tile_kernels.quant.per_token_cast_with_sf_only(**base_args, num_per_channels=num_per_channels)
+        if use_packed_ue8m0:
+            twice_sf_inv = clear_unused_sf(twice_sf_inv, hidden, num_per_channels)
+        assert_equal(twice_sf_inv, x_sf)
+
+
+@pytest.mark.benchmark
+@pytest.mark.parametrize('params', generate_test_params(is_benchmark=True), ids=make_param_id)
+def test_per_token_cast_benchmark(benchmark_timer, benchmark_record, params):
+    in_dtype = params['in_dtype']
+    num_per_channels = params['num_per_channels']
+
+    x, _, base_args, _ = generate_test_data(params)
+    func = lambda: tile_kernels.quant.per_token_cast(
+        **base_args,
+        num_per_channels=num_per_channels,
+    )
+    x_casted, x_sf = func()
+
+    t_us = benchmark_timer(func)
+    num_bytes = count_bytes(x, x_casted, x_sf)
+
+    benchmark_record(
+        kernel='per_token_cast',
+        operation='fwd',
+        params={**params, 'in_dtype': dtype_to_str(in_dtype)},
+        time_us=t_us,
+        bandwidth_gbs=num_bytes / t_us / 1e3,
+    )

tile_kernels_src/tests/quant/test_per_token_cast_to_e5m6.py

@@ -0,0 +1,118 @@
+import os
+import pytest
+import torch
+
+import tile_kernels
+from tile_kernels.testing import clear_unused_sf
+from tile_kernels.testing.bench import dtype_to_str, make_param_id
+from tile_kernels.testing.numeric import assert_equal, count_bytes
+from tile_kernels.testing.generator import generate_hidden_sizes, generate_num_tokens, generate_e5m6_inputs
+from tile_kernels.torch import cast_to_e5m6
+
+# Disable TileLang prints
+os.environ['TILELANG_PRINT_ON_COMPILATION'] = '0'
+
+
+def generate_test_data(params):
+    x = params['x']
+    num_per_channels = params['num_per_channels']
+    use_tma_aligned_col_major_sf = params['use_tma_aligned_col_major_sf']
+    round_sf = params['round_sf']
+    use_packed_ue8m0 = params['use_packed_ue8m0']
+
+    func = lambda: tile_kernels.quant.per_token_cast(
+        x, 'e5m6', num_per_channels=num_per_channels,
+        use_tma_aligned_col_major_sf=use_tma_aligned_col_major_sf,
+        round_sf=round_sf,
+        use_packed_ue8m0=use_packed_ue8m0,
+    )
+    torch_func_ref = lambda: cast_to_e5m6(
+        x, num_per_channels=num_per_channels,
+        use_tma_aligned_col_major_sf=use_tma_aligned_col_major_sf,
+        round_sf=round_sf,
+        use_packed_ue8m0=use_packed_ue8m0,
+    )
+    return (func, torch_func_ref)
+
+
+def generate_test_params(is_benchmark: bool) -> list[dict]:
+    return [
+        {
+            'num_tokens': num_tokens,
+            'hidden': hidden_size,
+            'use_tma_aligned_col_major_sf': use_tma_aligned_col_major_sf,
+            'round_sf': round_sf,
+            'use_packed_ue8m0': use_packed_ue8m0,
+            'in_dtype': in_dtype,
+        }
+        for num_tokens in generate_num_tokens(is_benchmark=is_benchmark)
+        for hidden_size in generate_hidden_sizes()
+        for use_tma_aligned_col_major_sf, round_sf, use_packed_ue8m0 in [(False, True, False), (True, True, True)]
+        for in_dtype in (torch.bfloat16, torch.float32)
+    ]
+
+
+@pytest.mark.parametrize('params', generate_test_params(is_benchmark=False), ids=make_param_id)
+def test_per_token_cast_to_e5m6(params):
+    num_tokens = params['num_tokens']
+    hidden = params['hidden']
+    use_tma_aligned_col_major_sf = params['use_tma_aligned_col_major_sf']
+    round_sf = params['round_sf']
+    use_packed_ue8m0 = params['use_packed_ue8m0']
+    in_dtype = params['in_dtype']
+
+    num_per_channels = hidden
+    for x, is_special in generate_e5m6_inputs(num_tokens, hidden, in_dtype):
+        # Test correctness
+        func, torch_func_ref = generate_test_data({
+            'x': x,
+            'num_per_channels': num_per_channels,
+            'use_tma_aligned_col_major_sf': use_tma_aligned_col_major_sf,
+            'round_sf': round_sf,
+            'use_packed_ue8m0': use_packed_ue8m0,
+        })
+
+        x_fp8, x_sf = func()
+        x_fp8_ref, x_sf_ref = torch_func_ref()
+
+        if use_packed_ue8m0:
+            x_sf = clear_unused_sf(x_sf, hidden, num_per_channels)
+            x_sf_ref = clear_unused_sf(x_sf_ref, hidden, num_per_channels)
+
+        assert_equal(x_fp8, x_fp8_ref)
+        assert_equal(x_sf, x_sf_ref)
+
+
+@pytest.mark.benchmark
+@pytest.mark.parametrize('params', generate_test_params(is_benchmark=True), ids=make_param_id)
+def test_per_token_cast_to_e5m6_benchmark(benchmark_timer, benchmark_record, params):
+    hidden = params['hidden']
+    use_tma_aligned_col_major_sf = params['use_tma_aligned_col_major_sf']
+    use_packed_ue8m0 = params['use_packed_ue8m0']
+    in_dtype = params['in_dtype']
+
+    num_per_channels = hidden
+    for x, is_special in generate_e5m6_inputs(params['num_tokens'], hidden, in_dtype):
+        if is_special:
+            continue
+
+        func, torch_func_ref = generate_test_data({
+            'x': x,
+            'num_per_channels': num_per_channels,
+            'use_tma_aligned_col_major_sf': use_tma_aligned_col_major_sf,
+            'round_sf': params['round_sf'],
+            'use_packed_ue8m0': use_packed_ue8m0,
+        })
+
+        x_fp8, x_sf = func()
+
+        t_us = benchmark_timer(func)
+        num_bytes = count_bytes(x, x_fp8, x_sf)
+
+        benchmark_record(
+            kernel='per_token_cast_to_e5m6',
+            operation='fwd',
+            params={**params, 'num_per_channels': num_per_channels, 'in_dtype': dtype_to_str(in_dtype)},
+            time_us=t_us,
+            bandwidth_gbs=num_bytes / t_us / 1e3,
+        )

tile_kernels_src/tests/quant/test_swiglu_backward_and_per_token_cast.py

@@ -0,0 +1,149 @@
+import os
+import pytest
+import torch
+
+import tile_kernels
+from tile_kernels.testing.generator import generate_topk_idx, generate_hidden_sizes, generate_moe_params
+from tile_kernels.testing.numeric import assert_equal, calc_diff, count_bytes
+from tile_kernels.testing.bench import make_param_id
+
+# Disable TileLang prints
+os.environ['TILELANG_PRINT_ON_COMPILATION'] = '0'
+
+
+def generate_test_data(params):
+    num_topk = params['num_topk']
+    num_experts = params['num_experts']
+    hidden = params['hidden']
+    num_per_channels = params['num_per_channels']
+
+    topk_idx = generate_topk_idx(params)
+    num_tokens = topk_idx.shape[0]
+    topk_weights = torch.rand((num_tokens, num_topk), dtype=torch.float32, device='cuda')
+    x = torch.randn((num_tokens, hidden * 2), dtype=torch.bfloat16, device='cuda')
+    _, pos_to_token, pos_to_token_topk, token_topk_to_pos, _, _, _, _ = tile_kernels.moe.get_fused_mapping(
+        topk_idx, num_experts, 0, num_per_channels
+    )
+    x_expand = tile_kernels.moe.expand_to_fused(x, token_topk_to_pos, pos_to_token)
+    x = tile_kernels.quant.per_token_cast(x_expand, 'e4m3', num_per_channels=num_per_channels)
+    num_expand_tokens = x_expand.size(0)
+    weighted_act_x_grad = torch.randn((num_expand_tokens, hidden), dtype=torch.bfloat16, device='cuda')
+
+    return (x, num_tokens, topk_weights, pos_to_token_topk, token_topk_to_pos, weighted_act_x_grad)
+
+
+def generate_test_params(is_benchmark: bool) -> list[dict]:
+    params = [
+        {
+            'num_send_tokens': moe['num_send_tokens'],
+            'num_topk': moe['num_topk'],
+            'num_experts': moe['num_experts'],
+            'num_ep_ranks': moe['num_ep_ranks'],
+            'hidden': hidden_size,
+            'num_per_channels': num_per_channels,
+            'round_sf': round_sf,
+            'swiglu_clamp_value': swiglu_clamp_value,
+        }
+        for moe in generate_moe_params(is_benchmark)
+        for hidden_size in generate_hidden_sizes(256)
+        for num_per_channels in (32, 128)
+        for round_sf in (False, True)
+        for swiglu_clamp_value in (None, 10.0, 0.5)
+    ]
+    if is_benchmark:
+        params = [p for p in params if p['swiglu_clamp_value'] in (None, 0.5) and p['round_sf']]
+    return params
+
+
+@pytest.mark.parametrize('params', generate_test_params(is_benchmark=False), ids=make_param_id)
+def test_swiglu_backward_and_per_token_cast(params):
+    num_per_channels = params['num_per_channels']
+    round_sf = params['round_sf']
+    swiglu_clamp_value = params['swiglu_clamp_value']
+
+    x, num_tokens, topk_weights, pos_to_token_topk, token_topk_to_pos, weighted_act_x_grad = generate_test_data(params)
+
+    func = lambda: tile_kernels.quant.swiglu_backward_and_per_token_cast(
+        x,
+        weighted_act_x_grad,
+        topk_weights,
+        pos_to_token_topk,
+        token_topk_to_pos,
+        num_per_channels=num_per_channels,
+        round_sf=round_sf,
+        swiglu_clamp_value=swiglu_clamp_value,
+    )
+
+    def func_ref():
+        out, x_grad_full, weight_grad = tile_kernels.torch.swiglu_backward(
+            x,
+            weighted_act_x_grad,
+            topk_weights,
+            pos_to_token_topk,
+            token_topk_to_pos,
+            num_per_channels=num_per_channels,
+            swiglu_clamp_value=swiglu_clamp_value,
+        )
+        x_grad_fp8_full, x_grad_fp8_sf = tile_kernels.torch.cast(
+            x_grad_full, 'e4m3', block_size=(1, num_per_channels), round_sf=round_sf
+        )
+        return (
+            out.to(weighted_act_x_grad.dtype),
+            (x_grad_fp8_full, x_grad_fp8_sf),
+            x_grad_full.to(weighted_act_x_grad.dtype),
+            weight_grad,
+        )
+
+    weighted_act_x, x_grad_fp8, x_grad, topk_weights_grad = func()
+    weighted_act_x_ref, x_grad_fp8_ref, x_grad_ref, topk_weights_grad_ref = func_ref()
+
+    assert_equal(weighted_act_x, weighted_act_x_ref)
+    assert_equal(x_grad, x_grad_ref)
+    assert_equal(x_grad_fp8[0], x_grad_fp8_ref[0])
+    assert_equal(x_grad_fp8[1], x_grad_fp8_ref[1])
+    torch.testing.assert_close(topk_weights_grad, topk_weights_grad_ref, atol=1e-4, rtol=1e-4)
+
+
+@pytest.mark.benchmark
+@pytest.mark.parametrize('params', generate_test_params(is_benchmark=True), ids=make_param_id)
+def test_swiglu_backward_and_per_token_cast_benchmark(benchmark_timer, benchmark_record, params):
+    num_per_channels = params['num_per_channels']
+    round_sf = params['round_sf']
+    swiglu_clamp_value = params['swiglu_clamp_value']
+
+    x, num_tokens, topk_weights, pos_to_token_topk, token_topk_to_pos, weighted_act_x_grad = generate_test_data(params)
+
+    func = lambda: tile_kernels.quant.swiglu_backward_and_per_token_cast(
+        x,
+        weighted_act_x_grad,
+        topk_weights,
+        pos_to_token_topk,
+        token_topk_to_pos,
+        num_per_channels=num_per_channels,
+        round_sf=round_sf,
+        swiglu_clamp_value=swiglu_clamp_value,
+    )
+
+    weighted_act_x, x_grad_fp8, x_grad, topk_weights_grad = func()
+
+    t_us = benchmark_timer(func)
+    num_bytes = count_bytes(
+        x,
+        weighted_act_x_grad,
+        topk_weights,
+        pos_to_token_topk,
+        token_topk_to_pos,
+        weighted_act_x,
+        x_grad_fp8,
+        x_grad,
+        topk_weights_grad,
+    )
+
+    params.pop('num_send_tokens')
+    benchmark_record(
+        kernel='swiglu_backward_and_per_token_cast',
+        operation='fwd',
+        params={'num_tokens': num_tokens, **params},
+        time_us=t_us,
+        bandwidth_gbs=num_bytes / t_us / 1e3,
+    )

tile_kernels_src/tests/quant/test_swiglu_forward_and_per_channel_cast_and_transpose.py

@@ -0,0 +1,114 @@
+import os
+import pytest
+import torch
+
+import tile_kernels
+from tile_kernels.testing.generator import generate_hidden_sizes, generate_num_tokens
+from tile_kernels.testing.numeric import assert_equal, count_bytes
+from tile_kernels.testing.bench import make_param_id
+
+# Disable TileLang prints
+os.environ['TILELANG_PRINT_ON_COMPILATION'] = '0'
+
+
+def generate_test_data(params):
+    num_tokens = params['num_tokens']
+    hidden = params['hidden']
+    dtype = torch.bfloat16
+    x = torch.randn((num_tokens, hidden * 2), dtype=dtype, device='cuda')
+    return x
+
+
+def generate_test_params(is_benchmark: bool) -> list[dict]:
+    params = [
+        {
+            'num_tokens': num_tokens,
+            'hidden': hidden_size,
+            'num_per_tokens': num_per_tokens,
+            'without_transpose': without_transpose,
+            'round_sf': round_sf,
+            'swiglu_clamp_value': swiglu_clamp_value,
+        }
+        for num_tokens in generate_num_tokens(128, is_benchmark=is_benchmark)
+        for hidden_size in generate_hidden_sizes()
+        for num_per_tokens in (32, 128)
+        for without_transpose in (True, False)
+        for round_sf in (True, False)
+        for swiglu_clamp_value in (None, 10.0, 0.5)
+    ]
+    if is_benchmark:
+        params = [p for p in params if p['swiglu_clamp_value'] in (None, 0.5)]
+    return params
+
+
+@pytest.mark.parametrize('params', generate_test_params(is_benchmark=False), ids=make_param_id)
+def test_swiglu_forward_and_per_channel_cast_and_transpose(params):
+    num_per_tokens = params['num_per_tokens']
+    without_transpose = params['without_transpose']
+    round_sf = params['round_sf']
+    swiglu_clamp_value = params['swiglu_clamp_value']
+
+    x = generate_test_data(params)
+
+    func = lambda: tile_kernels.quant.swiglu_forward_and_per_channel_cast_and_transpose(
+        x,
+        'e4m3',
+        num_per_tokens=num_per_tokens,
+        round_sf=round_sf,
+        without_transpose=without_transpose,
+        swiglu_clamp_value=swiglu_clamp_value,
+    )
+
+    def func_ref():
+        act_out = tile_kernels.torch.swiglu_forward(
+            x,
+            swiglu_clamp_value=swiglu_clamp_value,
+        ).bfloat16()
+        x_fp8_ref, x_sf_ref = tile_kernels.torch.cast(
+            act_out,
+            'e4m3',
+            block_size=(num_per_tokens, 1),
+            round_sf=round_sf,
+        )
+        if not without_transpose:
+            x_fp8_ref = x_fp8_ref.T.contiguous()
+        return x_fp8_ref, x_sf_ref
+
+    x_fp8, x_sf = func()
+    x_fp8_ref, x_sf_ref = func_ref()
+
+    assert_equal(x_sf, x_sf_ref)
+    assert_equal(x_fp8, x_fp8_ref)
+
+
+@pytest.mark.benchmark
+@pytest.mark.parametrize('params', generate_test_params(is_benchmark=True), ids=make_param_id)
+def test_swiglu_forward_and_per_channel_cast_and_transpose_benchmark(benchmark_timer, benchmark_record, params):
+    num_per_tokens = params['num_per_tokens']
+    without_transpose = params['without_transpose']
+    round_sf = params['round_sf']
+    swiglu_clamp_value = params['swiglu_clamp_value']
+
+    x = generate_test_data(params)
+
+    func = lambda: tile_kernels.quant.swiglu_forward_and_per_channel_cast_and_transpose(
+        x,
+        'e4m3',
+        num_per_tokens=num_per_tokens,
+        round_sf=round_sf,
+        without_transpose=without_transpose,
+        swiglu_clamp_value=swiglu_clamp_value,
+    )
+
+    x_fp8, x_sf = func()
+    num_bytes = count_bytes(x, x_fp8, x_sf)
+
+    t_us = benchmark_timer(func)
+
+    benchmark_record(
+        kernel='swiglu_forward_and_per_channel_cast_and_transpose',
+        operation='fwd',
+        params=params,
+        time_us=t_us,
+        bandwidth_gbs=num_bytes / t_us / 1e3,
+    )

tile_kernels_src/tests/quant/test_swiglu_forward_and_per_token_cast.py

@@ -0,0 +1,179 @@
+import os
+import pytest
+import torch
+
+import tile_kernels
+from tile_kernels.testing import clear_unused_sf
+from tile_kernels.torch import swiglu_forward, cast
+from tile_kernels.config import set_num_sms
+from tile_kernels.testing.generator import generate_topk_idx, generate_hidden_sizes, generate_moe_params, generate_num_sms
+from tile_kernels.testing.numeric import assert_equal, count_bytes
+from tile_kernels.testing.bench import make_param_id
+
+# Disable TileLang prints
+os.environ['TILELANG_PRINT_ON_COMPILATION'] = '0'
+
+
+def generate_test_data(params):
+    num_topk = params['num_topk']
+    num_experts = params['num_experts']
+    hidden = params['hidden']
+
+    topk_idx = generate_topk_idx(params)
+    num_tokens = topk_idx.shape[0]
+    alignment = 16
+    pos_to_expert, pos_to_token, pos_to_token_topk, token_topk_to_pos, _, _, _, _ = tile_kernels.moe.get_fused_mapping(topk_idx, num_experts, 0, alignment)
+    post_weights = torch.randn((num_tokens, num_topk), dtype=torch.float32, device='cuda')
+    x = torch.randn((num_tokens, hidden * 2), dtype=torch.bfloat16, device='cuda')
+    x = tile_kernels.moe.expand_to_fused(x, token_topk_to_pos, pos_to_token)
+    _clamped_count = torch.zeros(3, dtype=torch.int64, device='cuda')
+
+    return (x, num_tokens, pos_to_expert, pos_to_token_topk, post_weights, _clamped_count)
+
+
+def generate_test_params(is_benchmark: bool) -> list[dict]:
+    params = [
+        {
+            **moe,
+            'hidden': hidden_size,
+            'enable_pos_to_expert': enable_pos_to_expert,
+            'with_weights': with_weights,
+            'num_per_channels': num_per_channels,
+            'use_tma_aligned_col_major_sf': use_tma_aligned_col_major_sf,
+            'round_sf': round_sf,
+            'use_packed_ue8m0': use_packed_ue8m0,
+            'swiglu_clamp_value': swiglu_clamp_value,
+        }
+        for moe in generate_moe_params(is_benchmark)
+        for hidden_size in [h // 2 for h in generate_hidden_sizes(256)]
+        for enable_pos_to_expert in (True, False)
+        for with_weights in (True, False)
+        for num_per_channels in (128, hidden_size)
+        for use_tma_aligned_col_major_sf, round_sf, use_packed_ue8m0 in [(False, True, False), (True, True, True)]
+        if not ((use_packed_ue8m0 and with_weights) or (use_tma_aligned_col_major_sf and num_per_channels == hidden_size))
+        for swiglu_clamp_value in (None, 10.0, 0.5)
+    ]
+    if is_benchmark:
+        params = [p for p in params if p['swiglu_clamp_value'] in (0.5, None) and p['use_tma_aligned_col_major_sf'] and p['round_sf']]
+    return params
+
+
+@pytest.mark.parametrize('params', generate_test_params(is_benchmark=False), ids=make_param_id)
+def test_swiglu_forward_and_per_token_cast(params):
+    hidden = params['hidden']
+    enable_pos_to_expert = params['enable_pos_to_expert']
+    with_weights = params['with_weights']
+    num_per_channels = params['num_per_channels']
+    use_tma_aligned_col_major_sf = params['use_tma_aligned_col_major_sf']
+    round_sf = params['round_sf']
+    use_packed_ue8m0 = params['use_packed_ue8m0']
+    swiglu_clamp_value = params['swiglu_clamp_value']
+
+    x, num_tokens, pos_to_expert, pos_to_token_topk, post_weights, _clamped_count = generate_test_data(params)
+
+    do_clamp_count = num_per_channels != hidden and swiglu_clamp_value is not None
+    clamped_count_ref = _clamped_count.clone() if do_clamp_count else None
+    base_args = dict(
+        x=x,
+        fmt='e4m3',
+        pos_to_expert=pos_to_expert if enable_pos_to_expert else None,
+        swiglu_clamp_value=swiglu_clamp_value
+    )
+    kernel_args = dict(
+        **base_args,
+        num_per_channels=num_per_channels,
+        pos_to_token_topk=pos_to_token_topk if with_weights else None,
+        topk_weights=post_weights if with_weights else None,
+        use_tma_aligned_col_major_sf=use_tma_aligned_col_major_sf, round_sf=round_sf,
+        use_packed_ue8m0=use_packed_ue8m0,
+    )
+
+    def func_ref():
+        out = swiglu_forward(
+            x,
+            pos_to_token_topk if with_weights else None,
+            post_weights if with_weights else None,
+            swiglu_clamp_value,
+            clamped_count_ref,
+        )
+
+        if enable_pos_to_expert:
+            mask = pos_to_expert == -1
+            out = out.masked_fill(mask.unsqueeze(-1), 0)
+
+        result = cast(
+            out, 'e4m3', (1, num_per_channels),
+            use_tma_aligned_col_major_sf=use_tma_aligned_col_major_sf,
+            round_sf=round_sf,
+            use_packed_ue8m0=use_packed_ue8m0,
+        )
+        return result
+
+    x_fp8_ref, x_sf_ref = func_ref()
+    mask = (pos_to_expert == -1).unsqueeze(-1)
+    x_fp8_ref_float = x_fp8_ref.float().masked_fill(mask, 0)
+    x_sf_ref = x_sf_ref.masked_fill(mask, 0)
+    if use_packed_ue8m0:
+        x_sf_ref = clear_unused_sf(x_sf_ref, hidden, num_per_channels)
+
+    for num_sms in generate_num_sms():
+        set_num_sms(num_sms)
+        clamped_count = _clamped_count.clone() if do_clamp_count else None
+        x_fp8, x_sf = tile_kernels.quant.swiglu_forward_and_per_token_cast(
+            **kernel_args, clamped_count=clamped_count
+        )
+        x_fp8_float = x_fp8.float().masked_fill(mask, 0)
+        x_sf = x_sf.masked_fill(mask, 0)
+        if use_packed_ue8m0:
+            x_sf = clear_unused_sf(x_sf, hidden, num_per_channels)
+
+        assert_equal(x_fp8_float, x_fp8_ref_float)
+        assert_equal(x_sf, x_sf_ref)
+        if do_clamp_count:
+            assert_equal(clamped_count, clamped_count_ref)
+
+
+@pytest.mark.benchmark
+@pytest.mark.parametrize('params', generate_test_params(is_benchmark=True), ids=make_param_id)
+def test_swiglu_forward_and_per_token_cast_benchmark(benchmark_timer, benchmark_record, params):
+    hidden = params['hidden']
+    enable_pos_to_expert = params['enable_pos_to_expert']
+    with_weights = params['with_weights']
+    num_per_channels = params['num_per_channels']
+    use_tma_aligned_col_major_sf = params['use_tma_aligned_col_major_sf']
+    round_sf = params['round_sf']
+    use_packed_ue8m0 = params['use_packed_ue8m0']
+    swiglu_clamp_value = params['swiglu_clamp_value']
+
+    x, num_tokens, pos_to_expert, pos_to_token_topk, post_weights, _clamped_count = generate_test_data(params)
+
+    do_clamp_count = num_per_channels != hidden and swiglu_clamp_value is not None
+    clamped_count = _clamped_count.clone() if do_clamp_count else None
+    kernel_args = dict(
+        x=x,
+        fmt='e4m3',
+        pos_to_expert=pos_to_expert if enable_pos_to_expert else None,
+        swiglu_clamp_value=swiglu_clamp_value,
+        num_per_channels=num_per_channels,
+        pos_to_token_topk=pos_to_token_topk if with_weights else None,
+        topk_weights=post_weights if with_weights else None,
+        use_tma_aligned_col_major_sf=use_tma_aligned_col_major_sf, round_sf=round_sf,
+        use_packed_ue8m0=use_packed_ue8m0,
+    )
+
+    func = lambda: tile_kernels.quant.swiglu_forward_and_per_token_cast(
+        **kernel_args, clamped_count=clamped_count
+    )
+    x_fp8, x_sf = func()
+
+    t_us = benchmark_timer(func)
+    num_bytes = count_bytes(x, x_fp8, x_sf)
+
+    params.pop('num_send_tokens')
+    benchmark_record(
+        kernel='swiglu_forward_and_per_token_cast',
+        operation='fwd',
+        params={'num_tokens': num_tokens, **params},
+        time_us=t_us,
+        bandwidth_gbs=num_bytes / t_us / 1e3,
+    )