peacock-data-public-datasets-idc-llm_eval
/
env-llmeval
/lib
/python3.10
/site-packages
/triton
/ops
/matmul.py
| import torch | |
| from .. import Config, autotune, cdiv, heuristics, jit | |
| from .. import language as tl | |
| from .matmul_perf_model import early_config_prune, estimate_matmul_time | |
| _ordered_datatypes = [torch.float16, torch.bfloat16, torch.float32] | |
| def get_higher_dtype(a, b): | |
| if a is b: | |
| return a | |
| assert a in _ordered_datatypes | |
| assert b in _ordered_datatypes | |
| for d in _ordered_datatypes: | |
| if a is d: | |
| return b | |
| if b is d: | |
| return a | |
| def init_to_zero(name): | |
| return lambda nargs: nargs[name].zero_() | |
| def get_configs_io_bound(): | |
| configs = [] | |
| for num_stages in [2, 3, 4, 5, 6]: | |
| for block_m in [16, 32]: | |
| for block_k in [32, 64]: | |
| for block_n in [32, 64, 128, 256]: | |
| num_warps = 2 if block_n <= 64 else 4 | |
| configs.append( | |
| Config({'BLOCK_M': block_m, 'BLOCK_N': block_n, 'BLOCK_K': block_k, 'SPLIT_K': 1}, | |
| num_stages=num_stages, num_warps=num_warps)) | |
| # split_k | |
| for split_k in [2, 4, 8, 16]: | |
| configs.append( | |
| Config({'BLOCK_M': block_m, 'BLOCK_N': block_n, 'BLOCK_K': block_k, 'SPLIT_K': split_k}, | |
| num_stages=num_stages, num_warps=num_warps, pre_hook=init_to_zero('C'))) | |
| return configs | |
| def _kernel(A, B, C, M, N, K, # | |
| stride_am, stride_ak, # | |
| stride_bk, stride_bn, # | |
| stride_cm, stride_cn, # | |
| dot_out_dtype: tl.constexpr, # | |
| allow_tf32: tl.constexpr, # | |
| fp8_fast_accum: tl.constexpr, # | |
| BLOCK_M: tl.constexpr, BLOCK_N: tl.constexpr, BLOCK_K: tl.constexpr, # | |
| GROUP_M: tl.constexpr, SPLIT_K: tl.constexpr, EVEN_K: tl.constexpr, AB_DTYPE: tl.constexpr # | |
| ): | |
| # matrix multiplication | |
| pid = tl.program_id(0) | |
| pid_z = tl.program_id(1) | |
| grid_m = tl.cdiv(M, BLOCK_M) | |
| grid_n = tl.cdiv(N, BLOCK_N) | |
| # re-order program ID for better L2 performance | |
| width = GROUP_M * grid_n | |
| group_id = pid // width | |
| group_size = min(grid_m - group_id * GROUP_M, GROUP_M) | |
| pid_m = group_id * GROUP_M + (pid % group_size) | |
| pid_n = (pid % width) // (group_size) | |
| # do matrix multiplication | |
| rm = pid_m * BLOCK_M + tl.arange(0, BLOCK_M) | |
| rn = pid_n * BLOCK_N + tl.arange(0, BLOCK_N) | |
| ram = tl.max_contiguous(tl.multiple_of(rm % M, BLOCK_M), BLOCK_M) | |
| rbn = tl.max_contiguous(tl.multiple_of(rn % N, BLOCK_N), BLOCK_N) | |
| rk = pid_z * BLOCK_K + tl.arange(0, BLOCK_K) | |
| # pointers | |
| A = A + (ram[:, None] * stride_am + rk[None, :] * stride_ak) | |
| B = B + (rk[:, None] * stride_bk + rbn[None, :] * stride_bn) | |
| acc = tl.zeros((BLOCK_M, BLOCK_N), dtype=dot_out_dtype) | |
| for k in range(0, tl.cdiv(K, BLOCK_K * SPLIT_K)): | |
| if EVEN_K: | |
| a = tl.load(A) | |
| b = tl.load(B) | |
| else: | |
| k_remaining = K - k * (BLOCK_K * SPLIT_K) | |
| _0 = tl.zeros((1, 1), dtype=C.dtype.element_ty) | |
| a = tl.load(A, mask=rk[None, :] < k_remaining, other=_0) | |
| b = tl.load(B, mask=rk[:, None] < k_remaining, other=_0) | |
| if AB_DTYPE: | |
| a = a.to(C.dtype.element_ty) | |
| b = b.to(C.dtype.element_ty) | |
| if fp8_fast_accum: | |
| acc = tl.dot(a, b, acc, out_dtype=dot_out_dtype, allow_tf32=allow_tf32) | |
| else: | |
| acc += tl.dot(a, b, out_dtype=dot_out_dtype, allow_tf32=allow_tf32) | |
| A += BLOCK_K * SPLIT_K * stride_ak | |
| B += BLOCK_K * SPLIT_K * stride_bk | |
| acc = acc.to(C.dtype.element_ty) | |
| # rematerialize rm and rn to save registers | |
| rm = pid_m * BLOCK_M + tl.arange(0, BLOCK_M) | |
| rn = pid_n * BLOCK_N + tl.arange(0, BLOCK_N) | |
| C = C + (rm[:, None] * stride_cm + rn[None, :] * stride_cn) | |
| mask = (rm < M)[:, None] & (rn < N)[None, :] | |
| # handles write-back with reduction-splitting | |
| if SPLIT_K == 1: | |
| tl.store(C, acc, mask=mask) | |
| else: | |
| tl.atomic_add(C, acc, mask=mask) | |
| class _matmul(torch.autograd.Function): | |
| kernel = _kernel | |
| _locks = {} | |
| def _call(a, b, dot_out_dtype, allow_tf32, fp8_fast_accum): | |
| device = a.device | |
| # handle non-contiguous inputs if necessary | |
| if a.stride(0) > 1 and a.stride(1) > 1: | |
| a = a.contiguous() | |
| if b.stride(0) > 1 and b.stride(1) > 1: | |
| b = b.contiguous() | |
| # checks constraints | |
| assert a.shape[1] == b.shape[0], "incompatible dimensions" | |
| M, K = a.shape | |
| _, N = b.shape | |
| # allocates output | |
| if a.dtype in [tl.float8e4nv, tl.float8e4b15, tl.float8e5] or\ | |
| b.dtype in [tl.float8e4nv, tl.float8e4b15, tl.float8e5]: | |
| c_dtype = torch.float16 | |
| elif a.dtype in [torch.int8] or b.dtype in [torch.int8]: | |
| c_dtype = torch.int32 | |
| else: | |
| c_dtype = get_higher_dtype(a.dtype, b.dtype) | |
| c = torch.empty((M, N), device=device, dtype=c_dtype) | |
| if dot_out_dtype is None: | |
| if c_dtype in [torch.float16, torch.float32, torch.bfloat16]: | |
| dot_out_dtype = tl.float32 | |
| else: | |
| dot_out_dtype = tl.int32 | |
| else: | |
| assert isinstance(dot_out_dtype, torch.dtype), "dot_out_dtype must be a torch.dtype" | |
| if dot_out_dtype == torch.float16: | |
| dot_out_dtype = tl.float16 | |
| elif dot_out_dtype in [torch.float32, torch.bfloat16]: | |
| dot_out_dtype = tl.float32 | |
| else: | |
| dot_out_dtype = tl.int32 | |
| ab_dtype = True | |
| if a.dtype in [tl.float8e4nv, tl.float8e5] and b.dtype in [tl.float8e4nv, tl.float8e5]: | |
| ab_dtype = False | |
| if a.dtype in [torch.int8] and b.dtype in [torch.int8]: | |
| ab_dtype = False | |
| # launch kernel | |
| grid = lambda META: (cdiv(M, META['BLOCK_M']) * cdiv(N, META['BLOCK_N']), META['SPLIT_K']) | |
| _kernel[grid]( | |
| a, b, c, M, N, K, # | |
| a.stride(0), a.stride(1), # | |
| b.stride(0), b.stride(1), # | |
| c.stride(0), c.stride(1), # | |
| dot_out_dtype=dot_out_dtype, # | |
| allow_tf32=allow_tf32, # | |
| fp8_fast_accum=fp8_fast_accum, # | |
| GROUP_M=8, AB_DTYPE=ab_dtype) | |
| return c | |
| def forward(ctx, a, b, dot_out_dtype=None, allow_tf32=True, fp8_fast_accum=True): | |
| return _matmul._call(a, b, dot_out_dtype=dot_out_dtype, allow_tf32=allow_tf32, fp8_fast_accum=fp8_fast_accum) | |
| matmul = _matmul.apply | |