diff --git a/python/sglang/srt/mem_cache/deepseek_v4_memory_pool.py b/python/sglang/srt/mem_cache/deepseek_v4_memory_pool.py index eefa122fc0..c26c7a1eb1 100644 --- a/python/sglang/srt/mem_cache/deepseek_v4_memory_pool.py +++ b/python/sglang/srt/mem_cache/deepseek_v4_memory_pool.py @@ -1080,6 +1080,7 @@ class DeepSeekV4TokenToKVPool(BaseSWAKVPool): kv_pool_cls: type = DeepSeekV4SingleKVPool self.request_window = None + self.full_to_swa_index_mapping = None encoder_replay = get_exec().features.enable_encoder_swa_bounded_replay # DSpark's draft shares the target's full-to-SWA mapping, so the target # keeps its paged SWA allocator even under encoder replay. diff --git a/test/registered/unit/mem_cache/test_dsv4_compressed_pools.py b/test/registered/unit/mem_cache/test_dsv4_compressed_pools.py index 9966a34c61..eee6b0cb4b 100644 --- a/test/registered/unit/mem_cache/test_dsv4_compressed_pools.py +++ b/test/registered/unit/mem_cache/test_dsv4_compressed_pools.py @@ -9,6 +9,10 @@ from sglang.kernels.ops.attention.dsv4.kv_layout import ( KVLayout, is_valid_kv_layout_pair, ) +from sglang.srt.layers.attention.deepseek_v4_backend import DeepseekV4AttnBackend +from sglang.srt.layers.attention.dsv4.sparse_prefill_utils import ( + SparsePrefillChunkCache, +) from sglang.srt.mem_cache.allocator.swa import SWATokenToKVPoolAllocator from sglang.srt.mem_cache.deepseek_v4_memory_pool import ( DeepSeekV4SingleKVPool, @@ -16,6 +20,8 @@ from sglang.srt.mem_cache.deepseek_v4_memory_pool import ( _CompressedPoolConfig, _num_dsv4_physical_kv_pages, ) +from sglang.srt.mem_cache.dsv41_request_window import window_layout +from sglang.srt.model_executor.forward_batch_info import ForwardMode from sglang.srt.runtime_context import get_context from sglang.test.ci.ci_register import register_cpu_ci from sglang.test.test_utils import CustomTestCase @@ -433,5 +439,92 @@ class TestPagedDSparkWithEncoderReplay(CustomTestCase): ) +class TestEncoderReplayWithoutSpeculation(CustomTestCase): + """Encoder replay without speculation has no paged SWA allocator, yet the + sparse-prefill path still reads the pool's full-to-SWA mapping.""" + + def setUp(self): + super().setUp() + override = get_context().override_server_args( + enable_encoder_swa_bounded_replay=True, + page_size=256, + max_running_requests=2, + chunked_prefill_size=256, + ) + override.install() + self.addCleanup(override.restore) + + def test_sparse_prefill_chunk_cache_builds_without_mapping(self): + pool = DeepSeekV4TokenToKVPool( + max_num_reqs=2, + num_req_slots=3, + swa_size=0, + c4_size=0, + c128_size=0, + c4_state_pool_size=0, + c128_state_pool_size=0, + page_size=256, + swa_page_size=256, + dtype=torch.float8_e4m3fn, + c4_state_dtype=torch.float32, + c128_state_dtype=torch.bfloat16, + qk_nope_head_dim=448, + qk_rope_head_dim=64, + indexer_head_dim=128, + layer_num=3, + device="cpu", + enable_memory_saver=False, + compression_ratios=[0, 0, 0], + full_size=2048, + ) + self.assertIsNotNone(pool.request_window) + self.assertFalse(pool.needs_paged_swa_allocator) + self.assertIsNone(pool.full_to_swa_index_mapping) + + # A 300-token cold prefill of request slot 1 on the sparse-prefill path. + rows = 300 + layout = window_layout( + torch.ones(rows, dtype=torch.int64), + torch.arange(rows), + capacity=pool.request_window.capacity, + num_groups=1, + ) + backend = object.__new__(DeepseekV4AttnBackend) + backend.token_to_kv_pool = pool + backend.req_to_token = torch.zeros((3, 2048), dtype=torch.int32) + backend.forward_metadata = SimpleNamespace(late_layer_tail=None) + forward_batch = SimpleNamespace( + forward_mode=ForwardMode.EXTEND, + seq_lens=torch.tensor([rows]), + seq_lens_cpu=torch.tensor([rows]), + extend_seq_lens=torch.tensor([rows], dtype=torch.int32), + extend_seq_lens_cpu=[rows], + req_pool_indices=torch.tensor([1]), + ) + core = SimpleNamespace( + request_window_layout=layout, seq_lens_casual=torch.arange(1, rows + 1) + ) + build = SparsePrefillChunkCache.build + empty = torch.empty(0, dtype=torch.int32) + with ( + patch.object(SparsePrefillChunkCache, "build", wraps=build) as spy, + # The combine is a Triton kernel; the request-window inputs are the contract. + patch( + "sglang.srt.layers.attention.dsv4.sparse_prefill_utils." + "combine_topk_swa_indices", + return_value=(empty, empty), + ) as combine, + ): + cache = backend._build_sparse_prefill_chunk_cache( + forward_batch, core, num_qo_tokens=rows + ) + + self.assertIsNone(spy.call_args.kwargs["full_to_swa"]) + self.assertIs(cache.swa_indices, layout.indices) + self.assertIs(cache.swa_lengths, layout.lengths) + self.assertIs(combine.call_args.kwargs["swa_indices"], layout.indices) + torch.testing.assert_close(cache.query_pos, layout.pos.to(torch.int32)) + + if __name__ == "__main__": unittest.main()