leavelet/cutlass
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity
Files
291300ffffa3533a78ee104f08a8490a29ce9ccb
cutlass/examples/python/CuTeDSL/blackwell/sm103_dense_blockscaled_gemm_persistent.py
Junkai-Wu d4bbf728ca v4.4 tag release update. (#3032)
2026-02-13 23:27:58 -05:00

3040 lines
118 KiB
Python
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
# Copyright (c) 2025 - 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
# SPDX-License-Identifier: BSD-3-Clause
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions are met:
#
# 1. Redistributions of source code must retain the above copyright notice, this
# list of conditions and the following disclaimer.
#
# 2. Redistributions in binary form must reproduce the above copyright notice,
# this list of conditions and the following disclaimer in the documentation
# and/or other materials provided with the distribution.
#
# 3. Neither the name of the copyright holder nor the names of its
# contributors may be used to endorse or promote products derived from
# this software without specific prior written permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
import argparse
from typing import Optional, Type, Tuple, Union
import cuda.bindings.driver as cuda
import cutlass
import cutlass.cute as cute
from cutlass.cute.nvgpu import cpasync, tcgen05
import cutlass.utils as utils
import cutlass.pipeline as pipeline
from cutlass.pipeline import pipeline_init_arrive, pipeline_init_wait
import cutlass.utils.blackwell_helpers as sm103_utils
import cutlass.utils.blockscaled_layout as blockscaled_utils
from cutlass.cute.runtime import from_dlpack
from dataclasses import dataclass, field
"""
This example provides an experimental implementation of the SM103 batched 3xFP4 blockscaled GEMM kernel, please note that the APIs and implementation details related to this kernel may change in future releases.
A high-performance persistent batched 3xFP4 blockscaled GEMM example for the NVIDIA Blackwell SM103 architecture
using CUTE DSL.
- Matrix A is MxKxL, L is batch dimension, A can only be row-major("K") for MXF4/NVF4 input type
- Matrix B is NxKxL, L is batch dimension, B can only be row-major("K") for MXF4/NVF4 input type
- Matrix C is MxNxL, L is batch dimension, C can be row-major("N") or column-major("M")
- Matrix SFA layout is filled internally according to A shape and sm103_BlockScaledBasicChunk, which has M×ceil_div(K, sf_vec_size)×L elements respectively
- Matrix SFB layout is filled internally according to B shape and sm103_BlockScaledBasicChunk, which has N×ceil_div(K, sf_vec_size)×L elements respectively
This GEMM kernel supports the following features:
- Utilizes Tensor Memory Access (TMA) for efficient memory operations
- Utilizes Blackwell's tcgen05.mma for matrix multiply-accumulate (MMA) operations (including 2cta mma instructions)
- Implements TMA multicast with cluster to reduce L2 memory traffic
- Support persistent tile scheduling to better overlap memory load/store with mma between tiles
- Support warp specialization with separate TMA warps for A/B and scale factors
- Utilizes circular buffer technique for optimal memory and computation overlap
This GEMM works as follows:
1. TMA A/B warp: Load A and B matrices from global memory (GMEM) to shared memory (SMEM) using TMA operations.
2. TMA SF warp: Load scale factor A/B from global memory (GMEM) to shared memory (SMEM) using TMA operations.
3. MMA warp:
- Load scale factor A/B from shared memory (SMEM) to tensor memory (TMEM) using tcgen05.cp instruction.
- Perform matrix multiply-accumulate (MMA) operations using tcgen05.mma instruction to deal with circular buffering.
4. Epilogue warps:
- Load completed accumulator from tensor memory (TMEM) to registers (RMEM) using tcgen05.ld.
- Type convert C matrix to output type.
- Store C matrix directly from registers (RMEM) to global memory (GMEM) without TMA operations.
- Optionally accept an elementwise lambda function epilogue_op to apply to the output tensor:
e.g., relu can set epilogue_op = lambda x: cute.where(x > 0, x, cute.full_like(x, 0))
SM103 tcgen05.mma.kind.block_scale instructions operate as follows:
- Read matrix A from two SMEM buffers(current buffer and next buffer)
- Read matrix B from two SMEM buffers(current buffer and next buffer)
- Read scalefactor A from TMEM
- Read scalefactor B from TMEM
- Write accumulator to TMEM
The accumulator in TMEM must then be loaded to registers before writing back to GMEM.
Input arguments to this example is shown below:
.. code-block:: bash
python examples/blackwell/sm103_dense_blockscaled_gemm_persistent.py \
--ab_dtype Float4E2M1FN --sf_dtype Float8E8M0FNU --sf_vec_size 16 \
--c_dtype Float16 \
--mma_tiler_mn 256,256 --cluster_shape_mn 2,4 \
--mnkl 4096,4096,6144,1
To collect performance with NCU profiler:
.. code-block:: bash
ncu python examples/blackwell/sm103_dense_blockscaled_gemm_persistent.py \
--ab_dtype Float4E2M1FN --sf_dtype Float8E8M0FNU --sf_vec_size 16 \
--c_dtype Float16 \
--mma_tiler_mn 256,256 --cluster_shape_mn 2,4 \
--mnkl 4096,4096,6144,1 \
--warmup_iterations 1 --iterations 10 --skip_ref_check
Constraints:
- Supported input data types: mxf4, nvf4
- see detailed valid dtype combinations in below Sm103BlockScaledPersistentDenseGemmKernel class documentation
- A/B tensor must have the same data type
- Mma tiler M must be 128 or 256(use_2cta_instrs)
- Mma tiler N must be 128 or 256
- Cluster shape M/N must be positive and power of 2, total cluster size <= 16
- Cluster shape M must be multiple of 2 if Mma tiler M is 256(use_2cta_instrs)
- The contiguous dimension of A/B/C tensors must be at least 16 bytes aligned,
i.e, number of elements is a multiple of 32 for MXF4/NVF4.
"""
class Sm103BlockScaledPersistentDenseGemmKernel:
"""This class implements batched matrix multiplication (C = A x SFA x B x SFB) with support for FP4 data types
and architectural features specific to Blackwell SM103 GPUs with persistent tile scheduling and warp specialization.
:param sf_vec_size: Scalefactor vector size.
:type sf_vec_size: int
:param mma_tiler_mn: Shape of the Matrix Multiply-Accumulate (MMA) tile (M,N)
:type mma_tiler_mn: Tuple[int, int]
:param cluster_shape_mn: Cluster dimensions (M,N) for parallel processing
:type cluster_shape_mn: Tuple[int, int]
:note: In current version, A and B tensor must have the same data type
- i.e., Float4E2M1FN for A and Float4E2M1FN for B is not supported
:note: Supported combinations of A/B data types, SF data typs and SF vector size:
- MXF4: A/B: Float4E2M1FN + SF: Float8E8M0FNU + sf_vec_size: 32
- NVF4: A/B: Float4E2M1FN + SF: Float8E8M0FNU/Float8E4M3FN + sf_vec_size: 16
:note: Supported accumulator data types:
- Float32
:note: Supported C data types:
- Float32
- Float16/BFloat16
- Float8E4M3FN/Float8E5M2
:note: Constraints:
- MMA tiler M must be 128 or 256 (use_2cta_instrs)
- MMA tiler N must be 128/256
- Cluster shape M must be multiple of 2 if Mma tiler M is 256
- Cluster shape M/N must be positive and power of 2, total cluster size <= 16
- Cluster shape M/N must be <= 4 for scale factor multicasts due to limited size of scale factors
Example:
>>> gemm = Sm103BlockScaledPersistentDenseGemmKernel(
... sf_vec_size=16,
... mma_tiler_mn=(256, 256),
... cluster_shape_mn=(2, 4)
... )
>>> gemm(a_tensor, b_tensor, sfa_tensor, sfb_tensor, c_tensor, max_active_clusters, stream)
"""
def __init__(
self,
sf_vec_size: int,
mma_tiler_mn: Tuple[int, int],
cluster_shape_mn: Tuple[int, int],
use_tma_store: bool,
):
"""Initializes the configuration for a Blackwell SM103 3xFP4 GEMM kernel.
This configuration includes several key aspects:
1. MMA Instruction Settings (tcgen05):
- acc_dtype: Data types for MMA accumulator, always set to Float32
- sf_vec_size: Scalefactor A/B vector size.
- mma_tiler_mn: The (M, N) shape of the MMA instruction tiler.
2. Cluster Shape:
- cluster_shape_mn: The (ClusterM, ClusterN) shape of the CTA cluster.
:param sf_vec_size: Scalefactor vector size.
:type sf_vec_size: int
:param mma_tiler_mn: Tuple (M, N) shape of the MMA instruction.
:type mma_tiler_mn: Tuple[int, int]
:param cluster_shape_mn: Tuple (ClusterM, ClusterN) shape of the cluster.
:type cluster_shape_mn: Tuple[int, int]
:param use_tma_store: Whether TMA store is enabled.
:type use_tma_store: bool
"""
self.acc_dtype = cutlass.Float32
self.sf_vec_size = sf_vec_size
self.use_2cta_instrs = mma_tiler_mn[0] == 256
self.cluster_shape_mn = cluster_shape_mn
# K dimension is deferred in _setup_attributes
self.mma_tiler = (*mma_tiler_mn, 1)
self.use_tma_store = use_tma_store
self.cta_group = (
tcgen05.CtaGroup.TWO if self.use_2cta_instrs else tcgen05.CtaGroup.ONE
)
self.occupancy = 1
# Set specialized warp ids
self.epilogue_warp_id = (
0,
1,
2,
3,
)
self.mma_warp_id = 4
self.tma_ab_warp_id = 5
self.tma_sf_warp_id = 6
self.threads_per_cta = 32 * len(
(
self.mma_warp_id,
self.tma_ab_warp_id,
self.tma_sf_warp_id,
*self.epilogue_warp_id,
)
)
# Set barrier id for epilogue sync and tmem ptr sync
self.epilog_sync_bar_id = 1
self.tmem_alloc_sync_bar_id = 2
self.tmem_dealloc_sync_bar_id = 3
self.smem_capacity = utils.get_smem_capacity_in_bytes("sm_103")
self.num_tmem_alloc_cols = cute.arch.get_max_tmem_alloc_cols("sm_103")
self.sf_buffers_per_tile_k = 4 if self.sf_vec_size == 16 else 2
def _setup_attributes(self):
"""Set up kernel attributes that depend on runtime tensor inputs.
This method configures various attributes based on the input tensor properties
(data types, leading dimensions) and kernel settings:
- Configuring tiled MMA
- Computing MMA/cluster/tile shapes
- Computing cluster layout
- Computing multicast CTAs for A/B/SFA/SFB
- Computing epilogue subtile
- Setting up A/B/SFA/SFB/C stage counts in shared memory
- Computing A/B/SFA/SFB/C shared memory layout
"""
# Compute mma instruction shapes
# (MMA_Tile_Shape_M, MMA_Tile_Shape_N, MMA_Inst_Shape_K)
self.mma_inst_shape_mn = (self.mma_tiler[0], self.mma_tiler[1])
# (CTA_Tile_Shape_M, Round_Up(MMA_Tile_Shape_N, 128), MMA_Inst_Shape_K)
self.mma_inst_shape_mn_sfb = (
self.mma_inst_shape_mn[0] // (2 if self.use_2cta_instrs else 1),
cute.round_up(self.mma_inst_shape_mn[1], 128),
)
tiled_mma = self.sm103_make_blockscaled_trivial_tiled_mma(
self.sf_dtype,
self.sf_vec_size,
self.cta_group,
self.mma_inst_shape_mn,
)
dummy_tiled_mma_sfb = self.sm103_make_blockscaled_trivial_tiled_mma(
self.sf_dtype,
self.sf_vec_size,
tcgen05.CtaGroup.ONE,
self.mma_inst_shape_mn_sfb,
)
# Compute mma/cluster/tile shapes
self.mma_tiler = (
self.mma_inst_shape_mn[0],
self.mma_inst_shape_mn[1],
768,
)
self.cta_tile_shape_mnk = (
self.mma_tiler[0] // cute.size(tiled_mma.thr_layout_vmnk.shape[0]),
self.mma_tiler[1],
self.mma_tiler[2],
)
blk_mn = 128
self.cta_n_sf = cute.round_up(cute.size(self.cta_tile_shape_mnk[1]), blk_mn)
self.mma_sf_tiler = (
self.cta_tile_shape_mnk[0],
self.cta_n_sf,
self.cta_tile_shape_mnk[2] // self.sf_buffers_per_tile_k,
)
self.sf_atom = self.Sm103BlockScaledBasicChunk(
self.sf_vec_size, tiled_mma.op.a_major_mode
).layout
# Compute cluster layout
self.cluster_layout_vmnk = cute.tiled_divide(
cute.make_layout((*self.cluster_shape_mn, 1)),
(tiled_mma.thr_id.shape,),
)
self.cluster_layout_sfb_vmnk = cute.tiled_divide(
cute.make_layout((*self.cluster_shape_mn, 1)),
(dummy_tiled_mma_sfb.thr_id.shape,),
)
# Compute number of multicast CTAs for A/B
self.num_mcast_ctas_a = cute.size(self.cluster_layout_vmnk.shape[2])
self.num_mcast_ctas_b = cute.size(self.cluster_layout_vmnk.shape[1])
self.num_mcast_ctas_sfb = cute.size(self.cluster_layout_sfb_vmnk.shape[1])
self.is_a_mcast = self.num_mcast_ctas_a > 1
self.is_b_mcast = self.num_mcast_ctas_b > 1
self.is_sfb_mcast = self.num_mcast_ctas_sfb > 1
# Compute epilogue subtile
self.epi_tile = sm103_utils.compute_epilogue_tile_shape(
self.cta_tile_shape_mnk,
self.use_2cta_instrs,
self.c_layout,
self.c_dtype,
)
self.num_acc_stage, self.num_ab_stage, self.num_sf_stage, self.num_c_stage = (
self._compute_stages(
tiled_mma,
self.mma_tiler,
self.epi_tile,
self.c_dtype,
self.c_layout,
self.sf_dtype,
self.sf_vec_size,
self.smem_capacity,
self.occupancy,
self.use_tma_store,
)
)
# Compute A/B/SFA/SFB/C shared memory layout
# ((CTA_MMA_M,16bytes),1,8,num_ab_stage)
self.a_smem_layout_staged = self.sm103_make_smem_layout_a(
tiled_mma,
self.mma_tiler,
self.num_ab_stage,
)
# ((CTA_MMA_M,16bytes),1,8,3)
self.a_smem_layout_staged_tma = self.sm103_make_smem_layout_a(
tiled_mma,
self.mma_tiler,
3,
)
# ((CTA_MMA_N,16bytes),1,8,num_ab_stage)
self.b_smem_layout_staged = self.sm103_make_smem_layout_b(
tiled_mma,
self.mma_tiler,
self.num_ab_stage,
)
# ((CTA_MMA_N,16bytes),1,8,3)
self.b_smem_layout_staged_tma = self.sm103_make_smem_layout_b(
tiled_mma,
self.mma_tiler,
3,
)
# (((8,4,4),(sf_vec_size,4)),1,3,num_sf_stage)
self.sfa_smem_layout_staged = self.sm103_make_smem_layout_sfa(
tiled_mma,
self.mma_tiler,
self.sf_vec_size,
self.num_sf_stage,
)
# (((32,4,2),(sf_vec_size,4)),1,3,num_sf_stage)
self.sfb_smem_layout_staged = self.sm103_make_smem_layout_sfb(
tiled_mma,
self.mma_tiler,
self.sf_vec_size,
self.num_sf_stage,
)
self.c_smem_layout_staged = None
if self.use_tma_store:
self.c_smem_layout_staged = sm103_utils.make_smem_layout_epi(
self.c_dtype, self.c_layout, self.epi_tile, self.num_c_stage
)
# Overlap and double buffer accumulator when num_acc_stage == 1 for cta_tile_n = 256 case
self.overlapping_accum = self.num_acc_stage == 1 and not self.use_tma_store
self.epi_tile_n = cute.size(self.epi_tile[1])
if self.overlapping_accum:
# Compute SF TMEM column count from a scale factor layout.
# Column count = cosize of Int32-recast layout & 0xFFFF,
# mirroring the computation in find_tmem_tensor_col_offset.
def _sf_tmem_cols(make_tmem_layout_fn, smem_layout_staged):
layout = make_tmem_layout_fn(
tiled_mma,
self.mma_tiler,
self.sf_vec_size,
cute.slice_(smem_layout_staged, (None, None, None, 0)),
)
return (
cute.cosize(cute.recast_layout(32, self.sf_dtype.width, layout))
& 0xFFFF
)
self.num_sfa_tmem_cols = _sf_tmem_cols(
blockscaled_utils.make_tmem_layout_sfa, self.sfa_smem_layout_staged
)
self.num_sfb_tmem_cols = _sf_tmem_cols(
blockscaled_utils.make_tmem_layout_sfb, self.sfb_smem_layout_staged
)
self.num_sf_tmem_cols = self.num_sfa_tmem_cols + self.num_sfb_tmem_cols
# Release accumulator buffer early in epilogue when overlapping
self.iter_acc_early_release_in_epilogue = (
self.num_sf_tmem_cols // self.epi_tile_n
)
@cute.jit
def __call__(
self,
a_tensor: cute.Tensor,
b_tensor: cute.Tensor,
sfa_tensor: cute.Tensor,
sfb_tensor: cute.Tensor,
c_tensor: cute.Tensor,
max_active_clusters: cutlass.Constexpr,
stream: cuda.CUstream,
epilogue_op: cutlass.Constexpr = lambda x: x,
):
"""Execute the GEMM operation in steps:
- Setup static attributes before smem/grid/tma computation
- Setup TMA load/store atoms and tensors
- Compute grid size with regard to hardware constraints
- Define shared storage for kernel
- Launch the kernel synchronously
:param a_tensor: Input tensor A
:type a_tensor: cute.Tensor
:param b_tensor: Input tensor B
:type b_tensor: cute.Tensor
:param sfa_tensor: Scale factor tensor A
:type sfa_tensor: cute.Tensor
:param sfb_tensor: Scale factor tensor B
:type sfb_tensor: cute.Tensor
:param c_tensor: Output tensor C
:type c_tensor: cute.Tensor
:param max_active_clusters: Maximum number of active clusters
:type max_active_clusters: cutlass.Constexpr
:param stream: CUDA stream for asynchronous execution
:type stream: cuda.CUstream
:param epilogue_op: Optional elementwise lambda function to apply to the output tensor
:type epilogue_op: cutlass.Constexpr
:raises TypeError: If input data types are incompatible with the MMA instruction.
"""
# Setup static attributes before smem/grid/tma computation
self.a_dtype: Type[cutlass.Numeric] = a_tensor.element_type
self.b_dtype: Type[cutlass.Numeric] = b_tensor.element_type
self.sf_dtype: Type[cutlass.Numeric] = sfa_tensor.element_type
self.c_dtype: Type[cutlass.Numeric] = c_tensor.element_type
self.a_major_mode = utils.LayoutEnum.from_tensor(a_tensor).mma_major_mode()
self.b_major_mode = utils.LayoutEnum.from_tensor(b_tensor).mma_major_mode()
self.c_layout = utils.LayoutEnum.from_tensor(c_tensor)
# Check if input data types are compatible with MMA instruction
if cutlass.const_expr(self.a_dtype != self.b_dtype):
raise TypeError(f"Type must match: {self.a_dtype} != {self.b_dtype}")
# Setup attributes that dependent on gemm inputs
self._setup_attributes()
# Setup sfa/sfb tensor by filling A/B tensor to scale factor atom layout
sfa_layout = cute.tile_to_shape(self.sf_atom, a_tensor.shape, (2, 1, 3))
sfa_tensor = cute.make_tensor(sfa_tensor.iterator, sfa_layout)
sfb_layout = cute.tile_to_shape(self.sf_atom, b_tensor.shape, (2, 1, 3))
sfb_tensor = cute.make_tensor(sfb_tensor.iterator, sfb_layout)
tiled_mma = self.sm103_make_blockscaled_trivial_tiled_mma(
self.sf_dtype,
self.sf_vec_size,
self.cta_group,
self.mma_inst_shape_mn,
)
dummy_tiled_mma_sfb = self.sm103_make_blockscaled_trivial_tiled_mma(
self.sf_dtype,
self.sf_vec_size,
tcgen05.CtaGroup.ONE,
self.mma_inst_shape_mn_sfb,
)
atom_thr_size = cute.size(tiled_mma.thr_id.shape)
# Setup TMA load for A
a_op = sm103_utils.cluster_shape_to_tma_atom_A(
self.cluster_shape_mn, tiled_mma.thr_id
)
# casting layout as uint8 for multicast
a_smem_layout_tma_ready = self.adapt_layout_for_tma_ab(
self.a_smem_layout_staged_tma
)
a_tensor_uint8 = cute.recast_tensor(a_tensor, cutlass.Uint8)
tma_atom_a, tma_tensor_a = cute.nvgpu.cpasync.make_tiled_tma_atom(
a_op,
a_tensor_uint8,
a_smem_layout_tma_ready,
# 384 corresponds to the number of uint8 elements along the K dimension processed in a single MMA mainloop iteration.
(cute.size(tiled_mma.tv_layout_A[1][0]), 384),
self.cluster_shape_mn[1],
internal_type=cutlass.Uint8,
)
# Setup TMA load for B
b_op = sm103_utils.cluster_shape_to_tma_atom_B(
self.cluster_shape_mn, tiled_mma.thr_id
)
# casting layout as uint8 for multicast
b_smem_layout_tma_ready = self.adapt_layout_for_tma_ab(
self.b_smem_layout_staged_tma
)
b_tensor_uint8 = cute.recast_tensor(b_tensor, cutlass.Uint8)
tma_atom_b, tma_tensor_b = cute.nvgpu.cpasync.make_tiled_tma_atom(
b_op,
b_tensor_uint8,
b_smem_layout_tma_ready,
(cute.size(tiled_mma.tv_layout_B[1][0]), 384),
self.cluster_shape_mn[0] // cute.size(tiled_mma.thr_id.shape),
internal_type=cutlass.Uint8,
)
# Setup TMA load for SFA
sfa_op = sm103_utils.cluster_shape_to_tma_atom_A(
self.cluster_shape_mn, tiled_mma.thr_id
)
sfa_smem_layout = cute.slice_(
self.sfa_smem_layout_staged, (None, None, None, 0)
)
sfa_smem_layout_tma_ready = self.adapt_layout_for_tma_sf(sfa_smem_layout)
tma_atom_sfa, tma_tensor_sfa = cute.nvgpu.cpasync.make_tiled_tma_atom(
sfa_op,
sfa_tensor,
sfa_smem_layout_tma_ready,
(self.mma_sf_tiler[0], self.mma_sf_tiler[2]),
self.cluster_shape_mn[1],
internal_type=cutlass.Uint8,
)
# Setup TMA load for SFB
sfb_op = sm103_utils.cluster_shape_to_tma_atom_SFB(
self.cluster_shape_mn, tiled_mma.thr_id
)
sfb_smem_layout = cute.slice_(
self.sfb_smem_layout_staged, (None, None, None, 0)
)
sfb_smem_layout_tma_ready = self.adapt_layout_for_tma_sf(sfb_smem_layout)
tma_atom_sfb, tma_tensor_sfb = cute.nvgpu.cpasync.make_tiled_tma_atom(
sfb_op,
sfb_tensor,
sfb_smem_layout_tma_ready,
(self.mma_sf_tiler[1], self.mma_sf_tiler[2]),
self.cluster_shape_mn[0] // cute.size(dummy_tiled_mma_sfb.thr_id),
internal_type=cutlass.Uint8,
)
# Setup TMA store for C
tma_atom_c = None
tma_tensor_c = None
if cutlass.const_expr(self.use_tma_store):
epi_smem_layout = cute.slice_(self.c_smem_layout_staged, (None, None, 0))
tma_atom_c, tma_tensor_c = cpasync.make_tiled_tma_atom(
cpasync.CopyBulkTensorTileS2GOp(),
c_tensor,
epi_smem_layout,
self.epi_tile,
)
a_copy_size = cute.size_in_bytes(
cutlass.Uint8,
cute.slice_(self.a_smem_layout_staged_tma, (None, None, None, 0)),
)
b_copy_size = cute.size_in_bytes(
cutlass.Uint8,
cute.slice_(self.b_smem_layout_staged_tma, (None, None, None, 0)),
)
sfa_copy_size = cute.size_in_bytes(
cutlass.Uint8,
cute.slice_(self.sfa_smem_layout_staged, (None, None, None, 0)),
)
sfb_copy_size = cute.size_in_bytes(
cutlass.Uint8,
cute.slice_(self.sfb_smem_layout_staged, (None, None, None, 0)),
)
self.num_tma_load_bytes_ab = (a_copy_size + b_copy_size) * atom_thr_size
self.num_tma_load_bytes_sf = (sfa_copy_size + sfb_copy_size) * atom_thr_size
# Compute grid size
self.tile_sched_params, grid = self._compute_grid(
c_tensor,
self.cta_tile_shape_mnk,
self.cluster_shape_mn,
max_active_clusters,
)
self.buffer_align_bytes = 1024
# Define shared storage for kernel
@cute.struct
class SharedStorage:
ab_full_mbar_ptr: cute.struct.MemRange[cutlass.Int64, self.num_ab_stage]
ab_empty_mbar_ptr: cute.struct.MemRange[cutlass.Int64, self.num_ab_stage]
sf_full_mbar_ptr: cute.struct.MemRange[cutlass.Int64, self.num_sf_stage]
sf_empty_mbar_ptr: cute.struct.MemRange[cutlass.Int64, self.num_sf_stage]
acc_full_mbar_ptr: cute.struct.MemRange[cutlass.Int64, self.num_acc_stage]
acc_empty_mbar_ptr: cute.struct.MemRange[cutlass.Int64, self.num_acc_stage]
tmem_dealloc_mbar_ptr: cutlass.Int64
tmem_holding_buf: cutlass.Int32
# (MMA, MMA_M, MMA_K, STAGE)
sA: cute.struct.Align[
cute.struct.MemRange[
cutlass.Uint8, cute.cosize(self.a_smem_layout_staged.outer)
],
self.buffer_align_bytes,
]
# (MMA, MMA_N, MMA_K, STAGE)
sB: cute.struct.Align[
cute.struct.MemRange[
cutlass.Uint8, cute.cosize(self.b_smem_layout_staged.outer)
],
self.buffer_align_bytes,
]
# (MMA, MMA_M, MMA_K, STAGE)
sSFA: cute.struct.Align[
cute.struct.MemRange[
cutlass.Uint8, cute.cosize(self.sfa_smem_layout_staged)
],
self.buffer_align_bytes,
]
# (MMA, MMA_N, MMA_K, STAGE)
sSFB: cute.struct.Align[
cute.struct.MemRange[
cutlass.Uint8, cute.cosize(self.sfb_smem_layout_staged)
],
self.buffer_align_bytes,
]
self.shared_storage = SharedStorage
# Launch the kernel synchronously
self.kernel(
tiled_mma,
tma_atom_a,
tma_tensor_a,
tma_atom_b,
tma_tensor_b,
tma_atom_sfa,
tma_tensor_sfa,
tma_atom_sfb,
tma_tensor_sfb,
tma_atom_c,
tma_tensor_c if self.use_tma_store else c_tensor,
self.cluster_layout_vmnk,
self.cluster_layout_sfb_vmnk,
self.a_smem_layout_staged,
self.b_smem_layout_staged,
self.sfa_smem_layout_staged,
self.sfb_smem_layout_staged,
self.c_smem_layout_staged,
self.epi_tile,
self.tile_sched_params,
epilogue_op,
).launch(
grid=grid,
block=[self.threads_per_cta, 1, 1],
cluster=(*self.cluster_shape_mn, 1),
stream=stream,
min_blocks_per_mp=1,
)
return
# GPU device kernel
@cute.kernel
def kernel(
self,
tiled_mma: cute.TiledMma,
tma_atom_a: cute.CopyAtom,
mA_mkl: cute.Tensor,
tma_atom_b: cute.CopyAtom,
mB_nkl: cute.Tensor,
tma_atom_sfa: cute.CopyAtom,
mSFA_mkl: cute.Tensor,
tma_atom_sfb: cute.CopyAtom,
mSFB_nkl: cute.Tensor,
tma_atom_c: cute.CopyAtom,
mC_mnl: cute.Tensor,
cluster_layout_vmnk: cute.Layout,
cluster_layout_sfb_vmnk: cute.Layout,
a_smem_layout_staged: cute.ComposedLayout,
b_smem_layout_staged: cute.ComposedLayout,
sfa_smem_layout_staged: cute.Layout,
sfb_smem_layout_staged: cute.Layout,
c_smem_layout_staged: Union[cute.Layout, cute.ComposedLayout, None],
epi_tile: cute.Tile,
tile_sched_params: utils.PersistentTileSchedulerParams,
epilogue_op: cutlass.Constexpr,
):
"""
GPU device kernel performing the Persistent batched GEMM computation.
"""
warp_idx = cute.arch.warp_idx()
warp_idx = cute.arch.make_warp_uniform(warp_idx)
#
# Prefetch tma desc
#
if warp_idx == self.tma_ab_warp_id:
cpasync.prefetch_descriptor(tma_atom_a)
cpasync.prefetch_descriptor(tma_atom_b)
if cutlass.const_expr(self.use_tma_store):
cpasync.prefetch_descriptor(tma_atom_c)
if warp_idx == self.tma_sf_warp_id:
cpasync.prefetch_descriptor(tma_atom_sfa)
cpasync.prefetch_descriptor(tma_atom_sfb)
use_2cta_instrs = cute.size(tiled_mma.thr_id.shape) == 2
#
# Setup cta/thread coordinates
#
# Coords inside cluster
bidx, bidy, bidz = cute.arch.block_idx()
mma_tile_coord_v = bidx % cute.size(tiled_mma.thr_id.shape)
is_leader_cta = mma_tile_coord_v == 0
cta_rank_in_cluster = cute.arch.make_warp_uniform(
cute.arch.block_idx_in_cluster()
)
block_in_cluster_coord_vmnk = cluster_layout_vmnk.get_flat_coord(
cta_rank_in_cluster
)
block_in_cluster_coord_sfb_vmnk = cluster_layout_sfb_vmnk.get_flat_coord(
cta_rank_in_cluster
)
# Coord inside cta
tidx, _, _ = cute.arch.thread_idx()
#
# Alloc and init: a+b full/empty, sfa+sfb full/empty, accumulator full/empty, tensor memory dealloc barrier
#
smem = utils.SmemAllocator()
storage = smem.allocate(self.shared_storage)
# Initialize mainloop ab_producer and ab_consumer
ab_producer_group = pipeline.CooperativeGroup(pipeline.Agent.Thread)
num_tma_producer = self.num_mcast_ctas_a + self.num_mcast_ctas_b - 1
ab_consumer_group = pipeline.CooperativeGroup(
pipeline.Agent.Thread, num_tma_producer
)
ab_producer, ab_consumer = pipeline.PipelineTmaUmma.create(
barrier_storage=storage.ab_full_mbar_ptr.data_ptr(),
num_stages=self.num_ab_stage,
producer_group=ab_producer_group,
consumer_group=ab_consumer_group,
tx_count=self.num_tma_load_bytes_ab,
cta_layout_vmnk=cluster_layout_vmnk,
defer_sync=True,
).make_participants()
# Initialize mainloop sf_producer and sf_consumer
sf_producer_group = pipeline.CooperativeGroup(pipeline.Agent.Thread)
num_sf_tma_producer = self.num_mcast_ctas_a + self.num_mcast_ctas_b - 1
sf_consumer_group = pipeline.CooperativeGroup(
pipeline.Agent.Thread, num_sf_tma_producer
)
sf_producer, sf_consumer = pipeline.PipelineTmaUmma.create(
barrier_storage=storage.sf_full_mbar_ptr.data_ptr(),
num_stages=self.num_sf_stage,
producer_group=sf_producer_group,
consumer_group=sf_consumer_group,
tx_count=self.num_tma_load_bytes_sf,
cta_layout_vmnk=cluster_layout_vmnk,
defer_sync=True,
).make_participants()
# Initialize acc_pipeline (barrier) and states
acc_pipeline_producer_group = pipeline.CooperativeGroup(pipeline.Agent.Thread)
num_acc_consumer_threads = len(self.epilogue_warp_id) * (
2 if use_2cta_instrs else 1
)
acc_pipeline_consumer_group = pipeline.CooperativeGroup(
pipeline.Agent.Thread, num_acc_consumer_threads
)
acc_pipeline = pipeline.PipelineUmmaAsync.create(
barrier_storage=storage.acc_full_mbar_ptr.data_ptr(),
num_stages=self.num_acc_stage,
producer_group=acc_pipeline_producer_group,
consumer_group=acc_pipeline_consumer_group,
cta_layout_vmnk=cluster_layout_vmnk,
defer_sync=True,
)
tmem_alloc_barrier = pipeline.NamedBarrier(
barrier_id=self.tmem_alloc_sync_bar_id,
num_threads=32 * len((self.mma_warp_id, *self.epilogue_warp_id)),
)
tmem_dealloc_barrier = None
if cutlass.const_expr(not self.use_tma_store):
tmem_dealloc_barrier = pipeline.NamedBarrier(
barrier_id=self.tmem_dealloc_sync_bar_id,
num_threads=32 * len(self.epilogue_warp_id),
)
# Tensor memory dealloc barrier init
tmem = utils.TmemAllocator(
storage.tmem_holding_buf,
barrier_for_retrieve=tmem_alloc_barrier,
allocator_warp_id=self.epilogue_warp_id[0],
is_two_cta=use_2cta_instrs,
two_cta_tmem_dealloc_mbar_ptr=storage.tmem_dealloc_mbar_ptr,
)
# Cluster arrive after barrier init
pipeline_init_arrive(cluster_shape_mn=self.cluster_shape_mn, is_relaxed=True)
#
# Setup smem tensor A/B/SFA/SFB/C
#
sA = storage.sA.get_tensor(
a_smem_layout_staged.outer, swizzle=a_smem_layout_staged.inner
)
sB = storage.sB.get_tensor(
b_smem_layout_staged.outer, swizzle=b_smem_layout_staged.inner
)
sSFA = storage.sSFA.get_tensor(sfa_smem_layout_staged)
sSFB = storage.sSFB.get_tensor(sfb_smem_layout_staged)
#
# Compute multicast mask for A/B/SFA/SFB buffer full
#
a_full_mcast_mask = None
b_full_mcast_mask = None
sfa_full_mcast_mask = None
sfb_full_mcast_mask = None
if cutlass.const_expr(self.is_a_mcast or self.is_b_mcast or use_2cta_instrs):
a_full_mcast_mask = cpasync.create_tma_multicast_mask(
cluster_layout_vmnk, block_in_cluster_coord_vmnk, mcast_mode=2
)
b_full_mcast_mask = cpasync.create_tma_multicast_mask(
cluster_layout_vmnk, block_in_cluster_coord_vmnk, mcast_mode=1
)
sfa_full_mcast_mask = cpasync.create_tma_multicast_mask(
cluster_layout_vmnk, block_in_cluster_coord_vmnk, mcast_mode=2
)
sfb_full_mcast_mask = cpasync.create_tma_multicast_mask(
cluster_layout_sfb_vmnk, block_in_cluster_coord_sfb_vmnk, mcast_mode=1
)
#
# Local_tile partition global tensors
#
# (BLK_M, BLK_K, m, k, l)
gA_mkl = cute.local_tile(
mA_mkl,
cute.slice_((self.mma_tiler[0], self.mma_tiler[1], 384), (None, 0, None)),
(None, None, None),
)
# (BLK_N, BLK_K, n, k, l)
gB_nkl = cute.local_tile(
mB_nkl,
cute.slice_((self.mma_tiler[0], self.mma_tiler[1], 384), (0, None, None)),
(None, None, None),
)
gSFA_mkl = cute.local_tile(
mSFA_mkl,
cute.slice_(self.mma_sf_tiler, (None, 0, None)),
(None, None, None),
)
gSFB_nkl = cute.local_tile(
mSFB_nkl,
cute.slice_(self.mma_sf_tiler, (0, None, None)),
(None, None, None),
)
gC_mnl = cute.local_tile(
mC_mnl, cute.slice_(self.mma_tiler, (None, None, 0)), (None, None, None)
)
k_tile_cnt = cute.size(gA_mkl, mode=[3])
#
# Partition global tensor for TiledMMA_A/B/C
#
thr_mma = tiled_mma.get_slice(mma_tile_coord_v)
# create tCgA_tmp
tCgA_mkl_tmp = thr_mma.partition_A(gA_mkl)
tCgA_layout = self.append_coalesce_layout(tCgA_mkl_tmp.layout)
cta_tCgA = cute.make_tensor(tCgA_mkl_tmp.iterator, tCgA_layout)
# ((CTA_MMA_M,256),Rest_MMA_M,Rest_MMA_K, m, k, l)
tCgA = cute.make_tensor(
cta_tCgA.iterator,
cute.tiled_divide(
cta_tCgA.layout, (cute.size(tiled_mma.tv_layout_A[1][0]), 128)
),
)
tCgB_nkl_tmp = thr_mma.partition_B(gB_nkl)
tCgB_layout = self.append_coalesce_layout(tCgB_nkl_tmp.layout)
cta_tCgB = cute.make_tensor(tCgB_nkl_tmp.iterator, tCgB_layout)
# ((CTA_MMA_N,256),Rest_MMA_N, Rest_MMA_K, n, k, l)
tCgB = cute.make_tensor(
cta_tCgB.iterator,
cute.tiled_divide(
cta_tCgB.layout, (cute.size(tiled_mma.tv_layout_B[1][0]), 128)
),
)
tCgSFA = cute.make_tensor(
gSFA_mkl.iterator,
cute.tiled_divide(
gSFA_mkl.layout, (self.mma_sf_tiler[0], self.mma_sf_tiler[2])
),
)
tCgSFB = cute.make_tensor(
gSFB_nkl.iterator,
cute.tiled_divide(
gSFB_nkl.layout, (self.mma_sf_tiler[1], self.mma_sf_tiler[2])
),
)
tCgC = thr_mma.partition_C(gC_mnl)
# Create identity tensor for C to use in epilogue predication
idC = cute.make_identity_tensor(mC_mnl.shape)
cC_mnl = cute.local_tile(
idC, cute.slice_(self.mma_tiler, (None, None, 0)), (None, None, None)
)
# (MMA, MMA_M, MMA_N, RestM, RestN, RestL)
tCcC = thr_mma.partition_C(cC_mnl)
#
# Partition global/shared tensor for TMA load A/B
#
# TMA load A partition_S/D
a_cta_layout = cute.make_layout(
cute.slice_(cluster_layout_vmnk, (0, 0, None, 0)).shape
)
tAsA, tAgA = cpasync.tma_partition(
tma_atom_a,
block_in_cluster_coord_vmnk[2],
a_cta_layout,
cute.group_modes(sA, 0, 3),
cute.group_modes(tCgA, 0, 1),
)
# TMA load B partition_S/D
b_cta_layout = cute.make_layout(
cute.slice_(cluster_layout_vmnk, (0, None, 0, 0)).shape
)
tBsB, tBgB = cpasync.tma_partition(
tma_atom_b,
block_in_cluster_coord_vmnk[1],
b_cta_layout,
cute.group_modes(sB, 0, 3),
cute.group_modes(tCgB, 0, 1),
)
# TMA partition for scale factor A
sfa_cta_layout = a_cta_layout
tAsSFA, tAgSFA = cute.nvgpu.cpasync.tma_partition(
tma_atom_sfa,
block_in_cluster_coord_vmnk[2],
sfa_cta_layout,
cute.group_modes(sSFA, 0, 3),
cute.group_modes(tCgSFA, 0, 3),
)
tAsSFA_compact = cute.filter_zeros(tAsSFA)
# TMA partition for scale factor B
sfb_cta_layout = cute.make_layout(
cute.slice_(cluster_layout_sfb_vmnk, (0, None, 0, 0)).shape
)
tBsSFB, tBgSFB = cute.nvgpu.cpasync.tma_partition(
tma_atom_sfb,
block_in_cluster_coord_sfb_vmnk[1],
sfb_cta_layout,
cute.group_modes(sSFB, 0, 3),
cute.group_modes(tCgSFB, 0, 3),
)
tBsSFB_compact = cute.filter_zeros(tBsSFB)
#
# Partition shared/tensor memory tensor for TiledMMA_A/B/C
#
# (MMA, MMA_M, MMA_N)
acc_shape = tiled_mma.partition_shape_C(self.mma_tiler[:2])
if cutlass.const_expr(self.overlapping_accum):
num_acc_stage_overlapped = 2
tCtAcc_fake = tiled_mma.make_fragment_C(
cute.append(acc_shape, num_acc_stage_overlapped)
)
# (MMA, MMA_M, MMA_N, STAGE)
tCtAcc_fake = cute.make_tensor(
tCtAcc_fake.iterator,
cute.make_layout(
tCtAcc_fake.shape,
stride=(
tCtAcc_fake.stride[0],
tCtAcc_fake.stride[1],
tCtAcc_fake.stride[2],
(self.cta_tile_shape_mnk[1] - self.num_sf_tmem_cols)
* tCtAcc_fake.stride[0][1],
),
),
)
else:
# (MMA, MMA_M, MMA_N, STAGE)
tCtAcc_fake = tiled_mma.make_fragment_C(
cute.append(acc_shape, self.num_acc_stage)
)
#
# Cluster wait before tensor memory alloc
#
pipeline_init_wait(cluster_shape_mn=self.cluster_shape_mn)
#
# Construct the scheduler
#
tile_sched = utils.StaticPersistentTileScheduler.create(
tile_sched_params, cute.arch.block_idx(), cute.arch.grid_dim()
)
work_tile = tile_sched.initial_work_tile_info()
#
# Specialized TMA load warp for A/B tensors
#
if warp_idx == self.tma_ab_warp_id:
#
# Persistent tile scheduling loop for AB loads
#
buffers_per_k_tile = 3
while work_tile.is_valid_tile:
# Get tile coord from tile scheduler
cur_tile_coord = work_tile.tile_idx
mma_tile_coord_mnl = (
cur_tile_coord[0] // cute.size(tiled_mma.thr_id.shape),
cur_tile_coord[1],
cur_tile_coord[2],
)
#
# Slice to per mma tile index
#
tAgA_slice = tAgA[
(
None,
None,
None,
mma_tile_coord_mnl[0],
None,
mma_tile_coord_mnl[2],
)
]
tBgB_slice = tBgB[
(
None,
None,
None,
mma_tile_coord_mnl[1],
None,
mma_tile_coord_mnl[2],
)
]
# Peek (try_wait) AB buffer empty for k_tile = prefetch_k_tile_cnt
ab_producer.reset()
peek_ab_empty_status = cutlass.Boolean(1)
peek_ab_empty_status = ab_producer.try_acquire()
#
# TMA load loop for A/B tensors
#
for k_tile in cutlass.range(0, k_tile_cnt, 1, unroll=1):
# Load buffers_per_k_tile buffers
for buffer in cutlass.range(buffers_per_k_tile, unroll_full=True):
# Acquire next empty AB buffer
ab_empty = ab_producer.acquire_and_advance(peek_ab_empty_status)
# TMA load A/B
cute.copy(
tma_atom_a,
cute.group_modes(
tAgA_slice[(None, None, buffer, k_tile)], 0, 2
),
tAsA[(None, ab_empty.index)],
tma_bar_ptr=ab_empty.barrier,
mcast_mask=a_full_mcast_mask,
)
cute.copy(
tma_atom_b,
cute.group_modes(
tBgB_slice[(None, None, buffer, k_tile)], 0, 2
),
tBsB[(None, ab_empty.index)],
tma_bar_ptr=ab_empty.barrier,
mcast_mask=b_full_mcast_mask,
)
# Peek (try_wait) AB buffer empty for next buffer
peek_ab_empty_status = cutlass.Boolean(1)
# Check if we're not at the last buffer of the last k_tile
if not (
(k_tile == k_tile_cnt - 1)
and (buffer == buffers_per_k_tile - 1)
):
peek_ab_empty_status = ab_producer.try_acquire()
# Advance to next tile
tile_sched.advance_to_next_work()
work_tile = tile_sched.get_current_work()
# Signal end of AB loads
ab_producer.tail()
#
# Specialized TMA load warp for scale factor tensors
#
if warp_idx == self.tma_sf_warp_id:
#
# Persistent tile scheduling loop for SF loads
#
while work_tile.is_valid_tile:
# Get tile coord from tile scheduler
cur_tile_coord = work_tile.tile_idx
mma_tile_coord_mnl = (
cur_tile_coord[0],
cur_tile_coord[1],
cur_tile_coord[2],
)
#
# Slice to per mma tile index
#
tAgSFA_slice = tAgSFA[
(None, mma_tile_coord_mnl[0], None, mma_tile_coord_mnl[2])
]
tBgSFB_slice = tBgSFB[
(None, mma_tile_coord_mnl[1], None, mma_tile_coord_mnl[2])
]
# Peek (try_wait) SF buffer empty
sf_producer.reset()
peek_sf_empty_status = cutlass.Boolean(1)
peek_sf_empty_status = sf_producer.try_acquire()
#
# TMA load loop for scale factors
#
for k_tile in cutlass.range(0, k_tile_cnt, 1, unroll=1):
# Load SF stages based on sf_buffers_per_tile_k
for sf_stage in cutlass.range(
self.sf_buffers_per_tile_k, unroll_full=True
):
# Acquire next empty SF buffer
sf_empty = sf_producer.acquire_and_advance(peek_sf_empty_status)
tAgSFA_compact = cute.filter_zeros(
tAgSFA_slice[
(None, k_tile * self.sf_buffers_per_tile_k + sf_stage)
]
)
tBgSFB_compact = cute.filter_zeros(
tBgSFB_slice[
(None, k_tile * self.sf_buffers_per_tile_k + sf_stage)
]
)
# TMA load SFA/SFB for this SF stage
cute.copy(
tma_atom_sfa,
tAgSFA_compact,
tAsSFA_compact[(None, sf_empty.index)],
tma_bar_ptr=sf_empty.barrier,
mcast_mask=sfa_full_mcast_mask,
)
cute.copy(
tma_atom_sfb,
tBgSFB_compact,
tBsSFB_compact[(None, sf_empty.index)],
tma_bar_ptr=sf_empty.barrier,
mcast_mask=sfb_full_mcast_mask,
)
# Peek (try_wait) SF buffer empty for next stage
peek_sf_empty_status = cutlass.Boolean(1)
# Check if we're not at the last stage of the last k_tile
if not (
k_tile == k_tile_cnt - 1
and sf_stage == self.sf_buffers_per_tile_k - 1
):
peek_sf_empty_status = sf_producer.try_acquire()
# Advance to next tile
tile_sched.advance_to_next_work()
work_tile = tile_sched.get_current_work()
# Signal end of SF loads
sf_producer.tail()
#
# Specialized MMA warp
#
if warp_idx == self.mma_warp_id:
#
# Bar sync for retrieve tensor memory ptr from shared mem
#
tmem.wait_for_alloc()
#
# Retrieving tensor memory ptr and make accumulator/SFA/SFB tensor
#
acc_tmem_ptr = tmem.retrieve_ptr(self.acc_dtype)
# Make accumulator tmem tensor
# (MMA, MMA_M, MMA_N, STAGE)
tCtAcc_base = cute.make_tensor(acc_tmem_ptr, tCtAcc_fake.layout)
# Make SFA tmem tensor
sfa_tmem_ptr = cute.recast_ptr(
acc_tmem_ptr + tcgen05.find_tmem_tensor_col_offset(tCtAcc_base),
dtype=self.sf_dtype,
)
tCtSFA_layout = blockscaled_utils.make_tmem_layout_sfa(
tiled_mma,
self.mma_tiler,
self.sf_vec_size,
cute.slice_(sfa_smem_layout_staged, (None, None, None, 0)),
)
MMA_M = self.cta_tile_shape_mnk[0]
MMA_N_SF = self.cta_n_sf
MMA_K_SF = self.cta_tile_shape_mnk[2] // 2
mnBasicBlockShape = (32, 4)
kBasicBlockShape_single = (self.sf_vec_size, 1)
mma_iter_SFA_shape = (
(mnBasicBlockShape, MMA_M // 128),
kBasicBlockShape_single,
)
sSFA_iter_shape = (mma_iter_SFA_shape, 1, MMA_K_SF // self.sf_vec_size)
sSFA_iter_layout = cute.make_layout(sSFA_iter_shape)
mma_iter_SFB_shape = (
(mnBasicBlockShape, MMA_N_SF // 128),
kBasicBlockShape_single,
)
sSFB_iter_shape = (mma_iter_SFB_shape, 1, MMA_K_SF // self.sf_vec_size)
sSFB_iter_layout = cute.make_layout(sSFB_iter_shape)
tCtSFA_layout_mma = blockscaled_utils.make_tmem_layout_sfa(
tiled_mma, self.mma_tiler, self.sf_vec_size, sSFA_iter_layout
)
tCtSFA = cute.make_tensor(sfa_tmem_ptr, tCtSFA_layout)
tCtSFA_mma = cute.make_tensor(sfa_tmem_ptr, tCtSFA_layout_mma)
# Make SFB tmem tensor
sfb_tmem_ptr = cute.recast_ptr(
acc_tmem_ptr
+ tcgen05.find_tmem_tensor_col_offset(tCtAcc_base)
+ tcgen05.find_tmem_tensor_col_offset(tCtSFA),
dtype=self.sf_dtype,
)
tCtSFB_layout = blockscaled_utils.make_tmem_layout_sfb(
tiled_mma,
self.mma_tiler,
self.sf_vec_size,
cute.slice_(sfb_smem_layout_staged, (None, None, None, 0)),
)
tCtSFB_layout_mma = blockscaled_utils.make_tmem_layout_sfb(
tiled_mma, self.mma_tiler, self.sf_vec_size, sSFB_iter_layout
)
tCtSFB = cute.make_tensor(sfb_tmem_ptr, tCtSFB_layout)
tCtSFB_mma = cute.make_tensor(sfb_tmem_ptr, tCtSFB_layout_mma)
#
# Partition for S2T copy of SFA/SFB
#
(
tiled_copy_s2t_sfa,
tCsSFA_compact_s2t,
tCtSFA_compact_s2t,
) = self.mainloop_s2t_copy_and_partition(sSFA, tCtSFA)
(
tiled_copy_s2t_sfb,
tCsSFB_compact_s2t,
tCtSFB_compact_s2t,
) = self.mainloop_s2t_copy_and_partition(sSFB, tCtSFB)
#
# Persistent tile scheduling loop
#
acc_producer_state = pipeline.make_pipeline_state(
pipeline.PipelineUserType.Producer, self.num_acc_stage
)
MmasPerSfBuffer = 8 // self.sf_buffers_per_tile_k
sf_stride = 6 if self.sf_vec_size == 16 else 3
while work_tile.is_valid_tile:
# Get tile coord from tile scheduler
cur_tile_coord = work_tile.tile_idx
mma_tile_coord_mnl = (
cur_tile_coord[0] // cute.size(tiled_mma.thr_id.shape),
cur_tile_coord[1],
cur_tile_coord[2],
)
# Get accumulator stage index
if cutlass.const_expr(self.overlapping_accum):
acc_stage_index = acc_producer_state.phase ^ 1
else:
acc_stage_index = acc_producer_state.index
# Set tensor memory buffer for current tile
tCtAcc = tCtAcc_base[(None, 0, 0, acc_stage_index)]
# Peek (try_wait) AB buffer full for k_tile = 0
ab_consumer.reset()
peek_ab_full_status = cutlass.Boolean(1)
if is_leader_cta:
peek_ab_full_status = ab_consumer.try_wait()
# Peek (try_wait) SF buffer full
sf_consumer.reset()
peek_sf_full_status = cutlass.Boolean(1)
if is_leader_cta:
peek_sf_full_status = sf_consumer.try_wait()
#
# Reset the ACCUMULATE field for each tile
#
tiled_mma.set(tcgen05.Field.ACCUMULATE, False)
is_first_iteration = True
for k_tile in cutlass.range(0, k_tile_cnt, 1, unroll=1):
if is_leader_cta:
# Conditionally load SFA/SFB for MMA0/MMA1 depending on sf_vec_size
if 0 % MmasPerSfBuffer == 0:
sf_full = sf_consumer.wait_and_advance(peek_sf_full_status)
s2t_stage_coord = (
None,
None,
None,
None,
sf_full.index,
)
cute.copy(
tiled_copy_s2t_sfa,
tCsSFA_compact_s2t[s2t_stage_coord],
tCtSFA_compact_s2t,
)
cute.copy(
tiled_copy_s2t_sfb,
tCsSFB_compact_s2t[s2t_stage_coord],
tCtSFB_compact_s2t,
)
sf_full.release()
peek_sf_full_status = cutlass.Boolean(1)
peek_sf_full_status = sf_consumer.try_wait()
# Wait for A/B data to be ready(MMA0, MMA1, part of MMA2)
ab_full0 = ab_consumer.wait_and_advance(peek_ab_full_status)
# peek for next stage (MMA2, MMA3, MMA4, part of MMA5)
peek_ab_full_status = cutlass.Boolean(1)
peek_ab_full_status = ab_consumer.try_wait()
# delay the acc acquire to ublock tmem
if is_first_iteration:
acc_pipeline.producer_acquire(acc_producer_state)
is_first_iteration = False
# MMA0
k_block_coord_cur = (None, 0, 0, ab_full0.index)
k_block_coord_next = (None, 0, 0, ab_full0.index)
sf_kblock_coord = (None, None, 0 % MmasPerSfBuffer * sf_stride)
tiled_mma.set(
tcgen05.Field.SFA, tCtSFA_mma[sf_kblock_coord].iterator
)
tiled_mma.set(
tcgen05.Field.SFB, tCtSFB_mma[sf_kblock_coord].iterator
)
self.make_desc_and_call_mma(
tiled_mma,
tCtAcc,
sA[k_block_coord_cur],
sA[k_block_coord_next],
sB[k_block_coord_cur],
sB[k_block_coord_next],
tCtAcc,
)
tiled_mma.set(tcgen05.Field.ACCUMULATE, True)
# MMA1
k_block_coord_cur = (None, 0, 3, ab_full0.index)
k_block_coord_next = (None, 0, 0, ab_full0.index)
sf_kblock_coord = (None, None, 1 % MmasPerSfBuffer * sf_stride)
tiled_mma.set(
tcgen05.Field.SFA, tCtSFA_mma[sf_kblock_coord].iterator
)
tiled_mma.set(
tcgen05.Field.SFB, tCtSFB_mma[sf_kblock_coord].iterator
)
self.make_desc_and_call_mma(
tiled_mma,
tCtAcc,
sA[k_block_coord_cur],
sA[k_block_coord_next],
sB[k_block_coord_cur],
sB[k_block_coord_next],
tCtAcc,
)
# Conditionally load SFA/SFB for MMA2/MMA3
if 2 % MmasPerSfBuffer == 0:
sf_full = sf_consumer.wait_and_advance(peek_sf_full_status)
s2t_stage_coord = (
None,
None,
None,
None,
sf_full.index,
)
cute.copy(
tiled_copy_s2t_sfa,
tCsSFA_compact_s2t[s2t_stage_coord],
tCtSFA_compact_s2t,
)
cute.copy(
tiled_copy_s2t_sfb,
tCsSFB_compact_s2t[s2t_stage_coord],
tCtSFB_compact_s2t,
)
sf_full.release()
peek_sf_full_status = cutlass.Boolean(1)
peek_sf_full_status = sf_consumer.try_wait()
# Wait for A/B data to be ready(MMA2, MMA3, MMA4, part of MMA5)
ab_full1 = ab_consumer.wait_and_advance(peek_ab_full_status)
# peek for next stage (part of MMA5, MMA6, MMA7)
peek_ab_full_status = cutlass.Boolean(1)
peek_ab_full_status = ab_consumer.try_wait()
# MMA2
k_block_coord_cur = (None, 0, 6, ab_full0.index)
k_block_coord_next = (None, 0, 0, ab_full1.index)
sf_kblock_coord = (None, None, 2 % MmasPerSfBuffer * sf_stride)
tiled_mma.set(
tcgen05.Field.SFA, tCtSFA_mma[sf_kblock_coord].iterator
)
tiled_mma.set(
tcgen05.Field.SFB, tCtSFB_mma[sf_kblock_coord].iterator
)
self.make_desc_and_call_mma(
tiled_mma,
tCtAcc,
sA[k_block_coord_cur],
sA[k_block_coord_next],
sB[k_block_coord_cur],
sB[k_block_coord_next],
tCtAcc,
)
# Release stage_ab_0 as it is no longer needed
ab_full0.release()
# MMA3
k_block_coord_cur = (None, 0, 1, ab_full1.index)
k_block_coord_next = (None, 0, 0, ab_full1.index)
sf_kblock_coord = (None, None, 3 % MmasPerSfBuffer * sf_stride)
tiled_mma.set(
tcgen05.Field.SFA, tCtSFA_mma[sf_kblock_coord].iterator
)
tiled_mma.set(
tcgen05.Field.SFB, tCtSFB_mma[sf_kblock_coord].iterator
)
self.make_desc_and_call_mma(
tiled_mma,
tCtAcc,
sA[k_block_coord_cur],
sA[k_block_coord_next],
sB[k_block_coord_cur],
sB[k_block_coord_next],
tCtAcc,
)
# Conditionally load SFA/SFB for MMA4/MMA5
if 4 % MmasPerSfBuffer == 0:
sf_full = sf_consumer.wait_and_advance(peek_sf_full_status)
s2t_stage_coord = (
None,
None,
None,
None,
sf_full.index,
)
cute.copy(
tiled_copy_s2t_sfa,
tCsSFA_compact_s2t[s2t_stage_coord],
tCtSFA_compact_s2t,
)
cute.copy(
tiled_copy_s2t_sfb,
tCsSFB_compact_s2t[s2t_stage_coord],
tCtSFB_compact_s2t,
)
sf_full.release()
peek_sf_full_status = cutlass.Boolean(1)
peek_sf_full_status = sf_consumer.try_wait()
# MMA4
k_block_coord_cur = (None, 0, 4, ab_full1.index)
k_block_coord_next = (None, 0, 0, ab_full1.index)
sf_kblock_coord = (None, None, 4 % MmasPerSfBuffer * sf_stride)
tiled_mma.set(
tcgen05.Field.SFA, tCtSFA_mma[sf_kblock_coord].iterator
)
tiled_mma.set(
tcgen05.Field.SFB, tCtSFB_mma[sf_kblock_coord].iterator
)
self.make_desc_and_call_mma(
tiled_mma,
tCtAcc,
sA[k_block_coord_cur],
sA[k_block_coord_next],
sB[k_block_coord_cur],
sB[k_block_coord_next],
tCtAcc,
)
# Wait for A/B data to be ready(part of MMA5, MMA6, MMA7)
ab_full2 = ab_consumer.wait_and_advance(peek_ab_full_status)
# peek for next loop's first stage (MMA0, MMA1, part of MMA2)
peek_ab_full_status = cutlass.Boolean(1)
if k_tile + 1 < k_tile_cnt:
peek_ab_full_status = ab_consumer.try_wait()
# MMA5
k_block_coord_cur = (None, 0, 7, ab_full1.index)
k_block_coord_next = (None, 0, 0, ab_full2.index)
sf_kblock_coord = (None, None, 5 % MmasPerSfBuffer * sf_stride)
tiled_mma.set(
tcgen05.Field.SFA, tCtSFA_mma[sf_kblock_coord].iterator
)
tiled_mma.set(
tcgen05.Field.SFB, tCtSFB_mma[sf_kblock_coord].iterator
)
self.make_desc_and_call_mma(
tiled_mma,
tCtAcc,
sA[k_block_coord_cur],
sA[k_block_coord_next],
sB[k_block_coord_cur],
sB[k_block_coord_next],
tCtAcc,
)
# Conditionally load SFA/SFB for MMA6/MMA7
if 6 % MmasPerSfBuffer == 0:
sf_full = sf_consumer.wait_and_advance(peek_sf_full_status)
s2t_stage_coord = (
None,
None,
None,
None,
sf_full.index,
)
cute.copy(
tiled_copy_s2t_sfa,
tCsSFA_compact_s2t[s2t_stage_coord],
tCtSFA_compact_s2t,
)
cute.copy(
tiled_copy_s2t_sfb,
tCsSFB_compact_s2t[s2t_stage_coord],
tCtSFB_compact_s2t,
)
sf_full.release()
peek_sf_full_status = cutlass.Boolean(1)
if k_tile + 1 < k_tile_cnt:
peek_sf_full_status = sf_consumer.try_wait()
ab_full1.release()
# MMA6
k_block_coord_cur = (None, 0, 2, ab_full2.index)
k_block_coord_next = (None, 0, 0, ab_full2.index)
sf_kblock_coord = (None, None, 6 % MmasPerSfBuffer * sf_stride)
tiled_mma.set(
tcgen05.Field.SFA, tCtSFA_mma[sf_kblock_coord].iterator
)
tiled_mma.set(
tcgen05.Field.SFB, tCtSFB_mma[sf_kblock_coord].iterator
)
self.make_desc_and_call_mma(
tiled_mma,
tCtAcc,
sA[k_block_coord_cur],
sA[k_block_coord_next],
sB[k_block_coord_cur],
sB[k_block_coord_next],
tCtAcc,
)
# MMA7
k_block_coord_cur = (None, 0, 5, ab_full2.index)
k_block_coord_next = (None, 0, 0, ab_full2.index)
sf_kblock_coord = (None, None, 7 % MmasPerSfBuffer * sf_stride)
tiled_mma.set(
tcgen05.Field.SFA, tCtSFA_mma[sf_kblock_coord].iterator
)
tiled_mma.set(
tcgen05.Field.SFB, tCtSFB_mma[sf_kblock_coord].iterator
)
self.make_desc_and_call_mma(
tiled_mma,
tCtAcc,
sA[k_block_coord_cur],
sA[k_block_coord_next],
sB[k_block_coord_cur],
sB[k_block_coord_next],
tCtAcc,
)
ab_full2.release()
if is_leader_cta:
acc_pipeline.producer_commit(acc_producer_state)
acc_producer_state.advance()
#
# Advance to next tile
#
tile_sched.advance_to_next_work()
work_tile = tile_sched.get_current_work()
#
# Wait for accumulator buffer empty
#
acc_pipeline.producer_tail(acc_producer_state)
sC = None
if cutlass.const_expr(self.use_tma_store):
# (EPI_TILE_M, EPI_TILE_N, STAGE)
sC = smem.allocate_tensor(
element_type=self.c_dtype,
layout=c_smem_layout_staged.outer,
byte_alignment=128,
swizzle=c_smem_layout_staged.inner,
)
#
# Specialized epilogue warps
#
if warp_idx < self.mma_warp_id:
#
# Alloc tensor memory buffer
#
tmem.allocate(self.num_tmem_alloc_cols)
#
# Bar sync for retrieve tensor memory ptr from shared memory
#
tmem.wait_for_alloc()
#
# Retrieving tensor memory ptr and make accumulator tensor
#
acc_tmem_ptr = tmem.retrieve_ptr(self.acc_dtype)
# (MMA, MMA_M, MMA_N, STAGE)
tCtAcc_base = cute.make_tensor(acc_tmem_ptr, tCtAcc_fake.layout)
#
# Persistent tile scheduling loop
#
acc_consumer_state = pipeline.make_pipeline_state(
pipeline.PipelineUserType.Consumer, self.num_acc_stage
)
if cutlass.const_expr(self.use_tma_store):
assert tma_atom_c is not None and sC is not None
c_producer_group = pipeline.CooperativeGroup(
pipeline.Agent.Thread,
32 * len(self.epilogue_warp_id),
)
c_pipeline = pipeline.PipelineTmaStore.create(
num_stages=self.num_c_stage, producer_group=c_producer_group
)
while work_tile.is_valid_tile:
# Get tile coord from tile scheduler
cur_tile_coord = work_tile.tile_idx
mma_tile_coord_mnl = (
cur_tile_coord[0] // cute.size(tiled_mma.thr_id.shape),
cur_tile_coord[1],
cur_tile_coord[2],
)
#
# Pre-advance to next tile
#
tile_sched.advance_to_next_work()
work_tile = tile_sched.get_current_work()
num_tiles_executed = tile_sched.num_tiles_executed
if cutlass.const_expr(self.use_tma_store):
acc_consumer_state = utils.gemm.sm100.epilogue_tma_store(
self,
tidx,
warp_idx,
tma_atom_c,
tCtAcc_base,
sC,
tCgC,
epi_tile,
num_tiles_executed,
epilogue_op,
mma_tile_coord_mnl,
acc_consumer_state,
acc_pipeline,
c_pipeline,
)
else:
acc_consumer_state = utils.gemm.sm100.epilogue(
self,
tidx,
tCtAcc_base,
tCgC,
epi_tile,
epilogue_op,
mma_tile_coord_mnl,
acc_consumer_state,
acc_pipeline,
tCcC_base=tCcC,
mC_mnl=mC_mnl,
overlapping_accum=self.overlapping_accum,
)
if cutlass.const_expr(self.use_tma_store):
# Wait for C store complete
c_pipeline.producer_tail()
else:
# Synchronize before TMEM dealloc (done by the caller)
tmem_dealloc_barrier.arrive_and_wait()
#
# Dealloc the tensor memory buffer
#
tmem.relinquish_alloc_permit()
tmem.free(acc_tmem_ptr)
@staticmethod
def make_desc_and_call_mma(
tiled_mma: cute.TiledMma,
d: cute.Tensor,
sA_cur: cute.Tensor,
sA_next: cute.Tensor,
sB_cur: cute.Tensor,
sB_next: cute.Tensor,
c: cute.Tensor,
) -> None:
"""Specialized GEMM for circular-buffered A/B from SMEM.
Performs D <- A * B + C where A and B are described by circular SMEM
descriptors constructed from the (current, next) buffers. C and D may alias.
Some tcgen05 MMAs require explicitly toggling an accumulate field outside of
this routine; the caller is responsible for that.
All tensors must already be partitioned for the provided tiled MMA.
For MMA Atoms that require single-threaded execution, the gemm op automatically handles thread
election internally. Manual thread selection is not required in such cases.
:param atom: MMA atom
:type atom: cute.MmaAtom
:param d: Destination tensor
:type d: cute.Tensor
:param sA_cur: Current shared memory tensor for operand A
:type sA_cur: cute.Tensor
:param sA_next: Next shared memory tensor for operand A, used for circular buffering
:type sA_next: cute.Tensor
:param sB_cur: Current shared memory tensor for operand B
:type sB_cur: cute.Tensor
:param sB_next: Next shared memory tensor for operand B, used for circular buffering
:type sB_next: cute.Tensor
:param c: Third source tensor
:type c: cute.Tensor
:return: None
:rtype: None
"""
a_desc = tcgen05.make_umma_smem_desc(
sA_cur.iterator,
sA_cur.layout,
"k" if tiled_mma.op.a_major_mode.name == "K" else "mn",
next_src=sA_next.iterator,
)
b_desc = tcgen05.make_umma_smem_desc(
sB_cur.iterator,
sB_cur.layout,
"k" if tiled_mma.op.b_major_mode.name == "K" else "mn",
next_src=sB_next.iterator,
)
view_layout = cute.make_layout(1, stride=0)
a_tensor = cute.make_tensor(a_desc, view_layout)
b_tensor = cute.make_tensor(b_desc, view_layout)
return cute.mma_atom_call(tiled_mma, d, a_tensor, b_tensor, c)
@staticmethod
def sm103_make_blockscaled_trivial_tiled_mma(
sf_dtype: Type[cutlass.Numeric],
sf_vec_size: int,
cta_group: tcgen05.CtaGroup,
mma_tiler_mn: Tuple[int, int],
a_source: tcgen05.OperandSource = tcgen05.OperandSource.SMEM,
) -> cute.TiledMma:
"""Create a blockscaled trivial tiled MMA for SM103 (3xFP4), K fixed to 96.
Returns a tcgen05 MMA configured for the given (M, N) tiler and CTA group.
:param sf_dtype: Data type of the scale factor (typically 8-bit)
:type sf_dtype: Type[cutlass.Numeric]
:param sf_vec_size: The vector size of the scale factor
:type sf_vec_size: int
:param cta_group: The CTA group configuration
:type cta_group: tcgen05.CtaGroup
:param mma_tiler_mn: The MMA tiler dimensions (M, N)
:type mma_tiler_mn: Tuple[int, int]
:param a_source: Source location for operand A (SMEM by default)
:type a_source: tcgen05.OperandSource
:return: A tiled MMA atom configured for SM103 blockscaled operations
:rtype: cute.TiledMma
:raises TypeError: If the data type is not supported.
:raises ValueError: If the sf_vec_size is not supported.
"""
if sf_vec_size == 32:
mma_op = tcgen05.SM103MmaMXF4Op(
(*mma_tiler_mn, 96),
cta_group,
a_source,
)
elif sf_vec_size == 16:
mma_op = tcgen05.SM103MmaMXF4NVF4Op(
sf_dtype,
(*mma_tiler_mn, 96),
cta_group,
a_source,
)
else:
raise ValueError(
f"Unsupported sf_vec_size: {sf_vec_size}. Expected 16 or 32."
)
return cute.make_tiled_mma(cute.make_mma_atom(mma_op))
# Utils
@staticmethod
def sm103_make_smem_layout_a(
tiled_mma: cute.TiledMma,
mma_tiler_mnk: cute.Tile,
num_stages: int,
) -> Union[cute.Layout, cute.ComposedLayout]:
"""
Create the SMEM layout for operand A using K_SW128 and Uint8.
This function creates a SMEM layout for operand A using the make_smem_layout_atom function with K_SW128 kind and Uint8 element type.
:param tiled_mma: The tiled MMA atom
:type tiled_mma: cute.TiledMma
:param mma_tiler_mnk: The mma tiler shape (M, N, K)
:type mma_tiler_mnk: cute.Tile
:param num_stages: The number of stages
:type num_stages: int
:return: SMEM layout for operand A
:rtype: cute.Layout
"""
is_k_major = tiled_mma.op.a_major_mode == tcgen05.OperandMajorMode.K
a_smem_layout_staged = tcgen05.tile_to_mma_shape(
tcgen05.make_smem_layout_atom(
tcgen05.SmemLayoutAtomKind.K_SW128, cutlass.Uint8
),
cute.append(
(
(
mma_tiler_mnk[0]
// cute.size(tiled_mma.thr_layout_vmnk.shape[0]),
16,
),
1,
8,
),
num_stages,
),
order=((1, 0, 2) if not is_k_major else (0, 1, 2)),
)
return a_smem_layout_staged
@staticmethod
def sm103_make_smem_layout_b(
tiled_mma: cute.TiledMma,
mma_tiler_mnk: cute.Tile,
num_stages: int,
) -> Union[cute.Layout, cute.ComposedLayout]:
"""
Create the SMEM layout for operand B using K_SW128 and Uint8.
This function creates a SMEM layout for operand B using the make_smem_layout_atom function with K_SW128 kind and Uint8 element type.
:param tiled_mma: The tiled MMA atom
:type tiled_mma: cute.TiledMma
:param mma_tiler_mnk: The mma tiler shape (M, N, K)
:type mma_tiler_mnk: cute.Tile
:param num_stages: The number of stages
:type num_stages: int
:return: SMEM layout for operand B
:rtype: cute.Layout
"""
is_k_major = tiled_mma.op.b_major_mode == tcgen05.OperandMajorMode.K
b_smem_layout_staged = tcgen05.tile_to_mma_shape(
tcgen05.make_smem_layout_atom(
tcgen05.SmemLayoutAtomKind.K_SW128, cutlass.Uint8
),
cute.append(
((mma_tiler_mnk[1] // cute.size(tiled_mma.thr_id.shape), 16), 1, 8),
num_stages,
),
order=((1, 0, 2) if not is_k_major else (0, 1, 2)),
)
return b_smem_layout_staged
@dataclass(frozen=True)
class Sm103BlockScaledBasicChunk:
"""
Basic scale-factor atom layout decided by tcgen05 BlockScaled MMA Ops on SM103.
Represents the fixed layout pattern for scale factors used by tcgen05
BlockScaled MMA Ops on SM103. The layout is determined by the instruction
specification and is not configurable.
"""
sf_vec_size: int
major_mode: tcgen05.OperandMajorMode = tcgen05.OperandMajorMode.K
_layout: cute.Layout = field(init=False, repr=False)
def __post_init__(self) -> None:
if self.major_mode == tcgen05.OperandMajorMode.K:
atom_shape = ((8, 4, 4), (self.sf_vec_size, 4))
atom_stride = ((16, 128, 4), (0, 1))
else:
atom_shape = ((self.sf_vec_size, 4), (8, 4, 4))
atom_stride = ((0, 1), (16, 128, 4))
object.__setattr__(
self, "_layout", cute.make_layout(shape=atom_shape, stride=atom_stride)
)
@property
def layout(self) -> cute.Layout:
return self._layout
@staticmethod
def sm103_make_smem_layout_sfa(
tiled_mma: cute.TiledMma,
mma_tiler: cute.Tile,
sf_vec_size: int,
num_stages: int,
) -> cute.Layout:
"""
Make SMEM layout for SFA based on:
1) Sm103BlockScaledBasicChunk, 2) MMA tiler, 3) sf_vec_size, 4) stages.
:param tiled_mma: The tiled MMA
:type tiled_mma: cute.TiledMma
:param mma_tiler: The mma tiler shape
:type mma_tiler: cute.Tile
:param sf_vec_size: The scale factor vector size
:type sf_vec_size: int
:param num_stages: The number of stages
:type num_stages: int
:return: Smem layout for SFA
:rtype: cute.Layout
"""
mma_shape_mk = tiled_mma.partition_shape_A((mma_tiler[0], mma_tiler[2]))
sf_atom = Sm103BlockScaledPersistentDenseGemmKernel.Sm103BlockScaledBasicChunk(
sf_vec_size, tiled_mma.op.a_major_mode
).layout
k_divisor = 4 if sf_vec_size == 16 else 2
mma_sfa_tiler = (
mma_shape_mk[0][0] * mma_shape_mk[1],
mma_shape_mk[0][1] * mma_shape_mk[2] // k_divisor,
)
sfa_smem_atom_layout = cute.tiled_product(
sf_atom,
cute.make_layout(
cute.shape_div(mma_sfa_tiler, cute.product_each(sf_atom.shape))
),
)
sfa_smem_layout_staged = cute.make_layout(
shape=cute.append(sfa_smem_atom_layout.shape, num_stages),
stride=cute.append(
sfa_smem_atom_layout.stride,
cute.size(cute.filter_zeros(sfa_smem_atom_layout)),
),
)
return sfa_smem_layout_staged
@staticmethod
def sm103_make_smem_layout_sfb(
tiled_mma: cute.TiledMma,
mma_tiler: cute.Tile,
sf_vec_size: int,
num_stages: int,
) -> cute.Layout:
"""
Make SMEM layout for SFB based on the basic chunk, MMA tiler, sf_vec_size, stages.
:param tiled_mma: The tiled MMA
:type tiled_mma: cute.TiledMma
:param mma_tiler: The mma tiler shape
:type mma_tiler: cute.Tile
:param sf_vec_size: The scale factor vector size
:type sf_vec_size: int
:param num_stages: The number of stages
:type num_stages: int
:return: Smem layout for SFB
:rtype: cute.Layout
"""
sf_atom = Sm103BlockScaledPersistentDenseGemmKernel.Sm103BlockScaledBasicChunk(
sf_vec_size, tiled_mma.op.a_major_mode
).layout
k_divisor = 4 if sf_vec_size == 16 else 2
mma_sfb_tiler = (mma_tiler[1], mma_tiler[2] // k_divisor)
if mma_sfb_tiler[0] == 128:
sfb_smem_atom_layout = cute.tiled_product(
sf_atom,
cute.make_layout(
cute.shape_div(mma_sfb_tiler, cute.product_each(sf_atom.shape))
),
)
else:
sf_k_major_atom256 = cute.make_layout(
shape=(
(32, 4, 2),
(sf_vec_size, 4),
),
stride=(
(16, 4, mma_sfb_tiler[1] // sf_vec_size // 4 * 512),
(0, 1),
),
)
sfb_smem_atom_layout = cute.tiled_product(
sf_k_major_atom256,
cute.make_layout(
cute.shape_div(
mma_sfb_tiler, cute.product_each(sf_k_major_atom256.shape)
)
),
)
sfb_smem_layout_staged = cute.make_layout(
shape=cute.append(sfb_smem_atom_layout.shape, num_stages),
stride=cute.append(
sfb_smem_atom_layout.stride,
cute.size(cute.filter_zeros(sfb_smem_atom_layout)),
),
)
return sfb_smem_layout_staged
def mainloop_s2t_copy_and_partition(
self,
sSF: cute.Tensor,
tSF: cute.Tensor,
) -> Tuple[cute.TiledCopy, cute.Tensor, cute.Tensor]:
"""
Make tiledCopy for smem to tmem load for scale factor tensor, then use it to partition smem memory (source) and tensor memory (destination).
:param sSF: The scale factor tensor in smem
:type sSF: cute.Tensor
:param tSF: The scale factor tensor in tmem
:type tSF: cute.Tensor
:return: A tuple containing (tiled_copy_s2t, tCsSF_compact_s2t, tCtSF_compact_s2t) where:
- tiled_copy_s2t: The tiled copy operation for smem to tmem load for scale factor tensor(s2t)
- tCsSF_compact_s2t: The partitioned scale factor tensor in smem
- tSF_compact_s2t: The partitioned scale factor tensor in tmem
:rtype: Tuple[cute.TiledCopy, cute.Tensor, cute.Tensor]
"""
# (MMA, MMA_MN, MMA_K, STAGE)
tCsSF_compact = cute.filter_zeros(sSF)
# (MMA, MMA_MN, MMA_K)
tCtSF_compact = cute.filter_zeros(tSF)
tCtSF_compact_copy = cute.make_tensor(
tCtSF_compact.iterator,
cute.append(
cute.append(tCtSF_compact[(None, 0, 0)].layout, cute.make_layout((1))),
cute.make_layout(1),
),
)
# Make S2T CopyAtom and tiledCopy
copy_atom_s2t = cute.make_copy_atom(
tcgen05.Cp4x32x128bOp(self.cta_group),
self.sf_dtype,
)
tiled_copy_s2t = tcgen05.make_s2t_copy(copy_atom_s2t, tCtSF_compact_copy)
thr_copy_s2t = tiled_copy_s2t.get_slice(0)
tCsSF_compact_s2t_ = thr_copy_s2t.partition_S(tCsSF_compact)
tCsSF_compact_s2t = tcgen05.get_s2t_smem_desc_tensor(
tiled_copy_s2t, tCsSF_compact_s2t_
)
tCtSF_compact_s2t = thr_copy_s2t.partition_D(tCtSF_compact)
return tiled_copy_s2t, tCsSF_compact_s2t, tCtSF_compact_s2t
@staticmethod
def _compute_stages(
tiled_mma: cute.TiledMma,
mma_tiler: Tuple[int, int, int],
epi_tile: cute.Tile,
c_dtype: Type[cutlass.Numeric],
c_layout: utils.LayoutEnum,
sf_dtype: Type[cutlass.Numeric],
sf_vec_size: int,
smem_capacity: int,
occupancy: int,
use_tma_store: bool,
) -> Tuple[int, int, int]:
"""Computes the number of stages for A/B and SF operands based on heuristics.
SM103 requires separate stage counts for AB and SF pipelines.
:param tiled_mma: The tiled MMA object defining the core computation.
:type tiled_mma: cute.TiledMma
:param mma_tiler: The shape (M, N, K) of the MMA tiler.
:type mma_tiler: tuple[int, int, int]
:param epi_tile: The epilogue tile shape.
:type epi_tile: cute.Tile
:param c_dtype: Data type of operand C (output).
:type c_dtype: type[cutlass.Numeric]
:param c_layout: Layout enum of operand C.
:type c_layout: utils.LayoutEnum
:param sf_dtype: Data type of Scale factor.
:type sf_dtype: type[cutlass.Numeric]
:param sf_vec_size: Scale factor vector size.
:type sf_vec_size: int
:param smem_capacity: Total available shared memory capacity in bytes.
:type smem_capacity: int
:param occupancy: Target number of CTAs per SM (occupancy).
:type occupancy: int
:param use_tma_store: Whether TMA store is enabled.
:type use_tma_store: bool
:return: A tuple containing the computed number of stages for:
(ACC stages, A/B operand stages, SF stages)
:rtype: tuple[int, int, int]
"""
# ACC stages - same as SM100 dense blockscaled gemm
num_acc_stage = 1 if mma_tiler[1] == 256 else 2
# Default C stages
num_c_stage = 2 if use_tma_store else 0
# Calculate smem layout and size for one stage of A, B, SFA, SFB
a_smem_layout_stage_one = (
Sm103BlockScaledPersistentDenseGemmKernel.sm103_make_smem_layout_a(
tiled_mma,
mma_tiler,
1,
)
)
b_smem_layout_staged_one = (
Sm103BlockScaledPersistentDenseGemmKernel.sm103_make_smem_layout_b(
tiled_mma,
mma_tiler,
1,
)
)
sfa_smem_layout_staged_one = (
Sm103BlockScaledPersistentDenseGemmKernel.sm103_make_smem_layout_sfa(
tiled_mma,
mma_tiler,
sf_vec_size,
1,
)
)
sfb_smem_layout_staged_one = (
Sm103BlockScaledPersistentDenseGemmKernel.sm103_make_smem_layout_sfb(
tiled_mma,
mma_tiler,
sf_vec_size,
1,
)
)
c_smem_layout_staged_one = sm103_utils.make_smem_layout_epi(
c_dtype,
c_layout,
epi_tile,
1,
)
c_bytes_per_stage = cute.size_in_bytes(c_dtype, c_smem_layout_staged_one)
c_bytes = c_bytes_per_stage * num_c_stage
ab_bytes_per_stage = cute.size_in_bytes(
cutlass.Uint8, a_smem_layout_stage_one
) + cute.size_in_bytes(cutlass.Uint8, b_smem_layout_staged_one)
sf_bytes_per_stage = cute.size_in_bytes(
sf_dtype, sfa_smem_layout_staged_one
) + cute.size_in_bytes(sf_dtype, sfb_smem_layout_staged_one)
mbar_helpers_bytes = 1024
num_ab_stage = (
smem_capacity // occupancy
- (mbar_helpers_bytes + sf_bytes_per_stage + c_bytes)
) // ab_bytes_per_stage
num_sf_stage = (
smem_capacity
- occupancy * ab_bytes_per_stage * num_ab_stage
- occupancy * mbar_helpers_bytes
- occupancy * c_bytes
) // (occupancy * sf_bytes_per_stage)
# Refine epilogue stages:
# Calculate remaining smem after allocating for A/B stages and reserved bytes
# Add remaining unused smem to epilogue
if use_tma_store:
# xinyu TODO: not sure if aligned with c++
num_c_stage += (
smem_capacity
- occupancy * ab_bytes_per_stage * num_ab_stage
- occupancy * sf_bytes_per_stage * num_sf_stage
- occupancy * mbar_helpers_bytes
- occupancy * c_bytes
) // (occupancy * c_bytes_per_stage)
return num_acc_stage, num_ab_stage, num_sf_stage, num_c_stage
@staticmethod
def _compute_grid(
c: cute.Tensor,
cta_tile_shape_mnk: Tuple[int, int, int],
cluster_shape_mn: Tuple[int, int],
max_active_clusters: cutlass.Constexpr,
) -> Tuple[utils.PersistentTileSchedulerParams, Tuple[int, int, int]]:
"""Use persistent tile scheduler to compute the grid size for the output tensor C.
:param c: The output tensor C
:type c: cute.Tensor
:param cta_tile_shape_mnk: The shape (M, N, K) of the CTA tile.
:type cta_tile_shape_mnk: tuple[int, int, int]
:param cluster_shape_mn: Shape of each cluster in M, N dimensions.
:type cluster_shape_mn: tuple[int, int]
:param max_active_clusters: Maximum number of active clusters.
:type max_active_clusters: cutlass.Constexpr
:return: A tuple containing:
- tile_sched_params: Parameters for the persistent tile scheduler.
- grid: Grid shape for kernel launch.
:rtype: Tuple[utils.PersistentTileSchedulerParams, tuple[int, int, int]]
"""
c_shape = cute.slice_(cta_tile_shape_mnk, (None, None, 0))
gc = cute.zipped_divide(c, tiler=c_shape)
num_ctas_mnl = gc[(0, (None, None, None))].shape
cluster_shape_mnl = (*cluster_shape_mn, 1)
tile_sched_params = utils.PersistentTileSchedulerParams(
num_ctas_mnl, cluster_shape_mnl
)
grid = utils.StaticPersistentTileScheduler.get_grid_shape(
tile_sched_params, max_active_clusters
)
return tile_sched_params, grid
@staticmethod
def is_valid_dtypes_and_scale_factor_vec_size(
ab_dtype: Type[cutlass.Numeric],
sf_dtype: Type[cutlass.Numeric],
sf_vec_size: int,
c_dtype: Type[cutlass.Numeric],
) -> bool:
"""
Check if the dtypes and sf_vec_size are valid combinations
:param ab_dtype: The data type of the A and B operands
:type ab_dtype: Type[cutlass.Numeric]
:param sf_dtype: The data type of the scale factor
:type sf_dtype: Type[cutlass.Numeric]
:param sf_vec_size: The vector size of the scale factor
:type sf_vec_size: int
:param c_dtype: The data type of the output tensor
:type c_dtype: Type[cutlass.Numeric]
:return: True if the dtypes and sf_vec_size are valid, False otherwise
:rtype: bool
"""
is_valid = True
# Check valid ab_dtype
if ab_dtype != cutlass.Float4E2M1FN:
is_valid = False
# Check valid sf_vec_size
if sf_vec_size not in {16, 32}:
is_valid = False
# Check valid sf_dtype
if sf_dtype not in {cutlass.Float8E8M0FNU, cutlass.Float8E4M3FN}:
is_valid = False
# Check valid sf_dtype and sf_vec_size combinations
if sf_dtype == cutlass.Float8E4M3FN and sf_vec_size == 32:
is_valid = False
# Check valid c_dtype
if c_dtype not in {
cutlass.Float32,
cutlass.Float16,
cutlass.BFloat16,
cutlass.Float8E5M2,
cutlass.Float8E4M3FN,
}:
is_valid = False
return is_valid
@staticmethod
def is_valid_layouts(
ab_dtype: Type[cutlass.Numeric],
c_dtype: Type[cutlass.Numeric],
a_major: str,
b_major: str,
c_major: str,
) -> bool:
"""
Check if layouts and dtypes are valid combinations
:param ab_dtype: The data type of the A and B operands
:type ab_dtype: Type[cutlass.Numeric]
:param c_dtype: The data type of the output tensor
:type c_dtype: Type[cutlass.Numeric]
:param a_major: The major dimension of the A tensor
:type a_major: str
:param b_major: The major dimension of the B tensor
:type b_major: str
:param c_major: The major dimension of the C tensor
:type c_major: str
:return: True if the layouts are valid, False otherwise
:rtype: bool
"""
is_valid = True
if ab_dtype is cutlass.Float4E2M1FN and not (a_major == "k" and b_major == "k"):
is_valid = False
return is_valid
@staticmethod
def is_valid_mma_tiler_and_cluster_shape(
mma_tiler_mn: Tuple[int, int],
cluster_shape_mn: Tuple[int, int],
) -> bool:
"""
Check if the mma tiler and cluster shape are valid
:param mma_tiler_mn: The (M, N) shape of the MMA instruction tiler
:type mma_tiler_mn: Tuple[int, int]
:param cluster_shape_mn: The (ClusterM, ClusterN) shape of the CTA cluster
:type cluster_shape_mn: Tuple[int, int]
:return: True if the mma tiler and cluster shape are valid, False otherwise
:rtype: bool
"""
is_valid = True
# Skip invalid mma tile shape
if not mma_tiler_mn[0] in [128, 256]:
is_valid = False
if not mma_tiler_mn[1] in [128, 256]:
is_valid = False
# Skip illegal cluster shape
if cluster_shape_mn[0] % (2 if mma_tiler_mn[0] == 256 else 1) != 0:
is_valid = False
# Skip invalid cluster shape
is_power_of_2 = lambda x: x > 0 and (x & (x - 1)) == 0
if (
cluster_shape_mn[0] * cluster_shape_mn[1] > 16
or cluster_shape_mn[0] <= 0
or cluster_shape_mn[1] <= 0
# Special cluster shape check for scale factor multicasts.
# Due to limited size of scale factors, we can't multicast among more than 4 CTAs.
or cluster_shape_mn[0] > 4
or cluster_shape_mn[1] > 4
or not is_power_of_2(cluster_shape_mn[0])
or not is_power_of_2(cluster_shape_mn[1])
):
is_valid = False
return is_valid
@staticmethod
def is_valid_tensor_alignment(
m: int,
n: int,
k: int,
l: int,
ab_dtype: Type[cutlass.Numeric],
c_dtype: Type[cutlass.Numeric],
a_major: str,
b_major: str,
c_major: str,
) -> bool:
"""
Check if the tensor alignment is valid
:param m: The number of rows in the A tensor
:type m: int
:param n: The number of columns in the B tensor
:type n: int
:param k: The number of columns in the A tensor
:type k: int
:param l: The number of columns in the C tensor
:type l: int
:param ab_dtype: The data type of the A and B operands
:type ab_dtype: Type[cutlass.Numeric]
:param c_dtype: The data type of the output tensor
:type c_dtype: Type[cutlass.Numeric]
:param a_major: The major axis of the A tensor
:type a_major: str
:param b_major: The major axis of the B tensor
:type b_major: str
:param c_major: The major axis of the C tensor
:type c_major: str
:return: True if the problem shape is valid, False otherwise
:rtype: bool
"""
is_valid = True
def check_contigous_alignment(
dtype, is_mode0_major, tensor_shape, alignment_bytes
):
"""Check if tensor satisfies the required byte alignment.
:param dtype: Data type of the tensor
:param is_mode0_major: Whether mode 0 is the major (contiguous) mode
:param tensor_shape: Shape of the tensor (mode0, mode1, batch)
:param alignment_bytes: Required alignment in bytes (e.g., 16 or 32)
:return: True if alignment is satisfied
"""
major_mode_idx = 0 if is_mode0_major else 1
num_major_elements = tensor_shape[major_mode_idx]
# Calculate number of contiguous elements needed for alignment
# alignment_bytes * 8 (bits per byte) / dtype.width (bits per element)
num_contiguous_elements = alignment_bytes * 8 // dtype.width
return num_major_elements % num_contiguous_elements == 0
# Check A/B tensors for 16B alignment
# Check C tensor for 32B alignment
if (
not check_contigous_alignment(ab_dtype, a_major == "m", (m, k, l), 16)
or not check_contigous_alignment(ab_dtype, b_major == "n", (n, k, l), 16)
or not check_contigous_alignment(c_dtype, c_major == "m", (m, n, l), 32)
):
is_valid = False
return is_valid
@staticmethod
def can_implement(
ab_dtype: Type[cutlass.Numeric],
sf_dtype: Type[cutlass.Numeric],
sf_vec_size: int,
c_dtype: Type[cutlass.Numeric],
mma_tiler_mn: Tuple[int, int],
cluster_shape_mn: Tuple[int, int],
m: int,
n: int,
k: int,
l: int,
a_major: str,
b_major: str,
c_major: str,
use_tma_store: bool,
) -> bool:
"""
Check if the gemm can be implemented
:param ab_dtype: The data type of the A and B operands
:type ab_dtype: Type[cutlass.Numeric]
:param sf_dtype: The data type of the scale factor tensor
:type sf_dtype: Type[cutlass.Numeric]
:param sf_vec_size: The vector size
:type sf_vec_size: int
:param c_dtype: The data type of the output tensor
:type c_dtype: Type[cutlass.Numeric]
:param mma_tiler_mn: The (M, N) shape of the MMA instruction tiler
:type mma_tiler_mn: Tuple[int, int]
:param cluster_shape_mn: The (ClusterM, ClusterN) shape of the CTA cluster
:type cluster_shape_mn: Tuple[int, int]
:param m: The number of rows in the A tensor
:type m: int
:param n: The number of columns in the B tensor
:type n: int
:param k: The number of columns in the A tensor
:type k: int
:param l: The number of columns in the C tensor
:type l: int
:param a_major: The major axis of the A tensor
:type a_major: str
:param b_major: The major axis of the B tensor
:type b_major: str
:param c_major: The major axis of the C tensor
:type c_major: str
:return: True if the gemm can be implemented, False otherwise
:rtype: bool
"""
can_implement = True
# Skip unsupported types
if not Sm103BlockScaledPersistentDenseGemmKernel.is_valid_dtypes_and_scale_factor_vec_size(
ab_dtype, sf_dtype, sf_vec_size, c_dtype
):
can_implement = False
# Skip unsupported layouts
if not Sm103BlockScaledPersistentDenseGemmKernel.is_valid_layouts(
ab_dtype, c_dtype, a_major, b_major, c_major
):
can_implement = False
# Skip invalid mma tile shape and cluster shape
if not Sm103BlockScaledPersistentDenseGemmKernel.is_valid_mma_tiler_and_cluster_shape(
mma_tiler_mn, cluster_shape_mn
):
can_implement = False
# Skip illegal problem shape for load/store alignment
if not Sm103BlockScaledPersistentDenseGemmKernel.is_valid_tensor_alignment(
m, n, k, l, ab_dtype, c_dtype, a_major, b_major, c_major
):
can_implement = False
return can_implement
# Helper function for append and coalesce layout
@staticmethod
def append_coalesce_layout(layout):
# coalesce is like: cutlass/python/pycute/layout.py:coalesce
part1 = cute.coalesce(cute.append(layout[0][0], layout[1]))
part2 = cute.coalesce(cute.append(layout[0][1], layout[2]))
result = cute.append(part1, part2)
result = cute.append(result, layout[3])
result = cute.append(result, layout[4])
result = cute.append(result, layout[5])
return result
@staticmethod
def adapt_layout_for_tma_ab(composed_layout):
# input: S<3,4,3> o 0 o ((128,16),1,8,3):((128,1),0,16,16384)
# output: S<3,4,3> o 0 o (128,(128,3)):(128,(1,16384))
# for ctaValueMap: (128,384):(1@0,1@1)
layout = composed_layout.outer
part1 = cute.coalesce(cute.append(layout[0][0], layout[1]))
part2 = cute.coalesce(cute.append(layout[0][1], layout[2]))
part3 = cute.append(part2, layout[3])
result = cute.append(part1, part3)
return cute.make_composed_layout(
composed_layout.inner, composed_layout.offset, result
)
@staticmethod
def adapt_layout_for_tma_sf(layout):
# TODO: need ethan check this
# input: (((8,4,4),(16,4)),1,3):(((16,128,4),(0,1)),0,512)
# output: ((32,4),(16,4,3)):((16,4),(0,1,512))
# for ctaValueMap: ((8,4,4),(16,4,3)):((1@0@0@0,1@1@0@0,1@2@0@0),(1@0@0@1,1@1@0@1,1@1@1))
part1 = cute.coalesce(cute.append(layout[0][0], layout[1]))
part2 = cute.coalesce(cute.append(layout[0][1], layout[2]))
result = cute.append(cute.group_modes(part1, 0, cute.rank(part1)), part2)
return result
@cute.jit
def cvt_sf_MKL_to_M32x4xrm_K4xrk_L(
sf_ref_tensor: cute.Tensor,
sf_mma_tensor: cute.Tensor,
):
"""Convert scale factor tensor from MKL layout to mma specification M(32x4xrest_m)xK(4xrest_k)xL layout"""
# sf_mma_tensor has flatten shape (32, 4, rest_m, 4, rest_k, l)
# group to ((32, 4, rest_m), (4, rest_k), l)
sf_mma_tensor = cute.group_modes(sf_mma_tensor, 0, 3)
sf_mma_tensor = cute.group_modes(sf_mma_tensor, 1, 3)
for i in cutlass.range(cute.size(sf_ref_tensor)):
mkl_coord = sf_ref_tensor.layout.get_hier_coord(i)
sf_mma_tensor[mkl_coord] = sf_ref_tensor[mkl_coord]
def run(
mnkl: Tuple[int, int, int, int],
ab_dtype: Type[cutlass.Numeric],
sf_dtype: Type[cutlass.Numeric],
sf_vec_size: int,
c_dtype: Type[cutlass.Numeric],
a_major: str,
b_major: str,
c_major: str,
mma_tiler_mn: Tuple[int, int],
cluster_shape_mn: Tuple[int, int],
use_tma_store: bool = True,
tolerance: float = 1e-01,
warmup_iterations: int = 0,
iterations: int = 1,
skip_ref_check: bool = False,
use_cold_l2: bool = False,
**kwargs,
):
"""Execute a persistent batched dense blockscaled GEMM operation on Blackwell architecture with performance benchmarking.
This function prepares input tensors, configures and launches the persistent GEMM kernel,
optionally performs reference validation, and benchmarks the execution performance.
:param mnkl: Problem size (M, N, K, L)
:type mnkl: Tuple[int, int, int, int]
:param ab_dtype: Data type for input tensors A and B
:type ab_dtype: Type[cutlass.Numeric]
:param sf_dtype: Data type for scale factor tensor
:type sf_dtype: Type[cutlass.Numeric]
:param sf_vec_size: Vector size for scale factor tensor
:type sf_vec_size: int
:param c_dtype: Data type for output tensor C
:type c_dtype: Type[cutlass.Numeric]
:param a_major/b_major/c_major: Memory layout of tensor A/B/C
:type a_major/b_major/c_major: str
:param mma_tiler_mn: MMA tiling size.
:type mma_tiler_mn: Tuple[int, int]
:param cluster_shape_mn: Cluster shape.
:type cluster_shape_mn: Tuple[int, int]
:param use_2cta_instrs: Whether to use 2CTA instructions.
:type use_2cta_instrs: bool, optional
:param use_tma_store: Whether to use TMA store.
:type use_tma_store: bool, optional
:param tolerance: Tolerance value for reference validation comparison, defaults to 1e-01
:type tolerance: float, optional
:param warmup_iterations: Number of warmup iterations before benchmarking, defaults to 0
:type warmup_iterations: int, optional
:param iterations: Number of benchmark iterations to run, defaults to 1
:type iterations: int, optional
:param skip_ref_check: Whether to skip reference result validation, defaults to False
:type skip_ref_check: bool, optional
:param use_cold_l2: Whether to use circular buffer strategy to ensure cold L2 cache, defaults to False
:type use_cold_l2: bool, optional
:raises RuntimeError: If CUDA GPU is not available
:raises ValueError: If the configuration is invalid or unsupported by the kernel
:return: Execution time of the GEMM kernel
:rtype: float
"""
print(f"Running Sm103 Persistent 3xfp4 Dense BlockScaled GEMM test with:")
print(f"mnkl: {mnkl}")
print(f"AB dtype: {ab_dtype}, SF dtype: {sf_dtype}, SF Vec size: {sf_vec_size}")
print(f"C dtype: {c_dtype}")
print(f"Matrix majors - A: {a_major}, B: {b_major}, C: {c_major}")
print(f"Mma Tiler (M, N): {mma_tiler_mn}, Cluster Shape (M, N): {cluster_shape_mn}")
print(f"Use TMA Store: {'True' if use_tma_store else 'False'}")
print(f"Tolerance: {tolerance}")
print(f"Warmup iterations: {warmup_iterations}")
print(f"Iterations: {iterations}")
print(f"Skip reference checking: {skip_ref_check}")
print(f"Use cold L2: {'True' if use_cold_l2 else 'False'}")
import torch
import cutlass.torch as cutlass_torch
# Unpack parameters
m, n, k, l = mnkl
# Skip unsupported testcase
if not Sm103BlockScaledPersistentDenseGemmKernel.can_implement(
ab_dtype,
sf_dtype,
sf_vec_size,
c_dtype,
mma_tiler_mn,
cluster_shape_mn,
m,
n,
k,
l,
a_major,
b_major,
c_major,
use_tma_store,
):
raise TypeError(
f"Unsupported testcase {ab_dtype}, {sf_dtype}, {sf_vec_size}, {c_dtype}, {mma_tiler_mn}, {cluster_shape_mn}, {m}, {n}, {k}, {l}, {a_major}, {b_major}, {c_major}, "
f"use_tma_store: {use_tma_store}"
)
if not torch.cuda.is_available():
raise RuntimeError("GPU is required to run this example!")
torch.manual_seed(1111)
# Create tensor A/B/C
a_ref = cutlass_torch.matrix(l, m, k, a_major == "m", cutlass.Float32)
b_ref = cutlass_torch.matrix(l, n, k, b_major == "n", cutlass.Float32)
c_ref = cutlass_torch.matrix(l, m, n, c_major == "m", cutlass.Float32)
a_tensor, a_torch = cutlass_torch.cute_tensor_like(
a_ref, ab_dtype, is_dynamic_layout=True, assumed_align=16
)
b_tensor, b_torch = cutlass_torch.cute_tensor_like(
b_ref, ab_dtype, is_dynamic_layout=True, assumed_align=16
)
c_tensor, c_torch = cutlass_torch.cute_tensor_like(
c_ref, c_dtype, is_dynamic_layout=True, assumed_align=32
)
# Mark tensor with byte alignment divisibility
a_tensor.mark_compact_shape_dynamic(
mode=1 if a_major == "k" else 0,
stride_order=(2, 0, 1) if a_major == "k" else (2, 1, 0),
divisibility=32 if ab_dtype == cutlass.Float4E2M1FN else 16,
)
b_tensor.mark_compact_shape_dynamic(
mode=1 if b_major == "k" else 0,
stride_order=(2, 0, 1) if b_major == "k" else (2, 1, 0),
divisibility=32 if ab_dtype == cutlass.Float4E2M1FN else 16,
)
c_tensor.mark_compact_shape_dynamic(
mode=1 if c_major == "n" else 0,
stride_order=(2, 0, 1) if c_major == "n" else (2, 1, 0),
divisibility=64 if ab_dtype == cutlass.Float4E2M1FN else 32,
)
# Create scale factor tensor SFA/SFB
def create_scale_factor_tensor(l, mn, k, sf_vec_size, dtype):
def ceil_div(a, b):
return (a + b - 1) // b
sf_k = ceil_div(k, sf_vec_size)
ref_shape = (l, mn, sf_k)
atom_m = (32, 4)
atom_k = 4
mma_shape = (
l,
ceil_div(mn, atom_m[0] * atom_m[1]),
ceil_div(sf_k, atom_k),
atom_m[0],
atom_m[1],
atom_k,
)
ref_permute_order = (1, 2, 0)
mma_permute_order = (3, 4, 1, 5, 2, 0)
# Create f32 ref torch tensor (cpu)
ref_f32_torch_tensor_cpu = cutlass_torch.create_and_permute_torch_tensor(
ref_shape,
torch.float32,
permute_order=ref_permute_order,
init_type=cutlass_torch.TensorInitType.RANDOM,
init_config=cutlass_torch.RandomInitConfig(
min_val=1,
max_val=3,
),
)
# Create f32 cute torch tensor (cpu)
cute_f32_torch_tensor_cpu = cutlass_torch.create_and_permute_torch_tensor(
mma_shape,
torch.float32,
permute_order=mma_permute_order,
init_type=cutlass_torch.TensorInitType.SCALAR,
init_config=cutlass_torch.ScalarInitConfig(value=1.0),
)
# convert ref f32 tensor to cute f32 tensor
cvt_sf_MKL_to_M32x4xrm_K4xrk_L(
from_dlpack(ref_f32_torch_tensor_cpu),
from_dlpack(cute_f32_torch_tensor_cpu),
)
cute_f32_torch_tensor = cute_f32_torch_tensor_cpu.cuda()
# reshape makes memory contiguous
ref_f32_torch_tensor_cpu = (
ref_f32_torch_tensor_cpu.permute(2, 0, 1)
.unsqueeze(-1)
.expand(l, mn, sf_k, sf_vec_size)
.reshape(l, mn, sf_k * sf_vec_size)
.permute(*ref_permute_order)
)
# prune to mkl for reference check.
ref_f32_torch_tensor_cpu = ref_f32_torch_tensor_cpu[:, :k, :]
# Create dtype cute torch tensor (cpu)
cute_tensor, cute_torch_tensor = cutlass_torch.cute_tensor_like(
cute_f32_torch_tensor_cpu,
dtype,
is_dynamic_layout=True,
assumed_align=16,
)
# Convert f32 cute tensor to dtype cute tensor
cute_tensor = cutlass_torch.convert_cute_tensor(
cute_f32_torch_tensor,
cute_tensor,
dtype,
is_dynamic_layout=True,
)
return ref_f32_torch_tensor_cpu, cute_tensor, cute_torch_tensor
sfa_ref, sfa_tensor, sfa_torch = create_scale_factor_tensor(
l, m, k, sf_vec_size, sf_dtype
)
sfb_ref, sfb_tensor, sfb_torch = create_scale_factor_tensor(
l, n, k, sf_vec_size, sf_dtype
)
# Configure gemm kernel
gemm = Sm103BlockScaledPersistentDenseGemmKernel(
sf_vec_size,
mma_tiler_mn,
cluster_shape_mn,
use_tma_store,
)
# Compute max active clusters on current device
hardware_info = cutlass.utils.HardwareInfo()
max_active_clusters = hardware_info.get_max_active_clusters(
cluster_shape_mn[0] * cluster_shape_mn[1]
)
# Initialize Stream
current_stream = cutlass_torch.default_stream()
# Compile gemm kernel
compiled_gemm = cute.compile(
gemm,
a_tensor,
b_tensor,
sfa_tensor,
sfb_tensor,
c_tensor,
max_active_clusters,
current_stream,
)
# Compute reference result
if not skip_ref_check:
# Execute kernel once for reference checking
compiled_gemm(
a_tensor, b_tensor, sfa_tensor, sfb_tensor, c_tensor, current_stream
)
print("Verifying results...")
res_a = torch.einsum("mkl,mkl->mkl", a_ref, sfa_ref)
res_b = torch.einsum("nkl,nkl->nkl", b_ref, sfb_ref)
ref = torch.einsum("mkl,nkl->mnl", res_a, res_b)
# Convert c back to f32 for comparison.
c_ref_device = c_ref.cuda()
cute.testing.convert(
c_tensor,
from_dlpack(c_ref_device, assumed_align=32).mark_layout_dynamic(
leading_dim=(1 if c_major == "n" else 0)
),
)
c_ref = c_ref_device.cpu()
if c_dtype in (cutlass.Float32, cutlass.Float16, cutlass.BFloat16):
torch.testing.assert_close(c_ref, ref, atol=tolerance, rtol=1e-02)
elif c_dtype in (cutlass.Float8E5M2, cutlass.Float8E4M3FN):
# Convert ref : f32 -> f8 -> f32
ref_f8_ = torch.empty(*(l, m, n), dtype=torch.uint8, device="cuda").permute(
1, 2, 0
)
ref_f8 = from_dlpack(ref_f8_, assumed_align=32).mark_layout_dynamic(
leading_dim=1
)
ref_f8.element_type = c_dtype
ref_device = ref.permute(2, 0, 1).contiguous().permute(1, 2, 0).cuda()
ref_tensor = from_dlpack(ref_device, assumed_align=32).mark_layout_dynamic(
leading_dim=1
)
cute.testing.convert(ref_tensor, ref_f8)
cute.testing.convert(ref_f8, ref_tensor)
ref = ref_device.cpu()
torch.testing.assert_close(c_ref, ref, atol=tolerance, rtol=1e-02)
def generate_tensors():
a_tensor, _ = cutlass_torch.cute_tensor_like(
a_ref, ab_dtype, is_dynamic_layout=True, assumed_align=16
)
b_tensor, _ = cutlass_torch.cute_tensor_like(
b_ref, ab_dtype, is_dynamic_layout=True, assumed_align=16
)
c_tensor, _ = cutlass_torch.cute_tensor_like(
c_ref, c_dtype, is_dynamic_layout=True, assumed_align=32
)
# Mark tensor to be byte aligned
a_tensor.mark_compact_shape_dynamic(
mode=1 if a_major == "k" else 0,
stride_order=(2, 0, 1) if a_major == "k" else (2, 1, 0),
divisibility=32 if ab_dtype == cutlass.Float4E2M1FN else 16,
)
b_tensor.mark_compact_shape_dynamic(
mode=1 if b_major == "k" else 0,
stride_order=(2, 0, 1) if b_major == "k" else (2, 1, 0),
divisibility=32 if ab_dtype == cutlass.Float4E2M1FN else 16,
)
c_tensor.mark_compact_shape_dynamic(
mode=1 if c_major == "n" else 0,
stride_order=(2, 0, 1) if c_major == "n" else (2, 1, 0),
divisibility=64 if ab_dtype == cutlass.Float4E2M1FN else 32,
)
_, sfa_tensor, _ = create_scale_factor_tensor(l, m, k, sf_vec_size, sf_dtype)
_, sfb_tensor, _ = create_scale_factor_tensor(l, n, k, sf_vec_size, sf_dtype)
return cute.testing.JitArguments(
a_tensor, b_tensor, sfa_tensor, sfb_tensor, c_tensor, current_stream
)
workspace_count = 1
if use_cold_l2:
one_workspace_bytes = (
a_torch.numel() * a_torch.element_size()
+ b_torch.numel() * b_torch.element_size()
+ sfa_torch.numel() * sfa_torch.element_size()
+ sfb_torch.numel() * sfb_torch.element_size()
+ c_torch.numel() * c_torch.element_size()
)
workspace_count = cute.testing.get_workspace_count(
one_workspace_bytes, warmup_iterations, iterations
)
exec_time = cute.testing.benchmark(
compiled_gemm,
workspace_generator=generate_tensors,
workspace_count=workspace_count,
stream=current_stream,
warmup_iterations=warmup_iterations,
iterations=iterations,
)
return exec_time # Return execution time in microseconds
if __name__ == "__main__":
def parse_comma_separated_ints(s: str) -> Tuple[int, ...]:
try:
return tuple(int(x.strip()) for x in s.split(","))
except ValueError:
raise argparse.ArgumentTypeError(
"Invalid format. Expected comma-separated integers."
)
parser = argparse.ArgumentParser(
description="Example of Sm103 3xfp4 Dense Persistent BlockScaled GEMM."
)
parser.add_argument(
"--mnkl",
type=parse_comma_separated_ints,
default=(4096, 4096, 6144, 2),
help="mnkl dimensions (comma-separated)",
)
parser.add_argument(
"--mma_tiler_mn",
type=parse_comma_separated_ints,
default=(256, 256),
help="Mma tile shape (comma-separated)",
)
parser.add_argument(
"--cluster_shape_mn",
type=parse_comma_separated_ints,
default=(2, 4),
help="Cluster shape (comma-separated)",
)
parser.add_argument("--ab_dtype", type=cutlass.dtype, default=cutlass.Float4E2M1FN)
parser.add_argument("--sf_dtype", type=cutlass.dtype, default=cutlass.Float8E8M0FNU)
parser.add_argument("--sf_vec_size", type=int, default=16)
parser.add_argument("--c_dtype", type=cutlass.dtype, default=cutlass.Float16)
parser.add_argument("--a_major", choices=["k"], type=str, default="k")
parser.add_argument("--b_major", choices=["k"], type=str, default="k")
parser.add_argument("--c_major", choices=["n"], type=str, default="n")
parser.add_argument(
"--use_tma_store", action="store_true", help="Use tma store or not"
)
parser.add_argument(
"--tolerance", type=float, default=1e-01, help="Tolerance for validation"
)
parser.add_argument(
"--warmup_iterations", type=int, default=0, help="Warmup iterations"
)
parser.add_argument(
"--iterations",
type=int,
default=1,
help="Number of iterations to run the kernel",
)
parser.add_argument(
"--skip_ref_check", action="store_true", help="Skip reference checking"
)
parser.add_argument(
"--use_cold_l2",
action="store_true",
default=False,
help="Use circular buffer tensor sets to ensure L2 cold cache",
)
args = parser.parse_args()
if len(args.mnkl) != 4:
parser.error("--mnkl must contain exactly 4 values")
if len(args.mma_tiler_mn) != 2:
parser.error("--mma_tiler_mn must contain exactly 2 values")
if len(args.cluster_shape_mn) != 2:
parser.error("--cluster_shape_mn must contain exactly 2 values")
run(
args.mnkl,
args.ab_dtype,
args.sf_dtype,
args.sf_vec_size,
args.c_dtype,
args.a_major,
args.b_major,
args.c_major,
args.mma_tiler_mn,
args.cluster_shape_mn,
args.use_tma_store,
args.tolerance,
args.warmup_iterations,
args.iterations,
args.skip_ref_check,
args.use_cold_l2,
)
print("PASS")
Reference in New Issue View Git Blame Copy Permalink