| import math |
|
|
| import tilelang |
| import torch |
| from tilelang import language as T |
|
|
|
|
| @tilelang.jit( |
| pass_configs={ |
| tilelang.PassConfigKey.TL_DISABLE_WARP_SPECIALIZED: True, |
| tilelang.PassConfigKey.TL_PTXAS_REGISTER_USAGE_LEVEL: 10, |
| tilelang.PassConfigKey.TL_DISABLE_VECTORIZE_256: True, |
| }, |
| ) |
| def _mhc_post_fwd(mhc: int, hidden: int, n_thr: int = 128, h_blk: int = 1024) -> tilelang.JITKernel: |
| n = T.dynamic('num_tokens') |
| h = hidden |
|
|
| h_blk = math.gcd(hidden, h_blk) |
|
|
| @T.prim_func |
| def _mhc_post_fwd_kernel( |
| a: T.Tensor[(n, mhc, mhc), T.float32], |
| b: T.Tensor[(n, mhc, h), T.bfloat16], |
| c: T.Tensor[(n, mhc), T.float32], |
| d: T.Tensor[(n, h), T.bfloat16], |
| x: T.Tensor[(n, mhc, h), T.bfloat16], |
| ) -> None: |
| with T.Kernel(n, threads=n_thr) as pid_n: |
| x_shared = T.alloc_shared((mhc, h_blk), T.bfloat16) |
| b_shared = T.alloc_shared((mhc, h_blk), T.bfloat16) |
| d_shared = T.alloc_shared(h_blk, T.bfloat16) |
|
|
| x_local = T.alloc_fragment((mhc, h_blk), T.float32) |
| b_local = T.alloc_fragment((mhc, h_blk), T.float32) |
| d_local = T.alloc_fragment(h_blk, T.float32) |
|
|
| a_local = T.alloc_fragment((mhc, mhc), T.float32) |
| c_local = T.alloc_fragment(mhc, T.float32) |
| T.copy(a[pid_n, 0, 0], a_local) |
| T.copy(c[pid_n, 0], c_local) |
| T.pdl_sync() |
|
|
| for i0_h in T.Pipelined(T.ceildiv(h, h_blk), num_stages=2): |
| T.copy(b[pid_n, 0, i0_h * h_blk], b_shared, disable_tma=True) |
| T.copy(d[pid_n, i0_h * h_blk], d_shared, disable_tma=True) |
|
|
| T.copy(b_shared, b_local) |
| T.copy(d_shared, d_local) |
| for i_mhco, i1_h in T.Parallel(mhc, h_blk): |
| x_local[i_mhco, i1_h] = c_local[i_mhco] * d_local[i1_h] |
| for i_mhci in T.serial(mhc): |
| x_local[i_mhco, i1_h] += a_local[i_mhci, i_mhco] * b_local[i_mhci, i1_h] |
| T.copy(x_local, x_shared) |
|
|
| T.copy(x_shared, x[pid_n, 0, i0_h * h_blk], disable_tma=True) |
|
|
| return _mhc_post_fwd_kernel |
|
|
|
|
| @tilelang.jit( |
| pass_configs={ |
| tilelang.PassConfigKey.TL_DISABLE_WARP_SPECIALIZED: True, |
| tilelang.PassConfigKey.TL_PTXAS_REGISTER_USAGE_LEVEL: 10, |
| tilelang.PassConfigKey.TL_DISABLE_VECTORIZE_256: True, |
| }, |
| out_idx=[5, 6, 7, 8], |
| ) |
| def _mhc_post_bwd(mhc: int, hidden: int, n_thr: int = 128, h_blk: int = 256) -> tilelang.JITKernel: |
| assert mhc == 4 |
| n = T.dynamic('num_tokens') |
| h = hidden |
|
|
| h_blk = math.gcd(hidden, h_blk) |
|
|
| @T.prim_func |
| def _mhc_post_bwd_kernel( |
| dx: T.Tensor[(n, 4, h), T.bfloat16], |
| a: T.Tensor[(n, 4, 4), T.float32], |
| b: T.Tensor[(n, 4, h), T.bfloat16], |
| c: T.Tensor[(n, 4), T.float32], |
| d: T.Tensor[(n, h), T.bfloat16], |
| da: T.Tensor[(n, 4, 4), T.float32], |
| db: T.Tensor[(n, 4, h), T.bfloat16], |
| dc: T.Tensor[(n, 4), T.float32], |
| dd: T.Tensor[(n, h), T.bfloat16], |
| ) -> None: |
| with T.Kernel(n, threads=n_thr) as pid_n: |
| dx_shared = T.alloc_shared((4, h_blk), T.bfloat16) |
| b_shared = T.alloc_shared((4, h_blk), T.bfloat16) |
| db_shared = T.alloc_shared((4, h_blk), T.bfloat16) |
| d_shared = T.alloc_shared(h_blk, T.bfloat16) |
| dd_shared = T.alloc_shared(h_blk, T.bfloat16) |
|
|
| dx_local = T.alloc_fragment((4, h_blk), T.float32) |
| b_local = T.alloc_fragment((4, h_blk), T.float32) |
| db_local = T.alloc_fragment((4, h_blk), T.float32) |
| d_local = T.alloc_fragment(h_blk, T.float32) |
| dd_local = T.alloc_fragment(h_blk, T.float32) |
|
|
| a_local = T.alloc_fragment((4, 4), T.float32) |
| c_local = T.alloc_fragment(4, T.float32) |
| T.copy(a[pid_n, 0, 0], a_local) |
| T.copy(c[pid_n, 0], c_local) |
|
|
| da_reducer = T.alloc_reducer((4, 4), T.float32, replication='all') |
| dc_reducer = T.alloc_reducer(4, T.float32, replication='all') |
| T.clear(da_reducer) |
| T.clear(dc_reducer) |
|
|
| for i0_h in T.Pipelined(T.ceildiv(h, h_blk), num_stages=3): |
| T.copy(dx[pid_n, 0, i0_h * h_blk], dx_shared, disable_tma=True) |
| T.copy(b[pid_n, 0, i0_h * h_blk], b_shared, disable_tma=True) |
| T.copy(d[pid_n, i0_h * h_blk], d_shared, disable_tma=True) |
|
|
| T.copy(dx_shared, dx_local) |
| T.copy(b_shared, b_local) |
| T.copy(d_shared, d_local) |
|
|
| |
| T.clear(db_local) |
| for i_mhci in T.serial(4): |
| for i_mhco in T.serial(4): |
| for i1_h in T.Parallel(h_blk): |
| db_local[i_mhci, i1_h] += a_local[i_mhci, i_mhco] * dx_local[i_mhco, i1_h] |
| da_reducer[i_mhci, i_mhco] += b_local[i_mhci, i1_h] * dx_local[i_mhco, i1_h] |
|
|
| |
| T.clear(dd_local) |
| for i_mhc in T.serial(4): |
| for i1_h in T.Parallel(h_blk): |
| dc_reducer[i_mhc] += d_local[i1_h] * dx_local[i_mhc, i1_h] |
| dd_local[i1_h] += c_local[i_mhc] * dx_local[i_mhc, i1_h] |
|
|
| T.copy(db_local, db_shared) |
| T.copy(dd_local, dd_shared) |
|
|
| T.copy(db_shared, db[pid_n, 0, i0_h * h_blk], disable_tma=True) |
| T.copy(dd_shared, dd[pid_n, i0_h * h_blk], disable_tma=True) |
|
|
| T.finalize_reducer(da_reducer) |
| T.finalize_reducer(dc_reducer) |
| T.copy(da_reducer, da[pid_n, 0, 0]) |
| T.copy(dc_reducer, dc[pid_n, 0]) |
|
|
| return _mhc_post_bwd_kernel |
|
|
|
|
| def mhc_post_fwd( |
| x: torch.Tensor, |
| residual: torch.Tensor, |
| post_layer_mix: torch.Tensor, |
| comb_res_mix: torch.Tensor, |
| out: torch.Tensor | None = None, |
| ) -> torch.Tensor: |
| num_seqs, num_tokens, mhc, hidden = residual.shape |
|
|
| assert x.dtype == torch.bfloat16, f'{x.dtype=}' |
| assert residual.dtype == torch.bfloat16, f'{residual.dtype=}' |
| assert post_layer_mix.dtype == torch.float32, f'{post_layer_mix.dtype=}' |
| assert comb_res_mix.dtype == torch.float32, f'{comb_res_mix.dtype=}' |
| assert x.shape == (num_seqs, num_tokens, hidden), f'{x.shape=}' |
| assert post_layer_mix.shape == (num_seqs, num_tokens, mhc, 1), f'{post_layer_mix.shape=}' |
| assert comb_res_mix.shape == (num_seqs, num_tokens, mhc, mhc), f'{comb_res_mix.shape=}' |
|
|
| residual = residual.contiguous() |
| assert x.is_contiguous() |
| assert post_layer_mix.is_contiguous() |
| assert comb_res_mix.is_contiguous() |
|
|
| if out is None: |
| out = torch.empty_like(residual) |
| kernel = _mhc_post_fwd(mhc, hidden) |
| kernel( |
| comb_res_mix.flatten(0, 1), |
| residual.flatten(0, 1), |
| post_layer_mix.flatten(0, 1).squeeze(-1), |
| x.flatten(0, 1), |
| out.flatten(0, 1), |
| ) |
| return out |
|
|
|
|
| def mhc_post_bwd( |
| x: torch.Tensor, |
| residual: torch.Tensor, |
| post_layer_mix: torch.Tensor, |
| comb_res_mix: torch.Tensor, |
| d_o: torch.Tensor, |
| fuse_grad_acc: bool = True, |
| ) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor]: |
| n = d_o.shape[0] * d_o.shape[1] |
| mhc = d_o.shape[2] |
| h = d_o.shape[3] |
|
|
| bwd_kernel = _mhc_post_bwd(mhc, h) |
| ( |
| d_comb_res_mix, |
| d_residual, |
| d_post_layer_mix, |
| d_x, |
| ) = bwd_kernel( |
| d_o.contiguous().view(n, mhc, h), |
| comb_res_mix.view(n, mhc, mhc), |
| residual.view(n, mhc, h), |
| post_layer_mix.view(n, mhc), |
| x.view(n, h), |
| ) |
| assert isinstance(d_x, torch.Tensor) |
| assert isinstance(d_post_layer_mix, torch.Tensor) |
| assert isinstance(d_comb_res_mix, torch.Tensor) |
| assert isinstance(d_residual, torch.Tensor) |
| if fuse_grad_acc: |
| residual.untyped_storage().grad_from_mhc_post = d_residual |
|
|
| return ( |
| d_x.view_as(x), |
| d_residual.view_as(residual), |
| d_post_layer_mix.view_as(post_layer_mix), |
| d_comb_res_mix.view_as(comb_res_mix), |
| ) |
|
|
