fix: preserve CP host siblings during stale cleanup

python/sglang/srt/mem_cache/hiradix_cache.py

@@ -1104,7 +1104,11 @@ class HiRadixCache(RadixCache):
             if not self._node_backuped(x):
                 if len(x.children) == 0:
                     parent = self._remove_host_leaf(x)
-                    if parent.evicted and self._node_backuped(parent):
+                    if (
+                        len(parent.children) == 0
+                        and parent.evicted
+                        and self._node_backuped(parent)
+                    ):
                         new_priority = self.eviction_strategy.get_priority(parent)
                         heapq.heappush(eviction_heap, (new_priority, parent))
                 continue

test/registered/unit/mem_cache/test_cp_hicache_metadata.py

@@ -431,6 +431,72 @@ class TestHiRadixCacheCPSplitEvict(CustomTestCase):
         self.assertIsNone(parent.cp_hicache)
         self.assertNotIn(1, cache.root_node.children)
 
+    def test_cp_host_eviction_preserves_parent_with_sibling_after_stale_cleanup(
+        self,
+    ):
+        cache = HiRadixCache.__new__(HiRadixCache)
+        cache._uses_cp_hicache = True
+        cache.root_node = TreeNode()
+        cache.root_node.key = RadixKey([])
+        cache.evictable_host_leaves = set()
+        cache.get_child_key_fn = lambda key: key.token_ids[0]
+        cache.eviction_strategy = type(
+            "Strategy", (), {"get_priority": lambda self, node: 0}
+        )()
+        cache._clear_pin = lambda node: None
+        cache._record_remove_event = lambda node: None
+        freed = []
+        cache.cache_controller = type(
+            "Controller",
+            (),
+            {
+                "evict_host": lambda self, indices: freed.append(indices.clone())
+                or len(indices)
+            },
+        )()
+
+        parent = TreeNode()
+        parent.parent = cache.root_node
+        parent.key = RadixKey([1])
+        parent.value = None
+        parent.host_len = 4
+        parent.cp_hicache = CpHiCacheNodeMetadata(
+            logical_len=4,
+            owned_positions=torch.tensor([2], dtype=torch.int64),
+            host_indices=torch.tensor([80], dtype=torch.int64),
+        )
+        cache.root_node.children[1] = parent
+
+        stale_child = TreeNode()
+        stale_child.parent = parent
+        stale_child.key = RadixKey([2])
+        stale_child.value = None
+        stale_child.host_len = 0
+        stale_child.cp_hicache = None
+        parent.children[2] = stale_child
+
+        sibling = TreeNode()
+        sibling.parent = parent
+        sibling.key = RadixKey([3])
+        sibling.value = None
+        sibling.host_len = 0
+        sibling.cp_hicache = None
+        parent.children[3] = sibling
+        cache.evictable_host_leaves.add(stale_child)
+
+        physical_freed = cache._evict_host_for_physical_slots(1)
+
+        self.assertEqual(physical_freed, 0)
+        self.assertEqual(freed, [])
+        self.assertNotIn(2, parent.children)
+        self.assertIn(1, cache.root_node.children)
+        self.assertIs(cache.root_node.children[1], parent)
+        self.assertIn(3, parent.children)
+        self.assertIs(parent.children[3], sibling)
+        self.assertEqual(parent.host_len, 4)
+        self.assertIsNotNone(parent.cp_hicache)
+        self.assertEqual(parent.cp_hicache.host_indices.tolist(), [80])
+
 
 if __name__ == "__main__":
     unittest.main()