playground/Abbie-b200/benchmarking/bench_layer.py

import argparse

import torch
import torch.distributed as dist
from rich.console import Console
from rich.table import Table
from tqdm import tqdm
from transformers.models.qwen3_moe.modeling_qwen3_moe import Qwen3MoeRotaryEmbedding

from abbie.device_mesh_manager import DMM, init_distributed_env
from abbie.gargantua.config import GenericTransformerConfig
from abbie.gargantua.functional import GargantuaLayerFunc
from abbie.gargantua.layer import GenericTransformerLayer
from abbie.gargantua.overlapper import get_overlapper
from abbie.utils.deterministic_utils import set_deterministic
from abbie.utils.flash_attn_utils import gather_cu_seqlens_from_position_ids
from dualpipe.module.config import GargantuaConfig


MODEL_TYPE_TO_CONFIG_KWARGS = {
    "qwen2_7b": {
        "num_hidden_layers": 28,
        "hidden_size": 3584,
        "num_attention_heads": 28,
        "num_key_value_heads": 4,
        "use_qkv_bias": False,
        "use_o_bias": False,
        "use_qk_norm": False,
        "intermediate_size": 18944,
        "use_mlp_gate_up_bias": False,
        "use_mlp_down_bias": False,
    },
    "qwen3_4b": {
        "num_hidden_layers": 36,
        "hidden_size": 2560,
        "head_size": 128,
        "num_attention_heads": 32,
        "num_key_value_heads": 8,
        "use_qkv_bias": False,
        "use_o_bias": False,
        "use_qk_norm": True,
        "intermediate_size": 9728,
        "use_mlp_gate_up_bias": False,
        "use_mlp_down_bias": False,
    },
    "qwen3_8b": {
        "num_hidden_layers": 36,
        "hidden_size": 4096,
        "head_size": 128,
        "num_attention_heads": 32,
        "num_key_value_heads": 8,
        "use_qkv_bias": False,
        "use_o_bias": False,
        "use_qk_norm": True,
        "intermediate_size": 12288,
        "use_mlp_gate_up_bias": False,
        "use_mlp_down_bias": False,
    },
    "qwen3_moe_30b": {
        "num_hidden_layers": 48,
        "hidden_size": 2048,
        "head_size": 128,
        "num_attention_heads": 32,
        "num_key_value_heads": 4,
        "use_qkv_bias": False,
        "use_o_bias": False,
        "use_qk_norm": True,
        "num_experts_per_tok": 8,
        "num_routed_experts": 128,
        "moe_intermediate_size": 768,
    },
    "qwen3_moe_235b": {
        "num_hidden_layers": 94,
        "hidden_size": 4096,
        "head_size": 128,
        "num_attention_heads": 64,
        "num_key_value_heads": 4,
        "use_qkv_bias": False,
        "use_o_bias": False,
        "use_qk_norm": True,
        "num_experts_per_tok": 8,
        "num_routed_experts": 128,
        "moe_intermediate_size": 1536,
    },
    # We don't have sink attention or expert bias yet
    "gpt_oss_20b": {
        "num_hidden_layers": 24,
        "hidden_size": 2880,
        "head_size": 64,
        "num_attention_heads": 64,
        "num_key_value_heads": 8,
        "use_qkv_bias": False,
        "use_o_bias": False,
        "use_qk_norm": False,
        "num_experts_per_tok": 4,
        "num_routed_experts": 32,
        "moe_intermediate_size": 2880,
    },
    # We don't have sink attention or expert bias yet
    "gpt_oss_120b": {
        "num_hidden_layers": 36,
        "hidden_size": 2880,
        "head_size": 64,
        "num_attention_heads": 64,
        "num_key_value_heads": 8,
        "use_qkv_bias": False,
        "use_o_bias": False,
        "use_qk_norm": False,
        "num_experts_per_tok": 4,
        "num_routed_experts": 128,
        "moe_intermediate_size": 2880,
    },
    # We don't have MLA or shared experts yet
    "deepseek_v3": {
        "num_hidden_layers": 61,
        "hidden_size": 7168,
        "head_size": 128,
        "num_attention_heads": 128,
        "num_key_value_heads": 128,
        "use_qkv_bias": False,
        "use_o_bias": False,
        "use_qk_norm": True,
        "num_experts_per_tok": 9,
        "num_routed_experts": 256,
        "moe_intermediate_size": 2048,
    },
}


def get_gg_config(model_type: str, **extra_kwargs) -> GenericTransformerConfig:
    kwargs = dict(MODEL_TYPE_TO_CONFIG_KWARGS[model_type])
    kwargs.update(extra_kwargs)

    return GenericTransformerConfig(
        dp_group=DMM.dp_group,
        pp_group=DMM.pp_group,
        ep_group=DMM.ep_group,
        norm_topk_prob=True,
        use_moe_gate_up_bias=False,
        use_moe_down_bias=False,
        dtype=torch.bfloat16,
        rope_theta=1e6,
        rope_scaling={"type": "default"},
        aux_loss_coef=None,
        z_loss_coef=None,
        **kwargs,
    )


def make_gg_layer(config: GenericTransformerConfig):
    if config.token_dispatch_method == "deep-ep":
        from abbie.ops.deep_ep import setup_deep_ep_buffer

        setup_deep_ep_buffer(
            group=DMM.ep_group,
            hidden_bytes=config.hidden_size * 2,
            num_sms=20,
        )

    layer = GenericTransformerLayer(config, layer_idx=0)
    layer.train().cuda()

    for param in layer.parameters():
        param.data.normal_(0, std=1e-3)

    return layer


def make_dummy_inputs(
    config: GenericTransformerConfig,
    num_tokens: int = 4096,
    max_seqlen: int = 4096,
):
    input_tensor = torch.randn(
        num_tokens,
        config.hidden_size,
        dtype=torch.bfloat16,
    ).cuda()

    position_ids = []
    while len(position_ids) < num_tokens:
        position_ids.extend(range(max_seqlen))
    position_ids = position_ids[:num_tokens]
    position_ids = torch.tensor(position_ids, dtype=torch.long, device="cuda")

    rotary_emb = Qwen3MoeRotaryEmbedding(config, device="cuda")
    position_embeddings = rotary_emb(input_tensor[None], position_ids[None])
    cos, sin = position_embeddings[0][0], position_embeddings[1][0]
    cu_seqlens, max_seqlen = gather_cu_seqlens_from_position_ids(position_ids)

    d_output_tensor = torch.randn_like(input_tensor)
    input_tensor.requires_grad_(True)

    return {
        "input_tensor": input_tensor,
        "d_output_tensor": d_output_tensor,
        "cos": cos,
        "sin": sin,
        "cu_seqlens": cu_seqlens,
        "max_seqlen": max_seqlen,
    }


def calc_fwd_tflop(config: GargantuaConfig, seqlens: torch.Tensor):
    n_attn_params = (config.num_attention_heads + config.num_key_value_heads) * 2
    n_attn_params *= config.hidden_size * config.head_size

    if config.num_experts_per_tok > 0:
        n_expert_params = config.num_experts_per_tok * config.hidden_size * config.moe_intermediate_size * 3
        n_act_params = n_attn_params + n_expert_params
    else:
        n_dense_params = config.hidden_size * config.intermediate_size * 3
        n_act_params = n_attn_params + n_dense_params

    attn_tflop = (seqlens**2).sum().item() * config.hidden_size * 4 / 1e12
    fwd_tflop = n_act_params * seqlens.sum().item() * 2 / 1e12
    fwd_tflop += attn_tflop

    return fwd_tflop


def bench_layer(
    model_type: str,
    num_tokens: int = 4096,
    max_seqlen: int = 4096,
    num_layers: int = 4,
    warmup: int = 3,
    rep: int = 20,
    **extra_kwargs,
):
    config = get_gg_config(model_type, **extra_kwargs)
    DMM.print_rank0(config)

    layer = make_gg_layer(config)
    overlapper = get_overlapper()

    dummy_inputs = make_dummy_inputs(
        config,
        num_tokens=num_tokens,
        max_seqlen=max_seqlen,
    )

    event0 = torch.cuda.Event(enable_timing=True)
    event1 = torch.cuda.Event(enable_timing=True)
    event2 = torch.cuda.Event(enable_timing=True)
    event3 = torch.cuda.Event(enable_timing=True)

    def run_once(return_ctx_size: bool = False):
        event0.record()

        # Forward
        x0 = dummy_inputs["input_tensor"]
        for _ in range(num_layers):
            ctx0, x0 = GargantuaLayerFunc.apply_module(
                layer=layer,
                x=x0,
                cos=dummy_inputs["cos"],
                sin=dummy_inputs["sin"],
                cu_seqlens=dummy_inputs["cu_seqlens"],
                max_seqlen=dummy_inputs["max_seqlen"],
                global_num_tokens=num_tokens,
            )
        torch.cuda.synchronize()
        event1.record()

        ctx_size = None
        if return_ctx_size:
            ctx_size = ctx0.calc_tensors_size()

        # Overlap
        overlapper.on()
        x1 = dummy_inputs["input_tensor"]
        for _ in range(num_layers):
            ctx1, x1 = GargantuaLayerFunc.apply_module(
                layer=layer,
                x=x1,
                cos=dummy_inputs["cos"],
                sin=dummy_inputs["sin"],
                cu_seqlens=dummy_inputs["cu_seqlens"],
                max_seqlen=dummy_inputs["max_seqlen"],
                global_num_tokens=num_tokens,
            )
        torch.autograd.backward(x0, dummy_inputs["d_output_tensor"])
        overlapper.off()
        torch.cuda.synchronize()
        event2.record()

        torch.autograd.backward(x1, dummy_inputs["d_output_tensor"])
        event3.record()

        torch.cuda.synchronize()

        return {
            "fwd_time_ms": event0.elapsed_time(event1),
            "ovl_time_ms": event1.elapsed_time(event2),
            "bwd_time_ms": event2.elapsed_time(event3),
            "ctx_size": ctx_size,
        }

    DMM.print_rank0("Warming up")
    for _ in range(warmup):
        res = run_once(return_ctx_size=True)
    ctx_size = res["ctx_size"]
    DMM.print_rank0(f"ctx_size: {ctx_size / 1e9:.5f} GB")

    torch.cuda.synchronize()

    fwd_time_ms = ovl_time_ms = bwd_time_ms = 0
    for _ in tqdm(range(rep), disable=not DMM.is_global_rank0):
        timings = run_once()
        fwd_time_ms += timings["fwd_time_ms"] / rep
        ovl_time_ms += timings["ovl_time_ms"] / rep
        bwd_time_ms += timings["bwd_time_ms"] / rep

    if DMM.is_global_rank0:
        table = Table(
            title="Gargantua Layer Benchmark Results",
            show_header=True,
            header_style="bold magenta",
        )
        table.add_column("Operation", style="cyan")
        table.add_column("Time", style="blue")
        table.add_column("TFLOPS", style="green")
        table.add_column("MFU", style="yellow")

        fwd_tflop = calc_fwd_tflop(config, seqlens=dummy_inputs["cu_seqlens"].diff())
        fwd_tflop *= num_layers

        fwd_tflops = fwd_tflop / fwd_time_ms * 1e3
        ovl_tflops = fwd_tflop * 3 / ovl_time_ms * 1e3
        bwd_tflops = fwd_tflop * 2 / bwd_time_ms * 1e3
        gpu_tflops = 989.5

        table.add_row(
            "Forward",
            f"{fwd_time_ms:.1f}",
            f"{fwd_tflops:.1f}",
            f"{fwd_tflops / gpu_tflops:.3f}",
        )
        table.add_row(
            "Backward",
            f"{bwd_time_ms:.1f}",
            f"{bwd_tflops:.1f}",
            f"{bwd_tflops / gpu_tflops:.3f}",
        )
        table.add_row(
            "Overlap",
            f"{ovl_time_ms:.1f}",
            f"{ovl_tflops:.1f}",
            f"{ovl_tflops / gpu_tflops:.3f}",
        )

        console = Console()
        console.print(table)

        token_per_sec = num_tokens / ovl_time_ms * 1e3
        token_per_sec *= num_layers / config.num_hidden_layers
        console.print(f"Overlap token/s: {token_per_sec:.1f}")

    with torch.profiler.profile(
        activities=[
            torch.profiler.ProfilerActivity.CPU,
            torch.profiler.ProfilerActivity.CUDA,
        ],
        # with_stack=True,
    ) as profiler:
        run_once()
    if DMM.is_global_rank0:
        profiler.export_chrome_trace("trace.json")


def main():
    parser = argparse.ArgumentParser()

    parser.add_argument("--model_type", default="qwen3_moe_30b", choices=MODEL_TYPE_TO_CONFIG_KWARGS.keys())
    parser.add_argument("--ep", type=int, default=1)
    parser.add_argument("--num_tokens", type=int, default=4096)
    parser.add_argument("--max_seqlen", type=int, default=4096)

    parser.add_argument("--num_layers", type=int, default=4)
    parser.add_argument("--warmup", type=int, default=3)
    parser.add_argument("--rep", type=int, default=20)

    parser.add_argument("--recompute_norm", action="store_true")
    parser.add_argument("--recompute_attn_up_proj", action="store_true")
    parser.add_argument("--recompute_attn", action="store_true")
    parser.add_argument("--recompute_attn_down_proj", action="store_true")
    parser.add_argument("--recompute_mlp", action="store_true")
    parser.add_argument("--recompute_mlp_act", action="store_true")
    parser.add_argument("--recompute_dispatch", action="store_true")

    parser.add_argument("--token_dispatch_method", type=str, default="deep-ep")

    parser.add_argument("--deterministic_fwd", action="store_true")

    args = parser.parse_args()

    init_distributed_env(ep_size=args.ep)

    if args.deterministic_fwd:
        set_deterministic()

    try:
        bench_layer(
            model_type=args.model_type,
            num_tokens=args.num_tokens,
            max_seqlen=args.max_seqlen,
            num_layers=args.num_layers,
            warmup=args.warmup,
            rep=args.rep,
            recompute_norm=args.recompute_norm,
            recompute_attn_up_proj=args.recompute_attn_up_proj,
            recompute_attn=args.recompute_attn,
            recompute_attn_down_proj=args.recompute_attn_down_proj,
            recompute_mlp=args.recompute_mlp,
            recompute_mlp_act=args.recompute_mlp_act,
            recompute_dispatch=args.recompute_dispatch,
            token_dispatch_method=args.token_dispatch_method,
        )
    finally:
        dist.destroy_process_group()


if __name__ == "__main__":
    main()