| """TP-aware embedding and LM head (L2 operators).""" |
|
|
| from __future__ import annotations |
|
|
| import torch |
| import torch.distributed as dist |
| import torch.nn as nn |
| import triton |
| import triton.language as tl |
|
|
| from ....infra.context import get_context |
| from ....infra.tp import _tp_size, _tp_rank |
| from ..L1.linear import Matmul |
| from ..L1.embedding import Embedding |
| from ..L1.allreduce import AllReduce |
|
|
|
|
| @triton.autotune( |
| configs=[ |
| triton.Config({"BLOCK": 256}, num_warps=4, num_stages=1), |
| triton.Config({"BLOCK": 512}, num_warps=4, num_stages=1), |
| triton.Config({"BLOCK": 1024}, num_warps=4, num_stages=1), |
| triton.Config({"BLOCK": 1024}, num_warps=8, num_stages=1), |
| triton.Config({"BLOCK": 2048}, num_warps=4, num_stages=1), |
| triton.Config({"BLOCK": 2048}, num_warps=8, num_stages=1), |
| triton.Config({"BLOCK": 4096}, num_warps=8, num_stages=1), |
| ], |
| key=["num_rows", "embedding_dim"], |
| ) |
| @triton.jit |
| def _embedding_kernel(weight, input_ids, output, num_rows: tl.constexpr, |
| embedding_dim: tl.constexpr, BLOCK: tl.constexpr): |
| chunk = tl.program_id(0) |
| chunks_per_row = tl.cdiv(embedding_dim, BLOCK) |
| row = chunk // chunks_per_row |
| col = (chunk % chunks_per_row) * BLOCK + tl.arange(0, BLOCK) |
| index = tl.load(input_ids + row) |
| mask = col < embedding_dim |
| value = tl.load(weight + index * embedding_dim + col, mask=mask) |
| tl.store(output + row * embedding_dim + col, value, mask=mask) |
|
|
|
|
| @triton.autotune( |
| configs=[ |
| triton.Config({"BM": 16, "BN": 128, "BK": 64}, num_warps=4, |
| num_stages=3), |
| triton.Config({"BM": 16, "BN": 256, "BK": 64}, num_warps=8, |
| num_stages=3), |
| triton.Config({"BM": 32, "BN": 128, "BK": 64}, num_warps=4, |
| num_stages=3), |
| triton.Config({"BM": 32, "BN": 256, "BK": 64}, num_warps=8, |
| num_stages=3), |
| triton.Config({"BM": 64, "BN": 128, "BK": 64}, num_warps=4, |
| num_stages=2), |
| triton.Config({"BM": 64, "BN": 128, "BK": 64}, num_warps=4, |
| num_stages=3), |
| triton.Config({"BM": 64, "BN": 128, "BK": 64}, num_warps=4, |
| num_stages=4), |
| triton.Config({"BM": 64, "BN": 128, "BK": 64}, num_warps=8, |
| num_stages=3), |
| triton.Config({"BM": 64, "BN": 128, "BK": 64}, num_warps=4, |
| num_stages=3, num_ctas=2), |
| triton.Config({"BM": 64, "BN": 128, "BK": 128}, num_warps=4, |
| num_stages=3), |
| triton.Config({"BM": 64, "BN": 256, "BK": 64}, num_warps=8, |
| num_stages=3), |
| ], |
| key=["M", "N", "K"], |
| ) |
| @triton.jit |
| def _lm_head_kernel(x, weight, output, M: tl.constexpr, N: tl.constexpr, |
| K: tl.constexpr, BM: tl.constexpr, BN: tl.constexpr, |
| BK: tl.constexpr): |
| pid_m = tl.program_id(0) |
| pid_n = tl.program_id(1) |
| rows = pid_m * BM + tl.arange(0, BM) |
| cols = pid_n * BN + tl.arange(0, BN) |
| inner = tl.arange(0, BK) |
| x_ptrs = x + rows[:, None] * K + inner[None, :] |
| w_ptrs = weight + cols[:, None] * K + inner[None, :] |
| accumulator = tl.zeros((BM, BN), dtype=tl.float32) |
| for offset in range(0, K, BK): |
| a = tl.load(x_ptrs, mask=(rows[:, None] < M) & |
| (inner[None, :] + offset < K), other=0.0) |
| b = tl.load(w_ptrs, mask=(cols[:, None] < N) & |
| (inner[None, :] + offset < K), other=0.0) |
| accumulator += tl.dot(a, tl.trans(b)) |
| x_ptrs += BK |
| w_ptrs += BK |
| out_ptrs = output + rows[:, None] * N + cols[None, :] |
| tl.store(out_ptrs, accumulator, |
| mask=(rows[:, None] < M) & (cols[None, :] < N)) |
|
|
|
|
| class VocabParallelEmbedding(nn.Module): |
| def __init__(self, num_embeddings: int, embedding_dim: int, |
| params_dtype: torch.dtype | None = None, |
| org_num_embeddings: int | None = None, |
| padding_size: int = 64): |
| super().__init__() |
| tp, rank = _tp_size(), _tp_rank() |
| assert num_embeddings % tp == 0 |
| self.num_embeddings = num_embeddings |
| self.org_vocab_size = org_num_embeddings or num_embeddings |
| self.padding_size = padding_size |
| self.embedding_dim = embedding_dim |
| self.per_partition = num_embeddings // tp |
| self.vocab_start = self.per_partition * rank |
| self.vocab_end = self.vocab_start + self.per_partition |
| self.tp_size = tp |
| if params_dtype is None: |
| params_dtype = torch.get_default_dtype() |
| self.embedding_op = Embedding(self.per_partition, embedding_dim) |
| self.embedding_op.emb.weight.weight_loader = self._weight_loader |
| self.allreduce = AllReduce() |
|
|
| def _weight_loader(self, param, loaded_weight): |
| tp, rank = _tp_size(), _tp_rank() |
| shard = param.data.size(0) |
| param.data.copy_(loaded_weight.narrow(0, rank * shard, shard)) |
|
|
| def forward(self, x): |
| if self.tp_size == 1: |
| y = torch.empty((*x.shape, self.embedding_dim), device=x.device, |
| dtype=self.embedding_op.emb.weight.dtype) |
| grid = lambda meta: ( |
| x.numel() * triton.cdiv(self.embedding_dim, meta["BLOCK"]), |
| ) |
| _embedding_kernel[grid]( |
| self.embedding_op.emb.weight, x, y, x.numel(), |
| self.embedding_dim, |
| ) |
| return y |
|
|
| if self.tp_size > 1: |
| mask = (x >= self.vocab_start) & (x < self.vocab_end) |
| x = mask * (x - self.vocab_start) |
| y = self.embedding_op(x) |
| if self.tp_size > 1: |
| y = mask.unsqueeze(-1) * y |
| y = self.allreduce(y) |
| return y |
|
|
|
|
| class ParallelLMHead(VocabParallelEmbedding): |
| def __init__(self, num_embeddings: int, embedding_dim: int, |
| bias: bool = False, |
| params_dtype: torch.dtype | None = None, |
| org_num_embeddings: int | None = None, |
| padding_size: int = 64): |
| super().__init__(num_embeddings, embedding_dim, |
| params_dtype=params_dtype, |
| org_num_embeddings=org_num_embeddings, |
| padding_size=padding_size) |
| self.linear_op = Matmul() |
|
|
| def project(self, x): |
| """Linear projection only (no gather). Used inside CUDA graph.""" |
| ctx = get_context() |
| if ctx.is_mixed: |
| x = x[ctx.logit_indices].contiguous() |
| elif ctx.is_prefill: |
| last_indices = ctx.cu_seqlens_q[1:] - 1 |
| x = x[last_indices].contiguous() |
| if x.ndim == 2 and 1 < x.shape[0] <= 64: |
| m, k = x.shape |
| n = self.per_partition |
| output = torch.empty((m, n), device=x.device, dtype=x.dtype) |
| grid = lambda meta: ( |
| triton.cdiv(m, meta["BM"]), |
| triton.cdiv(n, meta["BN"]), |
| ) |
| _lm_head_kernel[grid]( |
| x, self.embedding_op.emb.weight, output, m, n, k, |
| ) |
| return output |
| return self.linear_op(x, self.embedding_op.emb.weight) |
|
|
| def gather_logits(self, logits): |
| """Gather partial logits from all ranks. Used outside CUDA graph.""" |
| if self.tp_size > 1: |
| all_logits = [torch.empty_like(logits) for _ in range(self.tp_size)] if _tp_rank() == 0 else None |
| dist.gather(logits, all_logits, 0) |
| logits = torch.cat(all_logits, -1) if _tp_rank() == 0 else logits |
| return logits |
|
|
| def gather_greedy(self, logits): |
| """Fast path for greedy: local argmax + small allgather. |
| |
| Instead of gathering full vocab logits (~31MB/rank), gather only |
| the (max_val, max_idx) per sequence (~2KB/rank). |
| Returns token IDs directly on rank 0, None on other ranks. |
| """ |
| if self.tp_size <= 1: |
| return None |
|
|
| rank = _tp_rank() |
| local_max_vals, local_max_idxs = logits.max(dim=-1) |
| local_max_idxs = local_max_idxs + self.vocab_start |
|
|
| info = torch.stack([local_max_vals, local_max_idxs.float()], dim=-1) |
| gathered = [torch.empty_like(info) for _ in range(self.tp_size)] |
| dist.all_gather(gathered, info) |
| if rank == 0: |
| all_info = torch.stack(gathered, dim=0) |
| all_vals = all_info[:, :, 0] |
| all_idxs = all_info[:, :, 1].long() |
| best_rank = all_vals.argmax(dim=0) |
| bs = logits.size(0) |
| token_ids = all_idxs[best_rank, torch.arange(bs, device=logits.device)] |
| return token_ids |
| return None |
|
|
| def forward(self, x): |
| logits = self.project(x) |
| return self.gather_logits(logits) |
|
|
