@kernaut/kernaut-resources 0.1.17-beta.1 → 0.1.18

package/resources/kop-2026-10-23-0.1.17-beta.1/product_capabilities/kernel_optflow/skills/KernelWiki-private/wiki/nvidia/code-walkthroughs/cutlass-cute/attention-fmha-example/README.md

@@ -1,148 +0,0 @@
----
-id: code-cutlass-cute-attention-fmha-example-README
-type: code-walkthrough
-vendor: nvidia
-title: Readme
-upstream_repo: NVIDIA/cutlass-cute
-architectures:
-- sm90
-- sm90a
-languages:
-- cuda-cpp
-- cute-dsl
-hardware_features:
-- wgmma
-- tma
-- fp8
-techniques:
-- warp-specialization
-- persistent-kernel
-- pipeline-stages
-- tile-scheduling
-- software-exp
-- conditional-rescaling
-kernel_types:
-- gemm
-- attention
-- flash-attention
-- quantization
-confidence: inferred
-evidence_level: inferred
-tags:
-- wgmma
-- tma
-- fp8
-- warp-specialization
-- persistent-kernel
-- pipeline-stages
-- tile-scheduling
-- software-exp
-- conditional-rescaling
-- gemm
-- attention
-- flash-attention
-- quantization
-- cuda-cpp
-- cute-dsl
----
-# cutlass example 88: Hopper FMHA
-
-This directory documents the extraction of cutlass `examples/88_hopper_fmha/` — the primary sm_90a flash multi-head attention implementation in the cutlass repository.
-
-## Source location
-
-```
-{{CUTLASS_REPO_REF}}/examples/88_hopper_fmha/
-├── 88_hopper_fmha.cu          # Runner: CLI parsing, reference comparison, timing
-├── CMakeLists.txt
-├── README.md                  # NVIDIA's own documentation
-├── collective/                # FMHA collective layer (16 headers)
-│   ├── fmha_collective_tma_warpspecialized.hpp   # Primary forward collective
-│   ├── fmha_collective_bwd_tma_warpspecialized.hpp
-│   ├── fmha_collective_load.hpp
-│   ├── fmha_collective_softmax.hpp
-│   ├── fmha_collective_tma.hpp
-│   ├── fmha_common.hpp
-│   ├── fmha_epilogue.hpp
-│   ├── fmha_epilogue_bwd.hpp
-│   └── fmha_fusion.hpp
-├── kernel/                    # Kernel layer: builder, scheduler, options
-│   ├── fmha_kernel_builder.hpp       # Dispatches to fmha_kernel_tma_warpspecialized
-│   ├── fmha_kernel_tma_warpspecialized.hpp
-│   ├── fmha_kernel_tma.hpp
-│   ├── fmha_options.hpp              # Tag-based option system
-│   ├── fmha_tile_scheduler.hpp
-│   ├── fmha_kernel_bwd_convert.hpp
-│   └── fmha_kernel_bwd_sum_OdO.hpp
-├── device/                    # Device layer: workspace orchestration
-│   ├── device_universal.hpp
-│   └── fmha_device_bwd.hpp
-└── reference/                 # CPU/GPU reference implementations for verification
-```
-
-Upstream commit: `cutlass@f74fea9c`.
-
-## Architecture overview
-
-The example follows cutlass's standard 4-layer architecture:
-
-1. **Runner** (`88_hopper_fmha.cu`): Parses command line (`--b`, `--h`, `--q`, `--k`, `--d`), allocates tensors, runs the kernel, compares against reference, reports timing.
-
-2. **Device layer** (`device/device_universal.hpp`): Orchestrates workspace allocation, kernel launch configuration, and multi-kernel scheduling for backward pass.
-
-3. **Kernel layer** (`kernel/fmha_kernel_builder.hpp` → `fmha_kernel_tma_warpspecialized.hpp`): The kernel entry point. `FmhaKernelBuilder` dispatches to the warp-specialized kernel template based on options. The kernel template manages the main loop, CTA scheduling, and interfaces with the collective layer.
-
-4. **Collective layer** (`collective/fmha_collective_tma_warpspecialized.hpp`): Contains the core FMHA logic — TMA-based Q/K/V loads, wgmma-based S=Q@K^T and O=P@V tiles, online softmax, and epilogue writeback. This is the most complex layer and is documented separately at `wiki/nvidia/code-walkthroughs/cutlass-cute/attention-fmha-collective/`.
-
-## Key types and entry points
-
-- **Runner entry**: `run()` in `88_hopper_fmha.cu` calls `device.run(args, workspace, stream)`.
-- **Kernel builder**: `cutlass::fmha::kernel::FmhaKernelBuilder<Options...>` in `fmha_kernel_builder.hpp`. This is the primary compile-time dispatch point.
-- **Options system**: `cutlass::fmha::kernel::Tag` enum in `fmha_options.hpp` defines compile-time knobs: `kIsPersistent`, `kNumMmaWarpGroups`, `kStagesQ`, `kStagesKV`, `kBlocksPerSM`, `kClusterM`, `kAccQK`, etc.
-- **Forward collective**: `cutlass::fmha::collective::FmhaCollectiveTmaWarpSpecialized` in `fmha_collective_tma_warpspecialized.hpp`.
-
-## Supported features
-
-- Forward pass (fp16, bf16, fp8)
-- Backward pass (fp16, bf16)
-- Causal masking
-- Warp-specialized (producer/consumer) mainloop
-- Persistent kernel scheduling
-- Multi-stage TMA pipeline (configurable via `kStagesQ`, `kStagesKV`)
-
-## sm_80 fallback context: `41_fused_multi_head_attention`
-
-Cutlass also ships `examples/41_fused_multi_head_attention/`, an older FMHA example targeting sm_80 (Ampere) using `mma.sync` instead of wgmma. This example:
-- Uses the pre-Hopper collective architecture (no TMA, no warp-specialization)
-- Supports fp16 and bf16 forward pass with causal masking
-- Source: `{{CUTLASS_REPO_REF}}/examples/41_fused_multi_head_attention/`
-
-It is not the primary extraction target (sm_90a/H200 requires `88_hopper_fmha`) but provides architectural context for understanding how FMHA evolved from Ampere to Hopper.
-
-## How to build and run
-
-Repo-local extracted wrapper: `artifacts/experience/api-probes/attention/cutlass_88_hopper_fmha.cu`
-Build script: `artifacts/experience/api-probes/attention/build_cutlass_fmha.sh`
-
-```bash
-# Set CUTLASS_DIR to your cutlass checkout (default: {{CUTLASS_REPO_REF}})
-cd artifacts/experience/api-probes/attention/
-CUTLASS_DIR=/path/to/cutlass bash build_cutlass_fmha.sh
-./88_hopper_fmha --b=2 --h=16 --q=1024 --k=1024 --d=128 --verify
-```
-
-The wrapper includes the upstream source via `#include "88_hopper_fmha.cu"` and requires the cutlass include tree at build time.
-
-## H200 measured results
-
-See sources/experience/api-probes/attention.md.
-
-| Config | Shape | TFLOPS/s | Correctness |
-|--------|-------|----------|-------------|
-| cooperative 128x128x128 | B2 H16 S1024 D128 full | 366.6 | OK |
-| ping-pong 128x128x128 | B2 H16 S1024 D128 full | 376.1 | OK |
-
-## Docs
-
-1. Read `tuning.md` for the compile-time and runtime knobs.
-2. Read `fmha_skeleton.md` for a guided tour of the code flow.

package/resources/kop-2026-10-23-0.1.17-beta.1/product_capabilities/kernel_optflow/skills/KernelWiki-private/wiki/nvidia/code-walkthroughs/cutlass-cute/attention-fmha-example/fmha_skeleton.md

@@ -1,138 +0,0 @@
----
-id: code-cutlass-cute-fmha_skeleton
-type: code-walkthrough
-vendor: nvidia
-title: Fmha_Skeleton
-upstream_repo: NVIDIA/cutlass-cute
-architectures:
-- sm90
-- sm90a
-languages:
-- cuda-cpp
-- cute-dsl
-hardware_features:
-- wgmma
-- tma
-- mbarrier
-- cluster
-techniques:
-- warp-specialization
-- persistent-kernel
-- pipeline-stages
-- kernel-fusion
-- shared-memory-optimization
-- tile-scheduling
-- software-exp
-- conditional-rescaling
-kernel_types:
-- gemm
-- attention
-- flash-attention
-- fused-kernel
-confidence: inferred
-evidence_level: inferred
-tags:
-- wgmma
-- tma
-- mbarrier
-- cluster
-- warp-specialization
-- persistent-kernel
-- pipeline-stages
-- kernel-fusion
-- shared-memory-optimization
-- tile-scheduling
-- software-exp
-- conditional-rescaling
-- gemm
-- attention
-- flash-attention
-- fused-kernel
-- cuda-cpp
-- cute-dsl
----
-# cutlass 88_hopper_fmha Code Skeleton
-
-A guided tour of the forward-pass code flow, referencing cutlass structs and functions by name (not by line number, per KB rules). All paths are relative to `{{CUTLASS_REPO_REF}}/examples/88_hopper_fmha/`.
-
-## 1. Entry point: `88_hopper_fmha.cu`
-
-The `run()` function:
-- Parses CLI options (`Options` struct): `--b` (batch), `--h` (heads), `--q`/`--k` (sequence lengths), `--d` (head dimension).
-- Instantiates the kernel type via `FmhaKernelBuilder`:
-
-```cpp
-using Kernel = typename cutlass::fmha::kernel::FmhaKernelBuilder<
-    cutlass::half_t, cutlass::half_t,  // Element types for Q/K and V/O
-    128,                                 // kHeadDim
-    /* Options... */
->::Kernel;
-```
-
-- Wraps in `cutlass::fmha::device::DeviceUniversal<Kernel>`.
-- Calls `device.run(args, workspace, stream)`.
-
-## 2. Kernel builder: `kernel/fmha_kernel_builder.hpp`
-
-`FmhaKernelBuilder<ElementQK, ElementVO, kHeadDim, Options...>`:
-- Uses the `find_option_t<Tag, Default, Options...>` mechanism from `fmha_options.hpp`.
-- Key compile-time constants resolved here:
-  - `kNumMmaWarpGroups` (default: 2; controls consumer warpgroup count; see `find_option_t` in `fmha_collective_tma_warpspecialized.hpp`)
-  - `kIsPersistent` (default: false; enables persistent kernel scheduling)
-  - `kStagesQ`, `kStagesKV` (pipeline stage counts)
-  - `kClusterM` (CTA cluster dimension)
-  - `kBlocksPerSM` (max CTAs co-resident per SM)
-- Dispatches to `FmhaKernelTmaWarpSpecialized` (the primary forward kernel).
-
-## 3. Forward kernel: `kernel/fmha_kernel_tma_warpspecialized.hpp`
-
-`FmhaKernelTmaWarpSpecialized`:
-- `operator()` is the `__global__` kernel entry.
-- Allocates shared memory for Q, K, V tiles and pipeline barriers.
-- Calls the collective's `mainloop()` to execute the attention computation.
-- Calls the collective's `epilogue()` to write output.
-
-## 4. Tile scheduler: `kernel/fmha_tile_scheduler.hpp`
-
-- Manages the mapping from CTA index to (batch, head, Q-tile) work items.
-- For persistent kernels, implements work-stealing across the grid.
-
-## 5. Forward collective: `collective/fmha_collective_tma_warpspecialized.hpp`
-
-`FmhaCollectiveTmaWarpSpecialized`:
-- This is the core of the FMHA algorithm. It implements a warp-specialized mainloop:
-  - **Producer warpgroup**: issues TMA loads for K/V tiles into smem pipeline stages.
-  - **Consumer warpgroup(s)**: execute wgmma for S=Q@K^T and O=P@V, plus online softmax.
-- Key methods:
-  - `load()`: TMA-driven K/V tile loading, managed by mbarrier-based pipeline.
-  - `mma()`: wgmma-based matmul, accumulator management, softmax integration.
-  - `epilogue()`: final rescale and writeback.
-
-## 6. Softmax: `collective/fmha_collective_softmax.hpp`
-
-- Implements the online softmax algorithm (FlashAttention-2 style).
-- Tracks per-row running max and running sum.
-- Performs accumulator rescaling when the max updates.
-- Uses warp-level reductions (`__shfl_xor_sync`) for rowmax and rowsum across threads.
-
-## 7. Epilogue: `collective/fmha_epilogue.hpp`
-
-- Writes the final attention output from registers to global memory.
-- Applies the final `1/l_i` normalization.
-- Supports TMA store or direct global store depending on configuration.
-
-## 8. Fusion hooks: `collective/fmha_fusion.hpp`
-
-- Defines the interface for custom attention fusions (e.g., causal mask, ALiBi, custom score modifications).
-- The default is `FmhaFusionNone`; `FmhaFusionCausal` implements causal masking.
-
-## Navigation guide
-
-| To understand... | Read... |
-|---|---|
-| The overall data flow | `88_hopper_fmha.cu` `run()` → `DeviceUniversal::run()` |
-| How tiles are configured | `fmha_kernel_builder.hpp` (compile-time option resolution) |
-| The mainloop algorithm | `fmha_collective_tma_warpspecialized.hpp` `load()` + `mma()` |
-| Online softmax | `fmha_collective_softmax.hpp` |
-| TMA pipeline management | `fmha_collective_load.hpp` |
-| Tuning knobs | `fmha_options.hpp` (Tag enum) |

package/resources/kop-2026-10-23-0.1.17-beta.1/product_capabilities/kernel_optflow/skills/KernelWiki-private/wiki/nvidia/code-walkthroughs/cutlass-cute/attention-fmha-example/tuning.md

@@ -1,109 +0,0 @@
----
-id: code-cutlass-cute-attention-fmha-example-tuning
-type: code-walkthrough
-vendor: nvidia
-title: Tuning
-upstream_repo: NVIDIA/cutlass-cute
-architectures:
-- sm90
-- sm90a
-languages:
-- cuda-cpp
-- cute-dsl
-hardware_features:
-- wgmma
-- tma
-- mbarrier
-- cluster
-techniques:
-- warp-specialization
-- persistent-kernel
-- pipeline-stages
-- double-buffering
-- register-budgeting
-- shared-memory-optimization
-- tma-multicast
-kernel_types:
-- gemm
-- attention
-- flash-attention
-confidence: inferred
-evidence_level: inferred
-tags:
-- wgmma
-- tma
-- mbarrier
-- cluster
-- warp-specialization
-- persistent-kernel
-- pipeline-stages
-- double-buffering
-- register-budgeting
-- shared-memory-optimization
-- tma-multicast
-- gemm
-- attention
-- flash-attention
-- cuda-cpp
-- cute-dsl
----
-# cutlass 88_hopper_fmha Tuning Parameters
-
-## Compile-time knobs (via `fmha_options.hpp` Tag system)
-
-| Knob | Tag | Default | Allowed values | Effect |
-|---|---|---|---|---|
-| Head dimension | `kHeadDim` (template param) | 128 | 64, 128, 256 | Determines the K/inner dimension of Q@K^T. Larger D increases smem per tile. |
-| MMA warpgroups | `Tag::kNumMmaWarpGroups` | 2 | 1, 2 | Number of consumer warpgroups computing wgmma. Default 2 in the warp-specialized collective. 1 halves compute parallelism but reduces register/smem pressure. |
-| Persistent kernel | `Tag::kIsPersistent` | false | true, false | Enables persistent-kernel scheduling (CTAs loop over work items instead of one-shot). Improves occupancy for small batch/head counts. |
-| Q pipeline stages | `Tag::kStagesQ` | auto | 1, 2 | Number of smem pipeline stages for Q tiles. 2 enables double-buffering. |
-| KV pipeline stages | `Tag::kStagesKV` | auto | 2, 3, 4 | Number of smem pipeline stages for K/V tiles. More stages hide TMA latency. |
-| Cluster M | `Tag::kClusterM` | 1 | 1, 2, 4 | CTA cluster size in the M (Q-tile) dimension. Enables TMA multicast across clustered CTAs. |
-| Blocks per SM | `Tag::kBlocksPerSM` | auto | 1, 2 | Max CTAs co-resident per SM. Higher increases occupancy but reduces per-CTA smem/register budget. |
-| Q loaded separately | `Tag::kLoadsQSeparately` | false | true, false | If true, Q is loaded by a dedicated producer warpgroup; otherwise Q shares the K/V producer. |
-| Mainloop locked | `Tag::kIsMainloopLocked` | false | true, false | If true, mainloop uses lock-based synchronization instead of mbarrier. |
-| Epilogue locked | `Tag::kIsEpilogueLocked` | false | true, false | Same as above for epilogue. |
-| Accumulator QK | `Tag::kAccQK` | f32 | f32, f16 | Accumulator precision for the S=Q@K^T product. f16 saves registers but loses precision. |
-| Epilogue kind | `Tag::kEpilogueKind` | default | default, residual | Controls epilogue behavior (e.g., residual connections). |
-
-## Runtime parameters
-
-| Parameter | CLI flag | Default | Effect |
-|---|---|---|---|
-| Batch size | `--b` | 16 | Number of sequences in the batch. |
-| Number of heads | `--h` | 16 | Number of attention heads. |
-| Query sequence length | `--q` | 1024 | Length of the Q sequence. |
-| Key/Value sequence length | `--k` | 1024 | Length of the K/V sequence. |
-| Head dimension | `--d` | 128 | Must match compile-time `kHeadDim`. |
-| Attention mask | `--mask` | `no` | Masking mode: `no` (full attention), `causal` (triangular), or `residual`. Parsed in `88_hopper_fmha.cu` main function. |
-| Backward pass | `--bwd` | false | Run backward pass in addition to forward. |
-| Verification | `--verify` | false | Compare against CPU/GPU reference. |
-
-## Tile shape derivation
-
-The tile shape is derived from compile-time parameters:
-- **BLOCK_M** = 64 × `kNumMmaWarpGroups` (64 for 1 warpgroup, 128 for 2)
-- **BLOCK_N** = derived from head dimension and smem budget
-- **K-dimension** = `kHeadDim` (fixed per tile iteration for Q@K^T)
-
-## Interaction map
-
-```
-kNumMmaWarpGroups ─→ BLOCK_M (tile height)
-                   ─→ register pressure (more warpgroups = more accumulators)
-                   ─→ smem per CTA (Q tile grows with BLOCK_M)
-
-kStagesKV ─────────→ smem per CTA (K/V buffers multiply)
-                   ─→ TMA latency hiding (more stages = better hiding)
-                   ─→ kBlocksPerSM (more stages = fewer co-resident CTAs)
-
-kClusterM ─────────→ TMA multicast efficiency
-                   ─→ grid utilization (cluster must divide grid-M evenly)
-
-kIsPersistent ─────→ kernel scheduling model
-                   ─→ useful when grid is smaller than SM count
-```
-
-## Source reference
-
-All knobs are defined in `kernel/fmha_options.hpp` as `Tag` enum values and consumed by `kernel/fmha_kernel_builder.hpp` via `find_option_t<Tag, Default, Options...>`.

package/resources/kop-2026-10-23-0.1.17-beta.1/product_capabilities/kernel_optflow/skills/KernelWiki-private/wiki/nvidia/code-walkthroughs/cutlass-cute/example48-hopper-warp-specialized-gemm/README.md

@@ -1,90 +0,0 @@
----
-id: code-cutlass-cute-example48-hopper-warp-specialized-gemm-README
-type: code-walkthrough
-vendor: nvidia
-title: Readme
-upstream_repo: NVIDIA/cutlass-cute
-architectures:
-- sm90
-- sm90a
-languages:
-- cuda-cpp
-- cute-dsl
-hardware_features:
-- wgmma
-- tma
-- cluster
-techniques:
-- warp-specialization
-- pipeline-stages
-- shared-memory-optimization
-- tma-multicast
-kernel_types:
-- gemm
-confidence: inferred
-evidence_level: inferred
-tags:
-- wgmma
-- tma
-- cluster
-- warp-specialization
-- pipeline-stages
-- shared-memory-optimization
-- tma-multicast
-- gemm
-- cuda-cpp
-- cute-dsl
----
-# wiki/nvidia/code-walkthroughs/cutlass-cute/example48-hopper-warp-specialized-gemm
-
-This directory is a CUTLASS reading guide for:
-
-```text
-examples/48_hopper_warp_specialized_gemm/48_hopper_warp_specialized_gemm.cu
-```
-
-It explains the example as one complete Hopper GEMM, not as separate TMA and warp-specialization topics. The runnable artifact for this path lives at:
-
-- `artifacts/experience/api-probes/gemm/gemm_aligned.cu`
-
-No buildable code lives here.
-
-## What This Example Demonstrates
-
-Example 48 is the smallest useful CUTLASS example where these Hopper pieces appear together:
-
-| Layer | CUTLASS / CuTe object | What it means |
-|---|---|---|
-| CTA tile | `TileShape = Shape<_128,_128,_32>` | one CTA computes a 128 x 128 output tile over K chunks of 32 |
-| CTA cluster | `ClusterShape = Shape<_4,_2,_1>` | 8 CTAs cooperate as a 4-by-2 cluster |
-| Producer side | `cute::copy(tma_atom, gmem, smem)` | TMA moves A/B tiles from global memory to shared memory |
-| Consumer side | `cute::gemm(tiled_mma, sA, sB, accum)` | WGMMA consumes shared-memory operands |
-| Synchronization | `PipelineTmaAsync` / mbarriers | producer commits smem stages; consumers wait and release |
-| Schedule | `KernelTmaWarpSpecializedCooperative` via `KernelScheduleAuto` | producer / consumer warpgroup split with cooperative cluster behavior |
-
-Read this directory when you want to understand the source file's structure: how the template parameters, TMA copy path, WGMMA issue path, cluster shape, and warp-specialized schedule fit together.
-
-## What Belongs Elsewhere
-
-- WGMMA atom name decoding: `../wgmma-atom-decoding/`
-- TMA hardware concept and pitfalls: `wiki/nvidia/hardware/tma/`
-- Warp-specialization as a general algorithm: `wiki/nvidia/techniques/warp-specialization/`
-- Performance probes and measured evidence: `sources/experience/api-probes/gemm/`
-
-## File Map
-
-- `mainloop_skeleton.md` — the compact tour through example 48's template setup and producer / consumer mainloop.
-
-## Key Reading Order
-
-1. Start with `mainloop_skeleton.md`.
-2. If `MMA_64x128x8_F32TF32TF32_SS_TN` is unclear, branch to `../wgmma-atom-decoding/wgmma_skeleton.md`.
-3. If `ClusterShape` or schedule selection is unclear, stay in this directory: example 48's TMA multicast and cooperative schedule only make sense together.
-
-## Cross-references
-
-- Aligned GEMM probe: `sources/experience/api-probes/gemm.md`
-- TMA counters: `sources/experience/api-probes/gemm.md`
-- WGMMA counters: `sources/experience/api-probes/gemm.md`
-- Warp-specialization ablation: `sources/experience/api-probes/gemm.md`
-- Upstream (pinned): `cutlass@f74fea9c` (`{{CUTLASS_REPO_REF}}`)

package/resources/kop-2026-10-23-0.1.17-beta.1/product_capabilities/kernel_optflow/skills/KernelWiki-private/wiki/nvidia/code-walkthroughs/cutlass-cute/example48-hopper-warp-specialized-gemm/mainloop_skeleton.md

@@ -1,174 +0,0 @@
----
-id: code-cutlass-cute-mainloop_skeleton
-type: code-walkthrough
-vendor: nvidia
-title: Mainloop_Skeleton
-upstream_repo: NVIDIA/cutlass-cute
-architectures:
-- sm90
-- sm90a
-languages:
-- cuda-cpp
-- cute-dsl
-hardware_features:
-- wgmma
-- tma
-- mbarrier
-- cluster
-techniques:
-- warp-specialization
-- pipeline-stages
-- data-reuse
-- shared-memory-optimization
-- tma-multicast
-kernel_types:
-- gemm
-confidence: inferred
-evidence_level: inferred
-tags:
-- wgmma
-- tma
-- mbarrier
-- cluster
-- warp-specialization
-- pipeline-stages
-- data-reuse
-- shared-memory-optimization
-- tma-multicast
-- gemm
-- cuda-cpp
-- cute-dsl
----
-# Example 48 Mainloop Skeleton (cutlass commit `f74fea9c`)
-
-This is the compact mental model for `48_hopper_warp_specialized_gemm.cu`: one CUTLASS Hopper GEMM that combines TMA, WGMMA, CTA clusters, and a warp-specialized producer / consumer mainloop.
-
-## Template Shape
-
-The key compile-time setup is:
-
-```cpp
-using TileShape    = Shape<_128, _128, _32>;
-using ClusterShape = Shape<_4,   _2,   _1>;
-
-using CollectiveMainloop = typename cutlass::gemm::collective::CollectiveBuilder<
-    ArchTag, OperatorClass,
-    ElementA, LayoutA, AlignmentA,
-    ElementB, LayoutB, AlignmentB,
-    ElementAccumulator,
-    TileShape, ClusterShape,
-    StageCountAuto,
-    KernelScheduleAuto
-  >::CollectiveOp;
-```
-
-Read this as:
-
-```text
-one CTA tile:     128 x 128 x 32
-one CTA cluster:   4 x   2 x  1 CTAs
-cluster covers:   512 x 256 x 32
-```
-
-`CollectiveBuilder` uses these parameters to choose the TMA copy atoms, WGMMA atom, shared-memory layouts, pipeline shape, and schedule policy.
-
-## ClusterShape and TMA Multicast
-
-For GEMM:
-
-```text
-C[m,n] += A[m,k] * B[k,n]
-```
-
-With `ClusterShape<_4,_2,_1>`, the cluster has 4 CTAs along M and 2 CTAs along N:
-
-```text
-        N0        N1
-M0   CTA(0,0)  CTA(0,1)
-M1   CTA(1,0)  CTA(1,1)
-M2   CTA(2,0)  CTA(2,1)
-M3   CTA(3,0)  CTA(3,1)
-```
-
-That creates two reuse directions:
-
-- A tile reuse: CTAs with the same M and different N share `A[m,k]`; fanout is `ClusterShape.N = 2`.
-- B tile reuse: CTAs with the same N and different M share `B[k,n]`; fanout is `ClusterShape.M = 4`.
-
-CUTLASS therefore selects the multicast TMA form:
-
-```text
-SM90_TMA_LOAD_MULTICAST
-cp.async.bulk.tensor.*.shared::cluster.global.tile...
-```
-
-One TMA transaction can read a global tile once and distribute it to multiple CTAs' shared memory inside the hardware cluster.
-
-## Producer / Consumer Mainloop
-
-The mainloop is a staged shared-memory pipeline:
-
-```cpp
-// producer role
-pipeline.producer_acquire(stage);
-cute::copy(tma_atom_a, gA, sA);        // TMA load A tile
-cute::copy(tma_atom_b, gB, sB);        // TMA load B tile
-pipeline.producer_commit(stage);       // mbarrier arrives for consumers
-
-// consumer role
-pipeline.consumer_wait(stage);         // wait for TMA stage to become visible
-warpgroup_fence_operand(accum);        // wgmma.fence
-cute::gemm(tiled_mma, sA, sB, accum);  // repeated wgmma.mma_async issues
-warpgroup_commit_batch();              // wgmma.commit_group
-warpgroup_wait<0>();                   // wgmma.wait_group 0
-pipeline.consumer_release(stage);      // stage can be reused by producer
-```
-
-The producer side is about feeding shared memory with TMA. The consumer side is about issuing WGMMA from shared memory. `PipelineTmaAsync` and mbarriers connect the two sides.
-
-## WGMMA Atom Used
-
-For the TF32 example path, the selected atom is:
-
-```cpp
-MMA_Atom<MMA_64x128x8_F32TF32TF32_SS_TN<1,1>>
-```
-
-Meaning:
-
-```text
-one WGMMA instruction computes: 64 x 128 x 8
-CTA tile is:                    128 x 128 x 32
-repeat pattern:                   2 x   1 x  4 atom issues
-```
-
-For atom-name decoding, see `../wgmma-atom-decoding/wgmma_skeleton.md`.
-
-## Schedule Meaning
-
-In this example, `KernelScheduleAuto` resolves to the cooperative warp-specialized path for the large aligned configuration:
-
-```text
-producer role: TMA global -> shared
-consumer role: WGMMA shared -> accumulator
-cluster role: multicast and cooperative scheduling across CTAs
-```
-
-This is why the source file cannot be understood cleanly by reading "TMA" and "warp-specialization" independently. The example's point is the interaction:
-
-```text
-ClusterShape enables multicast
-multicast feeds the producer side efficiently
-PipelineTmaAsync connects producer and consumer
-WGMMA consumes the staged smem operands
-KernelTmaWarpSpecializedCooperative ties the policy together
-```
-
-## Cross-references
-
-- Directory overview: `README.md`
-- WGMMA atom decoding: `../wgmma-atom-decoding/wgmma_skeleton.md`
-- TMA hardware feature: `wiki/nvidia/hardware/tma/skill.md`
-- Warp-specialization algorithm: `wiki/nvidia/techniques/warp-specialization.md`
-- Aligned GEMM probe: `sources/experience/api-probes/gemm.md`
-- Upstream source: `{{CUTLASS_REPO_REF}}/examples/48_hopper_warp_specialized_gemm/48_hopper_warp_specialized_gemm.cu`