tools/factory/specs/deepseek_node_dispatch_pack.py

"""Spec for `deepseek-node-dispatch-pack` — the node-limited expert-parallel dispatch: deduplicate each
token's experts down to the set of NODES that hold them and pack the all-to-all send buffer."""
import pathlib
import sys

sys.path.insert(0, str(pathlib.Path(__file__).resolve().parents[1]))
from spec import TaskSpec

SPEC = TaskSpec(
    name="deepseek-node-dispatch-pack",
    title="Write a fast node-limited MoE dispatch (dedup + all-to-all send-buffer pack) kernel",
    blurb=("DeepSeek-V3's node-limited routing exists so that a token's experts live on at most a handful "
           "of nodes — and the payoff is collected right here, in the kernel that builds the all-to-all "
           "send buffer. A token routed to four experts on the same node is sent to that node ONCE, not "
           "four times, so the dispatch has to deduplicate every token's expert set down to a node set, "
           "rank the tokens per node, and gather the hidden states into node-major order. It is the "
           "largest tensor in the layer moved once, with an index computation that is anything but a "
           "memcpy."),
    keywords=["mle", "kernel-generation", "moe", "expert-parallel", "dispatch", "all-to-all", "deepseek",
              "node-limited", "gather", "memory-bound"],
    module="dispatch_pack.py",
    func="node_dispatch_pack",
    signature="node_dispatch_pack(x, topk_ids, num_nodes, experts_per_node)",
    returns_doc="""Node-limited MoE dispatch: dedup to node sets and pack the all-to-all send buffer.

Args:
    x:                (T, H) bfloat16 — token hidden states.
    topk_ids:         (T, K) int32    — the K expert ids chosen for each token (distinct within a row).
    num_nodes:        int             — N, the number of expert-parallel nodes.
    experts_per_node: int             — EPN; expert e lives on node e // EPN.

Returns:
    (send_buf, src_token, node_counts, node_offsets) where
      send_buf:     (T*M, H) bfloat16 — hidden states in NODE-MAJOR order, tokens ascending inside a node
      src_token:    (T*M,)   int32    — the token each packed row came from
      node_counts:  (N,)     int32    — rows destined for each node
      node_offsets: (N+1,)   int32    — node n owns rows [node_offsets[n], node_offsets[n+1])
    M is the (fixed) number of distinct nodes every token's experts span, so T*M rows are always
    produced.""",

    reference_imports="import torch",
    reference_src='''
def node_dispatch_pack(x, topk_ids, num_nodes, experts_per_node):
    """Deduplicate each token's experts to a node set, then gather node-major.

    Correct and simple — it is the exact SPECIFICATION, not a performance target. It materialises a dense
    (T, N) boolean membership matrix and lets `nonzero` do the ordering and the ranking, which is exactly
    the multi-pass shape a real kernel replaces with one privatised histogram and one gather.
    """
    T, K = topk_ids.shape
    node = topk_ids.to(torch.int64) // experts_per_node             # (T, K) node of every routed slot
    member = torch.zeros(T, num_nodes, dtype=torch.bool, device=x.device)
    member.scatter_(1, node, True)                                  # DEDUP: token -> set of nodes

    pairs = member.t().nonzero()                    # (R, 2) = [node, token], node-major, token-ascending
    src = pairs[:, 1]
    send_buf = x[src]                                               # the gather

    counts = member.sum(0).to(torch.int32)                          # rows per node
    offsets = torch.cat([torch.zeros(1, dtype=torch.int32, device=x.device),
                         torch.cumsum(counts, 0).to(torch.int32)])
    return send_buf, src.to(torch.int32), counts, offsets
''',
    make_inputs_src='''
def _mk(T, H, K, N, M, EPN, seed):
    """Hidden states plus a NODE-LIMITED routing table: every token's K experts are distinct and span
    EXACTLY M distinct nodes, which is what the node-limited router guarantees and what makes the packed
    length T*M a function of the shape alone.

    Slot j of a token goes to the (j % M)-th of its M chosen nodes, and takes the (j // M)-th entry of a
    random permutation of that node's experts — so the K experts are always distinct.
    """
    gen = torch.Generator(device="cuda").manual_seed(seed)
    x = torch.randn(T, H, device="cuda", dtype=torch.bfloat16, generator=gen)

    nodes = torch.rand(T, N, device="cuda", generator=gen).argsort(dim=-1)[:, :M]      # (T, M) distinct
    perm = torch.rand(T, M, EPN, device="cuda", generator=gen).argsort(dim=-1)         # (T, M, EPN)
    j = torch.arange(K, device="cuda")
    m, r = j % M, j // M
    sel_node = nodes[:, m]                                                             # (T, K)
    sel_off = perm[:, m, r]                                                            # (T, K)
    topk_ids = (sel_node * EPN + sel_off).to(torch.int32)
    del nodes, perm, sel_node, sel_off
    return x, topk_ids.contiguous(), N, EPN
''',
    flops_src='''
def canonical_work(T, H, K, N, M, EPN):
    """BYTES attributed to one dispatch pack, from the SHAPE ALONE.

    The unavoidable traffic: read the (T, H) bf16 hidden states once, read the (T, K) int32 routing table,
    write the (T*M, H) bf16 send buffer and the (T*M,) int32 source map. The membership bitset, the
    per-node counters and the prefix sum are tiny and never need to reach HBM. Node-limited routing fixes
    the number of copies at exactly M per token, so this is a function of the shape alone. This is a
    memory-bound kernel, so the score is achieved bandwidth against this fixed byte count.
    """
    return 2 * T * H + 4 * T * K + 2 * T * M * H + 4 * T * M + 4 * (2 * N + 1)
''',
    flops_formula=("bytes = 2*T*H  +  4*T*K  +  2*T*M*H  +  4*T*M  +  4*(2*N+1)\n"
                   "#       read x   read ids  write buf   src map   counts+offsets"),

    metric="GB/s",
    compare="tuple",
    tuple_names=("send_buf", "src_token", "node_counts", "node_offsets"),
    tol=1e-5,   # MEASURED: the payload is a pure gather, so an independent implementation differs by 0.0
    shape_names=("T", "H", "K", "N", "M", "EPN"),
    grader_shapes=[(32768, 7168, 8, 8, 4, 32), (24576, 7168, 8, 8, 4, 32),
                   (49152, 4096, 8, 8, 4, 32), (32768, 7168, 6, 8, 3, 32),
                   (32768, 5120, 8, 4, 3, 64)],
    measure_shapes=[(28672, 7168, 8, 8, 4, 32), (20480, 7168, 8, 8, 4, 32),
                    (40960, 4096, 8, 8, 4, 32), (28672, 7168, 6, 8, 3, 32),
                    (28672, 5120, 8, 4, 3, 64)],
    measure_quick_shapes=[(4096, 2048, 8, 8, 4, 32), (8192, 1024, 6, 4, 3, 16),
                          (2048, 4096, 8, 8, 2, 32)],
    correct_shapes=[(256, 512, 8, 4, 2, 16), (129, 256, 6, 4, 3, 8), (512, 1024, 8, 8, 4, 16),
                    (64, 128, 4, 4, 2, 8)],

    spec_md="""In expert-parallel serving the experts are spread over `N` nodes — expert `e` lives on node
`e // EPN` — and before the all-to-all can run, every token's hidden state has to be copied into the send
buffer of each node that owns one of its experts.

**The dedup is the point.** A token routed to four experts that happen to live on the same node is sent to
that node **once**. So the first step is to turn each token's `K` expert ids into a *set* of nodes:

```
node[t, j]  = topk_ids[t, j] // EPN
member[t,n] = True iff any j has node[t, j] == n
```

DeepSeek's node-limited routing guarantees each token's experts span exactly `M` distinct nodes, so
`member` has exactly `M` true entries per row and the packed buffer is exactly `T*M` rows long.

**The packing is node-major, token-ascending inside a node:**

```
node_counts[n]  = number of tokens with member[t, n]
node_offsets    = [0, cumsum(node_counts)]                 # (N+1,)
```

Node `n` owns rows `[node_offsets[n], node_offsets[n+1])` of `send_buf`, and those rows hold its tokens in
**increasing token index**. Formally, if `r` is the rank of token `t` among the tokens that chose node `n`
(counting in increasing `t`):

```
send_buf[node_offsets[n] + r, :] = x[t, :]
src_token[node_offsets[n] + r]   = t
```

`src_token` is what the combine step later uses to scatter the expert outputs back, so it is part of the
contract, not a debugging aid.

Note what is **not** asked for: no per-expert grouping, no weights, no padding. This is the transport
layer — one copy of each token per destination node, in the order the receiver expects.

`/app/reference.py` builds a dense `(T, N)` boolean matrix and lets `nonzero` produce the ordering. That is
the exact specification; it is deliberately simple rather than fast.""",

    contract_md="""| arg | shape | dtype | meaning |
|-----|-------|-------|---------|
| `x` | `(T, H)` | `bfloat16` | token hidden states |
| `topk_ids` | `(T, K)` | `int32` | the `K` expert ids per token, **distinct within a row** |
| `num_nodes` | int | | `N` |
| `experts_per_node` | int | | `EPN`; expert `e` is on node `e // EPN` |

**Return a 4-tuple in exactly this order:**

| out | shape | dtype | notes |
|-----|-------|-------|-------|
| `send_buf` | `(T*M, H)` | `bfloat16` | node-major, token-ascending inside each node |
| `src_token` | `(T*M,)` | `int32` | source token of each packed row; compared **exactly** |
| `node_counts` | `(N,)` | `int32` | compared **exactly** |
| `node_offsets` | `(N+1,)` | `int32` | exclusive prefix sum, `node_offsets[N] == T*M`; compared **exactly** |

`M` — the number of distinct nodes each token's experts span — is **fixed for a given call** and is what
makes `T*M` a shape-only quantity; you can compute it, but you do not need to guess it, because
`send_buf`'s length follows from the routing table you are given.

All inputs are **read-only**; the copy is functional. `T` is **not** guaranteed to be a multiple of any
tile size — the correctness shapes include `T = 129`.""",

    regime_md="""**Shape regime you are graded in** (the exact grader sizes are *not* disclosed): `T`
(tokens in the micro-batch) in 24576–49152, `H` in 4096–7168, `K` in 6–8, `N` (nodes) 4 or 8, `M`
(distinct nodes per token) 3 or 4, `EPN` in 32–64. The send buffer is 3–4x the size of the input, so this
call moves more bytes than any other single op in the MoE layer.""",

    correctness_md="""Three of the four outputs are **integer** and are compared **bit-exactly** — one
wrong row index anywhere and the score is 0. `send_buf` is a pure gather, so a correct kernel reproduces it
**bit for bit**; its `1e-5` gate exists only to reject a change of dtype.

The ordering rules are an exact specification, not a convention: **node-major** blocks, **ascending token
index** inside each block. Two variants that break them were tried and both fail outright — packing
token-major (all of token 0's copies, then token 1's) and leaving the tokens unsorted inside a node. So
does skipping the dedup and emitting one row per expert slot, which produces `T*K` rows instead of `T*M`
and fails on shape.""",

    perf_md="""One read of `x`, `M` writes of each row, and an index computation in between. The floor is
`(1 + M)` passes over a `(T, H)`-sized tensor and nothing else, which is what the byte count assumes.

The index side is small but it is where the naive version dies. The reference's `(T, N)` boolean matrix,
`nonzero`, and the implied sort cost several passes over `T*N` and a device-wide scan. What it actually is:

* a **bitset per token** — `N <= 8` nodes fit in one byte, so the dedup is `mask |= 1 << (e // EPN)` over
  `K` ids, entirely in registers;
* a **histogram** of `N` counters, which wants per-block privatised counters and one atomic per block per
  node, not one atomic per token;
* a **prefix sum over `N <= 8` numbers**, which is one warp;
* a **rank within node**, which is the block's own offset plus a lane prefix — again no global sort.

Then the gather. Each destination row is a full `H`-wide bf16 copy (8–14 KB), so use vectorised 128-bit
accesses and give each row enough lanes to saturate; the read of `x[t]` serves all `M` of its destinations,
so a block that has a token's row in registers or shared memory should write **all** its copies before
moving on — reading `x` once instead of `M` times is a 25–33% bandwidth saving on its own.

The destinations of one token are `M` widely separated offsets, so the writes are scattered at row
granularity but perfectly coalesced within a row. Prefer a grid over (token tile) with the row resident,
rather than a grid over output rows that re-reads the source.""",

    precision_md="""`x` and `send_buf` are **bfloat16** and the copy is exact — no arithmetic happens to
the payload at all, so a correct kernel is bit-identical to the reference and the `1e-5` gate is
effectively an exactness check. Returning `send_buf` in fp32 would change the contract (and cost twice the
bandwidth for no benefit); returning it in fp8 would be a lossy transform of data that is supposed to be
transported unchanged.

The three integer outputs are compared **exactly**: `.float()` is lossy above 2^24 and `T*M` reaches
200000 here, so the grader never converts them.

**Where the tolerance comes from.** It is measured, and the measurement is that there is nothing to
measure: an independent implementation — the membership computed as a per-token bitmask, the ranking from
a scatter-add histogram plus a segmented rank instead of `nonzero`, and the gather written as an explicit
row copy — differs from this reference by a relative Frobenius error of exactly **0.0e+00** on `send_buf`
and reproduces all three integer outputs **bit for bit**, at every correctness shape and at a full-size
graded shape, over several seeds. The gate is set at `1e-5` rather than at zero only so that a legitimate
bf16 round-trip cannot fail on a denormal; it admits nothing except the specified bf16 payload, and in
particular an fp8 or fp16 payload would miss it by 1e-3 or more.""",
).validate()