import argparse
import time

import datasets
import torch
from transformers import AutoModelForCausalLM, AutoTokenizer
from transformers.generation import GenerationConfig


MODEL_ID = "Qwen/Qwen3-4B-Instruct-2507"


def main():
    parser = argparse.ArgumentParser()
    parser.add_argument("--samples", type=int, default=100, help="Number of prompts to run")
    parser.add_argument("--batch-size", "-bs", type=int, default=32, help="Static batch size")
    parser.add_argument("--max-new-tokens", type=int, default=512, help="Max new tokens per request")
    parser.add_argument("--warmup", type=int, default=1, help="Warmup batches (excluded from timing)")
    args = parser.parse_args()

    # Load model (static batching, SDPA attention), BF16 for speed/memory
    model = AutoModelForCausalLM.from_pretrained(
        MODEL_ID,
        attn_implementation="sdpa",
        torch_dtype=torch.bfloat16,
    ).cuda().eval()

    # Tokenizer: left padding is typically better for batched causal LMs
    tokenizer = AutoTokenizer.from_pretrained(MODEL_ID, padding_side="left")
    if tokenizer.pad_token_id is None:
        tokenizer.pad_token = tokenizer.eos_token

    # Dataset: GSM8K (socratic) questions only
    dataset = datasets.load_dataset("openai/gsm8k", "socratic", split="test")
    dataset = dataset.select(range(args.samples))

    # Tokenize up front (no padding yet; we’ll pad per-batch for efficiency)
    encoded = tokenizer(list(dataset["question"]), padding=False, truncation=False)
    inputs = [{"input_ids": ids, "attention_mask": attn}
              for ids, attn in zip(encoded["input_ids"], encoded["attention_mask"])]

    # Generation config
    gen_cfg = GenerationConfig(
        do_sample=False,
        max_new_tokens=args.max_new_tokens,
        eos_token_id=tokenizer.eos_token_id,
        pad_token_id=tokenizer.pad_token_id,
        use_cuda_graph=False,  # keep simple/portable
    )

    # Helper to create a padded batch on-device
    def make_batch(items):
        batch = tokenizer.pad(items, padding=True, return_tensors="pt")
        return {k: v.cuda(non_blocking=True) for k, v in batch.items()}

    # Optional warmup (excluded from timing)
    model_inputs = []
    if args.warmup > 0:
        warm = make_batch(inputs[: min(len(inputs), args.batch_size * args.warmup)])
        with torch.no_grad():
            _ = model.generate(**warm, generation_config=gen_cfg)

    # Timed generation over all batches
    token_count = 0
    bs = args.batch_size
    start = time.time()
    with torch.no_grad():
        for i in range(0, len(inputs), bs):
            batch_items = inputs[i : i + bs]
            batch = make_batch(batch_items)

            # Run generate()
            outputs = model.generate(**batch, generation_config=gen_cfg)

            # Count newly generated tokens per sequence
            # new_tokens = (#non-pad tokens after the original prompt length)
            pad_id = tokenizer.pad_token_id
            input_lens = batch["attention_mask"].sum(dim=1).tolist()
            for row, in_len in zip(outputs, input_lens):
                seq = row.tolist()
                gen_part = seq[int(in_len):]
                token_count += sum(1 for t in gen_part if t != pad_id)

    end = time.time()
    elapsed = end - start
    tps = token_count / elapsed if elapsed > 0 else 0.0

    print("-" * 20)
    print("--- Finished Static Batching Benchmark ---\n")
    print(f"Model: {MODEL_ID}")
    print(f"Attention: sdpa | Batch size: {args.batch_size} | Samples: {args.samples} | Max new tokens: {args.max_new_tokens}")
    print(f"Generation time (no warmup): {elapsed:.2f} s for {token_count} generated tokens -> {tps:.2f} tok/s")


if __name__ == "__main__":
    main()

#Attention: sdpa | Batch size: 32 | Samples: 100 | Max new tokens: 512
# Generation time (no warmup): 153.98 s for 53427 generated tokens -> 346.98 tok/s