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()