Upload folder using huggingface_hub

README.md

@@ -10,39 +10,6 @@ tags:
 - benchmark
 size_categories:
 - n<1K
-dataset_info:
-  features:
-  - name: problem_id
-    dtype: int64
-  - name: stem
-    dtype: large_string
-  - name: reference_code
-    dtype: large_string
-  - name: reference_path
-    dtype: large_string
-  - name: input_tensor_spec_path
-    dtype: large_string
-  - name: world_size
-    dtype: int64
-  - name: default_m
-    dtype: int64
-  - name: default_n
-    dtype: int64
-  - name: default_dtype
-    dtype: large_string
-  - name: default_trials
-    dtype: int64
-  splits:
-  - name: train
-    num_bytes: 282750
-    num_examples: 87
-  download_size: 85789
-  dataset_size: 282750
-configs:
-- config_name: default
-  data_files:
-  - split: train
-    path: data/train-*
 ---
 
 # ParallelKernelBench (benchmark)

reference/26_moe_token_preprocess.py

@@ -43,6 +43,11 @@ def solution(
     expert_mask: torch.Tensor,
     num_experts: int,
     group: Optional[dist.ProcessGroup] = None,
-) -> Tuple[List[int], List[int], torch.Tensor, torch.Tensor]:
+) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor]:
     group = group or dist.group.WORLD
-    return _preprocess_impl(expert_mask=expert_mask, num_experts=num_experts, ep_group=group)
+    input_splits, output_splits, per_local_expert, sum_per_local_expert = _preprocess_impl(
+        expert_mask=expert_mask, num_experts=num_experts, ep_group=group
+    )
+    input_splits_t = torch.tensor(input_splits, dtype=torch.long)
+    output_splits_t = torch.tensor(output_splits, dtype=torch.long)
+    return (input_splits_t, output_splits_t, per_local_expert, sum_per_local_expert)

reference/31_fused_moe_fwd.py

@@ -1,3 +1,9 @@
+# Expert-parallel (EP) fused MoE forward — BASE case.
+#
+# This is the generic fused MoE forward pass: router (softmax + top-k) -> token
+# permutation -> all_to_all dispatch -> per-expert SiLU MLP -> all_to_all combine ->
+# weighted unpermute. Here the expert count is fixed (num_experts = 8) regardless of
+# world size, so the EP load pattern depends on the launch configuration.
 from typing import List, Optional, Tuple, Union
 
 import torch

reference/49_moe_ep_balanced.py

@@ -1,3 +1,10 @@
+# Expert-parallel (EP) fused MoE forward — BALANCED EP.
+#
+# Same kernel as problem 31 (router -> permute -> all_to_all dispatch -> per-expert
+# SiLU MLP -> all_to_all combine -> unpermute), but the harness sets
+# num_experts == world_size, i.e. exactly one expert per rank. With uniform routing
+# this gives the balanced all_to_all dispatch pattern (each rank sends/receives a
+# roughly equal token count).
 from typing import List, Optional, Tuple, Union
 
 import torch

reference/50_moe_ep_wide.py

@@ -1,3 +1,10 @@
+# Expert-parallel (EP) fused MoE forward — WIDE EP.
+#
+# Same kernel as problem 31 (router -> permute -> all_to_all dispatch -> per-expert
+# SiLU MLP -> all_to_all combine -> unpermute), but the harness sets
+# num_experts == world_size * 2, i.e. multiple experts hosted per rank. This stresses
+# the per-rank local expert loop and the larger, more fragmented all_to_all token
+# dispatch relative to the balanced case.
 from typing import List, Optional, Tuple, Union
 
 import torch

reference/64_gnn_neighbor_sampling.py

@@ -25,10 +25,7 @@ def _sample_one_hop_csc_dist(
         take = min(k, deg) if k >= 0 else deg
 
         if take > 0:
-            if replace:
-                perm = torch.randint(deg, (take,), device=input_nodes.device)
-            else:
-                perm = torch.randperm(deg, device=input_nodes.device)[:take]
+            perm = torch.arange(take, device=input_nodes.device)
             sampled_nodes.append(row[start:end].index_select(0, perm))
             sampled_edges.append(torch.arange(start, end, device=input_nodes.device).index_select(0, perm))
 

utils/input_output_tensors.py

@@ -7,8 +7,6 @@ consistent tensor creation and saving behavior.
 
 import os
 import json
-import copy
-import importlib.util
 import math
 
 import torch
@@ -53,7 +51,6 @@ def save_tensor(output, logs_dir: str, rank: int) -> str:
 # but may include Python scalars / dicts / dataclasses (e.g. problem 4, problems 100–105).
 #   - solution(tensor) for single-tensor problems: x is (tensor,)
 #   - solution(t1, t2) for multi-arg problems: x is (t1, t2, ...)
-# Problems 100–105: solution(rank, world_size, cfg, input_ids).
 # Output from solution_fn may still be a single tensor or a tuple; save_tensor() handles both.
 # ---------------------------------------------------------------------------
 
@@ -62,7 +59,6 @@ def _seed(problem_id: int, rank: int, trial: int = 0) -> None:
     torch.manual_seed(42 + problem_id * 1000 + rank + trial * 1_000_003)
 
 _PROJECT_ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
-_REF_MODULES_CACHE: dict[int, object] = {}
 
 def _round_up_multiple(n: int, m: int) -> int:
     return ((n + m - 1) // m) * m
@@ -98,50 +94,6 @@ def _moe_narrow_num_experts(world_size: int) -> int:
 def _linear(in_features: int, out_features: int, dtype: torch.dtype, device) -> torch.nn.Linear:
     return torch.nn.Linear(in_features, out_features).to(device=device, dtype=dtype)
 
-def _load_reference_module(problem_id: int):
-    if problem_id in _REF_MODULES_CACHE:
-        return _REF_MODULES_CACHE[problem_id]
-    stem = {
-        100: "100_deepseek_v3_671b_tp_attn_ep_moe",
-        101: "101_gemma3_27b_tp_attn_tp_mlp",
-        102: "102_llama32_3b_tp_attn_tp_mlp",
-        103: "103_olmo_3_32b_tp_attn_tp_mlp",
-        104: "104_qwen3_235b_tp_attn_ep_moe",
-        105: "105_qwen3_code_flash_30b_tp_attn_ep_moe",
-        106: "106_deepseek_v3_671b_cp_ulysses_attn_ep_moe",
-        107: "107_gemma3_27b_cp_ulysses_attn_tp_mlp",
-        108: "108_llama32_3b_cp_ulysses_attn_tp_mlp",
-        109: "109_olmo_3_32b_cp_ulysses_attn_tp_mlp",
-        110: "110_qwen3_235b_cp_ulysses_attn_ep_moe",
-        111: "111_qwen3_code_flash_30b_cp_ulysses_attn_ep_moe",
-    }[problem_id]
-    path = os.path.join(_PROJECT_ROOT, "reference", f"{stem}.py")
-    spec = importlib.util.spec_from_file_location(f"ref_{stem}", path)
-    mod = importlib.util.module_from_spec(spec)
-    spec.loader.exec_module(mod)
-    _REF_MODULES_CACHE[problem_id] = mod
-    return mod
-
-def _align_model_args_100(cfg, world_size: int) -> None:
-    """ModelArgs for reference/100: TP/EP divisibility constraints."""
-    cfg.n_layers = 2
-    for attr in ("dim", "inter_dim", "moe_inter_dim"):
-        v = getattr(cfg, attr)
-        if v % world_size:
-            setattr(cfg, attr, _round_up_multiple(v, world_size))
-    if cfg.vocab_size % world_size:
-        cfg.vocab_size = _round_up_multiple(cfg.vocab_size, world_size)
-    if cfg.n_heads % world_size:
-        cfg.n_heads = _round_up_multiple(cfg.n_heads, world_size)
-    if cfg.n_routed_experts % world_size:
-        cfg.n_routed_experts = _round_up_multiple(cfg.n_routed_experts, world_size)
-    shared = cfg.n_shared_experts * cfg.moe_inter_dim
-    guard = 0
-    while shared % world_size and guard < 4096:
-        cfg.moe_inter_dim += 1
-        shared = cfg.n_shared_experts * cfg.moe_inter_dim
-        guard += 1
-
 def _common_attn_dims(base_shape, world_size):
     """Shared (B, T, num_heads, head_dim) from base_shape (M, N)."""
     M, N = base_shape
@@ -277,6 +229,39 @@ def _build_polar_azimuth_groups(azimuth_size: int):
     polar_rank = dist.get_rank(polar_group)
     return azimuth_group, polar_group, azimuth_rank, polar_rank, azimuth_size, polar_size
 
+def _build_ep_fsdp_groups(ep_size: int):
+    """
+    Build a 2D EP x EP-FSDP process grid for problem 22 (EP-aware grad clipping).
+    Rank layout: rank = ep_fsdp_idx * ep_size + ep_idx. The EP group reduces across
+    experts (contiguous blocks of ep_size); the EP-FSDP group reduces across the FSDP
+    replicas of each expert (strided). The two groups tile the world, so reducing an
+    EP grad term over both stages sums it across every rank exactly once.
+
+    Returns (ep_group, ep_fsdp_group). For a degenerate EP layout (ep_size <= 1 or it
+    does not divide world_size) the EP term is reduced over the whole world in a single
+    stage: (None, WORLD).
+    """
+    world_size = dist.get_world_size()
+    rank = dist.get_rank()
+    if ep_size <= 1 or world_size % ep_size != 0:
+        return None, dist.group.WORLD
+
+    ep_fsdp_size = world_size // ep_size
+    ep_group = None
+    ep_fsdp_group = None
+    for blk in range(ep_fsdp_size):
+        ranks = list(range(blk * ep_size, (blk + 1) * ep_size))
+        g = dist.new_group(ranks=ranks)
+        if rank in ranks:
+            ep_group = g
+    for ep_idx in range(ep_size):
+        ranks = [ep_idx + blk * ep_size for blk in range(ep_fsdp_size)]
+        g = dist.new_group(ranks=ranks)
+        if rank in ranks:
+            ep_fsdp_group = g
+    assert ep_group is not None and ep_fsdp_group is not None
+    return ep_group, ep_fsdp_group
+
 def create_input_tensor(
     rank: int,
     world_size: int,
@@ -295,7 +280,7 @@ def create_input_tensor(
     Args:
         rank: Process rank (0..world_size-1)
         world_size: Total number of processes
-        problem_id: Problem ID (e.g. 1–105) from reference filename
+        problem_id: Problem ID (e.g. 1–87) from reference filename
         base_shape: Base tensor shape tuple (e.g., (M, N))
         dtype: Tensor data type
         trial: Non-negative index; changes RNG for problems that use random inputs (trial=0 is legacy behavior).
@@ -438,7 +423,7 @@ def create_input_tensor(
     elif problem_id == 21:
         _seed(problem_id, rank, trial)
         grad_tensors = [torch.randn(base_shape, dtype=dtype, device=dev) for _ in range(3)]
-        return (grad_tensors, 1.0, 2.0, None)
+        return (grad_tensors, 1.0, 2.0, dist.group.WORLD)
 
     # 22: clip_grad_norm_ep
     elif problem_id == 22:
@@ -446,7 +431,8 @@ def create_input_tensor(
         non_ep = [torch.randn(base_shape, dtype=dtype, device=dev)]
         ep_size = max(1, world_size // 2)
         ep = [torch.randn(base_shape, dtype=dtype, device=dev)]
-        return (non_ep, ep, 1.0, 2.0, ep_size, None, None, None)
+        ep_group, ep_fsdp_group = _build_ep_fsdp_groups(ep_size)
+        return (non_ep, ep, 1.0, 2.0, ep_size, dist.group.WORLD, ep_fsdp_group, ep_group)
 
     # 23: grad_acc_loss
     elif problem_id == 23: