diff --git a/configs/runner_configs/runner_moorethreads_vllm_musa_e0266927.yaml.example b/configs/runner_configs/runner_moorethreads_vllm_musa_e0266927.yaml.example
new file mode 100644
index 00000000..e3877321
--- /dev/null
+++ b/configs/runner_configs/runner_moorethreads_vllm_musa_e0266927.yaml.example
@@ -0,0 +1,60 @@
+# AccelMark runner config — moorethreads_vllm_musa_e0266927 (vllm-musa on Moore Threads)
+#
+# Copy this file to runner_moorethreads_vllm_musa_e0266927.yaml (remove
+# .example suffix) and edit as needed for your hardware. The actual .yaml
+# is gitignored.
+#
+# These settings adapt the runner to your hardware environment. They are
+# recorded in result.json task.extra_config for transparency but are NOT
+# part of the benchmark identity (not hashed into run_id).
+#
+# Merge priority: CLI flags > suite-specific > global defaults > runner defaults
+
+# ── Global defaults (apply to all suites) ─────────────────────────────────────
+
+# Tensor parallel size — number of Moore Threads GPUs to use (default: 1).
+# For multi-card runs make sure to export VLLM_WORKER_MULTIPROC_METHOD=spawn.
+tensor_parallel_size: 1
+
+# Disable Triton CUDA-graph / compilation. Set true if you hit Triton kernel
+# errors on first request (most common on S3000 / S80 paths).
+enforce_eager: false
+
+# Maximum number of sequences in a batch (default: 256).
+# Reduce on lower-memory cards: 128 on 24 GB cards, 64 on 16 GB cards.
+max_num_seqs: 256
+
+# Fraction of MUSA HBM reserved for the KV cache (default: 0.85). Reduce if
+# you hit OOM; the vLLM flag is named gpu_memory_utilization but applies to
+# MUSA HBM via torchada.
+gpu_memory_utilization: 0.85
+
+# Pass-through kwargs forwarded directly to vLLM LLM() / AsyncEngineArgs().
+# Unknown keys are dropped automatically with a warning, so this is safe to
+# use across vLLM 0.10.x / 0.13.x.
+# engine_kwargs:
+# swap_space: 8
+# max_seq_len_to_capture: 4096
+
+# ── Suite-specific overrides ───────────────────────────────────────────────────
+
+suites:
+ suite_D:
+ # Long-context — reduce batch size and reserve more memory.
+ max_num_seqs: 32
+ gpu_memory_utilization: 0.80
+
+ suite_F:
+ max_num_seqs: 128
+
+# ── Speculative decoding (suite_A / suite_D extra scenario) ─────────────────
+# Uncomment to enable. vllm-musa accepts the same speculative_config dict as
+# upstream vLLM; the runner translates flat keys (speculative_model,
+# num_speculative_tokens, ...) into speculative_config automatically.
+#
+# suites:
+# suite_A:
+# engine_kwargs:
+# speculative_model: "meta-llama/Llama-3.2-1B-Instruct"
+# num_speculative_tokens: 4
+# speculative_draft_tensor_parallel_size: 1
diff --git a/results/community/mtt_s4000x4_suite_E_moorethreads_vllm_musa_e0266927_559dc817/1x/offline/result.json b/results/community/mtt_s4000x4_suite_E_moorethreads_vllm_musa_e0266927_559dc817/1x/offline/result.json
new file mode 100644
index 00000000..8c084ebe
--- /dev/null
+++ b/results/community/mtt_s4000x4_suite_E_moorethreads_vllm_musa_e0266927_559dc817/1x/offline/result.json
@@ -0,0 +1,229 @@
+{
+ "schema_version": "1.0",
+ "suite_id": "suite_E",
+ "implementation_id": "moorethreads_vllm_musa_e0266927",
+ "chip": {
+ "name": "MTT S4000",
+ "vendor": "Moore Threads",
+ "count": 1,
+ "card_count": 1,
+ "dies_per_card": 1,
+ "memory_gb": 48.0,
+ "interconnect_intra_node": null,
+ "interconnect_inter_node": null
+ },
+ "environment": {
+ "collected_at": "2026-09-08T17:51:04.613786+00:00",
+ "accelerators": [
+ {
+ "index": 0,
+ "name": "MTT S4000",
+ "vendor": "Moore Threads",
+ "memory_gb": 48.0,
+ "driver_version": "2.7.0",
+ "firmware_version": null,
+ "supports_bf16": true
+ },
+ {
+ "index": 1,
+ "name": "MTT S4000",
+ "vendor": "Moore Threads",
+ "memory_gb": 48.0,
+ "driver_version": "2.7.0",
+ "firmware_version": null,
+ "supports_bf16": true
+ },
+ {
+ "index": 2,
+ "name": "MTT S4000",
+ "vendor": "Moore Threads",
+ "memory_gb": 48.0,
+ "driver_version": "2.7.0",
+ "firmware_version": null,
+ "supports_bf16": true
+ },
+ {
+ "index": 3,
+ "name": "MTT S4000",
+ "vendor": "Moore Threads",
+ "memory_gb": 48.0,
+ "driver_version": "2.7.0",
+ "firmware_version": null,
+ "supports_bf16": true
+ }
+ ],
+ "accelerator_platform": "moorethreads",
+ "accelerator_topology": null,
+ "intra_node_interconnect": "MCCL/PCIe",
+ "cpu": {
+ "model": "Intel(R) Xeon(R) Gold 6430",
+ "physical_cores": 64,
+ "logical_cores": 128,
+ "numa_nodes": 2
+ },
+ "system_memory_gb": 1007.5,
+ "pcie_generation": "PCIe 16x/16x",
+ "cpu_accelerator_bandwidth_gbs": null,
+ "network_interfaces": [
+ {
+ "name": "mlx5_0",
+ "type": "InfiniBand/RoCE",
+ "bandwidth_gbps": null
+ },
+ {
+ "name": "mlx5_1",
+ "type": "InfiniBand/RoCE",
+ "bandwidth_gbps": null
+ },
+ {
+ "name": "mlx5_bond_0",
+ "type": "InfiniBand/RoCE",
+ "bandwidth_gbps": null
+ }
+ ],
+ "os": "Ubuntu Jammy Jellyfish (development branch)",
+ "python_version": "3.10.8",
+ "kernel_version": "5.15.0-105-generic",
+ "runtime_version": "Moore Threads Driver 2.7.0",
+ "pytorch_version": "2.2.0"
+ },
+ "software": {
+ "framework": "vllm-musa",
+ "framework_version": "0.4.2",
+ "driver_version": "2.7.0",
+ "runtime_version": "Moore Threads Driver 2.7.0",
+ "os": "Ubuntu Jammy Jellyfish (development branch)",
+ "python_version": "3.10.8"
+ },
+ "model": {
+ "model_id": "meta-llama/Meta-Llama-3-8B-Instruct",
+ "model_revision": "8afb486c1db24fe5011ec46dfbe5b5dccdb575c2",
+ "model_name": null,
+ "model_note": null,
+ "model_source": "local",
+ "architecture": "dense",
+ "parameter_count_b": 8.0,
+ "precision": "FP16",
+ "effective_dtype": "float16",
+ "quantization_method": null,
+ "model_format": "HuggingFace original"
+ },
+ "task": {
+ "scenario": "offline",
+ "num_runs": 3,
+ "warmup_runs": 1,
+ "parallelism": {
+ "tensor_parallel_size": 1,
+ "pipeline_parallel_size": 1,
+ "expert_parallel_size": 1,
+ "data_parallel_size": 1
+ },
+ "extra_config": null,
+ "runtime_metrics": null
+ },
+ "metrics": {
+ "offline": {
+ "results_by_concurrency": [
+ {
+ "client_concurrency": 8,
+ "throughput_tokens_per_sec": 410.16,
+ "throughput_tokens_per_sec_per_chip": 410.16,
+ "throughput_tokens_per_sec_total": 964.21,
+ "elapsed_seconds_median": 66.9,
+ "peak_memory_gb": null,
+ "power_watts_avg": null,
+ "power_watts_peak": null,
+ "oom": false,
+ "throughput_tokens_per_sec_reliability": {
+ "n": 3,
+ "mean": 410.14,
+ "std": 0.16,
+ "cv_pct": 0.04,
+ "stability": "stable",
+ "runs": [
+ 409.97,
+ 410.29,
+ 410.16
+ ]
+ },
+ "_throughput_note": "output_only",
+ "_concurrency_note": "client_concurrency is the number of requests sent simultaneously. The inference engine batches internally; this does not directly set engine parameters like max_num_seqs."
+ },
+ {
+ "client_concurrency": 32,
+ "throughput_tokens_per_sec": 410.34,
+ "throughput_tokens_per_sec_per_chip": 410.34,
+ "throughput_tokens_per_sec_total": 964.63,
+ "elapsed_seconds_median": 66.9,
+ "peak_memory_gb": null,
+ "power_watts_avg": null,
+ "power_watts_peak": null,
+ "oom": false,
+ "throughput_tokens_per_sec_reliability": {
+ "n": 3,
+ "mean": 410.15,
+ "std": 0.84,
+ "cv_pct": 0.2,
+ "stability": "stable",
+ "runs": [
+ 410.34,
+ 409.23,
+ 410.87
+ ]
+ },
+ "_throughput_note": "output_only",
+ "_concurrency_note": "client_concurrency is the number of requests sent simultaneously. The inference engine batches internally; this does not directly set engine parameters like max_num_seqs."
+ },
+ {
+ "client_concurrency": 128,
+ "throughput_tokens_per_sec": 410.6,
+ "throughput_tokens_per_sec_per_chip": 410.6,
+ "throughput_tokens_per_sec_total": 965.25,
+ "elapsed_seconds_median": 66.8,
+ "peak_memory_gb": null,
+ "power_watts_avg": null,
+ "power_watts_peak": null,
+ "oom": false,
+ "throughput_tokens_per_sec_reliability": {
+ "n": 3,
+ "mean": 410.41,
+ "std": 0.44,
+ "cv_pct": 0.11,
+ "stability": "stable",
+ "runs": [
+ 409.91,
+ 410.72,
+ 410.6
+ ]
+ },
+ "_throughput_note": "output_only",
+ "_concurrency_note": "client_concurrency is the number of requests sent simultaneously. The inference engine batches internally; this does not directly set engine parameters like max_num_seqs."
+ }
+ ]
+ }
+ },
+ "accuracy": {
+ "subset_score": null,
+ "baseline_delta": null,
+ "valid": false,
+ "notes": "Run --scenario accuracy to check model accuracy."
+ },
+ "meta": {
+ "submitted_by": "Keke946",
+ "submission_type": "individual",
+ "date": "2026-09-09",
+ "time": "02:36:24",
+ "run_id": "ba95dc30",
+ "run_name": "mtt_s4000x1_suite_E_moorethreads_vllm_musa_e0266927_ba95dc30",
+ "flagged": null,
+ "reproduce_script": "runners/moorethreads_vllm_musa_e0266927/runner.py",
+ "env_info_file": "../../env_info.json",
+ "log_file": "run.log",
+ "samples_file": "samples.jsonl",
+ "notes": null,
+ "benchmark_start_time": "2026-09-08T18:23:00.513416+00:00",
+ "benchmark_end_time": "2026-09-08T18:36:24.149660+00:00",
+ "benchmark_elapsed_minutes": 13.4,
+ "model_load_seconds": 123.2
+ }
+}
\ No newline at end of file
diff --git a/results/community/mtt_s4000x4_suite_E_moorethreads_vllm_musa_e0266927_559dc817/1x/result.json b/results/community/mtt_s4000x4_suite_E_moorethreads_vllm_musa_e0266927_559dc817/1x/result.json
new file mode 100644
index 00000000..0ff258ce
--- /dev/null
+++ b/results/community/mtt_s4000x4_suite_E_moorethreads_vllm_musa_e0266927_559dc817/1x/result.json
@@ -0,0 +1,234 @@
+{
+ "schema_version": "1.0",
+ "suite_id": "suite_E",
+ "implementation_id": "moorethreads_vllm_musa_e0266927",
+ "chip": {
+ "name": "MTT S4000",
+ "vendor": "Moore Threads",
+ "count": 1,
+ "card_count": 1,
+ "dies_per_card": 1,
+ "memory_gb": 48.0,
+ "interconnect_intra_node": null,
+ "interconnect_inter_node": null
+ },
+ "environment": {
+ "collected_at": "2026-09-08T17:51:04.613786+00:00",
+ "accelerators": [
+ {
+ "index": 0,
+ "name": "MTT S4000",
+ "vendor": "Moore Threads",
+ "memory_gb": 48.0,
+ "driver_version": "2.7.0",
+ "firmware_version": null,
+ "supports_bf16": true
+ },
+ {
+ "index": 1,
+ "name": "MTT S4000",
+ "vendor": "Moore Threads",
+ "memory_gb": 48.0,
+ "driver_version": "2.7.0",
+ "firmware_version": null,
+ "supports_bf16": true
+ },
+ {
+ "index": 2,
+ "name": "MTT S4000",
+ "vendor": "Moore Threads",
+ "memory_gb": 48.0,
+ "driver_version": "2.7.0",
+ "firmware_version": null,
+ "supports_bf16": true
+ },
+ {
+ "index": 3,
+ "name": "MTT S4000",
+ "vendor": "Moore Threads",
+ "memory_gb": 48.0,
+ "driver_version": "2.7.0",
+ "firmware_version": null,
+ "supports_bf16": true
+ }
+ ],
+ "accelerator_platform": "moorethreads",
+ "accelerator_topology": null,
+ "intra_node_interconnect": "MCCL/PCIe",
+ "cpu": {
+ "model": "Intel(R) Xeon(R) Gold 6430",
+ "physical_cores": 64,
+ "logical_cores": 128,
+ "numa_nodes": 2
+ },
+ "system_memory_gb": 1007.5,
+ "pcie_generation": "PCIe 16x/16x",
+ "cpu_accelerator_bandwidth_gbs": null,
+ "network_interfaces": [
+ {
+ "name": "mlx5_0",
+ "type": "InfiniBand/RoCE",
+ "bandwidth_gbps": null
+ },
+ {
+ "name": "mlx5_1",
+ "type": "InfiniBand/RoCE",
+ "bandwidth_gbps": null
+ },
+ {
+ "name": "mlx5_bond_0",
+ "type": "InfiniBand/RoCE",
+ "bandwidth_gbps": null
+ }
+ ],
+ "os": "Ubuntu Jammy Jellyfish (development branch)",
+ "python_version": "3.10.8",
+ "kernel_version": "5.15.0-105-generic",
+ "runtime_version": "Moore Threads Driver 2.7.0",
+ "pytorch_version": "2.2.0"
+ },
+ "software": {
+ "framework": "vllm-musa",
+ "framework_version": "0.4.2",
+ "driver_version": "2.7.0",
+ "runtime_version": "Moore Threads Driver 2.7.0",
+ "os": "Ubuntu Jammy Jellyfish (development branch)",
+ "python_version": "3.10.8"
+ },
+ "model": {
+ "model_id": "meta-llama/Meta-Llama-3-8B-Instruct",
+ "model_revision": "8afb486c1db24fe5011ec46dfbe5b5dccdb575c2",
+ "model_name": null,
+ "model_note": null,
+ "model_source": "local",
+ "architecture": "dense",
+ "parameter_count_b": 8.0,
+ "precision": "FP16",
+ "effective_dtype": "float16",
+ "quantization_method": null,
+ "model_format": "HuggingFace original"
+ },
+ "task": {
+ "scenarios_run": [
+ "offline"
+ ],
+ "parallelism": {
+ "tensor_parallel_size": 1,
+ "pipeline_parallel_size": 1,
+ "expert_parallel_size": 1,
+ "data_parallel_size": 1
+ },
+ "num_runs": 3,
+ "extra_config": null
+ },
+ "metrics": {
+ "derived": {},
+ "offline": {
+ "results_by_concurrency": [
+ {
+ "client_concurrency": 8,
+ "throughput_tokens_per_sec": 410.16,
+ "throughput_tokens_per_sec_per_chip": 410.16,
+ "throughput_tokens_per_sec_total": 964.21,
+ "elapsed_seconds_median": 66.9,
+ "peak_memory_gb": null,
+ "power_watts_avg": null,
+ "power_watts_peak": null,
+ "oom": false,
+ "throughput_tokens_per_sec_reliability": {
+ "n": 3,
+ "mean": 410.14,
+ "std": 0.16,
+ "cv_pct": 0.04,
+ "stability": "stable",
+ "runs": [
+ 409.97,
+ 410.29,
+ 410.16
+ ]
+ },
+ "_throughput_note": "output_only",
+ "_concurrency_note": "client_concurrency is the number of requests sent simultaneously. The inference engine batches internally; this does not directly set engine parameters like max_num_seqs."
+ },
+ {
+ "client_concurrency": 32,
+ "throughput_tokens_per_sec": 410.34,
+ "throughput_tokens_per_sec_per_chip": 410.34,
+ "throughput_tokens_per_sec_total": 964.63,
+ "elapsed_seconds_median": 66.9,
+ "peak_memory_gb": null,
+ "power_watts_avg": null,
+ "power_watts_peak": null,
+ "oom": false,
+ "throughput_tokens_per_sec_reliability": {
+ "n": 3,
+ "mean": 410.15,
+ "std": 0.84,
+ "cv_pct": 0.2,
+ "stability": "stable",
+ "runs": [
+ 410.34,
+ 409.23,
+ 410.87
+ ]
+ },
+ "_throughput_note": "output_only",
+ "_concurrency_note": "client_concurrency is the number of requests sent simultaneously. The inference engine batches internally; this does not directly set engine parameters like max_num_seqs."
+ },
+ {
+ "client_concurrency": 128,
+ "throughput_tokens_per_sec": 410.6,
+ "throughput_tokens_per_sec_per_chip": 410.6,
+ "throughput_tokens_per_sec_total": 965.25,
+ "elapsed_seconds_median": 66.8,
+ "peak_memory_gb": null,
+ "power_watts_avg": null,
+ "power_watts_peak": null,
+ "oom": false,
+ "throughput_tokens_per_sec_reliability": {
+ "n": 3,
+ "mean": 410.41,
+ "std": 0.44,
+ "cv_pct": 0.11,
+ "stability": "stable",
+ "runs": [
+ 409.91,
+ 410.72,
+ 410.6
+ ]
+ },
+ "_throughput_note": "output_only",
+ "_concurrency_note": "client_concurrency is the number of requests sent simultaneously. The inference engine batches internally; this does not directly set engine parameters like max_num_seqs."
+ }
+ ]
+ }
+ },
+ "accuracy": {
+ "subset_score": null,
+ "baseline_delta": null,
+ "valid": false,
+ "notes": "Run --scenario accuracy to populate."
+ },
+ "meta": {
+ "submitted_by": "Keke946",
+ "submission_type": "individual",
+ "date": "2026-09-09",
+ "time": "02:36:24",
+ "run_id": "ba95dc30",
+ "run_name": "mtt_s4000x1_suite_E_moorethreads_vllm_musa_e0266927_ba95dc30",
+ "flagged": null,
+ "reproduce_script": "runners/moorethreads_vllm_musa_e0266927/runner.py",
+ "env_info_file": "../../env_info.json",
+ "log_file": "run.log",
+ "samples_file": "samples.jsonl",
+ "notes": null,
+ "benchmark_start_time": "2026-09-08T18:23:00.513416+00:00",
+ "benchmark_end_time": "2026-09-08T18:36:24.149660+00:00",
+ "benchmark_elapsed_minutes": 13.4,
+ "model_load_seconds": 123.2,
+ "benchmark_elapsed_minutes_note": "Total across ['offline'] scenarios.",
+ "scenario_dirs": {
+ "offline": "results/community/mtt_s4000x4_suite_E_moorethreads_vllm_musa_e0266927_559dc817/1x/offline"
+ }
+ }
+}
\ No newline at end of file
diff --git a/results/community/mtt_s4000x4_suite_E_moorethreads_vllm_musa_e0266927_559dc817/2x/offline/result.json b/results/community/mtt_s4000x4_suite_E_moorethreads_vllm_musa_e0266927_559dc817/2x/offline/result.json
new file mode 100644
index 00000000..8fb93221
--- /dev/null
+++ b/results/community/mtt_s4000x4_suite_E_moorethreads_vllm_musa_e0266927_559dc817/2x/offline/result.json
@@ -0,0 +1,229 @@
+{
+ "schema_version": "1.0",
+ "suite_id": "suite_E",
+ "implementation_id": "moorethreads_vllm_musa_e0266927",
+ "chip": {
+ "name": "MTT S4000",
+ "vendor": "Moore Threads",
+ "count": 2,
+ "card_count": 2,
+ "dies_per_card": 1,
+ "memory_gb": 48.0,
+ "interconnect_intra_node": "MCCL/PCIe",
+ "interconnect_inter_node": null
+ },
+ "environment": {
+ "collected_at": "2026-09-08T17:51:04.613786+00:00",
+ "accelerators": [
+ {
+ "index": 0,
+ "name": "MTT S4000",
+ "vendor": "Moore Threads",
+ "memory_gb": 48.0,
+ "driver_version": "2.7.0",
+ "firmware_version": null,
+ "supports_bf16": true
+ },
+ {
+ "index": 1,
+ "name": "MTT S4000",
+ "vendor": "Moore Threads",
+ "memory_gb": 48.0,
+ "driver_version": "2.7.0",
+ "firmware_version": null,
+ "supports_bf16": true
+ },
+ {
+ "index": 2,
+ "name": "MTT S4000",
+ "vendor": "Moore Threads",
+ "memory_gb": 48.0,
+ "driver_version": "2.7.0",
+ "firmware_version": null,
+ "supports_bf16": true
+ },
+ {
+ "index": 3,
+ "name": "MTT S4000",
+ "vendor": "Moore Threads",
+ "memory_gb": 48.0,
+ "driver_version": "2.7.0",
+ "firmware_version": null,
+ "supports_bf16": true
+ }
+ ],
+ "accelerator_platform": "moorethreads",
+ "accelerator_topology": null,
+ "intra_node_interconnect": "MCCL/PCIe",
+ "cpu": {
+ "model": "Intel(R) Xeon(R) Gold 6430",
+ "physical_cores": 64,
+ "logical_cores": 128,
+ "numa_nodes": 2
+ },
+ "system_memory_gb": 1007.5,
+ "pcie_generation": "PCIe 16x/16x",
+ "cpu_accelerator_bandwidth_gbs": null,
+ "network_interfaces": [
+ {
+ "name": "mlx5_0",
+ "type": "InfiniBand/RoCE",
+ "bandwidth_gbps": null
+ },
+ {
+ "name": "mlx5_1",
+ "type": "InfiniBand/RoCE",
+ "bandwidth_gbps": null
+ },
+ {
+ "name": "mlx5_bond_0",
+ "type": "InfiniBand/RoCE",
+ "bandwidth_gbps": null
+ }
+ ],
+ "os": "Ubuntu Jammy Jellyfish (development branch)",
+ "python_version": "3.10.8",
+ "kernel_version": "5.15.0-105-generic",
+ "runtime_version": "Moore Threads Driver 2.7.0",
+ "pytorch_version": "2.2.0"
+ },
+ "software": {
+ "framework": "vllm-musa",
+ "framework_version": "0.4.2",
+ "driver_version": "2.7.0",
+ "runtime_version": "Moore Threads Driver 2.7.0",
+ "os": "Ubuntu Jammy Jellyfish (development branch)",
+ "python_version": "3.10.8"
+ },
+ "model": {
+ "model_id": "meta-llama/Meta-Llama-3-8B-Instruct",
+ "model_revision": "8afb486c1db24fe5011ec46dfbe5b5dccdb575c2",
+ "model_name": null,
+ "model_note": null,
+ "model_source": "local",
+ "architecture": "dense",
+ "parameter_count_b": 8.0,
+ "precision": "FP16",
+ "effective_dtype": "float16",
+ "quantization_method": null,
+ "model_format": "HuggingFace original"
+ },
+ "task": {
+ "scenario": "offline",
+ "num_runs": 3,
+ "warmup_runs": 1,
+ "parallelism": {
+ "tensor_parallel_size": 2,
+ "pipeline_parallel_size": 1,
+ "expert_parallel_size": 1,
+ "data_parallel_size": 1
+ },
+ "extra_config": null,
+ "runtime_metrics": null
+ },
+ "metrics": {
+ "offline": {
+ "results_by_concurrency": [
+ {
+ "client_concurrency": 8,
+ "throughput_tokens_per_sec": 473.16,
+ "throughput_tokens_per_sec_per_chip": 236.58,
+ "throughput_tokens_per_sec_total": 1111.64,
+ "elapsed_seconds_median": 58.1,
+ "peak_memory_gb": null,
+ "power_watts_avg": null,
+ "power_watts_peak": null,
+ "oom": false,
+ "throughput_tokens_per_sec_reliability": {
+ "n": 3,
+ "mean": 472.64,
+ "std": 2.09,
+ "cv_pct": 0.44,
+ "stability": "stable",
+ "runs": [
+ 474.43,
+ 473.16,
+ 470.34
+ ]
+ },
+ "_throughput_note": "output_only",
+ "_concurrency_note": "client_concurrency is the number of requests sent simultaneously. The inference engine batches internally; this does not directly set engine parameters like max_num_seqs."
+ },
+ {
+ "client_concurrency": 32,
+ "throughput_tokens_per_sec": 469.92,
+ "throughput_tokens_per_sec_per_chip": 234.96,
+ "throughput_tokens_per_sec_total": 1104.02,
+ "elapsed_seconds_median": 58.5,
+ "peak_memory_gb": null,
+ "power_watts_avg": null,
+ "power_watts_peak": null,
+ "oom": false,
+ "throughput_tokens_per_sec_reliability": {
+ "n": 3,
+ "mean": 469.27,
+ "std": 1.2,
+ "cv_pct": 0.26,
+ "stability": "stable",
+ "runs": [
+ 470.0,
+ 469.92,
+ 467.88
+ ]
+ },
+ "_throughput_note": "output_only",
+ "_concurrency_note": "client_concurrency is the number of requests sent simultaneously. The inference engine batches internally; this does not directly set engine parameters like max_num_seqs."
+ },
+ {
+ "client_concurrency": 128,
+ "throughput_tokens_per_sec": 468.21,
+ "throughput_tokens_per_sec_per_chip": 234.11,
+ "throughput_tokens_per_sec_total": 1100.01,
+ "elapsed_seconds_median": 58.7,
+ "peak_memory_gb": null,
+ "power_watts_avg": null,
+ "power_watts_peak": null,
+ "oom": false,
+ "throughput_tokens_per_sec_reliability": {
+ "n": 3,
+ "mean": 468.32,
+ "std": 0.7,
+ "cv_pct": 0.15,
+ "stability": "stable",
+ "runs": [
+ 468.21,
+ 467.68,
+ 469.06
+ ]
+ },
+ "_throughput_note": "output_only",
+ "_concurrency_note": "client_concurrency is the number of requests sent simultaneously. The inference engine batches internally; this does not directly set engine parameters like max_num_seqs."
+ }
+ ]
+ }
+ },
+ "accuracy": {
+ "subset_score": null,
+ "baseline_delta": null,
+ "valid": false,
+ "notes": "Run --scenario accuracy to check model accuracy."
+ },
+ "meta": {
+ "submitted_by": "Keke946",
+ "submission_type": "individual",
+ "date": "2026-09-09",
+ "time": "02:20:32",
+ "run_id": "bc213e2a",
+ "run_name": "mtt_s4000x2_suite_E_moorethreads_vllm_musa_e0266927_bc213e2a",
+ "flagged": null,
+ "reproduce_script": "runners/moorethreads_vllm_musa_e0266927/runner.py",
+ "env_info_file": "../../env_info.json",
+ "log_file": "run.log",
+ "samples_file": "samples.jsonl",
+ "notes": null,
+ "benchmark_start_time": "2026-09-08T18:08:50.502588+00:00",
+ "benchmark_end_time": "2026-09-08T18:20:32.906620+00:00",
+ "benchmark_elapsed_minutes": 11.7,
+ "model_load_seconds": 123.1
+ }
+}
\ No newline at end of file
diff --git a/results/community/mtt_s4000x4_suite_E_moorethreads_vllm_musa_e0266927_559dc817/2x/result.json b/results/community/mtt_s4000x4_suite_E_moorethreads_vllm_musa_e0266927_559dc817/2x/result.json
new file mode 100644
index 00000000..08a60b84
--- /dev/null
+++ b/results/community/mtt_s4000x4_suite_E_moorethreads_vllm_musa_e0266927_559dc817/2x/result.json
@@ -0,0 +1,234 @@
+{
+ "schema_version": "1.0",
+ "suite_id": "suite_E",
+ "implementation_id": "moorethreads_vllm_musa_e0266927",
+ "chip": {
+ "name": "MTT S4000",
+ "vendor": "Moore Threads",
+ "count": 2,
+ "card_count": 2,
+ "dies_per_card": 1,
+ "memory_gb": 48.0,
+ "interconnect_intra_node": "MCCL/PCIe",
+ "interconnect_inter_node": null
+ },
+ "environment": {
+ "collected_at": "2026-09-08T17:51:04.613786+00:00",
+ "accelerators": [
+ {
+ "index": 0,
+ "name": "MTT S4000",
+ "vendor": "Moore Threads",
+ "memory_gb": 48.0,
+ "driver_version": "2.7.0",
+ "firmware_version": null,
+ "supports_bf16": true
+ },
+ {
+ "index": 1,
+ "name": "MTT S4000",
+ "vendor": "Moore Threads",
+ "memory_gb": 48.0,
+ "driver_version": "2.7.0",
+ "firmware_version": null,
+ "supports_bf16": true
+ },
+ {
+ "index": 2,
+ "name": "MTT S4000",
+ "vendor": "Moore Threads",
+ "memory_gb": 48.0,
+ "driver_version": "2.7.0",
+ "firmware_version": null,
+ "supports_bf16": true
+ },
+ {
+ "index": 3,
+ "name": "MTT S4000",
+ "vendor": "Moore Threads",
+ "memory_gb": 48.0,
+ "driver_version": "2.7.0",
+ "firmware_version": null,
+ "supports_bf16": true
+ }
+ ],
+ "accelerator_platform": "moorethreads",
+ "accelerator_topology": null,
+ "intra_node_interconnect": "MCCL/PCIe",
+ "cpu": {
+ "model": "Intel(R) Xeon(R) Gold 6430",
+ "physical_cores": 64,
+ "logical_cores": 128,
+ "numa_nodes": 2
+ },
+ "system_memory_gb": 1007.5,
+ "pcie_generation": "PCIe 16x/16x",
+ "cpu_accelerator_bandwidth_gbs": null,
+ "network_interfaces": [
+ {
+ "name": "mlx5_0",
+ "type": "InfiniBand/RoCE",
+ "bandwidth_gbps": null
+ },
+ {
+ "name": "mlx5_1",
+ "type": "InfiniBand/RoCE",
+ "bandwidth_gbps": null
+ },
+ {
+ "name": "mlx5_bond_0",
+ "type": "InfiniBand/RoCE",
+ "bandwidth_gbps": null
+ }
+ ],
+ "os": "Ubuntu Jammy Jellyfish (development branch)",
+ "python_version": "3.10.8",
+ "kernel_version": "5.15.0-105-generic",
+ "runtime_version": "Moore Threads Driver 2.7.0",
+ "pytorch_version": "2.2.0"
+ },
+ "software": {
+ "framework": "vllm-musa",
+ "framework_version": "0.4.2",
+ "driver_version": "2.7.0",
+ "runtime_version": "Moore Threads Driver 2.7.0",
+ "os": "Ubuntu Jammy Jellyfish (development branch)",
+ "python_version": "3.10.8"
+ },
+ "model": {
+ "model_id": "meta-llama/Meta-Llama-3-8B-Instruct",
+ "model_revision": "8afb486c1db24fe5011ec46dfbe5b5dccdb575c2",
+ "model_name": null,
+ "model_note": null,
+ "model_source": "local",
+ "architecture": "dense",
+ "parameter_count_b": 8.0,
+ "precision": "FP16",
+ "effective_dtype": "float16",
+ "quantization_method": null,
+ "model_format": "HuggingFace original"
+ },
+ "task": {
+ "scenarios_run": [
+ "offline"
+ ],
+ "parallelism": {
+ "tensor_parallel_size": 2,
+ "pipeline_parallel_size": 1,
+ "expert_parallel_size": 1,
+ "data_parallel_size": 1
+ },
+ "num_runs": 3,
+ "extra_config": null
+ },
+ "metrics": {
+ "derived": {},
+ "offline": {
+ "results_by_concurrency": [
+ {
+ "client_concurrency": 8,
+ "throughput_tokens_per_sec": 473.16,
+ "throughput_tokens_per_sec_per_chip": 236.58,
+ "throughput_tokens_per_sec_total": 1111.64,
+ "elapsed_seconds_median": 58.1,
+ "peak_memory_gb": null,
+ "power_watts_avg": null,
+ "power_watts_peak": null,
+ "oom": false,
+ "throughput_tokens_per_sec_reliability": {
+ "n": 3,
+ "mean": 472.64,
+ "std": 2.09,
+ "cv_pct": 0.44,
+ "stability": "stable",
+ "runs": [
+ 474.43,
+ 473.16,
+ 470.34
+ ]
+ },
+ "_throughput_note": "output_only",
+ "_concurrency_note": "client_concurrency is the number of requests sent simultaneously. The inference engine batches internally; this does not directly set engine parameters like max_num_seqs."
+ },
+ {
+ "client_concurrency": 32,
+ "throughput_tokens_per_sec": 469.92,
+ "throughput_tokens_per_sec_per_chip": 234.96,
+ "throughput_tokens_per_sec_total": 1104.02,
+ "elapsed_seconds_median": 58.5,
+ "peak_memory_gb": null,
+ "power_watts_avg": null,
+ "power_watts_peak": null,
+ "oom": false,
+ "throughput_tokens_per_sec_reliability": {
+ "n": 3,
+ "mean": 469.27,
+ "std": 1.2,
+ "cv_pct": 0.26,
+ "stability": "stable",
+ "runs": [
+ 470.0,
+ 469.92,
+ 467.88
+ ]
+ },
+ "_throughput_note": "output_only",
+ "_concurrency_note": "client_concurrency is the number of requests sent simultaneously. The inference engine batches internally; this does not directly set engine parameters like max_num_seqs."
+ },
+ {
+ "client_concurrency": 128,
+ "throughput_tokens_per_sec": 468.21,
+ "throughput_tokens_per_sec_per_chip": 234.11,
+ "throughput_tokens_per_sec_total": 1100.01,
+ "elapsed_seconds_median": 58.7,
+ "peak_memory_gb": null,
+ "power_watts_avg": null,
+ "power_watts_peak": null,
+ "oom": false,
+ "throughput_tokens_per_sec_reliability": {
+ "n": 3,
+ "mean": 468.32,
+ "std": 0.7,
+ "cv_pct": 0.15,
+ "stability": "stable",
+ "runs": [
+ 468.21,
+ 467.68,
+ 469.06
+ ]
+ },
+ "_throughput_note": "output_only",
+ "_concurrency_note": "client_concurrency is the number of requests sent simultaneously. The inference engine batches internally; this does not directly set engine parameters like max_num_seqs."
+ }
+ ]
+ }
+ },
+ "accuracy": {
+ "subset_score": null,
+ "baseline_delta": null,
+ "valid": false,
+ "notes": "Run --scenario accuracy to populate."
+ },
+ "meta": {
+ "submitted_by": "Keke946",
+ "submission_type": "individual",
+ "date": "2026-09-09",
+ "time": "02:20:32",
+ "run_id": "bc213e2a",
+ "run_name": "mtt_s4000x2_suite_E_moorethreads_vllm_musa_e0266927_bc213e2a",
+ "flagged": null,
+ "reproduce_script": "runners/moorethreads_vllm_musa_e0266927/runner.py",
+ "env_info_file": "../../env_info.json",
+ "log_file": "run.log",
+ "samples_file": "samples.jsonl",
+ "notes": null,
+ "benchmark_start_time": "2026-09-08T18:08:50.502588+00:00",
+ "benchmark_end_time": "2026-09-08T18:20:32.906620+00:00",
+ "benchmark_elapsed_minutes": 11.7,
+ "model_load_seconds": 123.1,
+ "benchmark_elapsed_minutes_note": "Total across ['offline'] scenarios.",
+ "scenario_dirs": {
+ "offline": "results/community/mtt_s4000x4_suite_E_moorethreads_vllm_musa_e0266927_559dc817/2x/offline"
+ }
+ }
+}
\ No newline at end of file
diff --git a/results/community/mtt_s4000x4_suite_E_moorethreads_vllm_musa_e0266927_559dc817/4x/offline/result.json b/results/community/mtt_s4000x4_suite_E_moorethreads_vllm_musa_e0266927_559dc817/4x/offline/result.json
new file mode 100644
index 00000000..c0f76bfd
--- /dev/null
+++ b/results/community/mtt_s4000x4_suite_E_moorethreads_vllm_musa_e0266927_559dc817/4x/offline/result.json
@@ -0,0 +1,229 @@
+{
+ "schema_version": "1.0",
+ "suite_id": "suite_E",
+ "implementation_id": "moorethreads_vllm_musa_e0266927",
+ "chip": {
+ "name": "MTT S4000",
+ "vendor": "Moore Threads",
+ "count": 4,
+ "card_count": 4,
+ "dies_per_card": 1,
+ "memory_gb": 48.0,
+ "interconnect_intra_node": "MCCL/PCIe",
+ "interconnect_inter_node": null
+ },
+ "environment": {
+ "collected_at": "2026-09-08T17:51:04.613786+00:00",
+ "accelerators": [
+ {
+ "index": 0,
+ "name": "MTT S4000",
+ "vendor": "Moore Threads",
+ "memory_gb": 48.0,
+ "driver_version": "2.7.0",
+ "firmware_version": null,
+ "supports_bf16": true
+ },
+ {
+ "index": 1,
+ "name": "MTT S4000",
+ "vendor": "Moore Threads",
+ "memory_gb": 48.0,
+ "driver_version": "2.7.0",
+ "firmware_version": null,
+ "supports_bf16": true
+ },
+ {
+ "index": 2,
+ "name": "MTT S4000",
+ "vendor": "Moore Threads",
+ "memory_gb": 48.0,
+ "driver_version": "2.7.0",
+ "firmware_version": null,
+ "supports_bf16": true
+ },
+ {
+ "index": 3,
+ "name": "MTT S4000",
+ "vendor": "Moore Threads",
+ "memory_gb": 48.0,
+ "driver_version": "2.7.0",
+ "firmware_version": null,
+ "supports_bf16": true
+ }
+ ],
+ "accelerator_platform": "moorethreads",
+ "accelerator_topology": null,
+ "intra_node_interconnect": "MCCL/PCIe",
+ "cpu": {
+ "model": "Intel(R) Xeon(R) Gold 6430",
+ "physical_cores": 64,
+ "logical_cores": 128,
+ "numa_nodes": 2
+ },
+ "system_memory_gb": 1007.5,
+ "pcie_generation": "PCIe 16x/16x",
+ "cpu_accelerator_bandwidth_gbs": null,
+ "network_interfaces": [
+ {
+ "name": "mlx5_0",
+ "type": "InfiniBand/RoCE",
+ "bandwidth_gbps": null
+ },
+ {
+ "name": "mlx5_1",
+ "type": "InfiniBand/RoCE",
+ "bandwidth_gbps": null
+ },
+ {
+ "name": "mlx5_bond_0",
+ "type": "InfiniBand/RoCE",
+ "bandwidth_gbps": null
+ }
+ ],
+ "os": "Ubuntu Jammy Jellyfish (development branch)",
+ "python_version": "3.10.8",
+ "kernel_version": "5.15.0-105-generic",
+ "runtime_version": "Moore Threads Driver 2.7.0",
+ "pytorch_version": "2.2.0"
+ },
+ "software": {
+ "framework": "vllm-musa",
+ "framework_version": "0.4.2",
+ "driver_version": "2.7.0",
+ "runtime_version": "Moore Threads Driver 2.7.0",
+ "os": "Ubuntu Jammy Jellyfish (development branch)",
+ "python_version": "3.10.8"
+ },
+ "model": {
+ "model_id": "meta-llama/Meta-Llama-3-8B-Instruct",
+ "model_revision": "8afb486c1db24fe5011ec46dfbe5b5dccdb575c2",
+ "model_name": null,
+ "model_note": null,
+ "model_source": "local",
+ "architecture": "dense",
+ "parameter_count_b": 8.0,
+ "precision": "FP16",
+ "effective_dtype": "float16",
+ "quantization_method": null,
+ "model_format": "HuggingFace original"
+ },
+ "task": {
+ "scenario": "offline",
+ "num_runs": 3,
+ "warmup_runs": 1,
+ "parallelism": {
+ "tensor_parallel_size": 4,
+ "pipeline_parallel_size": 1,
+ "expert_parallel_size": 1,
+ "data_parallel_size": 1
+ },
+ "extra_config": null,
+ "runtime_metrics": null
+ },
+ "metrics": {
+ "offline": {
+ "results_by_concurrency": [
+ {
+ "client_concurrency": 8,
+ "throughput_tokens_per_sec": 532.61,
+ "throughput_tokens_per_sec_per_chip": 133.15,
+ "throughput_tokens_per_sec_total": 1253.59,
+ "elapsed_seconds_median": 51.4,
+ "peak_memory_gb": null,
+ "power_watts_avg": null,
+ "power_watts_peak": null,
+ "oom": false,
+ "throughput_tokens_per_sec_reliability": {
+ "n": 3,
+ "mean": 532.57,
+ "std": 0.25,
+ "cv_pct": 0.05,
+ "stability": "stable",
+ "runs": [
+ 532.61,
+ 532.8,
+ 532.3
+ ]
+ },
+ "_throughput_note": "output_only",
+ "_concurrency_note": "client_concurrency is the number of requests sent simultaneously. The inference engine batches internally; this does not directly set engine parameters like max_num_seqs."
+ },
+ {
+ "client_concurrency": 32,
+ "throughput_tokens_per_sec": 528.67,
+ "throughput_tokens_per_sec_per_chip": 132.17,
+ "throughput_tokens_per_sec_total": 1244.31,
+ "elapsed_seconds_median": 51.8,
+ "peak_memory_gb": null,
+ "power_watts_avg": null,
+ "power_watts_peak": null,
+ "oom": false,
+ "throughput_tokens_per_sec_reliability": {
+ "n": 3,
+ "mean": 528.77,
+ "std": 0.34,
+ "cv_pct": 0.06,
+ "stability": "stable",
+ "runs": [
+ 528.5,
+ 528.67,
+ 529.15
+ ]
+ },
+ "_throughput_note": "output_only",
+ "_concurrency_note": "client_concurrency is the number of requests sent simultaneously. The inference engine batches internally; this does not directly set engine parameters like max_num_seqs."
+ },
+ {
+ "client_concurrency": 128,
+ "throughput_tokens_per_sec": 524.51,
+ "throughput_tokens_per_sec_per_chip": 131.13,
+ "throughput_tokens_per_sec_total": 1234.52,
+ "elapsed_seconds_median": 52.2,
+ "peak_memory_gb": null,
+ "power_watts_avg": null,
+ "power_watts_peak": null,
+ "oom": false,
+ "throughput_tokens_per_sec_reliability": {
+ "n": 3,
+ "mean": 524.52,
+ "std": 1.15,
+ "cv_pct": 0.22,
+ "stability": "stable",
+ "runs": [
+ 524.51,
+ 525.68,
+ 523.37
+ ]
+ },
+ "_throughput_note": "output_only",
+ "_concurrency_note": "client_concurrency is the number of requests sent simultaneously. The inference engine batches internally; this does not directly set engine parameters like max_num_seqs."
+ }
+ ]
+ }
+ },
+ "accuracy": {
+ "subset_score": null,
+ "baseline_delta": null,
+ "valid": false,
+ "notes": "Run --scenario accuracy to check model accuracy."
+ },
+ "meta": {
+ "submitted_by": "Keke946",
+ "submission_type": "individual",
+ "date": "2026-09-09",
+ "time": "02:06:21",
+ "run_id": "559dc817",
+ "run_name": "mtt_s4000x4_suite_E_moorethreads_vllm_musa_e0266927_559dc817",
+ "flagged": null,
+ "reproduce_script": "runners/moorethreads_vllm_musa_e0266927/runner.py",
+ "env_info_file": "../../env_info.json",
+ "log_file": "run.log",
+ "samples_file": "samples.jsonl",
+ "notes": null,
+ "benchmark_start_time": "2026-09-08T17:55:58.630224+00:00",
+ "benchmark_end_time": "2026-09-08T18:06:21.927438+00:00",
+ "benchmark_elapsed_minutes": 10.4,
+ "model_load_seconds": 139.2
+ }
+}
\ No newline at end of file
diff --git a/results/community/mtt_s4000x4_suite_E_moorethreads_vllm_musa_e0266927_559dc817/4x/result.json b/results/community/mtt_s4000x4_suite_E_moorethreads_vllm_musa_e0266927_559dc817/4x/result.json
new file mode 100644
index 00000000..496dd060
--- /dev/null
+++ b/results/community/mtt_s4000x4_suite_E_moorethreads_vllm_musa_e0266927_559dc817/4x/result.json
@@ -0,0 +1,234 @@
+{
+ "schema_version": "1.0",
+ "suite_id": "suite_E",
+ "implementation_id": "moorethreads_vllm_musa_e0266927",
+ "chip": {
+ "name": "MTT S4000",
+ "vendor": "Moore Threads",
+ "count": 4,
+ "card_count": 4,
+ "dies_per_card": 1,
+ "memory_gb": 48.0,
+ "interconnect_intra_node": "MCCL/PCIe",
+ "interconnect_inter_node": null
+ },
+ "environment": {
+ "collected_at": "2026-09-08T17:51:04.613786+00:00",
+ "accelerators": [
+ {
+ "index": 0,
+ "name": "MTT S4000",
+ "vendor": "Moore Threads",
+ "memory_gb": 48.0,
+ "driver_version": "2.7.0",
+ "firmware_version": null,
+ "supports_bf16": true
+ },
+ {
+ "index": 1,
+ "name": "MTT S4000",
+ "vendor": "Moore Threads",
+ "memory_gb": 48.0,
+ "driver_version": "2.7.0",
+ "firmware_version": null,
+ "supports_bf16": true
+ },
+ {
+ "index": 2,
+ "name": "MTT S4000",
+ "vendor": "Moore Threads",
+ "memory_gb": 48.0,
+ "driver_version": "2.7.0",
+ "firmware_version": null,
+ "supports_bf16": true
+ },
+ {
+ "index": 3,
+ "name": "MTT S4000",
+ "vendor": "Moore Threads",
+ "memory_gb": 48.0,
+ "driver_version": "2.7.0",
+ "firmware_version": null,
+ "supports_bf16": true
+ }
+ ],
+ "accelerator_platform": "moorethreads",
+ "accelerator_topology": null,
+ "intra_node_interconnect": "MCCL/PCIe",
+ "cpu": {
+ "model": "Intel(R) Xeon(R) Gold 6430",
+ "physical_cores": 64,
+ "logical_cores": 128,
+ "numa_nodes": 2
+ },
+ "system_memory_gb": 1007.5,
+ "pcie_generation": "PCIe 16x/16x",
+ "cpu_accelerator_bandwidth_gbs": null,
+ "network_interfaces": [
+ {
+ "name": "mlx5_0",
+ "type": "InfiniBand/RoCE",
+ "bandwidth_gbps": null
+ },
+ {
+ "name": "mlx5_1",
+ "type": "InfiniBand/RoCE",
+ "bandwidth_gbps": null
+ },
+ {
+ "name": "mlx5_bond_0",
+ "type": "InfiniBand/RoCE",
+ "bandwidth_gbps": null
+ }
+ ],
+ "os": "Ubuntu Jammy Jellyfish (development branch)",
+ "python_version": "3.10.8",
+ "kernel_version": "5.15.0-105-generic",
+ "runtime_version": "Moore Threads Driver 2.7.0",
+ "pytorch_version": "2.2.0"
+ },
+ "software": {
+ "framework": "vllm-musa",
+ "framework_version": "0.4.2",
+ "driver_version": "2.7.0",
+ "runtime_version": "Moore Threads Driver 2.7.0",
+ "os": "Ubuntu Jammy Jellyfish (development branch)",
+ "python_version": "3.10.8"
+ },
+ "model": {
+ "model_id": "meta-llama/Meta-Llama-3-8B-Instruct",
+ "model_revision": "8afb486c1db24fe5011ec46dfbe5b5dccdb575c2",
+ "model_name": null,
+ "model_note": null,
+ "model_source": "local",
+ "architecture": "dense",
+ "parameter_count_b": 8.0,
+ "precision": "FP16",
+ "effective_dtype": "float16",
+ "quantization_method": null,
+ "model_format": "HuggingFace original"
+ },
+ "task": {
+ "scenarios_run": [
+ "offline"
+ ],
+ "parallelism": {
+ "tensor_parallel_size": 4,
+ "pipeline_parallel_size": 1,
+ "expert_parallel_size": 1,
+ "data_parallel_size": 1
+ },
+ "num_runs": 3,
+ "extra_config": null
+ },
+ "metrics": {
+ "derived": {},
+ "offline": {
+ "results_by_concurrency": [
+ {
+ "client_concurrency": 8,
+ "throughput_tokens_per_sec": 532.61,
+ "throughput_tokens_per_sec_per_chip": 133.15,
+ "throughput_tokens_per_sec_total": 1253.59,
+ "elapsed_seconds_median": 51.4,
+ "peak_memory_gb": null,
+ "power_watts_avg": null,
+ "power_watts_peak": null,
+ "oom": false,
+ "throughput_tokens_per_sec_reliability": {
+ "n": 3,
+ "mean": 532.57,
+ "std": 0.25,
+ "cv_pct": 0.05,
+ "stability": "stable",
+ "runs": [
+ 532.61,
+ 532.8,
+ 532.3
+ ]
+ },
+ "_throughput_note": "output_only",
+ "_concurrency_note": "client_concurrency is the number of requests sent simultaneously. The inference engine batches internally; this does not directly set engine parameters like max_num_seqs."
+ },
+ {
+ "client_concurrency": 32,
+ "throughput_tokens_per_sec": 528.67,
+ "throughput_tokens_per_sec_per_chip": 132.17,
+ "throughput_tokens_per_sec_total": 1244.31,
+ "elapsed_seconds_median": 51.8,
+ "peak_memory_gb": null,
+ "power_watts_avg": null,
+ "power_watts_peak": null,
+ "oom": false,
+ "throughput_tokens_per_sec_reliability": {
+ "n": 3,
+ "mean": 528.77,
+ "std": 0.34,
+ "cv_pct": 0.06,
+ "stability": "stable",
+ "runs": [
+ 528.5,
+ 528.67,
+ 529.15
+ ]
+ },
+ "_throughput_note": "output_only",
+ "_concurrency_note": "client_concurrency is the number of requests sent simultaneously. The inference engine batches internally; this does not directly set engine parameters like max_num_seqs."
+ },
+ {
+ "client_concurrency": 128,
+ "throughput_tokens_per_sec": 524.51,
+ "throughput_tokens_per_sec_per_chip": 131.13,
+ "throughput_tokens_per_sec_total": 1234.52,
+ "elapsed_seconds_median": 52.2,
+ "peak_memory_gb": null,
+ "power_watts_avg": null,
+ "power_watts_peak": null,
+ "oom": false,
+ "throughput_tokens_per_sec_reliability": {
+ "n": 3,
+ "mean": 524.52,
+ "std": 1.15,
+ "cv_pct": 0.22,
+ "stability": "stable",
+ "runs": [
+ 524.51,
+ 525.68,
+ 523.37
+ ]
+ },
+ "_throughput_note": "output_only",
+ "_concurrency_note": "client_concurrency is the number of requests sent simultaneously. The inference engine batches internally; this does not directly set engine parameters like max_num_seqs."
+ }
+ ]
+ }
+ },
+ "accuracy": {
+ "subset_score": null,
+ "baseline_delta": null,
+ "valid": false,
+ "notes": "Run --scenario accuracy to populate."
+ },
+ "meta": {
+ "submitted_by": "Keke946",
+ "submission_type": "individual",
+ "date": "2026-09-09",
+ "time": "02:06:21",
+ "run_id": "559dc817",
+ "run_name": "mtt_s4000x4_suite_E_moorethreads_vllm_musa_e0266927_559dc817",
+ "flagged": null,
+ "reproduce_script": "runners/moorethreads_vllm_musa_e0266927/runner.py",
+ "env_info_file": "../../env_info.json",
+ "log_file": "run.log",
+ "samples_file": "samples.jsonl",
+ "notes": null,
+ "benchmark_start_time": "2026-09-08T17:55:58.630224+00:00",
+ "benchmark_end_time": "2026-09-08T18:06:21.927438+00:00",
+ "benchmark_elapsed_minutes": 10.4,
+ "model_load_seconds": 139.2,
+ "benchmark_elapsed_minutes_note": "Total across ['offline'] scenarios.",
+ "scenario_dirs": {
+ "offline": "results/community/mtt_s4000x4_suite_E_moorethreads_vllm_musa_e0266927_559dc817/4x/offline"
+ }
+ }
+}
\ No newline at end of file
diff --git a/results/community/mtt_s4000x4_suite_E_moorethreads_vllm_musa_e0266927_559dc817/accuracy/accuracy.json b/results/community/mtt_s4000x4_suite_E_moorethreads_vllm_musa_e0266927_559dc817/accuracy/accuracy.json
new file mode 100644
index 00000000..866e2eee
--- /dev/null
+++ b/results/community/mtt_s4000x4_suite_E_moorethreads_vllm_musa_e0266927_559dc817/accuracy/accuracy.json
@@ -0,0 +1,8 @@
+{
+ "subset_score": 0.07,
+ "baseline_delta": null,
+ "valid": true,
+ "framework": "vllm-musa",
+ "precision": "FP16",
+ "notes": "Integrated accuracy check \u2014 used same vllm-musa instance as benchmark."
+}
\ No newline at end of file
diff --git a/results/community/mtt_s4000x4_suite_E_moorethreads_vllm_musa_e0266927_559dc817/env_info.json b/results/community/mtt_s4000x4_suite_E_moorethreads_vllm_musa_e0266927_559dc817/env_info.json
new file mode 100644
index 00000000..af50e19e
--- /dev/null
+++ b/results/community/mtt_s4000x4_suite_E_moorethreads_vllm_musa_e0266927_559dc817/env_info.json
@@ -0,0 +1,75 @@
+{
+ "collected_at": "2026-09-08T17:51:04.613786+00:00",
+ "accelerators": [
+ {
+ "index": 0,
+ "name": "MTT S4000",
+ "vendor": "Moore Threads",
+ "memory_gb": 48.0,
+ "driver_version": "2.7.0",
+ "firmware_version": null,
+ "supports_bf16": true
+ },
+ {
+ "index": 1,
+ "name": "MTT S4000",
+ "vendor": "Moore Threads",
+ "memory_gb": 48.0,
+ "driver_version": "2.7.0",
+ "firmware_version": null,
+ "supports_bf16": true
+ },
+ {
+ "index": 2,
+ "name": "MTT S4000",
+ "vendor": "Moore Threads",
+ "memory_gb": 48.0,
+ "driver_version": "2.7.0",
+ "firmware_version": null,
+ "supports_bf16": true
+ },
+ {
+ "index": 3,
+ "name": "MTT S4000",
+ "vendor": "Moore Threads",
+ "memory_gb": 48.0,
+ "driver_version": "2.7.0",
+ "firmware_version": null,
+ "supports_bf16": true
+ }
+ ],
+ "accelerator_platform": "moorethreads",
+ "accelerator_topology": null,
+ "intra_node_interconnect": "MCCL/PCIe",
+ "cpu": {
+ "model": "Intel(R) Xeon(R) Gold 6430",
+ "physical_cores": 64,
+ "logical_cores": 128,
+ "numa_nodes": 2
+ },
+ "system_memory_gb": 1007.5,
+ "pcie_generation": "PCIe 16x/16x",
+ "cpu_accelerator_bandwidth_gbs": null,
+ "network_interfaces": [
+ {
+ "name": "mlx5_0",
+ "type": "InfiniBand/RoCE",
+ "bandwidth_gbps": null
+ },
+ {
+ "name": "mlx5_1",
+ "type": "InfiniBand/RoCE",
+ "bandwidth_gbps": null
+ },
+ {
+ "name": "mlx5_bond_0",
+ "type": "InfiniBand/RoCE",
+ "bandwidth_gbps": null
+ }
+ ],
+ "os": "Ubuntu Jammy Jellyfish (development branch)",
+ "python_version": "3.10.8",
+ "kernel_version": "5.15.0-105-generic",
+ "runtime_version": "Moore Threads Driver 2.7.0",
+ "pytorch_version": "2.2.0"
+}
\ No newline at end of file
diff --git a/results/community/mtt_s4000x4_suite_E_moorethreads_vllm_musa_e0266927_559dc817/result.json b/results/community/mtt_s4000x4_suite_E_moorethreads_vllm_musa_e0266927_559dc817/result.json
new file mode 100644
index 00000000..91c47070
--- /dev/null
+++ b/results/community/mtt_s4000x4_suite_E_moorethreads_vllm_musa_e0266927_559dc817/result.json
@@ -0,0 +1,345 @@
+{
+ "schema_version": "1.0",
+ "suite_id": "suite_E",
+ "implementation_id": "moorethreads_vllm_musa_e0266927",
+ "chip": {
+ "name": "MTT S4000",
+ "vendor": "Moore Threads",
+ "count": 4,
+ "card_count": 1,
+ "dies_per_card": 1,
+ "memory_gb": 48.0,
+ "interconnect_intra_node": "MCCL/PCIe",
+ "interconnect_inter_node": null,
+ "_count_note": "Maximum chip count used in this suite. See task.chip_counts_run for all counts tested."
+ },
+ "software": {
+ "framework": "vllm-musa",
+ "framework_version": "0.4.2",
+ "driver_version": "2.7.0",
+ "runtime_version": "Moore Threads Driver 2.7.0",
+ "os": "Ubuntu Jammy Jellyfish (development branch)",
+ "python_version": "3.10.8"
+ },
+ "model": {
+ "model_id": "meta-llama/Meta-Llama-3-8B-Instruct",
+ "model_revision": "8afb486c1db24fe5011ec46dfbe5b5dccdb575c2",
+ "model_name": null,
+ "model_note": null,
+ "model_source": "local",
+ "architecture": "dense",
+ "parameter_count_b": 8.0,
+ "precision": "FP16",
+ "effective_dtype": "float16",
+ "quantization_method": null,
+ "model_format": "HuggingFace original"
+ },
+ "task": {
+ "scenarios_run": [
+ "offline"
+ ],
+ "chip_counts_run": [
+ 1,
+ 2,
+ 4
+ ],
+ "parallelism_note": "Each chip_count uses tensor_parallel_size=N",
+ "num_runs": 3
+ },
+ "metrics": {
+ "scaling": {
+ "base_chip_count": 1,
+ "base_throughput_tokens_per_sec": 410.6,
+ "results_by_chip_count": [
+ {
+ "chip_count": 1,
+ "best_throughput_tokens_per_sec": 410.6,
+ "throughput_tokens_per_sec_per_chip": 410.6,
+ "scaling_efficiency": 1.0,
+ "results_by_concurrency": [
+ {
+ "client_concurrency": 8,
+ "throughput_tokens_per_sec": 410.16,
+ "throughput_tokens_per_sec_per_chip": 410.16,
+ "throughput_tokens_per_sec_total": 964.21,
+ "elapsed_seconds_median": 66.9,
+ "peak_memory_gb": null,
+ "power_watts_avg": null,
+ "power_watts_peak": null,
+ "oom": false,
+ "throughput_tokens_per_sec_reliability": {
+ "n": 3,
+ "mean": 410.14,
+ "std": 0.16,
+ "cv_pct": 0.04,
+ "stability": "stable",
+ "runs": [
+ 409.97,
+ 410.29,
+ 410.16
+ ]
+ },
+ "_throughput_note": "output_only",
+ "_concurrency_note": "client_concurrency is the number of requests sent simultaneously. The inference engine batches internally; this does not directly set engine parameters like max_num_seqs."
+ },
+ {
+ "client_concurrency": 32,
+ "throughput_tokens_per_sec": 410.34,
+ "throughput_tokens_per_sec_per_chip": 410.34,
+ "throughput_tokens_per_sec_total": 964.63,
+ "elapsed_seconds_median": 66.9,
+ "peak_memory_gb": null,
+ "power_watts_avg": null,
+ "power_watts_peak": null,
+ "oom": false,
+ "throughput_tokens_per_sec_reliability": {
+ "n": 3,
+ "mean": 410.15,
+ "std": 0.84,
+ "cv_pct": 0.2,
+ "stability": "stable",
+ "runs": [
+ 410.34,
+ 409.23,
+ 410.87
+ ]
+ },
+ "_throughput_note": "output_only",
+ "_concurrency_note": "client_concurrency is the number of requests sent simultaneously. The inference engine batches internally; this does not directly set engine parameters like max_num_seqs."
+ },
+ {
+ "client_concurrency": 128,
+ "throughput_tokens_per_sec": 410.6,
+ "throughput_tokens_per_sec_per_chip": 410.6,
+ "throughput_tokens_per_sec_total": 965.25,
+ "elapsed_seconds_median": 66.8,
+ "peak_memory_gb": null,
+ "power_watts_avg": null,
+ "power_watts_peak": null,
+ "oom": false,
+ "throughput_tokens_per_sec_reliability": {
+ "n": 3,
+ "mean": 410.41,
+ "std": 0.44,
+ "cv_pct": 0.11,
+ "stability": "stable",
+ "runs": [
+ 409.91,
+ 410.72,
+ 410.6
+ ]
+ },
+ "_throughput_note": "output_only",
+ "_concurrency_note": "client_concurrency is the number of requests sent simultaneously. The inference engine batches internally; this does not directly set engine parameters like max_num_seqs."
+ }
+ ],
+ "result_dir": "1x"
+ },
+ {
+ "chip_count": 2,
+ "best_throughput_tokens_per_sec": 473.16,
+ "throughput_tokens_per_sec_per_chip": 236.58,
+ "scaling_efficiency": 0.576,
+ "results_by_concurrency": [
+ {
+ "client_concurrency": 8,
+ "throughput_tokens_per_sec": 473.16,
+ "throughput_tokens_per_sec_per_chip": 236.58,
+ "throughput_tokens_per_sec_total": 1111.64,
+ "elapsed_seconds_median": 58.1,
+ "peak_memory_gb": null,
+ "power_watts_avg": null,
+ "power_watts_peak": null,
+ "oom": false,
+ "throughput_tokens_per_sec_reliability": {
+ "n": 3,
+ "mean": 472.64,
+ "std": 2.09,
+ "cv_pct": 0.44,
+ "stability": "stable",
+ "runs": [
+ 474.43,
+ 473.16,
+ 470.34
+ ]
+ },
+ "_throughput_note": "output_only",
+ "_concurrency_note": "client_concurrency is the number of requests sent simultaneously. The inference engine batches internally; this does not directly set engine parameters like max_num_seqs."
+ },
+ {
+ "client_concurrency": 32,
+ "throughput_tokens_per_sec": 469.92,
+ "throughput_tokens_per_sec_per_chip": 234.96,
+ "throughput_tokens_per_sec_total": 1104.02,
+ "elapsed_seconds_median": 58.5,
+ "peak_memory_gb": null,
+ "power_watts_avg": null,
+ "power_watts_peak": null,
+ "oom": false,
+ "throughput_tokens_per_sec_reliability": {
+ "n": 3,
+ "mean": 469.27,
+ "std": 1.2,
+ "cv_pct": 0.26,
+ "stability": "stable",
+ "runs": [
+ 470.0,
+ 469.92,
+ 467.88
+ ]
+ },
+ "_throughput_note": "output_only",
+ "_concurrency_note": "client_concurrency is the number of requests sent simultaneously. The inference engine batches internally; this does not directly set engine parameters like max_num_seqs."
+ },
+ {
+ "client_concurrency": 128,
+ "throughput_tokens_per_sec": 468.21,
+ "throughput_tokens_per_sec_per_chip": 234.1,
+ "throughput_tokens_per_sec_total": 1100.01,
+ "elapsed_seconds_median": 58.7,
+ "peak_memory_gb": null,
+ "power_watts_avg": null,
+ "power_watts_peak": null,
+ "oom": false,
+ "throughput_tokens_per_sec_reliability": {
+ "n": 3,
+ "mean": 468.32,
+ "std": 0.7,
+ "cv_pct": 0.15,
+ "stability": "stable",
+ "runs": [
+ 468.21,
+ 467.68,
+ 469.06
+ ]
+ },
+ "_throughput_note": "output_only",
+ "_concurrency_note": "client_concurrency is the number of requests sent simultaneously. The inference engine batches internally; this does not directly set engine parameters like max_num_seqs."
+ }
+ ],
+ "result_dir": "2x"
+ },
+ {
+ "chip_count": 4,
+ "best_throughput_tokens_per_sec": 532.61,
+ "throughput_tokens_per_sec_per_chip": 133.15,
+ "scaling_efficiency": 0.324,
+ "results_by_concurrency": [
+ {
+ "client_concurrency": 8,
+ "throughput_tokens_per_sec": 532.61,
+ "throughput_tokens_per_sec_per_chip": 133.15,
+ "throughput_tokens_per_sec_total": 1253.59,
+ "elapsed_seconds_median": 51.4,
+ "peak_memory_gb": null,
+ "power_watts_avg": null,
+ "power_watts_peak": null,
+ "oom": false,
+ "throughput_tokens_per_sec_reliability": {
+ "n": 3,
+ "mean": 532.57,
+ "std": 0.25,
+ "cv_pct": 0.05,
+ "stability": "stable",
+ "runs": [
+ 532.61,
+ 532.8,
+ 532.3
+ ]
+ },
+ "_throughput_note": "output_only",
+ "_concurrency_note": "client_concurrency is the number of requests sent simultaneously. The inference engine batches internally; this does not directly set engine parameters like max_num_seqs."
+ },
+ {
+ "client_concurrency": 32,
+ "throughput_tokens_per_sec": 528.67,
+ "throughput_tokens_per_sec_per_chip": 132.17,
+ "throughput_tokens_per_sec_total": 1244.31,
+ "elapsed_seconds_median": 51.8,
+ "peak_memory_gb": null,
+ "power_watts_avg": null,
+ "power_watts_peak": null,
+ "oom": false,
+ "throughput_tokens_per_sec_reliability": {
+ "n": 3,
+ "mean": 528.77,
+ "std": 0.34,
+ "cv_pct": 0.06,
+ "stability": "stable",
+ "runs": [
+ 528.5,
+ 528.67,
+ 529.15
+ ]
+ },
+ "_throughput_note": "output_only",
+ "_concurrency_note": "client_concurrency is the number of requests sent simultaneously. The inference engine batches internally; this does not directly set engine parameters like max_num_seqs."
+ },
+ {
+ "client_concurrency": 128,
+ "throughput_tokens_per_sec": 524.51,
+ "throughput_tokens_per_sec_per_chip": 131.13,
+ "throughput_tokens_per_sec_total": 1234.52,
+ "elapsed_seconds_median": 52.2,
+ "peak_memory_gb": null,
+ "power_watts_avg": null,
+ "power_watts_peak": null,
+ "oom": false,
+ "throughput_tokens_per_sec_reliability": {
+ "n": 3,
+ "mean": 524.52,
+ "std": 1.15,
+ "cv_pct": 0.22,
+ "stability": "stable",
+ "runs": [
+ 524.51,
+ 525.68,
+ 523.37
+ ]
+ },
+ "_throughput_note": "output_only",
+ "_concurrency_note": "client_concurrency is the number of requests sent simultaneously. The inference engine batches internally; this does not directly set engine parameters like max_num_seqs."
+ }
+ ],
+ "result_dir": "4x"
+ }
+ ]
+ },
+ "derived": {}
+ },
+ "accuracy": {
+ "subset_score": 0.07,
+ "baseline_delta": null,
+ "valid": true,
+ "framework": "vllm-musa",
+ "precision": "FP16",
+ "notes": "Integrated accuracy check \u2014 used same vllm-musa instance as benchmark."
+ },
+ "meta": {
+ "submitted_by": "Keke946",
+ "submission_type": "individual",
+ "date": "2026-09-09",
+ "time": "02:36:24",
+ "run_id": "559dc817",
+ "run_name": "mtt_s4000x4_suite_E_moorethreads_vllm_musa_e0266927_559dc817",
+ "flagged": null,
+ "reproduce_script": "runners/moorethreads_vllm_musa_e0266927/runner.py",
+ "env_info_file": "../../env_info.json",
+ "log_file": "run.log",
+ "samples_file": "samples.jsonl",
+ "notes": null,
+ "benchmark_start_time": "2026-09-08T18:23:00.513416+00:00",
+ "benchmark_end_time": "2026-09-08T18:36:24.149660+00:00",
+ "benchmark_elapsed_minutes": 35.5,
+ "model_load_seconds": 123.2,
+ "benchmark_elapsed_minutes_note": "Sum of per-chip-count benchmark_elapsed_minutes (excludes sleep gaps, orchestrator overhead, and skipped counts).",
+ "scenario_dirs": {
+ "offline": "results/community/mtt_s4000x4_suite_E_moorethreads_vllm_musa_e0266927_559dc817/1x/offline"
+ },
+ "chip_count_dirs": {
+ "1": "1x",
+ "2": "2x",
+ "4": "4x"
+ }
+ }
+}
\ No newline at end of file
diff --git a/runners/benchmark_runner.py b/runners/benchmark_runner.py
index 5a9b9740..311ad2ff 100644
--- a/runners/benchmark_runner.py
+++ b/runners/benchmark_runner.py
@@ -1293,6 +1293,14 @@ def _run_single_scenario(self, args, suite: dict) -> dict:
warmup_minutes=suite.get("warmup_minutes", 2.0),
)
)
+ elif args.scenario == "online" and getattr(self, "_loop", None) is not None:
+ # Reuse the runner-owned event loop. Legacy vLLM-MUSA starts a
+ # persistent background engine task on this loop; asyncio.run()
+ # would try to tear that loop down immediately after the benchmark
+ # and can hang before result.json is written.
+ metrics = self._loop.run_until_complete(
+ loadgen._run_online_async(inference_fn)
+ )
else:
metrics = loadgen.run(inference_fn)
diff --git a/runners/moorethreads_vllm_musa_e0266927/README.md b/runners/moorethreads_vllm_musa_e0266927/README.md
new file mode 100644
index 00000000..22107498
--- /dev/null
+++ b/runners/moorethreads_vllm_musa_e0266927/README.md
@@ -0,0 +1,153 @@
+# moorethreads_vllm_musa_e0266927 — Moore Threads MUSA Runner (vllm-musa)
+
+AccelMark runner for Moore Threads MUSA GPUs using
+[vllm-musa](https://github.com/MooreThreads/vllm-musa).
+
+## Supported suites
+
+| Suite | Description | Notes |
+|-------|-------------|-------|
+| Suite A | Single-chip, Llama-3-8B | Validated on S4000 (default: accuracy/offline/online) |
+| Suite B | Multi-chip, Llama-3-70B | MCCL tensor parallelism; set `VLLM_WORKER_MULTIPROC_METHOD=spawn` |
+| Suite C | Quantization, Llama-3.1-8B | FP8 skipped (not supported); W8A8/W8A16 via compressed-tensors |
+| Suite D | Long context ~28K input, Llama-3.1-8B | Reduce `max_num_seqs` / `gpu_memory_utilization` in runner config |
+| Suite E | Multi-chip scaling, Llama-3-8B | MCCL tensor parallelism |
+| Suite F | Edge, Qwen2.5-0.5B | Validated on MTT S4000 (community result in repo) |
+| Suite G | MoE multi-chip, Mixtral-8x7B | Unsupported |
+
+## Hardware compatibility
+
+| GPU | BF16 / FP16 | Multi-chip TP | FP8 | Notes |
+|-----|-------------|---------------|-----|-------|
+| MTT S4000 / S5000 | ✅ (BF16 → float16 on vLLM < 0.10) | ✅ (MCCL) | ❌ | Tested with vLLM 0.4.x+musa |
+| MTT S3000 / S80 | ✅ | ✅ | ❌ | May need `--enforce-eager` on Triton errors |
+
+FP8 is excluded — not supported on this runner. FP32 inference fails with
+FlashAttention on MUSA (use FP16 or BF16). Qwen3 requires a newer vLLM + MUSA port
+(Qwen2.5 / Llama-3 work on 0.4.x).
+
+## Prerequisites
+
+Install in this order — **do not** `pip install torch` or `vllm` from PyPI on a
+bare Linux host:
+
+**1. MUSA toolkit + driver**
+
+
+
+**2. vllm-musa (official build)**
+
+| Resource | URL |
+|----------|-----|
+| Repository | |
+| Build guide | [README_vllm_musa.md](https://github.com/MooreThreads/vllm-musa/blob/main/README_vllm_musa.md) |
+| PyTorch MUSA | |
+
+```bash
+git clone https://github.com/MooreThreads/vllm-musa.git
+cd vllm-musa
+bash build_musa.sh
+python -c "from vllm import LLM; print('vllm ok')"
+```
+
+**3. Runner dependencies and legacy vLLM-MUSA multi-chip patch**
+
+```bash
+pip install -r runners/moorethreads_vllm_musa_e0266927/requirements.txt
+bash runners/moorethreads_vllm_musa_e0266927/apply_patches.sh
+```
+
+The patch skips zero-element tensor collectives in vLLM-MUSA 0.4.2's
+`broadcast_tensor_dict`. MCCL 2.7 rejects a zero-count broadcast during vLLM's
+multi-chip profiling pass. Tensor metadata and the empty tensor itself are
+still reconstructed on every rank; only the invalid payload collective is
+omitted. The script is idempotent and reports when the patch is already present.
+
+Pin `transformers` to **4.40–4.46** (not 5.x) when on vLLM 0.4.x.
+
+**Environment variables**
+
+```bash
+export MUSA_VISIBLE_DEVICES=0
+export VLLM_WORKER_MULTIPROC_METHOD=spawn # when tensor_parallel_size > 1
+```
+
+## Smoke test
+
+```bash
+python runners/moorethreads_vllm_musa_e0266927/test_smoke.py
+python runners/moorethreads_vllm_musa_e0266927/test_smoke.py /path/to/model
+```
+
+## Accuracy
+
+AccelMark runs an integrated MMLU subset after each benchmark using the **same**
+vLLM instance as the perf run. The runner sets `device=musa`, dtype, and
+tokenizer correctly; low scores on vLLM **0.4.x+musa** reflect broken generation
+in that stack, not missing AccelMark wiring.
+
+| Model | Suite | Measured | Baseline |
+|-------|-------|----------|----------|
+| Qwen2.5-0.5B-Instruct | F | **~0.07** | 0.37 (FP16) / 0.38 (BF16) |
+| Llama-3-8B-Instruct | A | **~0.07** | 0.60 (BF16) |
+
+Throughput completes normally; answers are effectively random (repetition, system
+prompt regurgitation, similar ~7% across different models).
+
+While accuracy is broken on 0.4.x, use `--skip-accuracy-gate` to finish a perf run:
+
+```bash
+python run.py --runner moorethreads_vllm_musa_e0266927 \
+ --suite suite_F --precision FP16 --skip-accuracy-gate
+```
+
+Likely fix: upgrade to vllm-musa aligned with vLLM **0.10+**, keep
+`transformers` 4.40–4.46 on legacy forks, then re-run without
+`--skip-accuracy-gate`.
+
+## Usage
+
+```bash
+python run.py --runner moorethreads_vllm_musa_e0266927 --suite suite_F --precision FP16
+
+VLLM_WORKER_MULTIPROC_METHOD=spawn \
+python run.py --runner moorethreads_vllm_musa_e0266927 \
+ --suite suite_B --tensor-parallel-size 8
+```
+
+Optional runner config (copy and edit):
+
+```bash
+cp configs/runner_configs/runner_moorethreads_vllm_musa_e0266927.yaml.example \
+ configs/runner_configs/runner_moorethreads_vllm_musa_e0266927.yaml
+```
+
+| Field | Default | Notes |
+|-------|---------|-------|
+| `tensor_parallel_size` | 1 | MCCL tensor parallelism |
+| `enforce_eager` | false | Only if Triton / graph capture errors |
+| `max_num_seqs` | 256 | Lower on small HBM |
+| `gpu_memory_utilization` | 0.85 | Lower if OOM |
+
+## Troubleshooting
+
+| Symptom | Fix |
+|---------|-----|
+| `GLIBCXX_3.4.30` on import | Import `torch` before `transformers` (runner and smoke test do this) |
+| `AutoMcclGroup End Failed` during TP profiling | Run `bash runners/moorethreads_vllm_musa_e0266927/apply_patches.sh` |
+| `KeyError: 'type'` in rope_scaling | Pin `transformers==4.46.3` (not 5.x) |
+| `Expected musa device, got cuda:0` | Use this runner (`device="musa"`) |
+| MMLU ~0.07 | See [Accuracy](#accuracy); `--skip-accuracy-gate` for perf-only runs |
+| OOM | Lower `gpu_memory_utilization` / `max_num_seqs` |
+| Triton / graph errors | `--enforce-eager` or `enforce_eager: true` in runner YAML |
+
+## Requirements
+
+See `requirements.txt` for AccelMark extras. vLLM, torch_musa, and the MUSA
+driver are installed per the official vllm-musa guide above (not from this file).
+
+Minimum environment:
+
+- Moore Threads GPU with MUSA driver
+- Python 3.10+
+- vllm-musa build per [MooreThreads/vllm-musa](https://github.com/MooreThreads/vllm-musa)
diff --git a/runners/moorethreads_vllm_musa_e0266927/apply_patches.sh b/runners/moorethreads_vllm_musa_e0266927/apply_patches.sh
new file mode 100755
index 00000000..f2a8b92c
--- /dev/null
+++ b/runners/moorethreads_vllm_musa_e0266927/apply_patches.sh
@@ -0,0 +1,16 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+runner_dir="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+patch_file="$runner_dir/patches/vllm_musa_skip_empty_broadcast.patch"
+site_packages="$(python -c 'import pathlib, vllm; print(pathlib.Path(vllm.__file__).resolve().parent.parent)')"
+target="$site_packages/vllm/distributed/communication_op.py"
+
+if grep -q 'if tensor.numel() > 0:' "$target"; then
+ echo "vLLM-MUSA empty-tensor broadcast patch already applied: $target"
+ exit 0
+fi
+
+patch --batch --forward -p1 -d "$site_packages" < "$patch_file"
+python -m py_compile "$target"
+echo "Applied vLLM-MUSA empty-tensor broadcast patch: $target"
diff --git a/runners/moorethreads_vllm_musa_e0266927/meta.json b/runners/moorethreads_vllm_musa_e0266927/meta.json
new file mode 100644
index 00000000..d84d8875
--- /dev/null
+++ b/runners/moorethreads_vllm_musa_e0266927/meta.json
@@ -0,0 +1,24 @@
+{
+ "id": "moorethreads_vllm_musa_e0266927",
+ "platform": "moorethreads",
+ "name": "vllm-musa on Moore Threads MUSA GPU",
+ "framework": "vllm-musa",
+ "submitted_by": "Keke946",
+ "description": "AccelMark runner for Moore Threads MUSA GPUs using vllm-musa (https://github.com/MooreThreads/vllm-musa). Install torch/vllm per upstream README_vllm_musa.md; requirements.txt adds benchmark deps only. Sets device=musa; BF16 maps to float16 on vLLM <0.10. MCCL tensor parallelism. FP8 unsupported.",
+ "supersedes_chain": [
+ "moorethreads_vllm_musa_006fed40",
+ "moorethreads_vllm_musa_f2f6f965"
+ ],
+ "notes": "Legacy vLLM-MUSA 0.4.x reports FP16 as the effective precision because BF16 execution is mapped to float16. Tested on MTT S4000.",
+ "created": "2026-08-25",
+ "hardware_label": null,
+ "suite_support": {
+ "A": "validated",
+ "B": "pending",
+ "C": "pending",
+ "D": "pending",
+ "E": "validated",
+ "F": "validated",
+ "G": "unsupported"
+ }
+}
diff --git a/runners/moorethreads_vllm_musa_e0266927/patches/vllm_musa_skip_empty_broadcast.patch b/runners/moorethreads_vllm_musa_e0266927/patches/vllm_musa_skip_empty_broadcast.patch
new file mode 100644
index 00000000..8728effa
--- /dev/null
+++ b/runners/moorethreads_vllm_musa_e0266927/patches/vllm_musa_skip_empty_broadcast.patch
@@ -0,0 +1,38 @@
+--- a/vllm/distributed/communication_op.py
++++ b/vllm/distributed/communication_op.py
+@@ -203,11 +203,12 @@
+ group=metadata_group)
+ async_handles = []
+ for tensor in tensor_list:
+- async_handles.append(
+- torch.distributed.broadcast(tensor,
+- src=src,
+- group=group,
+- async_op=True))
++ if tensor.numel() > 0:
++ async_handles.append(
++ torch.distributed.broadcast(tensor,
++ src=src,
++ group=group,
++ async_op=True))
+ for async_handle in async_handles:
+ async_handle.wait()
+
+@@ -224,11 +225,12 @@
+ tensor = torch.empty(value.size,
+ dtype=value.dtype,
+ device="musa")
+- async_handle = torch.distributed.broadcast(tensor,
+- src=src,
+- async_op=True,
+- group=group)
+- async_handles.append(async_handle)
++ if tensor.numel() > 0:
++ async_handle = torch.distributed.broadcast(tensor,
++ src=src,
++ async_op=True,
++ group=group)
++ async_handles.append(async_handle)
+ tensor_dict[key] = tensor
+ else:
+ tensor_dict[key] = value
diff --git a/runners/moorethreads_vllm_musa_e0266927/requirements.txt b/runners/moorethreads_vllm_musa_e0266927/requirements.txt
new file mode 100644
index 00000000..f462ba7a
--- /dev/null
+++ b/runners/moorethreads_vllm_musa_e0266927/requirements.txt
@@ -0,0 +1,23 @@
+# AccelMark — moorethreads_vllm_musa_e0266927
+#
+# AccelMark benchmark dependencies only. Install MUSA toolkit, torch_musa, and
+# vllm-musa first — see README.md and https://github.com/MooreThreads/vllm-musa
+#
+# pip install -r runners/moorethreads_vllm_musa_e0266927/requirements.txt
+# bash runners/moorethreads_vllm_musa_e0266927/apply_patches.sh
+# python runners/moorethreads_vllm_musa_e0266927/test_smoke.py
+
+# AccelMark / loadgen
+numpy==1.26.4
+jsonschema==4.25.1
+psutil==7.1.0
+tqdm==4.67.1
+aiohttp==3.12.15
+PyYAML==6.0.2
+
+# Tokenizer / config (pin to match vLLM 0.4.x — see README)
+transformers>=4.43.0,<4.47.0
+tokenizers>=0.20.0,<0.21.0
+huggingface-hub>=0.26.0,<0.27.0
+accelerate>=1.2.0,<1.3.0
+safetensors>=0.4.5,<0.5.0
diff --git a/runners/moorethreads_vllm_musa_e0266927/runner.py b/runners/moorethreads_vllm_musa_e0266927/runner.py
new file mode 100644
index 00000000..88b7d71b
--- /dev/null
+++ b/runners/moorethreads_vllm_musa_e0266927/runner.py
@@ -0,0 +1,459 @@
+"""
+AccelMark — Moore Threads MUSA vLLM benchmark runner (vllm-musa).
+
+Implements BenchmarkRunner for vllm-musa on Moore Threads MUSA GPUs.
+See README.md in this folder for install and hardware notes.
+"""
+
+import asyncio
+import gc
+import sys
+import time
+from pathlib import Path
+from typing import Optional
+
+_REPO_ROOT = Path(__file__).resolve().parent.parent.parent
+sys.path.insert(0, str(_REPO_ROOT))
+
+from runners.benchmark_runner import BenchmarkRunner, InferenceRequest
+from loadgen.types import InferenceResult
+
+import logging
+logging.getLogger("vllm.engine.async_llm_engine").setLevel(logging.WARNING)
+logging.getLogger("vllm.engine.llm_engine").setLevel(logging.WARNING)
+
+
+class MoorethreadsVLLMMUSARunner(BenchmarkRunner):
+ """vLLM on Moore Threads MUSA via vllm-musa."""
+
+ SUPPORTS_STREAMING = True
+ SUPPORTS_BATCHING = True
+ SUPPORTS_ONLINE = True
+ SUPPORTS_MULTI_CHIP = True
+
+ SUPPORTED_PRECISIONS = ["bf16", "fp16"]
+ SUPPORTED_QUANTIZATION_BACKENDS = ["compressed-tensors"]
+
+ _musa_runtime_prepared = False
+
+ def __init__(self):
+ self.llm = None
+ self.engine = None
+ self.tokenizer = None
+ self.sampling_params = None
+ self._loop: asyncio.AbstractEventLoop = None
+
+ def _get_chip_count(self) -> int:
+ try:
+ import pymtml
+ pymtml.mtmlInit()
+ try:
+ n = pymtml.mtmlDeviceGetCount()
+ finally:
+ try:
+ pymtml.mtmlShutdown()
+ except Exception:
+ pass
+ if n and n > 0:
+ return int(n)
+ except Exception:
+ pass
+ try:
+ import torch
+ n = torch.cuda.device_count()
+ return n if n > 0 else 1
+ except Exception:
+ return 1
+
+ def _get_framework_name(self) -> str:
+ return "vllm-musa"
+
+ def _get_framework_version(self) -> str:
+ plugin_version = "unknown"
+ try:
+ from importlib.metadata import version
+ plugin_version = version("vllm-musa")
+ except Exception:
+ try:
+ import vllm_musa_platform # type: ignore
+ plugin_version = getattr(vllm_musa_platform, "__version__", "unknown")
+ except Exception:
+ pass
+ try:
+ import vllm
+ core_version = vllm.__version__
+ except Exception:
+ core_version = "unknown"
+ if plugin_version == "unknown" and core_version == "unknown":
+ return "unknown"
+ if plugin_version == "unknown":
+ return core_version
+ return f"{plugin_version}+vllm-{core_version}"
+
+ def get_model_format(self) -> str:
+ return "HuggingFace original"
+
+ @classmethod
+ def _prepare_musa_runtime(cls) -> None:
+ if cls._musa_runtime_prepared:
+ return
+ import torch # noqa: F401
+ cls._musa_runtime_prepared = True
+
+ @staticmethod
+ def _legacy_vllm_musa() -> bool:
+ try:
+ import vllm
+ ver = vllm.__version__.split("+")[0]
+ major, minor = (int(x) for x in ver.split(".")[:2])
+ return (major, minor) < (0, 10)
+ except Exception:
+ return True
+
+ def get_supported_precisions(self, chip_name: str, env_info: dict):
+ # Legacy vLLM-MUSA 0.4.x maps BF16 execution to FP16. Report only
+ # FP16 so run_id, result metadata, and the actual runtime dtype agree.
+ if self._legacy_vllm_musa():
+ return ["FP16"]
+ return None
+
+ @staticmethod
+ def _get_engine_arg_fields() -> set[str]:
+ try:
+ import dataclasses
+ from vllm.engine.arg_utils import EngineArgs
+ return {f.name for f in dataclasses.fields(EngineArgs)}
+ except Exception:
+ return set()
+
+ def _resolve_musa_dtype(self, dtype: str, precision: str) -> str:
+ if not self._legacy_vllm_musa():
+ return dtype
+ if dtype in ("bfloat16", "auto") or precision.upper() == "BF16":
+ if dtype != "float16":
+ print(" Note: vLLM 0.4.x+musa — using float16")
+ return "float16"
+ return dtype
+
+ def load_model(self, model_path: str, parallelism: dict) -> None:
+ self._prepare_musa_runtime()
+
+ from transformers import AutoTokenizer
+ from vllm import LLM, AsyncLLMEngine, SamplingParams
+ from vllm.engine.arg_utils import AsyncEngineArgs
+
+ tp_size = parallelism["tensor_parallel_size"]
+ pp_size = parallelism["pipeline_parallel_size"]
+ ep_size = parallelism.get("expert_parallel_size", 1)
+ assert pp_size <= 1, (
+ "Pipeline parallelism is not supported. Use --tensor-parallel-size."
+ )
+
+ max_tokens = parallelism["max_tokens"]
+ max_model_len = parallelism["max_model_len"]
+ use_async = parallelism["use_async"]
+ enforce_eager = getattr(self, "_enforce_eager", False)
+
+ cfg = getattr(self, "_runner_config", {})
+ max_num_seqs = cfg.get("max_num_seqs", 256)
+ musa_memory_util = cfg.get("gpu_memory_utilization", 0.85)
+ extra_kwargs = dict(cfg.get("engine_kwargs") or {})
+
+ _valid_engine_fields = self._get_engine_arg_fields()
+ if _valid_engine_fields:
+ _dropped = {k: v for k, v in extra_kwargs.items()
+ if k not in _valid_engine_fields}
+ if _dropped:
+ print(f" Warning: engine_kwargs keys not supported by this "
+ f"vllm-musa / vLLM version and will be ignored: "
+ f"{list(_dropped)}")
+ extra_kwargs = {k: v for k, v in extra_kwargs.items()
+ if k in _valid_engine_fields}
+
+ effective_precision = getattr(self, "_effective_precision", "BF16").upper()
+ precision = getattr(self, "_precision", None) or effective_precision
+ _dtype_override = getattr(self, "_precision_dtype_override", None)
+ _prec_eng_kwargs = dict(getattr(self, "_precision_engine_kwargs", None) or {})
+ quantization = _prec_eng_kwargs.pop("quantization", None)
+
+ _NATIVE_DTYPE_MAP = {"BF16": "bfloat16", "FP16": "float16", "FP32": "float32"}
+ dtype = _NATIVE_DTYPE_MAP.get(precision, "auto")
+ self._quantization_method = quantization
+
+ if _dtype_override:
+ dtype = _dtype_override
+ dtype = self._resolve_musa_dtype(dtype, precision)
+ if _prec_eng_kwargs:
+ _prec_eng_kwargs.update(extra_kwargs)
+ extra_kwargs = _prec_eng_kwargs
+
+ if "speculative_model" in extra_kwargs and "speculative_config" not in extra_kwargs:
+ extra_kwargs["speculative_config"] = {
+ "model": extra_kwargs.pop("speculative_model"),
+ "num_speculative_tokens": extra_kwargs.pop("num_speculative_tokens", 4),
+ "draft_tensor_parallel_size": extra_kwargs.pop(
+ "speculative_draft_tensor_parallel_size", 1
+ ),
+ }
+
+ print(
+ f"Loading model: precision={precision}, dtype={dtype}"
+ + (f", quantization_method={self._quantization_method}"
+ if self._quantization_method else "")
+ )
+
+ if tp_size > 1:
+ # Ray does not auto-detect MUSA accelerators as GPU resources.
+ # Register the local MUSA devices explicitly before vLLM builds
+ # its tensor-parallel Ray placement group.
+ import ray
+ if not ray.is_initialized():
+ ray.init(num_gpus=tp_size, ignore_reinit_error=True)
+
+ self.tokenizer = AutoTokenizer.from_pretrained(
+ model_path, trust_remote_code=False
+ )
+ self.sampling_params = SamplingParams(max_tokens=max_tokens, temperature=0.0)
+
+ base_kwargs = dict(
+ model=model_path,
+ dtype=dtype,
+ tensor_parallel_size=tp_size,
+ trust_remote_code=False,
+ enforce_eager=enforce_eager,
+ )
+ if tp_size > 1:
+ # vLLM's custom all-reduce implementation targets NVIDIA/NVML.
+ # Moore Threads multi-card execution uses torch.distributed/MCCL.
+ base_kwargs["disable_custom_all_reduce"] = True
+ if not _valid_engine_fields or "device" in _valid_engine_fields:
+ base_kwargs["device"] = "musa"
+ if ep_size > 1:
+ base_kwargs["enable_expert_parallel"] = True
+ if quantization:
+ base_kwargs["quantization"] = quantization
+ if max_model_len:
+ base_kwargs["max_model_len"] = max_model_len
+
+ if not use_async:
+ self.llm = LLM(**{
+ **base_kwargs,
+ "max_num_seqs": max_num_seqs,
+ "gpu_memory_utilization": musa_memory_util,
+ **extra_kwargs,
+ })
+ else:
+ self._loop = asyncio.new_event_loop()
+ asyncio.set_event_loop(self._loop)
+ engine_args = AsyncEngineArgs(**{
+ **base_kwargs,
+ "gpu_memory_utilization": musa_memory_util,
+ **extra_kwargs,
+ })
+ self.engine = AsyncLLMEngine.from_engine_args(engine_args)
+
+ def get_effective_dtype(self) -> Optional[str]:
+ try:
+ if self.llm is not None:
+ return str(self.llm.llm_engine.model_config.dtype).replace("torch.", "")
+ if self.engine is not None:
+ return str(self.engine.engine.model_config.dtype).replace("torch.", "")
+ except Exception:
+ pass
+ return getattr(self, "_effective_dtype", None)
+
+ def inference_fn_offline(self, requests: list[InferenceRequest]) -> list[InferenceResult]:
+ formatted = [self._format_prompt(r.prompt) for r in requests]
+ t_start = time.perf_counter()
+ outputs = self.llm.generate(formatted, self.sampling_params)
+ elapsed = time.perf_counter() - t_start
+
+ self._last_accuracy_outputs = [o.outputs[0].text for o in outputs]
+
+ return [
+ InferenceResult(
+ first_token_time_ms=None,
+ total_time_ms=elapsed * 1000,
+ output_tokens=len(o.outputs[0].token_ids),
+ input_tokens=len(o.prompt_token_ids),
+ success=True,
+ output_text=o.outputs[0].text,
+ )
+ for o in outputs
+ ]
+
+ async def inference_fn_streaming(self, request: InferenceRequest) -> InferenceResult:
+ from vllm.utils import random_uuid
+
+ formatted = self._format_prompt(request.prompt)
+ request_id = random_uuid()
+ t_start = time.perf_counter()
+ first_token_time_ms = None
+ output_tokens = 0
+ output_text = ""
+
+ async for output in self.engine.generate(
+ formatted, self.sampling_params, request_id
+ ):
+ if first_token_time_ms is None and len(output.outputs[0].token_ids) > 0:
+ first_token_time_ms = (time.perf_counter() - t_start) * 1000
+ output_tokens = len(output.outputs[0].token_ids)
+ output_text = output.outputs[0].text
+
+ return InferenceResult(
+ first_token_time_ms=first_token_time_ms,
+ total_time_ms=(time.perf_counter() - t_start) * 1000,
+ output_tokens=output_tokens,
+ input_tokens=0,
+ success=True,
+ output_text=output_text,
+ )
+
+ async def inference_fn_token_stream(self, request: InferenceRequest):
+ from vllm.utils import random_uuid
+
+ formatted = self._format_prompt(request.prompt)
+ request_id = random_uuid()
+ prev_length = 0
+
+ async for output in self.engine.generate(
+ formatted, self.sampling_params, request_id
+ ):
+ current_text = output.outputs[0].text
+ delta = current_text[prev_length:]
+ if delta:
+ yield delta
+ prev_length = len(current_text)
+
+ def get_peak_memory_gb(self) -> Optional[float]:
+ try:
+ import torch
+ return torch.cuda.max_memory_allocated() / (1024 ** 3)
+ except Exception:
+ pass
+ try:
+ import pymtml
+ pymtml.mtmlInit()
+ try:
+ dev = pymtml.mtmlDeviceGetByIndex(0)
+ info = pymtml.mtmlDeviceGetMemoryInfo(dev)
+ used = getattr(info, "used", None)
+ if used is not None:
+ return float(used) / (1024 ** 3)
+ finally:
+ try:
+ pymtml.mtmlShutdown()
+ except Exception:
+ pass
+ except Exception:
+ pass
+ return None
+
+ def release_resources(self) -> None:
+ if self.llm is not None:
+ try:
+ del self.llm
+ except Exception:
+ pass
+ self.llm = None
+
+ if self.engine is not None:
+ try:
+ if self._loop and not self._loop.is_closed():
+ self._loop.run_until_complete(self.engine.shutdown())
+ except Exception:
+ pass
+ try:
+ del self.engine
+ except Exception:
+ pass
+ self.engine = None
+
+ try:
+ from vllm.distributed.parallel_state import cleanup_dist_env_and_memory
+ cleanup_dist_env_and_memory(shutdown_ray=False)
+ except Exception:
+ try:
+ from vllm.distributed.parallel_state import (
+ destroy_model_parallel,
+ destroy_distributed_environment,
+ )
+ destroy_model_parallel()
+ destroy_distributed_environment()
+ except Exception:
+ pass
+
+ try:
+ import torch
+ if torch.distributed.is_initialized():
+ torch.distributed.destroy_process_group()
+ except Exception:
+ pass
+
+ gc.collect()
+
+ try:
+ import torch
+ torch.cuda.empty_cache()
+ torch.cuda.reset_peak_memory_stats()
+ except Exception:
+ pass
+
+ def parse_args(self):
+ """Add vllm-musa-specific CLI flags. Base class pre-loads runner config."""
+ args = super().parse_args()
+ cfg = self._runner_config
+
+ import argparse
+ parser = argparse.ArgumentParser(add_help=False)
+ parser.add_argument("--tensor-parallel-size", type=int, default=None,
+ dest="tensor_parallel_size")
+ parser.add_argument("--expert-parallel-size", type=int, default=None,
+ dest="expert_parallel_size")
+ parser.add_argument("--enforce-eager", action="store_true", default=False,
+ dest="enforce_eager")
+ extra, _ = parser.parse_known_args()
+
+ tp_size, _tp_source = self._resolve_tensor_parallel_size(
+ extra.tensor_parallel_size
+ )
+ ep_size = (extra.expert_parallel_size
+ if extra.expert_parallel_size is not None
+ else cfg.get("expert_parallel_size", 1))
+ self._enforce_eager = extra.enforce_eager or cfg.get("enforce_eager", False)
+
+ print(f" tensor_parallel_size = {tp_size} [{_tp_source}]")
+ if ep_size > 1:
+ print(f" expert_parallel_size = {ep_size} [cli/yaml]")
+
+ if not self.SUPPORTS_MULTI_CHIP and tp_size > 1:
+ print(f"Warning: {self.__class__.__name__} does not support multi-chip. "
+ f"Ignoring tensor_parallel_size={tp_size}, using 1.")
+ tp_size = 1
+ ep_size = 1
+
+ self._parallelism = {
+ "tensor_parallel_size": tp_size,
+ "pipeline_parallel_size": 1,
+ "expert_parallel_size": ep_size,
+ "data_parallel_size": 1,
+ }
+ self._chip_count = tp_size
+ self._precision = getattr(args, "precision", None)
+ return args
+
+ def get_extra_subprocess_args(self, args) -> list[str]:
+ extra = [
+ "--tensor-parallel-size",
+ str(self._parallelism.get("tensor_parallel_size", 1)),
+ ]
+ if self._parallelism.get("expert_parallel_size", 1) > 1:
+ extra += ["--expert-parallel-size",
+ str(self._parallelism["expert_parallel_size"])]
+ if self._enforce_eager:
+ extra += ["--enforce-eager"]
+ return extra
+
+
+if __name__ == "__main__":
+ MoorethreadsVLLMMUSARunner().main()
diff --git a/runners/moorethreads_vllm_musa_e0266927/test_smoke.py b/runners/moorethreads_vllm_musa_e0266927/test_smoke.py
new file mode 100644
index 00000000..86cbbf98
--- /dev/null
+++ b/runners/moorethreads_vllm_musa_e0266927/test_smoke.py
@@ -0,0 +1,77 @@
+#!/usr/bin/env python3
+"""
+Standalone vllm-musa smoke test (does not use the AccelMark runner).
+
+Usage (from repo root):
+
+ python runners/moorethreads_vllm_musa_f2f6f965/test_smoke.py
+ python runners/moorethreads_vllm_musa_f2f6f965/test_smoke.py /path/to/model
+
+ MODEL_PATH=/path/to/Qwen2.5-0.5B-Instruct \\
+ python runners/moorethreads_vllm_musa_f2f6f965/test_smoke.py
+"""
+
+from __future__ import annotations
+
+import gc
+import os
+import sys
+import time
+
+import torch # noqa: F401 — before transformers/vllm (libstdc++ load order)
+
+from vllm import LLM, SamplingParams
+
+_DEFAULT_MODEL = os.getenv("MODEL_PATH", "Qwen/Qwen2.5-0.5B-Instruct")
+
+PROMPTS = [
+ "The capital of France is",
+ "Say hello in one short sentence.",
+]
+
+
+def main() -> int:
+ model_path = sys.argv[1] if len(sys.argv) > 1 else _DEFAULT_MODEL
+
+ sampling_params = SamplingParams(temperature=0.0, max_tokens=64)
+
+ print(f"Loading {model_path} ...")
+ t_load = time.perf_counter()
+ llm = LLM(
+ model=model_path,
+ device="musa",
+ dtype="float16",
+ tensor_parallel_size=1,
+ max_model_len=1024,
+ max_num_seqs=4,
+ gpu_memory_utilization=0.85,
+ trust_remote_code=False,
+ )
+ print(f"Model loaded in {time.perf_counter() - t_load:.1f}s\n")
+
+ t_infer = time.perf_counter()
+ outputs = llm.generate(PROMPTS, sampling_params)
+ print(f"Inference done in {time.perf_counter() - t_infer:.1f}s\n")
+
+ for prompt, output in zip(PROMPTS, outputs):
+ text = output.outputs[0].text
+ n_tokens = len(output.outputs[0].token_ids)
+ print(f"Prompt: {prompt!r}")
+ print(f"Output: {text!r}")
+ print(f"Tokens: {n_tokens}\n")
+
+ del llm
+ gc.collect()
+ try:
+ if hasattr(torch, "musa"):
+ torch.musa.empty_cache()
+ else:
+ torch.cuda.empty_cache()
+ except Exception:
+ pass
+ print("Done.")
+ return 0
+
+
+if __name__ == "__main__":
+ raise SystemExit(main())
diff --git a/runners/validate_submission.py b/runners/validate_submission.py
index 6daa4659..34e2fab2 100644
--- a/runners/validate_submission.py
+++ b/runners/validate_submission.py
@@ -217,6 +217,7 @@ def check_run_id_integrity(result: dict) -> list[str]:
"chip_name": chip.get("name", "unknown"),
"chip_memory_gb": round(float(chip.get("memory_gb") or 0)),
"chip_count": chip_count,
+ "dies_per_card": chip.get("dies_per_card", 1) or 1,
"interconnect": chip.get("interconnect_intra_node") if chip_count > 1 else None,
"runner_id": result.get("implementation_id", "unknown"),
"framework_version": sw.get("framework_version", "unknown"),
diff --git a/suites/suite_E/suite.py b/suites/suite_E/suite.py
index 34e8460e..78ab4f1e 100644
--- a/suites/suite_E/suite.py
+++ b/suites/suite_E/suite.py
@@ -331,7 +331,13 @@ def _merge_suite_e_results(
merged = {
"schema_version": "1.0",
"suite_id": "suite_E",
- "implementation_id": base_result.get("implementation_id"),
+ # The per-chip result can come from a resumable run made before the
+ # current runner was assigned its content-addressed ID. The suite-level
+ # result must describe the orchestrating runner used for this merge.
+ "implementation_id": (
+ br._compute_implementation_id()
+ or base_result.get("implementation_id")
+ ),
"chip": {
**base_result["chip"],
"count": max_count,