본문으로 건너뛰기

[vllm] RDNA4에서 Sparse 명령어로 Dense Skinny GEMM 가속하기: vLLM의 SWMMAC N=5~8 커널 분석

PR 링크: vllm-project/vllm#45559 상태: Merged | 변경: +1072 / -7

들어가며

로컬 환경이나 소규모 서빙 환경에서 LLM을 돌리면 decode 단계의 active batch는 대개 18 정도로 작습니다. 이때 Linear layer는 [N x K] @ [K x M] 형태에서 N이 매우 작은 skinny GEMM이 됩니다. 문제는 GPU의 matrix 명령어가 16x16 같은 고정된 tile shape을 전제로 설계되어 있다는 점입니다. RDNA4(GFX12)의 WMMA 명령어로 N=58을 계산하면 16행 중 절반 이상을 padding으로 채우게 되어 연산 자원의 대부분이 낭비됩니다.

이 PR은 이 문제를 SWMMAC(Sparse Wave Matrix Multiply-ACcumulate) 명령어로 풀어냅니다. 원래 2:4 structured sparsity용 명령어를 dense한 skinny 행렬에 "트릭"으로 적용해, 하나의 논리 행을 두 개의 sparse 행으로 펼쳐 instruction 용량을 채우는 방식입니다. 같은 아이디어는 Hugging Face의 MI300 커널 블로그와 IREE 이슈 #22863에서도 다뤄진 바 있으며, 이 PR은 이를 vLLM ROCm/GFX12 경로에 맞게 적용했습니다.

핵심 아이디어: 논리 행 1개 → sparse 행 2개

swmmac_f32_16x16x32 명령어는 A를 16x32이지만 "2:4 sparse"로 받습니다. 즉 각 행은 실제로 K=32 중 16개 값만 들고 있고, sparse_idx(selector)가 그 값들이 원래 어느 위치였는지를 알려줍니다. B는 dense한 32x16 fragment입니다.

여기서 트릭은:

  • sparse 행 2n: A[n, :]에서 짝수 번째 16-bit pair들을 선택
  • sparse 행 2n+1: 같은 A[n, :]에서 나머지(홀수 번째) pair를 선택
  • 둘 다 같은 B fragment와 곱해 두 개의 partial 누산 행을 생성
  • epilogue에서 인접한 두 행을 더해 최종 결과 복원

결과적으로 16행짜리 instruction에 N=8 논리 행이 정확히 들어맞고, 한 번의 instruction이 K=32를 dense하게 처리합니다. N=5~7도 padding 비율이 크게 줄어듭니다.

코드 분석

csrc/rocm/skinny_gemms.cuh — selector와 traits

// Selectors used by the SWMMAC sparse A operand. Even/odd lanes choose
// different 16-bit pairs from the A fragment.
static constexpr int32_t kSwmmacSelect01 = static_cast<int32_t>(0x44444444u);
static constexpr int32_t kSwmmacSelect23 = static_cast<int32_t>(0xEEEEEEEEu);

2:4 sparsity index는 4개 그룹당 2개의 2-bit 인덱스를 씁니다. 0x4(=01 00)는 위치 {0,1}, 0xE(=11 10)는 위치 {2,3}을 의미합니다. 즉 짝수 sparse 행은 각 4-그룹의 앞 pair, 홀수 sparse 행은 뒤 pair를 담당한다는 것을 하드웨어에 알리는 값입니다.

dtype별 intrinsic 차이는 traits로 추상화했습니다.

template <>
struct swmmac_traits<__hip_bfloat16> {
  using a_frag_t = swmmac_i16x8;
  using b_frag_t = swmmac_i16x16;
  __device__ __forceinline__ static swmmac_f32x8 mma(const a_frag_t a,
      const b_frag_t b, const swmmac_f32x8 acc, const int sparse_idx) {
    return __builtin_amdgcn_swmmac_f32_16x16x32_bf16_w32(a, b, acc, sparse_idx);
  }
  ...
};

A fragment는 8개(sparse이므로 32의 절반 중 lane 몫), B는 16개 원소이고 누산은 FP32 8개입니다. FP16도 같은 구조로 __builtin_amdgcn_swmmac_f32_16x16x32_f16_w32를 호출합니다.

A fragment 로딩: pair 선택을 레지스터 셔플로

const int sparse_row = lane & 15;
const int original_n = sparse_row >> 1;
if (original_n >= N) {
  return frag;   // N<8이면 남는 sparse 행은 0
}
const int lane_half = lane >> 4;
const bool select_high_pair = (sparse_row & 1) != 0;
...
const auto load0 = src_vec[0];
const auto load1 = src_vec[1];
if (select_high_pair) {
  frag_i32[0] = load0[1];
  frag_i32[1] = load0[3];
  frag_i32[2] = load1[1];
  frag_i32[3] = load1[3];
} else {
  frag_i32[0] = load0[0];
  ...
}

핵심은 original_n = sparse_row >> 1 입니다. lane 0,1은 둘 다 논리 행 0을, lane 2,3은 행 1을 읽습니다. 각 lane은 16개 bf16(=8개 int32)을 128-bit vector load 2번으로 가져온 뒤, int32 단위(= 16-bit pair 단위)로 짝수/홀수 인덱스만 골라 fragment를 구성합니다. 별도의 shuffle 명령 없이 레지스터 선택만으로 sparse layout을 만드는 깔끔한 방식입니다.

B 패널: nontemporal load + LDS ping-pong

skinny GEMM은 사실상 weight(B) 스트리밍이 병목인 memory-bound 연산입니다. 그래서 B 경로에 공이 많이 들어갔습니다.

// B panels are streamed through the kernel, so use nontemporal vector loads.
template <typename frag_t>
__device__ __forceinline__ frag_t
load_swmmac_b(const frag_t* __restrict__ ptr) {
  return __builtin_nontemporal_load(ptr);
}

weight는 한 번 읽고 재사용되지 않으므로 nontemporal hint로 캐시 오염을 줄입니다.

// Two B panels per wave. They are used as ping-pong buffers.
__shared__ __align__(16)
    scalar_t b_lds[WV_PER_GROUP][2][columns_per_wave][k_load_pad];

흐름은 prefetch_swmmac_b_panel(global → VGPR) → 현재 패널로 연산 → commit_swmmac_b_panel(VGPR → 다른 LDS 버퍼) 입니다. global load latency를 연산 뒤에 숨기는 전형적인 software pipelining이며, k_load_pad = k_load + 8 패딩으로 LDS bank conflict를 줄입니다. 동기화는 wave 단위로만 필요하므로 __syncthreads 대신 가벼운 fence를 사용합니다.

__device__ __forceinline__ void swmmac_lds_wave_fence() {
  asm volatile("s_waitcnt lgkmcnt(0)" ::: "memory");
  __syncwarp();
}

커널 템플릿과 범위 제한

template <typename scalar_t, int N, bool HAS_BIAS, int LOAD_GROUP,
          bool ALIGNED_K, int TILE_COLUMNS, int M_TILES_PER_WAVE, ...>
__global__ void __launch_bounds__(WV_PER_GROUP* THREADS_PER_WAVE)
    swmmacGemmRegular(...) {
  static_assert(N >= 5 && N <= 8);

N, bias 유무, K 정렬 여부 등을 compile-time 파라미터로 두어 분기를 제거했습니다. N=4는 측정 결과 이득이 없어 의도적으로 제외되었는데, N≤4는 기존 경로로도 underfill 손실이 상대적으로 작기 때문으로 보입니다.

빌드 및 디스패치

set(VLLM_SKINNY_SRC
  "csrc/rocm/skinny_gemms_llmm1.cu"
+ "csrc/rocm/skinny_gemms_swmmac.cu"
  ...

별도 translation unit으로 분리해 ninja 병렬 컴파일을 유지했습니다. 런타임 체크용 on_gfx120x()도 추가되었습니다.

리뷰에서 나온 논의

리뷰어 dllehr-amd는 두 가지 아키텍처 가드 불일치를 지적했습니다.

  1. Compile guard가 너무 좁다: 커널이 gfx1201만 컴파일되면 gfx1200은 런타임 체크는 통과하지만 실제 코드가 없는 상황이 됩니다. → #if defined(__gfx1200__) || defined(__gfx1201__)로 확장.
  2. Python dispatch gate가 너무 넓다: on_gfx12x()는 gfx1250까지 포함해 다른 ISA 장치에 잘못 진입할 수 있습니다. → 기존 on_rdna4() helper로 좁힘.

이는 ROCm 커널 작업에서 흔한 함정입니다. 컴파일 타임 가드, C++ 런타임 체크, Python 디스패치 조건 세 곳이 정확히 같은 장치 집합을 가리켜야 합니다. 하나라도 어긋나면 빈 커널이 실행되거나 지원되지 않는 instruction으로 크래시가 날 수 있습니다.

왜 이게 좋은가

AMD Radeon AI PRO R9700(gfx1201)에서 Qwen3-4B, concurrency 5~8 기준으로 측정한 36개 케이스 모두 개선되었습니다.

Workload Req throughput Out tok/s Mean E2EL
512/128 +23.0% +23.2% -19.0%
1024/256 +22.2% +22.5% -18.2%
1024/2048 +20.8% +21.2% -17.5%
8192/512 +9.8% +7.2% -6.5%

TTFT는 거의 변화가 없는데, prefill은 N이 크므로 이 경로를 타지 않기 때문입니다. 반대로 decode 비중이 큰 workload일수록 이득이 큽니다(긴 입력의 8192/512는 attention 비중이 커 개선폭이 작음). GSM8K 정확도도 baseline 0.8650 → 0.8666(strict)으로 동등하며, 평가 시간은 11:13 → 9:48로 단축되었습니다.

일반적 교훈

  • Instruction shape과 문제 shape의 미스매치는 곧 낭비다. padding을 줄이는 layout 재해석이 커널 튜닝보다 큰 이득을 줄 수 있습니다.
  • Sparse 명령어를 dense 연산에 쓸 수 있다. 하나의 dense 행을 상보적인 두 sparse 행으로 쪼개면, 하드웨어는 sparse 연산을 한다고 생각하지만 실제로는 정보 손실 없는 dense 곱입니다.
  • memory-bound 커널은 데이터 이동이 핵심이다. nontemporal load, VGPR prefetch, LDS ping-pong으로 weight 스트리밍을 최적화하는 것이 compute trick만큼 중요합니다.
  • 범위를 측정으로 정하라. N=4를 제외한 것처럼, 이득이 확인된 구간에만 새 경로를 적용하고 나머지는 기존 fallback을 유지하는 것이 안전합니다.

참고 자료

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

댓글

관련 포스트

PR Analysis 의 다른글