[Bugfix] Fix SHM cache initialization (vllm-project#26427)

Signed-off-by: DarkLight1337 <tlleungac@connect.ust.hk>

Author: DarkLight1337

tests/entrypoints/openai/test_lora_resolvers.py

@@ -113,15 +113,17 @@ async def mock_generate(*args, **kwargs):
     mock_engine.generate.reset_mock()
     mock_engine.add_lora.reset_mock()
 
-    mock_model_config = MockModelConfig()
+    mock_engine.model_config = MockModelConfig()
+    mock_engine.processor = MagicMock()
+    mock_engine.io_processor = MagicMock()
+
     models = OpenAIServingModels(
         engine_client=mock_engine,
         base_model_paths=BASE_MODEL_PATHS,
-        model_config=mock_model_config,
     )
 
     serving_completion = OpenAIServingCompletion(
-        mock_engine, mock_model_config, models, request_logger=None
+        mock_engine, models, request_logger=None
     )
 
     serving_completion._process_inputs = AsyncMock(

tests/entrypoints/openai/test_serving_chat.py

@@ -245,17 +245,13 @@ def get_diff_sampling_param(self):
         return self.diff_sampling_param or {}
 
 
-def _build_serving_chat(
-    engine: AsyncLLM, model_config: MockModelConfig
-) -> OpenAIServingChat:
+def _build_serving_chat(engine: AsyncLLM) -> OpenAIServingChat:
     models = OpenAIServingModels(
         engine_client=engine,
         base_model_paths=BASE_MODEL_PATHS,
-        model_config=model_config,
     )
     serving_chat = OpenAIServingChat(
         engine,
-        model_config,
         models,
         response_role="assistant",
         chat_template=CHAT_TEMPLATE,
@@ -280,18 +276,17 @@ async def _fake_process_inputs(
 
 @dataclass
 class MockEngine:
-    async def get_model_config(self):
-        return MockModelConfig()
+    model_config: MockModelConfig = field(default_factory=MockModelConfig)
+    processor: MagicMock = field(default_factory=MagicMock)
+    io_processor: MagicMock = field(default_factory=MagicMock)
 
 
 async def _async_serving_chat_init():
     engine = MockEngine()
-    model_config = await engine.get_model_config()
 
-    models = OpenAIServingModels(engine, model_config, BASE_MODEL_PATHS)
+    models = OpenAIServingModels(engine, BASE_MODEL_PATHS)
     serving_completion = OpenAIServingChat(
         engine,
-        model_config,
         models,
         response_role="assistant",
         chat_template=CHAT_TEMPLATE,
@@ -311,8 +306,11 @@ async def test_serving_chat_returns_correct_model_name():
     mock_engine = MagicMock(spec=AsyncLLM)
     mock_engine.get_tokenizer.return_value = get_tokenizer(MODEL_NAME)
     mock_engine.errored = False
+    mock_engine.model_config = MockModelConfig()
+    mock_engine.processor = MagicMock()
+    mock_engine.io_processor = MagicMock()
 
-    serving_chat = _build_serving_chat(mock_engine, MockModelConfig())
+    serving_chat = _build_serving_chat(mock_engine)
     messages = [{"role": "user", "content": "what is 1+1?"}]
 
     async def return_model_name(*args):
@@ -338,8 +336,11 @@ async def test_serving_chat_should_set_correct_max_tokens():
     mock_engine = MagicMock(spec=AsyncLLM)
     mock_engine.get_tokenizer.return_value = get_tokenizer(MODEL_NAME)
     mock_engine.errored = False
+    mock_engine.model_config = MockModelConfig()
+    mock_engine.processor = MagicMock()
+    mock_engine.io_processor = MagicMock()
 
-    serving_chat = _build_serving_chat(mock_engine, MockModelConfig())
+    serving_chat = _build_serving_chat(mock_engine)
 
     req = ChatCompletionRequest(
         model=MODEL_NAME,
@@ -368,9 +369,12 @@ async def test_serving_chat_should_set_correct_max_tokens():
     mock_engine = MagicMock(spec=AsyncLLM)
     mock_engine.get_tokenizer.return_value = get_tokenizer(MODEL_NAME)
     mock_engine.errored = False
+    mock_engine.model_config = mock_model_config
+    mock_engine.processor = MagicMock()
+    mock_engine.io_processor = MagicMock()
 
     # Initialize the serving chat
-    serving_chat = _build_serving_chat(mock_engine, mock_model_config)
+    serving_chat = _build_serving_chat(mock_engine)
 
     # Test Case 1: No max_tokens specified in request
     req = ChatCompletionRequest(
@@ -410,9 +414,12 @@ async def test_serving_chat_should_set_correct_max_tokens():
     mock_engine = MagicMock(spec=AsyncLLM)
     mock_engine.get_tokenizer.return_value = get_tokenizer(MODEL_NAME)
     mock_engine.errored = False
+    mock_engine.model_config = mock_model_config
+    mock_engine.processor = MagicMock()
+    mock_engine.io_processor = MagicMock()
 
     # Initialize the serving chat
-    serving_chat = _build_serving_chat(mock_engine, mock_model_config)
+    serving_chat = _build_serving_chat(mock_engine)
 
     # Test case 1: No max_tokens specified, defaults to context_window
     req = ChatCompletionRequest(
@@ -453,9 +460,12 @@ async def test_serving_chat_could_load_correct_generation_config():
     mock_engine = MagicMock(spec=AsyncLLM)
     mock_engine.get_tokenizer.return_value = get_tokenizer(MODEL_NAME)
     mock_engine.errored = False
+    mock_engine.model_config = mock_model_config
+    mock_engine.processor = MagicMock()
+    mock_engine.io_processor = MagicMock()
 
     # Initialize the serving chat
-    serving_chat = _build_serving_chat(mock_engine, mock_model_config)
+    serving_chat = _build_serving_chat(mock_engine)
 
     req = ChatCompletionRequest(
         model=MODEL_NAME,
@@ -496,8 +506,11 @@ async def test_serving_chat_did_set_correct_cache_salt(model_type):
     mock_engine = MagicMock(spec=AsyncLLM)
     mock_engine.get_tokenizer.return_value = get_tokenizer(MODEL_NAME)
     mock_engine.errored = False
+    mock_engine.model_config = mock_model_config
+    mock_engine.processor = MagicMock()
+    mock_engine.io_processor = MagicMock()
 
-    serving_chat = _build_serving_chat(mock_engine, mock_model_config)
+    serving_chat = _build_serving_chat(mock_engine)
 
     # Test cache_salt
     req = ChatCompletionRequest(

tests/entrypoints/openai/test_serving_engine.py

@@ -22,10 +22,12 @@ def serving() -> OpenAIServing:
     model_config = Mock(spec=ModelConfig)
     model_config.max_model_len = 32768
     models = Mock(spec=OpenAIServingModels)
+    models.model_config = model_config
+    models.processor = Mock()
+    models.io_processor = Mock()
 
     serving = OpenAIServing(
         engine_client=engine_client,
-        model_config=model_config,
         models=models,
         request_logger=None,
     )

tests/entrypoints/openai/test_serving_models.py

@@ -25,15 +25,17 @@
 
 
 async def _async_serving_models_init() -> OpenAIServingModels:
-    mock_model_config = MagicMock(spec=ModelConfig)
     mock_engine_client = MagicMock(spec=EngineClient)
     # Set the max_model_len attribute to avoid missing attribute
+    mock_model_config = MagicMock(spec=ModelConfig)
     mock_model_config.max_model_len = 2048
+    mock_engine_client.model_config = mock_model_config
+    mock_engine_client.processor = MagicMock()
+    mock_engine_client.io_processor = MagicMock()
 
     serving_models = OpenAIServingModels(
         engine_client=mock_engine_client,
         base_model_paths=BASE_MODEL_PATHS,
-        model_config=mock_model_config,
         lora_modules=None,
     )
     await serving_models.init_static_loras()

tests/entrypoints/openai/test_serving_responses.py

@@ -2,7 +2,7 @@
 # SPDX-FileCopyrightText: Copyright contributors to the vLLM project
 
 from contextlib import AsyncExitStack
-from unittest.mock import AsyncMock, MagicMock
+from unittest.mock import MagicMock
 
 import pytest
 import pytest_asyncio
@@ -70,11 +70,14 @@ async def serving_responses_instance(self):
         """Create a real OpenAIServingResponses instance for testing"""
         # Create minimal mocks for required dependencies
         engine_client = MagicMock()
-        engine_client.get_model_config = AsyncMock()
 
         model_config = MagicMock()
         model_config.hf_config.model_type = "test"
         model_config.get_diff_sampling_param.return_value = {}
+        engine_client.model_config = model_config
+
+        engine_client.processor = MagicMock()
+        engine_client.io_processor = MagicMock()
 
         models = MagicMock()
 
@@ -83,7 +86,6 @@ async def serving_responses_instance(self):
         # Create the actual instance
         instance = OpenAIServingResponses(
             engine_client=engine_client,
-            model_config=model_config,
             models=models,
             request_logger=None,
             chat_template=None,
@@ -132,18 +134,20 @@ async def serving_responses_instance(self):
         """Create a real OpenAIServingResponses instance for testing"""
         # Create minimal mocks for required dependencies
         engine_client = MagicMock()
-        engine_client.get_model_config = AsyncMock()
 
         model_config = MagicMock()
         model_config.hf_config.model_type = "test"
         model_config.get_diff_sampling_param.return_value = {}
+        engine_client.model_config = model_config
+
+        engine_client.processor = MagicMock()
+        engine_client.io_processor = MagicMock()
 
         models = MagicMock()
 
         # Create the actual instance
         instance = OpenAIServingResponses(
             engine_client=engine_client,
-            model_config=model_config,
             models=models,
             request_logger=None,
             chat_template=None,

tests/test_inputs.py

@@ -7,6 +7,7 @@
 from vllm.inputs import zip_enc_dec_prompts
 from vllm.inputs.parse import parse_raw_prompts
 from vllm.inputs.preprocess import InputPreprocessor
+from vllm.transformers_utils.tokenizer import init_tokenizer_from_configs
 
 pytestmark = pytest.mark.cpu_test
 
@@ -106,7 +107,8 @@ def test_zip_enc_dec_prompts(mm_processor_kwargs, expected_mm_kwargs):
 )
 def test_preprocessor_text_no_mm_inputs(model_id, prompt):
     model_config = ModelConfig(model=model_id)
-    input_preprocessor = InputPreprocessor(model_config)
+    tokenizer = init_tokenizer_from_configs(model_config)
+    input_preprocessor = InputPreprocessor(model_config, tokenizer)
 
     with pytest.raises(ValueError, match="does not support multimodal inputs"):
         input_preprocessor.preprocess(prompt)
@@ -127,8 +129,8 @@ def test_preprocessor_text_no_mm_inputs(model_id, prompt):
 )
 def test_preprocessor_always_mm_code_path(model_id, prompt):
     model_config = ModelConfig(model=model_id)
-    input_preprocessor = InputPreprocessor(model_config)
-    tokenizer = input_preprocessor.tokenizer
+    tokenizer = init_tokenizer_from_configs(model_config)
+    input_preprocessor = InputPreprocessor(model_config, tokenizer)
 
     # HF processor adds sep token
     sep_token_id = tokenizer.vocab[tokenizer.sep_token]

tests/v1/engine/test_processor_multi_modal_uuids.py

@@ -65,7 +65,7 @@ def __init__(self, gb: float):
         device_config=DeviceConfig(device="cpu"),
     )
 
-    return Processor(vllm_config)
+    return Processor(vllm_config, tokenizer=None)
 
 
 def test_multi_modal_uuids_length_mismatch_raises(monkeypatch):

tests/v1/sample/test_logprobs.py

@@ -459,7 +459,7 @@ def test_all_logprobs(example_prompts):
     results_logprobs_all = runner.llm.generate(
         example_prompts, sampling_params=sampling_params_logprobs_all
     )
-    vocab_size = runner.llm.llm_engine.get_model_config().get_vocab_size()
+    vocab_size = runner.llm.llm_engine.model_config.get_vocab_size()
 
     for i in range(len(results_logprobs_all)):
         logprobs = results_logprobs_all[i].outputs[0].logprobs

vllm/benchmarks/throughput.py

@@ -186,7 +186,7 @@ async def run_vllm_async(
         engine_args,
         disable_frontend_multiprocessing=disable_frontend_multiprocessing,
     ) as llm:
-        model_config = await llm.get_model_config()
+        model_config = llm.model_config
         assert all(
             model_config.max_model_len
             >= (request.prompt_len + request.expected_output_len)