diff --git a/.gitignore b/.gitignore index b8e528e..f4641ef 100644 --- a/.gitignore +++ b/.gitignore @@ -8,6 +8,7 @@ results.csv out/ data/ outputs/ +experiments/ .env .venv/ bench_*/ diff --git a/HARNESS.md b/HARNESS.md index 3df756c..5342421 100644 --- a/HARNESS.md +++ b/HARNESS.md @@ -52,6 +52,18 @@ The config file is the interface for setting instance, vLLM, and benchmark args. **Note**: Always include `results-csv: /tmp/results.csv` in the benchmark config so results are saved and fetched from the remote instance. +To collect server metrics during the benchmark, add BatchBench's metrics flags +under `benchmark`. The harness passes them through to the Rust CLI and copies +the resulting directory back to `results///metrics/`. + +```yaml +benchmark: + results-csv: /tmp/results.csv + metrics-output-dir: /tmp/batchbench-metrics + metrics-endpoint: /metrics + metrics-interval-ms: 1000 +``` + ## Architecture The harness accepts either a single config file or a directory of configs (all `*.yaml` files in that directory). diff --git a/README.md b/README.md index 54d0b10..7f2359e 100644 --- a/README.md +++ b/README.md @@ -39,6 +39,7 @@ config = { ) ], "dry_run": True, + "enable_json_decoding": True, } report = batchbench.run_benchmark(config) @@ -75,9 +76,60 @@ batchbench \ --output-vary 0 ``` +To benchmark a JSONL dataset instead of generated prompts, pass `--dataset-jsonl`. +Each non-empty line may be one of: + +- `{"text": "prompt text", "input_tokens": 123}` to build a chat completion request. +- `{"body": {...}, "input_tokens": 123}` to send `body` as the request payload. +- A full request body object, such as `{"model": "...", "messages": [...]}`. + +The CLI `--model` value is injected into every request body at runtime. This means +dataset rows can omit `model`, and any `model` present in the JSONL is overridden +by the value passed to `batchbench --model`. + +```bash +batchbench \ + --dataset-jsonl dataset.jsonl \ + --model gpt-4o-mini \ + --users 8 \ + --requests-per-user 2 +``` + +The dataset must contain at least `users * requests-per-user` request entries. +If `--users` is omitted for a dataset run, BatchBench uses as many complete +request rounds as the dataset can provide for the selected `--requests-per-user`. + Use `--sglang` to apply output token constraints via `min_new_tokens`/`max_new_tokens` instead of `min_tokens`/`max_tokens`. +Use `--enable-json-decoding` to request JSON constrained decoding. With `--sglang`, +BatchBench adds `response_format: {"type": "json_object"}`. Without `--sglang`, it +adds vLLM `structured_outputs.json_object: true`, equivalent to passing that value +through the OpenAI SDK's `extra_body`. + +Use `--qwen35-disable-thinking` to add +`chat_template_kwargs: {"enable_thinking": false}` to each request. + +Use `--metrics-output-dir` to scrape Prometheus metrics from the benchmarked +server while the benchmark runs. BatchBench defaults to `--metrics-endpoint +/metrics`, resolved against `--host`; pass a full URL or another path such as +`/v1/metrics` if your deployment exposes metrics elsewhere. + +```bash +batchbench \ + --dataset-jsonl dataset.jsonl \ + --host http://127.0.0.1:3000 \ + --model Qwen/Qwen3.6-27B \ + --users 8 \ + --requests-per-user 2 \ + --metrics-output-dir runs/qwen/metrics +``` + +Metrics artifacts include raw Prometheus scrape payloads (`raw.promjsonl`), +parsed long-form samples (`samples.csv`), run metadata (`metadata.json`), and a +compact derived summary (`summary.json`). SGLang must be launched with +`--enable-metrics`; vLLM and SGLang both commonly expose metrics at `/metrics`. + Press `Ctrl+C` during a run to cancel active requests and print a partial summary. ## Rust CLI diff --git a/bin/batchbench b/bin/batchbench index ad6e309..af8bfd4 100755 Binary files a/bin/batchbench and b/bin/batchbench differ diff --git a/configs/k8s/piccolo-k8s-sweep-example-manifest.yaml b/configs/k8s/piccolo-k8s-sweep-example-manifest.yaml new file mode 100644 index 0000000..f973393 --- /dev/null +++ b/configs/k8s/piccolo-k8s-sweep-example-manifest.yaml @@ -0,0 +1,6383 @@ +--- +apiVersion: v1 +kind: ConfigMap +metadata: + name: piccolo-k8s-sweep-example-config + namespace: specdec + labels: + app.kubernetes.io/name: batchbench-sweep + app.kubernetes.io/component: benchmark + batchbench.doubleword.ai/sweep-name: piccolo-k8s-sweep-example +data: + combinations.json: |- + [ + { + "index": 0, + "variant_name": "baseline", + "variant_extra_args": [ + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_16k.jsonl", + "dataset_slug": "throughput_16k", + "run_slug": "000-baseline-throughput_16k" + }, + { + "index": 1, + "variant_name": "baseline", + "variant_extra_args": [ + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_1k.jsonl", + "dataset_slug": "throughput_1k", + "run_slug": "001-baseline-throughput_1k" + }, + { + "index": 2, + "variant_name": "baseline", + "variant_extra_args": [ + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_2k.jsonl", + "dataset_slug": "throughput_2k", + "run_slug": "002-baseline-throughput_2k" + }, + { + "index": 3, + "variant_name": "baseline", + "variant_extra_args": [ + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_32k.jsonl", + "dataset_slug": "throughput_32k", + "run_slug": "003-baseline-throughput_32k" + }, + { + "index": 4, + "variant_name": "baseline", + "variant_extra_args": [ + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_8k.jsonl", + "dataset_slug": "throughput_8k", + "run_slug": "004-baseline-throughput_8k" + }, + { + "index": 5, + "variant_name": "baseline", + "variant_extra_args": [ + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/json_mode_eval/jsonl/train.jsonl", + "dataset_slug": "train", + "run_slug": "005-baseline-train" + }, + { + "index": 6, + "variant_name": "mtp-s2-k1-d3", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "2", + "--speculative-eagle-topk", + "1", + "--speculative-num-draft-tokens", + "3", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_16k.jsonl", + "dataset_slug": "throughput_16k", + "run_slug": "006-mtp-s2-k1-d3-throughput_16k" + }, + { + "index": 7, + "variant_name": "mtp-s2-k1-d3", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "2", + "--speculative-eagle-topk", + "1", + "--speculative-num-draft-tokens", + "3", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_1k.jsonl", + "dataset_slug": "throughput_1k", + "run_slug": "007-mtp-s2-k1-d3-throughput_1k" + }, + { + "index": 8, + "variant_name": "mtp-s2-k1-d3", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "2", + "--speculative-eagle-topk", + "1", + "--speculative-num-draft-tokens", + "3", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_2k.jsonl", + "dataset_slug": "throughput_2k", + "run_slug": "008-mtp-s2-k1-d3-throughput_2k" + }, + { + "index": 9, + "variant_name": "mtp-s2-k1-d3", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "2", + "--speculative-eagle-topk", + "1", + "--speculative-num-draft-tokens", + "3", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_32k.jsonl", + "dataset_slug": "throughput_32k", + "run_slug": "009-mtp-s2-k1-d3-throughput_32k" + }, + { + "index": 10, + "variant_name": "mtp-s2-k1-d3", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "2", + "--speculative-eagle-topk", + "1", + "--speculative-num-draft-tokens", + "3", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_8k.jsonl", + "dataset_slug": "throughput_8k", + "run_slug": "010-mtp-s2-k1-d3-throughput_8k" + }, + { + "index": 11, + "variant_name": "mtp-s2-k1-d3", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "2", + "--speculative-eagle-topk", + "1", + "--speculative-num-draft-tokens", + "3", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/json_mode_eval/jsonl/train.jsonl", + "dataset_slug": "train", + "run_slug": "011-mtp-s2-k1-d3-train" + }, + { + "index": 12, + "variant_name": "mtp-s2-k1-d4", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "2", + "--speculative-eagle-topk", + "1", + "--speculative-num-draft-tokens", + "4", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_16k.jsonl", + "dataset_slug": "throughput_16k", + "run_slug": "012-mtp-s2-k1-d4-throughput_16k" + }, + { + "index": 13, + "variant_name": "mtp-s2-k1-d4", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "2", + "--speculative-eagle-topk", + "1", + "--speculative-num-draft-tokens", + "4", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_1k.jsonl", + "dataset_slug": "throughput_1k", + "run_slug": "013-mtp-s2-k1-d4-throughput_1k" + }, + { + "index": 14, + "variant_name": "mtp-s2-k1-d4", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "2", + "--speculative-eagle-topk", + "1", + "--speculative-num-draft-tokens", + "4", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_2k.jsonl", + "dataset_slug": "throughput_2k", + "run_slug": "014-mtp-s2-k1-d4-throughput_2k" + }, + { + "index": 15, + "variant_name": "mtp-s2-k1-d4", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "2", + "--speculative-eagle-topk", + "1", + "--speculative-num-draft-tokens", + "4", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_32k.jsonl", + "dataset_slug": "throughput_32k", + "run_slug": "015-mtp-s2-k1-d4-throughput_32k" + }, + { + "index": 16, + "variant_name": "mtp-s2-k1-d4", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "2", + "--speculative-eagle-topk", + "1", + "--speculative-num-draft-tokens", + "4", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_8k.jsonl", + "dataset_slug": "throughput_8k", + "run_slug": "016-mtp-s2-k1-d4-throughput_8k" + }, + { + "index": 17, + "variant_name": "mtp-s2-k1-d4", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "2", + "--speculative-eagle-topk", + "1", + "--speculative-num-draft-tokens", + "4", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/json_mode_eval/jsonl/train.jsonl", + "dataset_slug": "train", + "run_slug": "017-mtp-s2-k1-d4-train" + }, + { + "index": 18, + "variant_name": "mtp-s2-k1-d5", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "2", + "--speculative-eagle-topk", + "1", + "--speculative-num-draft-tokens", + "5", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_16k.jsonl", + "dataset_slug": "throughput_16k", + "run_slug": "018-mtp-s2-k1-d5-throughput_16k" + }, + { + "index": 19, + "variant_name": "mtp-s2-k1-d5", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "2", + "--speculative-eagle-topk", + "1", + "--speculative-num-draft-tokens", + "5", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_1k.jsonl", + "dataset_slug": "throughput_1k", + "run_slug": "019-mtp-s2-k1-d5-throughput_1k" + }, + { + "index": 20, + "variant_name": "mtp-s2-k1-d5", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "2", + "--speculative-eagle-topk", + "1", + "--speculative-num-draft-tokens", + "5", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_2k.jsonl", + "dataset_slug": "throughput_2k", + "run_slug": "020-mtp-s2-k1-d5-throughput_2k" + }, + { + "index": 21, + "variant_name": "mtp-s2-k1-d5", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "2", + "--speculative-eagle-topk", + "1", + "--speculative-num-draft-tokens", + "5", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_32k.jsonl", + "dataset_slug": "throughput_32k", + "run_slug": "021-mtp-s2-k1-d5-throughput_32k" + }, + { + "index": 22, + "variant_name": "mtp-s2-k1-d5", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "2", + "--speculative-eagle-topk", + "1", + "--speculative-num-draft-tokens", + "5", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_8k.jsonl", + "dataset_slug": "throughput_8k", + "run_slug": "022-mtp-s2-k1-d5-throughput_8k" + }, + { + "index": 23, + "variant_name": "mtp-s2-k1-d5", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "2", + "--speculative-eagle-topk", + "1", + "--speculative-num-draft-tokens", + "5", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/json_mode_eval/jsonl/train.jsonl", + "dataset_slug": "train", + "run_slug": "023-mtp-s2-k1-d5-train" + }, + { + "index": 24, + "variant_name": "mtp-s2-k1-d6", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "2", + "--speculative-eagle-topk", + "1", + "--speculative-num-draft-tokens", + "6", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_16k.jsonl", + "dataset_slug": "throughput_16k", + "run_slug": "024-mtp-s2-k1-d6-throughput_16k" + }, + { + "index": 25, + "variant_name": "mtp-s2-k1-d6", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "2", + "--speculative-eagle-topk", + "1", + "--speculative-num-draft-tokens", + "6", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_1k.jsonl", + "dataset_slug": "throughput_1k", + "run_slug": "025-mtp-s2-k1-d6-throughput_1k" + }, + { + "index": 26, + "variant_name": "mtp-s2-k1-d6", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "2", + "--speculative-eagle-topk", + "1", + "--speculative-num-draft-tokens", + "6", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_2k.jsonl", + "dataset_slug": "throughput_2k", + "run_slug": "026-mtp-s2-k1-d6-throughput_2k" + }, + { + "index": 27, + "variant_name": "mtp-s2-k1-d6", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "2", + "--speculative-eagle-topk", + "1", + "--speculative-num-draft-tokens", + "6", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_32k.jsonl", + "dataset_slug": "throughput_32k", + "run_slug": "027-mtp-s2-k1-d6-throughput_32k" + }, + { + "index": 28, + "variant_name": "mtp-s2-k1-d6", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "2", + "--speculative-eagle-topk", + "1", + "--speculative-num-draft-tokens", + "6", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_8k.jsonl", + "dataset_slug": "throughput_8k", + "run_slug": "028-mtp-s2-k1-d6-throughput_8k" + }, + { + "index": 29, + "variant_name": "mtp-s2-k1-d6", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "2", + "--speculative-eagle-topk", + "1", + "--speculative-num-draft-tokens", + "6", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/json_mode_eval/jsonl/train.jsonl", + "dataset_slug": "train", + "run_slug": "029-mtp-s2-k1-d6-train" + }, + { + "index": 30, + "variant_name": "mtp-s2-k2-d3", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "2", + "--speculative-eagle-topk", + "2", + "--speculative-num-draft-tokens", + "3", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_16k.jsonl", + "dataset_slug": "throughput_16k", + "run_slug": "030-mtp-s2-k2-d3-throughput_16k" + }, + { + "index": 31, + "variant_name": "mtp-s2-k2-d3", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "2", + "--speculative-eagle-topk", + "2", + "--speculative-num-draft-tokens", + "3", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_1k.jsonl", + "dataset_slug": "throughput_1k", + "run_slug": "031-mtp-s2-k2-d3-throughput_1k" + }, + { + "index": 32, + "variant_name": "mtp-s2-k2-d3", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "2", + "--speculative-eagle-topk", + "2", + "--speculative-num-draft-tokens", + "3", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_2k.jsonl", + "dataset_slug": "throughput_2k", + "run_slug": "032-mtp-s2-k2-d3-throughput_2k" + }, + { + "index": 33, + "variant_name": "mtp-s2-k2-d3", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "2", + "--speculative-eagle-topk", + "2", + "--speculative-num-draft-tokens", + "3", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_32k.jsonl", + "dataset_slug": "throughput_32k", + "run_slug": "033-mtp-s2-k2-d3-throughput_32k" + }, + { + "index": 34, + "variant_name": "mtp-s2-k2-d3", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "2", + "--speculative-eagle-topk", + "2", + "--speculative-num-draft-tokens", + "3", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_8k.jsonl", + "dataset_slug": "throughput_8k", + "run_slug": "034-mtp-s2-k2-d3-throughput_8k" + }, + { + "index": 35, + "variant_name": "mtp-s2-k2-d3", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "2", + "--speculative-eagle-topk", + "2", + "--speculative-num-draft-tokens", + "3", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/json_mode_eval/jsonl/train.jsonl", + "dataset_slug": "train", + "run_slug": "035-mtp-s2-k2-d3-train" + }, + { + "index": 36, + "variant_name": "mtp-s2-k2-d4", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "2", + "--speculative-eagle-topk", + "2", + "--speculative-num-draft-tokens", + "4", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_16k.jsonl", + "dataset_slug": "throughput_16k", + "run_slug": "036-mtp-s2-k2-d4-throughput_16k" + }, + { + "index": 37, + "variant_name": "mtp-s2-k2-d4", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "2", + "--speculative-eagle-topk", + "2", + "--speculative-num-draft-tokens", + "4", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_1k.jsonl", + "dataset_slug": "throughput_1k", + "run_slug": "037-mtp-s2-k2-d4-throughput_1k" + }, + { + "index": 38, + "variant_name": "mtp-s2-k2-d4", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "2", + "--speculative-eagle-topk", + "2", + "--speculative-num-draft-tokens", + "4", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_2k.jsonl", + "dataset_slug": "throughput_2k", + "run_slug": "038-mtp-s2-k2-d4-throughput_2k" + }, + { + "index": 39, + "variant_name": "mtp-s2-k2-d4", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "2", + "--speculative-eagle-topk", + "2", + "--speculative-num-draft-tokens", + "4", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_32k.jsonl", + "dataset_slug": "throughput_32k", + "run_slug": "039-mtp-s2-k2-d4-throughput_32k" + }, + { + "index": 40, + "variant_name": "mtp-s2-k2-d4", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "2", + "--speculative-eagle-topk", + "2", + "--speculative-num-draft-tokens", + "4", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_8k.jsonl", + "dataset_slug": "throughput_8k", + "run_slug": "040-mtp-s2-k2-d4-throughput_8k" + }, + { + "index": 41, + "variant_name": "mtp-s2-k2-d4", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "2", + "--speculative-eagle-topk", + "2", + "--speculative-num-draft-tokens", + "4", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/json_mode_eval/jsonl/train.jsonl", + "dataset_slug": "train", + "run_slug": "041-mtp-s2-k2-d4-train" + }, + { + "index": 42, + "variant_name": "mtp-s2-k2-d5", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "2", + "--speculative-eagle-topk", + "2", + "--speculative-num-draft-tokens", + "5", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_16k.jsonl", + "dataset_slug": "throughput_16k", + "run_slug": "042-mtp-s2-k2-d5-throughput_16k" + }, + { + "index": 43, + "variant_name": "mtp-s2-k2-d5", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "2", + "--speculative-eagle-topk", + "2", + "--speculative-num-draft-tokens", + "5", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_1k.jsonl", + "dataset_slug": "throughput_1k", + "run_slug": "043-mtp-s2-k2-d5-throughput_1k" + }, + { + "index": 44, + "variant_name": "mtp-s2-k2-d5", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "2", + "--speculative-eagle-topk", + "2", + "--speculative-num-draft-tokens", + "5", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_2k.jsonl", + "dataset_slug": "throughput_2k", + "run_slug": "044-mtp-s2-k2-d5-throughput_2k" + }, + { + "index": 45, + "variant_name": "mtp-s2-k2-d5", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "2", + "--speculative-eagle-topk", + "2", + "--speculative-num-draft-tokens", + "5", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_32k.jsonl", + "dataset_slug": "throughput_32k", + "run_slug": "045-mtp-s2-k2-d5-throughput_32k" + }, + { + "index": 46, + "variant_name": "mtp-s2-k2-d5", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "2", + "--speculative-eagle-topk", + "2", + "--speculative-num-draft-tokens", + "5", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_8k.jsonl", + "dataset_slug": "throughput_8k", + "run_slug": "046-mtp-s2-k2-d5-throughput_8k" + }, + { + "index": 47, + "variant_name": "mtp-s2-k2-d5", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "2", + "--speculative-eagle-topk", + "2", + "--speculative-num-draft-tokens", + "5", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/json_mode_eval/jsonl/train.jsonl", + "dataset_slug": "train", + "run_slug": "047-mtp-s2-k2-d5-train" + }, + { + "index": 48, + "variant_name": "mtp-s2-k2-d6", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "2", + "--speculative-eagle-topk", + "2", + "--speculative-num-draft-tokens", + "6", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_16k.jsonl", + "dataset_slug": "throughput_16k", + "run_slug": "048-mtp-s2-k2-d6-throughput_16k" + }, + { + "index": 49, + "variant_name": "mtp-s2-k2-d6", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "2", + "--speculative-eagle-topk", + "2", + "--speculative-num-draft-tokens", + "6", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_1k.jsonl", + "dataset_slug": "throughput_1k", + "run_slug": "049-mtp-s2-k2-d6-throughput_1k" + }, + { + "index": 50, + "variant_name": "mtp-s2-k2-d6", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "2", + "--speculative-eagle-topk", + "2", + "--speculative-num-draft-tokens", + "6", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_2k.jsonl", + "dataset_slug": "throughput_2k", + "run_slug": "050-mtp-s2-k2-d6-throughput_2k" + }, + { + "index": 51, + "variant_name": "mtp-s2-k2-d6", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "2", + "--speculative-eagle-topk", + "2", + "--speculative-num-draft-tokens", + "6", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_32k.jsonl", + "dataset_slug": "throughput_32k", + "run_slug": "051-mtp-s2-k2-d6-throughput_32k" + }, + { + "index": 52, + "variant_name": "mtp-s2-k2-d6", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "2", + "--speculative-eagle-topk", + "2", + "--speculative-num-draft-tokens", + "6", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_8k.jsonl", + "dataset_slug": "throughput_8k", + "run_slug": "052-mtp-s2-k2-d6-throughput_8k" + }, + { + "index": 53, + "variant_name": "mtp-s2-k2-d6", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "2", + "--speculative-eagle-topk", + "2", + "--speculative-num-draft-tokens", + "6", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/json_mode_eval/jsonl/train.jsonl", + "dataset_slug": "train", + "run_slug": "053-mtp-s2-k2-d6-train" + }, + { + "index": 54, + "variant_name": "mtp-s2-k3-d3", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "2", + "--speculative-eagle-topk", + "3", + "--speculative-num-draft-tokens", + "3", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_16k.jsonl", + "dataset_slug": "throughput_16k", + "run_slug": "054-mtp-s2-k3-d3-throughput_16k" + }, + { + "index": 55, + "variant_name": "mtp-s2-k3-d3", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "2", + "--speculative-eagle-topk", + "3", + "--speculative-num-draft-tokens", + "3", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_1k.jsonl", + "dataset_slug": "throughput_1k", + "run_slug": "055-mtp-s2-k3-d3-throughput_1k" + }, + { + "index": 56, + "variant_name": "mtp-s2-k3-d3", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "2", + "--speculative-eagle-topk", + "3", + "--speculative-num-draft-tokens", + "3", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_2k.jsonl", + "dataset_slug": "throughput_2k", + "run_slug": "056-mtp-s2-k3-d3-throughput_2k" + }, + { + "index": 57, + "variant_name": "mtp-s2-k3-d3", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "2", + "--speculative-eagle-topk", + "3", + "--speculative-num-draft-tokens", + "3", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_32k.jsonl", + "dataset_slug": "throughput_32k", + "run_slug": "057-mtp-s2-k3-d3-throughput_32k" + }, + { + "index": 58, + "variant_name": "mtp-s2-k3-d3", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "2", + "--speculative-eagle-topk", + "3", + "--speculative-num-draft-tokens", + "3", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_8k.jsonl", + "dataset_slug": "throughput_8k", + "run_slug": "058-mtp-s2-k3-d3-throughput_8k" + }, + { + "index": 59, + "variant_name": "mtp-s2-k3-d3", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "2", + "--speculative-eagle-topk", + "3", + "--speculative-num-draft-tokens", + "3", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/json_mode_eval/jsonl/train.jsonl", + "dataset_slug": "train", + "run_slug": "059-mtp-s2-k3-d3-train" + }, + { + "index": 60, + "variant_name": "mtp-s2-k3-d4", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "2", + "--speculative-eagle-topk", + "3", + "--speculative-num-draft-tokens", + "4", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_16k.jsonl", + "dataset_slug": "throughput_16k", + "run_slug": "060-mtp-s2-k3-d4-throughput_16k" + }, + { + "index": 61, + "variant_name": "mtp-s2-k3-d4", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "2", + "--speculative-eagle-topk", + "3", + "--speculative-num-draft-tokens", + "4", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_1k.jsonl", + "dataset_slug": "throughput_1k", + "run_slug": "061-mtp-s2-k3-d4-throughput_1k" + }, + { + "index": 62, + "variant_name": "mtp-s2-k3-d4", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "2", + "--speculative-eagle-topk", + "3", + "--speculative-num-draft-tokens", + "4", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_2k.jsonl", + "dataset_slug": "throughput_2k", + "run_slug": "062-mtp-s2-k3-d4-throughput_2k" + }, + { + "index": 63, + "variant_name": "mtp-s2-k3-d4", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "2", + "--speculative-eagle-topk", + "3", + "--speculative-num-draft-tokens", + "4", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_32k.jsonl", + "dataset_slug": "throughput_32k", + "run_slug": "063-mtp-s2-k3-d4-throughput_32k" + }, + { + "index": 64, + "variant_name": "mtp-s2-k3-d4", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "2", + "--speculative-eagle-topk", + "3", + "--speculative-num-draft-tokens", + "4", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_8k.jsonl", + "dataset_slug": "throughput_8k", + "run_slug": "064-mtp-s2-k3-d4-throughput_8k" + }, + { + "index": 65, + "variant_name": "mtp-s2-k3-d4", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "2", + "--speculative-eagle-topk", + "3", + "--speculative-num-draft-tokens", + "4", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/json_mode_eval/jsonl/train.jsonl", + "dataset_slug": "train", + "run_slug": "065-mtp-s2-k3-d4-train" + }, + { + "index": 66, + "variant_name": "mtp-s2-k3-d5", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "2", + "--speculative-eagle-topk", + "3", + "--speculative-num-draft-tokens", + "5", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_16k.jsonl", + "dataset_slug": "throughput_16k", + "run_slug": "066-mtp-s2-k3-d5-throughput_16k" + }, + { + "index": 67, + "variant_name": "mtp-s2-k3-d5", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "2", + "--speculative-eagle-topk", + "3", + "--speculative-num-draft-tokens", + "5", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_1k.jsonl", + "dataset_slug": "throughput_1k", + "run_slug": "067-mtp-s2-k3-d5-throughput_1k" + }, + { + "index": 68, + "variant_name": "mtp-s2-k3-d5", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "2", + "--speculative-eagle-topk", + "3", + "--speculative-num-draft-tokens", + "5", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_2k.jsonl", + "dataset_slug": "throughput_2k", + "run_slug": "068-mtp-s2-k3-d5-throughput_2k" + }, + { + "index": 69, + "variant_name": "mtp-s2-k3-d5", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "2", + "--speculative-eagle-topk", + "3", + "--speculative-num-draft-tokens", + "5", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_32k.jsonl", + "dataset_slug": "throughput_32k", + "run_slug": "069-mtp-s2-k3-d5-throughput_32k" + }, + { + "index": 70, + "variant_name": "mtp-s2-k3-d5", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "2", + "--speculative-eagle-topk", + "3", + "--speculative-num-draft-tokens", + "5", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_8k.jsonl", + "dataset_slug": "throughput_8k", + "run_slug": "070-mtp-s2-k3-d5-throughput_8k" + }, + { + "index": 71, + "variant_name": "mtp-s2-k3-d5", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "2", + "--speculative-eagle-topk", + "3", + "--speculative-num-draft-tokens", + "5", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/json_mode_eval/jsonl/train.jsonl", + "dataset_slug": "train", + "run_slug": "071-mtp-s2-k3-d5-train" + }, + { + "index": 72, + "variant_name": "mtp-s2-k3-d6", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "2", + "--speculative-eagle-topk", + "3", + "--speculative-num-draft-tokens", + "6", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_16k.jsonl", + "dataset_slug": "throughput_16k", + "run_slug": "072-mtp-s2-k3-d6-throughput_16k" + }, + { + "index": 73, + "variant_name": "mtp-s2-k3-d6", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "2", + "--speculative-eagle-topk", + "3", + "--speculative-num-draft-tokens", + "6", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_1k.jsonl", + "dataset_slug": "throughput_1k", + "run_slug": "073-mtp-s2-k3-d6-throughput_1k" + }, + { + "index": 74, + "variant_name": "mtp-s2-k3-d6", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "2", + "--speculative-eagle-topk", + "3", + "--speculative-num-draft-tokens", + "6", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_2k.jsonl", + "dataset_slug": "throughput_2k", + "run_slug": "074-mtp-s2-k3-d6-throughput_2k" + }, + { + "index": 75, + "variant_name": "mtp-s2-k3-d6", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "2", + "--speculative-eagle-topk", + "3", + "--speculative-num-draft-tokens", + "6", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_32k.jsonl", + "dataset_slug": "throughput_32k", + "run_slug": "075-mtp-s2-k3-d6-throughput_32k" + }, + { + "index": 76, + "variant_name": "mtp-s2-k3-d6", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "2", + "--speculative-eagle-topk", + "3", + "--speculative-num-draft-tokens", + "6", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_8k.jsonl", + "dataset_slug": "throughput_8k", + "run_slug": "076-mtp-s2-k3-d6-throughput_8k" + }, + { + "index": 77, + "variant_name": "mtp-s2-k3-d6", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "2", + "--speculative-eagle-topk", + "3", + "--speculative-num-draft-tokens", + "6", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/json_mode_eval/jsonl/train.jsonl", + "dataset_slug": "train", + "run_slug": "077-mtp-s2-k3-d6-train" + }, + { + "index": 78, + "variant_name": "mtp-s3-k1-d3", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "3", + "--speculative-eagle-topk", + "1", + "--speculative-num-draft-tokens", + "3", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_16k.jsonl", + "dataset_slug": "throughput_16k", + "run_slug": "078-mtp-s3-k1-d3-throughput_16k" + }, + { + "index": 79, + "variant_name": "mtp-s3-k1-d3", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "3", + "--speculative-eagle-topk", + "1", + "--speculative-num-draft-tokens", + "3", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_1k.jsonl", + "dataset_slug": "throughput_1k", + "run_slug": "079-mtp-s3-k1-d3-throughput_1k" + }, + { + "index": 80, + "variant_name": "mtp-s3-k1-d3", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "3", + "--speculative-eagle-topk", + "1", + "--speculative-num-draft-tokens", + "3", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_2k.jsonl", + "dataset_slug": "throughput_2k", + "run_slug": "080-mtp-s3-k1-d3-throughput_2k" + }, + { + "index": 81, + "variant_name": "mtp-s3-k1-d3", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "3", + "--speculative-eagle-topk", + "1", + "--speculative-num-draft-tokens", + "3", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_32k.jsonl", + "dataset_slug": "throughput_32k", + "run_slug": "081-mtp-s3-k1-d3-throughput_32k" + }, + { + "index": 82, + "variant_name": "mtp-s3-k1-d3", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "3", + "--speculative-eagle-topk", + "1", + "--speculative-num-draft-tokens", + "3", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_8k.jsonl", + "dataset_slug": "throughput_8k", + "run_slug": "082-mtp-s3-k1-d3-throughput_8k" + }, + { + "index": 83, + "variant_name": "mtp-s3-k1-d3", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "3", + "--speculative-eagle-topk", + "1", + "--speculative-num-draft-tokens", + "3", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/json_mode_eval/jsonl/train.jsonl", + "dataset_slug": "train", + "run_slug": "083-mtp-s3-k1-d3-train" + }, + { + "index": 84, + "variant_name": "mtp-s3-k1-d4", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "3", + "--speculative-eagle-topk", + "1", + "--speculative-num-draft-tokens", + "4", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_16k.jsonl", + "dataset_slug": "throughput_16k", + "run_slug": "084-mtp-s3-k1-d4-throughput_16k" + }, + { + "index": 85, + "variant_name": "mtp-s3-k1-d4", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "3", + "--speculative-eagle-topk", + "1", + "--speculative-num-draft-tokens", + "4", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_1k.jsonl", + "dataset_slug": "throughput_1k", + "run_slug": "085-mtp-s3-k1-d4-throughput_1k" + }, + { + "index": 86, + "variant_name": "mtp-s3-k1-d4", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "3", + "--speculative-eagle-topk", + "1", + "--speculative-num-draft-tokens", + "4", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_2k.jsonl", + "dataset_slug": "throughput_2k", + "run_slug": "086-mtp-s3-k1-d4-throughput_2k" + }, + { + "index": 87, + "variant_name": "mtp-s3-k1-d4", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "3", + "--speculative-eagle-topk", + "1", + "--speculative-num-draft-tokens", + "4", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_32k.jsonl", + "dataset_slug": "throughput_32k", + "run_slug": "087-mtp-s3-k1-d4-throughput_32k" + }, + { + "index": 88, + "variant_name": "mtp-s3-k1-d4", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "3", + "--speculative-eagle-topk", + "1", + "--speculative-num-draft-tokens", + "4", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_8k.jsonl", + "dataset_slug": "throughput_8k", + "run_slug": "088-mtp-s3-k1-d4-throughput_8k" + }, + { + "index": 89, + "variant_name": "mtp-s3-k1-d4", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "3", + "--speculative-eagle-topk", + "1", + "--speculative-num-draft-tokens", + "4", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/json_mode_eval/jsonl/train.jsonl", + "dataset_slug": "train", + "run_slug": "089-mtp-s3-k1-d4-train" + }, + { + "index": 90, + "variant_name": "mtp-s3-k1-d5", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "3", + "--speculative-eagle-topk", + "1", + "--speculative-num-draft-tokens", + "5", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_16k.jsonl", + "dataset_slug": "throughput_16k", + "run_slug": "090-mtp-s3-k1-d5-throughput_16k" + }, + { + "index": 91, + "variant_name": "mtp-s3-k1-d5", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "3", + "--speculative-eagle-topk", + "1", + "--speculative-num-draft-tokens", + "5", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_1k.jsonl", + "dataset_slug": "throughput_1k", + "run_slug": "091-mtp-s3-k1-d5-throughput_1k" + }, + { + "index": 92, + "variant_name": "mtp-s3-k1-d5", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "3", + "--speculative-eagle-topk", + "1", + "--speculative-num-draft-tokens", + "5", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_2k.jsonl", + "dataset_slug": "throughput_2k", + "run_slug": "092-mtp-s3-k1-d5-throughput_2k" + }, + { + "index": 93, + "variant_name": "mtp-s3-k1-d5", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "3", + "--speculative-eagle-topk", + "1", + "--speculative-num-draft-tokens", + "5", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_32k.jsonl", + "dataset_slug": "throughput_32k", + "run_slug": "093-mtp-s3-k1-d5-throughput_32k" + }, + { + "index": 94, + "variant_name": "mtp-s3-k1-d5", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "3", + "--speculative-eagle-topk", + "1", + "--speculative-num-draft-tokens", + "5", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_8k.jsonl", + "dataset_slug": "throughput_8k", + "run_slug": "094-mtp-s3-k1-d5-throughput_8k" + }, + { + "index": 95, + "variant_name": "mtp-s3-k1-d5", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "3", + "--speculative-eagle-topk", + "1", + "--speculative-num-draft-tokens", + "5", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/json_mode_eval/jsonl/train.jsonl", + "dataset_slug": "train", + "run_slug": "095-mtp-s3-k1-d5-train" + }, + { + "index": 96, + "variant_name": "mtp-s3-k1-d6", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "3", + "--speculative-eagle-topk", + "1", + "--speculative-num-draft-tokens", + "6", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_16k.jsonl", + "dataset_slug": "throughput_16k", + "run_slug": "096-mtp-s3-k1-d6-throughput_16k" + }, + { + "index": 97, + "variant_name": "mtp-s3-k1-d6", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "3", + "--speculative-eagle-topk", + "1", + "--speculative-num-draft-tokens", + "6", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_1k.jsonl", + "dataset_slug": "throughput_1k", + "run_slug": "097-mtp-s3-k1-d6-throughput_1k" + }, + { + "index": 98, + "variant_name": "mtp-s3-k1-d6", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "3", + "--speculative-eagle-topk", + "1", + "--speculative-num-draft-tokens", + "6", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_2k.jsonl", + "dataset_slug": "throughput_2k", + "run_slug": "098-mtp-s3-k1-d6-throughput_2k" + }, + { + "index": 99, + "variant_name": "mtp-s3-k1-d6", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "3", + "--speculative-eagle-topk", + "1", + "--speculative-num-draft-tokens", + "6", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_32k.jsonl", + "dataset_slug": "throughput_32k", + "run_slug": "099-mtp-s3-k1-d6-throughput_32k" + }, + { + "index": 100, + "variant_name": "mtp-s3-k1-d6", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "3", + "--speculative-eagle-topk", + "1", + "--speculative-num-draft-tokens", + "6", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_8k.jsonl", + "dataset_slug": "throughput_8k", + "run_slug": "100-mtp-s3-k1-d6-throughput_8k" + }, + { + "index": 101, + "variant_name": "mtp-s3-k1-d6", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "3", + "--speculative-eagle-topk", + "1", + "--speculative-num-draft-tokens", + "6", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/json_mode_eval/jsonl/train.jsonl", + "dataset_slug": "train", + "run_slug": "101-mtp-s3-k1-d6-train" + }, + { + "index": 102, + "variant_name": "mtp-s3-k2-d3", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "3", + "--speculative-eagle-topk", + "2", + "--speculative-num-draft-tokens", + "3", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_16k.jsonl", + "dataset_slug": "throughput_16k", + "run_slug": "102-mtp-s3-k2-d3-throughput_16k" + }, + { + "index": 103, + "variant_name": "mtp-s3-k2-d3", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "3", + "--speculative-eagle-topk", + "2", + "--speculative-num-draft-tokens", + "3", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_1k.jsonl", + "dataset_slug": "throughput_1k", + "run_slug": "103-mtp-s3-k2-d3-throughput_1k" + }, + { + "index": 104, + "variant_name": "mtp-s3-k2-d3", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "3", + "--speculative-eagle-topk", + "2", + "--speculative-num-draft-tokens", + "3", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_2k.jsonl", + "dataset_slug": "throughput_2k", + "run_slug": "104-mtp-s3-k2-d3-throughput_2k" + }, + { + "index": 105, + "variant_name": "mtp-s3-k2-d3", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "3", + "--speculative-eagle-topk", + "2", + "--speculative-num-draft-tokens", + "3", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_32k.jsonl", + "dataset_slug": "throughput_32k", + "run_slug": "105-mtp-s3-k2-d3-throughput_32k" + }, + { + "index": 106, + "variant_name": "mtp-s3-k2-d3", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "3", + "--speculative-eagle-topk", + "2", + "--speculative-num-draft-tokens", + "3", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_8k.jsonl", + "dataset_slug": "throughput_8k", + "run_slug": "106-mtp-s3-k2-d3-throughput_8k" + }, + { + "index": 107, + "variant_name": "mtp-s3-k2-d3", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "3", + "--speculative-eagle-topk", + "2", + "--speculative-num-draft-tokens", + "3", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/json_mode_eval/jsonl/train.jsonl", + "dataset_slug": "train", + "run_slug": "107-mtp-s3-k2-d3-train" + }, + { + "index": 108, + "variant_name": "mtp-s3-k2-d4", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "3", + "--speculative-eagle-topk", + "2", + "--speculative-num-draft-tokens", + "4", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_16k.jsonl", + "dataset_slug": "throughput_16k", + "run_slug": "108-mtp-s3-k2-d4-throughput_16k" + }, + { + "index": 109, + "variant_name": "mtp-s3-k2-d4", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "3", + "--speculative-eagle-topk", + "2", + "--speculative-num-draft-tokens", + "4", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_1k.jsonl", + "dataset_slug": "throughput_1k", + "run_slug": "109-mtp-s3-k2-d4-throughput_1k" + }, + { + "index": 110, + "variant_name": "mtp-s3-k2-d4", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "3", + "--speculative-eagle-topk", + "2", + "--speculative-num-draft-tokens", + "4", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_2k.jsonl", + "dataset_slug": "throughput_2k", + "run_slug": "110-mtp-s3-k2-d4-throughput_2k" + }, + { + "index": 111, + "variant_name": "mtp-s3-k2-d4", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "3", + "--speculative-eagle-topk", + "2", + "--speculative-num-draft-tokens", + "4", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_32k.jsonl", + "dataset_slug": "throughput_32k", + "run_slug": "111-mtp-s3-k2-d4-throughput_32k" + }, + { + "index": 112, + "variant_name": "mtp-s3-k2-d4", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "3", + "--speculative-eagle-topk", + "2", + "--speculative-num-draft-tokens", + "4", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_8k.jsonl", + "dataset_slug": "throughput_8k", + "run_slug": "112-mtp-s3-k2-d4-throughput_8k" + }, + { + "index": 113, + "variant_name": "mtp-s3-k2-d4", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "3", + "--speculative-eagle-topk", + "2", + "--speculative-num-draft-tokens", + "4", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/json_mode_eval/jsonl/train.jsonl", + "dataset_slug": "train", + "run_slug": "113-mtp-s3-k2-d4-train" + }, + { + "index": 114, + "variant_name": "mtp-s3-k2-d5", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "3", + "--speculative-eagle-topk", + "2", + "--speculative-num-draft-tokens", + "5", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_16k.jsonl", + "dataset_slug": "throughput_16k", + "run_slug": "114-mtp-s3-k2-d5-throughput_16k" + }, + { + "index": 115, + "variant_name": "mtp-s3-k2-d5", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "3", + "--speculative-eagle-topk", + "2", + "--speculative-num-draft-tokens", + "5", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_1k.jsonl", + "dataset_slug": "throughput_1k", + "run_slug": "115-mtp-s3-k2-d5-throughput_1k" + }, + { + "index": 116, + "variant_name": "mtp-s3-k2-d5", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "3", + "--speculative-eagle-topk", + "2", + "--speculative-num-draft-tokens", + "5", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_2k.jsonl", + "dataset_slug": "throughput_2k", + "run_slug": "116-mtp-s3-k2-d5-throughput_2k" + }, + { + "index": 117, + "variant_name": "mtp-s3-k2-d5", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "3", + "--speculative-eagle-topk", + "2", + "--speculative-num-draft-tokens", + "5", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_32k.jsonl", + "dataset_slug": "throughput_32k", + "run_slug": "117-mtp-s3-k2-d5-throughput_32k" + }, + { + "index": 118, + "variant_name": "mtp-s3-k2-d5", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "3", + "--speculative-eagle-topk", + "2", + "--speculative-num-draft-tokens", + "5", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_8k.jsonl", + "dataset_slug": "throughput_8k", + "run_slug": "118-mtp-s3-k2-d5-throughput_8k" + }, + { + "index": 119, + "variant_name": "mtp-s3-k2-d5", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "3", + "--speculative-eagle-topk", + "2", + "--speculative-num-draft-tokens", + "5", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/json_mode_eval/jsonl/train.jsonl", + "dataset_slug": "train", + "run_slug": "119-mtp-s3-k2-d5-train" + }, + { + "index": 120, + "variant_name": "mtp-s3-k2-d6", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "3", + "--speculative-eagle-topk", + "2", + "--speculative-num-draft-tokens", + "6", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_16k.jsonl", + "dataset_slug": "throughput_16k", + "run_slug": "120-mtp-s3-k2-d6-throughput_16k" + }, + { + "index": 121, + "variant_name": "mtp-s3-k2-d6", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "3", + "--speculative-eagle-topk", + "2", + "--speculative-num-draft-tokens", + "6", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_1k.jsonl", + "dataset_slug": "throughput_1k", + "run_slug": "121-mtp-s3-k2-d6-throughput_1k" + }, + { + "index": 122, + "variant_name": "mtp-s3-k2-d6", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "3", + "--speculative-eagle-topk", + "2", + "--speculative-num-draft-tokens", + "6", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_2k.jsonl", + "dataset_slug": "throughput_2k", + "run_slug": "122-mtp-s3-k2-d6-throughput_2k" + }, + { + "index": 123, + "variant_name": "mtp-s3-k2-d6", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "3", + "--speculative-eagle-topk", + "2", + "--speculative-num-draft-tokens", + "6", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_32k.jsonl", + "dataset_slug": "throughput_32k", + "run_slug": "123-mtp-s3-k2-d6-throughput_32k" + }, + { + "index": 124, + "variant_name": "mtp-s3-k2-d6", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "3", + "--speculative-eagle-topk", + "2", + "--speculative-num-draft-tokens", + "6", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_8k.jsonl", + "dataset_slug": "throughput_8k", + "run_slug": "124-mtp-s3-k2-d6-throughput_8k" + }, + { + "index": 125, + "variant_name": "mtp-s3-k2-d6", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "3", + "--speculative-eagle-topk", + "2", + "--speculative-num-draft-tokens", + "6", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/json_mode_eval/jsonl/train.jsonl", + "dataset_slug": "train", + "run_slug": "125-mtp-s3-k2-d6-train" + }, + { + "index": 126, + "variant_name": "mtp-s3-k3-d3", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "3", + "--speculative-eagle-topk", + "3", + "--speculative-num-draft-tokens", + "3", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_16k.jsonl", + "dataset_slug": "throughput_16k", + "run_slug": "126-mtp-s3-k3-d3-throughput_16k" + }, + { + "index": 127, + "variant_name": "mtp-s3-k3-d3", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "3", + "--speculative-eagle-topk", + "3", + "--speculative-num-draft-tokens", + "3", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_1k.jsonl", + "dataset_slug": "throughput_1k", + "run_slug": "127-mtp-s3-k3-d3-throughput_1k" + }, + { + "index": 128, + "variant_name": "mtp-s3-k3-d3", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "3", + "--speculative-eagle-topk", + "3", + "--speculative-num-draft-tokens", + "3", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_2k.jsonl", + "dataset_slug": "throughput_2k", + "run_slug": "128-mtp-s3-k3-d3-throughput_2k" + }, + { + "index": 129, + "variant_name": "mtp-s3-k3-d3", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "3", + "--speculative-eagle-topk", + "3", + "--speculative-num-draft-tokens", + "3", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_32k.jsonl", + "dataset_slug": "throughput_32k", + "run_slug": "129-mtp-s3-k3-d3-throughput_32k" + }, + { + "index": 130, + "variant_name": "mtp-s3-k3-d3", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "3", + "--speculative-eagle-topk", + "3", + "--speculative-num-draft-tokens", + "3", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_8k.jsonl", + "dataset_slug": "throughput_8k", + "run_slug": "130-mtp-s3-k3-d3-throughput_8k" + }, + { + "index": 131, + "variant_name": "mtp-s3-k3-d3", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "3", + "--speculative-eagle-topk", + "3", + "--speculative-num-draft-tokens", + "3", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/json_mode_eval/jsonl/train.jsonl", + "dataset_slug": "train", + "run_slug": "131-mtp-s3-k3-d3-train" + }, + { + "index": 132, + "variant_name": "mtp-s3-k3-d4", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "3", + "--speculative-eagle-topk", + "3", + "--speculative-num-draft-tokens", + "4", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_16k.jsonl", + "dataset_slug": "throughput_16k", + "run_slug": "132-mtp-s3-k3-d4-throughput_16k" + }, + { + "index": 133, + "variant_name": "mtp-s3-k3-d4", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "3", + "--speculative-eagle-topk", + "3", + "--speculative-num-draft-tokens", + "4", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_1k.jsonl", + "dataset_slug": "throughput_1k", + "run_slug": "133-mtp-s3-k3-d4-throughput_1k" + }, + { + "index": 134, + "variant_name": "mtp-s3-k3-d4", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "3", + "--speculative-eagle-topk", + "3", + "--speculative-num-draft-tokens", + "4", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_2k.jsonl", + "dataset_slug": "throughput_2k", + "run_slug": "134-mtp-s3-k3-d4-throughput_2k" + }, + { + "index": 135, + "variant_name": "mtp-s3-k3-d4", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "3", + "--speculative-eagle-topk", + "3", + "--speculative-num-draft-tokens", + "4", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_32k.jsonl", + "dataset_slug": "throughput_32k", + "run_slug": "135-mtp-s3-k3-d4-throughput_32k" + }, + { + "index": 136, + "variant_name": "mtp-s3-k3-d4", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "3", + "--speculative-eagle-topk", + "3", + "--speculative-num-draft-tokens", + "4", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_8k.jsonl", + "dataset_slug": "throughput_8k", + "run_slug": "136-mtp-s3-k3-d4-throughput_8k" + }, + { + "index": 137, + "variant_name": "mtp-s3-k3-d4", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "3", + "--speculative-eagle-topk", + "3", + "--speculative-num-draft-tokens", + "4", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/json_mode_eval/jsonl/train.jsonl", + "dataset_slug": "train", + "run_slug": "137-mtp-s3-k3-d4-train" + }, + { + "index": 138, + "variant_name": "mtp-s3-k3-d5", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "3", + "--speculative-eagle-topk", + "3", + "--speculative-num-draft-tokens", + "5", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_16k.jsonl", + "dataset_slug": "throughput_16k", + "run_slug": "138-mtp-s3-k3-d5-throughput_16k" + }, + { + "index": 139, + "variant_name": "mtp-s3-k3-d5", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "3", + "--speculative-eagle-topk", + "3", + "--speculative-num-draft-tokens", + "5", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_1k.jsonl", + "dataset_slug": "throughput_1k", + "run_slug": "139-mtp-s3-k3-d5-throughput_1k" + }, + { + "index": 140, + "variant_name": "mtp-s3-k3-d5", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "3", + "--speculative-eagle-topk", + "3", + "--speculative-num-draft-tokens", + "5", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_2k.jsonl", + "dataset_slug": "throughput_2k", + "run_slug": "140-mtp-s3-k3-d5-throughput_2k" + }, + { + "index": 141, + "variant_name": "mtp-s3-k3-d5", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "3", + "--speculative-eagle-topk", + "3", + "--speculative-num-draft-tokens", + "5", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_32k.jsonl", + "dataset_slug": "throughput_32k", + "run_slug": "141-mtp-s3-k3-d5-throughput_32k" + }, + { + "index": 142, + "variant_name": "mtp-s3-k3-d5", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "3", + "--speculative-eagle-topk", + "3", + "--speculative-num-draft-tokens", + "5", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_8k.jsonl", + "dataset_slug": "throughput_8k", + "run_slug": "142-mtp-s3-k3-d5-throughput_8k" + }, + { + "index": 143, + "variant_name": "mtp-s3-k3-d5", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "3", + "--speculative-eagle-topk", + "3", + "--speculative-num-draft-tokens", + "5", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/json_mode_eval/jsonl/train.jsonl", + "dataset_slug": "train", + "run_slug": "143-mtp-s3-k3-d5-train" + }, + { + "index": 144, + "variant_name": "mtp-s3-k3-d6", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "3", + "--speculative-eagle-topk", + "3", + "--speculative-num-draft-tokens", + "6", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_16k.jsonl", + "dataset_slug": "throughput_16k", + "run_slug": "144-mtp-s3-k3-d6-throughput_16k" + }, + { + "index": 145, + "variant_name": "mtp-s3-k3-d6", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "3", + "--speculative-eagle-topk", + "3", + "--speculative-num-draft-tokens", + "6", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_1k.jsonl", + "dataset_slug": "throughput_1k", + "run_slug": "145-mtp-s3-k3-d6-throughput_1k" + }, + { + "index": 146, + "variant_name": "mtp-s3-k3-d6", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "3", + "--speculative-eagle-topk", + "3", + "--speculative-num-draft-tokens", + "6", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_2k.jsonl", + "dataset_slug": "throughput_2k", + "run_slug": "146-mtp-s3-k3-d6-throughput_2k" + }, + { + "index": 147, + "variant_name": "mtp-s3-k3-d6", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "3", + "--speculative-eagle-topk", + "3", + "--speculative-num-draft-tokens", + "6", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_32k.jsonl", + "dataset_slug": "throughput_32k", + "run_slug": "147-mtp-s3-k3-d6-throughput_32k" + }, + { + "index": 148, + "variant_name": "mtp-s3-k3-d6", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "3", + "--speculative-eagle-topk", + "3", + "--speculative-num-draft-tokens", + "6", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_8k.jsonl", + "dataset_slug": "throughput_8k", + "run_slug": "148-mtp-s3-k3-d6-throughput_8k" + }, + { + "index": 149, + "variant_name": "mtp-s3-k3-d6", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "3", + "--speculative-eagle-topk", + "3", + "--speculative-num-draft-tokens", + "6", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/json_mode_eval/jsonl/train.jsonl", + "dataset_slug": "train", + "run_slug": "149-mtp-s3-k3-d6-train" + }, + { + "index": 150, + "variant_name": "mtp-s4-k1-d3", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "4", + "--speculative-eagle-topk", + "1", + "--speculative-num-draft-tokens", + "3", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_16k.jsonl", + "dataset_slug": "throughput_16k", + "run_slug": "150-mtp-s4-k1-d3-throughput_16k" + }, + { + "index": 151, + "variant_name": "mtp-s4-k1-d3", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "4", + "--speculative-eagle-topk", + "1", + "--speculative-num-draft-tokens", + "3", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_1k.jsonl", + "dataset_slug": "throughput_1k", + "run_slug": "151-mtp-s4-k1-d3-throughput_1k" + }, + { + "index": 152, + "variant_name": "mtp-s4-k1-d3", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "4", + "--speculative-eagle-topk", + "1", + "--speculative-num-draft-tokens", + "3", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_2k.jsonl", + "dataset_slug": "throughput_2k", + "run_slug": "152-mtp-s4-k1-d3-throughput_2k" + }, + { + "index": 153, + "variant_name": "mtp-s4-k1-d3", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "4", + "--speculative-eagle-topk", + "1", + "--speculative-num-draft-tokens", + "3", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_32k.jsonl", + "dataset_slug": "throughput_32k", + "run_slug": "153-mtp-s4-k1-d3-throughput_32k" + }, + { + "index": 154, + "variant_name": "mtp-s4-k1-d3", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "4", + "--speculative-eagle-topk", + "1", + "--speculative-num-draft-tokens", + "3", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_8k.jsonl", + "dataset_slug": "throughput_8k", + "run_slug": "154-mtp-s4-k1-d3-throughput_8k" + }, + { + "index": 155, + "variant_name": "mtp-s4-k1-d3", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "4", + "--speculative-eagle-topk", + "1", + "--speculative-num-draft-tokens", + "3", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/json_mode_eval/jsonl/train.jsonl", + "dataset_slug": "train", + "run_slug": "155-mtp-s4-k1-d3-train" + }, + { + "index": 156, + "variant_name": "mtp-s4-k1-d4", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "4", + "--speculative-eagle-topk", + "1", + "--speculative-num-draft-tokens", + "4", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_16k.jsonl", + "dataset_slug": "throughput_16k", + "run_slug": "156-mtp-s4-k1-d4-throughput_16k" + }, + { + "index": 157, + "variant_name": "mtp-s4-k1-d4", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "4", + "--speculative-eagle-topk", + "1", + "--speculative-num-draft-tokens", + "4", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_1k.jsonl", + "dataset_slug": "throughput_1k", + "run_slug": "157-mtp-s4-k1-d4-throughput_1k" + }, + { + "index": 158, + "variant_name": "mtp-s4-k1-d4", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "4", + "--speculative-eagle-topk", + "1", + "--speculative-num-draft-tokens", + "4", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_2k.jsonl", + "dataset_slug": "throughput_2k", + "run_slug": "158-mtp-s4-k1-d4-throughput_2k" + }, + { + "index": 159, + "variant_name": "mtp-s4-k1-d4", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "4", + "--speculative-eagle-topk", + "1", + "--speculative-num-draft-tokens", + "4", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_32k.jsonl", + "dataset_slug": "throughput_32k", + "run_slug": "159-mtp-s4-k1-d4-throughput_32k" + }, + { + "index": 160, + "variant_name": "mtp-s4-k1-d4", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "4", + "--speculative-eagle-topk", + "1", + "--speculative-num-draft-tokens", + "4", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_8k.jsonl", + "dataset_slug": "throughput_8k", + "run_slug": "160-mtp-s4-k1-d4-throughput_8k" + }, + { + "index": 161, + "variant_name": "mtp-s4-k1-d4", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "4", + "--speculative-eagle-topk", + "1", + "--speculative-num-draft-tokens", + "4", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/json_mode_eval/jsonl/train.jsonl", + "dataset_slug": "train", + "run_slug": "161-mtp-s4-k1-d4-train" + }, + { + "index": 162, + "variant_name": "mtp-s4-k1-d5", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "4", + "--speculative-eagle-topk", + "1", + "--speculative-num-draft-tokens", + "5", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_16k.jsonl", + "dataset_slug": "throughput_16k", + "run_slug": "162-mtp-s4-k1-d5-throughput_16k" + }, + { + "index": 163, + "variant_name": "mtp-s4-k1-d5", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "4", + "--speculative-eagle-topk", + "1", + "--speculative-num-draft-tokens", + "5", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_1k.jsonl", + "dataset_slug": "throughput_1k", + "run_slug": "163-mtp-s4-k1-d5-throughput_1k" + }, + { + "index": 164, + "variant_name": "mtp-s4-k1-d5", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "4", + "--speculative-eagle-topk", + "1", + "--speculative-num-draft-tokens", + "5", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_2k.jsonl", + "dataset_slug": "throughput_2k", + "run_slug": "164-mtp-s4-k1-d5-throughput_2k" + }, + { + "index": 165, + "variant_name": "mtp-s4-k1-d5", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "4", + "--speculative-eagle-topk", + "1", + "--speculative-num-draft-tokens", + "5", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_32k.jsonl", + "dataset_slug": "throughput_32k", + "run_slug": "165-mtp-s4-k1-d5-throughput_32k" + }, + { + "index": 166, + "variant_name": "mtp-s4-k1-d5", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "4", + "--speculative-eagle-topk", + "1", + "--speculative-num-draft-tokens", + "5", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_8k.jsonl", + "dataset_slug": "throughput_8k", + "run_slug": "166-mtp-s4-k1-d5-throughput_8k" + }, + { + "index": 167, + "variant_name": "mtp-s4-k1-d5", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "4", + "--speculative-eagle-topk", + "1", + "--speculative-num-draft-tokens", + "5", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/json_mode_eval/jsonl/train.jsonl", + "dataset_slug": "train", + "run_slug": "167-mtp-s4-k1-d5-train" + }, + { + "index": 168, + "variant_name": "mtp-s4-k1-d6", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "4", + "--speculative-eagle-topk", + "1", + "--speculative-num-draft-tokens", + "6", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_16k.jsonl", + "dataset_slug": "throughput_16k", + "run_slug": "168-mtp-s4-k1-d6-throughput_16k" + }, + { + "index": 169, + "variant_name": "mtp-s4-k1-d6", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "4", + "--speculative-eagle-topk", + "1", + "--speculative-num-draft-tokens", + "6", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_1k.jsonl", + "dataset_slug": "throughput_1k", + "run_slug": "169-mtp-s4-k1-d6-throughput_1k" + }, + { + "index": 170, + "variant_name": "mtp-s4-k1-d6", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "4", + "--speculative-eagle-topk", + "1", + "--speculative-num-draft-tokens", + "6", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_2k.jsonl", + "dataset_slug": "throughput_2k", + "run_slug": "170-mtp-s4-k1-d6-throughput_2k" + }, + { + "index": 171, + "variant_name": "mtp-s4-k1-d6", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "4", + "--speculative-eagle-topk", + "1", + "--speculative-num-draft-tokens", + "6", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_32k.jsonl", + "dataset_slug": "throughput_32k", + "run_slug": "171-mtp-s4-k1-d6-throughput_32k" + }, + { + "index": 172, + "variant_name": "mtp-s4-k1-d6", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "4", + "--speculative-eagle-topk", + "1", + "--speculative-num-draft-tokens", + "6", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_8k.jsonl", + "dataset_slug": "throughput_8k", + "run_slug": "172-mtp-s4-k1-d6-throughput_8k" + }, + { + "index": 173, + "variant_name": "mtp-s4-k1-d6", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "4", + "--speculative-eagle-topk", + "1", + "--speculative-num-draft-tokens", + "6", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/json_mode_eval/jsonl/train.jsonl", + "dataset_slug": "train", + "run_slug": "173-mtp-s4-k1-d6-train" + }, + { + "index": 174, + "variant_name": "mtp-s4-k2-d3", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "4", + "--speculative-eagle-topk", + "2", + "--speculative-num-draft-tokens", + "3", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_16k.jsonl", + "dataset_slug": "throughput_16k", + "run_slug": "174-mtp-s4-k2-d3-throughput_16k" + }, + { + "index": 175, + "variant_name": "mtp-s4-k2-d3", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "4", + "--speculative-eagle-topk", + "2", + "--speculative-num-draft-tokens", + "3", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_1k.jsonl", + "dataset_slug": "throughput_1k", + "run_slug": "175-mtp-s4-k2-d3-throughput_1k" + }, + { + "index": 176, + "variant_name": "mtp-s4-k2-d3", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "4", + "--speculative-eagle-topk", + "2", + "--speculative-num-draft-tokens", + "3", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_2k.jsonl", + "dataset_slug": "throughput_2k", + "run_slug": "176-mtp-s4-k2-d3-throughput_2k" + }, + { + "index": 177, + "variant_name": "mtp-s4-k2-d3", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "4", + "--speculative-eagle-topk", + "2", + "--speculative-num-draft-tokens", + "3", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_32k.jsonl", + "dataset_slug": "throughput_32k", + "run_slug": "177-mtp-s4-k2-d3-throughput_32k" + }, + { + "index": 178, + "variant_name": "mtp-s4-k2-d3", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "4", + "--speculative-eagle-topk", + "2", + "--speculative-num-draft-tokens", + "3", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_8k.jsonl", + "dataset_slug": "throughput_8k", + "run_slug": "178-mtp-s4-k2-d3-throughput_8k" + }, + { + "index": 179, + "variant_name": "mtp-s4-k2-d3", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "4", + "--speculative-eagle-topk", + "2", + "--speculative-num-draft-tokens", + "3", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/json_mode_eval/jsonl/train.jsonl", + "dataset_slug": "train", + "run_slug": "179-mtp-s4-k2-d3-train" + }, + { + "index": 180, + "variant_name": "mtp-s4-k2-d4", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "4", + "--speculative-eagle-topk", + "2", + "--speculative-num-draft-tokens", + "4", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_16k.jsonl", + "dataset_slug": "throughput_16k", + "run_slug": "180-mtp-s4-k2-d4-throughput_16k" + }, + { + "index": 181, + "variant_name": "mtp-s4-k2-d4", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "4", + "--speculative-eagle-topk", + "2", + "--speculative-num-draft-tokens", + "4", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_1k.jsonl", + "dataset_slug": "throughput_1k", + "run_slug": "181-mtp-s4-k2-d4-throughput_1k" + }, + { + "index": 182, + "variant_name": "mtp-s4-k2-d4", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "4", + "--speculative-eagle-topk", + "2", + "--speculative-num-draft-tokens", + "4", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_2k.jsonl", + "dataset_slug": "throughput_2k", + "run_slug": "182-mtp-s4-k2-d4-throughput_2k" + }, + { + "index": 183, + "variant_name": "mtp-s4-k2-d4", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "4", + "--speculative-eagle-topk", + "2", + "--speculative-num-draft-tokens", + "4", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_32k.jsonl", + "dataset_slug": "throughput_32k", + "run_slug": "183-mtp-s4-k2-d4-throughput_32k" + }, + { + "index": 184, + "variant_name": "mtp-s4-k2-d4", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "4", + "--speculative-eagle-topk", + "2", + "--speculative-num-draft-tokens", + "4", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_8k.jsonl", + "dataset_slug": "throughput_8k", + "run_slug": "184-mtp-s4-k2-d4-throughput_8k" + }, + { + "index": 185, + "variant_name": "mtp-s4-k2-d4", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "4", + "--speculative-eagle-topk", + "2", + "--speculative-num-draft-tokens", + "4", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/json_mode_eval/jsonl/train.jsonl", + "dataset_slug": "train", + "run_slug": "185-mtp-s4-k2-d4-train" + }, + { + "index": 186, + "variant_name": "mtp-s4-k2-d5", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "4", + "--speculative-eagle-topk", + "2", + "--speculative-num-draft-tokens", + "5", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_16k.jsonl", + "dataset_slug": "throughput_16k", + "run_slug": "186-mtp-s4-k2-d5-throughput_16k" + }, + { + "index": 187, + "variant_name": "mtp-s4-k2-d5", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "4", + "--speculative-eagle-topk", + "2", + "--speculative-num-draft-tokens", + "5", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_1k.jsonl", + "dataset_slug": "throughput_1k", + "run_slug": "187-mtp-s4-k2-d5-throughput_1k" + }, + { + "index": 188, + "variant_name": "mtp-s4-k2-d5", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "4", + "--speculative-eagle-topk", + "2", + "--speculative-num-draft-tokens", + "5", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_2k.jsonl", + "dataset_slug": "throughput_2k", + "run_slug": "188-mtp-s4-k2-d5-throughput_2k" + }, + { + "index": 189, + "variant_name": "mtp-s4-k2-d5", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "4", + "--speculative-eagle-topk", + "2", + "--speculative-num-draft-tokens", + "5", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_32k.jsonl", + "dataset_slug": "throughput_32k", + "run_slug": "189-mtp-s4-k2-d5-throughput_32k" + }, + { + "index": 190, + "variant_name": "mtp-s4-k2-d5", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "4", + "--speculative-eagle-topk", + "2", + "--speculative-num-draft-tokens", + "5", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_8k.jsonl", + "dataset_slug": "throughput_8k", + "run_slug": "190-mtp-s4-k2-d5-throughput_8k" + }, + { + "index": 191, + "variant_name": "mtp-s4-k2-d5", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "4", + "--speculative-eagle-topk", + "2", + "--speculative-num-draft-tokens", + "5", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/json_mode_eval/jsonl/train.jsonl", + "dataset_slug": "train", + "run_slug": "191-mtp-s4-k2-d5-train" + }, + { + "index": 192, + "variant_name": "mtp-s4-k2-d6", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "4", + "--speculative-eagle-topk", + "2", + "--speculative-num-draft-tokens", + "6", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_16k.jsonl", + "dataset_slug": "throughput_16k", + "run_slug": "192-mtp-s4-k2-d6-throughput_16k" + }, + { + "index": 193, + "variant_name": "mtp-s4-k2-d6", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "4", + "--speculative-eagle-topk", + "2", + "--speculative-num-draft-tokens", + "6", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_1k.jsonl", + "dataset_slug": "throughput_1k", + "run_slug": "193-mtp-s4-k2-d6-throughput_1k" + }, + { + "index": 194, + "variant_name": "mtp-s4-k2-d6", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "4", + "--speculative-eagle-topk", + "2", + "--speculative-num-draft-tokens", + "6", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_2k.jsonl", + "dataset_slug": "throughput_2k", + "run_slug": "194-mtp-s4-k2-d6-throughput_2k" + }, + { + "index": 195, + "variant_name": "mtp-s4-k2-d6", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "4", + "--speculative-eagle-topk", + "2", + "--speculative-num-draft-tokens", + "6", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_32k.jsonl", + "dataset_slug": "throughput_32k", + "run_slug": "195-mtp-s4-k2-d6-throughput_32k" + }, + { + "index": 196, + "variant_name": "mtp-s4-k2-d6", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "4", + "--speculative-eagle-topk", + "2", + "--speculative-num-draft-tokens", + "6", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_8k.jsonl", + "dataset_slug": "throughput_8k", + "run_slug": "196-mtp-s4-k2-d6-throughput_8k" + }, + { + "index": 197, + "variant_name": "mtp-s4-k2-d6", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "4", + "--speculative-eagle-topk", + "2", + "--speculative-num-draft-tokens", + "6", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/json_mode_eval/jsonl/train.jsonl", + "dataset_slug": "train", + "run_slug": "197-mtp-s4-k2-d6-train" + }, + { + "index": 198, + "variant_name": "mtp-s4-k3-d3", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "4", + "--speculative-eagle-topk", + "3", + "--speculative-num-draft-tokens", + "3", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_16k.jsonl", + "dataset_slug": "throughput_16k", + "run_slug": "198-mtp-s4-k3-d3-throughput_16k" + }, + { + "index": 199, + "variant_name": "mtp-s4-k3-d3", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "4", + "--speculative-eagle-topk", + "3", + "--speculative-num-draft-tokens", + "3", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_1k.jsonl", + "dataset_slug": "throughput_1k", + "run_slug": "199-mtp-s4-k3-d3-throughput_1k" + }, + { + "index": 200, + "variant_name": "mtp-s4-k3-d3", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "4", + "--speculative-eagle-topk", + "3", + "--speculative-num-draft-tokens", + "3", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_2k.jsonl", + "dataset_slug": "throughput_2k", + "run_slug": "200-mtp-s4-k3-d3-throughput_2k" + }, + { + "index": 201, + "variant_name": "mtp-s4-k3-d3", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "4", + "--speculative-eagle-topk", + "3", + "--speculative-num-draft-tokens", + "3", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_32k.jsonl", + "dataset_slug": "throughput_32k", + "run_slug": "201-mtp-s4-k3-d3-throughput_32k" + }, + { + "index": 202, + "variant_name": "mtp-s4-k3-d3", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "4", + "--speculative-eagle-topk", + "3", + "--speculative-num-draft-tokens", + "3", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_8k.jsonl", + "dataset_slug": "throughput_8k", + "run_slug": "202-mtp-s4-k3-d3-throughput_8k" + }, + { + "index": 203, + "variant_name": "mtp-s4-k3-d3", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "4", + "--speculative-eagle-topk", + "3", + "--speculative-num-draft-tokens", + "3", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/json_mode_eval/jsonl/train.jsonl", + "dataset_slug": "train", + "run_slug": "203-mtp-s4-k3-d3-train" + }, + { + "index": 204, + "variant_name": "mtp-s4-k3-d4", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "4", + "--speculative-eagle-topk", + "3", + "--speculative-num-draft-tokens", + "4", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_16k.jsonl", + "dataset_slug": "throughput_16k", + "run_slug": "204-mtp-s4-k3-d4-throughput_16k" + }, + { + "index": 205, + "variant_name": "mtp-s4-k3-d4", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "4", + "--speculative-eagle-topk", + "3", + "--speculative-num-draft-tokens", + "4", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_1k.jsonl", + "dataset_slug": "throughput_1k", + "run_slug": "205-mtp-s4-k3-d4-throughput_1k" + }, + { + "index": 206, + "variant_name": "mtp-s4-k3-d4", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "4", + "--speculative-eagle-topk", + "3", + "--speculative-num-draft-tokens", + "4", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_2k.jsonl", + "dataset_slug": "throughput_2k", + "run_slug": "206-mtp-s4-k3-d4-throughput_2k" + }, + { + "index": 207, + "variant_name": "mtp-s4-k3-d4", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "4", + "--speculative-eagle-topk", + "3", + "--speculative-num-draft-tokens", + "4", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_32k.jsonl", + "dataset_slug": "throughput_32k", + "run_slug": "207-mtp-s4-k3-d4-throughput_32k" + }, + { + "index": 208, + "variant_name": "mtp-s4-k3-d4", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "4", + "--speculative-eagle-topk", + "3", + "--speculative-num-draft-tokens", + "4", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_8k.jsonl", + "dataset_slug": "throughput_8k", + "run_slug": "208-mtp-s4-k3-d4-throughput_8k" + }, + { + "index": 209, + "variant_name": "mtp-s4-k3-d4", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "4", + "--speculative-eagle-topk", + "3", + "--speculative-num-draft-tokens", + "4", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/json_mode_eval/jsonl/train.jsonl", + "dataset_slug": "train", + "run_slug": "209-mtp-s4-k3-d4-train" + }, + { + "index": 210, + "variant_name": "mtp-s4-k3-d5", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "4", + "--speculative-eagle-topk", + "3", + "--speculative-num-draft-tokens", + "5", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_16k.jsonl", + "dataset_slug": "throughput_16k", + "run_slug": "210-mtp-s4-k3-d5-throughput_16k" + }, + { + "index": 211, + "variant_name": "mtp-s4-k3-d5", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "4", + "--speculative-eagle-topk", + "3", + "--speculative-num-draft-tokens", + "5", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_1k.jsonl", + "dataset_slug": "throughput_1k", + "run_slug": "211-mtp-s4-k3-d5-throughput_1k" + }, + { + "index": 212, + "variant_name": "mtp-s4-k3-d5", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "4", + "--speculative-eagle-topk", + "3", + "--speculative-num-draft-tokens", + "5", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_2k.jsonl", + "dataset_slug": "throughput_2k", + "run_slug": "212-mtp-s4-k3-d5-throughput_2k" + }, + { + "index": 213, + "variant_name": "mtp-s4-k3-d5", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "4", + "--speculative-eagle-topk", + "3", + "--speculative-num-draft-tokens", + "5", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_32k.jsonl", + "dataset_slug": "throughput_32k", + "run_slug": "213-mtp-s4-k3-d5-throughput_32k" + }, + { + "index": 214, + "variant_name": "mtp-s4-k3-d5", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "4", + "--speculative-eagle-topk", + "3", + "--speculative-num-draft-tokens", + "5", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_8k.jsonl", + "dataset_slug": "throughput_8k", + "run_slug": "214-mtp-s4-k3-d5-throughput_8k" + }, + { + "index": 215, + "variant_name": "mtp-s4-k3-d5", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "4", + "--speculative-eagle-topk", + "3", + "--speculative-num-draft-tokens", + "5", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/json_mode_eval/jsonl/train.jsonl", + "dataset_slug": "train", + "run_slug": "215-mtp-s4-k3-d5-train" + }, + { + "index": 216, + "variant_name": "mtp-s4-k3-d6", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "4", + "--speculative-eagle-topk", + "3", + "--speculative-num-draft-tokens", + "6", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_16k.jsonl", + "dataset_slug": "throughput_16k", + "run_slug": "216-mtp-s4-k3-d6-throughput_16k" + }, + { + "index": 217, + "variant_name": "mtp-s4-k3-d6", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "4", + "--speculative-eagle-topk", + "3", + "--speculative-num-draft-tokens", + "6", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_1k.jsonl", + "dataset_slug": "throughput_1k", + "run_slug": "217-mtp-s4-k3-d6-throughput_1k" + }, + { + "index": 218, + "variant_name": "mtp-s4-k3-d6", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "4", + "--speculative-eagle-topk", + "3", + "--speculative-num-draft-tokens", + "6", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_2k.jsonl", + "dataset_slug": "throughput_2k", + "run_slug": "218-mtp-s4-k3-d6-throughput_2k" + }, + { + "index": 219, + "variant_name": "mtp-s4-k3-d6", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "4", + "--speculative-eagle-topk", + "3", + "--speculative-num-draft-tokens", + "6", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_32k.jsonl", + "dataset_slug": "throughput_32k", + "run_slug": "219-mtp-s4-k3-d6-throughput_32k" + }, + { + "index": 220, + "variant_name": "mtp-s4-k3-d6", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "4", + "--speculative-eagle-topk", + "3", + "--speculative-num-draft-tokens", + "6", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_8k.jsonl", + "dataset_slug": "throughput_8k", + "run_slug": "220-mtp-s4-k3-d6-throughput_8k" + }, + { + "index": 221, + "variant_name": "mtp-s4-k3-d6", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "4", + "--speculative-eagle-topk", + "3", + "--speculative-num-draft-tokens", + "6", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/json_mode_eval/jsonl/train.jsonl", + "dataset_slug": "train", + "run_slug": "221-mtp-s4-k3-d6-train" + }, + { + "index": 222, + "variant_name": "mtp-s5-k1-d3", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "5", + "--speculative-eagle-topk", + "1", + "--speculative-num-draft-tokens", + "3", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_16k.jsonl", + "dataset_slug": "throughput_16k", + "run_slug": "222-mtp-s5-k1-d3-throughput_16k" + }, + { + "index": 223, + "variant_name": "mtp-s5-k1-d3", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "5", + "--speculative-eagle-topk", + "1", + "--speculative-num-draft-tokens", + "3", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_1k.jsonl", + "dataset_slug": "throughput_1k", + "run_slug": "223-mtp-s5-k1-d3-throughput_1k" + }, + { + "index": 224, + "variant_name": "mtp-s5-k1-d3", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "5", + "--speculative-eagle-topk", + "1", + "--speculative-num-draft-tokens", + "3", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_2k.jsonl", + "dataset_slug": "throughput_2k", + "run_slug": "224-mtp-s5-k1-d3-throughput_2k" + }, + { + "index": 225, + "variant_name": "mtp-s5-k1-d3", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "5", + "--speculative-eagle-topk", + "1", + "--speculative-num-draft-tokens", + "3", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_32k.jsonl", + "dataset_slug": "throughput_32k", + "run_slug": "225-mtp-s5-k1-d3-throughput_32k" + }, + { + "index": 226, + "variant_name": "mtp-s5-k1-d3", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "5", + "--speculative-eagle-topk", + "1", + "--speculative-num-draft-tokens", + "3", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_8k.jsonl", + "dataset_slug": "throughput_8k", + "run_slug": "226-mtp-s5-k1-d3-throughput_8k" + }, + { + "index": 227, + "variant_name": "mtp-s5-k1-d3", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "5", + "--speculative-eagle-topk", + "1", + "--speculative-num-draft-tokens", + "3", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/json_mode_eval/jsonl/train.jsonl", + "dataset_slug": "train", + "run_slug": "227-mtp-s5-k1-d3-train" + }, + { + "index": 228, + "variant_name": "mtp-s5-k1-d4", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "5", + "--speculative-eagle-topk", + "1", + "--speculative-num-draft-tokens", + "4", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_16k.jsonl", + "dataset_slug": "throughput_16k", + "run_slug": "228-mtp-s5-k1-d4-throughput_16k" + }, + { + "index": 229, + "variant_name": "mtp-s5-k1-d4", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "5", + "--speculative-eagle-topk", + "1", + "--speculative-num-draft-tokens", + "4", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_1k.jsonl", + "dataset_slug": "throughput_1k", + "run_slug": "229-mtp-s5-k1-d4-throughput_1k" + }, + { + "index": 230, + "variant_name": "mtp-s5-k1-d4", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "5", + "--speculative-eagle-topk", + "1", + "--speculative-num-draft-tokens", + "4", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_2k.jsonl", + "dataset_slug": "throughput_2k", + "run_slug": "230-mtp-s5-k1-d4-throughput_2k" + }, + { + "index": 231, + "variant_name": "mtp-s5-k1-d4", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "5", + "--speculative-eagle-topk", + "1", + "--speculative-num-draft-tokens", + "4", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_32k.jsonl", + "dataset_slug": "throughput_32k", + "run_slug": "231-mtp-s5-k1-d4-throughput_32k" + }, + { + "index": 232, + "variant_name": "mtp-s5-k1-d4", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "5", + "--speculative-eagle-topk", + "1", + "--speculative-num-draft-tokens", + "4", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_8k.jsonl", + "dataset_slug": "throughput_8k", + "run_slug": "232-mtp-s5-k1-d4-throughput_8k" + }, + { + "index": 233, + "variant_name": "mtp-s5-k1-d4", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "5", + "--speculative-eagle-topk", + "1", + "--speculative-num-draft-tokens", + "4", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/json_mode_eval/jsonl/train.jsonl", + "dataset_slug": "train", + "run_slug": "233-mtp-s5-k1-d4-train" + }, + { + "index": 234, + "variant_name": "mtp-s5-k1-d5", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "5", + "--speculative-eagle-topk", + "1", + "--speculative-num-draft-tokens", + "5", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_16k.jsonl", + "dataset_slug": "throughput_16k", + "run_slug": "234-mtp-s5-k1-d5-throughput_16k" + }, + { + "index": 235, + "variant_name": "mtp-s5-k1-d5", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "5", + "--speculative-eagle-topk", + "1", + "--speculative-num-draft-tokens", + "5", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_1k.jsonl", + "dataset_slug": "throughput_1k", + "run_slug": "235-mtp-s5-k1-d5-throughput_1k" + }, + { + "index": 236, + "variant_name": "mtp-s5-k1-d5", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "5", + "--speculative-eagle-topk", + "1", + "--speculative-num-draft-tokens", + "5", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_2k.jsonl", + "dataset_slug": "throughput_2k", + "run_slug": "236-mtp-s5-k1-d5-throughput_2k" + }, + { + "index": 237, + "variant_name": "mtp-s5-k1-d5", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "5", + "--speculative-eagle-topk", + "1", + "--speculative-num-draft-tokens", + "5", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_32k.jsonl", + "dataset_slug": "throughput_32k", + "run_slug": "237-mtp-s5-k1-d5-throughput_32k" + }, + { + "index": 238, + "variant_name": "mtp-s5-k1-d5", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "5", + "--speculative-eagle-topk", + "1", + "--speculative-num-draft-tokens", + "5", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_8k.jsonl", + "dataset_slug": "throughput_8k", + "run_slug": "238-mtp-s5-k1-d5-throughput_8k" + }, + { + "index": 239, + "variant_name": "mtp-s5-k1-d5", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "5", + "--speculative-eagle-topk", + "1", + "--speculative-num-draft-tokens", + "5", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/json_mode_eval/jsonl/train.jsonl", + "dataset_slug": "train", + "run_slug": "239-mtp-s5-k1-d5-train" + }, + { + "index": 240, + "variant_name": "mtp-s5-k1-d6", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "5", + "--speculative-eagle-topk", + "1", + "--speculative-num-draft-tokens", + "6", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_16k.jsonl", + "dataset_slug": "throughput_16k", + "run_slug": "240-mtp-s5-k1-d6-throughput_16k" + }, + { + "index": 241, + "variant_name": "mtp-s5-k1-d6", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "5", + "--speculative-eagle-topk", + "1", + "--speculative-num-draft-tokens", + "6", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_1k.jsonl", + "dataset_slug": "throughput_1k", + "run_slug": "241-mtp-s5-k1-d6-throughput_1k" + }, + { + "index": 242, + "variant_name": "mtp-s5-k1-d6", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "5", + "--speculative-eagle-topk", + "1", + "--speculative-num-draft-tokens", + "6", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_2k.jsonl", + "dataset_slug": "throughput_2k", + "run_slug": "242-mtp-s5-k1-d6-throughput_2k" + }, + { + "index": 243, + "variant_name": "mtp-s5-k1-d6", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "5", + "--speculative-eagle-topk", + "1", + "--speculative-num-draft-tokens", + "6", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_32k.jsonl", + "dataset_slug": "throughput_32k", + "run_slug": "243-mtp-s5-k1-d6-throughput_32k" + }, + { + "index": 244, + "variant_name": "mtp-s5-k1-d6", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "5", + "--speculative-eagle-topk", + "1", + "--speculative-num-draft-tokens", + "6", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_8k.jsonl", + "dataset_slug": "throughput_8k", + "run_slug": "244-mtp-s5-k1-d6-throughput_8k" + }, + { + "index": 245, + "variant_name": "mtp-s5-k1-d6", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "5", + "--speculative-eagle-topk", + "1", + "--speculative-num-draft-tokens", + "6", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/json_mode_eval/jsonl/train.jsonl", + "dataset_slug": "train", + "run_slug": "245-mtp-s5-k1-d6-train" + }, + { + "index": 246, + "variant_name": "mtp-s5-k2-d3", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "5", + "--speculative-eagle-topk", + "2", + "--speculative-num-draft-tokens", + "3", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_16k.jsonl", + "dataset_slug": "throughput_16k", + "run_slug": "246-mtp-s5-k2-d3-throughput_16k" + }, + { + "index": 247, + "variant_name": "mtp-s5-k2-d3", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "5", + "--speculative-eagle-topk", + "2", + "--speculative-num-draft-tokens", + "3", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_1k.jsonl", + "dataset_slug": "throughput_1k", + "run_slug": "247-mtp-s5-k2-d3-throughput_1k" + }, + { + "index": 248, + "variant_name": "mtp-s5-k2-d3", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "5", + "--speculative-eagle-topk", + "2", + "--speculative-num-draft-tokens", + "3", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_2k.jsonl", + "dataset_slug": "throughput_2k", + "run_slug": "248-mtp-s5-k2-d3-throughput_2k" + }, + { + "index": 249, + "variant_name": "mtp-s5-k2-d3", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "5", + "--speculative-eagle-topk", + "2", + "--speculative-num-draft-tokens", + "3", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_32k.jsonl", + "dataset_slug": "throughput_32k", + "run_slug": "249-mtp-s5-k2-d3-throughput_32k" + }, + { + "index": 250, + "variant_name": "mtp-s5-k2-d3", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "5", + "--speculative-eagle-topk", + "2", + "--speculative-num-draft-tokens", + "3", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_8k.jsonl", + "dataset_slug": "throughput_8k", + "run_slug": "250-mtp-s5-k2-d3-throughput_8k" + }, + { + "index": 251, + "variant_name": "mtp-s5-k2-d3", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "5", + "--speculative-eagle-topk", + "2", + "--speculative-num-draft-tokens", + "3", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/json_mode_eval/jsonl/train.jsonl", + "dataset_slug": "train", + "run_slug": "251-mtp-s5-k2-d3-train" + }, + { + "index": 252, + "variant_name": "mtp-s5-k2-d4", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "5", + "--speculative-eagle-topk", + "2", + "--speculative-num-draft-tokens", + "4", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_16k.jsonl", + "dataset_slug": "throughput_16k", + "run_slug": "252-mtp-s5-k2-d4-throughput_16k" + }, + { + "index": 253, + "variant_name": "mtp-s5-k2-d4", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "5", + "--speculative-eagle-topk", + "2", + "--speculative-num-draft-tokens", + "4", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_1k.jsonl", + "dataset_slug": "throughput_1k", + "run_slug": "253-mtp-s5-k2-d4-throughput_1k" + }, + { + "index": 254, + "variant_name": "mtp-s5-k2-d4", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "5", + "--speculative-eagle-topk", + "2", + "--speculative-num-draft-tokens", + "4", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_2k.jsonl", + "dataset_slug": "throughput_2k", + "run_slug": "254-mtp-s5-k2-d4-throughput_2k" + }, + { + "index": 255, + "variant_name": "mtp-s5-k2-d4", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "5", + "--speculative-eagle-topk", + "2", + "--speculative-num-draft-tokens", + "4", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_32k.jsonl", + "dataset_slug": "throughput_32k", + "run_slug": "255-mtp-s5-k2-d4-throughput_32k" + }, + { + "index": 256, + "variant_name": "mtp-s5-k2-d4", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "5", + "--speculative-eagle-topk", + "2", + "--speculative-num-draft-tokens", + "4", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_8k.jsonl", + "dataset_slug": "throughput_8k", + "run_slug": "256-mtp-s5-k2-d4-throughput_8k" + }, + { + "index": 257, + "variant_name": "mtp-s5-k2-d4", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "5", + "--speculative-eagle-topk", + "2", + "--speculative-num-draft-tokens", + "4", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/json_mode_eval/jsonl/train.jsonl", + "dataset_slug": "train", + "run_slug": "257-mtp-s5-k2-d4-train" + }, + { + "index": 258, + "variant_name": "mtp-s5-k2-d5", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "5", + "--speculative-eagle-topk", + "2", + "--speculative-num-draft-tokens", + "5", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_16k.jsonl", + "dataset_slug": "throughput_16k", + "run_slug": "258-mtp-s5-k2-d5-throughput_16k" + }, + { + "index": 259, + "variant_name": "mtp-s5-k2-d5", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "5", + "--speculative-eagle-topk", + "2", + "--speculative-num-draft-tokens", + "5", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_1k.jsonl", + "dataset_slug": "throughput_1k", + "run_slug": "259-mtp-s5-k2-d5-throughput_1k" + }, + { + "index": 260, + "variant_name": "mtp-s5-k2-d5", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "5", + "--speculative-eagle-topk", + "2", + "--speculative-num-draft-tokens", + "5", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_2k.jsonl", + "dataset_slug": "throughput_2k", + "run_slug": "260-mtp-s5-k2-d5-throughput_2k" + }, + { + "index": 261, + "variant_name": "mtp-s5-k2-d5", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "5", + "--speculative-eagle-topk", + "2", + "--speculative-num-draft-tokens", + "5", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_32k.jsonl", + "dataset_slug": "throughput_32k", + "run_slug": "261-mtp-s5-k2-d5-throughput_32k" + }, + { + "index": 262, + "variant_name": "mtp-s5-k2-d5", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "5", + "--speculative-eagle-topk", + "2", + "--speculative-num-draft-tokens", + "5", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_8k.jsonl", + "dataset_slug": "throughput_8k", + "run_slug": "262-mtp-s5-k2-d5-throughput_8k" + }, + { + "index": 263, + "variant_name": "mtp-s5-k2-d5", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "5", + "--speculative-eagle-topk", + "2", + "--speculative-num-draft-tokens", + "5", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/json_mode_eval/jsonl/train.jsonl", + "dataset_slug": "train", + "run_slug": "263-mtp-s5-k2-d5-train" + }, + { + "index": 264, + "variant_name": "mtp-s5-k2-d6", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "5", + "--speculative-eagle-topk", + "2", + "--speculative-num-draft-tokens", + "6", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_16k.jsonl", + "dataset_slug": "throughput_16k", + "run_slug": "264-mtp-s5-k2-d6-throughput_16k" + }, + { + "index": 265, + "variant_name": "mtp-s5-k2-d6", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "5", + "--speculative-eagle-topk", + "2", + "--speculative-num-draft-tokens", + "6", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_1k.jsonl", + "dataset_slug": "throughput_1k", + "run_slug": "265-mtp-s5-k2-d6-throughput_1k" + }, + { + "index": 266, + "variant_name": "mtp-s5-k2-d6", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "5", + "--speculative-eagle-topk", + "2", + "--speculative-num-draft-tokens", + "6", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_2k.jsonl", + "dataset_slug": "throughput_2k", + "run_slug": "266-mtp-s5-k2-d6-throughput_2k" + }, + { + "index": 267, + "variant_name": "mtp-s5-k2-d6", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "5", + "--speculative-eagle-topk", + "2", + "--speculative-num-draft-tokens", + "6", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_32k.jsonl", + "dataset_slug": "throughput_32k", + "run_slug": "267-mtp-s5-k2-d6-throughput_32k" + }, + { + "index": 268, + "variant_name": "mtp-s5-k2-d6", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "5", + "--speculative-eagle-topk", + "2", + "--speculative-num-draft-tokens", + "6", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_8k.jsonl", + "dataset_slug": "throughput_8k", + "run_slug": "268-mtp-s5-k2-d6-throughput_8k" + }, + { + "index": 269, + "variant_name": "mtp-s5-k2-d6", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "5", + "--speculative-eagle-topk", + "2", + "--speculative-num-draft-tokens", + "6", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/json_mode_eval/jsonl/train.jsonl", + "dataset_slug": "train", + "run_slug": "269-mtp-s5-k2-d6-train" + }, + { + "index": 270, + "variant_name": "mtp-s5-k3-d3", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "5", + "--speculative-eagle-topk", + "3", + "--speculative-num-draft-tokens", + "3", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_16k.jsonl", + "dataset_slug": "throughput_16k", + "run_slug": "270-mtp-s5-k3-d3-throughput_16k" + }, + { + "index": 271, + "variant_name": "mtp-s5-k3-d3", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "5", + "--speculative-eagle-topk", + "3", + "--speculative-num-draft-tokens", + "3", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_1k.jsonl", + "dataset_slug": "throughput_1k", + "run_slug": "271-mtp-s5-k3-d3-throughput_1k" + }, + { + "index": 272, + "variant_name": "mtp-s5-k3-d3", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "5", + "--speculative-eagle-topk", + "3", + "--speculative-num-draft-tokens", + "3", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_2k.jsonl", + "dataset_slug": "throughput_2k", + "run_slug": "272-mtp-s5-k3-d3-throughput_2k" + }, + { + "index": 273, + "variant_name": "mtp-s5-k3-d3", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "5", + "--speculative-eagle-topk", + "3", + "--speculative-num-draft-tokens", + "3", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_32k.jsonl", + "dataset_slug": "throughput_32k", + "run_slug": "273-mtp-s5-k3-d3-throughput_32k" + }, + { + "index": 274, + "variant_name": "mtp-s5-k3-d3", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "5", + "--speculative-eagle-topk", + "3", + "--speculative-num-draft-tokens", + "3", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_8k.jsonl", + "dataset_slug": "throughput_8k", + "run_slug": "274-mtp-s5-k3-d3-throughput_8k" + }, + { + "index": 275, + "variant_name": "mtp-s5-k3-d3", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "5", + "--speculative-eagle-topk", + "3", + "--speculative-num-draft-tokens", + "3", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/json_mode_eval/jsonl/train.jsonl", + "dataset_slug": "train", + "run_slug": "275-mtp-s5-k3-d3-train" + }, + { + "index": 276, + "variant_name": "mtp-s5-k3-d4", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "5", + "--speculative-eagle-topk", + "3", + "--speculative-num-draft-tokens", + "4", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_16k.jsonl", + "dataset_slug": "throughput_16k", + "run_slug": "276-mtp-s5-k3-d4-throughput_16k" + }, + { + "index": 277, + "variant_name": "mtp-s5-k3-d4", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "5", + "--speculative-eagle-topk", + "3", + "--speculative-num-draft-tokens", + "4", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_1k.jsonl", + "dataset_slug": "throughput_1k", + "run_slug": "277-mtp-s5-k3-d4-throughput_1k" + }, + { + "index": 278, + "variant_name": "mtp-s5-k3-d4", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "5", + "--speculative-eagle-topk", + "3", + "--speculative-num-draft-tokens", + "4", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_2k.jsonl", + "dataset_slug": "throughput_2k", + "run_slug": "278-mtp-s5-k3-d4-throughput_2k" + }, + { + "index": 279, + "variant_name": "mtp-s5-k3-d4", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "5", + "--speculative-eagle-topk", + "3", + "--speculative-num-draft-tokens", + "4", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_32k.jsonl", + "dataset_slug": "throughput_32k", + "run_slug": "279-mtp-s5-k3-d4-throughput_32k" + }, + { + "index": 280, + "variant_name": "mtp-s5-k3-d4", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "5", + "--speculative-eagle-topk", + "3", + "--speculative-num-draft-tokens", + "4", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_8k.jsonl", + "dataset_slug": "throughput_8k", + "run_slug": "280-mtp-s5-k3-d4-throughput_8k" + }, + { + "index": 281, + "variant_name": "mtp-s5-k3-d4", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "5", + "--speculative-eagle-topk", + "3", + "--speculative-num-draft-tokens", + "4", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/json_mode_eval/jsonl/train.jsonl", + "dataset_slug": "train", + "run_slug": "281-mtp-s5-k3-d4-train" + }, + { + "index": 282, + "variant_name": "mtp-s5-k3-d5", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "5", + "--speculative-eagle-topk", + "3", + "--speculative-num-draft-tokens", + "5", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_16k.jsonl", + "dataset_slug": "throughput_16k", + "run_slug": "282-mtp-s5-k3-d5-throughput_16k" + }, + { + "index": 283, + "variant_name": "mtp-s5-k3-d5", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "5", + "--speculative-eagle-topk", + "3", + "--speculative-num-draft-tokens", + "5", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_1k.jsonl", + "dataset_slug": "throughput_1k", + "run_slug": "283-mtp-s5-k3-d5-throughput_1k" + }, + { + "index": 284, + "variant_name": "mtp-s5-k3-d5", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "5", + "--speculative-eagle-topk", + "3", + "--speculative-num-draft-tokens", + "5", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_2k.jsonl", + "dataset_slug": "throughput_2k", + "run_slug": "284-mtp-s5-k3-d5-throughput_2k" + }, + { + "index": 285, + "variant_name": "mtp-s5-k3-d5", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "5", + "--speculative-eagle-topk", + "3", + "--speculative-num-draft-tokens", + "5", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_32k.jsonl", + "dataset_slug": "throughput_32k", + "run_slug": "285-mtp-s5-k3-d5-throughput_32k" + }, + { + "index": 286, + "variant_name": "mtp-s5-k3-d5", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "5", + "--speculative-eagle-topk", + "3", + "--speculative-num-draft-tokens", + "5", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_8k.jsonl", + "dataset_slug": "throughput_8k", + "run_slug": "286-mtp-s5-k3-d5-throughput_8k" + }, + { + "index": 287, + "variant_name": "mtp-s5-k3-d5", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "5", + "--speculative-eagle-topk", + "3", + "--speculative-num-draft-tokens", + "5", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/json_mode_eval/jsonl/train.jsonl", + "dataset_slug": "train", + "run_slug": "287-mtp-s5-k3-d5-train" + }, + { + "index": 288, + "variant_name": "mtp-s5-k3-d6", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "5", + "--speculative-eagle-topk", + "3", + "--speculative-num-draft-tokens", + "6", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_16k.jsonl", + "dataset_slug": "throughput_16k", + "run_slug": "288-mtp-s5-k3-d6-throughput_16k" + }, + { + "index": 289, + "variant_name": "mtp-s5-k3-d6", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "5", + "--speculative-eagle-topk", + "3", + "--speculative-num-draft-tokens", + "6", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_1k.jsonl", + "dataset_slug": "throughput_1k", + "run_slug": "289-mtp-s5-k3-d6-throughput_1k" + }, + { + "index": 290, + "variant_name": "mtp-s5-k3-d6", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "5", + "--speculative-eagle-topk", + "3", + "--speculative-num-draft-tokens", + "6", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_2k.jsonl", + "dataset_slug": "throughput_2k", + "run_slug": "290-mtp-s5-k3-d6-throughput_2k" + }, + { + "index": 291, + "variant_name": "mtp-s5-k3-d6", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "5", + "--speculative-eagle-topk", + "3", + "--speculative-num-draft-tokens", + "6", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_32k.jsonl", + "dataset_slug": "throughput_32k", + "run_slug": "291-mtp-s5-k3-d6-throughput_32k" + }, + { + "index": 292, + "variant_name": "mtp-s5-k3-d6", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "5", + "--speculative-eagle-topk", + "3", + "--speculative-num-draft-tokens", + "6", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/speed_bench/jsonl/throughput_8k.jsonl", + "dataset_slug": "throughput_8k", + "run_slug": "292-mtp-s5-k3-d6-throughput_8k" + }, + { + "index": 293, + "variant_name": "mtp-s5-k3-d6", + "variant_extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "5", + "--speculative-eagle-topk", + "3", + "--speculative-num-draft-tokens", + "6", + "--mamba-scheduler-strategy", + "extra_buffer" + ], + "dataset_path": "examples/json_mode_eval/jsonl/train.jsonl", + "dataset_slug": "train", + "run_slug": "293-mtp-s5-k3-d6-train" + } + ] + variants.json: |- + [ + { + "name": "baseline", + "extra_args": [ + "--mamba-scheduler-strategy", + "extra_buffer" + ] + }, + { + "name": "mtp-s2-k1-d3", + "extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "2", + "--speculative-eagle-topk", + "1", + "--speculative-num-draft-tokens", + "3", + "--mamba-scheduler-strategy", + "extra_buffer" + ] + }, + { + "name": "mtp-s2-k1-d4", + "extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "2", + "--speculative-eagle-topk", + "1", + "--speculative-num-draft-tokens", + "4", + "--mamba-scheduler-strategy", + "extra_buffer" + ] + }, + { + "name": "mtp-s2-k1-d5", + "extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "2", + "--speculative-eagle-topk", + "1", + "--speculative-num-draft-tokens", + "5", + "--mamba-scheduler-strategy", + "extra_buffer" + ] + }, + { + "name": "mtp-s2-k1-d6", + "extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "2", + "--speculative-eagle-topk", + "1", + "--speculative-num-draft-tokens", + "6", + "--mamba-scheduler-strategy", + "extra_buffer" + ] + }, + { + "name": "mtp-s2-k2-d3", + "extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "2", + "--speculative-eagle-topk", + "2", + "--speculative-num-draft-tokens", + "3", + "--mamba-scheduler-strategy", + "extra_buffer" + ] + }, + { + "name": "mtp-s2-k2-d4", + "extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "2", + "--speculative-eagle-topk", + "2", + "--speculative-num-draft-tokens", + "4", + "--mamba-scheduler-strategy", + "extra_buffer" + ] + }, + { + "name": "mtp-s2-k2-d5", + "extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "2", + "--speculative-eagle-topk", + "2", + "--speculative-num-draft-tokens", + "5", + "--mamba-scheduler-strategy", + "extra_buffer" + ] + }, + { + "name": "mtp-s2-k2-d6", + "extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "2", + "--speculative-eagle-topk", + "2", + "--speculative-num-draft-tokens", + "6", + "--mamba-scheduler-strategy", + "extra_buffer" + ] + }, + { + "name": "mtp-s2-k3-d3", + "extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "2", + "--speculative-eagle-topk", + "3", + "--speculative-num-draft-tokens", + "3", + "--mamba-scheduler-strategy", + "extra_buffer" + ] + }, + { + "name": "mtp-s2-k3-d4", + "extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "2", + "--speculative-eagle-topk", + "3", + "--speculative-num-draft-tokens", + "4", + "--mamba-scheduler-strategy", + "extra_buffer" + ] + }, + { + "name": "mtp-s2-k3-d5", + "extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "2", + "--speculative-eagle-topk", + "3", + "--speculative-num-draft-tokens", + "5", + "--mamba-scheduler-strategy", + "extra_buffer" + ] + }, + { + "name": "mtp-s2-k3-d6", + "extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "2", + "--speculative-eagle-topk", + "3", + "--speculative-num-draft-tokens", + "6", + "--mamba-scheduler-strategy", + "extra_buffer" + ] + }, + { + "name": "mtp-s3-k1-d3", + "extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "3", + "--speculative-eagle-topk", + "1", + "--speculative-num-draft-tokens", + "3", + "--mamba-scheduler-strategy", + "extra_buffer" + ] + }, + { + "name": "mtp-s3-k1-d4", + "extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "3", + "--speculative-eagle-topk", + "1", + "--speculative-num-draft-tokens", + "4", + "--mamba-scheduler-strategy", + "extra_buffer" + ] + }, + { + "name": "mtp-s3-k1-d5", + "extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "3", + "--speculative-eagle-topk", + "1", + "--speculative-num-draft-tokens", + "5", + "--mamba-scheduler-strategy", + "extra_buffer" + ] + }, + { + "name": "mtp-s3-k1-d6", + "extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "3", + "--speculative-eagle-topk", + "1", + "--speculative-num-draft-tokens", + "6", + "--mamba-scheduler-strategy", + "extra_buffer" + ] + }, + { + "name": "mtp-s3-k2-d3", + "extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "3", + "--speculative-eagle-topk", + "2", + "--speculative-num-draft-tokens", + "3", + "--mamba-scheduler-strategy", + "extra_buffer" + ] + }, + { + "name": "mtp-s3-k2-d4", + "extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "3", + "--speculative-eagle-topk", + "2", + "--speculative-num-draft-tokens", + "4", + "--mamba-scheduler-strategy", + "extra_buffer" + ] + }, + { + "name": "mtp-s3-k2-d5", + "extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "3", + "--speculative-eagle-topk", + "2", + "--speculative-num-draft-tokens", + "5", + "--mamba-scheduler-strategy", + "extra_buffer" + ] + }, + { + "name": "mtp-s3-k2-d6", + "extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "3", + "--speculative-eagle-topk", + "2", + "--speculative-num-draft-tokens", + "6", + "--mamba-scheduler-strategy", + "extra_buffer" + ] + }, + { + "name": "mtp-s3-k3-d3", + "extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "3", + "--speculative-eagle-topk", + "3", + "--speculative-num-draft-tokens", + "3", + "--mamba-scheduler-strategy", + "extra_buffer" + ] + }, + { + "name": "mtp-s3-k3-d4", + "extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "3", + "--speculative-eagle-topk", + "3", + "--speculative-num-draft-tokens", + "4", + "--mamba-scheduler-strategy", + "extra_buffer" + ] + }, + { + "name": "mtp-s3-k3-d5", + "extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "3", + "--speculative-eagle-topk", + "3", + "--speculative-num-draft-tokens", + "5", + "--mamba-scheduler-strategy", + "extra_buffer" + ] + }, + { + "name": "mtp-s3-k3-d6", + "extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "3", + "--speculative-eagle-topk", + "3", + "--speculative-num-draft-tokens", + "6", + "--mamba-scheduler-strategy", + "extra_buffer" + ] + }, + { + "name": "mtp-s4-k1-d3", + "extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "4", + "--speculative-eagle-topk", + "1", + "--speculative-num-draft-tokens", + "3", + "--mamba-scheduler-strategy", + "extra_buffer" + ] + }, + { + "name": "mtp-s4-k1-d4", + "extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "4", + "--speculative-eagle-topk", + "1", + "--speculative-num-draft-tokens", + "4", + "--mamba-scheduler-strategy", + "extra_buffer" + ] + }, + { + "name": "mtp-s4-k1-d5", + "extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "4", + "--speculative-eagle-topk", + "1", + "--speculative-num-draft-tokens", + "5", + "--mamba-scheduler-strategy", + "extra_buffer" + ] + }, + { + "name": "mtp-s4-k1-d6", + "extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "4", + "--speculative-eagle-topk", + "1", + "--speculative-num-draft-tokens", + "6", + "--mamba-scheduler-strategy", + "extra_buffer" + ] + }, + { + "name": "mtp-s4-k2-d3", + "extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "4", + "--speculative-eagle-topk", + "2", + "--speculative-num-draft-tokens", + "3", + "--mamba-scheduler-strategy", + "extra_buffer" + ] + }, + { + "name": "mtp-s4-k2-d4", + "extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "4", + "--speculative-eagle-topk", + "2", + "--speculative-num-draft-tokens", + "4", + "--mamba-scheduler-strategy", + "extra_buffer" + ] + }, + { + "name": "mtp-s4-k2-d5", + "extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "4", + "--speculative-eagle-topk", + "2", + "--speculative-num-draft-tokens", + "5", + "--mamba-scheduler-strategy", + "extra_buffer" + ] + }, + { + "name": "mtp-s4-k2-d6", + "extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "4", + "--speculative-eagle-topk", + "2", + "--speculative-num-draft-tokens", + "6", + "--mamba-scheduler-strategy", + "extra_buffer" + ] + }, + { + "name": "mtp-s4-k3-d3", + "extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "4", + "--speculative-eagle-topk", + "3", + "--speculative-num-draft-tokens", + "3", + "--mamba-scheduler-strategy", + "extra_buffer" + ] + }, + { + "name": "mtp-s4-k3-d4", + "extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "4", + "--speculative-eagle-topk", + "3", + "--speculative-num-draft-tokens", + "4", + "--mamba-scheduler-strategy", + "extra_buffer" + ] + }, + { + "name": "mtp-s4-k3-d5", + "extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "4", + "--speculative-eagle-topk", + "3", + "--speculative-num-draft-tokens", + "5", + "--mamba-scheduler-strategy", + "extra_buffer" + ] + }, + { + "name": "mtp-s4-k3-d6", + "extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "4", + "--speculative-eagle-topk", + "3", + "--speculative-num-draft-tokens", + "6", + "--mamba-scheduler-strategy", + "extra_buffer" + ] + }, + { + "name": "mtp-s5-k1-d3", + "extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "5", + "--speculative-eagle-topk", + "1", + "--speculative-num-draft-tokens", + "3", + "--mamba-scheduler-strategy", + "extra_buffer" + ] + }, + { + "name": "mtp-s5-k1-d4", + "extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "5", + "--speculative-eagle-topk", + "1", + "--speculative-num-draft-tokens", + "4", + "--mamba-scheduler-strategy", + "extra_buffer" + ] + }, + { + "name": "mtp-s5-k1-d5", + "extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "5", + "--speculative-eagle-topk", + "1", + "--speculative-num-draft-tokens", + "5", + "--mamba-scheduler-strategy", + "extra_buffer" + ] + }, + { + "name": "mtp-s5-k1-d6", + "extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "5", + "--speculative-eagle-topk", + "1", + "--speculative-num-draft-tokens", + "6", + "--mamba-scheduler-strategy", + "extra_buffer" + ] + }, + { + "name": "mtp-s5-k2-d3", + "extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "5", + "--speculative-eagle-topk", + "2", + "--speculative-num-draft-tokens", + "3", + "--mamba-scheduler-strategy", + "extra_buffer" + ] + }, + { + "name": "mtp-s5-k2-d4", + "extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "5", + "--speculative-eagle-topk", + "2", + "--speculative-num-draft-tokens", + "4", + "--mamba-scheduler-strategy", + "extra_buffer" + ] + }, + { + "name": "mtp-s5-k2-d5", + "extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "5", + "--speculative-eagle-topk", + "2", + "--speculative-num-draft-tokens", + "5", + "--mamba-scheduler-strategy", + "extra_buffer" + ] + }, + { + "name": "mtp-s5-k2-d6", + "extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "5", + "--speculative-eagle-topk", + "2", + "--speculative-num-draft-tokens", + "6", + "--mamba-scheduler-strategy", + "extra_buffer" + ] + }, + { + "name": "mtp-s5-k3-d3", + "extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "5", + "--speculative-eagle-topk", + "3", + "--speculative-num-draft-tokens", + "3", + "--mamba-scheduler-strategy", + "extra_buffer" + ] + }, + { + "name": "mtp-s5-k3-d4", + "extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "5", + "--speculative-eagle-topk", + "3", + "--speculative-num-draft-tokens", + "4", + "--mamba-scheduler-strategy", + "extra_buffer" + ] + }, + { + "name": "mtp-s5-k3-d5", + "extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "5", + "--speculative-eagle-topk", + "3", + "--speculative-num-draft-tokens", + "5", + "--mamba-scheduler-strategy", + "extra_buffer" + ] + }, + { + "name": "mtp-s5-k3-d6", + "extra_args": [ + "--speculative-algorithm", + "EAGLE", + "--speculative-num-steps", + "5", + "--speculative-eagle-topk", + "3", + "--speculative-num-draft-tokens", + "6", + "--mamba-scheduler-strategy", + "extra_buffer" + ] + } + ] +--- +apiVersion: batch/v1 +kind: Job +metadata: + name: piccolo-k8s-sweep-example-job + namespace: specdec + labels: + app.kubernetes.io/name: batchbench-sweep + app.kubernetes.io/component: benchmark + batchbench.doubleword.ai/sweep-name: piccolo-k8s-sweep-example + annotations: + batchbench.doubleword.ai/image: tytn/batchbench-sglang-sweep:example + batchbench.doubleword.ai/created-at: '2026-04-27T16:56:23+00:00' + batchbench.doubleword.ai/git-sha: 6c8524e0b4ea +spec: + completionMode: Indexed + completions: 294 + parallelism: 1 + backoffLimit: 1 + template: + metadata: + labels: + app.kubernetes.io/name: batchbench-sweep + app.kubernetes.io/component: benchmark + batchbench.doubleword.ai/sweep-name: piccolo-k8s-sweep-example + spec: + restartPolicy: Never + runtimeClassName: nvidia + priorityClassName: research + containers: + - name: benchmark + image: tytn/batchbench-sglang-sweep:example + imagePullPolicy: IfNotPresent + env: + - name: SWEEP_NAME + value: piccolo-k8s-sweep-example + - name: OUTPUT_ROOT + value: /outputs/piccolo-k8s-sweep-example + - name: COMBINATIONS_JSON + value: /config/combinations.json + - name: SHARED_RESULTS_CSV + value: /outputs/piccolo-k8s-sweep-example/results/summary.csv + - name: CSV_LOCK_PATH + value: /outputs/piccolo-k8s-sweep-example/results/summary.csv.lock + - name: REQUEST_TIMEOUT_SECS + value: '6000' + - name: REQUESTS_PER_USER + value: '1' + - name: IMAGE_REF + value: tytn/batchbench-sglang-sweep:example + - name: JOB_COMPLETION_INDEX + valueFrom: + fieldRef: + fieldPath: metadata.annotations['batch.kubernetes.io/job-completion-index'] + - name: POD_NAME + valueFrom: + fieldRef: + fieldPath: metadata.name + - name: NODE_NAME + valueFrom: + fieldRef: + fieldPath: spec.nodeName + - name: SGLANG_USE_CUDA_IPC_TRANSPORT + value: '0' + - name: SGLANG_ENABLE_SPEC_V2 + value: '1' + resources: + limits: + nvidia.com/gpu: '4' + cpu: '64' + memory: 512Gi + requests: + nvidia.com/gpu: '4' + cpu: '64' + memory: 512Gi + volumeMounts: + - name: config + mountPath: /config + readOnly: true + - name: outputs + mountPath: /outputs + - name: cache + mountPath: /root/.cache + - name: dshm + mountPath: /dev/shm + volumes: + - name: config + configMap: + name: piccolo-k8s-sweep-example-config + - name: outputs + hostPath: + path: /mnt/raid/batchbench + type: DirectoryOrCreate + - name: cache + hostPath: + path: /mnt/raid/cache + type: DirectoryOrCreate + - name: dshm + emptyDir: + medium: Memory + sizeLimit: 16Gi diff --git a/docker/Dockerfile.cu126 b/docker/Dockerfile.cu126 deleted file mode 100644 index 422c371..0000000 --- a/docker/Dockerfile.cu126 +++ /dev/null @@ -1,105 +0,0 @@ -# ============================================================ -# Stage 1: NVSHMEM Builder -# ============================================================ -FROM pytorch/pytorch:2.9.0-cuda12.6-cudnn9-devel AS deepep-builder - -# Add rdma libraries and build dependencies -RUN apt-get update && apt-get install -y --no-install-recommends \ - git build-essential ninja-build cmake pkg-config wget \ - librdmacm-dev rdma-core libfabric-dev libibverbs-dev \ - devscripts debhelper fakeroot \ - && rm -rf /var/lib/apt/lists/* - -# Build GDRCopy -RUN cd /tmp && \ - wget https://github.com/NVIDIA/gdrcopy/archive/refs/tags/v2.5.1.tar.gz && \ - tar -xf v2.5.1.tar.gz && \ - cd gdrcopy-2.5.1/packages/ && \ - CUDA=/usr/local/cuda ./build-deb-packages.sh -t -k - -RUN apt-get update && apt-get install -y --no-install-recommends git \ - && dpkg -i /tmp/gdrcopy-2.5.1/packages/libgdrapi_*.deb \ - && rm -rf /var/lib/apt/lists/* - -# Build NVSHMEM - Need GDRCOPY and IBGDA support for DeepEP all2all kernels -RUN set -eux; \ - cd /tmp; \ - wget https://developer.nvidia.com/downloads/assets/secure/nvshmem/nvshmem_src_3.2.5-1.txz; \ - mkdir -p nvshmem_src_3.2.5-1; \ - tar xf nvshmem_src_3.2.5-1.txz -C nvshmem_src_3.2.5-1; \ - cd nvshmem_src_3.2.5-1/nvshmem_src; \ - mkdir -p build; \ - cd build; \ - cmake \ - -DNVSHMEM_PREFIX=/opt/nvshmem-3.2.5 \ - -DCMAKE_CUDA_ARCHITECTURES=90a \ - -DNVSHMEM_MPI_SUPPORT=0 \ - -DNVSHMEM_PMIX_SUPPORT=0 \ - -DNVSHMEM_USE_GDRCOPY=1 \ - -DNVSHMEM_IBGDA_SUPPORT=1 \ - -DNVSHMEM_BUILD_TESTS=1 \ - -DNVSHMEM_BUILD_EXAMPLES=1 \ - -DNVSHMEM_BUILD_HYDRA_LAUNCHER=1 \ - -DNVSHMEM_BUILD_TXZ_PACKAGE=1 \ - -G Ninja \ - ..; \ - ninja; \ - ninja install; \ - rm -rf /tmp/nvshmem_src_3.2.5-1.txz - - - - -# ============================================================ -# Stage 2: vLLM/Python Dependencies (slow, cache separately) -# ============================================================ -FROM pytorch/pytorch:2.9.0-cuda12.6-cudnn9-devel AS python-deps - -RUN apt-get update && apt-get install -y --no-install-recommends curl \ - && rm -rf /var/lib/apt/lists/* - -RUN curl -LsSf https://astral.sh/uv/install.sh | sh \ - && ln -s /root/.local/bin/uv /usr/local/bin/uv - -# flashinfer-cubin installs pre-compiled CUDA kernels for vLLM -# Needed for FP8-MOE models -RUN uv venv /opt/batchbench/.venv && \ - . /opt/batchbench/.venv/bin/activate && \ - uv pip install vllm --torch-backend=auto && \ - uv pip install flashinfer-cubin flashinfer-python -# ============================================================ -# Stage 3: Final Runtime Image -# ============================================================ -FROM pytorch/pytorch:2.9.0-cuda12.6-cudnn9-devel AS runtime - -# Copy built artifacts from builder stages -COPY --from=deepep-builder /opt/nvshmem-3.2.5 /opt/nvshmem-3.2.5 -COPY --from=deepep-builder /tmp/gdrcopy-2.5.1/packages/*.deb /tmp/gdrcopy/ -COPY --from=deepep-builder /opt/conda/lib/python3.11/site-packages/deep_ep* /opt/conda/lib/python3.11/site-packages/ -COPY --from=python-deps /opt/batchbench/.venv /opt/batchbench/.venv -COPY --from=python-deps /root/.local/bin/uv /usr/local/bin/uv - -# Install minimal runtime dependencies -RUN apt-get update && apt-get install -y --no-install-recommends \ - librdmacm-dev rdma-core libfabric-dev libibverbs-dev \ - git curl openssh-server librdmacm1 libibverbs1 libfabric1 \ - && dpkg -i /tmp/gdrcopy/libgdrapi_*.deb \ - && rm -rf /tmp/gdrcopy /var/lib/apt/lists/* - -# NVSHMEM Environment -ENV NVSHMEM_HOME=/opt/nvshmem-3.2.5 -ENV LD_LIBRARY_PATH=${NVSHMEM_HOME}/lib:/usr/local/cuda/lib64:${LD_LIBRARY_PATH} -ENV PATH="/opt/batchbench/.venv/bin:/opt/hydra/bin:/usr/local/cuda/bin:${PATH}" -ENV VLLM_HAS_FLASHINFER_CUBIN=1 - -# DeepEP installation - TODO: pull into the deepep-builder stage -RUN git clone https://github.com/deepseek-ai/DeepEP /deepep && \ - cd /deepep && \ - NVSHMEM_DIR=/opt/nvshmem-3.2.5 python setup.py install - -# SSH configuration -RUN mkdir -p /var/run/sshd /root/.ssh && \ - chmod 700 /root/.ssh && \ - sed -i 's/#PermitRootLogin prohibit-password/PermitRootLogin prohibit-password/' /etc/ssh/sshd_config && \ - sed -i 's@session\s*required\s*pam_loginuid.so@session optional pam_loginuid.so@g' /etc/pam.d/sshd && \ - ssh-keygen -A diff --git a/docker/Dockerfile.cu129 b/docker/Dockerfile.cu129 deleted file mode 100644 index ed56297..0000000 --- a/docker/Dockerfile.cu129 +++ /dev/null @@ -1,116 +0,0 @@ -# syntax=docker/dockerfile:1 -# ============================================================ -# Stage 1: NVSHMEM Builder -# ============================================================ -FROM pytorch/pytorch:2.8.0-cuda12.9-cudnn9-devel AS deepep-builder - -# Add rdma libraries and build dependencies -RUN --mount=type=cache,target=/var/cache/apt,sharing=locked \ - --mount=type=cache,target=/var/lib/apt,sharing=locked \ - apt-get update && apt-get install -y --no-install-recommends \ - git build-essential ninja-build cmake pkg-config wget \ - librdmacm-dev rdma-core libfabric-dev libibverbs-dev \ - devscripts debhelper fakeroot \ - && rm -rf /var/lib/apt/lists/* - -# Build GDRCopy -RUN cd /tmp && \ - wget https://github.com/NVIDIA/gdrcopy/archive/refs/tags/v2.5.1.tar.gz && \ - tar -xf v2.5.1.tar.gz && \ - cd gdrcopy-2.5.1/packages/ && \ - CUDA=/usr/local/cuda ./build-deb-packages.sh -t -k - -RUN --mount=type=cache,target=/var/cache/apt,sharing=locked \ - --mount=type=cache,target=/var/lib/apt,sharing=locked \ - apt-get update && apt-get install -y --no-install-recommends git \ - && dpkg -i /tmp/gdrcopy-2.5.1/packages/libgdrapi_*.deb - -# Build NVSHMEM - Need GDRCOPY and IBGDA support for DeepEP all2all kernels -RUN set -eux; \ - cd /tmp; \ - wget https://developer.nvidia.com/downloads/assets/secure/nvshmem/nvshmem_src_3.2.5-1.txz; \ - mkdir -p nvshmem_src_3.2.5-1; \ - tar xf nvshmem_src_3.2.5-1.txz -C nvshmem_src_3.2.5-1; \ - cd nvshmem_src_3.2.5-1/nvshmem_src; \ - mkdir -p build; \ - cd build; \ - cmake \ - -DNVSHMEM_PREFIX=/opt/nvshmem-3.2.5 \ - -DCMAKE_CUDA_ARCHITECTURES=90a \ - -DNVSHMEM_MPI_SUPPORT=0 \ - -DNVSHMEM_PMIX_SUPPORT=0 \ - -DNVSHMEM_USE_GDRCOPY=1 \ - -DNVSHMEM_IBGDA_SUPPORT=1 \ - -DNVSHMEM_BUILD_TESTS=0 \ - -DNVSHMEM_BUILD_EXAMPLES=0 \ - -DNVSHMEM_BUILD_HYDRA_LAUNCHER=1 \ - -DNVSHMEM_BUILD_TXZ_PACKAGE=1 \ - -G Ninja \ - ..; \ - ninja; \ - ninja install; \ - rm -rf /tmp/nvshmem_src_3.2.5-1.txz - - - - -# ============================================================ -# Stage 2: vLLM/Python Dependencies (slow, cache separately) -# ============================================================ -FROM pytorch/pytorch:2.8.0-cuda12.9-cudnn9-devel AS python-deps - -RUN --mount=type=cache,target=/var/cache/apt,sharing=locked \ - --mount=type=cache,target=/var/lib/apt,sharing=locked \ - apt-get update && apt-get install -y --no-install-recommends curl - -RUN curl -LsSf https://astral.sh/uv/install.sh | sh \ - && ln -s /root/.local/bin/uv /usr/local/bin/uv - -# flashinfer-cubin installs pre-compiled CUDA kernels for vLLM -# Needed for FP8-MOE models -RUN uv venv /opt/batchbench/.venv && \ - . /opt/batchbench/.venv/bin/activate && \ - uv pip install vllm --torch-backend=auto && \ - uv pip install flashinfer-cubin flashinfer-python && \ - uv pip install flashinfer-jit-cache --index-url https://flashinfer.ai/whl/cu129 - - -# ============================================================ -# Stage 3: Final Runtime Image -# ============================================================ -FROM pytorch/pytorch:2.8.0-cuda12.9-cudnn9-devel AS runtime - -# Copy built artifacts from builder stages -COPY --from=deepep-builder /opt/nvshmem-3.2.5 /opt/nvshmem-3.2.5 -COPY --from=deepep-builder /tmp/gdrcopy-2.5.1/packages/*.deb /tmp/gdrcopy/ -COPY --from=deepep-builder /opt/conda/lib/python3.11/site-packages/deep_ep* /opt/conda/lib/python3.11/site-packages/ -COPY --from=python-deps /opt/batchbench/.venv /opt/batchbench/.venv -COPY --from=python-deps /root/.local/bin/uv /usr/local/bin/uv - -# Install minimal runtime dependencies -RUN --mount=type=cache,target=/var/cache/apt,sharing=locked \ - --mount=type=cache,target=/var/lib/apt,sharing=locked \ - apt-get update && apt-get install -y --no-install-recommends \ - librdmacm-dev rdma-core libfabric-dev libibverbs-dev \ - git curl openssh-server librdmacm1 libibverbs1 libfabric1 \ - && dpkg -i /tmp/gdrcopy/libgdrapi_*.deb \ - && rm -rf /tmp/gdrcopy - -# NVSHMEM Environment -ENV NVSHMEM_HOME=/opt/nvshmem-3.2.5 -ENV LD_LIBRARY_PATH=${NVSHMEM_HOME}/lib:/usr/local/cuda/lib64:${LD_LIBRARY_PATH} -ENV PATH="/opt/batchbench/.venv/bin:/opt/hydra/bin:/usr/local/cuda/bin:${PATH}" -ENV VLLM_HAS_FLASHINFER_CUBIN=1 - -# DeepEP installation - TODO: pull into the deepep-builder stage -RUN git clone https://github.com/deepseek-ai/DeepEP /deepep && \ - cd /deepep && \ - NVSHMEM_DIR=/opt/nvshmem-3.2.5 python setup.py install - -# SSH configuration -RUN mkdir -p /var/run/sshd /root/.ssh && \ - chmod 700 /root/.ssh && \ - sed -i 's/#PermitRootLogin prohibit-password/PermitRootLogin prohibit-password/' /etc/ssh/sshd_config && \ - sed -i 's@session\s*required\s*pam_loginuid.so@session optional pam_loginuid.so@g' /etc/pam.d/sshd && \ - ssh-keygen -A - diff --git a/docker/Dockerfile.cu130 b/docker/Dockerfile.cu130 deleted file mode 100644 index c0f952f..0000000 --- a/docker/Dockerfile.cu130 +++ /dev/null @@ -1,114 +0,0 @@ -# ============================================================ -# Stage 1: NVSHMEM Builder -# ============================================================ -FROM pytorch/pytorch:2.9.0-cuda13.0-cudnn9-devel AS deepep-builder - -# Add rdma libraries and build dependencies -RUN --mount=type=cache,target=/var/cache/apt,sharing=locked \ - --mount=type=cache,target=/var/lib/apt,sharing=locked \ - apt-get update && apt-get install -y --no-install-recommends \ - git build-essential ninja-build cmake pkg-config wget \ - librdmacm-dev rdma-core libfabric-dev libibverbs-dev \ - devscripts debhelper fakeroot \ - && rm -rf /var/lib/apt/lists/* - -# Build GDRCopy -RUN cd /tmp && \ - wget https://github.com/NVIDIA/gdrcopy/archive/refs/tags/v2.5.1.tar.gz && \ - tar -xf v2.5.1.tar.gz && \ - cd gdrcopy-2.5.1/packages/ && \ - CUDA=/usr/local/cuda ./build-deb-packages.sh -t -k - -RUN --mount=type=cache,target=/var/cache/apt,sharing=locked \ - --mount=type=cache,target=/var/lib/apt,sharing=locked \ - apt-get update && apt-get install -y --no-install-recommends git \ - && dpkg -i /tmp/gdrcopy-2.5.1/packages/libgdrapi_*.deb - -# Build NVSHMEM - Need GDRCOPY and IBGDA support for DeepEP all2all kernels -RUN set -eux; \ - cd /tmp; \ - wget https://developer.nvidia.com/downloads/assets/secure/nvshmem/nvshmem_src_3.2.5-1.txz; \ - mkdir -p nvshmem_src_3.2.5-1; \ - tar xf nvshmem_src_3.2.5-1.txz -C nvshmem_src_3.2.5-1; \ - cd nvshmem_src_3.2.5-1/nvshmem_src; \ - mkdir -p build; \ - cd build; \ - cmake \ - -DNVSHMEM_PREFIX=/opt/nvshmem-3.2.5 \ - -DCMAKE_CUDA_ARCHITECTURES=90a \ - -DNVSHMEM_MPI_SUPPORT=0 \ - -DNVSHMEM_PMIX_SUPPORT=0 \ - -DNVSHMEM_USE_GDRCOPY=1 \ - -DNVSHMEM_IBGDA_SUPPORT=1 \ - -DNVSHMEM_BUILD_TESTS=0 \ - -DNVSHMEM_BUILD_EXAMPLES=0 \ - -DNVSHMEM_BUILD_HYDRA_LAUNCHER=1 \ - -DNVSHMEM_BUILD_TXZ_PACKAGE=1 \ - -G Ninja \ - ..; \ - ninja; \ - ninja install; \ - rm -rf /tmp/nvshmem_src_3.2.5-1.txz - - - - -# ============================================================ -# Stage 2: vLLM/Python Dependencies (slow, cache separately) -# ============================================================ -FROM pytorch/pytorch:2.9.0-cuda13.0-cudnn9-devel AS python-deps - -RUN --mount=type=cache,target=/var/cache/apt,sharing=locked \ - --mount=type=cache,target=/var/lib/apt,sharing=locked \ - apt-get update && apt-get install -y --no-install-recommends curl - -RUN curl -LsSf https://astral.sh/uv/install.sh | sh \ - && ln -s /root/.local/bin/uv /usr/local/bin/uv - -# flashinfer-cubin installs pre-compiled CUDA kernels for vLLM -# Needed for FP8-MOE models -RUN uv venv /opt/batchbench/.venv && \ - . /opt/batchbench/.venv/bin/activate && \ - uv pip install vllm --torch-backend=auto && \ - uv pip install flashinfer-cubin - -# ============================================================ -# Stage 3: Final Runtime Image -# ============================================================ -FROM pytorch/pytorch:2.9.0-cuda13.0-cudnn9-devel AS runtime - -# Copy built artifacts from builder stages -COPY --from=deepep-builder /opt/nvshmem-3.2.5 /opt/nvshmem-3.2.5 -COPY --from=deepep-builder /tmp/gdrcopy-2.5.1/packages/*.deb /tmp/gdrcopy/ -COPY --from=deepep-builder /opt/conda/lib/python3.11/site-packages/deep_ep* /opt/conda/lib/python3.11/site-packages/ -COPY --from=python-deps /opt/batchbench/.venv /opt/batchbench/.venv -COPY --from=python-deps /root/.local/bin/uv /usr/local/bin/uv - -# Install minimal runtime dependencies -RUN --mount=type=cache,target=/var/cache/apt,sharing=locked \ - --mount=type=cache,target=/var/lib/apt,sharing=locked \ - apt-get update && apt-get install -y --no-install-recommends \ - librdmacm-dev rdma-core libfabric-dev libibverbs-dev \ - git curl openssh-server librdmacm1 libibverbs1 libfabric1 \ - && dpkg -i /tmp/gdrcopy/libgdrapi_*.deb \ - && rm -rf /tmp/gdrcopy - -# Environment -ENV NVSHMEM_HOME=/opt/nvshmem-3.2.5 -ENV LD_LIBRARY_PATH=${NVSHMEM_HOME}/lib:${LD_LIBRARY_PATH} -ENV PATH="/opt/batchbench/.venv/bin:/opt/hydra/bin:${PATH}" -ENV VLLM_HAS_FLASHINFER_CUBIN=1 - -# DeepEP installation - TODO: pull into the deepep-builder stage -RUN git clone https://github.com/deepseek-ai/DeepEP /deepep && \ - cd /deepep && \ - NVSHMEM_DIR=/opt/nvshmem-3.2.5 python setup.py install - -# SSH configuration -RUN mkdir -p /var/run/sshd /root/.ssh && \ - chmod 700 /root/.ssh && \ - sed -i 's/#PermitRootLogin prohibit-password/PermitRootLogin prohibit-password/' /etc/ssh/sshd_config && \ - sed -i 's@session\s*required\s*pam_loginuid.so@session optional pam_loginuid.so@g' /etc/pam.d/sshd && \ - ssh-keygen -A - - \ No newline at end of file diff --git a/docker/run_vllm.sh b/docker/run_vllm.sh deleted file mode 100644 index 859196c..0000000 --- a/docker/run_vllm.sh +++ /dev/null @@ -1,56 +0,0 @@ -#!/bin/bash - -export HF_HOME="/data" -# uv pip list - -# Start vLLM server -vllm serve \ - --model Qwen/Qwen3-30B-A3B-Instruct-2507-FP8 \ - --max-model-len 131072 \ - --gpu-memory-utilization 0.9 \ - --trust-remote-code \ - --host 0.0.0.0 \ - --port 8000 - -# VLLM_HAS_FLASHINFER_CUBIN=1 \ -# VLLM_USE_FLASHINFER_MOE_FP8=1 \ -# VLLM_FLASHINFER_MOE_BACKEND=throughput \ -# vllm serve Qwen/Qwen3-30B-A3B-Instruct-2507-FP8 \ -# --gpu-memory-utilization 0.9 \ -# --trust-remote-code \ -# --host 0.0.0.0 \ -# --port 8000 \ -# --enable-expert-parallel \ -# --tensor-parallel-size 1 \ -# --data-parallel-size 2 - -# # Most verbose logging -# VLLM_LOGGING_LEVEL=DEBUG \ -# VLLM_TRACE_FUNCTION=1 \ -# VLLM_HAS_FLASHINFER_CUBIN=1 \ -# VLLM_USE_FLASHINFER_MOE_FP8=1 \ -# VLLM_FLASHINFER_MOE_BACKEND=throughput \ -# vllm serve Qwen/Qwen3-30B-A3B-Instruct-2507-FP8 \ -# --gpu-memory-utilization 0.9 \ -# --trust-remote-code \ -# --host 0.0.0.0 \ -# --port 8000 \ -# --enable-expert-parallel \ -# --tensor-parallel-size 1 \ -# --data-parallel-size 2 \ -# # --all2all-backend deepep_high_throughput \ -# --compilation-mode NONE \ -# --cudagraph-mode FULL - -# VLLM_LOGGING_LEVEL=DEBUG \ -# VLLM_TRACE_FUNCTION=1 \ -# vllm serve Qwen/Qwen3-30B-A3B-Instruct-2507-FP8 \ -# --gpu-memory-utilization 0.9 \ -# --trust-remote-code \ -# --host 0.0.0.0 \ -# --port 8000 \ -# --enable-expert-parallel \ -# --tensor-parallel-size 1 \ -# --data-parallel-size 2 \ -# --compilation-config '{"mode": 0, "cudagraph_mode": "full"}' \ -# --all2all-backend deepep_high_throughput \ No newline at end of file diff --git a/rust/README.md b/rust/README.md index 4b4a762..74a063e 100644 --- a/rust/README.md +++ b/rust/README.md @@ -10,7 +10,7 @@ The repository includes a ready-to-go CLI that reads prompts from a JSONL file ( ``` cargo run --bin batchbench -- \ - --jsonl data/requests.jsonl \ + --dataset-jsonl data/requests.jsonl \ --users 32 \ --model gpt-4o-mini \ --host https://api.openai.com \ @@ -21,9 +21,9 @@ By default every user issues a single request, so make sure the JSONL file conta The CLI reuses the library entry points under the hood and prints a `BenchmarkReport` when the run completes. -- `--jsonl ` Path to the JSONL input whose objects expose a `text` field (required). -- `--users ` Number of concurrent workers; defaults to the JSONL record count. -- `--model ` Model identifier injected into every request; default `gpt-4o-mini`. +- `--dataset-jsonl ` Path to the JSONL input. Each non-empty line may contain a `text` field, a `body` object, or a full request body object. The legacy alias `--jsonl` is also accepted. +- `--users ` Number of concurrent workers. For generated prompts this defaults to `1`; for JSONL datasets this defaults to as many complete request rounds as the dataset can provide for the selected `--requests-per-user`. +- `--model ` Model identifier injected into every request, overriding any `model` field in JSONL request bodies; default `gpt-4o-mini`. - `--host ` Base host for the API, including scheme; default `https://api.openai.com`. - `--endpoint ` Endpoint path or full URL; default `/v1/chat/completions`. - `--requests-per-user ` Iterations each worker performs before stopping; default `1`. @@ -35,6 +35,8 @@ The CLI reuses the library entry points under the hood and prints a `BenchmarkRe - `--output-tokens ` Force completions to emit exactly `` tokens (sets `max_completion_tokens` and enables `nvext.ignore_eos`). - `--output-vary ` When used with `--output-tokens`, add a per-request uniform variation in `[-num, +num]` tokens (lower bounded at 1). - `--sglang` Use `min_new_tokens` and `max_new_tokens` for output token constraints (default uses `min_tokens` and `max_tokens`). +- `--enable-json-decoding` Enable JSON constrained decoding. With `--sglang`, requests include `response_format: {"type": "json_object"}`. Without `--sglang`, requests include vLLM `structured_outputs.json_object: true`, equivalent to passing that value through the OpenAI SDK's `extra_body`. +- `--metrics-output-dir ` Enable Prometheus scraping from the benchmarked server and write raw scrapes, parsed samples, metadata, and a summary to ``. The default metrics endpoint is `/metrics`; override it with `--metrics-endpoint`. ### Library Usage @@ -102,6 +104,7 @@ The CLI reuses the library entry points under the hood and prints a `BenchmarkRe - Derived throughput metrics, such as tokens-per-second and requests-per-second. - Latency percentiles (p50/p90/p99) across all successful requests. - A list of `FailureRecord` items capturing the last error seen per failed request. +- Optional `MetricsRunReport` scrape counts and artifact location when metrics scraping is enabled. Use these fields to build dashboards, generate CSVs, or trigger alerts after a run. diff --git a/rust/src/cli.rs b/rust/src/cli.rs index 887a171..3837996 100644 --- a/rust/src/cli.rs +++ b/rust/src/cli.rs @@ -1,11 +1,12 @@ use std::ffi::OsString; use std::fs; +use std::io::{BufRead, BufReader}; use std::path::Path; use std::time::Duration; use crate::{ - generate_requests, run_benchmark, BenchmarkConfig, BenchmarkReport, DistMode, GenerateOptions, - RequestEntry, RunMode, + generate_requests, resolve_metrics_endpoint, run_benchmark, BenchmarkConfig, BenchmarkReport, + DistMode, GenerateOptions, MetricsConfig, RequestEntry, RunMode, }; use anyhow::{anyhow, Context, Result}; use clap::Parser; @@ -41,11 +42,19 @@ struct CsvResult { output_lognorm_sigma: Option, output_lognorm_max: Option, sglang: bool, + enable_json_decoding: bool, + qwen35_disable_thinking: bool, request_timeout_secs: u64, max_retries: usize, retry_delay_ms: u64, host: String, endpoint: String, + metrics_enabled: bool, + metrics_output_dir: Option, + metrics_scrape_count: Option, + metrics_scrape_error_count: Option, + metrics_first_timestamp: Option, + metrics_last_timestamp: Option, } #[derive(Parser, Debug)] @@ -98,6 +107,11 @@ struct Args { #[arg(long = "gen-dist-mode", hide = true)] legacy_gen_dist_mode: Option, + /// Path to a JSONL dataset. Each line may contain {"text": "..."}, + /// {"body": {...}}, or a full request body object. + #[arg(long, alias = "jsonl")] + dataset_jsonl: Option, + /// Number of concurrent users to spawn (default: 1) #[arg(long)] users: Option, @@ -166,6 +180,14 @@ struct Args { #[arg(long)] sglang: bool, + /// Enable JSON constrained decoding using provider-specific request fields + #[arg(long)] + enable_json_decoding: bool, + + /// Add chat_template_kwargs.enable_thinking=false to each request + #[arg(long)] + qwen35_disable_thinking: bool, + /// Enable verbose mode to print request/response details #[arg(long, short)] verbose: bool, @@ -179,6 +201,26 @@ struct Args { #[arg(long)] results_csv: Option, + /// Directory for Prometheus metrics artifacts; enables scraping when set + #[arg(long)] + metrics_output_dir: Option, + + /// Metrics endpoint path or full URL (default: /metrics) + #[arg(long, default_value = "/metrics")] + metrics_endpoint: String, + + /// Metrics scrape interval in milliseconds + #[arg(long, default_value_t = 1000)] + metrics_interval_ms: u64, + + /// Metrics scrape request timeout in milliseconds + #[arg(long, default_value_t = 2000)] + metrics_timeout_ms: u64, + + /// Fail the benchmark if any metrics scrape fails + #[arg(long)] + metrics_fail_on_error: bool, + /// Random seed for reproducible benchmarking (default: None) #[arg(long)] seed: Option, @@ -245,6 +287,18 @@ async fn run(args: Args) -> Result<()> { || args.input_lognorm_median.is_some() || args.input_lognorm_sigma.is_some() || args.input_lognorm_max.is_some(); + let dataset_jsonl = args.dataset_jsonl.clone(); + let input_generation_requested = args.input_tokens > 0 + || args.input_vary > 0 + || input_lognorm_requested + || args.input_prefix_overlap != 0.0 + || legacy_input_dist_mode.is_some(); + + if dataset_jsonl.is_some() && input_generation_requested { + return Err(anyhow!( + "--dataset-jsonl cannot be combined with input generation flags" + )); + } if args.input_tokens == 0 && args.input_vary > 0 { return Err(anyhow!("input-vary requires --input-tokens to be set")); @@ -380,6 +434,15 @@ async fn run(args: Args) -> Result<()> { } }; + if args.metrics_output_dir.is_some() { + if args.metrics_interval_ms == 0 { + return Err(anyhow!("metrics-interval-ms must be greater than zero")); + } + if args.metrics_timeout_ms == 0 { + return Err(anyhow!("metrics-timeout-ms must be greater than zero")); + } + } + let api_key = args .api_key .or_else(|| std::env::var(&args.api_key_env).ok()); @@ -390,8 +453,60 @@ async fn run(args: Args) -> Result<()> { return Err(anyhow!("requests_per_user must be greater than zero")); } - // Always generate inline: size to users * requests_per_user - let user_count = args.users.unwrap_or(1); + let (mut request_bodies, dataset_label, dataset_is_generated) = + if let Some(dataset_path) = dataset_jsonl.as_ref() { + let requests = load_dataset_jsonl(dataset_path, &args.model)?; + let label = dataset_path.display().to_string(); + (requests, label, false) + } else { + let user_count = args.users.unwrap_or(1); + if user_count == 0 { + return Err(anyhow!("users must be greater than zero")); + } + let total_requests = user_count + .checked_mul(requests_per_user) + .ok_or_else(|| anyhow!("users * requests_per_user overflowed"))?; + + let target_tokens = if args.input_tokens > 0 { + Some(args.input_tokens) + } else { + None + }; + + let gen_opts = GenerateOptions { + count: total_requests, + prefix_overlap: args.input_prefix_overlap, + target_tokens, + token_tolerance: if args.input_tokens > 0 { + Some(args.input_vary) + } else { + None + }, + tokenizer_model: args.model.clone(), + dist_mode: input_dist_mode, + dist_mu: input_dist_mu, + dist_median: input_dist_median, + dist_sigma: input_dist_sigma, + dist_max: input_dist_max, + seed: args.seed, + }; + + let requests = generate_requests(&gen_opts, &args.model)?; + let label = format!( + "generated (count={}, tokenizer={})", + total_requests, args.model + ); + (requests, label, true) + }; + + let dataset_size = request_bodies.len(); + let user_count = if dataset_is_generated { + args.users.unwrap_or(1) + } else if let Some(users) = args.users { + users + } else { + dataset_size / requests_per_user + }; if user_count == 0 { return Err(anyhow!("users must be greater than zero")); } @@ -399,32 +514,16 @@ async fn run(args: Args) -> Result<()> { let total_requests = user_count .checked_mul(requests_per_user) .ok_or_else(|| anyhow!("users * requests_per_user overflowed"))?; + if total_requests > dataset_size { + return Err(anyhow!( + "dataset contains {} request entries but benchmark needs {} (users {} * requests-per-user {})", + dataset_size, + total_requests, + user_count, + requests_per_user + )); + } - let target_tokens = if args.input_tokens > 0 { - Some(args.input_tokens) - } else { - None - }; - - let gen_opts = GenerateOptions { - count: total_requests, - prefix_overlap: args.input_prefix_overlap, - target_tokens, - token_tolerance: if args.input_tokens > 0 { - Some(args.input_vary) - } else { - None - }, - tokenizer_model: args.model.clone(), - dist_mode: input_dist_mode, - dist_mu: input_dist_mu, - dist_median: input_dist_median, - dist_sigma: input_dist_sigma, - dist_max: input_dist_max, - seed: args.seed, - }; - - let mut request_bodies = generate_requests(&gen_opts, &args.model)?; let output_vary = if args.output_tokens.is_some() { Some(args.output_vary) } else { @@ -437,11 +536,6 @@ async fn run(args: Args) -> Result<()> { args.seed, args.sglang, )?; - let dataset_label = format!( - "generated (count={}, tokenizer={})", - total_requests, args.model - ); - let dataset_size = request_bodies.len(); // Print input token histogram let input_tokens: Vec = request_bodies.iter().map(|r| r.input_tokens).collect(); @@ -459,7 +553,14 @@ async fn run(args: Args) -> Result<()> { println!("Dataset: {}", dataset_label); println!("Dataset size: {}", dataset_size); println!("Users: {}", user_count); - println!("Mode: Deterministic mapping m*N+n into generated dataset"); + println!( + "Mode: Deterministic mapping m*N+n into {}", + if dataset_is_generated { + "generated dataset" + } else { + "dataset" + } + ); println!("Requests per user: {}", requests_per_user); println!("Total requests: {}", total_requests); if let Some(tokens) = args.output_tokens { @@ -495,8 +596,36 @@ async fn run(args: Args) -> Result<()> { "default (min_tokens/max_tokens)" } ); + println!( + "JSON decoding: {}", + if args.enable_json_decoding { + if args.sglang { + "enabled (SGLang response_format)" + } else { + "enabled (vLLM structured_outputs)" + } + } else { + "disabled" + } + ); + println!( + "Qwen 3.5 thinking: {}", + if args.qwen35_disable_thinking { + "disabled (chat_template_kwargs.enable_thinking=false)" + } else { + "unchanged" + } + ); println!("Max retries: {}", args.max_retries); println!("Retry delay: {}ms", args.retry_delay_ms); + if let Some(metrics_output_dir) = args.metrics_output_dir.as_ref() { + let metrics_endpoint = resolve_metrics_endpoint(&args.host, &args.metrics_endpoint)?; + println!("Metrics endpoint: {}", metrics_endpoint); + println!("Metrics output: {}", metrics_output_dir.display()); + println!("Metrics interval: {}ms", args.metrics_interval_ms); + } else { + println!("Metrics scraping: disabled"); + } println!("===============================\n"); let mode = RunMode::Finite { requests_per_user }; @@ -515,7 +644,9 @@ async fn run(args: Args) -> Result<()> { .with_retry(args.max_retries, Duration::from_millis(args.retry_delay_ms)) .with_verbose(args.verbose) .with_dry_run(args.dry_run) - .with_sglang(args.sglang); + .with_sglang(args.sglang) + .with_json_decoding(args.enable_json_decoding) + .with_qwen35_disable_thinking(args.qwen35_disable_thinking); if let Some(seed) = args.seed { config = config.with_seed(seed); @@ -527,6 +658,30 @@ async fn run(args: Args) -> Result<()> { config = config.with_output_lognorm(mu, sigma, max); } + if let Some(metrics_output_dir) = args.metrics_output_dir.as_ref() { + let metrics_endpoint = resolve_metrics_endpoint(&args.host, &args.metrics_endpoint)?; + config = config.with_metrics(MetricsConfig { + endpoint: metrics_endpoint, + output_dir: metrics_output_dir.clone(), + interval: Duration::from_millis(args.metrics_interval_ms), + timeout: Duration::from_millis(args.metrics_timeout_ms), + fail_on_error: args.metrics_fail_on_error, + metadata: json!({ + "model": args.model.clone(), + "dataset_path": dataset_label.clone(), + "dataset_size": dataset_size, + "users": user_count, + "requests_per_user": requests_per_user, + "total_requests": total_requests, + "host": args.host.clone(), + "endpoint": endpoint_for_config.clone(), + "sglang": args.sglang, + "enable_json_decoding": args.enable_json_decoding, + "qwen35_disable_thinking": args.qwen35_disable_thinking, + }), + }); + } + let start_time = chrono::Utc::now(); let report = run_benchmark(config).await?; @@ -562,11 +717,31 @@ async fn run(args: Args) -> Result<()> { output_lognorm_sigma: args.output_lognorm_sigma, output_lognorm_max: args.output_lognorm_max, sglang: args.sglang, + enable_json_decoding: args.enable_json_decoding, + qwen35_disable_thinking: args.qwen35_disable_thinking, request_timeout_secs: args.request_timeout_secs, max_retries: args.max_retries, retry_delay_ms: args.retry_delay_ms, host: args.host.clone(), endpoint: endpoint_for_config.clone(), + metrics_enabled: report.metrics.is_some(), + metrics_output_dir: report + .metrics + .as_ref() + .map(|metrics| metrics.output_dir.clone()), + metrics_scrape_count: report.metrics.as_ref().map(|metrics| metrics.scrape_count), + metrics_scrape_error_count: report + .metrics + .as_ref() + .map(|metrics| metrics.scrape_error_count), + metrics_first_timestamp: report + .metrics + .as_ref() + .and_then(|metrics| metrics.first_timestamp.clone()), + metrics_last_timestamp: report + .metrics + .as_ref() + .and_then(|metrics| metrics.last_timestamp.clone()), }; match write_results_csv(csv_path.as_path(), &record) { @@ -593,6 +768,112 @@ fn parse_dist_mode(mode: &str) -> Result { } } +fn load_dataset_jsonl(path: &Path, model: &str) -> Result> { + let file = fs::File::open(path) + .with_context(|| format!("failed to open dataset JSONL {}", path.display()))?; + let reader = BufReader::new(file); + let mut requests = Vec::new(); + + for (line_number, line) in reader.lines().enumerate() { + let line_number = line_number + 1; + let line = line.with_context(|| { + format!( + "failed to read line {} from dataset JSONL {}", + line_number, + path.display() + ) + })?; + let trimmed = line.trim(); + if trimmed.is_empty() { + continue; + } + + let value: serde_json::Value = serde_json::from_str(trimmed).with_context(|| { + format!( + "failed to parse dataset JSONL {} line {} as JSON", + path.display(), + line_number + ) + })?; + requests.push(dataset_value_to_request_entry( + value, + requests.len(), + line_number, + model, + )?); + } + + if requests.is_empty() { + return Err(anyhow!("dataset JSONL {} is empty", path.display())); + } + + Ok(requests) +} + +fn dataset_value_to_request_entry( + value: serde_json::Value, + line_idx: usize, + line_number: usize, + model: &str, +) -> Result { + let input_tokens = value + .get("input_tokens") + .and_then(|v| v.as_u64()) + .map(|v| v as usize) + .unwrap_or(0); + + if let Some(mut body) = value.get("body").cloned() { + if !body.is_object() { + return Err(anyhow!( + "dataset line {} has a body field, but body must be a JSON object", + line_number + )); + } + apply_request_model(&mut body, model); + return Ok(RequestEntry { + body, + line_idx, + input_tokens, + }); + } + + if let Some(text) = value.get("text").and_then(|v| v.as_str()) { + return Ok(RequestEntry { + body: json!({ + "messages": [ + {"role": "user", "content": text} + ], + "model": model, + }), + line_idx, + input_tokens, + }); + } + + let mut body = value; + let Some(map) = body.as_object_mut() else { + return Err(anyhow!( + "dataset line {} must be a JSON object, or contain a body object or text string", + line_number + )); + }; + map.remove("input_tokens"); + map.remove("line_idx"); + map.insert("model".to_string(), json!(model)); + + Ok(RequestEntry { + body, + line_idx, + input_tokens, + }) +} + +fn apply_request_model(body: &mut serde_json::Value, model: &str) { + if let Some(map) = body.as_object_mut() { + map.insert("model".to_string(), json!(model)); + } +} + /// Apply output token settings to generated request bodies, honoring optional variation and seed. fn apply_output_tokens( bodies: &mut [RequestEntry], @@ -694,6 +975,13 @@ fn print_summary(report: &BenchmarkReport) -> Result<()> { } } + if let Some(metrics) = report.metrics.as_ref() { + println!( + "Metrics: {} scrape(s), {} error(s), artifacts at {}", + metrics.scrape_count, metrics.scrape_error_count, metrics.output_dir + ); + } + Ok(()) } @@ -763,6 +1051,85 @@ fn print_histogram(label: &str, data: &[usize], bins: usize, bar_width: usize) { } } +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn dataset_text_line_becomes_chat_request() { + let entry = + dataset_value_to_request_entry(json!({"text": "hello", "input_tokens": 3}), 0, 1, "m") + .unwrap(); + + assert_eq!(entry.line_idx, 0); + assert_eq!(entry.input_tokens, 3); + assert_eq!(entry.body["model"], "m"); + assert_eq!(entry.body["messages"][0]["content"], "hello"); + } + + #[test] + fn dataset_body_line_uses_body_object_and_overrides_model() { + let entry = dataset_value_to_request_entry( + json!({"body": {"model": "x", "prompt": "hello"}, "input_tokens": 5}), + 4, + 5, + "runtime-model", + ) + .unwrap(); + + assert_eq!(entry.line_idx, 4); + assert_eq!(entry.input_tokens, 5); + assert_eq!( + entry.body, + json!({"model": "runtime-model", "prompt": "hello"}) + ); + } + + #[test] + fn dataset_body_line_without_model_gets_runtime_model() { + let entry = dataset_value_to_request_entry( + json!({"body": {"messages": []}, "input_tokens": 5}), + 4, + 5, + "runtime-model", + ) + .unwrap(); + + assert_eq!( + entry.body, + json!({"model": "runtime-model", "messages": []}) + ); + } + + #[test] + fn dataset_full_request_line_drops_metadata_fields_and_overrides_model() { + let entry = dataset_value_to_request_entry( + json!({"model": "x", "messages": [], "input_tokens": 7, "line_idx": 99}), + 1, + 2, + "runtime-model", + ) + .unwrap(); + + assert_eq!(entry.input_tokens, 7); + assert_eq!( + entry.body, + json!({"model": "runtime-model", "messages": []}) + ); + } + + #[test] + fn parse_args_accepts_qwen35_disable_thinking_flag() { + let parsed = parse_args(["batchbench", "--qwen35-disable-thinking"]).unwrap(); + + let ParsedArgs::Ready(args) = parsed else { + panic!("expected parsed args"); + }; + + assert!(args.qwen35_disable_thinking); + } +} + fn format_latency(latency: Option) -> String { match latency { Some(value) => format!("{:.2}", value.as_secs_f64() * 1000.0), diff --git a/rust/src/config.rs b/rust/src/config.rs index 2a89f67..1002c10 100644 --- a/rust/src/config.rs +++ b/rust/src/config.rs @@ -5,6 +5,8 @@ use reqwest::header::{HeaderMap, HeaderName, HeaderValue, AUTHORIZATION, CONTENT use reqwest::Url; use serde_json::Value; +use crate::metrics::MetricsConfig; + #[derive(Clone, Debug)] pub struct RequestEntry { pub body: Value, @@ -40,6 +42,12 @@ pub struct BenchmarkConfig { pub dry_run: bool, /// Use SGLang sampling parameter names for output-token constraints pub sglang: bool, + /// Add provider-specific JSON constrained decoding fields to each request + pub enable_json_decoding: bool, + /// Disable Qwen 3.5 thinking via chat_template_kwargs.enable_thinking=false + pub qwen35_disable_thinking: bool, + /// Optional Prometheus metrics scraping configuration + pub metrics: Option, } impl BenchmarkConfig { @@ -100,6 +108,9 @@ impl BenchmarkConfig { seed: None, dry_run: false, sglang: false, + enable_json_decoding: false, + qwen35_disable_thinking: false, + metrics: None, }) } @@ -143,6 +154,21 @@ impl BenchmarkConfig { self } + pub fn with_json_decoding(mut self, enable_json_decoding: bool) -> Self { + self.enable_json_decoding = enable_json_decoding; + self + } + + pub fn with_qwen35_disable_thinking(mut self, qwen35_disable_thinking: bool) -> Self { + self.qwen35_disable_thinking = qwen35_disable_thinking; + self + } + + pub fn with_metrics(mut self, metrics: MetricsConfig) -> Self { + self.metrics = Some(metrics); + self + } + pub fn add_header(mut self, name: HeaderName, value: HeaderValue) -> Self { self.headers.insert(name, value); self diff --git a/rust/src/lib.rs b/rust/src/lib.rs index ea1911a..7b3e14f 100644 --- a/rust/src/lib.rs +++ b/rust/src/lib.rs @@ -1,6 +1,7 @@ mod cli; mod config; mod generator; +mod metrics; #[cfg(feature = "python")] mod py_bindings; mod report; @@ -9,6 +10,7 @@ mod runner; pub use cli::{run_from_argv, run_from_env}; pub use config::{BenchmarkConfig, RequestEntry, RunMode}; pub use generator::{generate_requests, DistMode, GenerateOptions}; +pub use metrics::{resolve_metrics_endpoint, MetricsConfig, MetricsRunReport}; pub use report::{BenchmarkReport, FailureRecord}; pub use reqwest::header::{HeaderMap, HeaderName, HeaderValue}; pub use runner::run_benchmark; diff --git a/rust/src/metrics.rs b/rust/src/metrics.rs new file mode 100644 index 0000000..5a729d8 --- /dev/null +++ b/rust/src/metrics.rs @@ -0,0 +1,902 @@ +use std::collections::{BTreeMap, HashMap}; +use std::fs::{self, File}; +use std::io::{BufWriter, Write}; +use std::path::PathBuf; +use std::time::{Duration, Instant}; + +use anyhow::{anyhow, Context, Result}; +use chrono::{DateTime, Utc}; +use reqwest::{Client, StatusCode, Url}; +use serde::{Deserialize, Serialize}; +use serde_json::{json, Value}; +use tokio::sync::oneshot; +use tokio::task::JoinHandle; + +#[derive(Clone, Debug)] +pub struct MetricsConfig { + pub endpoint: Url, + pub output_dir: PathBuf, + pub interval: Duration, + pub timeout: Duration, + pub fail_on_error: bool, + pub metadata: Value, +} + +#[derive(Clone, Debug, Default, Serialize, Deserialize)] +pub struct MetricsRunReport { + pub output_dir: String, + pub scrape_count: u64, + pub scrape_error_count: u64, + pub first_timestamp: Option, + pub last_timestamp: Option, +} + +pub struct MetricsCollectorHandle { + stop_tx: Option>, + join_handle: JoinHandle>, +} + +impl MetricsCollectorHandle { + pub async fn stop(mut self) -> Result { + if let Some(stop_tx) = self.stop_tx.take() { + let _ = stop_tx.send(()); + } + self.join_handle + .await + .map_err(|err| anyhow!("metrics collector task failed: {}", err))? + } +} + +pub async fn spawn_metrics_collector(config: MetricsConfig) -> Result { + let (stop_tx, stop_rx) = oneshot::channel(); + let (ready_tx, ready_rx) = oneshot::channel(); + let join_handle = tokio::spawn(async move { collect_metrics(config, stop_rx, ready_tx).await }); + ready_rx + .await + .map_err(|_| anyhow!("metrics collector exited before initial scrape"))??; + Ok(MetricsCollectorHandle { + stop_tx: Some(stop_tx), + join_handle, + }) +} + +async fn collect_metrics( + config: MetricsConfig, + mut stop_rx: oneshot::Receiver<()>, + ready_tx: oneshot::Sender>, +) -> Result { + fs::create_dir_all(&config.output_dir).with_context(|| { + format!( + "failed to create metrics output directory {}", + config.output_dir.display() + ) + })?; + + let raw_path = config.output_dir.join("raw.promjsonl"); + let samples_path = config.output_dir.join("samples.csv"); + let metadata_path = config.output_dir.join("metadata.json"); + let summary_path = config.output_dir.join("summary.json"); + + let mut raw_writer = BufWriter::new( + File::create(&raw_path) + .with_context(|| format!("failed to create metrics raw log {}", raw_path.display()))?, + ); + let mut sample_writer = csv::Writer::from_path(&samples_path).with_context(|| { + format!( + "failed to create parsed metrics samples CSV {}", + samples_path.display() + ) + })?; + + let client = Client::builder() + .timeout(config.timeout) + .build() + .context("failed to construct metrics HTTP client")?; + let started_at = Utc::now(); + let start = Instant::now(); + let mut state = MetricsSummaryBuilder::new(config.output_dir.display().to_string()); + let mut seq = 0u64; + + if let Err(err) = scrape_once( + &client, + &config, + &mut raw_writer, + &mut sample_writer, + &mut state, + seq, + start, + ) + .await + { + let message = err.to_string(); + let _ = ready_tx.send(Err(anyhow!(message))); + return Err(err); + } + let _ = ready_tx.send(Ok(())); + seq += 1; + + loop { + tokio::select! { + _ = tokio::time::sleep(config.interval) => { + scrape_once( + &client, + &config, + &mut raw_writer, + &mut sample_writer, + &mut state, + seq, + start, + ) + .await?; + seq += 1; + } + _ = &mut stop_rx => { + break; + } + } + } + + scrape_once( + &client, + &config, + &mut raw_writer, + &mut sample_writer, + &mut state, + seq, + start, + ) + .await?; + + raw_writer.flush()?; + sample_writer.flush()?; + + let ended_at = Utc::now(); + let report = state.report(); + let summary = state.summary(); + let metadata = json!({ + "schema_version": 1, + "benchmark_start_utc": started_at.to_rfc3339(), + "benchmark_end_utc": ended_at.to_rfc3339(), + "metrics_url": config.endpoint.as_str(), + "interval_ms": config.interval.as_millis(), + "timeout_ms": config.timeout.as_millis(), + "fail_on_error": config.fail_on_error, + "run": config.metadata, + }); + fs::write(&metadata_path, serde_json::to_vec_pretty(&metadata)?) + .with_context(|| format!("failed to write {}", metadata_path.display()))?; + fs::write(&summary_path, serde_json::to_vec_pretty(&summary)?) + .with_context(|| format!("failed to write {}", summary_path.display()))?; + + if config.fail_on_error && report.scrape_error_count > 0 { + return Err(anyhow!( + "metrics scraping recorded {} error(s); see {}", + report.scrape_error_count, + raw_path.display() + )); + } + + Ok(report) +} + +async fn scrape_once( + client: &Client, + config: &MetricsConfig, + raw_writer: &mut BufWriter, + sample_writer: &mut csv::Writer, + state: &mut MetricsSummaryBuilder, + seq: u64, + start: Instant, +) -> Result<()> { + let timestamp = Utc::now(); + let elapsed_ms = start.elapsed().as_millis() as u64; + let scrape_start = Instant::now(); + let result = client.get(config.endpoint.clone()).send().await; + let scrape_duration_ms = scrape_start.elapsed().as_millis() as u64; + + match result { + Ok(response) => { + let status = response.status(); + let body = response.text().await.unwrap_or_else(|err| err.to_string()); + if status.is_success() { + match parse_prometheus_text(&body) { + Ok(samples) => { + write_raw_record( + raw_writer, + RawScrapeRecord::success( + seq, + timestamp, + elapsed_ms, + scrape_duration_ms, + status, + &body, + ), + )?; + state.record_success(timestamp, &samples); + for sample in samples { + sample_writer.serialize(SampleCsvRecord { + seq, + timestamp_utc: timestamp.to_rfc3339(), + elapsed_ms, + name: sample.name, + metric_type: sample.metric_type, + labels_json: serde_json::to_string(&sample.labels)?, + value: sample.value.to_string(), + })?; + } + } + Err(err) => { + state.record_error(); + write_raw_record( + raw_writer, + RawScrapeRecord::parse_error( + seq, + timestamp, + elapsed_ms, + scrape_duration_ms, + status, + body, + err.to_string(), + ), + )?; + } + } + } else { + state.record_error(); + write_raw_record( + raw_writer, + RawScrapeRecord::http_error( + seq, + timestamp, + elapsed_ms, + scrape_duration_ms, + status, + body, + ), + )?; + } + } + Err(err) => { + state.record_error(); + write_raw_record( + raw_writer, + RawScrapeRecord::request_error( + seq, + timestamp, + elapsed_ms, + scrape_duration_ms, + err.to_string(), + ), + )?; + } + } + + raw_writer.flush()?; + sample_writer.flush()?; + Ok(()) +} + +fn write_raw_record(writer: &mut BufWriter, record: RawScrapeRecord) -> Result<()> { + serde_json::to_writer(&mut *writer, &record)?; + writer.write_all(b"\n")?; + Ok(()) +} + +#[derive(Serialize)] +struct RawScrapeRecord { + seq: u64, + timestamp_utc: String, + elapsed_ms: u64, + status: String, + http_status: Option, + scrape_duration_ms: u64, + body: Option, + error: Option, +} + +impl RawScrapeRecord { + fn success( + seq: u64, + timestamp: DateTime, + elapsed_ms: u64, + scrape_duration_ms: u64, + status: StatusCode, + body: &str, + ) -> Self { + Self { + seq, + timestamp_utc: timestamp.to_rfc3339(), + elapsed_ms, + status: "ok".to_string(), + http_status: Some(status.as_u16()), + scrape_duration_ms, + body: Some(body.to_string()), + error: None, + } + } + + fn parse_error( + seq: u64, + timestamp: DateTime, + elapsed_ms: u64, + scrape_duration_ms: u64, + status: StatusCode, + body: String, + error: String, + ) -> Self { + Self { + seq, + timestamp_utc: timestamp.to_rfc3339(), + elapsed_ms, + status: "parse_error".to_string(), + http_status: Some(status.as_u16()), + scrape_duration_ms, + body: Some(body), + error: Some(error), + } + } + + fn http_error( + seq: u64, + timestamp: DateTime, + elapsed_ms: u64, + scrape_duration_ms: u64, + status: StatusCode, + body: String, + ) -> Self { + Self { + seq, + timestamp_utc: timestamp.to_rfc3339(), + elapsed_ms, + status: "http_error".to_string(), + http_status: Some(status.as_u16()), + scrape_duration_ms, + body: Some(body), + error: None, + } + } + + fn request_error( + seq: u64, + timestamp: DateTime, + elapsed_ms: u64, + scrape_duration_ms: u64, + error: String, + ) -> Self { + Self { + seq, + timestamp_utc: timestamp.to_rfc3339(), + elapsed_ms, + status: "request_error".to_string(), + http_status: None, + scrape_duration_ms, + body: None, + error: Some(error), + } + } +} + +#[derive(Serialize)] +struct SampleCsvRecord { + seq: u64, + timestamp_utc: String, + elapsed_ms: u64, + name: String, + metric_type: String, + labels_json: String, + value: String, +} + +#[derive(Clone, Debug)] +struct ParsedSample { + name: String, + metric_type: String, + labels: BTreeMap, + value: f64, +} + +fn parse_prometheus_text(text: &str) -> Result> { + let mut metric_types = HashMap::new(); + let mut samples = Vec::new(); + + for line in text.lines() { + let line = line.trim(); + if line.is_empty() { + continue; + } + if let Some(rest) = line.strip_prefix("# TYPE ") { + let mut parts = rest.split_whitespace(); + if let (Some(name), Some(metric_type)) = (parts.next(), parts.next()) { + metric_types.insert(name.to_string(), metric_type.to_string()); + } + continue; + } + if line.starts_with('#') { + continue; + } + + let sample = parse_sample_line(line, &metric_types) + .with_context(|| format!("failed to parse Prometheus sample line: {}", line))?; + samples.push(sample); + } + + Ok(samples) +} + +fn parse_sample_line(line: &str, metric_types: &HashMap) -> Result { + let (name_and_labels, rest) = + split_sample_name_and_rest(line).ok_or_else(|| anyhow!("sample line missing value"))?; + let value_text = rest + .split_whitespace() + .next() + .ok_or_else(|| anyhow!("sample line missing value"))?; + let value = parse_prometheus_float(value_text)?; + + let (name, labels) = if let Some(label_start) = name_and_labels.find('{') { + let label_end = name_and_labels + .rfind('}') + .ok_or_else(|| anyhow!("metric labels missing closing brace"))?; + let name = &name_and_labels[..label_start]; + let labels_text = &name_and_labels[label_start + 1..label_end]; + (name.to_string(), parse_labels(labels_text)?) + } else { + (name_and_labels.to_string(), BTreeMap::new()) + }; + + let metric_type = infer_metric_type(&name, metric_types); + Ok(ParsedSample { + name, + metric_type, + labels, + value, + }) +} + +fn split_sample_name_and_rest(line: &str) -> Option<(&str, &str)> { + let mut in_labels = false; + let mut in_quotes = false; + let mut escaped = false; + + for (idx, ch) in line.char_indices() { + if escaped { + escaped = false; + continue; + } + if in_quotes && ch == '\\' { + escaped = true; + continue; + } + if in_labels && ch == '"' { + in_quotes = !in_quotes; + continue; + } + if !in_quotes { + if ch == '{' { + in_labels = true; + continue; + } + if ch == '}' { + in_labels = false; + continue; + } + if ch.is_whitespace() { + return Some((&line[..idx], line[idx..].trim_start())); + } + } + } + + None +} + +fn infer_metric_type(name: &str, metric_types: &HashMap) -> String { + if let Some(metric_type) = metric_types.get(name) { + return metric_type.clone(); + } + for suffix in ["_bucket", "_sum", "_count"] { + if let Some(base) = name.strip_suffix(suffix) { + if let Some(metric_type) = metric_types.get(base) { + return metric_type.clone(); + } + } + } + "untyped".to_string() +} + +fn parse_labels(labels_text: &str) -> Result> { + let mut labels = BTreeMap::new(); + let mut key = String::new(); + let mut value = String::new(); + let mut in_key = true; + let mut in_quotes = false; + let mut escaped = false; + + for ch in labels_text.chars().chain(std::iter::once(',')) { + if escaped { + value.push(match ch { + 'n' => '\n', + 't' => '\t', + '\\' => '\\', + '"' => '"', + other => other, + }); + escaped = false; + continue; + } + if in_quotes && ch == '\\' { + escaped = true; + continue; + } + if ch == '"' { + in_quotes = !in_quotes; + continue; + } + if !in_quotes && in_key && ch == '=' { + in_key = false; + continue; + } + if !in_quotes && ch == ',' { + let label_key = key.trim(); + if !label_key.is_empty() { + labels.insert(label_key.to_string(), value.clone()); + } + key.clear(); + value.clear(); + in_key = true; + continue; + } + if in_key { + key.push(ch); + } else { + value.push(ch); + } + } + + if in_quotes { + return Err(anyhow!("unterminated label quote")); + } + + Ok(labels) +} + +fn parse_prometheus_float(value: &str) -> Result { + match value { + "NaN" | "nan" => Ok(f64::NAN), + "Inf" | "+Inf" | "inf" | "+inf" => Ok(f64::INFINITY), + "-Inf" | "-inf" => Ok(f64::NEG_INFINITY), + other => other + .parse::() + .with_context(|| format!("invalid Prometheus float: {}", value)), + } +} + +#[derive(Default)] +struct MetricsSummaryBuilder { + output_dir: String, + scrape_count: u64, + scrape_error_count: u64, + first_timestamp: Option>, + last_timestamp: Option>, + scalar_stats: BTreeMap, + histogram_buckets: BTreeMap>, +} + +impl MetricsSummaryBuilder { + fn new(output_dir: String) -> Self { + Self { + output_dir, + ..Self::default() + } + } + + fn record_success(&mut self, timestamp: DateTime, samples: &[ParsedSample]) { + self.scrape_count += 1; + self.first_timestamp.get_or_insert(timestamp); + self.last_timestamp = Some(timestamp); + + let mut aggregated = BTreeMap::<(String, String), f64>::new(); + let mut buckets = BTreeMap::<(String, String), f64>::new(); + + for sample in samples { + if !sample.value.is_finite() { + continue; + } + if sample.name.ends_with("_bucket") { + if let Some(le) = sample.labels.get("le") { + let base = sample.name.trim_end_matches("_bucket").to_string(); + *buckets.entry((base, le.clone())).or_default() += sample.value; + } + continue; + } + if sample.name.ends_with("_sum") || sample.name.ends_with("_count") { + continue; + } + *aggregated + .entry((sample.name.clone(), sample.metric_type.clone())) + .or_default() += sample.value; + } + + for ((name, metric_type), value) in aggregated { + self.scalar_stats + .entry(name) + .or_insert_with(|| ScalarMetricStats::new(metric_type)) + .record(value); + } + for ((name, le), value) in buckets { + self.histogram_buckets + .entry(name) + .or_default() + .entry(le) + .or_default() + .record(value); + } + } + + fn record_error(&mut self) { + self.scrape_error_count += 1; + } + + fn report(&self) -> MetricsRunReport { + MetricsRunReport { + output_dir: self.output_dir.clone(), + scrape_count: self.scrape_count, + scrape_error_count: self.scrape_error_count, + first_timestamp: self.first_timestamp.map(|ts| ts.to_rfc3339()), + last_timestamp: self.last_timestamp.map(|ts| ts.to_rfc3339()), + } + } + + fn summary(&self) -> Value { + let mut counters = serde_json::Map::new(); + let mut gauges = serde_json::Map::new(); + for (name, stats) in &self.scalar_stats { + match stats.metric_type.as_str() { + "counter" => { + counters.insert(name.clone(), stats.counter_json()); + } + "gauge" => { + gauges.insert(name.clone(), stats.gauge_json()); + } + _ => {} + } + } + + let mut histograms = serde_json::Map::new(); + for (name, buckets) in &self.histogram_buckets { + histograms.insert(name.clone(), histogram_json(buckets)); + } + + json!({ + "schema_version": 1, + "scrape_count": self.scrape_count, + "scrape_error_count": self.scrape_error_count, + "first_timestamp": self.first_timestamp.map(|ts| ts.to_rfc3339()), + "last_timestamp": self.last_timestamp.map(|ts| ts.to_rfc3339()), + "counters": counters, + "gauges": gauges, + "histograms": histograms, + }) + } +} + +#[derive(Default)] +struct ScalarMetricStats { + metric_type: String, + first: Option, + last: Option, + min: f64, + max: f64, + sum: f64, + count: u64, +} + +impl ScalarMetricStats { + fn new(metric_type: String) -> Self { + Self { + metric_type, + ..Self::default() + } + } + + fn record(&mut self, value: f64) { + self.first.get_or_insert(value); + self.last = Some(value); + if self.count == 0 { + self.min = value; + self.max = value; + } else { + self.min = self.min.min(value); + self.max = self.max.max(value); + } + self.sum += value; + self.count += 1; + } + + fn counter_json(&self) -> Value { + let first = self.first.unwrap_or(0.0); + let last = self.last.unwrap_or(first); + json!({ + "first": first, + "last": last, + "delta": if last >= first { last - first } else { last }, + }) + } + + fn gauge_json(&self) -> Value { + json!({ + "first": self.first, + "last": self.last, + "min": self.min, + "max": self.max, + "mean": if self.count > 0 { Some(self.sum / self.count as f64) } else { None }, + }) + } +} + +#[derive(Default)] +struct BucketStats { + first: Option, + last: Option, +} + +impl BucketStats { + fn record(&mut self, value: f64) { + self.first.get_or_insert(value); + self.last = Some(value); + } + + fn delta(&self) -> f64 { + let first = self.first.unwrap_or(0.0); + let last = self.last.unwrap_or(first); + if last >= first { + last - first + } else { + last + } + } +} + +fn histogram_json(buckets: &BTreeMap) -> Value { + let mut bucket_values = Vec::new(); + for (le, stats) in buckets { + bucket_values.push(json!({ + "le": le, + "delta": stats.delta(), + })); + } + + json!({ + "buckets": bucket_values, + "p50": approximate_histogram_quantile(buckets, 0.50), + "p90": approximate_histogram_quantile(buckets, 0.90), + "p99": approximate_histogram_quantile(buckets, 0.99), + }) +} + +fn approximate_histogram_quantile( + buckets: &BTreeMap, + quantile: f64, +) -> Option { + let mut parsed = buckets + .iter() + .filter_map(|(le, stats)| parse_bucket_bound(le).map(|bound| (bound, stats.delta()))) + .collect::>(); + parsed.sort_by(|a, b| a.0.total_cmp(&b.0)); + + let total = parsed + .iter() + .find(|(bound, _)| bound.is_infinite()) + .map(|(_, count)| *count) + .or_else(|| parsed.last().map(|(_, count)| *count))?; + if total <= 0.0 { + return None; + } + + let target = total * quantile; + let mut previous_bound = 0.0; + let mut previous_count = 0.0; + for (bound, cumulative_count) in parsed { + if cumulative_count >= target { + if bound.is_infinite() { + return Some(previous_bound); + } + let bucket_count = cumulative_count - previous_count; + if bucket_count <= 0.0 { + return Some(bound); + } + let within_bucket = (target - previous_count) / bucket_count; + return Some(previous_bound + (bound - previous_bound) * within_bucket); + } + previous_bound = bound; + previous_count = cumulative_count; + } + None +} + +fn parse_bucket_bound(value: &str) -> Option { + match value { + "+Inf" | "Inf" | "inf" | "+inf" => Some(f64::INFINITY), + other => other.parse::().ok(), + } +} + +pub fn resolve_metrics_endpoint(host: &str, endpoint: &str) -> Result { + if endpoint.starts_with("http://") || endpoint.starts_with("https://") { + return Url::parse(endpoint) + .with_context(|| format!("invalid metrics endpoint: {}", endpoint)); + } + + let normalized_host = if host.starts_with("http://") || host.starts_with("https://") { + host.trim_end_matches('/').to_string() + } else { + format!("https://{}", host.trim_end_matches('/')) + }; + let resolved = format!("{}/{}", normalized_host, endpoint.trim_start_matches('/')); + Url::parse(&resolved).with_context(|| format!("invalid metrics endpoint: {}", resolved)) +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn resolves_relative_metrics_endpoint_against_host() { + let url = resolve_metrics_endpoint("http://127.0.0.1:3000/", "/metrics").unwrap(); + assert_eq!(url.as_str(), "http://127.0.0.1:3000/metrics"); + } + + #[test] + fn parses_colon_metric_names_and_labels() { + let parsed = parse_prometheus_text( + r#" +# HELP vllm:prompt_tokens_total Number of prefill tokens processed. +# TYPE vllm:prompt_tokens_total counter +vllm:prompt_tokens_total{model_name="Qwen/Qwen3"} 12 +# TYPE sglang:token_usage gauge +sglang:token_usage{model_name="Qwen/Qwen3"} 0.25 +"#, + ) + .unwrap(); + + assert_eq!(parsed[0].name, "vllm:prompt_tokens_total"); + assert_eq!(parsed[0].metric_type, "counter"); + assert_eq!(parsed[0].labels.get("model_name").unwrap(), "Qwen/Qwen3"); + assert_eq!(parsed[1].name, "sglang:token_usage"); + assert_eq!(parsed[1].metric_type, "gauge"); + } + + #[test] + fn summarizes_counter_deltas_and_gauge_stats() { + let mut summary = MetricsSummaryBuilder::new("metrics".to_string()); + let first = parse_prometheus_text( + r#" +# TYPE vllm:prompt_tokens_total counter +vllm:prompt_tokens_total 10 +# TYPE vllm:num_requests_running gauge +vllm:num_requests_running 1 +"#, + ) + .unwrap(); + let second = parse_prometheus_text( + r#" +# TYPE vllm:prompt_tokens_total counter +vllm:prompt_tokens_total 25 +# TYPE vllm:num_requests_running gauge +vllm:num_requests_running 3 +"#, + ) + .unwrap(); + + summary.record_success(Utc::now(), &first); + summary.record_success(Utc::now(), &second); + let payload = summary.summary(); + + assert_eq!( + payload["counters"]["vllm:prompt_tokens_total"]["delta"], + json!(15.0) + ); + assert_eq!( + payload["gauges"]["vllm:num_requests_running"]["max"], + json!(3.0) + ); + } +} diff --git a/rust/src/py_bindings.rs b/rust/src/py_bindings.rs index 61b415e..464b020 100644 --- a/rust/src/py_bindings.rs +++ b/rust/src/py_bindings.rs @@ -1,4 +1,5 @@ use std::collections::HashMap; +use std::path::PathBuf; use std::time::Duration; use anyhow::{anyhow, Context, Result}; @@ -10,8 +11,9 @@ use serde::{Deserialize, Serialize}; use serde_json::Value; use crate::{ - run_benchmark, run_from_argv, BenchmarkConfig, BenchmarkReport, DistMode, FailureRecord, - GenerateOptions, RequestEntry, RunMode, + resolve_metrics_endpoint, run_benchmark, run_from_argv, BenchmarkConfig, BenchmarkReport, + DistMode, FailureRecord, GenerateOptions, MetricsConfig, MetricsRunReport, RequestEntry, + RunMode, }; #[derive(Debug, Clone, Deserialize, Serialize)] @@ -173,9 +175,25 @@ struct PyBenchmarkConfig { #[serde(default)] sglang: bool, #[serde(default)] + enable_json_decoding: bool, + #[serde(default)] + qwen35_disable_thinking: bool, + #[serde(default)] seed: Option, #[serde(default)] dry_run: bool, + #[serde(default)] + metrics_host: Option, + #[serde(default)] + metrics_endpoint: Option, + #[serde(default)] + metrics_output_dir: Option, + #[serde(default)] + metrics_interval_ms: Option, + #[serde(default)] + metrics_timeout_ms: Option, + #[serde(default)] + metrics_fail_on_error: bool, } fn to_benchmark_config(value: PyBenchmarkConfig) -> Result { @@ -220,6 +238,14 @@ fn to_benchmark_config(value: PyBenchmarkConfig) -> Result { config = config.with_sglang(true); } + if value.enable_json_decoding { + config = config.with_json_decoding(true); + } + + if value.qwen35_disable_thinking { + config = config.with_qwen35_disable_thinking(true); + } + if let Some(seed) = value.seed { config = config.with_seed(seed); } @@ -228,6 +254,31 @@ fn to_benchmark_config(value: PyBenchmarkConfig) -> Result { config = config.with_dry_run(true); } + if let Some(metrics_output_dir) = value.metrics_output_dir { + let metrics_interval_ms = value.metrics_interval_ms.unwrap_or(1000); + if metrics_interval_ms == 0 { + return Err(anyhow!("metrics_interval_ms must be greater than zero")); + } + let metrics_timeout_ms = value.metrics_timeout_ms.unwrap_or(2000); + if metrics_timeout_ms == 0 { + return Err(anyhow!("metrics_timeout_ms must be greater than zero")); + } + let metrics_host = value + .metrics_host + .as_deref() + .unwrap_or(config.endpoint.as_str()); + let metrics_endpoint = value.metrics_endpoint.as_deref().unwrap_or("/metrics"); + let endpoint = resolve_metrics_endpoint(metrics_host, metrics_endpoint)?; + config = config.with_metrics(MetricsConfig { + endpoint, + output_dir: metrics_output_dir, + interval: Duration::from_millis(metrics_interval_ms), + timeout: Duration::from_millis(metrics_timeout_ms), + fail_on_error: value.metrics_fail_on_error, + metadata: serde_json::json!({}), + }); + } + for (name, value) in value.headers { let header_name = HeaderName::from_bytes(name.as_bytes()) .with_context(|| format!("invalid header name: {}", name))?; @@ -275,6 +326,7 @@ struct PyBenchmarkReport { latency_p90_ms: Option, latency_p99_ms: Option, failures: Vec, + metrics: Option, } impl From for PyBenchmarkReport { @@ -304,6 +356,7 @@ impl From for PyBenchmarkReport { .into_iter() .map(PyFailureRecord::from) .collect(), + metrics: value.metrics, } } } diff --git a/rust/src/report.rs b/rust/src/report.rs index b0c185a..451bd4d 100644 --- a/rust/src/report.rs +++ b/rust/src/report.rs @@ -1,5 +1,7 @@ use std::time::Duration; +use crate::metrics::MetricsRunReport; + #[derive(Debug, Clone)] pub struct FailureRecord { pub user_id: usize, @@ -21,6 +23,7 @@ pub struct BenchmarkReport { pub latency_p90: Option, pub latency_p99: Option, pub failures: Vec, + pub metrics: Option, } impl BenchmarkReport { diff --git a/rust/src/runner.rs b/rust/src/runner.rs index 30ab348..81873a2 100644 --- a/rust/src/runner.rs +++ b/rust/src/runner.rs @@ -14,6 +14,7 @@ use tokio::sync::mpsc; use tokio::task::JoinSet; use crate::config::{BenchmarkConfig, RequestEntry, RunMode}; +use crate::metrics::spawn_metrics_collector; use crate::report::{BenchmarkReport, FailureRecord}; use std::cmp; @@ -33,6 +34,50 @@ fn output_token_field_names(use_sglang: bool) -> (&'static str, &'static str) { } } +fn apply_json_decoding(body: &mut Value, use_sglang: bool) { + let Some(map) = body.as_object_mut() else { + return; + }; + + if use_sglang { + map.insert( + "response_format".to_string(), + serde_json::json!({"type": "json_object"}), + ); + return; + } + + let structured_outputs = map + .entry("structured_outputs".to_string()) + .or_insert_with(|| serde_json::json!({})); + if !structured_outputs.is_object() { + *structured_outputs = serde_json::json!({}); + } + + structured_outputs + .as_object_mut() + .expect("structured_outputs was normalized to an object") + .insert("json_object".to_string(), serde_json::json!(true)); +} + +fn apply_qwen35_disable_thinking(body: &mut Value) { + let Some(map) = body.as_object_mut() else { + return; + }; + + let chat_template_kwargs = map + .entry("chat_template_kwargs".to_string()) + .or_insert_with(|| serde_json::json!({})); + if !chat_template_kwargs.is_object() { + *chat_template_kwargs = serde_json::json!({}); + } + + chat_template_kwargs + .as_object_mut() + .expect("chat_template_kwargs was normalized to an object") + .insert("enable_thinking".to_string(), serde_json::json!(false)); +} + pub async fn run_benchmark(config: BenchmarkConfig) -> Result { let start = Instant::now(); let client = Client::builder() @@ -48,11 +93,20 @@ pub async fn run_benchmark(config: BenchmarkConfig) -> Result { let config = Arc::new(config); + let scrape_handle = if !config.dry_run { + match config.metrics.clone() { + Some(metrics_config) => Some(spawn_metrics_collector(metrics_config).await?), + None => None, + } + } else { + None + }; + let (event_tx, event_rx) = mpsc::unbounded_channel(); let (status_tx, status_rx) = mpsc::unbounded_channel(); let metrics_status_tx = status_tx.clone(); - let metrics_handle = tokio::spawn(async move { + let aggregator_handle = tokio::spawn(async move { collect_metrics(event_rx, planned_total_requests, metrics_status_tx).await }); @@ -70,6 +124,7 @@ pub async fn run_benchmark(config: BenchmarkConfig) -> Result { drop(status_tx); let mut interrupted = false; + let mut fatal_error: Option = None; let mut ctrl_c = pin!(tokio::signal::ctrl_c()); while !join_set.is_empty() { tokio::select! { @@ -94,7 +149,8 @@ pub async fn run_benchmark(config: BenchmarkConfig) -> Result { if interrupted { eprintln!("worker exited with error during shutdown: {}", err); } else { - return Err(err); + fatal_error = Some(err); + join_set.abort_all(); } } } @@ -103,7 +159,8 @@ pub async fn run_benchmark(config: BenchmarkConfig) -> Result { if interrupted && err.is_cancelled() { continue; } - return Err(anyhow!("worker task failed: {}", err)); + fatal_error = Some(anyhow!("worker task failed: {}", err)); + join_set.abort_all(); } None => break, } @@ -111,14 +168,23 @@ pub async fn run_benchmark(config: BenchmarkConfig) -> Result { } } - let aggregator = metrics_handle.await??; + let aggregator = aggregator_handle.await??; let total_duration = start.elapsed(); tracker_handle .await .map_err(|err| anyhow!("status tracker task failed: {}", err))?; - let (report, dry_run_events) = aggregator.finalize(total_duration); + let metrics_report = match scrape_handle { + Some(handle) => Some(handle.stop().await?), + None => None, + }; + + if let Some(err) = fatal_error { + return Err(err); + } + + let (report, dry_run_events) = aggregator.finalize(total_duration, metrics_report); if config.dry_run && !dry_run_events.is_empty() { print_sorted_dry_run_events(&dry_run_events); @@ -204,6 +270,14 @@ async fn dispatch_request( let mut request_body = request_entry.body.clone(); + if config.enable_json_decoding { + apply_json_decoding(&mut request_body, config.sglang); + } + + if config.qwen35_disable_thinking { + apply_qwen35_disable_thinking(&mut request_body); + } + // If lognormal output sampling is configured, sample and inject tokens let mut lognorm_tokens: Option = None; if let Some((mu, sigma, max)) = config.output_lognorm { @@ -508,7 +582,11 @@ impl MetricsAggregator { Ok(()) } - fn finalize(self, total_duration: Duration) -> (BenchmarkReport, Vec) { + fn finalize( + self, + total_duration: Duration, + metrics: Option, + ) -> (BenchmarkReport, Vec) { let total_requests = self.successful_requests + self.failed_requests; let duration_secs = total_duration.as_secs_f64(); let prompt_tokens_per_second = if duration_secs > 0.0 { @@ -547,6 +625,7 @@ impl MetricsAggregator { latency_p90, latency_p99, failures: self.failures, + metrics, }; (report, self.dry_run_events) @@ -753,3 +832,85 @@ fn print_histogram(label: &str, data: &[usize], bins: usize, bar_width: usize) { ); } } + +#[cfg(test)] +mod tests { + use super::*; + use serde_json::json; + + #[test] + fn json_decoding_for_sglang_adds_response_format() { + let mut body = json!({ + "model": "m", + "messages": [{"role": "user", "content": "ping"}] + }); + + apply_json_decoding(&mut body, true); + + assert_eq!(body["response_format"], json!({"type": "json_object"})); + assert!(body.get("extra_body").is_none()); + } + + #[test] + fn json_decoding_for_vllm_adds_structured_outputs() { + let mut body = json!({ + "model": "m", + "messages": [{"role": "user", "content": "ping"}] + }); + + apply_json_decoding(&mut body, false); + + assert_eq!(body["structured_outputs"]["json_object"], json!(true)); + assert!(body.get("response_format").is_none()); + } + + #[test] + fn json_decoding_for_vllm_preserves_existing_structured_outputs_fields() { + let mut body = json!({ + "model": "m", + "priority": 1, + "structured_outputs": { + "regex": "[0-9]+" + } + }); + + apply_json_decoding(&mut body, false); + + assert_eq!(body["priority"], json!(1)); + assert_eq!(body["structured_outputs"]["regex"], json!("[0-9]+")); + assert_eq!(body["structured_outputs"]["json_object"], json!(true)); + } + + #[test] + fn qwen35_disable_thinking_adds_chat_template_kwargs() { + let mut body = json!({ + "model": "m", + "messages": [{"role": "user", "content": "ping"}] + }); + + apply_qwen35_disable_thinking(&mut body); + + assert_eq!( + body["chat_template_kwargs"]["enable_thinking"], + json!(false) + ); + } + + #[test] + fn qwen35_disable_thinking_preserves_existing_chat_template_kwargs_fields() { + let mut body = json!({ + "model": "m", + "chat_template_kwargs": { + "foo": "bar" + } + }); + + apply_qwen35_disable_thinking(&mut body); + + assert_eq!(body["chat_template_kwargs"]["foo"], json!("bar")); + assert_eq!( + body["chat_template_kwargs"]["enable_thinking"], + json!(false) + ); + } +} diff --git a/src/batchbench/harness.py b/src/batchbench/harness.py index ebc24df..4e591c5 100644 --- a/src/batchbench/harness.py +++ b/src/batchbench/harness.py @@ -11,11 +11,15 @@ """ import argparse +import base64 import hashlib +import io import json import os import re +import shlex import sys +import tarfile import time from concurrent.futures import ThreadPoolExecutor, as_completed from dataclasses import dataclass @@ -449,9 +453,35 @@ def run_benchmark(env: RemoteEnvironment, config: dict, run_dir: Path) -> None: f.write(stdout) print(f"Results saved to: {local_results}") + remote_metrics = bench_cfg.get("metrics-output-dir") + if remote_metrics: + fetch_metrics_artifacts(env, remote_metrics, run_dir / "metrics") + print("\nBenchmark complete!") +def fetch_metrics_artifacts(env: RemoteEnvironment, remote_dir: str, local_dir: Path) -> None: + """Save BatchBench metrics artifacts from container to local run directory.""" + print("\nSaving metrics artifacts...") + quoted_remote_dir = shlex.quote(remote_dir) + cmd = f"test -d {quoted_remote_dir} && tar -C {quoted_remote_dir} -czf - . | base64 -w0" + stdout, _, rc = env.exec(cmd, timeout=120) + if rc != 0 or not stdout.strip(): + print("Warning: Could not retrieve metrics artifacts") + return + + local_dir.mkdir(parents=True, exist_ok=True) + archive = base64.b64decode(stdout.strip()) + local_root = local_dir.resolve() + with tarfile.open(fileobj=io.BytesIO(archive), mode="r:gz") as tar: + for member in tar.getmembers(): + target = (local_dir / member.name).resolve() + if not target.is_relative_to(local_root): + raise PipelineError(f"Unsafe metrics archive path: {member.name}") + tar.extractall(local_dir) + print(f"Metrics artifacts saved to: {local_dir}") + + def wait_for_vllm_ready(env: RemoteEnvironment, port: int, timeout: int) -> None: print(f"\nWaiting for vLLM server to be ready (timeout: {timeout}s)...") print("-" * 60)