submission 681382
pawelniegowski-a2 · python · License unknown
Use it
Vendorable · source mirrored · license unknownView source →
No package. Vendor the mirrored source: 2218 lines, June 9 Researcher Reciprocity License v1.0.
makora_generate.py
curl "https://kernelindex.com/api/v1/implementations/kernelbot-amd-mxfp4-mm-681382?include=source"interfacepython
Compatibility
measured onAMD Instinct MI355X
declared hardwareAMD Instinct MI355X
architecturesgfx950
dtypesbf16, mxfp4
Benchmark evidence
1 measurement across 1 GPU, fastest first.
Operation / workload
Hardware
Latency
Rank
Observed
Reported · How evidence levels are derived →
Source and license
sourceavailable
revision digestsha256:067fcb7354e0aeb34fab09d3e00fcb23ba9853c6697a915a0522c68cd7ffd926
license declaredunknown
license concludedunknown
authorspawelniegowski-a2
imported2026-08-15
Techniques
Extracted from the mirrored source by pattern, never inferred. Each row cites its line.
shared-memory
__shared__ float lds_reduce[SK * 2 * WAVE_SIZE * 16];split-k
template<bool IS_SPLITK, bool NO_BOUNDS>vector-width = float4
float4 s = *reinterpret_cast<const float4*>(ws + i4);Kernel source
makora_generate.py2218 lines
#!POPCORN leaderboard amd-mxfp4-mm
#!POPCORN gpu MI355X
import os
os.environ['PYTORCH_ROCM_ARCH'] = 'gfx950'
import torch
from torch.utils.cpp_extension import load_inline
from task import input_t, output_t
SCALE_GROUP_SIZE = 32
# v77: v76 (2.28x) + 1x2 register tiling for VALU-bound M<=64 shapes
# M<=16: v73's fused 16x16x128 kernel
# 16<M<=64 + N%64==0 + VALU-bound: fused 32x32x64 with 1x2 tiling (2 MFMAs per A quant)
# 16<M<=64 + short K: fused 32x32x64 standard
# M>64: v69's separate HIP quant kernel + non-fused GEMM
CUDA_SRC = r"""
#undef __HIP_NO_HALF_CONVERSIONS__
#undef __HIP_NO_HALF_OPERATORS__
#include <hip/hip_runtime.h>
#include <hip/hip_bf16.h>
#include <cstdint>
using fp4x2_t = uint8_t;
using fp4x64_t = fp4x2_t __attribute__((ext_vector_type(32)));
using fp32x16_t = float __attribute__((ext_vector_type(16)));
using fp32x4_t = float __attribute__((ext_vector_type(4)));
// Packed bf16x2 type for direct bf16->FP4 conversion
typedef __attribute__((ext_vector_type(2))) __bf16 bf16x2_t;
#define WAVE_SIZE 64
// Scheduling masks
#define MASK_VMEM_READ 0x0001
#define MASK_MFMA 0x0040
__device__ __forceinline__
uint16_t f32_to_bf16_bits(float f) {
__hip_bfloat16 v = __float2bfloat16(f);
return *reinterpret_cast<const uint16_t*>(&v);
}
__device__ __forceinline__
fp4x64_t load_frag_128(const uint8_t* __restrict__ base, size_t off) {
fp4x64_t r = {};
*reinterpret_cast<uint4*>(&r) = *reinterpret_cast<const uint4*>(base + off);
return r;
}
// ============================================================
// v73: quantize_group with separate hi/lo amax accumulators
// ============================================================
__device__ __forceinline__
void quantize_group_bf16_hw(
const uint32_t* __restrict__ src_global,
uint32_t* packed_out,
int& scale_out,
bool valid)
{
if (!valid) {
packed_out[0] = packed_out[1] = packed_out[2] = packed_out[3] = 0;
scale_out = 127;
return;
}
uint32_t src[16];
uint32_t amax_hi = 0, amax_lo = 0;
#pragma unroll
for (int i = 0; i < 4; i++) {
*reinterpret_cast<uint4*>(&src[i*4]) = *reinterpret_cast<const uint4*>(src_global + i*4);
#pragma unroll
for (int j = 0; j < 4; j++) {
uint32_t abs_pair = src[i*4+j] & 0x7FFF7FFFu;
amax_lo = max(amax_lo, abs_pair & 0xFFFFu);
amax_hi = max(amax_hi, abs_pair >> 16);
}
}
uint32_t amax_u32 = max(amax_hi, amax_lo);
float amax = __uint_as_float(amax_u32 << 16);
uint32_t amax_bits = __float_as_uint(amax);
amax_bits = (amax_bits + 0x200000u) & 0xFF800000u;
int biased_exp = (int)((amax_bits >> 23) & 0xFF);
int scale_unbiased = biased_exp - 129;
scale_unbiased = max(scale_unbiased, -127);
scale_unbiased = min(scale_unbiased, 127);
scale_out = scale_unbiased + 127;
int hw_scale_exp_biased = 127 + scale_unbiased;
float hw_scale = __uint_as_float((uint32_t)hw_scale_exp_biased << 23);
#pragma unroll
for (int j = 0; j < 4; j++) {
uint32_t r0 = src[j*4+0], r1 = src[j*4+1];
uint32_t r2 = src[j*4+2], r3 = src[j*4+3];
uint32_t w;
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wuninitialized"
w = __builtin_amdgcn_cvt_scalef32_pk_fp4_bf16(
w, *reinterpret_cast<const bf16x2_t*>(&r0), hw_scale, 0);
w = __builtin_amdgcn_cvt_scalef32_pk_fp4_bf16(
w, *reinterpret_cast<const bf16x2_t*>(&r1), hw_scale, 1);
w = __builtin_amdgcn_cvt_scalef32_pk_fp4_bf16(
w, *reinterpret_cast<const bf16x2_t*>(&r2), hw_scale, 2);
w = __builtin_amdgcn_cvt_scalef32_pk_fp4_bf16(
w, *reinterpret_cast<const bf16x2_t*>(&r3), hw_scale, 3);
#pragma clang diagnostic pop
packed_out[j] = w;
}
}
// ============================================================
// v73: Packed u16 max for faster amax (v_pk_max_u16)
// ============================================================
__device__ __forceinline__
uint32_t pk_max_u16(uint32_t a, uint32_t b) {
uint32_t r;
asm("v_pk_max_u16 %0, %1, %2" : "=v"(r) : "v"(a), "v"(b));
return r;
}
// ============================================================
// 32x32x64 MFMA
// ============================================================
__device__ __forceinline__
fp32x16_t mfma_fp4_32(fp4x64_t a, fp4x64_t b, fp32x16_t c, int sa, int sb) {
return __builtin_amdgcn_mfma_scale_f32_32x32x64_f8f6f4(
a, b, c, 4, 4, 0, sa, 0, sb);
}
struct Frag32 { fp4x64_t data; int scale; };
__device__ __forceinline__
fp32x16_t mfma_frag32(const Frag32& a, const Frag32& b, fp32x16_t c) {
return mfma_fp4_32(a.data, b.data, c, a.scale, b.scale);
}
// ============================================================
// ALoaderFused32 - v73: pk_max_u16 amax optimization
// ============================================================
struct ALoaderFused32 {
const uint32_t* __restrict__ A_u32;
int a_row;
int K;
int k_half;
bool valid;
__device__ __forceinline__
void init(const __hip_bfloat16* a, int row, int M, int K_val, int kh, bool nb) {
A_u32 = reinterpret_cast<const uint32_t*>(a);
a_row = row;
K = K_val;
k_half = kh;
valid = nb || (row < M);
}
__device__ __forceinline__
const uint32_t* get_src_ptr(int k_abs) const {
int k_start = k_abs + k_half * 32;
return A_u32 + (size_t)a_row * (K >> 1) + (k_start >> 1);
}
__device__ __forceinline__
Frag32 quantize_and_load(int k_abs) const {
Frag32 f;
f.data = {};
quantize_group_bf16_hw(get_src_ptr(k_abs), reinterpret_cast<uint32_t*>(&f.data), f.scale, valid);
return f;
}
// v73: Two-phase load with packed u16 amax (v_pk_max_u16)
__device__ __forceinline__
void load_raw(int k_abs, uint32_t raw[16], uint32_t& amax_packed_out) const {
if (!valid) {
#pragma unroll
for (int i = 0; i < 16; i++) raw[i] = 0;
amax_packed_out = 0;
return;
}
const uint32_t* src = get_src_ptr(k_abs);
uint32_t amax_pk = 0;
#pragma unroll
for (int i = 0; i < 4; i++) {
*reinterpret_cast<uint4*>(&raw[i*4]) = *reinterpret_cast<const uint4*>(src + i*4);
#pragma unroll
for (int j = 0; j < 4; j++) {
uint32_t abs_pair = raw[i*4+j] & 0x7FFF7FFFu;
amax_pk = pk_max_u16(amax_pk, abs_pair);
}
}
amax_packed_out = amax_pk;
}
// v73: quantize_raw with packed amax
__device__ __forceinline__
Frag32 quantize_raw(const uint32_t raw[16], uint32_t amax_packed) const {
Frag32 f;
f.data = {};
if (!valid) { f.scale = 127; return f; }
uint32_t amax_u32 = max(amax_packed & 0xFFFFu, amax_packed >> 16);
float amax = __uint_as_float(amax_u32 << 16);
uint32_t amax_bits = __float_as_uint(amax);
amax_bits = (amax_bits + 0x200000u) & 0xFF800000u;
int biased_exp = (int)((amax_bits >> 23) & 0xFF);
int scale_unbiased = biased_exp - 129;
scale_unbiased = max(scale_unbiased, -127);
scale_unbiased = min(scale_unbiased, 127);
f.scale = scale_unbiased + 127;
int hw_scale_exp = 127 + scale_unbiased;
float hw_scale = __uint_as_float((uint32_t)hw_scale_exp << 23);
#pragma unroll
for (int j = 0; j < 4; j++) {
uint32_t r0 = raw[j*4+0], r1 = raw[j*4+1];
uint32_t r2 = raw[j*4+2], r3 = raw[j*4+3];
uint32_t w;
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wuninitialized"
w = __builtin_amdgcn_cvt_scalef32_pk_fp4_bf16(
w, *reinterpret_cast<const bf16x2_t*>(&r0), hw_scale, 0);
w = __builtin_amdgcn_cvt_scalef32_pk_fp4_bf16(
w, *reinterpret_cast<const bf16x2_t*>(&r1), hw_scale, 1);
w = __builtin_amdgcn_cvt_scalef32_pk_fp4_bf16(
w, *reinterpret_cast<const bf16x2_t*>(&r2), hw_scale, 2);
w = __builtin_amdgcn_cvt_scalef32_pk_fp4_bf16(
w, *reinterpret_cast<const bf16x2_t*>(&r3), hw_scale, 3);
#pragma clang diagnostic pop
reinterpret_cast<uint32_t*>(&f.data)[j] = w;
}
return f;
}
};
// ============================================================
// ALoaderPacked32 - loads pre-quantized A (for non-fused path)
// ============================================================
struct ALoaderPacked32 {
const uint8_t* __restrict__ A_q;
const uint8_t* __restrict__ A_scale;
int a_row;
int K;
int k_half;
bool valid;
size_t aq_base;
size_t as_sh_base;
__device__ __forceinline__
void init(const uint8_t* aq, const uint8_t* asc,
int row, int M, int K_val, int kh, int sn_a, bool nb) {
A_q = aq;
A_scale = asc;
a_row = row;
K = K_val;
k_half = kh;
valid = nb || (row < M);
aq_base = (size_t)row * (K_val >> 1);
int o0 = row / 32;
int o1 = (row & 31) / 16;
int o2 = row & 15;
as_sh_base = (size_t)o1 + (size_t)o2 * 4 + (size_t)o0 * 32 * sn_a;
}
__device__ __forceinline__
int load_scale(int k_abs) const {
if (!valid) return 127;
int kg = (k_abs >> 5) + k_half;
return (int)A_scale[as_sh_base + (kg & 3) * 64 + ((kg >> 2) & 1) * 2 + (kg >> 3) * 256];
}
__device__ __forceinline__
fp4x64_t load_data(int k_abs) const {
if (!valid) return fp4x64_t{};
int k_start = k_abs + k_half * 32;
size_t byte_off = aq_base + (size_t)(k_start >> 1);
fp4x64_t r = {};
*reinterpret_cast<uint4*>(&r) = *reinterpret_cast<const uint4*>(A_q + byte_off);
return r;
}
};
// ============================================================
// BLoader32
// ============================================================
struct BLoader32 {
const uint8_t* __restrict__ B_sh;
const uint8_t* __restrict__ B_scale;
size_t bsh_base, bs_sh_base;
int k_half; bool valid;
__device__ __forceinline__
void init(const uint8_t* bsh, const uint8_t* bsc,
int b_col, int N, int half_K, int kh, int sn_val, bool nb) {
B_sh = bsh; B_scale = bsc; k_half = kh;
valid = nb || (b_col < N);
bsh_base = (size_t)(b_col >> 4) * (size_t)half_K * 16
+ (size_t)(b_col & 15) * 16;
int o0 = b_col / 32, o1 = (b_col & 31) / 16, o2 = b_col & 15;
bs_sh_base = (size_t)o1 + (size_t)o2 * 4 + (size_t)o0 * 32 * sn_val;
}
__device__ __forceinline__
fp4x64_t load_data(int k_abs) const {
return valid ? load_frag_128(B_sh, bsh_base + (size_t)(k_abs >> 6) * 512 + (size_t)k_half * 256) : fp4x64_t{};
}
__device__ __forceinline__
int load_scale(int k_abs) const {
int kg = (k_abs >> 5) + k_half;
return valid ? (int)B_scale[bs_sh_base + (kg & 3) * 64 + ((kg >> 2) & 1) * 2 + (kg >> 3) * 256] : 127;
}
};
// ============================================================
// Store accumulator 32x32x64
// ============================================================
template<bool IS_SPLITK, bool NO_BOUNDS>
__device__ __forceinline__
void store_accum_32(void* __restrict__ out, fp32x16_t c,
int m_start, int n_col, int k_half, int M, int N, int slice_offset) {
if constexpr (IS_SPLITK) {
float* dst = reinterpret_cast<float*>(out) + slice_offset;
#pragma unroll
for (int i = 0; i < 4; i++) {
int rb = m_start + 4 * k_half + 8 * i;
#pragma unroll
for (int j = 0; j < 4; j++) {
int r = rb + j;
if (NO_BOUNDS || r < M) dst[(size_t)r * N + n_col] = c[i * 4 + j];
}
}
} else {
// v78: Non-temporal stores to avoid L2 cache pollution for output
uint16_t* dst = reinterpret_cast<uint16_t*>(out);
#pragma unroll
for (int i = 0; i < 4; i++) {
int rb = m_start + 4 * k_half + 8 * i;
#pragma unroll
for (int j = 0; j < 4; j++) {
int r = rb + j;
if (NO_BOUNDS || r < M) {
uint16_t val = f32_to_bf16_bits(c[i * 4 + j]);
__builtin_nontemporal_store(val, &dst[(size_t)r * N + n_col]);
}
}
}
}
}
// ============================================================
// Pipeline 32x32x64 FUSED - v73: MFMA-first + circular buffer + pk_max
// ============================================================
template<int N_K_STEPS, int REGIME>
__device__ __forceinline__
void run_pipeline_fused32(const ALoaderFused32& al, const BLoader32& bl,
int k_begin, const int bsc[], fp32x16_t& c) {
c = {};
if constexpr (N_K_STEPS <= 6) {
Frag32 af[N_K_STEPS], bf[N_K_STEPS];
#pragma unroll
for (int s = 0; s < N_K_STEPS; s++) {
int ka = k_begin + s * 64;
af[s] = al.quantize_and_load(ka);
bf[s] = {bl.load_data(ka), bsc[s]};
}
__builtin_amdgcn_sched_barrier(0);
__builtin_amdgcn_s_setprio(3);
#pragma unroll
for (int s = 0; s < N_K_STEPS; s++) c = mfma_frag32(af[s], bf[s], c);
__builtin_amdgcn_s_setprio(0);
} else if constexpr (REGIME == 2) {
// Compute-bound: v73 MFMA-first + circular buffer + pk_max amax
constexpr int DEPTH = 6;
Frag32 a[DEPTH], b[DEPTH];
uint32_t prologue_raw[DEPTH][16];
uint32_t prologue_amax_pk[DEPTH];
fp4x64_t b_data[DEPTH];
#pragma unroll
for (int s = 0; s < DEPTH; s++)
al.load_raw(k_begin + s * 64, prologue_raw[s], prologue_amax_pk[s]);
#pragma unroll
for (int s = 0; s < DEPTH; s++)
b_data[s] = bl.load_data(k_begin + s * 64);
#pragma unroll
for (int s = 0; s < DEPTH; s++) {
a[s] = al.quantize_raw(prologue_raw[s], prologue_amax_pk[s]);
b[s] = {b_data[s], bsc[s]};
}
int head = 0;
__builtin_amdgcn_iglp_opt(0);
#pragma unroll
for (int s = 0; s < N_K_STEPS - DEPTH; s++) {
int ka = k_begin + (s + DEPTH) * 64;
__builtin_amdgcn_sched_group_barrier(MASK_VMEM_READ, 2, 0);
__builtin_amdgcn_sched_group_barrier(MASK_MFMA, 2, 0);
c = mfma_frag32(a[head], b[head], c);
uint32_t raw[16]; uint32_t amax_pk_val;
al.load_raw(ka, raw, amax_pk_val);
fp4x64_t bd = bl.load_data(ka);
Frag32 an = al.quantize_raw(raw, amax_pk_val);
a[head] = an;
b[head] = {bd, bsc[s + DEPTH]};
head = (head + 1) % DEPTH;
}
__builtin_amdgcn_sched_barrier(0);
__builtin_amdgcn_s_setprio(3);
#pragma unroll
for (int s = 0; s < DEPTH; s++) {
c = mfma_frag32(a[head], b[head], c);
head = (head + 1) % DEPTH;
}
__builtin_amdgcn_s_setprio(0);
} else {
// REGIME 0 or 1: BW-bound / default - v73: MFMA-first + circular buffer + pk_max
constexpr int DEPTH = 8;
Frag32 a[DEPTH], b[DEPTH];
uint32_t prologue_raw[DEPTH][16];
uint32_t prologue_amax_pk[DEPTH];
fp4x64_t b_data[DEPTH];
#pragma unroll
for (int s = 0; s < DEPTH; s++)
al.load_raw(k_begin + s * 64, prologue_raw[s], prologue_amax_pk[s]);
#pragma unroll
for (int s = 0; s < DEPTH; s++)
b_data[s] = bl.load_data(k_begin + s * 64);
#pragma unroll
for (int s = 0; s < DEPTH; s++) {
a[s] = al.quantize_raw(prologue_raw[s], prologue_amax_pk[s]);
b[s] = {b_data[s], bsc[s]};
}
int head = 0;
__builtin_amdgcn_iglp_opt(0);
#pragma unroll
for (int s = 0; s < N_K_STEPS - DEPTH; s++) {
int ka = k_begin + (s + DEPTH) * 64;
c = mfma_frag32(a[head], b[head], c);
uint32_t raw[16]; uint32_t amax_pk_val;
al.load_raw(ka, raw, amax_pk_val);
fp4x64_t bd = bl.load_data(ka);
Frag32 an = al.quantize_raw(raw, amax_pk_val);
a[head] = an;
b[head] = {bd, bsc[s + DEPTH]};
head = (head + 1) % DEPTH;
}
__builtin_amdgcn_sched_barrier(0);
__builtin_amdgcn_s_setprio(3);
#pragma unroll
for (int s = 0; s < DEPTH; s++) {
c = mfma_frag32(a[head], b[head], c);
head = (head + 1) % DEPTH;
}
__builtin_amdgcn_s_setprio(0);
}
}
// ============================================================
// Pipeline 32x32x64 NON-FUSED - pure VMEM + MFMA, zero quant VALU
// ============================================================
template<int N_K_STEPS, int REGIME>
__device__ __forceinline__
void run_pipeline_nonfused32(const ALoaderPacked32& al, const BLoader32& bl,
int k_begin, const int asc[], const int bsc[], fp32x16_t& c) {
c = {};
if constexpr (N_K_STEPS <= 6) {
Frag32 af[N_K_STEPS], bf[N_K_STEPS];
#pragma unroll
for (int s = 0; s < N_K_STEPS; s++) {
int ka = k_begin + s * 64;
af[s] = {al.load_data(ka), asc[s]};
bf[s] = {bl.load_data(ka), bsc[s]};
}
__builtin_amdgcn_sched_barrier(0);
__builtin_amdgcn_s_setprio(3);
#pragma unroll
for (int s = 0; s < N_K_STEPS; s++) c = mfma_frag32(af[s], bf[s], c);
__builtin_amdgcn_s_setprio(0);
} else if constexpr (REGIME == 2) {
// v78: Circular buffer with MFMA-first ordering
constexpr int DEPTH = 6;
Frag32 a[DEPTH], b[DEPTH];
#pragma unroll
for (int s = 0; s < DEPTH; s++) {
int ka = k_begin + s * 64;
a[s] = {al.load_data(ka), asc[s]};
b[s] = {bl.load_data(ka), bsc[s]};
}
int head = 0;
__builtin_amdgcn_iglp_opt(0);
#pragma unroll
for (int s = 0; s < N_K_STEPS - DEPTH; s++) {
int ka = k_begin + (s + DEPTH) * 64;
__builtin_amdgcn_sched_group_barrier(MASK_VMEM_READ, 2, 0);
__builtin_amdgcn_sched_group_barrier(MASK_MFMA, 2, 0);
c = mfma_frag32(a[head], b[head], c);
fp4x64_t ad = al.load_data(ka);
fp4x64_t bd = bl.load_data(ka);
a[head] = {ad, asc[s + DEPTH]};
b[head] = {bd, bsc[s + DEPTH]};
if (++head == DEPTH) head = 0;
}
__builtin_amdgcn_sched_barrier(0);
__builtin_amdgcn_s_setprio(3);
#pragma unroll
for (int s = 0; s < DEPTH; s++) {
c = mfma_frag32(a[head], b[head], c);
if (++head == DEPTH) head = 0;
}
__builtin_amdgcn_s_setprio(0);
} else {
// v78: Circular buffer with power-of-2 DEPTH for fast modulo
constexpr int DEPTH = 8;
Frag32 a[DEPTH], b[DEPTH];
#pragma unroll
for (int s = 0; s < DEPTH; s++) {
int ka = k_begin + s * 64;
a[s] = {al.load_data(ka), asc[s]};
b[s] = {bl.load_data(ka), bsc[s]};
}
int head = 0;
__builtin_amdgcn_iglp_opt(0);
#pragma unroll
for (int s = 0; s < N_K_STEPS - DEPTH; s++) {
int ka = k_begin + (s + DEPTH) * 64;
c = mfma_frag32(a[head], b[head], c);
fp4x64_t ad = al.load_data(ka);
fp4x64_t bd = bl.load_data(ka);
a[head] = {ad, asc[s + DEPTH]};
b[head] = {bd, bsc[s + DEPTH]};
head = (head + 1) & (DEPTH - 1);
}
__builtin_amdgcn_sched_barrier(0);
__builtin_amdgcn_s_setprio(3);
#pragma unroll
for (int s = 0; s < DEPTH; s++) {
c = mfma_frag32(a[head], b[head], c);
head = (head + 1) & (DEPTH - 1);
}
__builtin_amdgcn_s_setprio(0);
}
}
// ============================================================
// 32x32x64 fused kernel (v73)
// ============================================================
template<int TILES_N, int N_K_STEPS, bool IS_SPLITK, bool NO_BOUNDS, int REGIME>
__global__
__attribute__((amdgpu_flat_work_group_size(TILES_N * WAVE_SIZE, TILES_N * WAVE_SIZE)))
__attribute__((amdgpu_waves_per_eu(2, 2)))
void fused_gemm_kernel_32(
const __hip_bfloat16* __restrict__ A_bf16,
const uint8_t* __restrict__ B_sh,
const uint8_t* __restrict__ B_scale,
void* __restrict__ out,
int M, int N, int K, int k_chunk, int sn, int m_tiles)
{
const int tid = threadIdx.x;
const int wave_id = tid / WAVE_SIZE;
const int lane_id = tid % WAVE_SIZE;
const int lane_row = lane_id & 31;
const int k_half = lane_id >> 5;
constexpr int NPB = TILES_N * 32;
const int m_tile = blockIdx.x % m_tiles;
const int n_tile = blockIdx.x / m_tiles;
const int m_start = m_tile * 32;
const int n_col = n_tile * NPB + wave_id * 32 + lane_row;
const int half_K = K >> 1;
const int k_begin = IS_SPLITK ? (int)blockIdx.y * k_chunk : 0;
ALoaderFused32 al;
al.init(A_bf16, m_start + lane_row, M, K, k_half, NO_BOUNDS);
BLoader32 bl;
bl.init(B_sh, B_scale, n_col, N, half_K, k_half, sn, NO_BOUNDS);
int bsc[N_K_STEPS];
#pragma unroll
for (int i = 0; i < N_K_STEPS; i++) bsc[i] = bl.load_scale(k_begin + i * 64);
fp32x16_t c;
run_pipeline_fused32<N_K_STEPS, REGIME>(al, bl, k_begin, bsc, c);
const int soff = IS_SPLITK ? (int)blockIdx.y * M * N : 0;
if (NO_BOUNDS || n_col < N)
store_accum_32<IS_SPLITK, NO_BOUNDS>(out, c, m_start, n_col, k_half, M, N, soff);
}
// ============================================================
// v77: 1x2 Register Tiling Pipeline
// Each wave computes 2 accumulators (32x64 output) per K-step.
// 1 A quantization + 2 B loads + 2 MFMAs per step.
// VALU/MFMA ratio = 74/128 = 0.58 (MFMA-bound, not VALU-bound)
// Uses pk_max_u16 from v76 for fast amax
// ============================================================
template<int N_K_STEPS>
__device__ __forceinline__
void run_pipeline_1x2(
const ALoaderFused32& al,
const BLoader32& bl0, const BLoader32& bl1,
int k_begin,
const int bsc0[], const int bsc1[],
fp32x16_t& c0, fp32x16_t& c1)
{
c0 = {}; c1 = {};
if constexpr (N_K_STEPS <= 4) {
// Short path: prefetch all, then compute
Frag32 af[N_K_STEPS];
Frag32 bf0[N_K_STEPS], bf1[N_K_STEPS];
#pragma unroll
for (int s = 0; s < N_K_STEPS; s++) {
int ka = k_begin + s * 64;
af[s] = al.quantize_and_load(ka);
bf0[s] = {bl0.load_data(ka), bsc0[s]};
bf1[s] = {bl1.load_data(ka), bsc1[s]};
}
__builtin_amdgcn_sched_barrier(0);
__builtin_amdgcn_s_setprio(3);
#pragma unroll
for (int s = 0; s < N_K_STEPS; s++) {
c0 = mfma_frag32(af[s], bf0[s], c0);
c1 = mfma_frag32(af[s], bf1[s], c1);
}
__builtin_amdgcn_s_setprio(0);
} else {
// Main path: circular buffer with MFMA-first ordering
// DEPTH=6: balance between pipeline depth and register pressure
constexpr int DEPTH = 6;
Frag32 a[DEPTH], b0[DEPTH], b1[DEPTH];
// Three-phase prologue using pk_max_u16
uint32_t praw[DEPTH][16];
uint32_t pamax_pk[DEPTH];
fp4x64_t bd0[DEPTH], bd1[DEPTH];
// Phase 1: Issue all A loads (VMEM)
#pragma unroll
for (int s = 0; s < DEPTH; s++)
al.load_raw(k_begin + s * 64, praw[s], pamax_pk[s]);
// Phase 2: Issue all B loads (VMEM)
#pragma unroll
for (int s = 0; s < DEPTH; s++) {
int ka = k_begin + s * 64;
bd0[s] = bl0.load_data(ka);
bd1[s] = bl1.load_data(ka);
}
// Phase 3: Quantize A data (VALU)
#pragma unroll
for (int s = 0; s < DEPTH; s++) {
a[s] = al.quantize_raw(praw[s], pamax_pk[s]);
b0[s] = {bd0[s], bsc0[s]};
b1[s] = {bd1[s], bsc1[s]};
}
int head = 0;
__builtin_amdgcn_iglp_opt(0);
#pragma unroll
for (int s = 0; s < N_K_STEPS - DEPTH; s++) {
int ka = k_begin + (s + DEPTH) * 64;
// Issue 2 MFMAs FIRST - 2 x 64 = 128 cycles
// A quant (74 VALU) fits within 128 MFMA cycles
__builtin_amdgcn_sched_group_barrier(MASK_VMEM_READ, 2, 0);
__builtin_amdgcn_sched_group_barrier(MASK_MFMA, 2, 0);
c0 = mfma_frag32(a[head], b0[head], c0);
c1 = mfma_frag32(a[head], b1[head], c1);
// While 2 MFMAs execute (128 cycles): load + quantize next A + load 2 B tiles
uint32_t raw[16]; uint32_t amax_pk_val;
al.load_raw(ka, raw, amax_pk_val);
fp4x64_t bdata0 = bl0.load_data(ka);
fp4x64_t bdata1 = bl1.load_data(ka);
Frag32 an = al.quantize_raw(raw, amax_pk_val);
a[head] = an;
b0[head] = {bdata0, bsc0[s + DEPTH]};
b1[head] = {bdata1, bsc1[s + DEPTH]};
head = (head + 1) % DEPTH;
}
// Drain with high priority
__builtin_amdgcn_sched_barrier(0);
__builtin_amdgcn_s_setprio(3);
#pragma unroll
for (int s = 0; s < DEPTH; s++) {
c0 = mfma_frag32(a[head], b0[head], c0);
c1 = mfma_frag32(a[head], b1[head], c1);
head = (head + 1) % DEPTH;
}
__builtin_amdgcn_s_setprio(0);
}
}
// ============================================================
// v77: 1x2 tiling fused kernel
// Each wave handles a 32x64 output tile (1x2 of 32x32)
// Same A quantization shared across 2 column tiles
// ============================================================
template<int TILES_N, int N_K_STEPS, bool IS_SPLITK, bool NO_BOUNDS>
__global__
__attribute__((amdgpu_flat_work_group_size(TILES_N * WAVE_SIZE, TILES_N * WAVE_SIZE)))
__attribute__((amdgpu_waves_per_eu(2, 2)))
void fused_gemm_kernel_32_1x2(
const __hip_bfloat16* __restrict__ A_bf16,
const uint8_t* __restrict__ B_sh,
const uint8_t* __restrict__ B_scale,
void* __restrict__ out,
int M, int N, int K, int k_chunk, int sn, int m_tiles)
{
const int tid = threadIdx.x;
const int wave_id = tid / WAVE_SIZE;
const int lane_id = tid % WAVE_SIZE;
const int lane_row = lane_id & 31;
const int k_half = lane_id >> 5;
// Each wave covers 32 M-rows x 64 N-cols (2 column tiles)
// TILES_N waves per block, each covering 64 N-columns
constexpr int NPB = TILES_N * 64; // N per block
const int m_tile = blockIdx.x % m_tiles;
const int n_tile = blockIdx.x / m_tiles;
const int m_start = m_tile * 32;
const int n_base = n_tile * NPB + wave_id * 64;
const int n_col0 = n_base + lane_row; // first 32 columns
const int n_col1 = n_base + 32 + lane_row; // second 32 columns
const int half_K = K >> 1;
const int k_begin = IS_SPLITK ? (int)blockIdx.y * k_chunk : 0;
// One A loader (shared quantization across 2 column tiles)
ALoaderFused32 al;
al.init(A_bf16, m_start + lane_row, M, K, k_half, NO_BOUNDS);
// Two B loaders for column blocks 0 and 1
BLoader32 bl0, bl1;
bl0.init(B_sh, B_scale, n_col0, N, half_K, k_half, sn, NO_BOUNDS);
bl1.init(B_sh, B_scale, n_col1, N, half_K, k_half, sn, NO_BOUNDS);
int bsc0[N_K_STEPS], bsc1[N_K_STEPS];
#pragma unroll
for (int i = 0; i < N_K_STEPS; i++) {
int ka = k_begin + i * 64;
bsc0[i] = bl0.load_scale(ka);
bsc1[i] = bl1.load_scale(ka);
}
fp32x16_t c0, c1;
run_pipeline_1x2<N_K_STEPS>(al, bl0, bl1, k_begin, bsc0, bsc1, c0, c1);
const int soff = IS_SPLITK ? (int)blockIdx.y * M * N : 0;
// Store 2 tiles
if (NO_BOUNDS || n_col0 < N)
store_accum_32<IS_SPLITK, NO_BOUNDS>(out, c0, m_start, n_col0, k_half, M, N, soff);
if (NO_BOUNDS || n_col1 < N)
store_accum_32<IS_SPLITK, NO_BOUNDS>(out, c1, m_start, n_col1, k_half, M, N, soff);
}
// ============================================================
// v78: Cooperative 1x2 + split-K=2 fused kernel
// 2 waves per block: each handles a K-slice with 1x2 tiling (32x64 output)
// After compute, reduce via LDS and wave 0 writes bf16 output
// Eliminates reduce kernel launch, VALU fits within 2-MFMA window
// ============================================================
template<int N_K_STEPS, int SK, bool NO_BOUNDS>
__global__
__attribute__((amdgpu_flat_work_group_size(SK * WAVE_SIZE, SK * WAVE_SIZE)))
__attribute__((amdgpu_waves_per_eu(2, 2)))
void fused_gemm_kernel_32_coop_1x2(
const __hip_bfloat16* __restrict__ A_bf16,
const uint8_t* __restrict__ B_sh,
const uint8_t* __restrict__ B_scale,
void* __restrict__ out,
int M, int N, int K, int k_chunk, int sn, int m_tiles)
{
const int tid = threadIdx.x;
const int wave_id = tid / WAVE_SIZE; // 0 or 1 (K-slice index)
const int lane_id = tid % WAVE_SIZE;
const int lane_row = lane_id & 31;
const int k_half = lane_id >> 5;
// Both waves handle the SAME 32x64 output tile but DIFFERENT K-slices
const int m_tile = blockIdx.x % m_tiles;
const int n_tile = blockIdx.x / m_tiles;
const int m_start = m_tile * 32;
const int n_col0 = n_tile * 64 + lane_row;
const int n_col1 = n_tile * 64 + 32 + lane_row;
const int half_K = K >> 1;
const int k_begin = wave_id * k_chunk;
// One A loader per wave (shared quantization across 2 column tiles)
ALoaderFused32 al;
al.init(A_bf16, m_start + lane_row, M, K, k_half, NO_BOUNDS);
// Two B loaders for column blocks 0 and 1
BLoader32 bl0, bl1;
bl0.init(B_sh, B_scale, n_col0, N, half_K, k_half, sn, NO_BOUNDS);
bl1.init(B_sh, B_scale, n_col1, N, half_K, k_half, sn, NO_BOUNDS);
int bsc0[N_K_STEPS], bsc1[N_K_STEPS];
#pragma unroll
for (int i = 0; i < N_K_STEPS; i++) {
int ka = k_begin + i * 64;
bsc0[i] = bl0.load_scale(ka);
bsc1[i] = bl1.load_scale(ka);
}
fp32x16_t c0, c1;
run_pipeline_1x2<N_K_STEPS>(al, bl0, bl1, k_begin, bsc0, bsc1, c0, c1);
// === Cooperative reduction via LDS ===
// Each wave has 2 × fp32x16_t = 32 floats per lane
// LDS layout: [wave_id][accum_idx][lane_id][16]
__shared__ float lds_reduce[SK * 2 * WAVE_SIZE * 16];
// Write c0 and c1 to LDS
float* my_c0 = lds_reduce + wave_id * 2 * WAVE_SIZE * 16 + lane_id * 16;
float* my_c1 = my_c0 + WAVE_SIZE * 16;
#pragma unroll
for (int i = 0; i < 16; i++) { my_c0[i] = c0[i]; my_c1[i] = c1[i]; }
__syncthreads();
// Wave 0 reduces all SK partial sums and writes output
if (wave_id == 0) {
fp32x16_t sum0, sum1;
#pragma unroll
for (int i = 0; i < 16; i++) { sum0[i] = c0[i]; sum1[i] = c1[i]; }
#pragma unroll
for (int s = 1; s < SK; s++) {
float* s_c0 = lds_reduce + s * 2 * WAVE_SIZE * 16 + lane_id * 16;
float* s_c1 = s_c0 + WAVE_SIZE * 16;
#pragma unroll
for (int i = 0; i < 16; i++) { sum0[i] += s_c0[i]; sum1[i] += s_c1[i]; }
}
// Store results
uint16_t* dst = reinterpret_cast<uint16_t*>(out);
if (NO_BOUNDS || n_col0 < N) {
#pragma unroll
for (int i = 0; i < 4; i++) {
int rb = m_start + 4 * k_half + 8 * i;
#pragma unroll
for (int j = 0; j < 4; j++) {
int r = rb + j;
if (NO_BOUNDS || r < M) {
uint16_t val = f32_to_bf16_bits(sum0[i * 4 + j]);
__builtin_nontemporal_store(val, &dst[(size_t)r * N + n_col0]);
}
}
}
}
if (NO_BOUNDS || n_col1 < N) {
#pragma unroll
for (int i = 0; i < 4; i++) {
int rb = m_start + 4 * k_half + 8 * i;
#pragma unroll
for (int j = 0; j < 4; j++) {
int r = rb + j;
if (NO_BOUNDS || r < M) {
uint16_t val = f32_to_bf16_bits(sum1[i * 4 + j]);
__builtin_nontemporal_store(val, &dst[(size_t)r * N + n_col1]);
}
}
}
}
}
}
// ============================================================
// 32x32x64 NON-FUSED kernel (v69 - pre-quantized A, no inline quant)
// ============================================================
template<int TILES_N, int N_K_STEPS, bool IS_SPLITK, bool NO_BOUNDS, int REGIME>
__global__
__attribute__((amdgpu_flat_work_group_size(TILES_N * WAVE_SIZE, TILES_N * WAVE_SIZE)))
__attribute__((amdgpu_waves_per_eu(2, 2)))
void nonfused_gemm_kernel_32(
const uint8_t* __restrict__ A_q,
const uint8_t* __restrict__ A_scale_sh,
const uint8_t* __restrict__ B_sh,
const uint8_t* __restrict__ B_scale,
void* __restrict__ out,
int M, int N, int K, int k_chunk, int sn_b, int sn_a, int m_tiles)
{
const int tid = threadIdx.x;
const int wave_id = tid / WAVE_SIZE;
const int lane_id = tid % WAVE_SIZE;
const int lane_row = lane_id & 31;
const int k_half = lane_id >> 5;
constexpr int NPB = TILES_N * 32;
const int m_tile = blockIdx.x % m_tiles;
const int n_tile = blockIdx.x / m_tiles;
const int m_start = m_tile * 32;
const int n_col = n_tile * NPB + wave_id * 32 + lane_row;
const int half_K = K >> 1;
const int k_begin = IS_SPLITK ? (int)blockIdx.y * k_chunk : 0;
ALoaderPacked32 al;
al.init(A_q, A_scale_sh, m_start + lane_row, M, K, k_half, sn_a, NO_BOUNDS);
BLoader32 bl;
bl.init(B_sh, B_scale, n_col, N, half_K, k_half, sn_b, NO_BOUNDS);
int asc[N_K_STEPS];
int bsc[N_K_STEPS];
#pragma unroll
for (int i = 0; i < N_K_STEPS; i++) {
asc[i] = al.load_scale(k_begin + i * 64);
bsc[i] = bl.load_scale(k_begin + i * 64);
}
fp32x16_t c;
run_pipeline_nonfused32<N_K_STEPS, REGIME>(al, bl, k_begin, asc, bsc, c);
const int soff = IS_SPLITK ? (int)blockIdx.y * M * N : 0;
if (NO_BOUNDS || n_col < N)
store_accum_32<IS_SPLITK, NO_BOUNDS>(out, c, m_start, n_col, k_half, M, N, soff);
}
// 16x16x128 MFMA
// ============================================================
__device__ __forceinline__
fp32x4_t mfma_fp4_16(fp4x64_t a, fp4x64_t b, fp32x4_t c, int sa, int sb) {
return __builtin_amdgcn_mfma_scale_f32_16x16x128_f8f6f4(
a, b, c, 4, 4, 0, sa, 0, sb);
}
struct Frag16 { fp4x64_t data; int scale; };
__device__ __forceinline__
fp32x4_t mfma_frag16(const Frag16& a, const Frag16& b, fp32x4_t c) {
return mfma_fp4_16(a.data, b.data, c, a.scale, b.scale);
}
// ============================================================
// ALoaderFused16 - v73: pk_max_u16 for 16x16 path
// ============================================================
struct ALoaderFused16 {
const uint32_t* __restrict__ A_u32;
int a_row;
int K;
int k_quarter;
bool valid;
__device__ __forceinline__
void init(const __hip_bfloat16* a, int row, int M, int K_val, int kq, bool nb) {
A_u32 = reinterpret_cast<const uint32_t*>(a);
a_row = row;
K = K_val;
k_quarter = kq;
valid = nb || (row < M);
}
__device__ __forceinline__
const uint32_t* get_src_ptr(int k_abs) const {
int k_start = k_abs + k_quarter * 32;
return A_u32 + (size_t)a_row * (K >> 1) + (k_start >> 1);
}
__device__ __forceinline__
Frag16 quantize_and_load(int k_abs) const {
Frag16 f;
f.data = {};
quantize_group_bf16_hw(get_src_ptr(k_abs), reinterpret_cast<uint32_t*>(&f.data), f.scale, valid);
return f;
}
// v73: pk_max_u16 for 16x16 path
__device__ __forceinline__
void load_raw(int k_abs, uint32_t raw[16], uint32_t& amax_packed_out) const {
if (!valid) {
#pragma unroll
for (int i = 0; i < 16; i++) raw[i] = 0;
amax_packed_out = 0;
return;
}
const uint32_t* src = get_src_ptr(k_abs);
uint32_t amax_pk = 0;
#pragma unroll
for (int i = 0; i < 4; i++) {
*reinterpret_cast<uint4*>(&raw[i*4]) = *reinterpret_cast<const uint4*>(src + i*4);
#pragma unroll
for (int j = 0; j < 4; j++) {
uint32_t abs_pair = raw[i*4+j] & 0x7FFF7FFFu;
amax_pk = pk_max_u16(amax_pk, abs_pair);
}
}
amax_packed_out = amax_pk;
}
__device__ __forceinline__
Frag16 quantize_raw(const uint32_t raw[16], uint32_t amax_packed) const {
Frag16 f;
f.data = {};
if (!valid) { f.scale = 127; return f; }
uint32_t amax_u32 = max(amax_packed & 0xFFFFu, amax_packed >> 16);
float amax = __uint_as_float(amax_u32 << 16);
uint32_t amax_bits = __float_as_uint(amax);
amax_bits = (amax_bits + 0x200000u) & 0xFF800000u;
int biased_exp = (int)((amax_bits >> 23) & 0xFF);
int scale_unbiased = biased_exp - 129;
scale_unbiased = max(scale_unbiased, -127);
scale_unbiased = min(scale_unbiased, 127);
f.scale = scale_unbiased + 127;
int hw_scale_exp = 127 + scale_unbiased;
float hw_scale = __uint_as_float((uint32_t)hw_scale_exp << 23);
#pragma unroll
for (int j = 0; j < 4; j++) {
uint32_t r0 = raw[j*4+0], r1 = raw[j*4+1];
uint32_t r2 = raw[j*4+2], r3 = raw[j*4+3];
uint32_t w;
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wuninitialized"
w = __builtin_amdgcn_cvt_scalef32_pk_fp4_bf16(
w, *reinterpret_cast<const bf16x2_t*>(&r0), hw_scale, 0);
w = __builtin_amdgcn_cvt_scalef32_pk_fp4_bf16(
w, *reinterpret_cast<const bf16x2_t*>(&r1), hw_scale, 1);
w = __builtin_amdgcn_cvt_scalef32_pk_fp4_bf16(
w, *reinterpret_cast<const bf16x2_t*>(&r2), hw_scale, 2);
w = __builtin_amdgcn_cvt_scalef32_pk_fp4_bf16(
w, *reinterpret_cast<const bf16x2_t*>(&r3), hw_scale, 3);
#pragma clang diagnostic pop
reinterpret_cast<uint32_t*>(&f.data)[j] = w;
}
return f;
}
};
// ============================================================
// BLoader16
// ============================================================
struct BLoader16 {
const uint8_t* __restrict__ B_sh;
const uint8_t* __restrict__ B_scale;
size_t bsh_base;
size_t bs_sh_base;
size_t bsh_kq_off;
int k_quarter;
bool valid;
__device__ __forceinline__
void init(const uint8_t* bsh, const uint8_t* bsc,
int b_col, int N, int half_K, int kq, int sn_val, bool nb) {
B_sh = bsh; B_scale = bsc; k_quarter = kq;
valid = nb || (b_col < N);
bsh_base = (size_t)(b_col >> 4) * (size_t)half_K * 16
+ (size_t)(b_col & 15) * 16;
bsh_kq_off = (size_t)(kq >> 1) * 512 + (size_t)(kq & 1) * 256;
int o0 = b_col / 32, o1 = (b_col & 31) / 16, o2 = b_col & 15;
bs_sh_base = (size_t)o1 + (size_t)o2 * 4 + (size_t)o0 * 32 * sn_val;
}
__device__ __forceinline__
fp4x64_t load_data(int k_abs) const {
if (!valid) return fp4x64_t{};
return load_frag_128(B_sh, bsh_base + (size_t)(k_abs >> 6) * 512 + bsh_kq_off);
}
__device__ __forceinline__
int load_scale(int k_abs) const {
if (!valid) return 127;
int kg = (k_abs >> 5) + k_quarter;
return (int)B_scale[bs_sh_base + (kg & 3) * 64 + ((kg >> 2) & 1) * 2 + (kg >> 3) * 256];
}
};
// ============================================================
// Store accumulator 16x16x128
// ============================================================
template<bool IS_SPLITK, bool NO_BOUNDS>
__device__ __forceinline__
void store_accum_16(void* __restrict__ out, fp32x4_t c,
int m_start, int n_col, int k_quarter, int M, int N, int slice_offset) {
if constexpr (IS_SPLITK) {
float* dst = reinterpret_cast<float*>(out) + slice_offset;
#pragma unroll
for (int i = 0; i < 4; i++) {
int r = m_start + k_quarter * 4 + i;
if (NO_BOUNDS || r < M) dst[(size_t)r * N + n_col] = c[i];
}
} else {
// v78: Non-temporal stores
uint16_t* dst = reinterpret_cast<uint16_t*>(out);
#pragma unroll
for (int i = 0; i < 4; i++) {
int r = m_start + k_quarter * 4 + i;
if (NO_BOUNDS || r < M) {
uint16_t val = f32_to_bf16_bits(c[i]);
__builtin_nontemporal_store(val, &dst[(size_t)r * N + n_col]);
}
}
}
}
// ============================================================
// Pipeline 16x16x128 - v73: MFMA-first + circular buffer + pk_max, DEPTH=8
// ============================================================
template<int N_K_STEPS, int REGIME>
__device__ __forceinline__
void run_pipeline_fused16(const ALoaderFused16& al, const BLoader16& bl,
int k_begin, const int bsc[], fp32x4_t& c) {
c = {};
if constexpr (N_K_STEPS <= 6) {
Frag16 af[N_K_STEPS], bf[N_K_STEPS];
#pragma unroll
for (int s = 0; s < N_K_STEPS; s++) {
int ka = k_begin + s * 128;
af[s] = al.quantize_and_load(ka);
bf[s] = {bl.load_data(ka), bsc[s]};
}
__builtin_amdgcn_sched_barrier(0);
__builtin_amdgcn_s_setprio(3);
#pragma unroll
for (int s = 0; s < N_K_STEPS; s++) c = mfma_frag16(af[s], bf[s], c);
__builtin_amdgcn_s_setprio(0);
} else {
// v78: MFMA-first + circular buffer + pk_max
// Use min(DEPTH, N_K_STEPS) for prologue to avoid OOB reads
constexpr int DEPTH = (N_K_STEPS >= 8) ? 8 : N_K_STEPS;
Frag16 a[DEPTH], b[DEPTH];
uint32_t prologue_raw[DEPTH][16];
uint32_t prologue_amax_pk[DEPTH];
fp4x64_t b_data[DEPTH];
#pragma unroll
for (int s = 0; s < DEPTH; s++)
al.load_raw(k_begin + s * 128, prologue_raw[s], prologue_amax_pk[s]);
#pragma unroll
for (int s = 0; s < DEPTH; s++)
b_data[s] = bl.load_data(k_begin + s * 128);
#pragma unroll
for (int s = 0; s < DEPTH; s++) {
a[s] = al.quantize_raw(prologue_raw[s], prologue_amax_pk[s]);
b[s] = {b_data[s], bsc[s]};
}
int head = 0;
__builtin_amdgcn_iglp_opt(0);
#pragma unroll
for (int s = 0; s < N_K_STEPS - DEPTH; s++) {
int ka = k_begin + (s + DEPTH) * 128;
c = mfma_frag16(a[head], b[head], c);
uint32_t raw[16]; uint32_t amax_pk_val;
al.load_raw(ka, raw, amax_pk_val);
fp4x64_t bd = bl.load_data(ka);
Frag16 an = al.quantize_raw(raw, amax_pk_val);
a[head] = an;
b[head] = {bd, bsc[s + DEPTH]};
if constexpr (DEPTH > 1) {
head = (DEPTH & (DEPTH - 1)) == 0
? (head + 1) & (DEPTH - 1)
: ((head + 1 == DEPTH) ? 0 : head + 1);
}
}
__builtin_amdgcn_sched_barrier(0);
__builtin_amdgcn_s_setprio(3);
#pragma unroll
for (int s = 0; s < DEPTH; s++) {
c = mfma_frag16(a[head], b[head], c);
if constexpr (DEPTH > 1) {
head = (DEPTH & (DEPTH - 1)) == 0
? (head + 1) & (DEPTH - 1)
: ((head + 1 == DEPTH) ? 0 : head + 1);
}
}
__builtin_amdgcn_s_setprio(0);
}
}
// ============================================================
// 16x16x128 fused kernel
// ============================================================
template<int TILES_N, int N_K_STEPS, bool IS_SPLITK, bool NO_BOUNDS, int REGIME>
__global__
__attribute__((amdgpu_flat_work_group_size(TILES_N * WAVE_SIZE, TILES_N * WAVE_SIZE)))
__attribute__((amdgpu_waves_per_eu(4)))
void fused_gemm_kernel_16(
const __hip_bfloat16* __restrict__ A_bf16,
const uint8_t* __restrict__ B_sh,
const uint8_t* __restrict__ B_scale,
void* __restrict__ out,
int M, int N, int K, int k_chunk, int sn, int m_tiles)
{
const int tid = threadIdx.x;
const int wave_id = tid / WAVE_SIZE;
const int lane_id = tid % WAVE_SIZE;
const int lane16 = lane_id & 15;
const int k_quarter = lane_id >> 4;
constexpr int NPB = TILES_N * 16;
const int m_tile = blockIdx.x % m_tiles;
const int n_tile = blockIdx.x / m_tiles;
const int m_start = m_tile * 16;
const int n_col = n_tile * NPB + wave_id * 16 + lane16;
const int half_K = K >> 1;
const int k_begin = IS_SPLITK ? (int)blockIdx.y * k_chunk : 0;
ALoaderFused16 al;
al.init(A_bf16, m_start + lane16, M, K, k_quarter, NO_BOUNDS);
BLoader16 bl;
bl.init(B_sh, B_scale, n_col, N, half_K, k_quarter, sn, NO_BOUNDS);
int bsc[N_K_STEPS];
#pragma unroll
for (int i = 0; i < N_K_STEPS; i++) bsc[i] = bl.load_scale(k_begin + i * 128);
fp32x4_t c;
run_pipeline_fused16<N_K_STEPS, REGIME>(al, bl, k_begin, bsc, c);
const int soff = IS_SPLITK ? (int)blockIdx.y * M * N : 0;
if (NO_BOUNDS || n_col < N)
store_accum_16<IS_SPLITK, NO_BOUNDS>(out, c, m_start, n_col, k_quarter, M, N, soff);
}
// ============================================================
// v78: Cooperative split-K 16x16x128 fused kernel
// Multiple waves per block handle different K-slices, reduce via LDS
// Eliminates separate reduce kernel launch (~2us savings)
// ============================================================
template<int N_K_STEPS, int SK, bool NO_BOUNDS, int REGIME>
__global__
__attribute__((amdgpu_flat_work_group_size(SK * WAVE_SIZE, SK * WAVE_SIZE)))
__attribute__((amdgpu_waves_per_eu(4)))
void fused_gemm_kernel_16_coop(
const __hip_bfloat16* __restrict__ A_bf16,
const uint8_t* __restrict__ B_sh,
const uint8_t* __restrict__ B_scale,
void* __restrict__ out,
int M, int N, int K, int k_chunk, int sn, int m_tiles)
{
const int tid = threadIdx.x;
const int wave_id = tid / WAVE_SIZE; // 0..SK-1, identifies K-slice
const int lane_id = tid % WAVE_SIZE;
const int lane16 = lane_id & 15;
const int k_quarter = lane_id >> 4;
// All waves in the block handle the SAME (m_tile, n_tile) but DIFFERENT K-slices
const int m_tile = blockIdx.x % m_tiles;
const int n_tile = blockIdx.x / m_tiles;
const int m_start = m_tile * 16;
const int n_col = n_tile * 16 + lane16;
const int half_K = K >> 1;
const int k_begin = wave_id * k_chunk;
ALoaderFused16 al;
al.init(A_bf16, m_start + lane16, M, K, k_quarter, NO_BOUNDS);
BLoader16 bl;
bl.init(B_sh, B_scale, n_col, N, half_K, k_quarter, sn, NO_BOUNDS);
int bsc[N_K_STEPS];
#pragma unroll
for (int i = 0; i < N_K_STEPS; i++) bsc[i] = bl.load_scale(k_begin + i * 128);
fp32x4_t c;
run_pipeline_fused16<N_K_STEPS, REGIME>(al, bl, k_begin, bsc, c);
// === Cooperative reduction via LDS ===
// Each wave has fp32x4_t c (4 floats per lane).
// Layout: LDS[wave_id][lane_id][4] = SK * 64 * 4 floats = SK * 1024 bytes
__shared__ float lds_reduce[SK * WAVE_SIZE * 4];
// Write partial results to LDS
float* my_lds = lds_reduce + wave_id * WAVE_SIZE * 4 + lane_id * 4;
my_lds[0] = c[0]; my_lds[1] = c[1]; my_lds[2] = c[2]; my_lds[3] = c[3];
__syncthreads();
// Wave 0 reduces all SK partial sums and writes output
if (wave_id == 0) {
float sum[4];
sum[0] = lds_reduce[lane_id * 4 + 0];
sum[1] = lds_reduce[lane_id * 4 + 1];
sum[2] = lds_reduce[lane_id * 4 + 2];
sum[3] = lds_reduce[lane_id * 4 + 3];
#pragma unroll
for (int s = 1; s < SK; s++) {
float* s_lds = lds_reduce + s * WAVE_SIZE * 4 + lane_id * 4;
sum[0] += s_lds[0]; sum[1] += s_lds[1];
sum[2] += s_lds[2]; sum[3] += s_lds[3];
}
// Convert to bf16 and write output
if (NO_BOUNDS || n_col < N) {
uint16_t* dst = reinterpret_cast<uint16_t*>(out);
#pragma unroll
for (int i = 0; i < 4; i++) {
int r = m_start + k_quarter * 4 + i;
if (NO_BOUNDS || r < M) {
uint16_t val = f32_to_bf16_bits(sum[i]);
__builtin_nontemporal_store(val, &dst[(size_t)r * N + n_col]);
}
}
}
}
}
// ============================================================
// ============================================================
// v78: 16x16x128 1x4 fused kernel
// Each wave covers 16 rows × 64 columns (4 × 16x16 tiles), sharing A quantization
// VALU/MFMA = 74/(4×16) = 1.16. VGPRs ~196 → waves_per_eu(2)
// For M=64: 4 m_tiles × N/64 n_tiles = good occupancy WITHOUT split-K
// ============================================================
template<int N_K_STEPS, bool NO_BOUNDS>
__global__
__attribute__((amdgpu_flat_work_group_size(WAVE_SIZE, WAVE_SIZE)))
__attribute__((amdgpu_waves_per_eu(2, 2)))
void fused_gemm_kernel_16_1x4(
const __hip_bfloat16* __restrict__ A_bf16,
const uint8_t* __restrict__ B_sh,
const uint8_t* __restrict__ B_scale,
void* __restrict__ out,
int M, int N, int K, int sn, int m_tiles)
{
const int lane_id = threadIdx.x;
const int lane16 = lane_id & 15;
const int k_quarter = lane_id >> 4;
const int m_tile = blockIdx.x % m_tiles;
const int n_tile = blockIdx.x / m_tiles;
const int m_start = m_tile * 16;
const int n_base = n_tile * 64;
const int n_col0 = n_base + lane16;
const int n_col1 = n_base + 16 + lane16;
const int n_col2 = n_base + 32 + lane16;
const int n_col3 = n_base + 48 + lane16;
const int half_K = K >> 1;
ALoaderFused16 al;
al.init(A_bf16, m_start + lane16, M, K, k_quarter, NO_BOUNDS);
BLoader16 bl0, bl1, bl2, bl3;
bl0.init(B_sh, B_scale, n_col0, N, half_K, k_quarter, sn, NO_BOUNDS);
bl1.init(B_sh, B_scale, n_col1, N, half_K, k_quarter, sn, NO_BOUNDS);
bl2.init(B_sh, B_scale, n_col2, N, half_K, k_quarter, sn, NO_BOUNDS);
bl3.init(B_sh, B_scale, n_col3, N, half_K, k_quarter, sn, NO_BOUNDS);
int bsc0[N_K_STEPS], bsc1[N_K_STEPS], bsc2[N_K_STEPS], bsc3[N_K_STEPS];
#pragma unroll
for (int i = 0; i < N_K_STEPS; i++) {
int ka = i * 128;
bsc0[i] = bl0.load_scale(ka); bsc1[i] = bl1.load_scale(ka);
bsc2[i] = bl2.load_scale(ka); bsc3[i] = bl3.load_scale(ka);
}
fp32x4_t c0 = {}, c1 = {}, c2 = {}, c3 = {};
if constexpr (N_K_STEPS <= 4) {
Frag16 af[N_K_STEPS];
Frag16 bf0[N_K_STEPS], bf1[N_K_STEPS], bf2[N_K_STEPS], bf3[N_K_STEPS];
#pragma unroll
for (int s = 0; s < N_K_STEPS; s++) {
int ka = s * 128;
af[s] = al.quantize_and_load(ka);
bf0[s] = {bl0.load_data(ka), bsc0[s]}; bf1[s] = {bl1.load_data(ka), bsc1[s]};
bf2[s] = {bl2.load_data(ka), bsc2[s]}; bf3[s] = {bl3.load_data(ka), bsc3[s]};
}
__builtin_amdgcn_sched_barrier(0);
__builtin_amdgcn_s_setprio(3);
#pragma unroll
for (int s = 0; s < N_K_STEPS; s++) {
c0 = mfma_frag16(af[s], bf0[s], c0); c1 = mfma_frag16(af[s], bf1[s], c1);
c2 = mfma_frag16(af[s], bf2[s], c2); c3 = mfma_frag16(af[s], bf3[s], c3);
}
__builtin_amdgcn_s_setprio(0);
} else {
constexpr int DEPTH = (N_K_STEPS >= 4) ? 4 : N_K_STEPS;
Frag16 a[DEPTH], b0d[DEPTH], b1d[DEPTH], b2d[DEPTH], b3d[DEPTH];
uint32_t praw[DEPTH][16]; uint32_t pamax[DEPTH];
fp4x64_t pd0[DEPTH], pd1[DEPTH], pd2[DEPTH], pd3[DEPTH];
#pragma unroll
for (int s = 0; s < DEPTH; s++)
al.load_raw(s * 128, praw[s], pamax[s]);
#pragma unroll
for (int s = 0; s < DEPTH; s++) {
int ka = s * 128;
pd0[s] = bl0.load_data(ka); pd1[s] = bl1.load_data(ka);
pd2[s] = bl2.load_data(ka); pd3[s] = bl3.load_data(ka);
}
#pragma unroll
for (int s = 0; s < DEPTH; s++) {
a[s] = al.quantize_raw(praw[s], pamax[s]);
b0d[s] = {pd0[s], bsc0[s]}; b1d[s] = {pd1[s], bsc1[s]};
b2d[s] = {pd2[s], bsc2[s]}; b3d[s] = {pd3[s], bsc3[s]};
}
int head = 0;
__builtin_amdgcn_iglp_opt(0);
#pragma unroll
for (int s = 0; s < N_K_STEPS - DEPTH; s++) {
int ka = (s + DEPTH) * 128;
c0 = mfma_frag16(a[head], b0d[head], c0); c1 = mfma_frag16(a[head], b1d[head], c1);
c2 = mfma_frag16(a[head], b2d[head], c2); c3 = mfma_frag16(a[head], b3d[head], c3);
uint32_t raw[16]; uint32_t amx;
al.load_raw(ka, raw, amx);
fp4x64_t bd0 = bl0.load_data(ka), bd1 = bl1.load_data(ka);
fp4x64_t bd2 = bl2.load_data(ka), bd3 = bl3.load_data(ka);
Frag16 an = al.quantize_raw(raw, amx);
a[head] = an;
b0d[head] = {bd0, bsc0[s+DEPTH]}; b1d[head] = {bd1, bsc1[s+DEPTH]};
b2d[head] = {bd2, bsc2[s+DEPTH]}; b3d[head] = {bd3, bsc3[s+DEPTH]};
head = (head + 1) & (DEPTH - 1);
}
__builtin_amdgcn_sched_barrier(0);
__builtin_amdgcn_s_setprio(3);
#pragma unroll
for (int s = 0; s < DEPTH; s++) {
c0 = mfma_frag16(a[head], b0d[head], c0); c1 = mfma_frag16(a[head], b1d[head], c1);
c2 = mfma_frag16(a[head], b2d[head], c2); c3 = mfma_frag16(a[head], b3d[head], c3);
head = (head + 1) & (DEPTH - 1);
}
__builtin_amdgcn_s_setprio(0);
}
// Direct bf16 output (no split-K, no reduction needed!)
uint16_t* dst = reinterpret_cast<uint16_t*>(out);
#pragma unroll
for (int t = 0; t < 4; t++) {
int nc = n_base + t * 16 + lane16;
fp32x4_t& c = (t==0) ? c0 : (t==1) ? c1 : (t==2) ? c2 : c3;
if (NO_BOUNDS || nc < N) {
#pragma unroll
for (int i = 0; i < 4; i++) {
int r = m_start + k_quarter * 4 + i;
if (NO_BOUNDS || r < M) {
uint16_t val = f32_to_bf16_bits(c[i]);
__builtin_nontemporal_store(val, &dst[(size_t)r * N + nc]);
}
}
}
}
}
// v78: 16x16 1x4 C++ entry point
torch::Tensor fused_16_1x4_gemm(
torch::Tensor A_bf16, torch::Tensor B_sh,
torch::Tensor B_scale_sh,
int M, int N, int K)
{
auto a = reinterpret_cast<const __hip_bfloat16*>(A_bf16.data_ptr<at::BFloat16>());
auto b = B_sh.data_ptr<uint8_t>();
auto bs = B_scale_sh.data_ptr<uint8_t>();
int sn = (((K / 32) + 7) / 8) * 8;
int mt = (M + 15) / 16;
int nt = (N + 63) / 64;
bool nb = (M % 16 == 0) && (N % 64 == 0);
int nks = K / 128;
auto bf16o = torch::TensorOptions().dtype(torch::kBFloat16).device(A_bf16.device());
auto C = torch::empty({M, N}, bf16o);
// Dispatch based on nks
if (nks==16 && nb) fused_gemm_kernel_16_1x4<16, true><<<dim3(mt*nt), dim3(WAVE_SIZE)>>>(a,b,bs,C.data_ptr<at::BFloat16>(),M,N,K,sn,mt);
else if (nks==16 && !nb) fused_gemm_kernel_16_1x4<16, false><<<dim3(mt*nt), dim3(WAVE_SIZE)>>>(a,b,bs,C.data_ptr<at::BFloat16>(),M,N,K,sn,mt);
else if (nks==12 && nb) fused_gemm_kernel_16_1x4<12, true><<<dim3(mt*nt), dim3(WAVE_SIZE)>>>(a,b,bs,C.data_ptr<at::BFloat16>(),M,N,K,sn,mt);
else if (nks==12 && !nb) fused_gemm_kernel_16_1x4<12, false><<<dim3(mt*nt), dim3(WAVE_SIZE)>>>(a,b,bs,C.data_ptr<at::BFloat16>(),M,N,K,sn,mt);
else if (nks==4 && nb) fused_gemm_kernel_16_1x4<4, true><<<dim3(mt*nt), dim3(WAVE_SIZE)>>>(a,b,bs,C.data_ptr<at::BFloat16>(),M,N,K,sn,mt);
else if (nks==4 && !nb) fused_gemm_kernel_16_1x4<4, false><<<dim3(mt*nt), dim3(WAVE_SIZE)>>>(a,b,bs,C.data_ptr<at::BFloat16>(),M,N,K,sn,mt);
else if (nks==8 && nb) fused_gemm_kernel_16_1x4<8, true><<<dim3(mt*nt), dim3(WAVE_SIZE)>>>(a,b,bs,C.data_ptr<at::BFloat16>(),M,N,K,sn,mt);
else if (nks==8 && !nb) fused_gemm_kernel_16_1x4<8, false><<<dim3(mt*nt), dim3(WAVE_SIZE)>>>(a,b,bs,C.data_ptr<at::BFloat16>(),M,N,K,sn,mt);
return C;
}
// ============================================================
// Split-K reduce
// ============================================================
template<int SK>
__global__
__attribute__((amdgpu_flat_work_group_size(256, 256)))
void splitk_reduce(const float* __restrict__ ws, uint16_t* __restrict__ C, int MN) {
const int i4 = (blockIdx.x * blockDim.x + threadIdx.x) * 4;
if (i4 >= MN) return;
if (i4 + 3 < MN) {
float4 s = *reinterpret_cast<const float4*>(ws + i4);
#pragma unroll
for (int k = 1; k < SK; k++) {
float4 p = *reinterpret_cast<const float4*>(ws + (size_t)k * MN + i4);
s.x += p.x; s.y += p.y; s.z += p.z; s.w += p.w;
}
__hip_bfloat162 p01 = __halves2bfloat162(__float2bfloat16(s.x), __float2bfloat16(s.y));
__hip_bfloat162 p23 = __halves2bfloat162(__float2bfloat16(s.z), __float2bfloat16(s.w));
*reinterpret_cast<uint32_t*>(C + i4) = *reinterpret_cast<const uint32_t*>(&p01);
*reinterpret_cast<uint32_t*>(C + i4 + 2) = *reinterpret_cast<const uint32_t*>(&p23);
} else {
for (int i = 0; i < 4 && i4 + i < MN; i++) {
float sum = 0;
#pragma unroll
for (int k = 0; k < SK; k++) sum += ws[(size_t)k * MN + i4 + i];
C[i4 + i] = f32_to_bf16_bits(sum);
}
}
}
// ============================================================
// Configuration and dispatch
// ============================================================
struct Cfg { int tiles_n; int split_k; bool use_16x16; bool use_1x2; int regime; bool use_coop_sk = false; };
static int wave_ct_32(int M, int N, int tn) {
return ((M + 31) / 32) * ((N + tn * 32 - 1) / (tn * 32)) * tn;
}
static int wave_ct_16(int M, int N, int tn) {
return ((M + 15) / 16) * ((N + tn * 16 - 1) / (tn * 16)) * tn;
}
// v77: wave count for 1x2 tiling (32x64 per wave, TILES_N waves per block)
static int wave_ct_1x2(int M, int N, int tn) {
return ((M + 31) / 32) * ((N + tn * 64 - 1) / (tn * 64)) * tn;
}
// v77 choose_config for fused path (M<=64)
static Cfg choose_config_fused(int M, int N, int K) {
constexpr int TARGET = 384, NUM_CUS = 228;
// For M <= 16, use 16x16x128 path
if (M <= 16 && K % 128 == 0) {
int tn = 1;
int w = wave_ct_16(M, N, tn);
int nks_full = K / 128;
int regime = (nks_full <= 6) ? 0 : 1;
if (K <= 512 || w >= TARGET) return {tn, 1, true, false, regime};
// v78: For 16x16 path with high K, use cooperative split-K
// to eliminate separate reduce kernel (~2us savings)
int occ_target = std::min(TARGET * 2, NUM_CUS * 4); // ~768 waves
int need = (occ_target + w - 1) / std::max(w, 1);
int sk = 1;
while (sk < need) sk *= 2;
sk = std::min(sk, std::max(1, K / 128));
if (sk >= 8) sk = 8; else if (sk >= 4) sk = 4; else if (sk >= 2) sk = 2; else sk = 1;
while (sk > 1 && (K % (sk * 128)) != 0) sk /= 2;
while (sk > 1 && K / sk < 512) sk /= 2;
sk = std::max(sk, 1);
// Separate reduce kernel for 16x16 (faster than cooperative due to lower block overhead)
return {tn, sk, true, false, regime};
}
// v78: Extended 1x2 tiling to all M > 16 (not just M <= 64)
// Amortizes A quantization across 2 column tiles, halving VALU/MFMA ratio
// For M > 64 this also eliminates the 2-kernel non-fused overhead
int nks_full_64 = K / 64;
if (M > 16 && N % 64 == 0 && nks_full_64 > 16) {
// Try different TILES_N for 1x2
struct { int tn; } cands_1x2[3]; int nc2;
if (M <= 32) { cands_1x2[0]={1}; cands_1x2[1]={2}; nc2=2; }
else if (M <= 128) { cands_1x2[0]={2}; cands_1x2[1]={1}; nc2=2; }
else { cands_1x2[0]={2}; cands_1x2[1]={4}; cands_1x2[2]={1}; nc2=3; }
int best_tn_1x2 = cands_1x2[0].tn, best_w_1x2 = 0;
int first_ok_tn = -1;
for (int i = 0; i < nc2; i++) {
int w = wave_ct_1x2(M, N, cands_1x2[i].tn);
if (w >= TARGET && first_ok_tn < 0) {
first_ok_tn = cands_1x2[i].tn;
}
if (w > best_w_1x2) { best_tn_1x2 = cands_1x2[i].tn; best_w_1x2 = w; }
}
// v78: For VALU-bound shapes, try cooperative 1x2 + split-K=2
// Each block has 2 waves handling different K-slices with 1x2 tiling
// Halves VALU/MFMA ratio (fits in MFMA window), no reduce kernel needed
// Also eliminates 2-kernel overhead for M>64 (fused instead of non-fused)
// v78: Cooperative 1x2 + split-K
// Use SK=4 when base occupancy is very low (need 4x boost)
// Use SK=2 when base occupancy is moderate (2x boost sufficient)
{
int try_sk = (best_w_1x2 < TARGET) ? 4 : 2; // SK=4 when below TARGET, SK=2 when at/above
if (best_w_1x2 >= NUM_CUS / 2 && K % (try_sk * 64) == 0 && K / try_sk >= 256) {
int coop_w = best_w_1x2 * try_sk;
if (coop_w >= TARGET) {
Cfg c = {1, try_sk, false, true, 2};
c.use_coop_sk = true;
return c;
}
}
// Fall back to SK=2 if SK=4 doesn't apply
if (try_sk > 2 && best_w_1x2 >= NUM_CUS / 2 && K % (2 * 64) == 0 && K / 2 >= 512) {
int coop_w = best_w_1x2 * 2;
if (coop_w >= TARGET) {
Cfg c = {1, 2, false, true, 2};
c.use_coop_sk = true;
return c;
}
}
}
// Use standard 1x2 without cooperative if base occupancy sufficient
if (first_ok_tn >= 0) {
return {first_ok_tn, 1, false, true, 2};
}
// Fall through to 32x32 path which has better base occupancy
}
// 32x32x64 path for M > 16 (standard 1x1 tiling)
struct { int tn; } cands[3]; int nc;
if (M <= 4) { cands[0]={1}; nc=1; }
else if (M <= 32) { cands[0]={1}; cands[1]={2}; nc=2; }
else { cands[0]={2}; cands[1]={4}; cands[2]={1}; nc=3; }
int best_tn = 1, best_w = 0;
for (int i = 0; i < nc; i++) {
int w = wave_ct_32(M, N, cands[i].tn);
if (w >= TARGET) {
int nks_full = K / 64;
int regime;
if (nks_full <= 6) regime = 0;
else regime = 1;
return {cands[i].tn, 1, false, false, regime};
}
if (w > best_w) { best_tn = cands[i].tn; best_w = w; }
}
int nks_full = K / 64;
int regime;
if (nks_full <= 6) regime = 0;
else if (nks_full > 16) regime = 1;
else regime = 0;
if (K <= 512 && best_w >= NUM_CUS / 2) return {best_tn, 1, false, false, regime};
if (K <= 512 && best_w >= NUM_CUS / 4) {
if (best_w * 2 >= TARGET && K >= 256) return {best_tn, 2, false, false, regime};
return {best_tn, 1, false, false, regime};
}
int need = (TARGET + best_w - 1) / std::max(best_w, 1);
int sk = 1;
while (sk < need) sk *= 2;
sk = std::min(sk, std::max(1, K / 128));
if (sk >= 8) sk = 8; else if (sk >= 4) sk = 4; else if (sk >= 2) sk = 2; else sk = 1;
while (sk > 1 && (K % (sk * 64)) != 0) sk /= 2;
return {best_tn, std::max(sk, 1), false, false, regime};
}
// v69 choose_config for nonfused path (M>64): tn=4 preferred
static Cfg choose_config_nf(int M, int N, int K) {
constexpr int TARGET = 384;
struct { int tn; } cands[2] = {{4}, {2}}; int nc = 2;
int best_tn = 4, best_w = 0;
for (int i = 0; i < nc; i++) {
int w = wave_ct_32(M, N, cands[i].tn);
if (w >= TARGET) {
int nks_full = K / 64;
int regime;
if (nks_full <= 6) regime = 0;
else if (M >= 128) regime = 2;
else regime = 1;
return {cands[i].tn, 1, false, false, regime};
}
if (w > best_w) { best_tn = cands[i].tn; best_w = w; }
}
int nks_full = K / 64;
int regime;
if (nks_full <= 6) regime = 0;
else if (M >= 128) regime = 2;
else regime = 1;
return {best_tn, 1, false, false, regime};
}
// 32x32x64 fused dispatch
#define L32(TN, NKS, SK, NB, RG) \
fused_gemm_kernel_32<TN, NKS, SK, NB, RG><<<grid, dim3(TN * WAVE_SIZE)>>>( \
a_bf16, b, bs_p, out, M, N, K, k_chunk, sn, m_tiles)
static void dispatch_32(
const __hip_bfloat16* a_bf16, const uint8_t* b, const uint8_t* bs_p,
void* out, int M, int N, int K, int k_chunk, int sn, int m_tiles,
int tn, int nks, bool sk, bool nb, int regime, dim3 grid)
{
if (tn == 1) {
if (nks==6 && sk && !nb) L32(1, 6, true, false, 0);
else if (nks==8 && !sk && !nb) L32(1, 8, false, false, 0);
else if (nks==8 && !sk && nb) L32(1, 8, false, true, 0);
else if (nks==14 && sk && !nb) L32(1, 14, true, false, 1);
} else if (tn == 2) {
if (nks==8 && !sk && !nb) L32(2, 8, false, false, 0);
else if (nks==8 && !sk && nb) L32(2, 8, false, true, 0);
else if (nks==12 && sk && nb) L32(2, 12, true, true, 1);
// v78: split-K entries for VALU-bound shapes
else if (nks==16 && sk && nb) L32(2, 16, true, true, 1);
else if (nks==16 && sk && !nb) L32(2, 16, true, false, 1);
else if (nks==24 && !sk && nb) L32(2, 24, false, true, 1);
else if (nks==24 && !sk && !nb) L32(2, 24, false, false, 1);
else if (nks==32 && !sk && nb) L32(2, 32, false, true, 1);
else if (nks==32 && !sk && !nb) L32(2, 32, false, false, 1);
} else if (tn == 4) {
if (nks==8 && !sk && !nb) L32(4, 8, false, false, 0);
else if (nks==24 && !sk && nb) L32(4, 24, false, true, 1);
else if (nks==24 && !sk && !nb) L32(4, 24, false, false, 1);
}
}
#undef L32
// v77: 1x2 tiling dispatch
#define L1x2(TN, NKS, SK, NB) \
fused_gemm_kernel_32_1x2<TN, NKS, SK, NB><<<grid, dim3(TN * WAVE_SIZE)>>>( \
a_bf16, b, bs_p, out, M, N, K, k_chunk, sn, m_tiles)
static void dispatch_1x2(
const __hip_bfloat16* a_bf16, const uint8_t* b, const uint8_t* bs_p,
void* out, int M, int N, int K, int k_chunk, int sn, int m_tiles,
int tn, int nks, bool sk, bool nb, dim3 grid)
{
// Shape 4: M=64, N=7168, K=2048 -> tn=2, nks=32, no splitk, nb=true
if (tn == 1) {
if (nks==32 && !sk && nb) L1x2(1, 32, false, true);
else if (nks==32 && !sk && !nb) L1x2(1, 32, false, false);
else if (nks==24 && !sk && nb) L1x2(1, 24, false, true);
else if (nks==24 && !sk && !nb) L1x2(1, 24, false, false);
} else if (tn == 2) {
if (nks==32 && !sk && nb) L1x2(2, 32, false, true);
else if (nks==32 && !sk && !nb) L1x2(2, 32, false, false);
else if (nks==24 && !sk && nb) L1x2(2, 24, false, true);
else if (nks==24 && !sk && !nb) L1x2(2, 24, false, false);
// v78: 1x2 + split-K for VALU-bound shapes
else if (nks==16 && sk && nb) L1x2(2, 16, true, true);
else if (nks==16 && sk && !nb) L1x2(2, 16, true, false);
}
}
#undef L1x2
// v78: Cooperative 1x2 + split-K=2 dispatch
#define LCOOP(NKS, SK, NB) \
fused_gemm_kernel_32_coop_1x2<NKS, SK, NB><<<grid, dim3(SK * WAVE_SIZE)>>>( \
a_bf16, b, bs_p, out, M, N, K, k_chunk, sn, m_tiles)
static void dispatch_coop_1x2(
const __hip_bfloat16* a_bf16, const uint8_t* b, const uint8_t* bs_p,
void* out, int M, int N, int K, int k_chunk, int sn, int m_tiles,
int nks, int sk, bool nb, dim3 grid)
{
if (sk == 2) {
if (nks==16 && nb) LCOOP(16, 2, true);
else if (nks==16 && !nb) LCOOP(16, 2, false);
else if (nks==12 && nb) LCOOP(12, 2, true);
else if (nks==12 && !nb) LCOOP(12, 2, false);
} else if (sk == 4) {
if (nks==8 && nb) LCOOP( 8, 4, true);
else if (nks==8 && !nb) LCOOP( 8, 4, false);
else if (nks==6 && nb) LCOOP( 6, 4, true);
else if (nks==6 && !nb) LCOOP( 6, 4, false);
}
}
#undef LCOOP
// 32x32x64 non-fused dispatch (from v69)
#define NF32(TN, NKS, SK, NB, RG) \
nonfused_gemm_kernel_32<TN, NKS, SK, NB, RG><<<grid, dim3(TN * WAVE_SIZE)>>>( \
a_q, a_sc, b, bs_p, out, M, N, K, k_chunk, sn_b, sn_a, m_tiles)
static void dispatch_nf32(
const uint8_t* a_q, const uint8_t* a_sc,
const uint8_t* b, const uint8_t* bs_p,
void* out, int M, int N, int K, int k_chunk, int sn_b, int sn_a, int m_tiles,
int tn, int nks, bool sk, bool nb, int regime, dim3 grid)
{
if (tn == 4) {
if (regime == 1) {
if (nks==24 && !sk && nb) NF32(4, 24, false, true, 1);
else if (nks==24 && !sk && !nb) NF32(4, 24, false, false, 1);
else if (nks==32 && !sk && nb) NF32(4, 32, false, true, 1);
else if (nks==32 && !sk && !nb) NF32(4, 32, false, false, 1);
} else {
if (nks==24 && !sk && nb) NF32(4, 24, false, true, 2);
else if (nks==24 && !sk && !nb) NF32(4, 24, false, false, 2);
else if (nks==32 && !sk && nb) NF32(4, 32, false, true, 2);
else if (nks==32 && !sk && !nb) NF32(4, 32, false, false, 2);
}
if (nks==8 && !sk && !nb) NF32(4, 8, false, false, 0);
else if (nks==8 && !sk && nb) NF32(4, 8, false, true, 0);
} else if (tn == 2) {
if (nks==12 && sk && nb) NF32(2, 12, true, true, 1);
else if (nks==32 && !sk && nb) NF32(2, 32, false, true, 1);
else if (nks==32 && !sk && !nb) NF32(2, 32, false, false, 1);
} else if (tn == 1) {
if (nks==6 && sk && !nb) NF32(1, 6, true, false, 0);
else if (nks==8 && !sk && !nb) NF32(1, 8, false, false, 0);
else if (nks==8 && !sk && nb) NF32(1, 8, false, true, 0);
else if (nks==14 && sk && !nb) NF32(1, 14, true, false, 1);
}
}
#undef NF32
// 16x16x128 dispatch
#define L16(TN, NKS, SK, NB, RG) \
fused_gemm_kernel_16<TN, NKS, SK, NB, RG><<<grid, dim3(TN * WAVE_SIZE)>>>( \
a_bf16, b, bs_p, out, M, N, K, k_chunk, sn, m_tiles)
static void dispatch_16(
const __hip_bfloat16* a_bf16, const uint8_t* b, const uint8_t* bs_p,
void* out, int M, int N, int K, int k_chunk, int sn, int m_tiles,
int tn, int nks, bool sk, bool nb, int regime, dim3 grid)
{
if (tn == 1) {
if (nks==4 && !sk && !nb) L16(1, 4, false, false, 0);
else if (nks==4 && !sk && nb) L16(1, 4, false, true, 0);
else if (nks==4 && sk && !nb) L16(1, 4, true, false, 0);
else if (nks==6 && sk && nb) L16(1, 6, true, true, 0);
else if (nks==6 && sk && !nb) L16(1, 6, true, false, 0);
else if (nks==7 && sk && !nb) L16(1, 7, true, false, 1);
else if (nks==7 && sk && nb) L16(1, 7, true, true, 1);
else if (nks==14 && sk && !nb) L16(1, 14, true, false, 1);
else if (nks==14 && sk && nb) L16(1, 14, true, true, 1);
else if (nks==3 && sk && !nb) L16(1, 3, true, false, 0);
else if (nks==2 && sk && !nb) L16(1, 2, true, false, 0);
else if (nks==12 && sk && nb) L16(1, 12, true, true, 1);
else if (nks==28 && sk && !nb) L16(1, 28, true, false, 1);
else if (nks==28 && sk && nb) L16(1, 28, true, true, 1);
else if (nks==56 && !sk && nb) L16(1, 56, false, true, 1);
else if (nks==56 && !sk && !nb) L16(1, 56, false, false, 1);
}
}
#undef L16
// v78: Cooperative split-K 16x16 dispatch
#define LC16(NKS, SK, NB, RG) \
fused_gemm_kernel_16_coop<NKS, SK, NB, RG><<<grid, dim3(SK * WAVE_SIZE)>>>( \
a_bf16, b, bs_p, out, M, N, K, k_chunk, sn, m_tiles)
static void dispatch_16_coop(
const __hip_bfloat16* a_bf16, const uint8_t* b, const uint8_t* bs_p,
void* out, int M, int N, int K, int k_chunk, int sn, int m_tiles,
int nks, int sk, bool nb, int regime, dim3 grid)
{
// sk is the number of cooperative waves per block
if (sk == 8) {
if (nks==7 && nb) LC16( 7, 8, true, 1);
else if (nks==7 && !nb) LC16( 7, 8, false, 1);
} else if (sk == 4) {
if (nks==14 && nb) LC16(14, 4, true, 1);
else if (nks==14 && !nb) LC16(14, 4, false, 1);
}
}
#undef LC16
// ============================================================
// Fused GEMM entry point (v78: extended to all M via 1x2 tiling)
// ============================================================
torch::Tensor fused_mxfp4_gemm(
torch::Tensor A_bf16, torch::Tensor B_sh,
torch::Tensor B_scale_sh,
int M, int N, int K)
{
auto a_bf16 = reinterpret_cast<const __hip_bfloat16*>(A_bf16.data_ptr<at::BFloat16>());
auto b = B_sh.data_ptr<uint8_t>();
auto bs_p = B_scale_sh.data_ptr<uint8_t>();
int sn = (((K / 32) + 7) / 8) * 8;
auto cfg = choose_config_fused(M, N, K);
int tn = cfg.tiles_n;
int split_k = cfg.split_k;
bool use_16 = cfg.use_16x16;
bool use_1x2 = cfg.use_1x2;
bool use_coop_sk = cfg.use_coop_sk;
int regime = cfg.regime;
auto bf16o = torch::TensorOptions().dtype(torch::kBFloat16).device(A_bf16.device());
if (use_16 && use_coop_sk && split_k >= 4) {
// v78: Cooperative split-K 16x16x128 — single kernel, LDS reduction
int npb = 16; // tn=1 for coop path
bool nb = (M % 16 == 0) && (N % npb == 0);
int mt = (M + 15) / 16;
int nt = (N + npb - 1) / npb;
int k_chunk = K / split_k;
int nks = k_chunk / 128;
auto C = torch::empty({M, N}, bf16o);
dispatch_16_coop(a_bf16, b, bs_p, C.data_ptr<at::BFloat16>(),
M, N, K, k_chunk, sn, mt, nks, split_k, nb, regime, dim3(mt * nt));
return C;
} else if (use_16) {
// 16x16x128 fused path
int npb = tn * 16;
bool nb = (M % 16 == 0) && (N % npb == 0);
int mt = (M + 15) / 16;
int nt = (N + npb - 1) / npb;
int k_chunk = (split_k <= 1) ? K : K / split_k;
int nks = k_chunk / 128;
if (split_k <= 1) {
auto C = torch::empty({M, N}, bf16o);
dispatch_16(a_bf16, b, bs_p, C.data_ptr<at::BFloat16>(),
M, N, K, K, sn, mt, tn, nks, false, nb, regime, dim3(mt * nt));
return C;
} else {
auto f32o = torch::TensorOptions().dtype(torch::kFloat32).device(A_bf16.device());
auto ws = torch::empty({split_k, M, N}, f32o);
dispatch_16(a_bf16, b, bs_p, ws.data_ptr<float>(),
M, N, K, k_chunk, sn, mt, tn, nks, true, nb, regime, dim3(mt * nt, split_k));
auto C = torch::empty({M, N}, bf16o);
int mn = M * N;
auto wsp = ws.data_ptr<float>();
auto cp = reinterpret_cast<uint16_t*>(C.data_ptr<at::BFloat16>());
int rb = ((mn + 3) / 4 + 255) / 256;
if (split_k == 2) { splitk_reduce<2><<<rb, 256>>>(wsp, cp, mn); }
else if (split_k == 4) { splitk_reduce<4><<<rb, 256>>>(wsp, cp, mn); }
else if (split_k == 8) { splitk_reduce<8><<<rb, 256>>>(wsp, cp, mn); }
else { splitk_reduce<2><<<rb, 256>>>(wsp, cp, mn); }
return C;
}
} else if (use_1x2 && use_coop_sk) {
// v78: Cooperative 1x2 + split-K — single kernel, LDS reduction
int npb = 64; // each block covers 64 N-columns (1x2 per wave)
bool nb = (M % 32 == 0) && (N % npb == 0);
int mt = (M + 31) / 32;
int nt = (N + npb - 1) / npb;
int k_chunk = K / split_k;
int nks = k_chunk / 64;
auto C = torch::empty({M, N}, bf16o);
dispatch_coop_1x2(a_bf16, b, bs_p, C.data_ptr<at::BFloat16>(),
M, N, K, k_chunk, sn, mt, nks, split_k, nb, dim3(mt * nt));
return C;
} else if (use_1x2) {
// v78: 1x2 tiling fused path (32x64 per wave, shared A quantization)
int npb = tn * 64; // each wave covers 64 N-columns
bool nb = (M % 32 == 0) && (N % npb == 0);
int mt = (M + 31) / 32;
int nt = (N + npb - 1) / npb;
int k_chunk = (split_k <= 1) ? K : K / split_k;
int nks = k_chunk / 64;
if (split_k <= 1) {
auto C = torch::empty({M, N}, bf16o);
dispatch_1x2(a_bf16, b, bs_p, C.data_ptr<at::BFloat16>(),
M, N, K, K, sn, mt, tn, nks, false, nb, dim3(mt * nt));
return C;
} else {
auto f32o = torch::TensorOptions().dtype(torch::kFloat32).device(A_bf16.device());
auto ws = torch::empty({split_k, M, N}, f32o);
dispatch_1x2(a_bf16, b, bs_p, ws.data_ptr<float>(),
M, N, K, k_chunk, sn, mt, tn, nks, true, nb, dim3(mt * nt, split_k));
auto C = torch::empty({M, N}, bf16o);
int mn = M * N;
auto wsp = ws.data_ptr<float>();
auto cp = reinterpret_cast<uint16_t*>(C.data_ptr<at::BFloat16>());
int rb = ((mn + 3) / 4 + 255) / 256;
if (split_k == 2) { splitk_reduce<2><<<rb, 256>>>(wsp, cp, mn); }
else if (split_k == 4) { splitk_reduce<4><<<rb, 256>>>(wsp, cp, mn); }
else if (split_k == 8) { splitk_reduce<8><<<rb, 256>>>(wsp, cp, mn); }
else { splitk_reduce<2><<<rb, 256>>>(wsp, cp, mn); }
return C;
}
} else {
// 32x32x64 fused path
int npb = tn * 32;
bool nb = (M % 32 == 0) && (N % npb == 0);
int mt = (M + 31) / 32, nt = (N + npb - 1) / npb;
int k_chunk = (split_k <= 1) ? K : K / split_k;
int nks = k_chunk / 64;
if (split_k <= 1) {
auto C = torch::empty({M, N}, bf16o);
dispatch_32(a_bf16, b, bs_p, C.data_ptr<at::BFloat16>(),
M, N, K, K, sn, mt, tn, nks, false, nb, regime, dim3(mt * nt));
return C;
} else {
auto f32o = torch::TensorOptions().dtype(torch::kFloat32).device(A_bf16.device());
auto ws = torch::empty({split_k, M, N}, f32o);
dispatch_32(a_bf16, b, bs_p, ws.data_ptr<float>(),
M, N, K, k_chunk, sn, mt, tn, nks, true, nb, regime, dim3(mt * nt, split_k));
auto C = torch::empty({M, N}, bf16o);
int mn = M * N;
auto wsp = ws.data_ptr<float>();
auto cp = reinterpret_cast<uint16_t*>(C.data_ptr<at::BFloat16>());
int rb = ((mn + 3) / 4 + 255) / 256;
if (split_k == 2) { splitk_reduce<2><<<rb, 256>>>(wsp, cp, mn); }
else if (split_k == 4) { splitk_reduce<4><<<rb, 256>>>(wsp, cp, mn); }
else if (split_k == 8) { splitk_reduce<8><<<rb, 256>>>(wsp, cp, mn); }
else { splitk_reduce<2><<<rb, 256>>>(wsp, cp, mn); }
return C;
}
}
}
// ============================================================
// HIP quantization kernel: bf16 A -> fp4 A_q + e8m0 A_scale (with shuffle)
// ============================================================
__global__
__attribute__((amdgpu_flat_work_group_size(256, 256)))
void quant_bf16_to_mxfp4(
const __hip_bfloat16* __restrict__ A_bf16,
uint8_t* __restrict__ A_q,
uint8_t* __restrict__ A_scale_sh,
int M, int K, int sn_a)
{
const int tid_global = blockIdx.x * blockDim.x + threadIdx.x;
const int num_groups = K / 32;
const int row = tid_global / num_groups;
const int group = tid_global % num_groups;
if (row >= M) return;
const uint32_t* src = reinterpret_cast<const uint32_t*>(A_bf16) + (size_t)row * (K >> 1) + (size_t)group * 16;
uint32_t data[16];
uint32_t amax_pk = 0;
#pragma unroll
for (int i = 0; i < 4; i++) {
*reinterpret_cast<uint4*>(&data[i*4]) = *reinterpret_cast<const uint4*>(src + i*4);
#pragma unroll
for (int j = 0; j < 4; j++) {
uint32_t abs_pair = data[i*4+j] & 0x7FFF7FFFu;
amax_pk = pk_max_u16(amax_pk, abs_pair);
}
}
uint32_t amax_u32 = max(amax_pk & 0xFFFFu, amax_pk >> 16);
float amax = __uint_as_float(amax_u32 << 16);
uint32_t amax_bits = __float_as_uint(amax);
amax_bits = (amax_bits + 0x200000u) & 0xFF800000u;
int biased_exp = (int)((amax_bits >> 23) & 0xFF);
int scale_unbiased = biased_exp - 129;
scale_unbiased = max(scale_unbiased, -127);
scale_unbiased = min(scale_unbiased, 127);
int scale_e8m0 = scale_unbiased + 127;
int hw_scale_exp = 127 + scale_unbiased;
float hw_scale = __uint_as_float((uint32_t)hw_scale_exp << 23);
uint32_t packed[4];
#pragma unroll
for (int j = 0; j < 4; j++) {
uint32_t r0 = data[j*4+0], r1 = data[j*4+1];
uint32_t r2 = data[j*4+2], r3 = data[j*4+3];
uint32_t w;
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wuninitialized"
w = __builtin_amdgcn_cvt_scalef32_pk_fp4_bf16(
w, *reinterpret_cast<const bf16x2_t*>(&r0), hw_scale, 0);
w = __builtin_amdgcn_cvt_scalef32_pk_fp4_bf16(
w, *reinterpret_cast<const bf16x2_t*>(&r1), hw_scale, 1);
w = __builtin_amdgcn_cvt_scalef32_pk_fp4_bf16(
w, *reinterpret_cast<const bf16x2_t*>(&r2), hw_scale, 2);
w = __builtin_amdgcn_cvt_scalef32_pk_fp4_bf16(
w, *reinterpret_cast<const bf16x2_t*>(&r3), hw_scale, 3);
#pragma clang diagnostic pop
packed[j] = w;
}
uint8_t* dst_q = A_q + (size_t)row * (K >> 1) + (size_t)group * 16;
*reinterpret_cast<uint4*>(dst_q) = *reinterpret_cast<const uint4*>(packed);
// Write scale to shuffled position
int i0 = row / 32, i1 = (row & 31) / 16, i2 = row & 15;
int i3 = group / 8, i4 = (group & 7) / 4, i5 = group & 3;
size_t scale_off = (size_t)i0 * 32 * sn_a + (size_t)i3 * 256 + (size_t)i5 * 64 + (size_t)i2 * 4 + (size_t)i4 * 2 + (size_t)i1;
A_scale_sh[scale_off] = (uint8_t)scale_e8m0;
}
// ============================================================
// Combined quant + non-fused GEMM (M>64 path, all in C++)
// ============================================================
torch::Tensor quant_and_nonfused_gemm(
torch::Tensor A_bf16, torch::Tensor B_sh, torch::Tensor B_scale_sh,
int M, int N, int K)
{
auto a_bf16_ptr = reinterpret_cast<const __hip_bfloat16*>(A_bf16.data_ptr<at::BFloat16>());
auto b = B_sh.data_ptr<uint8_t>();
auto bs_p = B_scale_sh.data_ptr<uint8_t>();
int sn_a = (((K / 32) + 7) / 8) * 8;
int sn_b = sn_a;
// Allocate A_q and A_scale_sh
int sm_a = ((M + 255) / 256) * 256;
auto u8o = torch::TensorOptions().dtype(torch::kUInt8).device(A_bf16.device());
auto A_q_t = torch::empty({M, K / 2}, u8o);
auto A_scale_sh_t = (sm_a > M) ?
torch::full({sm_a, sn_a}, 127, u8o) :
torch::empty({sm_a, sn_a}, u8o);
auto a_q = A_q_t.data_ptr<uint8_t>();
auto a_sc = A_scale_sh_t.data_ptr<uint8_t>();
// Launch quant kernel
int num_groups = K / 32;
int total_groups = M * num_groups;
int quant_blocks = (total_groups + 255) / 256;
quant_bf16_to_mxfp4<<<quant_blocks, 256>>>(a_bf16_ptr, a_q, a_sc, M, K, sn_a);
// Launch non-fused GEMM kernel using nf config
auto cfg = choose_config_nf(M, N, K);
int tn = cfg.tiles_n;
int regime = 2; // Force compute-bound for non-fused (pure VMEM+MFMA)
auto bf16o = torch::TensorOptions().dtype(torch::kBFloat16).device(A_bf16.device());
int npb = tn * 32;
bool nb = (M % 32 == 0) && (N % npb == 0);
int mt = (M + 31) / 32, nt = (N + npb - 1) / npb;
int nks = K / 64;
auto C = torch::empty({M, N}, bf16o);
dispatch_nf32(a_q, a_sc, b, bs_p, C.data_ptr<at::BFloat16>(),
M, N, K, K, sn_b, sn_a, mt, tn, nks, false, nb, regime, dim3(mt * nt));
return C;
}
""";
CPP_SRC = """
torch::Tensor fused_mxfp4_gemm(
torch::Tensor A_bf16, torch::Tensor B_sh,
torch::Tensor B_scale_sh,
int M, int N, int K);
torch::Tensor quant_and_nonfused_gemm(
torch::Tensor A_bf16, torch::Tensor B_sh, torch::Tensor B_scale_sh,
int M, int N, int K);
torch::Tensor fused_16_1x4_gemm(
torch::Tensor A_bf16, torch::Tensor B_sh,
torch::Tensor B_scale_sh,
int M, int N, int K);
""";
module = load_inline(
name='mxfp4_v76',
cpp_sources=[CPP_SRC],
cuda_sources=[CUDA_SRC],
functions=['fused_mxfp4_gemm', 'quant_and_nonfused_gemm', 'fused_16_1x4_gemm'],
verbose=True,
extra_cuda_cflags=[
"--offload-arch=gfx950",
"-std=c++20",
"-O3",
"-ffast-math",
"-mllvm", "--amdgpu-function-calls=false",
],
)
def custom_kernel(data: input_t) -> output_t:
A, B, B_q, B_shuffle, B_scale_sh = data
m, k = A.shape
n = B.shape[0]
if m > 64 and n % 64 == 0 and k % 128 == 0:
# v78: 16x16x128 1x4 for M>64 — eliminates 2-kernel non-fused overhead
return module.fused_16_1x4_gemm(
A.contiguous(),
B_shuffle.view(torch.uint8),
B_scale_sh.view(torch.uint8),
m, n, k)
elif m > 64:
# Non-fused path for large M when 1x4 can't be used
return module.quant_and_nonfused_gemm(
A.contiguous(),
B_shuffle.view(torch.uint8),
B_scale_sh.view(torch.uint8),
m, n, k)
elif 16 < m <= 32 and n % 64 == 0 and k % 128 == 0:
# v78: 16x16x128 1x4 for M≤32 — beats 32x32 for small M
return module.fused_16_1x4_gemm(
A.contiguous(),
B_shuffle.view(torch.uint8),
B_scale_sh.view(torch.uint8),
m, n, k)
else:
# Fused path for small M
return module.fused_mxfp4_gemm(
A.contiguous(),
B_shuffle.view(torch.uint8),
B_scale_sh.view(torch.uint8),
m, n, k)
scrolls · 2218 lines total
Source code from GPU Mode and the KernelBot dataset · June 9 Researcher Reciprocity License v1.0
Best evidence level for this revision: reported
JSON