From c907df8eb8d824931082a9bf4d0c79f27fcad631 Mon Sep 17 00:00:00 2001 From: Anerudhan Gopal Date: Wed, 10 Jun 2026 22:23:36 -0700 Subject: [PATCH] Add the results. Initial script and README.md --- benchmark/cutedsl_fusion_kernels/README.md | 94 + .../cutedsl_fusion_benchmarks.py | 1613 +++++++++++++++++ .../results/B200/output.txt | 16 + .../results/B200/output_verbose.txt | 71 + .../results/B200/results.png | Bin 0 -> 176022 bytes .../results/B300/output.txt | 16 + .../results/B300/output_verbose.txt | 71 + .../results/B300/results.png | Bin 0 -> 176796 bytes 8 files changed, 1881 insertions(+) create mode 100644 benchmark/cutedsl_fusion_kernels/README.md create mode 100644 benchmark/cutedsl_fusion_kernels/cutedsl_fusion_benchmarks.py create mode 100644 benchmark/cutedsl_fusion_kernels/results/B200/output.txt create mode 100644 benchmark/cutedsl_fusion_kernels/results/B200/output_verbose.txt create mode 100644 benchmark/cutedsl_fusion_kernels/results/B200/results.png create mode 100644 benchmark/cutedsl_fusion_kernels/results/B300/output.txt create mode 100644 benchmark/cutedsl_fusion_kernels/results/B300/output_verbose.txt create mode 100644 benchmark/cutedsl_fusion_kernels/results/B300/results.png diff --git a/benchmark/cutedsl_fusion_kernels/README.md b/benchmark/cutedsl_fusion_kernels/README.md new file mode 100644 index 000000000..ff64aaae5 --- /dev/null +++ b/benchmark/cutedsl_fusion_kernels/README.md @@ -0,0 +1,94 @@ +# cuteDSL Fusion Benchmarks + +Microbenchmark comparing **fused cuDNN Frontend** grouped-GEMM + activation +kernels against the equivalent **unfused Transformer Engine** path +(grouped GEMM + activation) for Mixture-of-Experts activations. Timed with CUDA +graph replay; reports the per-activation speedup (`te/cudnn`). + +Activations covered: `swiglu`, `dswiglu`, `srelu`, `dsrelu`, `geglu`, `dgeglu` +(the `d*` variants are the corresponding backward / GLU-bprop patterns). + +For GLU-family kernels, the functional test also accounts for cuDNN Frontend's +32-column interleaved GLU layout. Forward GLU weights are packed from logical +`[gate, up]` order into `[gate32, up32, ...]` order before the fused path. For +backward GLU kernels, the saved activation input is packed the same way and the +fused gradient output is unpacked before comparison. + +For `geglu` and `dgeglu`, cuDNN Frontend's cuteDSL implementation uses +Megatron-style QuickGeGLU: `quick_gelu(gate) * (up + linear_offset)`, with +`quick_gelu(gate) = gate * sigmoid(1.702 * gate)`. The benchmark also applies +the cuDNN FE clamp settings used by this kernel path: gate is clamped above and +the linear half is clamped symmetrically. TE's plain `tex.geglu`/`tex.dgeglu` +use tanh-GELU instead, so the functional oracle uses the cuDNN FE QuickGeGLU +formula for those two tests. This mirrors Megatron-LM's +`megatron/core/fusions/fused_bias_geglu.py` QuickGeGLU helper. By default this +oracle is an eager PyTorch expression; pass +`--functional-reference-backend torch_compile` to run the same expression through +`torch.compile`. + +For `dsrelu`, cuDNN Frontend's cuteDSL backward epilogue treats the grouped GEMM +output as the saved SReLU input and `c_tensor` as the upstream gradient. The +functional oracle follows that operand order. + +## How to run + +In the latest PyTorch container (e.g. `nvcr.io/nvidia/pytorch:26.05-py3`), with +`cutedsl_fusion_benchmarks.py` available on the host: + +```bash +docker run -it --gpus=all --workdir /workspace \ + -v "$(pwd):/host:ro" \ + nvcr.io/nvidia/pytorch:26.05-py3 \ + bash -c "cp /host/cutedsl_fusion_benchmarks.py /workspace && bash" +``` + +Then, inside the container: + +```bash +PIP_CONSTRAINT="" pip install nvidia-cudnn-frontend[cutedsl] transformer-engine + +python cutedsl_fusion_benchmarks.py +``` + +## Running the functional test + +Run only the functional (correctness) subset: + +```bash +python cutedsl_fusion_benchmarks.py --activation all --functional-only +``` + +## Running custom sizes + +```bash +python cutedsl_fusion_benchmarks.py --activation all --experts 8 --tokens 4096 --glu-bprop-tokens 2048 --k 8192 --n 4096 +``` + +## Profiling with nsys + +```bash +nsys profile --force-overwrite=true --trace=cuda,nvtx,osrt --cuda-graph-trace=node --sample=none --cpuctxsw=none \ + python cutedsl_fusion_benchmarks.py --activation all --experts 8 --tokens 4096 --glu-bprop-tokens 2048 --k 8192 --n 4096 +``` + +## Results + +Pass `--output-dir` to write `output.txt` (device/versions/summary), +`output_verbose.txt` (per-activation detail), and `results.png` (speedup plot): + +```bash +python cutedsl_fusion_benchmarks.py --output-dir results +``` + +The results below were generated with the default shape +(`experts=8, tokens/expert=4096, K=8192, N=4096`, `bf16`) using +`torch 2.12.0a0+nv26.05`, `transformer-engine 2.15.0`, +`nvidia-cudnn-frontend 1.23.0`, and `nvidia-cutlass-dsl 4.4.1`. + +### B200 + +![cuDNN fused-epilogue speedups vs Transformer Engine on NVIDIA GB200](results/B200/results.png) + +### B300 + +![cuDNN fused-epilogue speedups vs Transformer Engine on NVIDIA GB300](results/B300/results.png) diff --git a/benchmark/cutedsl_fusion_kernels/cutedsl_fusion_benchmarks.py b/benchmark/cutedsl_fusion_kernels/cutedsl_fusion_benchmarks.py new file mode 100644 index 000000000..9e2c9c4c2 --- /dev/null +++ b/benchmark/cutedsl_fusion_kernels/cutedsl_fusion_benchmarks.py @@ -0,0 +1,1613 @@ +#!/usr/bin/env python3 +"""Benchmark fused cuDNN Frontend activations vs unfused Transformer Engine kernels. + +Supported activations: + swiglu, dswiglu, srelu, dsrelu, geglu, dgeglu + +Fused path: + cuDNN Frontend grouped GEMM + activation wrappers + +Unfused TE path: + TE MXFP8 quantize -> TE grouped GEMM -> optional pointwise scale + -> TE activation + MXFP8 quantize + +Both paths are warmed up, captured with CUDA Graphs, and timed with graph replay. +Functional tests can also be run with --functional-only. They use shared +TE-quantized MXFP8 inputs for the fused and reference paths and compare +dequantized outputs. For GeGLU/DGeGLU, the functional oracle uses an eager +PyTorch reference by default and matches cuDNN Frontend's Megatron-style +QuickGeGLU, clamp, and linear-offset semantics; TE's tex.geglu uses tanh-GELU +and is intentionally different. For dSReLU, the oracle matches cuDNN Frontend's operand order where +the grouped GEMM output is the saved SReLU input and c_tensor is the upstream +gradient. + +Shape convention: + E = number of experts + T = tokens per expert + K = input / gradient hidden size + N = activation output hidden size + +Forward GLU activations use a grouped GEMM with output width 2N and activation +output width N. Backward GLU activations use grouped GEMM output width N and +activation-gradient output width 2N. When comparing against a forward GLU shape, +pass --glu-bprop-tokens as half of --tokens for dswiglu/dgeglu. SReLU/dSReLU use +width N. + +Example: + python cutedsl_fusion_benchmarks.py --activation all --experts 8 --tokens 4096 --glu-bprop-tokens 2048 --k 8192 --n 4096 + python cutedsl_fusion_benchmarks.py --activation all --functional-only +""" + +from __future__ import annotations + +import argparse +import importlib.metadata as metadata +import inspect +import io +import os +import statistics +import sys +from collections.abc import Callable + +import torch +import torch.nn.functional as F + +ACTIVATIONS = ("swiglu", "dswiglu", "srelu", "dsrelu", "geglu", "dgeglu") +FORWARD_GLU = {"swiglu", "geglu"} +BACKWARD_GLU = {"dswiglu", "dgeglu"} +FORWARD_RELU = {"srelu"} +BACKWARD_RELU = {"dsrelu"} + +MXFP8_BLOCK = 32 +M_ALIGNED = 256 +GEGLU_ALPHA = 1.702 +GEGLU_LINEAR_OFFSET = 1.0 +GEGLU_CLAMP_MAX = 7.0 +GEGLU_CLAMP_MIN = -7.0 + +_COMPILED_GEGLU_REFERENCE: Callable[[torch.Tensor], torch.Tensor] | None = None +_COMPILED_DGEGLU_REFERENCE: Callable[[torch.Tensor, torch.Tensor, torch.Tensor], torch.Tensor] | None = None + + +def ceil_div(a: int, b: int) -> int: + return (a + b - 1) // b + + +def parse_dtype(name: str) -> torch.dtype: + if name in ("bf16", "bfloat16"): + return torch.bfloat16 + if name in ("fp16", "float16"): + return torch.float16 + raise argparse.ArgumentTypeError("dtype must be bf16 or fp16") + + +def package_version(name: str) -> str: + try: + return metadata.version(name) + except metadata.PackageNotFoundError: + return "not-installed" + + +def check_dims(tokens: int, k: int, n: int) -> None: + dims = {"tokens": tokens, "k": k, "n": n, "2*n": 2 * n} + bad = [name for name, value in dims.items() if value % MXFP8_BLOCK != 0] + if bad: + raise ValueError(f"MXFP8 dimensions must be divisible by {MXFP8_BLOCK}: {bad}") + if tokens % M_ALIGNED: + raise ValueError(f"tokens must be a multiple of {M_ALIGNED} for this benchmark") + if k % 64 or n % 64: + raise ValueError("cuDNN grouped-GEMM fusion expects k and n to be multiples of 64") + + +def activation_shape(activation: str, n: int) -> tuple[int, int | None, int]: + """Return GEMM N, optional fused C input width, and activation output width.""" + if activation in FORWARD_GLU: + return 2 * n, None, n + if activation in BACKWARD_GLU: + return n, 2 * n, 2 * n + if activation in FORWARD_RELU: + return n, None, n + if activation in BACKWARD_RELU: + return n, n, n + raise ValueError(f"Unsupported activation: {activation}") + + +def benchmark_tokens_for_activation(args: argparse.Namespace, activation: str) -> int: + if activation in BACKWARD_GLU and args.glu_bprop_tokens is not None: + return args.glu_bprop_tokens + return args.tokens + + +def random_layout_tensor( + *, + groups: int, + mode0: int, + mode1: int, + mode0_major: bool, + dtype: torch.dtype, + device: torch.device, +) -> torch.Tensor: + """Create a tensor in cuDNN Frontend grouped-GEMM layout.""" + shape = (groups, mode1, mode0) if mode0_major else (groups, mode0, mode1) + order = (2, 1, 0) if mode0_major else (1, 2, 0) + src = torch.empty(shape, dtype=torch.float32, device=device).uniform_(-2.0, 2.0) + return src.permute(order).to(dtype) + + +def random_scale_tensor( + *, + groups: int, + mn: int, + k: int, + sf_vec_size: int, + dtype: torch.dtype, + device: torch.device, +) -> torch.Tensor: + """Create MXFP8 scale factors in cuDNN Frontend's M32x4xK4 layout.""" + sf_k = ceil_div(k, sf_vec_size) + base_shape = (groups, ceil_div(mn, 128), ceil_div(sf_k, 4), 32, 4, 4) + scale = torch.empty(base_shape, dtype=torch.float32, device=device).uniform_(1.0, 3.0) + return scale.permute(3, 4, 1, 5, 2, 0).to(torch.int8).to(dtype) + + +def view_as_fp8_e4m3(tensor: torch.Tensor) -> torch.Tensor: + return tensor.view(dtype=torch.float8_e4m3fn) + + +def view_as_e8m0(tensor: torch.Tensor) -> torch.Tensor: + return tensor.view(dtype=torch.float8_e8m0fnu) + + +def k_major_3d(tensor: torch.Tensor) -> torch.Tensor: + rows, cols = tensor.shape + return tensor.as_strided((rows, cols, 1), (cols, 1, rows * cols)) + + +def compact_sf_to_cudnn_layout( + scale: torch.Tensor, + *, + mn: int, + nk: int, + groups: int, +) -> torch.Tensor: + """Convert compact MXFP8 scales to cuDNN Frontend's M32x4xK4 layout.""" + sf_k = ceil_div(nk, MXFP8_BLOCK) + m_blocks = ceil_div(mn, 128) + k_blocks = ceil_div(sf_k, 4) + padded = torch.zeros( + (m_blocks * 128, k_blocks * 4, groups), + dtype=scale.dtype, + device=scale.device, + ) + padded[:mn, :sf_k, :] = scale.reshape(mn, sf_k, groups) + base_data = padded.view(m_blocks, 4, 32, k_blocks, 4, groups).permute(5, 0, 3, 2, 1, 4) + + # Keep the same strided tensor contract as cuDNN Frontend test utilities. + base = torch.empty( + (groups, m_blocks, k_blocks, 32, 4, 4), + dtype=scale.dtype, + device=scale.device, + ) + base.copy_(base_data) + return base.permute(3, 4, 1, 5, 2, 0) + + +def cudnn_layout_to_compact_sf( + scale: torch.Tensor, + *, + mn: int, + nk: int, + groups: int, +) -> torch.Tensor: + """Convert cuDNN Frontend's M32x4xK4 scale layout back to compact scales.""" + sf_k = ceil_div(nk, MXFP8_BLOCK) + m_blocks = ceil_div(mn, 128) + k_blocks = ceil_div(sf_k, 4) + base = scale.permute(5, 2, 4, 0, 1, 3) + padded = ( + base.permute(1, 4, 3, 2, 5, 0) + .contiguous() + .view( + m_blocks * 128, + k_blocks * 4, + groups, + ) + ) + return padded[:mn, :sf_k, :] + + +def dequantize_cudnn_mxfp8_output( + tensor: torch.Tensor, + scale: torch.Tensor, + *, + out_n: int, + norm_const: float, +) -> torch.Tensor: + """Dequantize cuDNN FP8 output using the generated row scale factors.""" + m = tensor.shape[0] + compact = cudnn_layout_to_compact_sf(scale, mn=m, nk=out_n, groups=1).to(torch.float32) + expanded = compact.unsqueeze(2).expand(m, compact.shape[1], MXFP8_BLOCK, 1) + expanded = expanded.reshape(m, compact.shape[1] * MXFP8_BLOCK, 1)[:, :out_n, :] + return tensor.to(torch.float32) * expanded / norm_const + + +def glu_interleaved_indices(n: int, *, device: torch.device) -> torch.Tensor: + """Column order expected by cuDNN GLU kernels for a logical [gate, up] tensor.""" + if n % MXFP8_BLOCK: + raise ValueError(f"GLU width must be divisible by {MXFP8_BLOCK}, got {n}") + gate = torch.arange(n, dtype=torch.long, device=device).view(-1, MXFP8_BLOCK) + up = torch.arange(n, 2 * n, dtype=torch.long, device=device).view(-1, MXFP8_BLOCK) + return torch.stack((gate, up), dim=1).reshape(-1) + + +def pack_glu_interleaved(tensor: torch.Tensor) -> torch.Tensor: + """Pack logical [gate, up] columns into [gate32, up32, ...] GLU layout.""" + n2 = tensor.shape[1] + if n2 % 2: + raise ValueError(f"GLU tensor width must be even, got {n2}") + indices = glu_interleaved_indices(n2 // 2, device=tensor.device) + return tensor.index_select(1, indices).contiguous() + + +def unpack_glu_interleaved(tensor: torch.Tensor) -> torch.Tensor: + """Unpack [gate32, up32, ...] GLU columns back to logical [gate, up].""" + n2 = tensor.shape[1] + if n2 % 2: + raise ValueError(f"GLU tensor width must be even, got {n2}") + indices = glu_interleaved_indices(n2 // 2, device=tensor.device) + out = torch.empty_like(tensor) + out.index_copy_(1, indices, tensor) + return out + + +def require_torch_compile() -> None: + if not hasattr(torch, "compile"): + raise RuntimeError("torch.compile is required for --functional-reference-backend torch_compile") + + +def quick_gelu(gate: torch.Tensor) -> torch.Tensor: + """Megatron QuickGELU approximation used by cuDNN FE's GeGLU wrappers.""" + return gate * torch.sigmoid(GEGLU_ALPHA * gate) + + +def quick_geglu_formula(input_tensor: torch.Tensor) -> torch.Tensor: + """Megatron-style QuickGeGLU with cuDNN FE clamp and linear-offset settings.""" + gate, up = input_tensor.to(torch.float32).chunk(2, dim=-1) + gate = gate.clamp(max=GEGLU_CLAMP_MAX) + up = up.clamp(min=GEGLU_CLAMP_MIN, max=GEGLU_CLAMP_MAX) + out = quick_gelu(gate) * (up + GEGLU_LINEAR_OFFSET) + return out.to(input_tensor.dtype) + + +def compiled_geglu_formula() -> Callable[[torch.Tensor], torch.Tensor]: + global _COMPILED_GEGLU_REFERENCE + require_torch_compile() + if _COMPILED_GEGLU_REFERENCE is None: + _COMPILED_GEGLU_REFERENCE = torch.compile(quick_geglu_formula, fullgraph=True, dynamic=False) + return _COMPILED_GEGLU_REFERENCE + + +def cudnn_geglu_reference(input_tensor: torch.Tensor, quantizer, backend: str) -> object: + if backend == "torch_compile": + return quantizer(compiled_geglu_formula()(input_tensor)) + return quantizer(quick_geglu_formula(input_tensor)) + + +def cudnn_dgeglu_formula( + acc_tensor: torch.Tensor, + activation_input: torch.Tensor, + prob_tensor: torch.Tensor, +) -> torch.Tensor: + """Derivative for cuDNN FE's clamped, offset Megatron-style QuickGeGLU.""" + grad = acc_tensor.to(torch.float32) * prob_tensor.to(torch.float32) + gate_raw, up_raw = activation_input.to(torch.float32).chunk(2, dim=-1) + gate = gate_raw.clamp(max=GEGLU_CLAMP_MAX) + up = up_raw.clamp(min=GEGLU_CLAMP_MIN, max=GEGLU_CLAMP_MAX) + sigmoid = torch.sigmoid(GEGLU_ALPHA * gate) + + dgate = grad * sigmoid * (1.0 + GEGLU_ALPHA * gate * (1.0 - sigmoid)) + dgate = dgate * (up + GEGLU_LINEAR_OFFSET) + dup = grad * gate * sigmoid + + dgate = torch.where(gate_raw <= GEGLU_CLAMP_MAX, dgate, torch.zeros_like(dgate)) + up_mask = (up_raw >= GEGLU_CLAMP_MIN) & (up_raw <= GEGLU_CLAMP_MAX) + dup = torch.where(up_mask, dup, torch.zeros_like(dup)) + return torch.cat((dgate, dup), dim=-1).to(activation_input.dtype) + + +def compiled_dgeglu_formula() -> Callable[[torch.Tensor, torch.Tensor, torch.Tensor], torch.Tensor]: + global _COMPILED_DGEGLU_REFERENCE + require_torch_compile() + if _COMPILED_DGEGLU_REFERENCE is None: + _COMPILED_DGEGLU_REFERENCE = torch.compile(cudnn_dgeglu_formula, fullgraph=True, dynamic=False) + return _COMPILED_DGEGLU_REFERENCE + + +def cudnn_dgeglu_reference( + acc_tensor: torch.Tensor, + activation_input: torch.Tensor, + prob_tensor: torch.Tensor, + quantizer, + backend: str, +) -> object: + if backend == "torch_compile": + return quantizer(compiled_dgeglu_formula()(acc_tensor, activation_input, prob_tensor)) + return quantizer(cudnn_dgeglu_formula(acc_tensor, activation_input, prob_tensor)) + + +def cudnn_dsrelu_formula(acc_tensor: torch.Tensor, grad_tensor: torch.Tensor) -> torch.Tensor: + """cuDNN FE dSReLU math: 2 * relu(acc) * upstream_grad for alpha=prob=1.""" + acc_relu = torch.relu(acc_tensor.to(torch.float32)) + out = 2.0 * acc_relu * grad_tensor.to(torch.float32) + return out.to(grad_tensor.dtype) + + +def cudnn_dsrelu_reference(acc_tensor: torch.Tensor, grad_tensor: torch.Tensor, quantizer) -> object: + return quantizer(cudnn_dsrelu_formula(acc_tensor, grad_tensor)) + + +def pytorch_activation_formula( + *, + activation: str, + tensor: torch.Tensor, + activation_input: torch.Tensor | None, + prob: torch.Tensor, +) -> torch.Tensor: + """PyTorch pointwise baseline with cuDNN FE semantics for GeGLU/dSReLU cases.""" + if activation == "swiglu": + gate, up = tensor.to(torch.float32).chunk(2, dim=-1) + return (F.silu(gate) * up).to(tensor.dtype) + if activation == "geglu": + return quick_geglu_formula(tensor) + if activation == "srelu": + return torch.relu(tensor.to(torch.float32)).square().to(tensor.dtype) + + if activation_input is None: + raise ValueError(f"{activation} requires activation_input") + + if activation == "dswiglu": + grad = tensor.to(torch.float32) * prob.to(torch.float32) + gate, up = activation_input.to(torch.float32).chunk(2, dim=-1) + sigmoid = torch.sigmoid(gate) + silu = gate * sigmoid + dsilu = sigmoid * (1.0 + gate * (1.0 - sigmoid)) + return torch.cat((grad * up * dsilu, grad * silu), dim=-1).to(activation_input.dtype) + if activation == "dgeglu": + return cudnn_dgeglu_formula(tensor, activation_input, prob) + if activation == "dsrelu": + return cudnn_dsrelu_formula(tensor, activation_input) + + raise ValueError(f"Unsupported activation: {activation}") + + +def make_cudnn_inputs( + *, + activation: str, + experts: int, + tokens: int, + k: int, + n: int, + c_dtype: torch.dtype, + device: torch.device, +) -> dict[str, torch.Tensor | None]: + m = experts * tokens + gemm_n, c_cols, _ = activation_shape(activation, n) + sf_vec_size = 32 + + out: dict[str, torch.Tensor | None] = { + "a_tensor": random_layout_tensor( + groups=1, + mode0=m, + mode1=k, + mode0_major=False, + dtype=torch.float8_e4m3fn, + device=device, + ), + "b_tensor": random_layout_tensor( + groups=experts, + mode0=gemm_n, + mode1=k, + mode0_major=False, + dtype=torch.float8_e4m3fn, + device=device, + ), + "sfa_tensor": random_scale_tensor( + groups=1, + mn=m, + k=k, + sf_vec_size=sf_vec_size, + dtype=torch.float8_e8m0fnu, + device=device, + ), + "sfb_tensor": random_scale_tensor( + groups=experts, + mn=gemm_n, + k=k, + sf_vec_size=sf_vec_size, + dtype=torch.float8_e8m0fnu, + device=device, + ), + "padded_offsets": torch.arange( + tokens, + m + 1, + tokens, + dtype=torch.int32, + device=device, + ), + "alpha_tensor": torch.ones(experts, dtype=torch.float32, device=device), + "beta_tensor": torch.ones(experts, dtype=torch.float32, device=device), + "prob_tensor": torch.ones(m, 1, 1, dtype=torch.float32, device=device), + "dprob_tensor": torch.zeros(m, 1, 1, dtype=torch.float32, device=device), + "norm_const_tensor": torch.tensor([0.01], dtype=torch.float32, device=device), + "c_tensor": None, + } + + if c_cols is not None: + out["c_tensor"] = random_layout_tensor( + groups=1, + mode0=m, + mode1=c_cols, + mode0_major=False, + dtype=c_dtype, + device=device, + ) + return out + + +def make_mxfp8_quantizer(*, rowwise: bool, columnwise: bool): + import transformer_engine.pytorch # noqa: F401 + import transformer_engine_torch as tex + from transformer_engine.pytorch.tensor.mxfp8_tensor import MXFP8Quantizer + + return MXFP8Quantizer(tex.DType.kFloat8E4M3, rowwise=rowwise, columnwise=columnwise) + + +def capture_cuda_graph(fn: Callable[[], object], *, warmup: int) -> tuple[torch.cuda.CUDAGraph, object]: + warmup_stream = torch.cuda.Stream() + warmup_stream.wait_stream(torch.cuda.current_stream()) + with torch.cuda.stream(warmup_stream): + for _ in range(warmup): + fn() + torch.cuda.current_stream().wait_stream(warmup_stream) + torch.cuda.synchronize() + + graph = torch.cuda.CUDAGraph() + with torch.cuda.graph(graph): + graph_outputs = fn() + torch.cuda.synchronize() + return graph, graph_outputs + + +def cuda_graph_time_ms( + graph: torch.cuda.CUDAGraph, + *, + iters: int, + samples: int, +) -> list[float]: + out = [] + start = torch.cuda.Event(enable_timing=True) + end = torch.cuda.Event(enable_timing=True) + for _ in range(samples): + start.record() + for _ in range(iters): + graph.replay() + end.record() + torch.cuda.synchronize() + out.append(start.elapsed_time(end) / iters) + return out + + +def output_get(outputs: object, names: tuple[str, ...], indices: tuple[int, ...]) -> torch.Tensor: + """Fetch a named tensor from cuDNN TupleDict-like outputs with tuple fallback.""" + for name in names: + try: + value = outputs[name] # type: ignore[index] + if isinstance(value, torch.Tensor): + return value + except (KeyError, IndexError, TypeError, AttributeError): + pass + for index in indices: + try: + value = outputs[index] # type: ignore[index] + if isinstance(value, torch.Tensor): + return value + except (KeyError, IndexError, TypeError, AttributeError): + pass + keys = list(outputs.keys()) if hasattr(outputs, "keys") else type(outputs).__name__ # type: ignore[attr-defined] + raise AssertionError(f"could not find output tensor {names}; available={keys}") + + +def check_tensor_contract( + *, + name: str, + tensor: torch.Tensor, + shape: tuple[int, ...], + dtype: torch.dtype, +) -> None: + if tuple(tensor.shape) != shape: + raise AssertionError(f"{name} shape mismatch: got {tuple(tensor.shape)}, expected {shape}") + if tensor.dtype != dtype: + raise AssertionError(f"{name} dtype mismatch: got {tensor.dtype}, expected {dtype}") + if not tensor.is_cuda: + raise AssertionError(f"{name} must be a CUDA tensor") + + +def check_mxfp8_payload(*, tensor: object, rowwise_data: torch.Tensor, shape: tuple[int, ...]) -> None: + if tuple(rowwise_data.shape) != shape: + raise AssertionError(f"unfused MXFP8 rowwise payload shape mismatch: got {tuple(rowwise_data.shape)}, expected {shape}") + if rowwise_data.dtype not in (torch.uint8, torch.float8_e4m3fn): + raise AssertionError("unfused MXFP8 rowwise payload dtype mismatch: " f"got {rowwise_data.dtype}, expected packed uint8 or float8_e4m3fn") + if not rowwise_data.is_cuda: + raise AssertionError("unfused MXFP8 rowwise payload must be a CUDA tensor") + + if getattr(tensor, "_fp8_dtype", None) is None: + raise AssertionError("unfused output is missing MXFP8 dtype metadata") + if getattr(tensor, "_rowwise_scale_inv", None) is None: + raise AssertionError("unfused output is missing rowwise MXFP8 scales") + + +def check_functional_outputs( + *, + activation: str, + fused_outputs: object, + unfused_output: object, + m: int, + out_n: int, + dtype: torch.dtype, +) -> None: + if activation in FORWARD_GLU or activation in FORWARD_RELU: + fused_primary = output_get(fused_outputs, ("d_tensor", "D"), (1, 0)) + fused_name = "fused d_tensor" + else: + fused_primary = output_get(fused_outputs, ("d_row_tensor", "d_tensor", "D"), (0,)) + fused_name = "fused d_row_tensor" + + check_tensor_contract( + name=fused_name, + tensor=fused_primary, + shape=(m, out_n, 1), + dtype=torch.float8_e4m3fn, + ) + + if not hasattr(unfused_output, "shape"): + raise AssertionError(f"unfused output has no shape attribute: {type(unfused_output).__name__}") + if tuple(unfused_output.shape) != (m, out_n): # type: ignore[attr-defined] + raise AssertionError(f"unfused output shape mismatch: got {tuple(unfused_output.shape)}, expected {(m, out_n)}") # type: ignore[attr-defined] + if getattr(unfused_output, "dtype", None) != dtype: + raise AssertionError(f"unfused output dtype mismatch: got {getattr(unfused_output, 'dtype', None)}, expected {dtype}") + + rowwise_data = getattr(unfused_output, "_rowwise_data", None) + if rowwise_data is None: + raise AssertionError("unfused output is not rowwise MXFP8-quantized") + check_mxfp8_payload(tensor=unfused_output, rowwise_data=rowwise_data, shape=(m, out_n)) + + +def make_shared_functional_case( + *, + activation: str, + tex, + run_grouped_gemm, + experts: int, + tokens: int, + m: int, + k: int, + n: int, + dtype: torch.dtype, + device: torch.device, + wrappers, + use_dynamic_sched: bool, + reference_backend: str, +) -> tuple[Callable[[], object], Callable[[], object]]: + gemm_n, c_cols, _ = activation_shape(activation, n) + norm_const = 0.01 + + a = torch.randn(m, k, dtype=dtype, device=device) * 0.1 + weight = torch.randn(experts, k, gemm_n, dtype=dtype, device=device) * 0.1 + + q_a = make_mxfp8_quantizer(rowwise=True, columnwise=False) + q_w = make_mxfp8_quantizer(rowwise=True, columnwise=True) + q_out = make_mxfp8_quantizer(rowwise=True, columnwise=True) + + a_parts = [q_a(a[i * tokens : (i + 1) * tokens]) for i in range(experts)] + w_parts = [q_w(weight[i]) for i in range(experts)] + fused_weight = weight + if activation in FORWARD_GLU: + fused_weight = torch.stack( + [pack_glu_interleaved(weight[i]) for i in range(experts)], + dim=0, + ) + fused_w_parts = [q_w(fused_weight[i]) for i in range(experts)] + + a_payload = torch.cat([view_as_fp8_e4m3(part._rowwise_data) for part in a_parts], dim=0).contiguous() + a_scale = torch.cat([view_as_e8m0(part._rowwise_scale_inv) for part in a_parts], dim=0) + b_payload = torch.stack( + [view_as_fp8_e4m3(part._columnwise_data).T.contiguous() for part in fused_w_parts], + dim=0, + ).permute(1, 2, 0) + b_scale = torch.stack( + [view_as_e8m0(part._columnwise_scale_inv).T.contiguous() for part in fused_w_parts], + dim=2, + ) + + act_input = None + c_tensor = None + if c_cols is not None: + act_input = torch.randn(m, c_cols, dtype=dtype, device=device) * 0.1 + fused_act_input = pack_glu_interleaved(act_input) if activation in BACKWARD_GLU else act_input + c_tensor = k_major_3d(fused_act_input) + + fused_inputs: dict[str, torch.Tensor | None] = { + "a_tensor": k_major_3d(a_payload), + "b_tensor": b_payload, + "sfa_tensor": compact_sf_to_cudnn_layout( + a_scale.reshape(m, k // MXFP8_BLOCK, 1), + mn=m, + nk=k, + groups=1, + ), + "sfb_tensor": compact_sf_to_cudnn_layout( + b_scale, + mn=gemm_n, + nk=k, + groups=experts, + ), + "padded_offsets": torch.arange( + tokens, + m + 1, + tokens, + dtype=torch.int32, + device=device, + ), + "alpha_tensor": torch.ones(experts, dtype=torch.float32, device=device), + "beta_tensor": torch.ones(experts, dtype=torch.float32, device=device), + "prob_tensor": torch.ones(m, 1, 1, dtype=torch.float32, device=device), + "dprob_tensor": torch.zeros(m, 1, 1, dtype=torch.float32, device=device), + "norm_const_tensor": torch.tensor([norm_const], dtype=torch.float32, device=device), + "c_tensor": c_tensor, + } + + fused = make_fused_fn( + activation=activation, + inputs=fused_inputs, + dtype=dtype, + use_dynamic_sched=use_dynamic_sched, + wrappers=wrappers, + ) + + gemm_out = torch.empty(m, gemm_n, dtype=dtype, device=device) + prob = torch.ones(m, 1, dtype=dtype, device=device) + dact_dy = torch.empty_like(gemm_out) + + if activation in FORWARD_GLU or activation in FORWARD_RELU: + + def unfused() -> object: + run_grouped_gemm(w_parts, a_parts, gemm_out) + if activation == "geglu": + return cudnn_geglu_reference(gemm_out, q_out, reference_backend) + return getattr(tex, activation)(gemm_out, q_out) + + return fused, unfused + + if activation in BACKWARD_GLU or activation in BACKWARD_RELU: + + def unfused() -> object: + run_grouped_gemm(w_parts, a_parts, gemm_out) + if activation == "dgeglu": + return cudnn_dgeglu_reference(gemm_out, act_input, prob, q_out, reference_backend) + if activation == "dsrelu": + return cudnn_dsrelu_reference(gemm_out, act_input, q_out) + torch.mul(gemm_out, prob, out=dact_dy) + return getattr(tex, activation)(dact_dy, act_input, q_out) + + return fused, unfused + + raise ValueError(f"Unsupported activation: {activation}") + + +def compare_functional_outputs( + *, + activation: str, + fused_outputs: object, + unfused_output: object, + m: int, + out_n: int, + dtype: torch.dtype, + atol: float, + rtol: float, +) -> tuple[float, float, float]: + check_functional_outputs( + activation=activation, + fused_outputs=fused_outputs, + unfused_output=unfused_output, + m=m, + out_n=out_n, + dtype=dtype, + ) + + if activation in FORWARD_GLU or activation in FORWARD_RELU: + fused_primary = output_get(fused_outputs, ("d_tensor", "D"), (1, 0)) + else: + fused_primary = output_get(fused_outputs, ("d_row_tensor", "d_tensor", "D"), (0,)) + + sfd_row = output_get(fused_outputs, ("sfd_row_tensor",), (4, 5)) + fused_deq = dequantize_cudnn_mxfp8_output( + fused_primary, + sfd_row, + out_n=out_n, + norm_const=0.01, + ).reshape(m, out_n) + if activation in BACKWARD_GLU: + fused_deq = unpack_glu_interleaved(fused_deq) + unfused_deq = unfused_output.dequantize(dtype=torch.float32).reshape(m, out_n) # type: ignore[attr-defined] + + diff = (fused_deq - unfused_deq).abs() + max_abs = diff.max().item() + mean_abs = diff.mean().item() + p99_abs = torch.quantile(diff.flatten(), 0.99).item() + + try: + torch.testing.assert_close(fused_deq, unfused_deq, atol=atol, rtol=rtol) + except AssertionError as exc: + raise AssertionError( + f"{activation} output mismatch: max_abs={max_abs:.6g}, " f"p99_abs={p99_abs:.6g}, mean_abs={mean_abs:.6g}, " f"atol={atol}, rtol={rtol}" + ) from exc + + return max_abs, p99_abs, mean_abs + + +def run_functional_tests( + *, + activations: tuple[str, ...], + args, + tex, + general_grouped_gemm, + wrappers, + device: torch.device, +) -> None: + e = args.functional_experts + t = args.functional_tokens + k = args.functional_k + n = args.functional_n + m = e * t + check_dims(t, k, n) + + print() + print("functional tests:") + print(" scope: shared-input dequantized output comparison") + print(f" shape: experts={e}, tokens/expert={t}, M={m}, K={k}, N={n}") + print(f" tolerance: atol={args.functional_atol}, rtol={args.functional_rtol}") + if any(activation in {"geglu", "dgeglu"} for activation in activations): + print(" geglu reference: " f"{args.functional_reference_backend} Megatron-style QuickGeGLU + clamp + linear-offset semantics") + if "dsrelu" in activations: + print(" dsrelu reference: cuDNN FE operand order, GEMM output is saved activation input") + + run_grouped_gemm = make_grouped_gemm_runner( + general_grouped_gemm, + experts=e, + tokens=t, + dtype=args.dtype, + ) + + with torch.no_grad(): + for index, activation in enumerate(activations): + torch.manual_seed(args.seed + 1000 + index) + _, _, out_n = activation_shape(activation, n) + fused, unfused = make_shared_functional_case( + activation=activation, + tex=tex, + run_grouped_gemm=run_grouped_gemm, + experts=e, + tokens=t, + m=m, + k=k, + n=n, + dtype=args.dtype, + device=device, + wrappers=wrappers, + use_dynamic_sched=not args.no_dynamic_sched, + reference_backend=args.functional_reference_backend, + ) + + fused_outputs = fused() + unfused_output = unfused() + torch.cuda.synchronize() + max_abs, p99_abs, mean_abs = compare_functional_outputs( + activation=activation, + fused_outputs=fused_outputs, + unfused_output=unfused_output, + m=m, + out_n=out_n, + dtype=args.dtype, + atol=args.functional_atol, + rtol=args.functional_rtol, + ) + print(f" {activation:<8} PASS " f"max_abs={max_abs:.4g} p99_abs={p99_abs:.4g} mean_abs={mean_abs:.4g}") + + +def make_grouped_gemm_runner(general_grouped_gemm, *, experts: int, tokens: int, dtype: torch.dtype): + """Handle TE grouped-GEMM signature differences across NGC and TE main.""" + params = inspect.signature(general_grouped_gemm).parameters + if "quantization_params" in params: + + def run(w_parts, a_parts, gemm_out) -> None: + general_grouped_gemm( + w_parts, + a_parts, + [gemm_out], + [None] * experts, + dtype, + layout="NN", + m_splits=[tokens] * experts, + use_split_accumulator=True, + single_output=True, + ) + + return run + + from transformer_engine.pytorch.module.base import get_multi_stream_cublas_workspace + + workspace = get_multi_stream_cublas_workspace() + + def run(w_parts, a_parts, gemm_out) -> None: + general_grouped_gemm( + w_parts, + a_parts, + [gemm_out], + dtype, + workspace, + layout="NN", + m_splits=[tokens] * experts, + use_split_accumulator=True, + single_output=True, + ) + + return run + + +def make_fused_fn( + *, + activation: str, + inputs: dict[str, torch.Tensor | None], + dtype: torch.dtype, + use_dynamic_sched: bool, + wrappers, +): + common = { + "a_tensor": inputs["a_tensor"], + "b_tensor": inputs["b_tensor"], + "sfa_tensor": inputs["sfa_tensor"], + "sfb_tensor": inputs["sfb_tensor"], + "padded_offsets": inputs["padded_offsets"], + "alpha_tensor": inputs["alpha_tensor"], + "norm_const_tensor": inputs["norm_const_tensor"], + "acc_dtype": torch.float32, + "d_dtype": torch.float8_e4m3fn, + "cd_major": "n", + "mma_tiler_mn": (256, 256), + "cluster_shape_mn": (2, 1), + "sf_vec_size": 32, + "vector_f32": False, + "m_aligned": M_ALIGNED, + "discrete_col_sfd": False, + } + + def current_stream(): + return wrappers["cuda"].CUstream(torch.cuda.current_stream().cuda_stream) + + if activation in FORWARD_GLU: + + def fused() -> object: + return wrappers["glu"]( + **common, + prob_tensor=inputs["prob_tensor"], + c_dtype=dtype, + act_func=activation, + use_dynamic_sched=use_dynamic_sched, + current_stream=current_stream(), + ) + + return fused + + if activation in FORWARD_RELU: + + def fused() -> object: + return wrappers["srelu"]( + **common, + prob_tensor=inputs["prob_tensor"], + c_dtype=dtype, + use_dynamic_sched=use_dynamic_sched, + current_stream=current_stream(), + ) + + return fused + + if activation in BACKWARD_GLU: + + def fused() -> object: + inputs["dprob_tensor"].zero_() + return wrappers["dglu"]( + **common, + c_tensor=inputs["c_tensor"], + beta_tensor=inputs["beta_tensor"], + prob_tensor=inputs["prob_tensor"], + dprob_tensor=inputs["dprob_tensor"], + generate_dbias=False, + act_func=activation, + use_dynamic_sched=use_dynamic_sched, + current_stream=current_stream(), + ) + + return fused + + if activation in BACKWARD_RELU: + + def fused() -> object: + inputs["dprob_tensor"].zero_() + return wrappers["dsrelu"]( + **common, + c_tensor=inputs["c_tensor"], + prob_tensor=inputs["prob_tensor"], + dprob_tensor=inputs["dprob_tensor"], + generate_dbias=False, + use_dynamic_sched=use_dynamic_sched, + current_stream=current_stream(), + ) + + return fused + + raise ValueError(f"Unsupported activation: {activation}") + + +def make_unfused_te_fn( + *, + activation: str, + tex, + run_grouped_gemm, + experts: int, + tokens: int, + m: int, + k: int, + n: int, + dtype: torch.dtype, + device: torch.device, +): + gemm_n, c_cols, _ = activation_shape(activation, n) + + a = torch.randn(m, k, dtype=dtype, device=device) * 0.1 + weight = torch.randn(experts, k, gemm_n, dtype=dtype, device=device) * 0.1 + + q_a = make_mxfp8_quantizer(rowwise=True, columnwise=False) + q_w = make_mxfp8_quantizer(rowwise=True, columnwise=True) + q_out = make_mxfp8_quantizer(rowwise=True, columnwise=True) + + a_parts = [q_a(a[i * tokens : (i + 1) * tokens]) for i in range(experts)] + w_parts = [q_w(weight[i]) for i in range(experts)] + gemm_out = torch.empty(m, gemm_n, dtype=dtype, device=device) + + prob = torch.ones(m, 1, dtype=dtype, device=device) + dact_dy = torch.empty_like(gemm_out) + act_input = None + if c_cols is not None: + act_input = torch.randn(m, c_cols, dtype=dtype, device=device) * 0.1 + + if activation in FORWARD_GLU or activation in FORWARD_RELU: + + def unfused() -> object: + run_grouped_gemm(w_parts, a_parts, gemm_out) + return getattr(tex, activation)(gemm_out, q_out) + + return unfused + + if activation in BACKWARD_GLU or activation in BACKWARD_RELU: + + def unfused() -> object: + run_grouped_gemm(w_parts, a_parts, gemm_out) + torch.mul(gemm_out, prob, out=dact_dy) + return getattr(tex, activation)(dact_dy, act_input, q_out) + + return unfused + + raise ValueError(f"Unsupported activation: {activation}") + + +def make_pytorch_baseline_fn( + *, + activation: str, + run_grouped_gemm, + experts: int, + tokens: int, + m: int, + k: int, + n: int, + dtype: torch.dtype, + device: torch.device, +): + """TE MXFP8 grouped GEMM followed by PyTorch pointwise activation and TE quantize.""" + gemm_n, c_cols, _ = activation_shape(activation, n) + + a = torch.randn(m, k, dtype=dtype, device=device) * 0.1 + weight = torch.randn(experts, k, gemm_n, dtype=dtype, device=device) * 0.1 + + q_a = make_mxfp8_quantizer(rowwise=True, columnwise=False) + q_w = make_mxfp8_quantizer(rowwise=True, columnwise=True) + q_out = make_mxfp8_quantizer(rowwise=True, columnwise=True) + + a_parts = [q_a(a[i * tokens : (i + 1) * tokens]) for i in range(experts)] + w_parts = [q_w(weight[i]) for i in range(experts)] + gemm_out = torch.empty(m, gemm_n, dtype=dtype, device=device) + + prob = torch.ones(m, 1, dtype=dtype, device=device) + act_input = None + if c_cols is not None: + act_input = torch.randn(m, c_cols, dtype=dtype, device=device) * 0.1 + + def pytorch_baseline() -> object: + run_grouped_gemm(w_parts, a_parts, gemm_out) + out = pytorch_activation_formula( + activation=activation, + tensor=gemm_out, + activation_input=act_input, + prob=prob, + ) + return q_out(out) + + return pytorch_baseline + + +def benchmark_activation( + *, + activation: str, + args, + tex, + general_grouped_gemm, + wrappers, + device: torch.device, +) -> tuple[str, float, float, float | None, list[float], list[float], list[float] | None]: + e, k, n = args.experts, args.k, args.n + t = benchmark_tokens_for_activation(args, activation) + m = e * t + gemm_n, c_cols, out_n = activation_shape(activation, n) + + print() + print(f"activation: {activation}") + print(f"shape: experts={e}, tokens/expert={t}, M={m}, K={k}, N={n}") + print(f"fused GEMM N={gemm_n}, fused C input N={c_cols}, activation output N={out_n}") + + fused_inputs = make_cudnn_inputs( + activation=activation, + experts=e, + tokens=t, + k=k, + n=n, + c_dtype=args.dtype, + device=device, + ) + fused = make_fused_fn( + activation=activation, + inputs=fused_inputs, + dtype=args.dtype, + use_dynamic_sched=not args.no_dynamic_sched, + wrappers=wrappers, + ) + + run_grouped_gemm = make_grouped_gemm_runner( + general_grouped_gemm, + experts=e, + tokens=t, + dtype=args.dtype, + ) + unfused = make_unfused_te_fn( + activation=activation, + tex=tex, + run_grouped_gemm=run_grouped_gemm, + experts=e, + tokens=t, + m=m, + k=k, + n=n, + dtype=args.dtype, + device=device, + ) + fused_graph, fused_outputs = capture_cuda_graph(fused, warmup=args.warmup) + unfused_graph, unfused_outputs = capture_cuda_graph(unfused, warmup=args.warmup) + graph_outputs = [fused_outputs, unfused_outputs] + + pytorch_graph = None + pytorch_ms = None + pytorch_avg = None + if args.include_pytorch_baseline: + pytorch_baseline = make_pytorch_baseline_fn( + activation=activation, + run_grouped_gemm=run_grouped_gemm, + experts=e, + tokens=t, + m=m, + k=k, + n=n, + dtype=args.dtype, + device=device, + ) + pytorch_graph, pytorch_outputs = capture_cuda_graph(pytorch_baseline, warmup=args.warmup) + graph_outputs.append(pytorch_outputs) + + fused_ms = cuda_graph_time_ms(fused_graph, iters=args.iters, samples=args.samples) + unfused_ms = cuda_graph_time_ms(unfused_graph, iters=args.iters, samples=args.samples) + if pytorch_graph is not None: + pytorch_ms = cuda_graph_time_ms(pytorch_graph, iters=args.iters, samples=args.samples) + + fused_avg = statistics.mean(fused_ms) + unfused_avg = statistics.mean(unfused_ms) + if pytorch_ms is not None: + pytorch_avg = statistics.mean(pytorch_ms) + print(f"fused cuDNN avg: {fused_avg:.3f} ms") + print(f"unfused TE avg: {unfused_avg:.3f} ms") + print(f"speedup vs TE: {unfused_avg / fused_avg:.2f}x") + if pytorch_avg is not None: + print(f"PyTorch avg: {pytorch_avg:.3f} ms") + print(f"speedup vs torch:{pytorch_avg / fused_avg:6.2f}x") + print(f"fused samples: {[round(x, 3) for x in fused_ms]}") + print(f"TE samples: {[round(x, 3) for x in unfused_ms]}") + if pytorch_ms is not None: + print(f"PyTorch samples: {[round(x, 3) for x in pytorch_ms]}") + del graph_outputs + return activation, fused_avg, unfused_avg, pytorch_avg, fused_ms, unfused_ms, pytorch_ms + + +class _Tee: + """Write to several streams at once (e.g. real stdout and a capture buffer).""" + + def __init__(self, *streams) -> None: + self.streams = streams + + def write(self, data: str) -> int: + for stream in self.streams: + stream.write(data) + return len(data) + + def flush(self) -> None: + for stream in self.streams: + stream.flush() + + +# Lines kept in output.txt: device, dtype, library versions, and shapes. +OUTPUT_TXT_PREFIXES = ( + "device:", + "dtype:", + "torch:", + "transformer_engine:", + "nvidia-cudnn-frontend:", + "nvidia-cutlass-dsl:", + "shape:", + "base shape:", + "GLU bprop shape:", +) + +# Per-activation shape lines move next to each bar in the chart, so they are +# dropped from the chart's header block (but kept in output.txt). +SHAPE_PREFIXES = ("shape:", "base shape:", "GLU bprop shape:") + +DISPLAY_NAMES = { + "swiglu": "SwiGLU", + "dswiglu": "dSwiGLU", + "srelu": "SReLU", + "dsrelu": "dSReLU", + "geglu": "QuickGeGLU", + "dgeglu": "dQuickGeGLU", +} + + +# Preferred header fonts; matplotlib falls back to the first one available. +HEADER_FONT = ["Helvetica Neue", "Helvetica", "Arial", "DejaVu Sans"] +HEADER_ACCENT = "#00866a" + +# Prettier labels for the environment metadata lines in the chart header. +LABEL_PRETTY = { + "device": "Device", + "dtype": "Dtype", + "torch": "PyTorch", + "transformer_engine": "Transformer Engine", + "nvidia-cudnn-frontend": "cuDNN Frontend", + "nvidia-cutlass-dsl": "cuTLASS DSL", +} + + +def display_name(activation: str) -> str: + return DISPLAY_NAMES.get(activation, activation) + + +def family_color(activation: str) -> str: + """Bar color grouped by activation family (GLU=green, ReLU=blue, GeGLU=amber).""" + if activation in ("swiglu", "dswiglu"): + return "#0db58f" + if activation in ("srelu", "dsrelu"): + return "#6c8ff0" + return "#f2a51f" + + +def format_summary(results: list, *, include_pytorch: bool) -> list[str]: + """Render the benchmark summary table as a list of lines.""" + lines = ["summary:"] + if include_pytorch: + lines.append(f"{'activation':<10} {'cudnn_ms':>10} {'te_ms':>10} {'pytorch_ms':>12} " f"{'te/cudnn':>10} {'torch/cudnn':>12}") + for activation, fused_avg, unfused_avg, pytorch_avg, _, _, _ in results: + assert pytorch_avg is not None + lines.append( + f"{activation:<10} {fused_avg:10.3f} {unfused_avg:10.3f} {pytorch_avg:12.3f} " + f"{unfused_avg / fused_avg:9.2f}x {pytorch_avg / fused_avg:11.2f}x" + ) + else: + lines.append(f"{'activation':<10} {'cudnn_ms':>10} {'te_ms':>10} {'te/cudnn':>10}") + for activation, fused_avg, unfused_avg, _, _, _, _ in results: + lines.append(f"{activation:<10} {fused_avg:10.3f} {unfused_avg:10.3f} {unfused_avg / fused_avg:9.2f}x") + return lines + + +def write_results_png( + results: list, + *, + include_pytorch: bool, + shapes: dict[str, str], + info_lines: list[str], + path: str, +) -> None: + """Render speedups as a horizontal bar chart with a metadata header block.""" + try: + import matplotlib + + matplotlib.use("Agg") + import matplotlib.pyplot as plt + from matplotlib import font_manager + from matplotlib.patches import Patch + except ImportError: + print(f"matplotlib not available; skipping {path}") + return + + # Only request fonts that exist so matplotlib does not warn on every glyph. + available = {f.name for f in font_manager.fontManager.ttflist} + header_font = [f for f in HEADER_FONT if f in available] or ["sans-serif"] + + activations = [r[0] for r in results] + te_speedups = [unfused / fused for _, fused, unfused, _, _, _, _ in results] + torch_speedups = [(pytorch / fused) if pytorch is not None else None for _, fused, _, pytorch, _, _, _ in results] + have_torch = include_pytorch and all(s is not None for s in torch_speedups) + + # Header highlights: prominent speedup stats plus the environment metadata. + avg_te = sum(te_speedups) / len(te_speedups) + best_idx = max(range(len(te_speedups)), key=lambda i: te_speedups[i]) + stat_groups = [ + (f"{avg_te:.2f}x", "average speedup vs TE"), + (f"{te_speedups[best_idx]:.2f}x", f"best: {display_name(activations[best_idx])}"), + ] + if have_torch: + avg_torch = sum(torch_speedups) / len(torch_speedups) + stat_groups.append((f"{avg_torch:.2f}x", "average speedup vs PyTorch")) + stat_groups.append((str(len(results)), "activations benchmarked")) + + env_pairs = [] + for line in info_lines: + key, _, value = line.partition(":") + env_pairs.append((LABEL_PRETTY.get(key.strip(), key.strip()), value.strip())) + env_rows = (len(env_pairs) + 1) // 2 + + # Round the x-axis up to a clean 0.5 multiple that clears every bar. + raw_max = max(list(te_speedups) + [s for s in torch_speedups if s is not None] + [1.0]) + tick_max = 0.5 + while tick_max < raw_max + 1e-9: + tick_max += 0.5 + tick_max = max(tick_max, 1.5) + gutter = 0.55 * tick_max # left label column, in data units + + n = len(results) + head_h = 1.35 + 0.42 * env_rows + chart_h = 0.95 * n + 0.7 + fig = plt.figure(figsize=(14.0, head_h + chart_h + 0.5)) + fig.suptitle( + "cuDNN fused-epilogue speedups vs Transformer Engine", + fontsize=20, + fontweight="bold", + color="#0f172a", + family=header_font, + x=0.07, + ha="left", + ) + grid = fig.add_gridspec(2, 1, height_ratios=[head_h, chart_h], hspace=0.08) + + ax_info = fig.add_subplot(grid[0]) + ax_info.axis("off") + + # Stat highlights across the top: big accent number + muted caption. + n_stat = len(stat_groups) + for i, (value, caption) in enumerate(stat_groups): + x = i / n_stat + ax_info.text(x, 0.98, value, transform=ax_info.transAxes, va="top", ha="left", fontsize=26, fontweight="bold", color=HEADER_ACCENT, family=header_font) + ax_info.text(x, 0.60, caption, transform=ax_info.transAxes, va="top", ha="left", fontsize=12, color="#64748b", family=header_font) + + # Thin divider between the highlights and the environment metadata. + ax_info.plot([0.0, 1.0], [0.50, 0.50], transform=ax_info.transAxes, color="#e2e8f0", lw=1.2) + + # Environment metadata as a two-column label/value grid. + label_x = (0.0, 0.50) + value_x = (0.16, 0.74) + row_top = 0.40 + row_step = 0.40 / max(env_rows, 1) + for idx, (label, value) in enumerate(env_pairs): + col = idx % 2 + y = row_top - (idx // 2) * row_step + ax_info.text( + label_x[col], y, label, transform=ax_info.transAxes, va="top", ha="left", fontsize=12, fontweight="bold", color="#334155", family=header_font + ) + ax_info.text(value_x[col], y, value, transform=ax_info.transAxes, va="top", ha="left", fontsize=12, color="#0f172a", family=header_font) + + ax = fig.add_subplot(grid[1]) + for spine in ("top", "right", "left"): + ax.spines[spine].set_visible(False) + ax.set_yticks([]) + ax.set_xlim(-gutter, tick_max * 1.12) + ax.set_ylim(-0.7, n - 0.3) + ax.invert_yaxis() + + xticks = [] + tick = 0.0 + while tick <= tick_max + 1e-9: + xticks.append(round(tick, 1)) + tick += 0.5 + ax.set_xticks(xticks) + ax.set_xticklabels([f"{x:g}x" if x > 0 else "0" for x in xticks], color="#64748b") + ax.tick_params(axis="x", length=0) + for x in xticks: + ax.axvline(x, color="#eef2f7", lw=1.0, zorder=0) + ax.axvline(0.0, color="#cbd5e1", lw=1.2, zorder=1) + ax.axvline(1.0, color="#94a3b8", lw=1.4, ls=(0, (5, 7)), zorder=1) + ax.text(1.0, -0.62, "TE parity", color="#64748b", fontsize=11, ha="center", va="bottom") + + label_pad = tick_max * 0.02 + for i, activation in enumerate(activations): + color = family_color(activation) + shape = shapes.get(activation, "") + ax.text(-gutter * 0.96, i - 0.14, display_name(activation), ha="left", va="center", fontweight="bold", fontsize=13, color="#0f172a") + if shape: + ax.text(-gutter * 0.96, i + 0.18, shape, ha="left", va="center", fontsize=9.5, color="#64748b") + + if have_torch: + ax.barh(i - 0.17, te_speedups[i], height=0.30, color=color, zorder=3) + ax.barh(i + 0.17, torch_speedups[i], height=0.30, color=color, alpha=0.5, zorder=3) + ax.text(te_speedups[i] + label_pad, i - 0.17, f"{te_speedups[i]:.2f}x", ha="left", va="center", fontsize=11, fontweight="bold", color="#0f172a") + ax.text(torch_speedups[i] + label_pad, i + 0.17, f"{torch_speedups[i]:.2f}x", ha="left", va="center", fontsize=10, color="#475569") + else: + ax.barh(i, te_speedups[i], height=0.5, color=color, zorder=3) + ax.text(te_speedups[i] + label_pad, i, f"{te_speedups[i]:.2f}x", ha="left", va="center", fontsize=12, fontweight="bold", color="#0f172a") + + if have_torch: + handles = [ + Patch(facecolor="#475569", label="cuDNN vs TE"), + Patch(facecolor="#475569", alpha=0.5, label="cuDNN vs PyTorch"), + ] + ax.legend( + handles=handles, + loc="lower right", + bbox_to_anchor=(1.0, 1.0), + ncol=2, + frameon=False, + fontsize=10, + ) + + ax.set_xlabel("speedup (higher is better)", color="#475569", fontsize=11) + + fig.savefig(path, dpi=150, bbox_inches="tight", facecolor="white") + plt.close(fig) + print(f"wrote {path}") + + +def write_output_files( + *, + output_dir: str, + verbose_text: str, + results: list, + args: argparse.Namespace, +) -> None: + """Write output_verbose.txt, output.txt, and results.png into output_dir.""" + include_pytorch = args.include_pytorch_baseline + verbose_path = os.path.join(output_dir, "output_verbose.txt") + with open(verbose_path, "w") as handle: + handle.write(verbose_text) + print(f"wrote {verbose_path}") + + summary_lines = format_summary(results, include_pytorch=include_pytorch) if results else [] + # Preserve order but drop duplicates (per-activation "shape:" lines repeat the top-level one). + key_lines: list[str] = [] + seen: set[str] = set() + for line in verbose_text.splitlines(): + if line.startswith(OUTPUT_TXT_PREFIXES) and line not in seen: + seen.add(line) + key_lines.append(line) + output_path = os.path.join(output_dir, "output.txt") + with open(output_path, "w") as handle: + for line in key_lines: + handle.write(line + "\n") + if summary_lines: + handle.write("\n") + for line in summary_lines: + handle.write(line + "\n") + print(f"wrote {output_path}") + + if results: + # Per-activation GEMM shape: experts x tokens/expert x GEMM-N x K. + shapes = {} + for activation, *_ in results: + tokens = benchmark_tokens_for_activation(args, activation) + gemm_n, _, _ = activation_shape(activation, args.n) + shapes[activation] = f"GEMM: {args.experts} x {tokens} x {gemm_n} x {args.k}" + # The chart header keeps device/dtype/version info; shapes move next to each bar. + chart_info_lines = [line for line in key_lines if not line.startswith(SHAPE_PREFIXES)] + write_results_png( + results, + include_pytorch=include_pytorch, + shapes=shapes, + info_lines=chart_info_lines, + path=os.path.join(output_dir, "results.png"), + ) + + +def run_benchmarks(args: argparse.Namespace) -> list: + """Run functional tests and/or benchmarks, printing progress. Returns timing results.""" + if not torch.cuda.is_available(): + raise RuntimeError("CUDA is required") + torch.cuda.set_device(args.device) + device = torch.device("cuda", args.device) + + import transformer_engine.pytorch # noqa: F401 + import transformer_engine_torch as tex + from cuda.bindings import driver as cuda + from cudnn import ( + grouped_gemm_dglu_wrapper_sm100, + grouped_gemm_dsrelu_wrapper_sm100, + grouped_gemm_glu_wrapper_sm100, + grouped_gemm_srelu_wrapper_sm100, + ) + from transformer_engine.pytorch.cpp_extensions import general_grouped_gemm + + torch.manual_seed(args.seed) + + print(f"device: {torch.cuda.get_device_name(args.device)}") + if not args.functional_only: + if args.glu_bprop_tokens is None: + print(f"shape: experts={args.experts}, tokens/expert={args.tokens}, " f"M={args.experts * args.tokens}, K={args.k}, N={args.n}") + else: + print(f"base shape: experts={args.experts}, tokens/expert={args.tokens}, " f"M={args.experts * args.tokens}, K={args.k}, N={args.n}") + print( + f"GLU bprop shape: experts={args.experts}, " + f"tokens/expert={args.glu_bprop_tokens}, " + f"M={args.experts * args.glu_bprop_tokens}, K={args.k}, N={args.n}" + ) + print(f"dtype: {args.dtype}") + print(f"torch: {torch.__version__}") + print(f"transformer_engine: {package_version('transformer-engine')}") + print(f"nvidia-cudnn-frontend: {package_version('nvidia-cudnn-frontend')}") + print(f"nvidia-cutlass-dsl: {package_version('nvidia-cutlass-dsl')}") + + wrappers = { + "cuda": cuda, + "glu": grouped_gemm_glu_wrapper_sm100, + "srelu": grouped_gemm_srelu_wrapper_sm100, + "dsrelu": grouped_gemm_dsrelu_wrapper_sm100, + "dglu": grouped_gemm_dglu_wrapper_sm100, + } + activations = ACTIVATIONS if args.activation == "all" else (args.activation,) + + if args.functional_test or args.functional_only: + run_functional_tests( + activations=activations, + args=args, + tex=tex, + general_grouped_gemm=general_grouped_gemm, + wrappers=wrappers, + device=device, + ) + if args.functional_only: + return [] + + for tokens in sorted({benchmark_tokens_for_activation(args, activation) for activation in activations}): + check_dims(tokens, args.k, args.n) + print("timing mode: CUDA graph replay") + + results = [ + benchmark_activation( + activation=activation, + args=args, + tex=tex, + general_grouped_gemm=general_grouped_gemm, + wrappers=wrappers, + device=device, + ) + for activation in activations + ] + + if len(results) > 1: + print() + for line in format_summary(results, include_pytorch=args.include_pytorch_baseline): + print(line) + + return results + + +def main() -> None: + parser = argparse.ArgumentParser() + parser.add_argument("--activation", choices=("all",) + ACTIVATIONS, default="all") + parser.add_argument("--experts", type=int, default=8) + parser.add_argument("--tokens", type=int, default=4096, help="tokens per expert") + parser.add_argument( + "--glu-bprop-tokens", + type=int, + default=None, + help="tokens per expert for dswiglu/dgeglu; use half of --tokens for paired GLU bprop", + ) + parser.add_argument("--k", type=int, default=8192, help="input / gradient hidden size") + parser.add_argument("--n", type=int, default=4096, help="activation output hidden size") + parser.add_argument("--dtype", type=parse_dtype, default=torch.bfloat16) + parser.add_argument("--warmup", type=int, default=10) + parser.add_argument("--iters", type=int, default=20) + parser.add_argument("--samples", type=int, default=5) + parser.add_argument("--seed", type=int, default=1234) + parser.add_argument("--device", type=int, default=0) + parser.add_argument("--no-dynamic-sched", action="store_true") + parser.add_argument( + "--include-pytorch-baseline", + action="store_true", + help="also time the TE GEMM + PyTorch pointwise baseline", + ) + parser.add_argument( + "--functional-test", + action="store_true", + help="run small execution/shape/dtype tests before benchmarking", + ) + parser.add_argument( + "--functional-only", + action="store_true", + help="run only the functional tests and skip timing", + ) + parser.add_argument("--functional-experts", type=int, default=2) + parser.add_argument("--functional-tokens", type=int, default=256) + parser.add_argument("--functional-k", type=int, default=128) + parser.add_argument("--functional-n", type=int, default=256) + parser.add_argument("--functional-atol", type=float, default=0.5) + parser.add_argument("--functional-rtol", type=float, default=0.5) + parser.add_argument( + "--functional-reference-backend", + choices=("torch_compile", "torch"), + default="torch", + help="reference backend for cuDNN-specific GeGLU/DGeGLU functional checks", + ) + parser.add_argument( + "--output-dir", + type=str, + default=None, + help=( + "if set, write output_verbose.txt (full stdout), output.txt (device/version/" + "dtype/shape/summary), and results.png (summary table) to this directory" + ), + ) + args = parser.parse_args() + + if args.output_dir is None: + run_benchmarks(args) + return + + os.makedirs(args.output_dir, exist_ok=True) + buffer = io.StringIO() + original_stdout = sys.stdout + sys.stdout = _Tee(original_stdout, buffer) + try: + results = run_benchmarks(args) + finally: + sys.stdout = original_stdout + + write_output_files( + output_dir=args.output_dir, + verbose_text=buffer.getvalue(), + results=results, + args=args, + ) + + +if __name__ == "__main__": + main() diff --git a/benchmark/cutedsl_fusion_kernels/results/B200/output.txt b/benchmark/cutedsl_fusion_kernels/results/B200/output.txt new file mode 100644 index 000000000..eec7c8195 --- /dev/null +++ b/benchmark/cutedsl_fusion_kernels/results/B200/output.txt @@ -0,0 +1,16 @@ +device: NVIDIA GB200 +shape: experts=8, tokens/expert=4096, M=32768, K=8192, N=4096 +dtype: torch.bfloat16 +torch: 2.12.0a0+5aff3928d8.nv26.05 +transformer_engine: 2.15.0+42b84005 +nvidia-cudnn-frontend: 1.23.0 +nvidia-cutlass-dsl: 4.4.1 + +summary: +activation cudnn_ms te_ms te/cudnn +swiglu 1.550 1.934 1.25x +dswiglu 0.870 1.734 1.99x +srelu 0.739 1.041 1.41x +dsrelu 0.781 1.341 1.72x +geglu 1.544 1.890 1.22x +dgeglu 0.889 1.820 2.05x diff --git a/benchmark/cutedsl_fusion_kernels/results/B200/output_verbose.txt b/benchmark/cutedsl_fusion_kernels/results/B200/output_verbose.txt new file mode 100644 index 000000000..f3c7abdec --- /dev/null +++ b/benchmark/cutedsl_fusion_kernels/results/B200/output_verbose.txt @@ -0,0 +1,71 @@ +device: NVIDIA GB200 +shape: experts=8, tokens/expert=4096, M=32768, K=8192, N=4096 +dtype: torch.bfloat16 +torch: 2.12.0a0+5aff3928d8.nv26.05 +transformer_engine: 2.15.0+42b84005 +nvidia-cudnn-frontend: 1.23.0 +nvidia-cutlass-dsl: 4.4.1 +timing mode: CUDA graph replay + +activation: swiglu +shape: experts=8, tokens/expert=4096, M=32768, K=8192, N=4096 +fused GEMM N=8192, fused C input N=None, activation output N=4096 +fused cuDNN avg: 1.550 ms +unfused TE avg: 1.934 ms +speedup vs TE: 1.25x +fused samples: [1.357, 1.425, 1.64, 1.667, 1.663] +TE samples: [2.212, 1.937, 1.814, 1.839, 1.869] + +activation: dswiglu +shape: experts=8, tokens/expert=4096, M=32768, K=8192, N=4096 +fused GEMM N=4096, fused C input N=8192, activation output N=8192 +fused cuDNN avg: 0.870 ms +unfused TE avg: 1.734 ms +speedup vs TE: 1.99x +fused samples: [0.806, 0.806, 0.793, 0.963, 0.98] +TE samples: [2.254, 1.639, 1.626, 1.579, 1.571] + +activation: srelu +shape: experts=8, tokens/expert=4096, M=32768, K=8192, N=4096 +fused GEMM N=4096, fused C input N=None, activation output N=4096 +fused cuDNN avg: 0.739 ms +unfused TE avg: 1.041 ms +speedup vs TE: 1.41x +fused samples: [0.721, 0.718, 0.718, 0.734, 0.803] +TE samples: [1.1, 1.107, 1.023, 1.008, 0.97] + +activation: dsrelu +shape: experts=8, tokens/expert=4096, M=32768, K=8192, N=4096 +fused GEMM N=4096, fused C input N=4096, activation output N=4096 +fused cuDNN avg: 0.781 ms +unfused TE avg: 1.341 ms +speedup vs TE: 1.72x +fused samples: [0.731, 0.729, 0.73, 0.848, 0.866] +TE samples: [1.539, 1.386, 1.27, 1.265, 1.243] + +activation: geglu +shape: experts=8, tokens/expert=4096, M=32768, K=8192, N=4096 +fused GEMM N=8192, fused C input N=None, activation output N=4096 +fused cuDNN avg: 1.544 ms +unfused TE avg: 1.890 ms +speedup vs TE: 1.22x +fused samples: [1.358, 1.523, 1.6, 1.647, 1.595] +TE samples: [2.036, 1.827, 1.842, 1.87, 1.874] + +activation: dgeglu +shape: experts=8, tokens/expert=4096, M=32768, K=8192, N=4096 +fused GEMM N=4096, fused C input N=8192, activation output N=8192 +fused cuDNN avg: 0.889 ms +unfused TE avg: 1.820 ms +speedup vs TE: 2.05x +fused samples: [0.8, 0.795, 0.896, 0.951, 1.003] +TE samples: [2.369, 1.717, 1.668, 1.702, 1.644] + +summary: +activation cudnn_ms te_ms te/cudnn +swiglu 1.550 1.934 1.25x +dswiglu 0.870 1.734 1.99x +srelu 0.739 1.041 1.41x +dsrelu 0.781 1.341 1.72x +geglu 1.544 1.890 1.22x +dgeglu 0.889 1.820 2.05x diff --git a/benchmark/cutedsl_fusion_kernels/results/B200/results.png b/benchmark/cutedsl_fusion_kernels/results/B200/results.png new file mode 100644 index 0000000000000000000000000000000000000000..36795201babdbd5db7a4d163629fa429bd34fb2f GIT binary patch literal 176022 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 Ae*gdg literal 0 HcmV?d00001 diff --git a/benchmark/cutedsl_fusion_kernels/results/B300/output.txt b/benchmark/cutedsl_fusion_kernels/results/B300/output.txt new file mode 100644 index 000000000..4ebfb6cab --- /dev/null +++ b/benchmark/cutedsl_fusion_kernels/results/B300/output.txt @@ -0,0 +1,16 @@ +device: NVIDIA GB300 +shape: experts=8, tokens/expert=4096, M=32768, K=8192, N=4096 +dtype: torch.bfloat16 +torch: 2.12.0a0+5aff3928d8.nv26.05 +transformer_engine: 2.15.0+42b84005 +nvidia-cudnn-frontend: 1.23.0 +nvidia-cutlass-dsl: 4.4.1 + +summary: +activation cudnn_ms te_ms te/cudnn +swiglu 1.319 1.695 1.28x +dswiglu 0.740 1.549 2.09x +srelu 0.675 0.873 1.29x +dsrelu 0.686 1.163 1.70x +geglu 1.317 1.631 1.24x +dgeglu 0.751 1.666 2.22x diff --git a/benchmark/cutedsl_fusion_kernels/results/B300/output_verbose.txt b/benchmark/cutedsl_fusion_kernels/results/B300/output_verbose.txt new file mode 100644 index 000000000..b19d83aab --- /dev/null +++ b/benchmark/cutedsl_fusion_kernels/results/B300/output_verbose.txt @@ -0,0 +1,71 @@ +device: NVIDIA GB300 +shape: experts=8, tokens/expert=4096, M=32768, K=8192, N=4096 +dtype: torch.bfloat16 +torch: 2.12.0a0+5aff3928d8.nv26.05 +transformer_engine: 2.15.0+42b84005 +nvidia-cudnn-frontend: 1.23.0 +nvidia-cutlass-dsl: 4.4.1 +timing mode: CUDA graph replay + +activation: swiglu +shape: experts=8, tokens/expert=4096, M=32768, K=8192, N=4096 +fused GEMM N=8192, fused C input N=None, activation output N=4096 +fused cuDNN avg: 1.319 ms +unfused TE avg: 1.695 ms +speedup vs TE: 1.28x +fused samples: [1.233, 1.243, 1.374, 1.378, 1.369] +TE samples: [1.82, 1.612, 1.603, 1.703, 1.738] + +activation: dswiglu +shape: experts=8, tokens/expert=4096, M=32768, K=8192, N=4096 +fused GEMM N=4096, fused C input N=8192, activation output N=8192 +fused cuDNN avg: 0.740 ms +unfused TE avg: 1.549 ms +speedup vs TE: 2.09x +fused samples: [0.71, 0.716, 0.718, 0.763, 0.793] +TE samples: [1.856, 1.512, 1.464, 1.457, 1.454] + +activation: srelu +shape: experts=8, tokens/expert=4096, M=32768, K=8192, N=4096 +fused GEMM N=4096, fused C input N=None, activation output N=4096 +fused cuDNN avg: 0.675 ms +unfused TE avg: 0.873 ms +speedup vs TE: 1.29x +fused samples: [0.653, 0.654, 0.686, 0.677, 0.705] +TE samples: [0.942, 0.921, 0.85, 0.842, 0.811] + +activation: dsrelu +shape: experts=8, tokens/expert=4096, M=32768, K=8192, N=4096 +fused GEMM N=4096, fused C input N=4096, activation output N=4096 +fused cuDNN avg: 0.686 ms +unfused TE avg: 1.163 ms +speedup vs TE: 1.70x +fused samples: [0.659, 0.666, 0.677, 0.688, 0.743] +TE samples: [1.343, 1.167, 1.116, 1.096, 1.096] + +activation: geglu +shape: experts=8, tokens/expert=4096, M=32768, K=8192, N=4096 +fused GEMM N=8192, fused C input N=None, activation output N=4096 +fused cuDNN avg: 1.317 ms +unfused TE avg: 1.631 ms +speedup vs TE: 1.24x +fused samples: [1.231, 1.245, 1.344, 1.376, 1.389] +TE samples: [1.735, 1.626, 1.58, 1.65, 1.565] + +activation: dgeglu +shape: experts=8, tokens/expert=4096, M=32768, K=8192, N=4096 +fused GEMM N=4096, fused C input N=8192, activation output N=8192 +fused cuDNN avg: 0.751 ms +unfused TE avg: 1.666 ms +speedup vs TE: 2.22x +fused samples: [0.716, 0.717, 0.75, 0.774, 0.795] +TE samples: [2.058, 1.595, 1.569, 1.557, 1.553] + +summary: +activation cudnn_ms te_ms te/cudnn +swiglu 1.319 1.695 1.28x +dswiglu 0.740 1.549 2.09x +srelu 0.675 0.873 1.29x +dsrelu 0.686 1.163 1.70x +geglu 1.317 1.631 1.24x +dgeglu 0.751 1.666 2.22x diff --git a/benchmark/cutedsl_fusion_kernels/results/B300/results.png b/benchmark/cutedsl_fusion_kernels/results/B300/results.png new file mode 100644 index 0000000000000000000000000000000000000000..178841447d66fd7e3a99903a08526e07bb6c9091 GIT binary patch literal 176796 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ⅇ`s=eYodkqh*0Q4CyN6Mx8(;MGBt2#*8JIOiS6y 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 F{{<2JI|Tp$ literal 0 HcmV?d00001

r>d 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