| """Reference implementation — the CORRECTNESS SPEC for `moe_a2a_dispatch`. |
| |
| This is correct but slow. It defines exactly what your kernel must reproduce; its speed has no |
| bearing on your score, which is an absolute GB/s number. GENERATED by _factory/build.py. |
| """ |
| import torch |
| import torch.distributed as dist |
|
|
|
|
| def moe_a2a_dispatch(x, expert_idx, num_experts, ctx): |
| """Reference: sort by expert, all-gather the count matrix, one NCCL all-to-all, then a regroup loop. |
| |
| Correct and simple; it is the SPECIFICATION, not a performance target. There is no arithmetic here — |
| every output row is a verbatim copy of an input row — so a correct implementation matches bitwise. |
| """ |
| W, r = ctx.world_size, ctx.rank |
| E = num_experts |
| EL = E // W |
| T, H = x.shape |
| dev = x.device |
| idx = expert_idx.long() |
|
|
| order = torch.argsort(idx, stable=True) |
| xs = x[order].contiguous() |
| cnt = torch.bincount(idx, minlength=E).to(torch.int32) |
|
|
| all_cnt = torch.empty(W * E, dtype=torch.int32, device=dev) |
| dist.all_gather_into_tensor(all_cnt, cnt, group=ctx.group) |
| all_cnt = all_cnt.view(W, E) |
| recv = all_cnt[:, r * EL:(r + 1) * EL].contiguous() |
|
|
| send_split = cnt.view(W, EL).sum(1).tolist() |
| recv_split = recv.sum(1).tolist() |
| y_raw = torch.empty(int(sum(recv_split)), H, dtype=x.dtype, device=dev) |
| dist.all_to_all_single(y_raw, xs, recv_split, send_split, group=ctx.group) |
|
|
| |
| y = torch.empty_like(y_raw) |
| base = torch.cat([torch.zeros(1, dtype=torch.long, device=dev), recv.sum(0).long().cumsum(0)]) |
| cur = base[:-1].tolist() |
| rc = recv.tolist() |
| off = 0 |
| for s in range(W): |
| for e in range(EL): |
| n = rc[s][e] |
| if n: |
| y[cur[e]:cur[e] + n] = y_raw[off:off + n] |
| cur[e] += n |
| off += n |
| return y, recv |
|
|
