[TRTLLM-12154][test] Add Qwen3-32B FP8 Eagle3 disagg stress test

Add a Qwen3-32B FP8 disaggregated serving smoke and stress test that exercises Eagle3 with 4x TP1 context workers and 1x TP4 generation worker on 8 GPUs.

The YAML enables FP8 KV cache, chunked prefill, block and partial reuse, cache transfer, and a top-level Eagle3 speculative_config shared by context and generation workers. The draft model is stored as a model-root-relative path and the disagg harness now resolves relative model and speculative_model values through llm_models_root while preserving absolute paths.

Wire the smoke test into the H200 L0 list and the full 10k-request stress case into the QA stress list. Add Qwen-specific output substring checks and keep the stress accuracy threshold aligned with the adjacent GPT-OSS stress case.

Author: brnguyen2

tests/integration/defs/disaggregated/test_configs/disagg_config_ctxtp1_gentp4_qwen3_32b_fp8.yaml

@@ -0,0 +1,54 @@
+hostname: localhost
+model: Qwen3/Qwen3-32B-FP8
+backend: pytorch
+cuda_graph_config: null
+guided_decoding_backend: xgrammar
+# speculative_config goes top-level so both context and generation workers
+# see it. Putting it under generation_servers: only causes the disagg KV
+# transceiver to reject the cacheState handshake (cacheStates differ when
+# only one side has spec config).
+speculative_config:
+  decoding_type: Eagle3
+  max_draft_len: 3
+  speculative_model: Zhi-Create-Qwen3-32B-Eagle3
+context_servers:
+  num_instances: 4
+  tensor_parallel_size: 1
+  pipeline_parallel_size: 1
+  router:
+    type: kv_cache_aware
+  enable_chunked_prefill: true
+  max_num_tokens: 4096
+  max_seq_len: 10240
+  max_batch_size: 128
+  disable_overlap_scheduler: true
+  print_iter_log: true
+  kv_cache_config:
+    enable_block_reuse: true
+    enable_partial_reuse: true
+    dtype: fp8
+    free_gpu_memory_fraction: 0.8
+    event_buffer_max_size: 1024
+  cache_transceiver_config:
+    backend: DEFAULT
+    max_tokens_in_buffer: 16384
+generation_servers:
+  num_instances: 1
+  tensor_parallel_size: 4
+  pipeline_parallel_size: 1
+  enable_chunked_prefill: true
+  max_num_tokens: 4096
+  max_seq_len: 10240
+  max_batch_size: 128
+  # Eagle3 requires the overlap scheduler off. Cache settings must match the
+  # context block or disagg KV transfer rejects the cacheState handshake.
+  disable_overlap_scheduler: true
+  print_iter_log: true
+  kv_cache_config:
+    enable_block_reuse: true
+    enable_partial_reuse: true
+    dtype: fp8
+    free_gpu_memory_fraction: 0.8
+  cache_transceiver_config:
+    backend: DEFAULT
+    max_tokens_in_buffer: 16384

tests/integration/defs/disaggregated/test_disaggregated.py

@@ -261,6 +261,8 @@ def get_test_config(test_desc, example_dir, test_root):
         f"{test_configs_root}/disagg_config_ctxtp4_gentp4_deepseek_r1_v2_fp4_tllm.yaml",
         "gpt_oss_120b_stress":
         f"{test_configs_root}/disagg_config_ctxtp2_gentp2_gptoss_tllm.yaml",
+        "qwen3_32b_fp8_stress":
+        f"{test_configs_root}/disagg_config_ctxtp1_gentp4_qwen3_32b_fp8.yaml",
         "gpt_oss_120b_harmony":
         f"{test_configs_root}/disagg_config_ctxtp2_gentp2_gptoss_tllm.yaml",
         "cancel_stress_test":
@@ -294,6 +296,13 @@ def setup_model_symlink(llm_venv, model_root, dest_subpath):
         os.symlink(model_root, dst, target_is_directory=True)
 
 
+def resolve_llm_model_path(model_path: str) -> str:
+    """Resolve a model subpath relative to the test LLM model root."""
+    if os.path.isabs(model_path):
+        return model_path
+    return os.path.join(llm_models_root(), model_path)
+
+
 ClientTestSet = namedtuple('ClientTestSet', [
     'completion', 'completion_streaming', 'chat', 'chat_streaming',
     'verify_completion', 'verify_streaming_completion', 'verify_chat',
@@ -445,6 +454,11 @@ def run_client_tests(example_dir,
                         "The capital of Germany is Berlin",
                         "Using `asyncio` in Python"
                     ]
+                elif "qwen3_32b_fp8" in test_desc:
+                    expected_strings = [
+                        "The capital of Germany is Berlin",
+                        "Asyncio in Python is a library"
+                    ]
                 else:
                     expected_strings = [
                         "The capital of Germany is Berlin",
@@ -494,6 +508,13 @@ def setup_disagg_cluster(
     with open(config_file, 'r') as f:
         config = yaml.safe_load(f)
 
+    speculative_config = config.get("speculative_config")
+    if isinstance(speculative_config, dict):
+        speculative_model = speculative_config.get("speculative_model")
+        if speculative_model:
+            speculative_config["speculative_model"] = resolve_llm_model_path(
+                speculative_model)
+
     disagg_cluster = get_default_disagg_cluster_config()
     server_host = config.get("hostname", "localhost")
     server_port = get_free_port()
@@ -524,6 +545,8 @@ def setup_disagg_cluster(
 
     # Launch workers
     model = model_name or config.get("model")
+    if model:
+        model = resolve_llm_model_path(model)
     ctx_workers = []
     gen_workers = []
     disagg_server = None
@@ -2087,6 +2110,22 @@ def test_disaggregated_gpt_oss_120b_harmony(disaggregated_test_root,
                            cwd=llm_venv.get_working_directory())
 
 
+@skip_pre_hopper
+@pytest.mark.skip_less_device(8)
+@pytest.mark.parametrize("model_path", ['Qwen3/Qwen3-32B-FP8'])
+def test_disaggregated_qwen3_32b_fp8(disaggregated_test_root,
+                                     disaggregated_example_root, llm_venv,
+                                     model_path):
+    model_dir = resolve_llm_model_path(model_path)
+    setup_model_symlink(llm_venv, model_dir, model_path)
+
+    run_disaggregated_test(disaggregated_example_root,
+                           "qwen3_32b_fp8_stress",
+                           env=llm_venv._new_env,
+                           model_path=model_dir,
+                           cwd=llm_venv.get_working_directory())
+
+
 @pytest.mark.timeout(12600)
 @pytest.mark.parametrize("test_config", [
     pytest.param(TestConfig(model_path='DeepSeek-R1/DeepSeek-R1-0528-FP4-v2',
@@ -2099,6 +2138,11 @@ def test_disaggregated_gpt_oss_120b_harmony(disaggregated_test_root,
                             request_count=60000,
                             accuracy_threshold=0.42),
                  marks=(pytest.mark.skip_less_device(4), skip_pre_blackwell)),
+    pytest.param(TestConfig(model_path='Qwen3/Qwen3-32B-FP8',
+                            test_desc='qwen3_32b_fp8_stress',
+                            request_count=10000,
+                            accuracy_threshold=0.42),
+                 marks=(pytest.mark.skip_less_device(8), skip_pre_hopper)),
 ],
                          ids=lambda x: x.test_desc)
 @pytest.mark.parametrize("concurrency", [512], ids=lambda x: f"conc{x}")
@@ -2113,7 +2157,7 @@ def test_disaggregated_stress_test(disaggregated_test_root,
     # Unpack configuration from dataclass
     model_path = test_config.model_path
     test_desc = test_config.test_desc
-    model_dir = f"{llm_models_root()}/{model_path}"
+    model_dir = resolve_llm_model_path(model_path)
     setup_model_symlink(llm_venv, model_dir, model_path)
 
     config_file = get_test_config(test_desc, disaggregated_example_root,

tests/integration/test_lists/qa/llm_function_stress.txt

@@ -7,6 +7,7 @@ stress_test/stress_test.py::test_run_stress_test[DeepSeek-R1-0528-FP4_tp4-stress
 stress_test/stress_test.py::test_run_stress_test[DeepSeek-R1-0528-FP4_tp4-stress_time_3600s_timeout_10800s-MAX_UTILIZATION-pytorch-stress-test-with-accuracy]
 disaggregated/test_disaggregated.py::test_disaggregated_stress_test[input8k-output1k-conc512-deepseek_r1_v2_fp4_stress]
 disaggregated/test_disaggregated.py::test_disaggregated_stress_test[input8k-output1k-conc512-gpt_oss_120b_stress]
+disaggregated/test_disaggregated.py::test_disaggregated_stress_test[input8k-output1k-conc512-qwen3_32b_fp8_stress]
 accuracy/test_llm_api_pytorch.py::TestDeepSeekR1LongBenchV2::test_fp8_8gpus
 accuracy/test_llm_api_pytorch.py::TestDeepSeekR1LongBenchV2::test_nvfp4_4gpus
 accuracy/test_llm_api_pytorch.py::TestKimiK2::test_nvfp4_longseq_trtllm_moe_stress

tests/integration/test_lists/test-db/l0_dgx_h200.yml

@@ -42,6 +42,7 @@ l0_dgx_h200:
   - disaggregated/test_disaggregated.py::test_disaggregated_ctxtp2pp2_gentp2pp2[TinyLlama-1.1B-Chat-v1.0]
   - disaggregated/test_disaggregated.py::test_disaggregated_ctxpp4_genpp4[TinyLlama-1.1B-Chat-v1.0]
   - disaggregated/test_disaggregated.py::test_disaggregated_deepseek_v3_lite_fp8_ctxtp2ep2pp2_gentp4_one_mtp_block_reuse[DeepSeek-V3-Lite-fp8]
+  - disaggregated/test_disaggregated.py::test_disaggregated_qwen3_32b_fp8[Qwen3/Qwen3-32B-FP8]
   - unittest/llmapi/test_llm_pytorch.py::test_nemotron_nas_lora
 - condition:
     ranges: