Count evictable device cache when gating HiCache load-back

HiCache host hits can be skipped before load-back when the quota gate only counts immediately free KV allocator space. Under CP shared-KV pressure most reusable capacity may be represented as evictable radix-cache leaves, so the gate can incorrectly reject a host hit and leave prefill with cached-token zero despite host residency. Count device evictable cache in the quota estimate while leaving actual owner-lane allocation and eviction checks in the load path.

Constraint: CP HiCache load-back still has to respect owner-lane allocation and allocator eviction semantics.

Rejected: Force load-back regardless of quota | would bypass the scheduler pressure signal and increase OOM risk.

Rejected: Treat cache-hit zero as a transfer issue | logs showed host hits were found but skipped by quota before transfer.

Confidence: medium

Scope-risk: moderate

Directive: Do not remove evictable cache from load-back capacity accounting without checking CP HiCache host-hit behavior under device pressure.

Tested: git diff --check

Tested: remote g0034 container pytest -q test/registered/unit/managers/test_prefill_adder.py test/registered/unit/managers/test_hicache_controller_cp.py test/registered/unit/mem_cache/test_cp_hicache_metadata.py test/registered/unit/mem_cache/test_alloc_pages_with_owners.py (90 passed, 3 warnings)

Not-tested: Full ETE GLM5 CP+HiCache+EAGLE pressure run after this quota change

Co-authored-by: OmX <omx@oh-my-codex.dev>

test/registered/unit/managers/test_prefill_adder.py

@@ -1,11 +1,66 @@
 import sys
+import types
 import unittest
 from types import SimpleNamespace
 from unittest.mock import MagicMock
 
-for _mod in ("sgl_kernel", "sgl_kernel.kvcacheio"):
-    if _mod not in sys.modules:
-        sys.modules[_mod] = MagicMock()
+import torch
+
+if "sgl_kernel" not in sys.modules:
+    sys.modules["sgl_kernel"] = types.ModuleType("sgl_kernel")
+sys.modules["sgl_kernel"].__file__ = "sgl_kernel_stub.py"
+sys.modules["sgl_kernel"].__path__ = []
+if not hasattr(sys.modules["sgl_kernel"], "__getattr__"):
+
+    def _sgl_kernel_getattr(name):
+        if name.startswith("__"):
+            raise AttributeError(name)
+        fn = lambda *args, **kwargs: None
+        setattr(sys.modules["sgl_kernel"], name, fn)
+        return fn
+
+    sys.modules["sgl_kernel"].__getattr__ = _sgl_kernel_getattr
+
+if "sgl_kernel.kvcacheio" not in sys.modules:
+    sys.modules["sgl_kernel.kvcacheio"] = types.ModuleType("sgl_kernel.kvcacheio")
+
+for _name in (
+    "sgl_per_token_group_quant_8bit",
+    "sgl_per_token_group_quant_fp8",
+    "sgl_per_token_quant_fp8",
+    "fp8_blockwise_scaled_mm",
+    "fp8_scaled_mm",
+    "silu_and_mul",
+):
+    if not hasattr(sys.modules["sgl_kernel"], _name):
+        setattr(sys.modules["sgl_kernel"], _name, lambda *args, **kwargs: None)
+
+if "sgl_kernel.quantization" not in sys.modules:
+    quantization_stub = types.ModuleType("sgl_kernel.quantization")
+    for _name in (
+        "ggml_dequantize",
+        "ggml_moe_a8",
+        "ggml_moe_a8_vec",
+        "ggml_moe_get_block_size",
+        "ggml_mul_mat_a8",
+        "ggml_mul_mat_vec_a8",
+    ):
+        setattr(quantization_stub, _name, lambda *args, **kwargs: None)
+    sys.modules["sgl_kernel.quantization"] = quantization_stub
+
+_sgl_kernel_lib = torch.library.Library("sgl_kernel", "FRAGMENT")
+for _schema in (
+    "sgl_per_token_group_quant_8bit(Tensor input, Tensor(a!) output_q, Tensor(b!) output_s, int group_size, float eps, float fp8_min, float fp8_max, bool scale_ue8m0) -> ()",
+    "sgl_per_token_group_quant_fp8(Tensor input, Tensor(a!) output_q, Tensor(b!) output_s, int group_size, float eps, float fp8_min, float fp8_max, bool scale_ue8m0) -> ()",
+    "sgl_per_token_quant_fp8(Tensor input, Tensor(a!) output_q, Tensor(b!) output_s) -> ()",
+    "fp8_scaled_mm(Tensor mat_a, Tensor mat_b, Tensor scales_a, Tensor scales_b, ScalarType out_dtype, Tensor? bias=None) -> Tensor",
+    "fp8_blockwise_scaled_mm(Tensor mat_a, Tensor mat_b, Tensor scales_a, Tensor scales_b, ScalarType out_dtype) -> Tensor",
+):
+    try:
+        _sgl_kernel_lib.define(_schema)
+    except RuntimeError as exc:
+        if "already" not in str(exc).lower() and "duplicate" not in str(exc).lower():
+            raise
 
 from sglang.srt.managers.schedule_batch import Req
 from sglang.srt.managers.schedule_policy import AddReqResult, PrefillAdder
@@ -38,6 +93,7 @@ class TestPrefillAdder(CustomTestCase):
         tree_cache.full_evictable_size.return_value = full_evictable_size
         tree_cache.swa_evictable_size.return_value = swa_evictable_size
         tree_cache.evictable_size.return_value = evictable_size
+        tree_cache.supports_mamba.return_value = False
         tree_cache.disable = False
         tree_cache.inc_lock_ref.return_value = IncLockRefResult()
         tree_cache.dec_lock_ref.return_value = DecLockRefResult()
@@ -480,6 +536,20 @@ class TestPrefillAdder(CustomTestCase):
         params = self.mock_tree_cache.init_load_back.call_args.args[0]
         self.assertEqual(params.mem_quota, 320)
 
+    def test_load_back_mem_quota_counts_evictable_device_tokens(self):
+        self.mock_tree_cache = self.create_tree_cache(evictable_size=90000)
+        self.mock_token_allocator = self.create_token_allocator(available_size=1024)
+        adder = self.create_adder(
+            self.create_running_batch(),
+            page_size=64,
+            tree_cache=self.mock_tree_cache,
+            token_to_kv_pool_allocator=self.mock_token_allocator,
+        )
+
+        quota = adder._get_load_back_mem_quota(real_input_tokens=65536)
+
+        self.assertEqual(quota, 90000 + 1024 - 65536 - 64)
+
 
 if __name__ == "__main__":
     unittest.main()