submission 619833

#!POPCORN leaderboard amd-moe-mxfp4
#!POPCORN gpu MI355X

import os
import time
from task import input_t, output_t

from aiter import ActivationType, QuantType
from aiter.fused_moe import fused_moe

_PROFILE_SPLIT = os.getenv("POPCORN_PROFILE_SPLIT", "0") == "1"
_PROFILE_EVERY = int(os.getenv("POPCORN_PROFILE_EVERY", "10"))
_USE_DOWEIGHT_STAGE1 = os.getenv("POPCORN_MOE_DOWEIGHT_STAGE1", "0") == "1"
_FORCE_AITER_USE_NT = os.getenv("POPCORN_FORCE_AITER_USE_NT", "-1")
_FORCE_AITER_KSPLIT = os.getenv("POPCORN_FORCE_AITER_KSPLIT", "0")
_CFG_PAD_CACHE = {}
_PROFILE_CALLS = 0
_PROFILE_MOE_MS = 0.0

if _FORCE_AITER_USE_NT in {"0", "1"}:
    os.environ["AITER_USE_NT"] = _FORCE_AITER_USE_NT
if _FORCE_AITER_KSPLIT in {"1", "2", "3", "4"}:
    os.environ["AITER_KSPLIT"] = _FORCE_AITER_KSPLIT


def _get_pads(config):
    key = (
        config["d_hidden"],
        config["d_hidden_pad"],
        config["d_expert"],
        config["d_expert_pad"],
    )
    cached = _CFG_PAD_CACHE.get(key)
    if cached is not None:
        return cached
    pads = (
        config["d_hidden_pad"] - config["d_hidden"],
        config["d_expert_pad"] - config["d_expert"],
    )
    _CFG_PAD_CACHE[key] = pads
    return pads


def _select_ksplit(config, token_count):
    d_expert = config.get("d_expert")
    if d_expert == 512 and token_count <= 128:
        return 2
    return 1


def custom_kernel(data: input_t) -> output_t:
    """
    Submission template for DeepSeek-R1 MXFP4 MoE kernel.

    Input data tuple:
        hidden_states:                [M, d_hidden]                           bf16
        gate_up_weight:               [E, 2*d_expert_pad, d_hidden_pad//2]    fp4x2  (raw)
        down_weight:                  [E, d_hidden_pad, d_expert_pad//2]      fp4x2  (raw)
        gate_up_weight_scale:         [E, 2*d_expert_pad, scale_K]            e8m0   (raw)
        down_weight_scale:            [E, d_hidden_pad, scale_K]              e8m0   (raw)
        gate_up_weight_shuffled:      [E, 2*d_expert_pad, d_hidden_pad//2]    fp4x2  (shuffled)
        down_weight_shuffled:         [E, d_hidden_pad, d_expert_pad//2]      fp4x2  (shuffled)
        gate_up_weight_scale_shuffled:[padded, flat]                          e8m0   (shuffled)
        down_weight_scale_shuffled:   [padded, flat]                          e8m0   (shuffled)
        topk_weights:                 [M, total_top_k]                        float32
        topk_ids:                     [M, total_top_k]                        int32
        config:                       dict

    Returns:
        output: [M, d_hidden] bf16
    """
    (
        hidden_states,
        gate_up_weight,
        down_weight,
        gate_up_weight_scale,
        down_weight_scale,
        gate_up_weight_shuffled,
        down_weight_shuffled,
        gate_up_weight_scale_shuffled,
        down_weight_scale_shuffled,
        topk_weights,
        topk_ids,
        config,
    ) = data

    global _PROFILE_CALLS, _PROFILE_MOE_MS
    hidden_pad, intermediate_pad = _get_pads(config)
    if _FORCE_AITER_KSPLIT not in {"1", "2", "3", "4"}:
        os.environ["AITER_KSPLIT"] = str(_select_ksplit(config, hidden_states.shape[0]))
    if _PROFILE_SPLIT:
        t0 = time.perf_counter()

    output = fused_moe(
        hidden_states,
        gate_up_weight_shuffled,
        down_weight_shuffled,
        topk_weights,
        topk_ids,
        expert_mask=None,
        activation=ActivationType.Silu,
        quant_type=QuantType.per_1x32,
        doweight_stage1=_USE_DOWEIGHT_STAGE1,
        w1_scale=gate_up_weight_scale_shuffled,
        w2_scale=down_weight_scale_shuffled,
        a1_scale=None,
        a2_scale=None,
        hidden_pad=hidden_pad,
        intermediate_pad=intermediate_pad,
    )
    if _PROFILE_SPLIT:
        if output.is_cuda:
            import torch

            torch.cuda.synchronize(output.device)
        t1 = time.perf_counter()
        _PROFILE_CALLS += 1
        _PROFILE_MOE_MS += (t1 - t0) * 1000.0
        if _PROFILE_CALLS % _PROFILE_EVERY == 0:
            denom = float(_PROFILE_CALLS)
            print(f"[profile] calls={_PROFILE_CALLS} avg_moe_ms={_PROFILE_MOE_MS / denom:.3f}")

    return output