본문으로 건너뛰기

[flashinfer] 작은 shape를 위한 TMA-ring Sage-FP8 Quantizer: CUDA Graph에서 최대 1.23배 빨라진 SM100 Block-Sparse Attention

PR 링크: flashinfer-ai/flashinfer#9500 상태: Merged | 변경: +2745 / -23

들어가며

FlashInfer의 Cake backend는 FP8 Sage block-sparse attention을 SM100(B200)/SM103(GB300)용으로 제공합니다. 데이터 형식은 하나뿐입니다. Q/K/V는 FP8 E4M3이고, Q/K는 per-token scale, V는 per-channel scale을 씁니다. 입출력은 BF16이고 layout은 BSHD입니다. 실행은 quantize → attention 두 단계로 이루어지며, 두 단계를 묶은 combined API bsa_attn_sm100_sage_quantize_fwd_cake도 있습니다.

문제는 shape가 작을 때 생깁니다. B1/H2/S4096처럼 attention 자체가 십여 µs에 끝나는 경우에는 quantize 단계의 launch 수와 동기화 비용이 전체 latency에서 큰 몫을 차지합니다. 기존 quantizer는 두 가지였습니다.

  • two_launch: Q/K kernel(V amax를 atomic으로 reduce) + V kernel. 여기에 V amax scratch를 비우는 zero_가 한 번 더 붙습니다.
  • one_launch: (batch, head)마다 thread-block cluster 하나를 띄우고, V max는 distributed shared memory로 reduce합니다.

그런데 one_launch는 CUDA-graph capture 안에서는 선택되지 않았습니다. 그래서 graph 모드의 작은 shape는 항상 two_launch로 갔습니다. eager 모드에서도 one_launch가 커버하지 못하는 GQA shape(B1/H32/Hkv8)가 있었습니다. 이 PR은 이 빈자리를 채우는 세 번째 quantizer impl="tma"를 추가합니다. 출력은 기존 quantizer와 bit-identical입니다.

코드 분석

1. TMA-ring quantizer의 구조 (__init__.py 상수)

QUANTIZE_IMPLS = ("auto", "one_launch", "two_launch", "tma")

_TMA_RECORDS = (("quantize_qkv_tma_x8", 8), ("quantize_qkv_tma_x4", 4))
_TMA_MAX_SEQLEN_K = 4096
_TMA_CLUSTER_CTAS, _TMA_VBOX_TOKENS, _TMA_VBOXES = 4, 256, 4

핵심 아이디어는 V의 128개 channel을 vsplit(8 또는 4) 조각으로 나누는 것입니다. 각 (batch, KV head, V slice)마다 4-CTA cluster 하나가 시퀀스 전체를 맡습니다. CTA 하나는 256-token V box를 4개까지 담을 수 있습니다. 따라서 cluster 하나가 처리할 수 있는 길이는 4 × 4 × 256 = 4096 token이고, 이 값이 seqlen_k 상한이 됩니다. per-channel V scale은 시퀀스 전체에 대한 amax가 필요합니다. 한 cluster가 시퀀스 전체를 들고 있으므로 global atomic이나 scratch buffer 없이 cluster 안에서 reduce를 끝낼 수 있습니다. 입력 데이터는 모두 TMA로 shared memory에 들어오고, V cluster로 쓰이지 않는 나머지 resident cluster가 Q/K tile을 나눠 처리합니다.

2. Occupancy 조회와 CUDA Graph 제약

_TMA_RESIDENT: dict = {}

def _tma_resident(name: str, device_index: int) -> Optional[int]:
    key = (name, device_index)
    resident = _TMA_RESIDENT.get(key)
    if resident is None:
        if torch.cuda.is_current_stream_capturing():
            return None
        resident = _loader.resident_clusters(_loader.MODULES[name], device_index)
        _TMA_RESIDENT[key] = resident
    return resident

이 부분이 실무적으로 가장 중요합니다. cluster occupancy를 조회하려면(cudaOccupancyMaxActiveClusters 계열) probe module을 load해야 하는데, 이 작업이 진행 중인 graph capture를 무효화합니다. 그래서 결과를 (record, device) 단위로 캐시하고, capture 중에 캐시가 비어 있으면 None을 반환해 다른 quantizer로 넘어가게 합니다.

캐시를 미리 채우는 위치도 눈여겨볼 만합니다. eager 모드에서 one_launch가 선택된 경우에도 TMA occupancy를 미리 조회해 둡니다.

impl = "one_launch"
# The same row inside a later CUDA-graph capture takes the TMA quantizer:
# query its occupancy now, outside the capture
if (_TMA_RECORDS[-1][0], device_index) not in _TMA_RESIDENT:
    for name, _ in _TMA_RECORDS:
        if name in _loader.MODULES:
            _tma_resident(name, device_index)

보통은 eager warmup을 한 뒤 graph를 capture합니다. warmup 단계에서 캐시를 채워 두면 capture 중에는 TMA 경로를 안전하게 탈 수 있습니다.

3. 라우팅: "한 wave에 들어가는가"

ctas = batch * kv_heads * _TMA_RECORDS[-1][1] * _TMA_CLUSTER_CTAS
if one_wave and ctas > _loader.sm_count(device_index):
    return None
...
for name, vsplit in shipped:
    resident = _tma_resident(name, device_index)
    if resident is None:
        return None
    if batch * kv_heads * vsplit <= resident:
        return name, vsplit, resident

먼저 driver에 묻지 않고 걸러내는 단계가 있습니다. 4-CTA cluster는 SM당 CTA를 최대 하나만 두므로, 가장 작은 split으로도 CTA 수가 SM 수를 넘으면 그 자리에서 바로 탈락시킵니다. 이 단계를 통과하면 vsplit=8부터 시도합니다. V cluster 수가 resident cluster 수 이하일 때만 채택합니다. 두 번째 wave가 생기는 순간 V slice가 직렬화되어 다른 quantizer보다 느려지기 때문입니다. impl="tma"를 명시한 경우(one_wave=False)에는 이 조건을 만족하지 못해도 vsplit=4로 강행합니다.

변경 전 auto 로직은 아래와 같았습니다.

# Before
impl = ("one_launch" if _one_launch_fits(...) else "two_launch")

변경 후에는 one_launch → tma → two_launch 순서의 3단계 fallback이 됩니다.

# After
else:
    tma = _tma_route(batch, kv_heads, seqlen_q, seqlen_k, device_index, one_wave=True)
    impl = "two_launch" if tma is None else "tma"

4. 리뷰에서 발견된 32-bit overflow

리뷰어 yyihuang이 kernel의 work partition 계산에서 overflow를 찾아냈습니다. impl="tma", B=64, H=Hkv=128, S=64일 때 CTA 수 × tile 수가 int 범위(2**31)를 넘습니다. seqlen_q가 매우 길면 auto 경로에서도 같은 일이 생길 수 있습니다. kernel 소스는 generated 파일이라 곧바로 고칠 수 없었고, 대신 host 쪽에 guard를 넣었습니다.

def _tma_partition_fits(batch, heads, kv_heads, seqlen_q, seqlen_k, tma) -> bool:
    _, vsplit, resident = tma
    q_tiles = batch * heads * _ceil_div(seqlen_q, TOKENS_PER_CTA)
    k_tiles = batch * kv_heads * _ceil_div(seqlen_k, TOKENS_PER_CTA)
    ctas = _TMA_CLUSTER_CTAS * max(batch * kv_heads * vsplit, resident)
    return ctas * (q_tiles + k_tiles) < 2**31

이 곱은 partition 안에서 나오는 모든 곱의 상한입니다. 검사에 실패하면 auto는 two_launch로 조용히 fallback하고, 사용자가 tma를 명시한 경우에는 ValueError를 던집니다. kernel 자체의 64-bit 연산은 다음 소스 재생성 때 반영될 예정입니다. 리뷰 과정에서는 이 밖에도 H100 CI에서 새 테스트가 실패해 @requires_sm100을 붙이는 수정이 있었습니다.

왜 이게 좋은가

CUDA graph 모드의 작은 shape에서 개선 폭이 큽니다. B200 기준 수치입니다.

shape sel main PR speedup
B1/H4/S4096 6 19.2 15.9 1.209
B1/H2/S4096 6 15.0 12.5 1.205
B1/H8/S4096 6 26.4 23.8 1.109

GB300에서도 B1/H4/S4096이 1.220배로 비슷한 경향을 보입니다. eager 모드에서는 one_launch가 맡지 못하던 GQA shape B1/H32/Hkv8/S4096이 GB300 combined API 기준 74.2 → 53.2 µs로 1.395배 빨라졌습니다. 반면 B8/H32, S32768 같은 큰 shape는 모두 1.000 근처를 유지합니다. 라우팅 조건이 큰 shape를 정확히 피해 가고 있다는 뜻입니다.

일반적 교훈

  1. 작은 문제에서는 launch 수와 scratch 초기화가 곧 비용입니다. zero_ + 2 launch를 1 launch로 줄이는 것만으로 수 µs를 아낄 수 있고, 십여 µs짜리 workload에서는 이것이 20% 차이로 이어집니다.
  2. global atomic reduce보다 cluster 단위 reduce가 낫습니다. reduce 차원 전체를 cluster 하나에 담을 수 있다면 scratch와 atomic이 함께 사라집니다.
  3. CUDA Graph capture 중에는 금지된 동작이 있습니다. module load나 occupancy 조회처럼 capture를 깨뜨리는 작업은 eager 경로에서 미리 실행해 캐시해 두어야 합니다.
  4. wave quantization을 라우팅 기준으로 삼습니다. "한 wave에 들어가는가"를 판단 기준으로 두면 빠른 경로가 느려지는 영역을 깔끔하게 배제할 수 있습니다.
  5. generated kernel의 결함은 host guard로 먼저 막습니다. 소스를 다시 생성하기 전까지 overflow 가능한 shape를 확실히 걸러내고, 명시적 요청에는 에러를, 자동 경로에는 fallback을 적용하는 방식이 실용적입니다.

참고 자료

⚠️ 알림: 이 분석은 AI가 실제 코드 diff를 기반으로 작성했습니다.

댓글

관련 포스트

PR Analysis 의 다른글