gpumode · 강의 아카이브
《GPU Mode》 L101 2025 · CUTLASS High priority transcript · failed

Learning CUTLASS the hard way

CUTLASS — NVIDIA 의 GEMM/Attention 템플릿 라이브러리 — 가 “어렵다” 는 평판은 두 개의 다른 어려움이 합쳐진 결과다. C++ 템플릿 메타프로그래밍의 어려움 + GPU 아키텍처의 어려움. Kapil Sharma 가 L029 Triton Internals 에 이어 같은 자세로 — “이미 도는 코드를 위에서 아래로 추적하면서 매번 한 layer 씩만 이해한다” — CUTLASS 를 풀어가는 학습 노트. 자막은 실패했으나 발표자의 공개 자료, NVIDIA / Colfax 의 tutorial, 그리고 cutlass/media/docs 의 정리에서 같은 path 를 재구성했다.

CUTLASS CuTe Mainloop Epilogue CollectiveOp GEMM FlashAttention TMA Hopper Layout
K
Speaker
Kapil Sharma
L029 (Triton Internals) 의 같은 발표자 — practitioner-side learning notes
강의 번호
L101
스피커
Kapil Sharma
자막
failed · 재구성
priority
High · 정독
§ 01강의가 풀려는 문제· 왜 “the hard way”

“공식 example 을 따라가도 왜 GEMM 한 줄이 안 잡히는가”

CUTLASS 의 공식 자료는 양도 많고 깊이도 있다. 하지만 처음 들어온 사람은 — example 을 다 돌려보고 docs 를 다 읽어도 — “내가 짠 GEMM 한 줄이 동작하지 않을 때 어디서부터 무엇을 봐야 하는가” 가 안 잡힌다. 이 강의가 풀려는 문제가 정확히 이 자리.

강의가 던지는 두 개의 질문.

  1. CUTLASS 의 추상 hierarchy 를 어떻게 머리에 넣는가 — 한 번에 다 이해하지 않고, 위에서 아래로 한 layer 씩.
  2. 어떤 자료를 어떤 순서로 읽으면 학습 곡선이 가장 가파르지 않은가 — 시간을 가장 적게 쓰는 path.

발표자의 자세는 practitioner-honest. 이 강의는 “CUTLASS 가 쉽다” 는 광고가 아니라 — “CUTLASS 가 어렵다는 사실 자체를 우회하지 않고, 그 어려움을 단계로 나누어 학습 가능한 chunk 로 만든다”. L029 Triton Internals 와 같은 자세의 follow-up.

강의의 인지적 frame

“the hard way” 는 더 어렵게 한다는 뜻이 아니라 — 지름길을 의도적으로 거부하고, layer 별로 정확히 이해하기 의 자세. Kapil 의 메시지는 “처음 한 번 정확히 따라가면 이후 GEMM kernel 은 변형”.

“CUTLASS 의 헷갈림은 거의 항상 두 layer 를 동시에 보려고 해서 생긴다. 한 번에 한 layer.”학습 노트 · Kapil 의 자세
§ 02CUTLASS 학습 곡선의 이유· 왜 어렵게 느껴지는가

두 종류의 어려움이 한꺼번에 들어와서

CUTLASS 가 어려운 이유를 분해하면 — 서로 직교적인 두 차원의 어려움이 같은 코드 라인에 합쳐져 있다는 사실이 드러난다. 이 둘을 분리해서 따로따로 정복하는 게 강의의 첫 학습 전략.

차원 1 — C++ 템플릿 메타프로그래밍

CUTLASS 는 type-level 로 모든 결정을 내린다. tile size, stages, layout, swizzle, predication 모두 template parameter. 한 GEMM kernel 의 type signature 가 화면 한 페이지를 넘긴다.

이 layer 의 어려움은 — error message 가 인간이 읽을 수 없는 형태로 나온다는 점. candidate template ignored: substitution failure 류의 SFINAE error 가 50줄로 떨어진다.

해결 전략 — 기존 template instantiation 을 출발점으로. 빈 캔버스에서 시작하지 않고, cutlass::gemm::device::Gemm<...> 의 known-working alias 부터 시작해서 한 parameter 만 바꿔본다.

차원 2 — GPU 아키텍처 디테일

같은 코드가 — TMA, WGMMA, async copy, register tile, swizzle, predication — 모두 알아야 의미가 잡힌다. Hopper(H100) 의 새 명령들 (wgmma.mma_async, cp.async.bulk.tensor) 이 “예전 CUDA 패턴” 과 어떻게 다른지를 알아야 mainloop 가 읽힌다.

이 layer 의 어려움은 — 아키텍처 변화의 절대 속도. Ampere → Hopper → Blackwell 마다 mainloop 의 큰 골격이 바뀐다. 한 번 배운 패턴이 1.5년만에 바뀐다.

해결 전략 — 한 아키텍처 (보통 H100) 한 케이스를 정확히 통과. 그 다음 다른 케이스로 옮길 때 무엇이 변했는지를 비교 학습.

Kapil 의 메시지

“두 차원을 동시에 풀려고 하지 마라. 먼저 C++ 으로 한 known-working kernel 을 손에 잡고 빌드 → 실행 → 측정. 그 다음에야 mainloop 안의 cp.async 한 줄을 이해하기 시작한다.”

그래서 학습 곡선은 — 머리 속에서는 한 곡선이지만 — 실제로는 두 곡선의 합이다. 한 쪽을 평평하게 만들고 다른 쪽을 올라가는 게 “the hard way” 의 진짜 의미.

§ 03처음 만나는 추상· Mainloop · Epilogue · CollectiveOp

CUTLASS 3.x 의 class hierarchy — 큰 골격

CUTLASS 3.x (CuTe-based) 의 한 GEMM kernel 의 클래스 hierarchy 를 layer 로 풀면 다음 5 단. 위에서 아래로 — 각 layer 가 무엇을 결정하고 무엇을 다음 layer 에 위임하는지.

FIG · CUTLASS 3.x GEMM 의 class hierarchytop-down 학습 path
LEVEL 0 cutlass::gemm::device::GemmUniversalAdapter사용자 facing — kernel 을 launch 한 줄로 GEMM 을 호출. 내부의 type 결정은 모두 wrapped.
LEVEL 1 kernel::GemmUniversal<CollectiveMainloop, CollectiveEpilogue, TileScheduler>kernel 진입점 grid 의 전체 흐름 — for tile : load → compute → store. 세 동료가 합쳐서 한 SM 에서 한 tile 을 처리.
LEVEL 2 collective::CollectiveMmamainloop = data load + tensor core math cp.async.bulk + wgmma 의 stage-pipelined loop. 가장 “GEMM 답다”.
LEVEL 3 collective::CollectiveEpilogueepilogue = bias + activation + store accumulator 를 register 에서 받아 fused op (relu, scale, bias) 후 global mem 에 store. activation 도 여기.
LEVEL 4 cute::* primitivescopy / mma / tile / partition 위 모든 layer 의 building block. cute::copy, cute::gemm, cute::partition_S, cute::local_tile.
CUTLASS 2.x 는 같은 일을 다른 단으로 나눴다 (warp-level / threadblock-level / device-level). 3.x 의 가장 큰 변화는 — collective 추상이 mainloop 와 epilogue 를 분리해 user 가 둘 중 하나만 swap 하기 쉬워졌다는 것.
학습의 첫 stop

처음 한 달은 — Level 0–1 만 본다. 즉 “GEMM 을 한 번 launch” 까지만. device::GemmUniversalAdapter 의 type alias 를 가져와 example 을 컴파일하고 측정. mainloop 안은 보지 않는다. 이 단계에서 “CUTLASS 의 빌드 시스템이 어떤 모양” 만 손에 잡힌다.

두 번째 달 — Level 2 (mainloop) 만. epilogue 는 그대로 두고 mainloop 안의 stages 와 tile size 를 바꿔본다. “성능이 어디서 만들어지는가” 의 첫 답이 여기서 나온다.

세 번째 달 — Level 3 (epilogue). bias / activation / scaling 의 fused 패턴을 직접 짜본다. 이 단계에서 처음으로 CuTe 의 layout을 만지게 된다 — accumulator → output tensor 의 mapping.

§ 04CuTe layout 의 진입· Shape · Stride · Layout function

CUTLASS 3.x 의 모든 길은 CuTe layout 을 거친다

CUTLASS 2.x 에서는 layout 이 iterator pattern 으로 표현됐다. 3.x 부터는 layout 이 일급 객체 — Layout = (Shape, Stride). 이 한 줄을 정확히 이해하는 게 모든 mainloop / epilogue 코드의 출발점.

// 가장 단순한 row-major 4×2
using ShapeA  = Shape<_4, _2>;
using StrideA = Stride<_2, _1>;
using LayoutA = Layout<ShapeA, StrideA>;

// 좌표 (i,j) → index = 2*i + 1*j

// hierarchical — block 안에 sub-block
using Hier = Layout<Shape<_2, Shape<_2,_2>>,
                     Stride<_4, Stride<_2,_1>>>;

// 좌표 (i, (j0, j1)) → index = 4*i + 2*j0 + 1*j1

두 예시의 차이가 — “flat layout 만으로는 표현 못하는 구조가 hierarchical 로 자연스럽게 표현된다” — CuTe 의 가장 큰 contribution 의 한 면.

Layout = 좌표 → index 의 함수

핵심 직관 한 줄 — “Layout 은 함수다.” 좌표 (자연 좌표 또는 1-D 좌표) 를 받아 메모리 index 를 돌려준다. crd2idx(coord, layout) 가 그 함수.

  • Shape — 도메인 (좌표 공간).
  • Stride — 좌표를 index 로 mapping 하는 가중치.
  • Layout(coord) — Shape 의 좌표를 받아 Stride 와 inner product 한 값.
왜 함수로 봐야 하는가

모든 layout algebra (composition, divide, product, complement) 가 함수의 합성과 분해 의 의미를 갖는다. 이 시각이 잡히면 logical_divide 같은 연산이 자연스럽게 “tile 로 자르기” 의 의미로 보인다.

layout algebra — 자주 쓰는 5 연산

coalesce
호환 가능한 mode 들을 합쳐 더 단순한 layout 으로. (_2,_4):(_1,_2)_8:_1. 같은 함수, 더 짧은 표기.
composition (∘)
함수 합성. R(c) = A(B(c)). 1-D layout 을 2-D 로 다시 보거나, 한 layout 을 다른 layout 으로 “관통” 하기.
complement
한 layout 이 안 채운 자리. tile 의 “나머지” 를 표현. divide 의 짝.
logical_divide
tile 로 자르기 — “건드리는 좌표 vs 안 건드리는 좌표” 로 분해. 이게 “tiling” 의 정식 정의.
logical_product
한 layout 을 다른 layout 의 모양대로 복제. tile 의 grid 를 만들 때.
zipped_divide / blocked_product
divide / product 의 사용자 친화 wrapper. tile 별로 좌표 접근이 깔끔해진다.
“Layout 을 함수로 보지 못하면 — divide, product, complement 가 모두 magical 하게 느껴진다. 함수로 본 뒤에는 — 당연한 합성/분해 다.”학습 노트
§ 05GEMM step-by-step· tile · cp.async.bulk · WGMMA · epilogue

한 SM 에서 한 tile 이 도는 동안 무슨 일이 벌어지는가

강의의 본론. 강의가 한 번에 정확히 따라간다고 약속한 “한 case” — Hopper (sm_90) FP16 GEMM. 이 한 케이스의 mainloop step-by-step 을 따라가면 다른 케이스 (FP8, sparse, FP4) 가 변형으로 보인다.

FIG · Hopper FP16 GEMM mainloop 의 한 stagecp.async.bulk → wait → wgmma
step 01
TMA producer warpgroup
한 warpgroup 이 cp.async.bulk.tensor 로 GMEM → SMEM. 비동기. 다른 warpgroup 이 동시에 다른 일을 한다.
step 02
mbarrier wait
consumer warpgroup 이 mbarrier::wait 로 도착 대기. async barrier 가 stage 간 dependency 를 잡는다.
step 03
wgmma issue
consumer 가 wgmma.mma_async.sync 발행. SMEM 의 A · B 타일을 register accumulator 에 곱해 더한다. async — 다음 wgmma 와 overlap.
step 04
commit + arrive
consumer 가 wgmma.commit_group 후 다음 mbarrier 에 arrive. producer 가 다음 stage 의 load 를 시작.
step 05
accumulator 누적
K 차원의 모든 tile 이 끝나면 register 에 partial dot product 가 쌓여 있음. 이것이 epilogue 의 input.
step 06
epilogue: scale/bias
accumulator 에 alpha, bias, activation (relu/gelu) 를 register 에서 fused. 별도 kernel launch 없음.
step 07
SMEM 으로 cooperative store
register → SMEM. swizzle 을 풀어 align. store 의 coalescing 을 위한 staging.
step 08
SMEM → GMEM
cp.async.bulk 또는 ld/st 로 결과 write. tile 종료. tile scheduler 가 다음 tile 을 할당.
위 흐름의 두 가지 중요한 통찰 — (1) async 가 모든 단계를 관통한다 (load, mma, store 모두 async). (2) warpgroup specialization: 한 warpgroup 이 producer (load), 다른 warpgroup 이 consumer (mma). 이 producer-consumer pattern 이 Hopper 의 새 mainloop 의 근본 형태.

tile size 의 결정 logic

한 tile 의 크기 (BM × BN × BK) 는 — (1) accumulator 가 register 에 들어가야 한다 + (2) SMEM 에 stage × (A_tile + B_tile) 이 들어가야 한다 의 두 부등식으로 결정된다.

H100 의 register file 64K × FP32 / SM 와 SMEM 228KB / SM 가 이 부등식의 우항. K 차원의 tile size (BK) 는 작아도 되는 (보통 32–128) 데 비해 M/N (보통 64–128) 가 커지면 register 가 빠르게 차오른다.

대표적 setup — BM=BN=128, BK=64, stages=3 or 4. WGMMA 의 native shape (m64n*k16 등) 의 multiple 로 맞춰져야 한다.

왜 stages 가 필요한가

load 와 mma 가 async 라도 — load 가 끝나기 전에 mma 가 시작되려면 다른 stage 의 데이터를 미리 가져와 둬야 한다. 그래서 stages = 3 또는 4 가 표준. 한 stage 가 mma 중일 때 다음 stage 가 load 중, 그 다음 stage 가 wait, 가장 멀리는 commit.

stages 늘리면 latency hiding 이 좋아지는 대신 SMEM 사용량 증가. SMEM 은 occupancy 의 직접적 결정 요소이므로 무한정 늘릴 수 없음. 측정해서 결정.

학습 trick

tile size 와 stages 의 변화에 따른 throughput 곡선을 직접 그려본다. CUTLASS 의 profiler tool 이 같은 일을 자동화. 한 GPU 에 한 모델 × 한 dtype 의 sweet spot 을 한 번 찾아두면 다음 변형은 이 baseline 의 작은 이동.

§ 06attention 응용· FlashAttention3 in CUTLASS

같은 mainloop 가 attention 에서 어떻게 변형되는가

강의의 응용 파트. FlashAttention-3 의 reference 구현이 사실상 CUTLASS 위에 쓰여 있다. GEMM 의 mainloop 와 attention 의 mainloop 의 공통점/차이점을 정리하면 — 한 번 GEMM 을 이해하고 attention 으로 옮길 때 어디만 새로 봐야 하는지가 명확해진다.

공통: producer-consumer warpgroup
FA3 도 TMA producer + WGMMA consumer 의 같은 골격. async pipeline 의 stage 수를 attention 의 K 차원이 아닌 sequence 차원에 맞춤.
공통: register accumulator
QK^T 의 partial dot product 가 register 에 쌓임. softmax 가 그 위에서 register-fused.
차이: online softmax
attention 만의 핵심 — running max + running sum 으로 softmax 를 streaming. 매 KV tile 마다 accumulator 를 rescale. GEMM 에는 없는 pattern.
차이: 두 GEMM
QK^T 와 softmax-V. 한 mainloop 안에 GEMM 이 두 번. softmax 가 사이를 잇는다.
차이: causal masking
tile 의 일부만 valid. predication 이 GEMM 보다 복잡.
차이: head/batch fusion
batch × heads × seq 의 큰 grid. CTA 별 work assignment 가 GEMM 의 단순한 (M/BM, N/BN) 보다 복잡.
학습 path

먼저 CUTLASS 의 flash_attention example 을 build → 측정. 그 다음 mainloop 의 두 GEMM 부분을 따로 떼어 GEMM 처럼 본다. 마지막으로 그 사이의 online softmax 를 추가. 이 순서를 거꾸로 (softmax 부터) 가면 길을 잃는다.

FA3 가 H100 위에서 WGMMA + TMA + warp specialization 의 모든 기능을 한꺼번에 동원한다. 이 한 example 을 따라가면 — Hopper 시대의 모든 “fast kernel” 이 같은 패턴이라는 사실이 잡힌다. L086 — FlashAttention 3L057 — CuTe 가 같은 자리의 깊이 보충.

§ 07자주 빠지는 함정· common pitfalls

강의가 직접 거론할 가능성이 큰 — 그리고 첫 학습자가 거의 확실히 빠지는 — 함정들

PITFALL 01
layout 의 row-major / col-major 를 직접 “기억” 하려 함
CUTLASS 는 보통 cutlass::layout::RowMajor 같은 type 을 쓴다. 이걸 외우려 들면 거의 항상 다른 example 에서 막힌다. 대신 — “이 layout 의 stride 가 무엇인가” 만 본다. row-major 4×N → stride (N, 1).
PITFALL 02
SFINAE error 메세지를 다 읽으려 함
한 줄에서 시작된 type mismatch 가 50줄이 되어 표시. 원인은 보통 첫 줄. “candidate template ignored” 의 첫 mismatch 만 보고 — type alias 가 어디가 어긋났는지 추적.
PITFALL 03
tile size 를 빠르게 바꿔보려 함
tile size 변경은 — collective config 를 다시 instantiate 하는 일. 한 줄 바꿔도 build 가 5 분. 한 build 에 한 변경 만 하고 측정.
PITFALL 04
CuTe 와 CUTLASS 2.x 추상을 섞음
old example 들이 아직 많아서 — Iterator pattern 과 Layout 이 한 codebase 에 같이 있다. 3.x 위주로 학습 시작 — 2.x 는 maintenance 코드만.
PITFALL 05
NCU profile 을 mainloop 안 한 줄로 매핑하려 함
async pipeline 때문에 NCU 의 “line-level” 매핑이 실제 cause 와 다르게 보임. “한 stage 가 어디서 막혔는가” 의 stage-level 시각으로 본다.
PITFALL 06
epilogue 의 fusion 을 mainloop 에 끼워넣으려 함
CUTLASS 3.x 의 분리는 의도적. mainloop 는 mma 만, epilogue 는 store 직전 fused op 만. 둘을 섞기 시작하면 hierarchy 의 가치를 잃는다.
PITFALL 07
아키텍처 detection 을 무시
__CUDA_ARCH__ 분기 없이 짠 코드는 — sm_80 에서는 cp.async, sm_90 에서는 cp.async.bulk 를 쓰는 — 패턴을 망친다. arch 별 specialization 은 처음부터 의식.
PITFALL 08
Python wrapper 부터 시작
cutlass-python (CuTe DSL) 이 매력적이지만 — 처음 학습은 C++ template 으로. Python 의 추상이 무엇을 감추는지를 알아야 디버그 가능.
§ 08학습 자료 navigation· 어디서부터 무엇을 읽는가

학습 시간을 가장 적게 쓰는 path

CUTLASS 와 CuTe 의 자료는 너무 많고 산재. 어떤 자료를 어떤 순서로 읽으면 학습 곡선이 가장 가파르지 않은지 — 강의의 가장 실용적인 부분이자 강의 후 가장 자주 다시 보게 되는 자리.

01 CUTLASS quickstart (cutlass/media/docs/cute/00_quickstart.md) CuTe 의 가장 작은 entry. Layout = (Shape, Stride) 의 정의 + 좌표 mapping. 30분.
02 cute/01_layout.md · 02_layout_algebra.md composition / divide / product / complement 의 정의와 직관. 한 시간씩.
03 CUTLASS gemm/00_basic_gemm example (build & run) 아무것도 수정하지 말고 그대로. Level 0–1 만. 컴파일이 도는 환경 확보 그 자체가 가치.
04 Colfax Research — “Tutorial: Matrix Transpose in CUTLASS” SMEM swizzle 의 의미를 잡는 가장 좋은 단일 자료. naïve → SMEM → swizzle 의 3 단계 구체 실험.
05 Colfax — “Mastering the NVIDIA TMA” Hopper 의 cp.async.bulk.tensor 의 정확한 모양. mainloop 의 producer 부분을 읽기 위한 prerequisite.
06 CUTLASS 3.x examples/cute/tutorial step-by-step 의 가장 정련된 path. transpose, copy, sgemm 을 거쳐 hopper gemm.
07 FlashAttention-3 (CUTLASS-based 구현) attention 응용. mainloop + online softmax + warp specialization 한 자리에서.
08 Jay Shah / Pradeep Ramani — “Fundamentals of CuTe Layout Algebra” L103 의 자료. category-theoretic 시각으로 layout algebra 를 다시 정리.
강의의 한 줄 권고

“이 path 는 약 3 개월 걸린다. 1 주에 한 자료 + 한 코드 변형. 짧게 가려는 시도 (예: 한 주 안에 다 끝내려는 시도) 는 거의 항상 실패한다 — Kapil 자신이 그렇게 시도했다고 (확인 필요). hard way 의 진짜 의미가 시간 자체.”

§ 09다음 단계· CuTe DSL · Python · CUTLASS 4

이 강의 이후 가야 할 자리

§ 10기억할 메모· key takeaways · refs

다시 열었을 때 5분 안에 손에 잡혀야 할 것

두 차원 분리
C++ template 의 어려움 vs GPU 아키텍처의 어려움. 한 번에 한 차원만 풀어라.
5-layer hierarchy
device adapter → kernel → CollectiveMma → CollectiveEpilogue → cute primitives. 위에서 아래로 한 layer 씩.
Layout = 함수
(Shape, Stride) 가 좌표 → index 의 함수. 모든 layout algebra 는 이 함수의 합성/분해.
producer-consumer warpgroup
Hopper mainloop 의 본질. TMA producer + WGMMA consumer + mbarrier 의 stage pipeline.
tile sizing
accumulator(register) + stage×(A+B)(SMEM) 의 두 부등식이 결정. 보통 BM=BN=128, BK=64, stages=3~4.
epilogue 분리
CUTLASS 3.x 의 의도. mainloop 와 epilogue 를 따로 swap. fused activation 은 epilogue 만 변경.
FA3 = 두 GEMM + online softmax
attention 의 mainloop 는 GEMM mainloop 의 두 번 + 그 사이 streaming softmax. 학습 path 의 자연스러운 다음 step.
학습 시간
정직한 path 는 3 개월. 짧게 가려는 시도는 거의 실패. weekly 한 자료 + 한 코드 변형.
YouTube youtube.com/watch?v=jGouxuAHIfQ · transcript failed
CUTLASS github.com/NVIDIA/cutlass · CUTLASS + CuTe
CuTe docs cutlass/media/docs/cpp/cute · 00_quickstart, 01_layout, 02_layout_algebra
Colfax tutorials colfax-intl.com matrix transpose · TMA tutorial · pingpong GEMM
FlashAttention-3 github.com/Dao-AILab/flash-attention · CUTLASS-based reference
L029 Triton Internals · 같은 발표자, 같은 자세의 prequel

손에 새기기 — 12주 path

  1. 주 1 — CUTLASS clone, build env (CUDA 12.x, sm_90 capable GPU), 00_basic_gemm example 을 그대로 build & run. 측정만.
  2. 주 2 — CuTe quickstart 와 01_layout. 좌표 → index 의 함수 식 직접 손으로. 5 개의 layout 예시를 실제 메모리 mapping 으로 그림.
  3. 주 3 — 02_layout_algebra. logical_dividelogical_product 의 작은 예시들 (tile of 4×4 in 16×16) 직접 풀어보기.
  4. 주 4 — Colfax matrix transpose tutorial. 세 단계 (naïve, SMEM, swizzle) 를 모두 build 해 측정. swizzle 이 왜 bank conflict 를 푸는지 손에 잡힐 때까지.
  5. 주 5 — Colfax TMA tutorial. cp.async.bulk.tensor 의 mode (load, store, multicast) 한 번씩 실행.
  6. 주 6 — CUTLASS examples/cute/tutorial 의 sgemm path. 한 mainloop 의 한 stage 의 모든 step 을 손으로 그려본다.
  7. 주 7 — Hopper GEMM example. tile size 한 번, stages 한 번 변경. 측정 비교.
  8. 주 8 — epilogue swap. activation (relu) 추가, bias 추가 — 같은 mainloop 위에 다른 epilogue 만.
  9. 주 9 — FlashAttention example build. mainloop 두 GEMM 부분만 분리해 GEMM 처럼 본다.
  10. 주 10 — online softmax 의 의미 손으로. running max + running sum 의 invariant.
  11. 주 11 — NCU 로 mainloop profile. async pipeline 의 stage-level 시각으로 stall 추적.
  12. 주 12 — 자기 모델의 한 GEMM 을 CUTLASS 로 짜본다. 첫 “custom” mainloop. 이 시점이 강의가 약속한 “practitioner” 진입점.
§ 11다른 강의로 이어지는 길· connections

L101 의 path 가 다른 강의들에서 깊이 보충되는 자리

§ 12열린 질문· open questions

다음에 다시 들었을 때 직접 검증해야 할 것들

검증 메모

이 노트의 mainloop step (§ 05) 과 hierarchy (§ 03) 는 CUTLASS 3.x 의 공식 docs (cute/00–02), Colfax 의 tutorial 시리즈, FlashAttention-3 의 reference 구현으로부터 일반화. Kapil 의 강의가 같은 path 를 따랐을 가능성이 매우 높지만 (L029 의 자세를 봤을 때) — 구체적 demo 와 코드는 비디오 재시청과 본인 repo 확인 필요.

← Lecture 100 InferenceX — Continuous OSS Inference Benchmarking Lecture 102 → Quartet v2 — FP4 training