From b6c5ef97cd4332d176233d3702c05ec9754e40b0 Mon Sep 17 00:00:00 2001
From: jesse <szxfml@gmail.com>
Date: Fri, 5 Sep 2025 23:03:10 +0800
Subject: [PATCH 01/14] use event sync

Signed-off-by: jesse <szxfml@gmail.com>
---
 vllm_ascend/worker/model_runner_v1.py | 30 +++++++++++++++++++++++----
 1 file changed, 26 insertions(+), 4 deletions(-)

diff --git a/vllm_ascend/worker/model_runner_v1.py b/vllm_ascend/worker/model_runner_v1.py
index 9e8b58e34b..8e6970df46 100644
--- a/vllm_ascend/worker/model_runner_v1.py
+++ b/vllm_ascend/worker/model_runner_v1.py
@@ -176,6 +176,7 @@ def __init__(self, vllm_config: VllmConfig, device: torch.device):
         self.block_size = vllm_config.cache_config.block_size
         self.max_num_blocks_per_req = cdiv(self.model_config.max_model_len,
                                            self.block_size)
+        self.max_model_len = self.model_config.max_model_len
         self.max_num_tokens = self.scheduler_config.max_num_batched_tokens
         self.max_num_reqs = self.scheduler_config.max_num_seqs
         self.dp_size = vllm_config.parallel_config.data_parallel_size
@@ -343,6 +344,12 @@ def __init__(self, vllm_config: VllmConfig, device: torch.device):
         # Cached outputs.
         self._draft_token_ids: Optional[Union[list[list[int]],
                                               torch.Tensor]] = None
+        self.transfer_event = torch_npu.npu.Event()
+        self.sampled_token_ids_pinned_cpu = torch.empty(
+            (self.max_model_len, 1),
+            dtype=torch.int64,
+            device="cpu",
+            pin_memory=True)
 
         # NOTE: we need to use `in_profile_run` to determine whether `enable_force_load_balance` is True
         self.in_profile_run = False
@@ -1439,11 +1446,11 @@ def _select_moe_comm_method(self, num_tokens: int) -> str:
         2. If expert parallel is enabled, we need to consider the soc version and the
         number of tokens. This is based on the observation that all-gather is more
         efficient than all-to-all when running on A2.
-            
+
             a. For A2, we choose from MC2 and all-gather.
-            
+
             b. For A3, we choose from MC2 and all-to-all.
-            
+
             In both cases, we use MC2 when the number of tokens is smaller than
             a its capacity threshold.
 
@@ -1662,7 +1669,7 @@ def execute_model(
             max_gen_len = sampled_token_ids.shape[-1]
             if max_gen_len == 1:
                 # No spec decode tokens.
-                valid_sampled_token_ids = sampled_token_ids.tolist()
+                valid_sampled_token_ids = self._to_list(sampled_token_ids)
             else:
                 # Includes spec decode tokens.
                 valid_sampled_token_ids = self.rejection_sampler.parse_output(
@@ -2527,3 +2534,18 @@ def get_supported_pooling_tasks(self):
 
     def _build_drafter_prepare_inputs_torchair_param(self):
         return False
+
+    def _to_list(self, sampled_token_ids: torch.Tensor) -> list[list[int]]:
+        # This is a short term mitigation for issue mentioned in
+        # https://github.com/vllm-project/vllm/issues/22754.
+        # `tolist` would trigger a cuda wise stream sync, which
+        # would block other copy ops from other cuda streams.
+        # A cuda event sync would avoid such a situation. Since
+        # this is in the critical path of every single model
+        # forward loop, this has caused perf issue for a disagg
+        # setup.
+        pinned = self.sampled_token_ids_pinned_cpu[:sampled_token_ids.shape[0]]
+        pinned.copy_(sampled_token_ids, non_blocking=True)
+        self.transfer_event.record()
+        self.transfer_event.synchronize()
+        return pinned.tolist()
\ No newline at end of file

From 9816a3679b53d176a1196ab9c449620a7b598733 Mon Sep 17 00:00:00 2001
From: jesse <szxfml@gmail.com>
Date: Sat, 6 Sep 2025 02:05:17 +0800
Subject: [PATCH 02/14] add test

Signed-off-by: jesse <szxfml@gmail.com>
---
 .../ut/worker/test_model_runner_event_sync.py | 269 ++++++++++++++++++
 1 file changed, 269 insertions(+)
 create mode 100644 tests/ut/worker/test_model_runner_event_sync.py

diff --git a/tests/ut/worker/test_model_runner_event_sync.py b/tests/ut/worker/test_model_runner_event_sync.py
new file mode 100644
index 0000000000..39300f8d9f
--- /dev/null
+++ b/tests/ut/worker/test_model_runner_event_sync.py
@@ -0,0 +1,269 @@
+import torch
+import torch_npu
+from unittest import mock
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+from tests.ut.base import PytestBase
+from vllm import VllmConfig
+from vllm_ascend.worker.model_runner_v1 import NPUModelRunner
+
+
+class TestNPUModelRunnerEventSync(PytestBase):
+    """Test event synchronization optimization in NPUModelRunner"""
+
+    @pytest.fixture
+    def mock_vllm_config(self):
+        """Create a mock VllmConfig for testing"""
+        config = MagicMock(spec=VllmConfig)
+
+        # Mock model config
+        config.model_config = MagicMock()
+        config.model_config.max_model_len = 2048
+        config.model_config.is_multimodal_model = False
+        config.model_config.uses_mrope = False
+        config.model_config.use_mla = False
+
+        # Mock cache config
+        config.cache_config = MagicMock()
+        config.cache_config.block_size = 16
+        config.cache_config.max_num_blocks_per_req = 128
+
+        # Mock scheduler config
+        config.scheduler_config = MagicMock()
+        config.scheduler_config.max_num_batched_tokens = 2048
+        config.scheduler_config.max_num_seqs = 256
+
+        # Mock parallel config
+        config.parallel_config = MagicMock()
+        config.parallel_config.data_parallel_size = 1
+        config.parallel_config.enable_expert_parallel = False
+        config.parallel_config.world_size = 1
+
+        # Mock lora config
+        config.lora_config = None
+
+        # Mock speculative config
+        config.speculative_config = None
+
+        # Mock observability config
+        config.observability_config = MagicMock()
+        config.observability_config.collect_detailed_traces = False
+
+        return config
+
+    @pytest.fixture
+    def model_runner(self, mock_vllm_config):
+        """Create NPUModelRunner instance with mocked dependencies"""
+        device = torch.device("npu:0")
+
+        with patch('vllm_ascend.worker.model_runner_v1.get_ascend_config'), \
+             patch('vllm_ascend.worker.model_runner_v1.envs_ascend'), \
+             patch('vllm_ascend.worker.model_runner_v1.get_dp_group'), \
+             patch('vllm_ascend.worker.model_runner_v1.get_pp_group'), \
+             patch('vllm_ascend.worker.model_runner_v1.get_tp_group'), \
+             patch('vllm_ascend.worker.model_runner_v1.lmhead_tp_enable'), \
+             patch('vllm_ascend.worker.model_runner_v1.AscendCommonAttentionMetadata'), \
+             patch('vllm_ascend.worker.model_runner_v1.AscendMLACommonAttentionMetadata'), \
+             patch('vllm_ascend.worker.model_runner_v1.InputBatch'), \
+             patch('vllm_ascend.worker.model_runner_v1.AscendAttentionMetadataBuilder'), \
+             patch('vllm_ascend.worker.model_runner_v1.AscendMLAAttentionMetadataBuilder'), \
+             patch('vllm_ascend.worker.model_runner_v1.AscendSampler'), \
+             patch('vllm_ascend.worker.model_runner_v1.AscendRejectionSampler'), \
+             patch('vllm_ascend.worker.model_runner_v1.ACLGraphDispatcher'), \
+             patch('vllm_ascend.worker.model_runner_v1.HunYuanVideoTextModelAdapter'):
+
+            runner = NPUModelRunner(mock_vllm_config, device)
+            return runner
+
+    def test_initialization_with_event_sync_attributes(self, model_runner):
+        """Test that NPUModelRunner initializes with event sync attributes"""
+        # Check that transfer_event is initialized
+        assert hasattr(model_runner, 'transfer_event')
+        assert isinstance(model_runner.transfer_event, torch_npu.npu.Event)
+
+        # Check that sampled_token_ids_pinned_cpu is initialized
+        assert hasattr(model_runner, 'sampled_token_ids_pinned_cpu')
+        assert isinstance(model_runner.sampled_token_ids_pinned_cpu, torch.Tensor)
+        assert model_runner.sampled_token_ids_pinned_cpu.device.type == 'cpu'
+        assert model_runner.sampled_token_ids_pinned_cpu.is_pinned()
+        assert model_runner.sampled_token_ids_pinned_cpu.shape == (2048, 1)  # max_model_len, 1
+        assert model_runner.sampled_token_ids_pinned_cpu.dtype == torch.int64
+
+    def test_to_list_method_basic_functionality(self, model_runner):
+        """Test basic functionality of _to_list method"""
+        # Create a sample tensor on NPU
+        sampled_token_ids = torch.tensor([[1], [2], [3]], dtype=torch.int64, device="npu:0")
+
+        # Mock the event methods
+        model_runner.transfer_event.record = MagicMock()
+        model_runner.transfer_event.synchronize = MagicMock()
+
+        # Call _to_list
+        result = model_runner._to_list(sampled_token_ids)
+
+        # Verify result
+        assert isinstance(result, list)
+        assert len(result) == 3
+        assert result == [[1], [2], [3]]
+
+        # Verify event methods were called
+        model_runner.transfer_event.record.assert_called_once()
+        model_runner.transfer_event.synchronize.assert_called_once()
+
+    def test_to_list_method_with_different_sizes(self, model_runner):
+        """Test _to_list method with different tensor sizes"""
+        # Mock the event methods
+        model_runner.transfer_event.record = MagicMock()
+        model_runner.transfer_event.synchronize = MagicMock()
+
+        # Test with single token
+        single_token = torch.tensor([[42]], dtype=torch.int64, device="npu:0")
+        result_single = model_runner._to_list(single_token)
+        assert result_single == [[42]]
+
+        # Test with multiple tokens
+        multi_tokens = torch.tensor([[1], [2], [3], [4], [5]], dtype=torch.int64, device="npu:0")
+        result_multi = model_runner._to_list(multi_tokens)
+        assert result_multi == [[1], [2], [3], [4], [5]]
+
+        # Verify events were called for both cases
+        assert model_runner.transfer_event.record.call_count == 2
+        assert model_runner.transfer_event.synchronize.call_count == 2
+
+    def test_to_list_method_uses_pinned_memory(self, model_runner):
+        """Test that _to_list method correctly uses pinned memory buffer"""
+        sampled_token_ids = torch.tensor([[10], [20]], dtype=torch.int64, device="npu:0")
+
+        # Mock the event methods
+        model_runner.transfer_event.record = MagicMock()
+        model_runner.transfer_event.synchronize = MagicMock()
+
+        # Mock the pinned tensor copy operation to verify it's called correctly
+        original_copy = model_runner.sampled_token_ids_pinned_cpu.copy_
+        model_runner.sampled_token_ids_pinned_cpu.copy_ = MagicMock(side_effect=original_copy)
+
+        # Call _to_list
+        result = model_runner._to_list(sampled_token_ids)
+
+        # Verify the pinned memory buffer was used correctly
+        model_runner.sampled_token_ids_pinned_cpu.copy_.assert_called_once()
+        args, kwargs = model_runner.sampled_token_ids_pinned_cpu.copy_.call_args
+        assert torch.equal(args[0], sampled_token_ids)
+        assert kwargs.get('non_blocking', False) == True
+
+        # Verify result
+        assert result == [[10], [20]]
+
+    @patch.object(NPUModelRunner, '_to_list')
+    def test_execute_model_uses_to_list_method(self, mock_to_list, model_runner):
+        """Test that execute_model uses _to_list method instead of direct tolist()"""
+        # This test verifies the integration point where sampled_token_ids.tolist()
+        # was replaced with self._to_list(sampled_token_ids)
+
+        # Mock dependencies for execute_model
+        mock_scheduler_output = MagicMock()
+        mock_scheduler_output.total_num_scheduled_tokens = 0
+
+        # Mock the no work case to avoid full model execution
+        with patch('vllm_ascend.worker.model_runner_v1.has_kv_transfer_group', return_value=False):
+            result = model_runner.execute_model(mock_scheduler_output)
+
+            # In the no-work case, _to_list should not be called
+            mock_to_list.assert_not_called()
+
+    def test_to_list_method_memory_efficiency(self, model_runner):
+        """Test that _to_list method is memory efficient"""
+        # Create a larger tensor to test memory usage
+        large_tensor = torch.tensor(
+            [[i] for i in range(100)],
+            dtype=torch.int64,
+            device="npu:0"
+        )
+
+        # Mock the event methods
+        model_runner.transfer_event.record = MagicMock()
+        model_runner.transfer_event.synchronize = MagicMock()
+
+        # Verify that the method doesn't create unnecessary copies
+        original_pinned_buffer = model_runner.sampled_token_ids_pinned_cpu
+
+        result = model_runner._to_list(large_tensor)
+
+        # Buffer should be the same object (no new allocation)
+        assert model_runner.sampled_token_ids_pinned_cpu is original_pinned_buffer
+
+        # Result should be correct
+        expected = [[i] for i in range(100)]
+        assert result == expected
+
+    def test_to_list_method_error_handling(self, model_runner):
+        """Test _to_list method with edge cases and error conditions"""
+        # Test with empty tensor
+        empty_tensor = torch.empty((0, 1), dtype=torch.int64, device="npu:0")
+
+        # Mock the event methods
+        model_runner.transfer_event.record = MagicMock()
+        model_runner.transfer_event.synchronize = MagicMock()
+
+        result = model_runner._to_list(empty_tensor)
+        assert result == []
+
+        # Events should still be called for consistency
+        model_runner.transfer_event.record.assert_called_once()
+        model_runner.transfer_event.synchronize.assert_called_once()
+
+    def test_to_list_method_performance_optimization(self, model_runner):
+        """Test that _to_list method implements the performance optimization correctly"""
+        sampled_token_ids = torch.tensor([[1], [2]], dtype=torch.int64, device="npu:0")
+
+        # Mock the event methods to verify synchronization pattern
+        model_runner.transfer_event.record = MagicMock()
+        model_runner.transfer_event.synchronize = MagicMock()
+
+        # Call the method
+        result = model_runner._to_list(sampled_token_ids)
+
+        # Verify that the optimization pattern is followed:
+        # 1. Non-blocking copy to pinned memory
+        # 2. Event record
+        # 3. Event synchronize
+        # 4. tolist() on CPU tensor
+        model_runner.transfer_event.record.assert_called_once()
+        model_runner.transfer_event.synchronize.assert_called_once()
+
+        # Verify the event methods are called in the correct order
+        # (record before synchronize)
+        calls = [call[0] for call in [
+            model_runner.transfer_event.record.call_args,
+            model_runner.transfer_event.synchronize.call_args
+        ]]
+        assert len(calls) == 2  # Both methods should have been called
+
+    def test_max_model_len_attribute_initialization(self, mock_vllm_config):
+        """Test that max_model_len attribute is properly initialized"""
+        device = torch.device("npu:0")
+
+        with patch('vllm_ascend.worker.model_runner_v1.get_ascend_config'), \
+             patch('vllm_ascend.worker.model_runner_v1.envs_ascend'), \
+             patch('vllm_ascend.worker.model_runner_v1.get_dp_group'), \
+             patch('vllm_ascend.worker.model_runner_v1.get_pp_group'), \
+             patch('vllm_ascend.worker.model_runner_v1.get_tp_group'), \
+             patch('vllm_ascend.worker.model_runner_v1.lmhead_tp_enable'), \
+             patch('vllm_ascend.worker.model_runner_v1.AscendCommonAttentionMetadata'), \
+             patch('vllm_ascend.worker.model_runner_v1.AscendMLACommonAttentionMetadata'), \
+             patch('vllm_ascend.worker.model_runner_v1.InputBatch'), \
+             patch('vllm_ascend.worker.model_runner_v1.AscendAttentionMetadataBuilder'), \
+             patch('vllm_ascend.worker.model_runner_v1.AscendMLAAttentionMetadataBuilder'), \
+             patch('vllm_ascend.worker.model_runner_v1.AscendSampler'), \
+             patch('vllm_ascend.worker.model_runner_v1.AscendRejectionSampler'), \
+             patch('vllm_ascend.worker.model_runner_v1.ACLGraphDispatcher'), \
+             patch('vllm_ascend.worker.model_runner_v1.HunYuanVideoTextModelAdapter'):
+
+            runner = NPUModelRunner(mock_vllm_config, device)
+
+            # Verify max_model_len is set correctly
+            assert hasattr(runner, 'max_model_len')
+            assert runner.max_model_len == mock_vllm_config.model_config.max_model_len
+            assert runner.max_model_len == 2048

From f14a98b4bf7149d4dd94988e22f4b259f9f3d71b Mon Sep 17 00:00:00 2001
From: jesse <szxfml@gmail.com>
Date: Sat, 6 Sep 2025 02:18:07 +0800
Subject: [PATCH 03/14] update test

Signed-off-by: jesse <szxfml@gmail.com>
---
 .../ut/worker/test_model_runner_event_sync.py | 242 +++---------------
 1 file changed, 40 insertions(+), 202 deletions(-)

diff --git a/tests/ut/worker/test_model_runner_event_sync.py b/tests/ut/worker/test_model_runner_event_sync.py
index 39300f8d9f..e0145dffd7 100644
--- a/tests/ut/worker/test_model_runner_event_sync.py
+++ b/tests/ut/worker/test_model_runner_event_sync.py
@@ -1,6 +1,5 @@
 import torch
 import torch_npu
-from unittest import mock
 from unittest.mock import MagicMock, patch
 
 import pytest
@@ -11,259 +10,98 @@
 
 
 class TestNPUModelRunnerEventSync(PytestBase):
-    """Test event synchronization optimization in NPUModelRunner"""
+    """Test event synchronization optimization added in commit b6c5ef9"""
 
     @pytest.fixture
     def mock_vllm_config(self):
-        """Create a mock VllmConfig for testing"""
+        """Create minimal mock VllmConfig for testing"""
         config = MagicMock(spec=VllmConfig)
-
-        # Mock model config
         config.model_config = MagicMock()
-        config.model_config.max_model_len = 2048
-        config.model_config.is_multimodal_model = False
-        config.model_config.uses_mrope = False
-        config.model_config.use_mla = False
-
-        # Mock cache config
+        config.model_config.max_model_len = 1024  # Test the new max_model_len attribute
         config.cache_config = MagicMock()
         config.cache_config.block_size = 16
-        config.cache_config.max_num_blocks_per_req = 128
-
-        # Mock scheduler config
         config.scheduler_config = MagicMock()
-        config.scheduler_config.max_num_batched_tokens = 2048
-        config.scheduler_config.max_num_seqs = 256
-
-        # Mock parallel config
+        config.scheduler_config.max_num_batched_tokens = 1024
+        config.scheduler_config.max_num_seqs = 64
         config.parallel_config = MagicMock()
         config.parallel_config.data_parallel_size = 1
-        config.parallel_config.enable_expert_parallel = False
-        config.parallel_config.world_size = 1
-
-        # Mock lora config
         config.lora_config = None
-
-        # Mock speculative config
         config.speculative_config = None
-
-        # Mock observability config
-        config.observability_config = MagicMock()
-        config.observability_config.collect_detailed_traces = False
-
         return config
 
     @pytest.fixture
     def model_runner(self, mock_vllm_config):
-        """Create NPUModelRunner instance with mocked dependencies"""
+        """Create NPUModelRunner with minimal mocking"""
         device = torch.device("npu:0")
-
         with patch('vllm_ascend.worker.model_runner_v1.get_ascend_config'), \
              patch('vllm_ascend.worker.model_runner_v1.envs_ascend'), \
              patch('vllm_ascend.worker.model_runner_v1.get_dp_group'), \
              patch('vllm_ascend.worker.model_runner_v1.get_pp_group'), \
              patch('vllm_ascend.worker.model_runner_v1.get_tp_group'), \
-             patch('vllm_ascend.worker.model_runner_v1.lmhead_tp_enable'), \
-             patch('vllm_ascend.worker.model_runner_v1.AscendCommonAttentionMetadata'), \
-             patch('vllm_ascend.worker.model_runner_v1.AscendMLACommonAttentionMetadata'), \
              patch('vllm_ascend.worker.model_runner_v1.InputBatch'), \
              patch('vllm_ascend.worker.model_runner_v1.AscendAttentionMetadataBuilder'), \
-             patch('vllm_ascend.worker.model_runner_v1.AscendMLAAttentionMetadataBuilder'), \
              patch('vllm_ascend.worker.model_runner_v1.AscendSampler'), \
-             patch('vllm_ascend.worker.model_runner_v1.AscendRejectionSampler'), \
-             patch('vllm_ascend.worker.model_runner_v1.ACLGraphDispatcher'), \
-             patch('vllm_ascend.worker.model_runner_v1.HunYuanVideoTextModelAdapter'):
-
+             patch('vllm_ascend.worker.model_runner_v1.ACLGraphDispatcher'):
             runner = NPUModelRunner(mock_vllm_config, device)
             return runner
 
-    def test_initialization_with_event_sync_attributes(self, model_runner):
-        """Test that NPUModelRunner initializes with event sync attributes"""
-        # Check that transfer_event is initialized
+    def test_max_model_len_attribute_added(self, model_runner):
+        """Test that max_model_len attribute is properly set from config"""
+        # This tests the line: self.max_model_len = self.model_config.max_model_len
+        assert hasattr(model_runner, 'max_model_len')
+        assert model_runner.max_model_len == 1024
+
+    def test_event_sync_attributes_initialized(self, model_runner):
+        """Test that event sync attributes are properly initialized"""
+        # Test transfer_event is created
         assert hasattr(model_runner, 'transfer_event')
         assert isinstance(model_runner.transfer_event, torch_npu.npu.Event)
 
-        # Check that sampled_token_ids_pinned_cpu is initialized
+        # Test sampled_token_ids_pinned_cpu is created with correct properties
         assert hasattr(model_runner, 'sampled_token_ids_pinned_cpu')
-        assert isinstance(model_runner.sampled_token_ids_pinned_cpu, torch.Tensor)
-        assert model_runner.sampled_token_ids_pinned_cpu.device.type == 'cpu'
-        assert model_runner.sampled_token_ids_pinned_cpu.is_pinned()
-        assert model_runner.sampled_token_ids_pinned_cpu.shape == (2048, 1)  # max_model_len, 1
-        assert model_runner.sampled_token_ids_pinned_cpu.dtype == torch.int64
-
-    def test_to_list_method_basic_functionality(self, model_runner):
-        """Test basic functionality of _to_list method"""
-        # Create a sample tensor on NPU
+        pinned_tensor = model_runner.sampled_token_ids_pinned_cpu
+        assert isinstance(pinned_tensor, torch.Tensor)
+        assert pinned_tensor.device.type == 'cpu'
+        assert pinned_tensor.is_pinned()
+        assert pinned_tensor.shape == (1024, 1)  # (max_model_len, 1)
+        assert pinned_tensor.dtype == torch.int64
+
+    def test_to_list_method_functionality(self, model_runner):
+        """Test the new _to_list method implementation"""
+        # Create test input tensor
         sampled_token_ids = torch.tensor([[1], [2], [3]], dtype=torch.int64, device="npu:0")
 
-        # Mock the event methods
+        # Mock event methods to verify they're called
         model_runner.transfer_event.record = MagicMock()
         model_runner.transfer_event.synchronize = MagicMock()
 
-        # Call _to_list
+        # Test the method
         result = model_runner._to_list(sampled_token_ids)
 
-        # Verify result
-        assert isinstance(result, list)
-        assert len(result) == 3
+        # Verify correct result
         assert result == [[1], [2], [3]]
 
-        # Verify event methods were called
+        # Verify event synchronization pattern
         model_runner.transfer_event.record.assert_called_once()
         model_runner.transfer_event.synchronize.assert_called_once()
 
-    def test_to_list_method_with_different_sizes(self, model_runner):
-        """Test _to_list method with different tensor sizes"""
-        # Mock the event methods
-        model_runner.transfer_event.record = MagicMock()
-        model_runner.transfer_event.synchronize = MagicMock()
-
-        # Test with single token
-        single_token = torch.tensor([[42]], dtype=torch.int64, device="npu:0")
-        result_single = model_runner._to_list(single_token)
-        assert result_single == [[42]]
-
-        # Test with multiple tokens
-        multi_tokens = torch.tensor([[1], [2], [3], [4], [5]], dtype=torch.int64, device="npu:0")
-        result_multi = model_runner._to_list(multi_tokens)
-        assert result_multi == [[1], [2], [3], [4], [5]]
+    def test_to_list_uses_pinned_memory_buffer(self, model_runner):
+        """Test that _to_list uses the pinned memory buffer correctly"""
+        sampled_token_ids = torch.tensor([[5], [10]], dtype=torch.int64, device="npu:0")
 
-        # Verify events were called for both cases
-        assert model_runner.transfer_event.record.call_count == 2
-        assert model_runner.transfer_event.synchronize.call_count == 2
-
-    def test_to_list_method_uses_pinned_memory(self, model_runner):
-        """Test that _to_list method correctly uses pinned memory buffer"""
-        sampled_token_ids = torch.tensor([[10], [20]], dtype=torch.int64, device="npu:0")
-
-        # Mock the event methods
+        # Mock events
         model_runner.transfer_event.record = MagicMock()
         model_runner.transfer_event.synchronize = MagicMock()
 
-        # Mock the pinned tensor copy operation to verify it's called correctly
+        # Mock copy to verify non_blocking=True is used
         original_copy = model_runner.sampled_token_ids_pinned_cpu.copy_
         model_runner.sampled_token_ids_pinned_cpu.copy_ = MagicMock(side_effect=original_copy)
 
-        # Call _to_list
         result = model_runner._to_list(sampled_token_ids)
 
-        # Verify the pinned memory buffer was used correctly
+        # Verify copy was called with non_blocking=True
         model_runner.sampled_token_ids_pinned_cpu.copy_.assert_called_once()
-        args, kwargs = model_runner.sampled_token_ids_pinned_cpu.copy_.call_args
-        assert torch.equal(args[0], sampled_token_ids)
-        assert kwargs.get('non_blocking', False) == True
-
-        # Verify result
-        assert result == [[10], [20]]
-
-    @patch.object(NPUModelRunner, '_to_list')
-    def test_execute_model_uses_to_list_method(self, mock_to_list, model_runner):
-        """Test that execute_model uses _to_list method instead of direct tolist()"""
-        # This test verifies the integration point where sampled_token_ids.tolist()
-        # was replaced with self._to_list(sampled_token_ids)
-
-        # Mock dependencies for execute_model
-        mock_scheduler_output = MagicMock()
-        mock_scheduler_output.total_num_scheduled_tokens = 0
-
-        # Mock the no work case to avoid full model execution
-        with patch('vllm_ascend.worker.model_runner_v1.has_kv_transfer_group', return_value=False):
-            result = model_runner.execute_model(mock_scheduler_output)
-
-            # In the no-work case, _to_list should not be called
-            mock_to_list.assert_not_called()
-
-    def test_to_list_method_memory_efficiency(self, model_runner):
-        """Test that _to_list method is memory efficient"""
-        # Create a larger tensor to test memory usage
-        large_tensor = torch.tensor(
-            [[i] for i in range(100)],
-            dtype=torch.int64,
-            device="npu:0"
-        )
-
-        # Mock the event methods
-        model_runner.transfer_event.record = MagicMock()
-        model_runner.transfer_event.synchronize = MagicMock()
-
-        # Verify that the method doesn't create unnecessary copies
-        original_pinned_buffer = model_runner.sampled_token_ids_pinned_cpu
-
-        result = model_runner._to_list(large_tensor)
-
-        # Buffer should be the same object (no new allocation)
-        assert model_runner.sampled_token_ids_pinned_cpu is original_pinned_buffer
-
-        # Result should be correct
-        expected = [[i] for i in range(100)]
-        assert result == expected
-
-    def test_to_list_method_error_handling(self, model_runner):
-        """Test _to_list method with edge cases and error conditions"""
-        # Test with empty tensor
-        empty_tensor = torch.empty((0, 1), dtype=torch.int64, device="npu:0")
-
-        # Mock the event methods
-        model_runner.transfer_event.record = MagicMock()
-        model_runner.transfer_event.synchronize = MagicMock()
-
-        result = model_runner._to_list(empty_tensor)
-        assert result == []
-
-        # Events should still be called for consistency
-        model_runner.transfer_event.record.assert_called_once()
-        model_runner.transfer_event.synchronize.assert_called_once()
-
-    def test_to_list_method_performance_optimization(self, model_runner):
-        """Test that _to_list method implements the performance optimization correctly"""
-        sampled_token_ids = torch.tensor([[1], [2]], dtype=torch.int64, device="npu:0")
-
-        # Mock the event methods to verify synchronization pattern
-        model_runner.transfer_event.record = MagicMock()
-        model_runner.transfer_event.synchronize = MagicMock()
-
-        # Call the method
-        result = model_runner._to_list(sampled_token_ids)
-
-        # Verify that the optimization pattern is followed:
-        # 1. Non-blocking copy to pinned memory
-        # 2. Event record
-        # 3. Event synchronize
-        # 4. tolist() on CPU tensor
-        model_runner.transfer_event.record.assert_called_once()
-        model_runner.transfer_event.synchronize.assert_called_once()
-
-        # Verify the event methods are called in the correct order
-        # (record before synchronize)
-        calls = [call[0] for call in [
-            model_runner.transfer_event.record.call_args,
-            model_runner.transfer_event.synchronize.call_args
-        ]]
-        assert len(calls) == 2  # Both methods should have been called
-
-    def test_max_model_len_attribute_initialization(self, mock_vllm_config):
-        """Test that max_model_len attribute is properly initialized"""
-        device = torch.device("npu:0")
-
-        with patch('vllm_ascend.worker.model_runner_v1.get_ascend_config'), \
-             patch('vllm_ascend.worker.model_runner_v1.envs_ascend'), \
-             patch('vllm_ascend.worker.model_runner_v1.get_dp_group'), \
-             patch('vllm_ascend.worker.model_runner_v1.get_pp_group'), \
-             patch('vllm_ascend.worker.model_runner_v1.get_tp_group'), \
-             patch('vllm_ascend.worker.model_runner_v1.lmhead_tp_enable'), \
-             patch('vllm_ascend.worker.model_runner_v1.AscendCommonAttentionMetadata'), \
-             patch('vllm_ascend.worker.model_runner_v1.AscendMLACommonAttentionMetadata'), \
-             patch('vllm_ascend.worker.model_runner_v1.InputBatch'), \
-             patch('vllm_ascend.worker.model_runner_v1.AscendAttentionMetadataBuilder'), \
-             patch('vllm_ascend.worker.model_runner_v1.AscendMLAAttentionMetadataBuilder'), \
-             patch('vllm_ascend.worker.model_runner_v1.AscendSampler'), \
-             patch('vllm_ascend.worker.model_runner_v1.AscendRejectionSampler'), \
-             patch('vllm_ascend.worker.model_runner_v1.ACLGraphDispatcher'), \
-             patch('vllm_ascend.worker.model_runner_v1.HunYuanVideoTextModelAdapter'):
-
-            runner = NPUModelRunner(mock_vllm_config, device)
+        _, kwargs = model_runner.sampled_token_ids_pinned_cpu.copy_.call_args
+        assert kwargs.get('non_blocking') == True
 
-            # Verify max_model_len is set correctly
-            assert hasattr(runner, 'max_model_len')
-            assert runner.max_model_len == mock_vllm_config.model_config.max_model_len
-            assert runner.max_model_len == 2048
+        assert result == [[5], [10]]

From beabae40e3a5865fd622c2a61913ba8e5cb4c590 Mon Sep 17 00:00:00 2001
From: jesse <szxfml@gmail.com>
Date: Sat, 6 Sep 2025 08:47:49 +0800
Subject: [PATCH 04/14] fix test

Signed-off-by: jesse <szxfml@gmail.com>
---
 tests/ut/worker/test_model_runner_event_sync.py | 11 ++++++++---
 1 file changed, 8 insertions(+), 3 deletions(-)

diff --git a/tests/ut/worker/test_model_runner_event_sync.py b/tests/ut/worker/test_model_runner_event_sync.py
index e0145dffd7..9a921d7cb2 100644
--- a/tests/ut/worker/test_model_runner_event_sync.py
+++ b/tests/ut/worker/test_model_runner_event_sync.py
@@ -69,7 +69,9 @@ def test_event_sync_attributes_initialized(self, model_runner):
     def test_to_list_method_functionality(self, model_runner):
         """Test the new _to_list method implementation"""
         # Create test input tensor
-        sampled_token_ids = torch.tensor([[1], [2], [3]], dtype=torch.int64, device="npu:0")
+        sampled_token_ids = torch.tensor([[1], [2], [3]],
+                                         dtype=torch.int64,
+                                         device="npu:0")
 
         # Mock event methods to verify they're called
         model_runner.transfer_event.record = MagicMock()
@@ -87,7 +89,9 @@ def test_to_list_method_functionality(self, model_runner):
 
     def test_to_list_uses_pinned_memory_buffer(self, model_runner):
         """Test that _to_list uses the pinned memory buffer correctly"""
-        sampled_token_ids = torch.tensor([[5], [10]], dtype=torch.int64, device="npu:0")
+        sampled_token_ids = torch.tensor([[5], [10]],
+                                         dtype=torch.int64,
+                                         device="npu:0")
 
         # Mock events
         model_runner.transfer_event.record = MagicMock()
@@ -95,7 +99,8 @@ def test_to_list_uses_pinned_memory_buffer(self, model_runner):
 
         # Mock copy to verify non_blocking=True is used
         original_copy = model_runner.sampled_token_ids_pinned_cpu.copy_
-        model_runner.sampled_token_ids_pinned_cpu.copy_ = MagicMock(side_effect=original_copy)
+        model_runner.sampled_token_ids_pinned_cpu.copy_ = MagicMock(
+            side_effect=original_copy)
 
         result = model_runner._to_list(sampled_token_ids)
 

From 3da83fedb6964992d1fdc96f685c58e2272d72c5 Mon Sep 17 00:00:00 2001
From: jesse <szxfml@gmail.com>
Date: Sat, 6 Sep 2025 13:03:01 +0800
Subject: [PATCH 05/14] fix test

Signed-off-by: jesse <szxfml@gmail.com>
---
 tests/ut/worker/test_model_runner_event_sync.py | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/tests/ut/worker/test_model_runner_event_sync.py b/tests/ut/worker/test_model_runner_event_sync.py
index 9a921d7cb2..9d05a1f810 100644
--- a/tests/ut/worker/test_model_runner_event_sync.py
+++ b/tests/ut/worker/test_model_runner_event_sync.py
@@ -1,11 +1,11 @@
-import torch
-import torch_npu
 from unittest.mock import MagicMock, patch
 
 import pytest
+import torch
+import torch_npu
+from vllm import VllmConfig
 
 from tests.ut.base import PytestBase
-from vllm import VllmConfig
 from vllm_ascend.worker.model_runner_v1 import NPUModelRunner
 
 

From 1695f5fd86c576e0a8029cc13339358f382b58a4 Mon Sep 17 00:00:00 2001
From: jesse <szxfml@gmail.com>
Date: Sat, 6 Sep 2025 18:37:21 +0800
Subject: [PATCH 06/14] fix test

Signed-off-by: jesse <szxfml@gmail.com>
---
 tests/ut/worker/test_model_runner_event_sync.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/ut/worker/test_model_runner_event_sync.py b/tests/ut/worker/test_model_runner_event_sync.py
index 9d05a1f810..1efb76d6a5 100644
--- a/tests/ut/worker/test_model_runner_event_sync.py
+++ b/tests/ut/worker/test_model_runner_event_sync.py
@@ -107,6 +107,6 @@ def test_to_list_uses_pinned_memory_buffer(self, model_runner):
         # Verify copy was called with non_blocking=True
         model_runner.sampled_token_ids_pinned_cpu.copy_.assert_called_once()
         _, kwargs = model_runner.sampled_token_ids_pinned_cpu.copy_.call_args
-        assert kwargs.get('non_blocking') == True
+        assert kwargs.get('non_blocking')
 
         assert result == [[5], [10]]

From c483b2041397b4a09159e1c057588f0fee56dc34 Mon Sep 17 00:00:00 2001
From: jesse <szxfml@gmail.com>
Date: Sat, 6 Sep 2025 19:03:52 +0800
Subject: [PATCH 07/14] fix test

Signed-off-by: jesse <szxfml@gmail.com>
---
 tests/ut/worker/test_model_runner_event_sync.py | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/tests/ut/worker/test_model_runner_event_sync.py b/tests/ut/worker/test_model_runner_event_sync.py
index 1efb76d6a5..ba3490c7b4 100644
--- a/tests/ut/worker/test_model_runner_event_sync.py
+++ b/tests/ut/worker/test_model_runner_event_sync.py
@@ -3,7 +3,6 @@
 import pytest
 import torch
 import torch_npu
-from vllm import VllmConfig
 
 from tests.ut.base import PytestBase
 from vllm_ascend.worker.model_runner_v1 import NPUModelRunner
@@ -15,7 +14,7 @@ class TestNPUModelRunnerEventSync(PytestBase):
     @pytest.fixture
     def mock_vllm_config(self):
         """Create minimal mock VllmConfig for testing"""
-        config = MagicMock(spec=VllmConfig)
+        config = MagicMock()
         config.model_config = MagicMock()
         config.model_config.max_model_len = 1024  # Test the new max_model_len attribute
         config.cache_config = MagicMock()

From ed0b72f82e2de8145f26abda8b749ab6234545e0 Mon Sep 17 00:00:00 2001
From: jesse <szxfml@gmail.com>
Date: Sun, 7 Sep 2025 10:37:51 +0800
Subject: [PATCH 08/14] fix test

Signed-off-by: jesse <szxfml@gmail.com>
---
 .../ut/worker/test_model_runner_event_sync.py | 111 -----------
 tests/ut/worker/test_model_runner_v1.py       | 180 ++++++++++++++++++
 2 files changed, 180 insertions(+), 111 deletions(-)
 delete mode 100644 tests/ut/worker/test_model_runner_event_sync.py

diff --git a/tests/ut/worker/test_model_runner_event_sync.py b/tests/ut/worker/test_model_runner_event_sync.py
deleted file mode 100644
index ba3490c7b4..0000000000
--- a/tests/ut/worker/test_model_runner_event_sync.py
+++ /dev/null
@@ -1,111 +0,0 @@
-from unittest.mock import MagicMock, patch
-
-import pytest
-import torch
-import torch_npu
-
-from tests.ut.base import PytestBase
-from vllm_ascend.worker.model_runner_v1 import NPUModelRunner
-
-
-class TestNPUModelRunnerEventSync(PytestBase):
-    """Test event synchronization optimization added in commit b6c5ef9"""
-
-    @pytest.fixture
-    def mock_vllm_config(self):
-        """Create minimal mock VllmConfig for testing"""
-        config = MagicMock()
-        config.model_config = MagicMock()
-        config.model_config.max_model_len = 1024  # Test the new max_model_len attribute
-        config.cache_config = MagicMock()
-        config.cache_config.block_size = 16
-        config.scheduler_config = MagicMock()
-        config.scheduler_config.max_num_batched_tokens = 1024
-        config.scheduler_config.max_num_seqs = 64
-        config.parallel_config = MagicMock()
-        config.parallel_config.data_parallel_size = 1
-        config.lora_config = None
-        config.speculative_config = None
-        return config
-
-    @pytest.fixture
-    def model_runner(self, mock_vllm_config):
-        """Create NPUModelRunner with minimal mocking"""
-        device = torch.device("npu:0")
-        with patch('vllm_ascend.worker.model_runner_v1.get_ascend_config'), \
-             patch('vllm_ascend.worker.model_runner_v1.envs_ascend'), \
-             patch('vllm_ascend.worker.model_runner_v1.get_dp_group'), \
-             patch('vllm_ascend.worker.model_runner_v1.get_pp_group'), \
-             patch('vllm_ascend.worker.model_runner_v1.get_tp_group'), \
-             patch('vllm_ascend.worker.model_runner_v1.InputBatch'), \
-             patch('vllm_ascend.worker.model_runner_v1.AscendAttentionMetadataBuilder'), \
-             patch('vllm_ascend.worker.model_runner_v1.AscendSampler'), \
-             patch('vllm_ascend.worker.model_runner_v1.ACLGraphDispatcher'):
-            runner = NPUModelRunner(mock_vllm_config, device)
-            return runner
-
-    def test_max_model_len_attribute_added(self, model_runner):
-        """Test that max_model_len attribute is properly set from config"""
-        # This tests the line: self.max_model_len = self.model_config.max_model_len
-        assert hasattr(model_runner, 'max_model_len')
-        assert model_runner.max_model_len == 1024
-
-    def test_event_sync_attributes_initialized(self, model_runner):
-        """Test that event sync attributes are properly initialized"""
-        # Test transfer_event is created
-        assert hasattr(model_runner, 'transfer_event')
-        assert isinstance(model_runner.transfer_event, torch_npu.npu.Event)
-
-        # Test sampled_token_ids_pinned_cpu is created with correct properties
-        assert hasattr(model_runner, 'sampled_token_ids_pinned_cpu')
-        pinned_tensor = model_runner.sampled_token_ids_pinned_cpu
-        assert isinstance(pinned_tensor, torch.Tensor)
-        assert pinned_tensor.device.type == 'cpu'
-        assert pinned_tensor.is_pinned()
-        assert pinned_tensor.shape == (1024, 1)  # (max_model_len, 1)
-        assert pinned_tensor.dtype == torch.int64
-
-    def test_to_list_method_functionality(self, model_runner):
-        """Test the new _to_list method implementation"""
-        # Create test input tensor
-        sampled_token_ids = torch.tensor([[1], [2], [3]],
-                                         dtype=torch.int64,
-                                         device="npu:0")
-
-        # Mock event methods to verify they're called
-        model_runner.transfer_event.record = MagicMock()
-        model_runner.transfer_event.synchronize = MagicMock()
-
-        # Test the method
-        result = model_runner._to_list(sampled_token_ids)
-
-        # Verify correct result
-        assert result == [[1], [2], [3]]
-
-        # Verify event synchronization pattern
-        model_runner.transfer_event.record.assert_called_once()
-        model_runner.transfer_event.synchronize.assert_called_once()
-
-    def test_to_list_uses_pinned_memory_buffer(self, model_runner):
-        """Test that _to_list uses the pinned memory buffer correctly"""
-        sampled_token_ids = torch.tensor([[5], [10]],
-                                         dtype=torch.int64,
-                                         device="npu:0")
-
-        # Mock events
-        model_runner.transfer_event.record = MagicMock()
-        model_runner.transfer_event.synchronize = MagicMock()
-
-        # Mock copy to verify non_blocking=True is used
-        original_copy = model_runner.sampled_token_ids_pinned_cpu.copy_
-        model_runner.sampled_token_ids_pinned_cpu.copy_ = MagicMock(
-            side_effect=original_copy)
-
-        result = model_runner._to_list(sampled_token_ids)
-
-        # Verify copy was called with non_blocking=True
-        model_runner.sampled_token_ids_pinned_cpu.copy_.assert_called_once()
-        _, kwargs = model_runner.sampled_token_ids_pinned_cpu.copy_.call_args
-        assert kwargs.get('non_blocking')
-
-        assert result == [[5], [10]]
diff --git a/tests/ut/worker/test_model_runner_v1.py b/tests/ut/worker/test_model_runner_v1.py
index eb83d30070..48dfcca5bc 100644
--- a/tests/ut/worker/test_model_runner_v1.py
+++ b/tests/ut/worker/test_model_runner_v1.py
@@ -14,6 +14,7 @@
 from unittest.mock import MagicMock, patch
 
 import pytest
+import torch
 
 from vllm_ascend.utils import AscendSocVersion
 from vllm_ascend.worker.model_runner_v1 import NPUModelRunner
@@ -92,3 +93,182 @@ def test_select_moe_comm_method_unsupported_soc():
          pytest.raises(ValueError, match=f"Unsupported soc_version: {unsupported_soc}"):
 
         NPUModelRunner._select_moe_comm_method(mock_runner, 100)
+
+
+class TestNPUModelRunnerInit:
+    """Tests for NPUModelRunner initialization including new event sync feature."""
+
+    def test_patch_torch_npu_structure(self):
+        """Test to verify torch_npu mock structure works correctly."""
+        with patch('vllm_ascend.worker.model_runner_v1.torch_npu'
+                   ) as mock_torch_npu:
+            # 设置 mock 的嵌套结构
+            mock_event = MagicMock()
+            mock_torch_npu.npu.Event.return_value = mock_event
+
+            # 验证 mock 结构
+            assert mock_torch_npu.npu.Event() == mock_event
+            mock_torch_npu.npu.Event.assert_called_once()
+
+    @patch('vllm_ascend.worker.model_runner_v1.torch_npu')
+    @patch('vllm_ascend.worker.model_runner_v1.torch')
+    def test_init_creates_transfer_event_and_pinned_memory(
+            self, mock_torch, mock_torch_npu):
+        """Test that initialization creates transfer event and pinned CPU memory."""
+        # Mock torch.empty to return a mock tensor
+        mock_pinned_tensor = MagicMock()
+        mock_torch.empty.return_value = mock_pinned_tensor
+
+        # Mock torch_npu.npu.Event - 需要设置嵌套的 mock 结构
+        mock_event = MagicMock()
+        mock_torch_npu.npu.Event.return_value = mock_event
+
+        # Create mock vllm_config with necessary attributes
+        mock_vllm_config = MagicMock()
+        mock_vllm_config.model_config.max_model_len = 2048
+        mock_vllm_config.cache_config.block_size = 16
+        mock_vllm_config.scheduler_config.max_num_batched_tokens = 1024
+        mock_vllm_config.scheduler_config.max_num_seqs = 32
+        mock_vllm_config.parallel_config.data_parallel_size = 1
+        mock_vllm_config.parallel_config.pipeline_parallel_size = 1
+        mock_vllm_config.parallel_config.tensor_parallel_size = 1
+        mock_vllm_config.parallel_config.world_size = 1
+        mock_vllm_config.parallel_config.enable_expert_parallel = False
+        mock_vllm_config.speculative_config = None
+        mock_vllm_config.observability_config = None
+        mock_vllm_config.lora_config = None
+        mock_vllm_config.prompt_adapter_config = None
+        mock_vllm_config.decoding_config = None
+
+        # Mock other required attributes
+        mock_vllm_config.cache_config.enable_prefix_caching = False
+        mock_vllm_config.model_config.dtype = torch.float16
+
+        with patch.multiple(
+            'vllm_ascend.worker.model_runner_v1',
+            get_ascend_soc_version=MagicMock(return_value=AscendSocVersion.A2),
+            is_global_first_rank=MagicMock(return_value=True),
+            _check_env_vars_for_multiprocess=MagicMock(),
+            STR_DTYPE_TO_TORCH_DTYPE={'float16': torch.float16},
+        ), \
+        patch('vllm_ascend.worker.model_runner_v1.VocabParallelEmbedding'), \
+        patch('vllm_ascend.worker.model_runner_v1.ParallelLMHead'), \
+        patch('vllm_ascend.worker.model_runner_v1.get_model'), \
+        patch('vllm_ascend.worker.model_runner_v1.CudagraphDispatcher'):
+
+            # Create NPUModelRunner instance
+            runner = NPUModelRunner(vllm_config=mock_vllm_config)
+
+            # Verify max_model_len is set
+            assert runner.max_model_len == 2048
+
+            # Verify transfer_event is created
+            assert runner.transfer_event == mock_event
+            mock_torch_npu.npu.Event.assert_called_once()
+
+            # Verify pinned CPU memory is created with correct parameters
+            assert runner.sampled_token_ids_pinned_cpu == mock_pinned_tensor
+            mock_torch.empty.assert_called_with((2048, 1),
+                                                dtype=torch.int64,
+                                                device="cpu",
+                                                pin_memory=True)
+
+
+class TestNPUModelRunnerToList:
+    """Tests for the _to_list method in NPUModelRunner."""
+
+    def test_to_list_converts_tensor_correctly(self):
+        """Test that _to_list correctly converts tensor to list using event sync."""
+        # Create a mock runner with required attributes
+        mock_runner = MagicMock(spec=NPUModelRunner)
+
+        # Mock the pinned CPU tensor
+        mock_pinned_tensor = MagicMock()
+        mock_pinned_tensor.tolist.return_value = [[1], [2], [3]]
+        mock_runner.sampled_token_ids_pinned_cpu = MagicMock()
+        mock_runner.sampled_token_ids_pinned_cpu.__getitem__.return_value = mock_pinned_tensor
+
+        # Mock the transfer event
+        mock_event = MagicMock()
+        mock_runner.transfer_event = mock_event
+
+        # Create a mock input tensor
+        mock_input_tensor = MagicMock()
+        mock_input_tensor.shape = [3, 1]  # 3 tokens, 1 dimension
+
+        # Call the method
+        result = NPUModelRunner._to_list(mock_runner, mock_input_tensor)
+
+        # Verify the result
+        assert result == [[1], [2], [3]]
+
+        # Verify the pinned tensor slice was accessed correctly
+        mock_runner.sampled_token_ids_pinned_cpu.__getitem__.assert_called_once_with(
+            slice(None, 3))
+
+        # Verify copy operation was called
+        mock_pinned_tensor.copy_.assert_called_once_with(mock_input_tensor,
+                                                         non_blocking=True)
+
+        # Verify event operations were called
+        mock_event.record.assert_called_once()
+        mock_event.synchronize.assert_called_once()
+
+        # Verify tolist was called on the pinned tensor
+        mock_pinned_tensor.tolist.assert_called_once()
+
+    def test_to_list_handles_different_tensor_shapes(self):
+        """Test that _to_list handles tensors of different shapes correctly."""
+        # Create a mock runner
+        mock_runner = MagicMock(spec=NPUModelRunner)
+
+        # Mock pinned tensor for different sizes
+        mock_pinned_tensor = MagicMock()
+        mock_pinned_tensor.tolist.return_value = [[10], [20]]
+        mock_runner.sampled_token_ids_pinned_cpu = MagicMock()
+        mock_runner.sampled_token_ids_pinned_cpu.__getitem__.return_value = mock_pinned_tensor
+
+        # Mock the transfer event
+        mock_event = MagicMock()
+        mock_runner.transfer_event = mock_event
+
+        # Test with a smaller tensor (2 tokens)
+        mock_input_tensor = MagicMock()
+        mock_input_tensor.shape = [2, 1]
+
+        result = NPUModelRunner._to_list(mock_runner, mock_input_tensor)
+
+        # Verify the correct slice was used
+        mock_runner.sampled_token_ids_pinned_cpu.__getitem__.assert_called_with(
+            slice(None, 2))
+        assert result == [[10], [20]]
+
+    def test_to_list_event_synchronization_flow(self):
+        """Test that _to_list follows the correct event synchronization flow."""
+        # Create a mock runner
+        mock_runner = MagicMock(spec=NPUModelRunner)
+
+        # Mock pinned tensor
+        mock_pinned_tensor = MagicMock()
+        mock_pinned_tensor.tolist.return_value = [[42]]
+        mock_runner.sampled_token_ids_pinned_cpu = MagicMock()
+        mock_runner.sampled_token_ids_pinned_cpu.__getitem__.return_value = mock_pinned_tensor
+
+        # Mock the transfer event
+        mock_event = MagicMock()
+        mock_runner.transfer_event = mock_event
+
+        # Create a mock input tensor
+        mock_input_tensor = MagicMock()
+        mock_input_tensor.shape = [1, 1]
+
+        # Call the method
+        NPUModelRunner._to_list(mock_runner, mock_input_tensor)
+
+        # Verify the order of operations: copy -> record -> synchronize -> tolist
+        # We can't easily verify exact order without more complex mocking,
+        # but we can verify all operations were called
+        mock_pinned_tensor.copy_.assert_called_once()
+        mock_event.record.assert_called_once()
+        mock_event.synchronize.assert_called_once()
+        mock_pinned_tensor.tolist.assert_called_once()

From 1f9cb35f001cb852e59017488b705a1662433baa Mon Sep 17 00:00:00 2001
From: jesse <szxfml@gmail.com>
Date: Sun, 7 Sep 2025 11:39:45 +0800
Subject: [PATCH 09/14] fix test

Signed-off-by: jesse <szxfml@gmail.com>
---
 tests/ut/worker/test_model_runner_v1.py | 86 ++++++++++---------------
 1 file changed, 33 insertions(+), 53 deletions(-)

diff --git a/tests/ut/worker/test_model_runner_v1.py b/tests/ut/worker/test_model_runner_v1.py
index 48dfcca5bc..6da3b00eff 100644
--- a/tests/ut/worker/test_model_runner_v1.py
+++ b/tests/ut/worker/test_model_runner_v1.py
@@ -112,9 +112,11 @@ def test_patch_torch_npu_structure(self):
 
     @patch('vllm_ascend.worker.model_runner_v1.torch_npu')
     @patch('vllm_ascend.worker.model_runner_v1.torch')
-    def test_init_creates_transfer_event_and_pinned_memory(
-            self, mock_torch, mock_torch_npu):
+    def test_init_creates_transfer_event_and_pinned_memory(self, mock_torch, mock_torch_npu):
         """Test that initialization creates transfer event and pinned CPU memory."""
+        # This is a simplified test focusing only on the new attributes
+        # We mock the entire __init__ process and only test the specific lines we added
+
         # Mock torch.empty to return a mock tensor
         mock_pinned_tensor = MagicMock()
         mock_torch.empty.return_value = mock_pinned_tensor
@@ -123,57 +125,35 @@ def test_init_creates_transfer_event_and_pinned_memory(
         mock_event = MagicMock()
         mock_torch_npu.npu.Event.return_value = mock_event
 
-        # Create mock vllm_config with necessary attributes
-        mock_vllm_config = MagicMock()
-        mock_vllm_config.model_config.max_model_len = 2048
-        mock_vllm_config.cache_config.block_size = 16
-        mock_vllm_config.scheduler_config.max_num_batched_tokens = 1024
-        mock_vllm_config.scheduler_config.max_num_seqs = 32
-        mock_vllm_config.parallel_config.data_parallel_size = 1
-        mock_vllm_config.parallel_config.pipeline_parallel_size = 1
-        mock_vllm_config.parallel_config.tensor_parallel_size = 1
-        mock_vllm_config.parallel_config.world_size = 1
-        mock_vllm_config.parallel_config.enable_expert_parallel = False
-        mock_vllm_config.speculative_config = None
-        mock_vllm_config.observability_config = None
-        mock_vllm_config.lora_config = None
-        mock_vllm_config.prompt_adapter_config = None
-        mock_vllm_config.decoding_config = None
-
-        # Mock other required attributes
-        mock_vllm_config.cache_config.enable_prefix_caching = False
-        mock_vllm_config.model_config.dtype = torch.float16
-
-        with patch.multiple(
-            'vllm_ascend.worker.model_runner_v1',
-            get_ascend_soc_version=MagicMock(return_value=AscendSocVersion.A2),
-            is_global_first_rank=MagicMock(return_value=True),
-            _check_env_vars_for_multiprocess=MagicMock(),
-            STR_DTYPE_TO_TORCH_DTYPE={'float16': torch.float16},
-        ), \
-        patch('vllm_ascend.worker.model_runner_v1.VocabParallelEmbedding'), \
-        patch('vllm_ascend.worker.model_runner_v1.ParallelLMHead'), \
-        patch('vllm_ascend.worker.model_runner_v1.get_model'), \
-        patch('vllm_ascend.worker.model_runner_v1.CudagraphDispatcher'):
-
-            # Create NPUModelRunner instance
-            runner = NPUModelRunner(vllm_config=mock_vllm_config)
-
-            # Verify max_model_len is set
-            assert runner.max_model_len == 2048
-
-            # Verify transfer_event is created
-            assert runner.transfer_event == mock_event
-            mock_torch_npu.npu.Event.assert_called_once()
-
-            # Verify pinned CPU memory is created with correct parameters
-            assert runner.sampled_token_ids_pinned_cpu == mock_pinned_tensor
-            mock_torch.empty.assert_called_with((2048, 1),
-                                                dtype=torch.int64,
-                                                device="cpu",
-                                                pin_memory=True)
-
-
+        # Create a runner instance using __new__ to bypass __init__
+        runner = NPUModelRunner.__new__(NPUModelRunner)
+
+        # Manually set the attributes we need for our test
+        runner.max_model_len = 2048
+
+        # Test the specific lines from the commit
+        runner.transfer_event = mock_torch_npu.npu.Event()
+        runner.sampled_token_ids_pinned_cpu = mock_torch.empty(
+            (runner.max_model_len, 1),
+            dtype=torch.int64,
+            device="cpu",
+            pin_memory=True)
+
+        # Verify max_model_len is set
+        assert runner.max_model_len == 2048
+
+        # Verify transfer_event is created
+        assert runner.transfer_event == mock_event
+        mock_torch_npu.npu.Event.assert_called_once()
+
+        # Verify pinned CPU memory is created with correct parameters
+        assert runner.sampled_token_ids_pinned_cpu == mock_pinned_tensor
+        mock_torch.empty.assert_called_with(
+            (2048, 1),
+            dtype=torch.int64,
+            device="cpu",
+            pin_memory=True
+        )
 class TestNPUModelRunnerToList:
     """Tests for the _to_list method in NPUModelRunner."""
 

From 9c8fb4cc6a6ade6a8f0f0c3ad8dc95d613af0679 Mon Sep 17 00:00:00 2001
From: jesse <szxfml@gmail.com>
Date: Sun, 7 Sep 2025 12:31:27 +0800
Subject: [PATCH 10/14] fix test

Signed-off-by: jesse <szxfml@gmail.com>
---
 tests/ut/worker/test_model_runner_v1.py | 15 ++++++++-------
 1 file changed, 8 insertions(+), 7 deletions(-)

diff --git a/tests/ut/worker/test_model_runner_v1.py b/tests/ut/worker/test_model_runner_v1.py
index 6da3b00eff..116edcb4b2 100644
--- a/tests/ut/worker/test_model_runner_v1.py
+++ b/tests/ut/worker/test_model_runner_v1.py
@@ -112,7 +112,8 @@ def test_patch_torch_npu_structure(self):
 
     @patch('vllm_ascend.worker.model_runner_v1.torch_npu')
     @patch('vllm_ascend.worker.model_runner_v1.torch')
-    def test_init_creates_transfer_event_and_pinned_memory(self, mock_torch, mock_torch_npu):
+    def test_init_creates_transfer_event_and_pinned_memory(
+            self, mock_torch, mock_torch_npu):
         """Test that initialization creates transfer event and pinned CPU memory."""
         # This is a simplified test focusing only on the new attributes
         # We mock the entire __init__ process and only test the specific lines we added
@@ -148,12 +149,12 @@ def test_init_creates_transfer_event_and_pinned_memory(self, mock_torch, mock_to
 
         # Verify pinned CPU memory is created with correct parameters
         assert runner.sampled_token_ids_pinned_cpu == mock_pinned_tensor
-        mock_torch.empty.assert_called_with(
-            (2048, 1),
-            dtype=torch.int64,
-            device="cpu",
-            pin_memory=True
-        )
+        mock_torch.empty.assert_called_with((2048, 1),
+                                            dtype=torch.int64,
+                                            device="cpu",
+                                            pin_memory=True)
+
+
 class TestNPUModelRunnerToList:
     """Tests for the _to_list method in NPUModelRunner."""
 

From 598c8969ddeead920c4c7e280fef0c1fa58d2c1c Mon Sep 17 00:00:00 2001
From: jesse <szxfml@gmail.com>
Date: Mon, 15 Sep 2025 10:00:49 +0800
Subject: [PATCH 11/14] update test

Signed-off-by: jesse <szxfml@gmail.com>
---
 tests/ut/worker/test_model_runner_v1.py | 201 +++++-------------------
 1 file changed, 43 insertions(+), 158 deletions(-)

diff --git a/tests/ut/worker/test_model_runner_v1.py b/tests/ut/worker/test_model_runner_v1.py
index 116edcb4b2..bcacc0f980 100644
--- a/tests/ut/worker/test_model_runner_v1.py
+++ b/tests/ut/worker/test_model_runner_v1.py
@@ -95,161 +95,46 @@ def test_select_moe_comm_method_unsupported_soc():
         NPUModelRunner._select_moe_comm_method(mock_runner, 100)
 
 
-class TestNPUModelRunnerInit:
-    """Tests for NPUModelRunner initialization including new event sync feature."""
-
-    def test_patch_torch_npu_structure(self):
-        """Test to verify torch_npu mock structure works correctly."""
-        with patch('vllm_ascend.worker.model_runner_v1.torch_npu'
-                   ) as mock_torch_npu:
-            # 设置 mock 的嵌套结构
-            mock_event = MagicMock()
-            mock_torch_npu.npu.Event.return_value = mock_event
-
-            # 验证 mock 结构
-            assert mock_torch_npu.npu.Event() == mock_event
-            mock_torch_npu.npu.Event.assert_called_once()
-
-    @patch('vllm_ascend.worker.model_runner_v1.torch_npu')
-    @patch('vllm_ascend.worker.model_runner_v1.torch')
-    def test_init_creates_transfer_event_and_pinned_memory(
-            self, mock_torch, mock_torch_npu):
-        """Test that initialization creates transfer event and pinned CPU memory."""
-        # This is a simplified test focusing only on the new attributes
-        # We mock the entire __init__ process and only test the specific lines we added
-
-        # Mock torch.empty to return a mock tensor
-        mock_pinned_tensor = MagicMock()
-        mock_torch.empty.return_value = mock_pinned_tensor
-
-        # Mock torch_npu.npu.Event - 需要设置嵌套的 mock 结构
-        mock_event = MagicMock()
-        mock_torch_npu.npu.Event.return_value = mock_event
-
-        # Create a runner instance using __new__ to bypass __init__
-        runner = NPUModelRunner.__new__(NPUModelRunner)
-
-        # Manually set the attributes we need for our test
-        runner.max_model_len = 2048
-
-        # Test the specific lines from the commit
-        runner.transfer_event = mock_torch_npu.npu.Event()
-        runner.sampled_token_ids_pinned_cpu = mock_torch.empty(
-            (runner.max_model_len, 1),
-            dtype=torch.int64,
-            device="cpu",
-            pin_memory=True)
-
-        # Verify max_model_len is set
-        assert runner.max_model_len == 2048
-
-        # Verify transfer_event is created
-        assert runner.transfer_event == mock_event
-        mock_torch_npu.npu.Event.assert_called_once()
-
-        # Verify pinned CPU memory is created with correct parameters
-        assert runner.sampled_token_ids_pinned_cpu == mock_pinned_tensor
-        mock_torch.empty.assert_called_with((2048, 1),
-                                            dtype=torch.int64,
-                                            device="cpu",
-                                            pin_memory=True)
-
-
-class TestNPUModelRunnerToList:
-    """Tests for the _to_list method in NPUModelRunner."""
-
-    def test_to_list_converts_tensor_correctly(self):
-        """Test that _to_list correctly converts tensor to list using event sync."""
-        # Create a mock runner with required attributes
-        mock_runner = MagicMock(spec=NPUModelRunner)
-
-        # Mock the pinned CPU tensor
-        mock_pinned_tensor = MagicMock()
-        mock_pinned_tensor.tolist.return_value = [[1], [2], [3]]
-        mock_runner.sampled_token_ids_pinned_cpu = MagicMock()
-        mock_runner.sampled_token_ids_pinned_cpu.__getitem__.return_value = mock_pinned_tensor
-
-        # Mock the transfer event
-        mock_event = MagicMock()
-        mock_runner.transfer_event = mock_event
-
-        # Create a mock input tensor
-        mock_input_tensor = MagicMock()
-        mock_input_tensor.shape = [3, 1]  # 3 tokens, 1 dimension
-
-        # Call the method
-        result = NPUModelRunner._to_list(mock_runner, mock_input_tensor)
-
-        # Verify the result
-        assert result == [[1], [2], [3]]
-
-        # Verify the pinned tensor slice was accessed correctly
-        mock_runner.sampled_token_ids_pinned_cpu.__getitem__.assert_called_once_with(
-            slice(None, 3))
-
-        # Verify copy operation was called
-        mock_pinned_tensor.copy_.assert_called_once_with(mock_input_tensor,
-                                                         non_blocking=True)
-
-        # Verify event operations were called
-        mock_event.record.assert_called_once()
-        mock_event.synchronize.assert_called_once()
-
-        # Verify tolist was called on the pinned tensor
-        mock_pinned_tensor.tolist.assert_called_once()
-
-    def test_to_list_handles_different_tensor_shapes(self):
-        """Test that _to_list handles tensors of different shapes correctly."""
-        # Create a mock runner
-        mock_runner = MagicMock(spec=NPUModelRunner)
-
-        # Mock pinned tensor for different sizes
-        mock_pinned_tensor = MagicMock()
-        mock_pinned_tensor.tolist.return_value = [[10], [20]]
-        mock_runner.sampled_token_ids_pinned_cpu = MagicMock()
-        mock_runner.sampled_token_ids_pinned_cpu.__getitem__.return_value = mock_pinned_tensor
-
-        # Mock the transfer event
-        mock_event = MagicMock()
-        mock_runner.transfer_event = mock_event
-
-        # Test with a smaller tensor (2 tokens)
-        mock_input_tensor = MagicMock()
-        mock_input_tensor.shape = [2, 1]
-
-        result = NPUModelRunner._to_list(mock_runner, mock_input_tensor)
-
-        # Verify the correct slice was used
-        mock_runner.sampled_token_ids_pinned_cpu.__getitem__.assert_called_with(
-            slice(None, 2))
-        assert result == [[10], [20]]
-
-    def test_to_list_event_synchronization_flow(self):
-        """Test that _to_list follows the correct event synchronization flow."""
-        # Create a mock runner
-        mock_runner = MagicMock(spec=NPUModelRunner)
-
-        # Mock pinned tensor
-        mock_pinned_tensor = MagicMock()
-        mock_pinned_tensor.tolist.return_value = [[42]]
-        mock_runner.sampled_token_ids_pinned_cpu = MagicMock()
-        mock_runner.sampled_token_ids_pinned_cpu.__getitem__.return_value = mock_pinned_tensor
-
-        # Mock the transfer event
-        mock_event = MagicMock()
-        mock_runner.transfer_event = mock_event
-
-        # Create a mock input tensor
-        mock_input_tensor = MagicMock()
-        mock_input_tensor.shape = [1, 1]
-
-        # Call the method
-        NPUModelRunner._to_list(mock_runner, mock_input_tensor)
-
-        # Verify the order of operations: copy -> record -> synchronize -> tolist
-        # We can't easily verify exact order without more complex mocking,
-        # but we can verify all operations were called
-        mock_pinned_tensor.copy_.assert_called_once()
-        mock_event.record.assert_called_once()
-        mock_event.synchronize.assert_called_once()
-        mock_pinned_tensor.tolist.assert_called_once()
+@patch('vllm_ascend.worker.model_runner_v1.torch_npu')
+@patch('vllm_ascend.worker.model_runner_v1.torch')
+def test_init_creates_transfer_event_and_pinned_memory(self, mock_torch,
+                                                       mock_torch_npu):
+    """Test that initialization creates transfer event and pinned CPU memory."""
+    # This is a simplified test focusing only on the new attributes
+    # We mock the entire __init__ process and only test the specific lines we added
+
+    # Mock torch.empty to return a mock tensor
+    mock_pinned_tensor = MagicMock()
+    mock_torch.empty.return_value = mock_pinned_tensor
+
+    # Mock torch_npu.npu.Event - 需要设置嵌套的 mock 结构
+    mock_event = MagicMock()
+    mock_torch_npu.npu.Event.return_value = mock_event
+
+    # Create a runner instance using __new__ to bypass __init__
+    runner = NPUModelRunner.__new__(NPUModelRunner)
+
+    # Manually set the attributes we need for our test
+    runner.max_model_len = 2048
+
+    # Test the specific lines from the commit
+    runner.transfer_event = mock_torch_npu.npu.Event()
+    runner.sampled_token_ids_pinned_cpu = mock_torch.empty(
+        (runner.max_model_len, 1),
+        dtype=torch.int64,
+        device="cpu",
+        pin_memory=True)
+
+    # Verify max_model_len is set
+    assert runner.max_model_len == 2048
+
+    # Verify transfer_event is created
+    assert runner.transfer_event == mock_event
+    mock_torch_npu.npu.Event.assert_called_once()
+
+    # Verify pinned CPU memory is created with correct parameters
+    assert runner.sampled_token_ids_pinned_cpu == mock_pinned_tensor
+    mock_torch.empty.assert_called_with((2048, 1),
+                                        dtype=torch.int64,
+                                        device="cpu",
+                                        pin_memory=True)

From 674be7540feafcbc87da951f53885a929a4aeb3c Mon Sep 17 00:00:00 2001
From: jesse <szxfml@gmail.com>
Date: Mon, 15 Sep 2025 10:01:14 +0800
Subject: [PATCH 12/14] update test

Signed-off-by: jesse <szxfml@gmail.com>
---
 tests/ut/worker/test_model_runner_v1.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/ut/worker/test_model_runner_v1.py b/tests/ut/worker/test_model_runner_v1.py
index bcacc0f980..6bc68bda83 100644
--- a/tests/ut/worker/test_model_runner_v1.py
+++ b/tests/ut/worker/test_model_runner_v1.py
@@ -97,7 +97,7 @@ def test_select_moe_comm_method_unsupported_soc():
 
 @patch('vllm_ascend.worker.model_runner_v1.torch_npu')
 @patch('vllm_ascend.worker.model_runner_v1.torch')
-def test_init_creates_transfer_event_and_pinned_memory(self, mock_torch,
+def test_init_creates_transfer_event_and_pinned_memory(mock_torch,
                                                        mock_torch_npu):
     """Test that initialization creates transfer event and pinned CPU memory."""
     # This is a simplified test focusing only on the new attributes

From d81f665039352d129eb432201c65a08a9be1c168 Mon Sep 17 00:00:00 2001
From: jesse <szxfml@gmail.com>
Date: Tue, 16 Sep 2025 13:49:50 +0800
Subject: [PATCH 13/14] update test

Signed-off-by: jesse <szxfml@gmail.com>
---
 tests/ut/worker/test_model_runner_v1.py | 1 -
 1 file changed, 1 deletion(-)

diff --git a/tests/ut/worker/test_model_runner_v1.py b/tests/ut/worker/test_model_runner_v1.py
index ef3622878b..8278308b78 100644
--- a/tests/ut/worker/test_model_runner_v1.py
+++ b/tests/ut/worker/test_model_runner_v1.py
@@ -104,7 +104,6 @@ def test_select_moe_comm_method_unsupported_soc():
                return_value=True), \
          pytest.raises(ValueError, match=f"Unsupported soc_version: {unsupported_soc}"):
 
-
         NPUModelRunner._select_moe_comm_method(mock_runner, 100, False)
 
 

From dd4c177cfffe7431674bee34f8f6daa800739f6f Mon Sep 17 00:00:00 2001
From: jesse <szxfml@gmail.com>
Date: Mon, 22 Sep 2025 16:07:32 +0800
Subject: [PATCH 14/14] update comment

Signed-off-by: jesse <szxfml@gmail.com>
---
 vllm_ascend/worker/model_runner_v1.py | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/vllm_ascend/worker/model_runner_v1.py b/vllm_ascend/worker/model_runner_v1.py
index 94dead2d97..be2401b572 100644
--- a/vllm_ascend/worker/model_runner_v1.py
+++ b/vllm_ascend/worker/model_runner_v1.py
@@ -3065,9 +3065,9 @@ def _build_drafter_prepare_inputs_torchair_param(self):
     def _to_list(self, sampled_token_ids: torch.Tensor) -> list[list[int]]:
         # This is a short term mitigation for issue mentioned in
         # https://github.com/vllm-project/vllm/issues/22754.
-        # `tolist` would trigger a cuda wise stream sync, which
-        # would block other copy ops from other cuda streams.
-        # A cuda event sync would avoid such a situation. Since
+        # `tolist` would trigger a npu wise stream sync, which
+        # would block other copy ops from other npu streams.
+        # A npu event sync would avoid such a situation. Since
         # this is in the critical path of every single model
         # forward loop, this has caused perf issue for a disagg
         # setup.