128 lines
4.7 KiB
Python
128 lines
4.7 KiB
Python
import unittest
|
|
from unittest.mock import MagicMock, patch
|
|
|
|
from sglang.test.ci.ci_register import register_cpu_ci
|
|
from sglang.test.test_utils import maybe_stub_sgl_kernel
|
|
|
|
maybe_stub_sgl_kernel()
|
|
|
|
from sglang.srt.managers.io_struct import FlushCacheReqInput
|
|
from sglang.srt.managers.scheduler import Scheduler
|
|
from sglang.srt.managers.scheduler_components.flush_wrapper import (
|
|
SchedulerFlushWrapper,
|
|
)
|
|
|
|
register_cpu_ci(est_time=12, suite="base-a-test-cpu")
|
|
register_cpu_ci(est_time=8, suite="stage-b-test-cpu-intel")
|
|
|
|
|
|
class TestSchedulerFlushCache(unittest.TestCase):
|
|
def _new_scheduler(self) -> Scheduler:
|
|
scheduler = Scheduler.__new__(Scheduler)
|
|
scheduler.ipc_channels = MagicMock()
|
|
scheduler.flush_cache = MagicMock(return_value=True)
|
|
scheduler.is_fully_idle = MagicMock(return_value=False)
|
|
scheduler.flush_wrapper = SchedulerFlushWrapper(
|
|
flush_cache=scheduler.flush_cache,
|
|
is_fully_idle=scheduler.is_fully_idle,
|
|
ipc_channels=scheduler.ipc_channels,
|
|
)
|
|
return scheduler
|
|
|
|
def test_immediate_flush_no_timeout(self):
|
|
"""No timeout → flush immediately regardless of idle state."""
|
|
scheduler = self._new_scheduler()
|
|
scheduler.flush_cache.return_value = False
|
|
|
|
output = scheduler.flush_wrapper.handle(FlushCacheReqInput(timeout_s=None))
|
|
|
|
self.assertFalse(output.success)
|
|
scheduler.flush_cache.assert_called_once()
|
|
|
|
def test_immediate_flush_when_idle(self):
|
|
"""Positive timeout but already idle → flush immediately."""
|
|
scheduler = self._new_scheduler()
|
|
scheduler.is_fully_idle.return_value = True
|
|
|
|
output = scheduler.flush_wrapper.handle(FlushCacheReqInput(timeout_s=5.0))
|
|
|
|
self.assertTrue(output.success)
|
|
scheduler.flush_cache.assert_called_once()
|
|
|
|
def test_defers_when_busy(self):
|
|
"""Positive timeout + busy → defers, returns None."""
|
|
scheduler = self._new_scheduler()
|
|
req = FlushCacheReqInput(timeout_s=3.0)
|
|
|
|
with patch(
|
|
"sglang.srt.managers.scheduler_components.flush_wrapper.time.monotonic",
|
|
return_value=10.0,
|
|
):
|
|
output = scheduler.flush_wrapper.handle(req)
|
|
|
|
self.assertIsNone(output)
|
|
pending_req, deadline = scheduler.flush_wrapper._pending
|
|
self.assertIs(pending_req, req)
|
|
self.assertEqual(deadline, 13.0)
|
|
|
|
def test_rejects_when_already_pending(self):
|
|
"""Any new request is rejected while another is pending."""
|
|
scheduler = self._new_scheduler()
|
|
scheduler.flush_wrapper._pending = (FlushCacheReqInput(timeout_s=10.0), 999.0)
|
|
|
|
for timeout in [None, 5.0]:
|
|
output = scheduler.flush_wrapper.handle(
|
|
FlushCacheReqInput(timeout_s=timeout)
|
|
)
|
|
self.assertFalse(output.success)
|
|
self.assertIn("already in progress", output.message)
|
|
|
|
scheduler.flush_cache.assert_not_called()
|
|
|
|
def test_pending_flush_completes_on_idle(self):
|
|
scheduler = self._new_scheduler()
|
|
scheduler.is_fully_idle.return_value = True
|
|
req = FlushCacheReqInput(timeout_s=1.0)
|
|
scheduler.flush_wrapper._pending = (req, 111.0)
|
|
|
|
scheduler.flush_wrapper.check_pending()
|
|
|
|
self.assertIsNone(scheduler.flush_wrapper._pending)
|
|
scheduler.flush_cache.assert_called_once()
|
|
out = scheduler.ipc_channels.send_to_tokenizer.send_output.call_args.args[0]
|
|
self.assertTrue(out.success)
|
|
|
|
def test_pending_flush_expires_on_timeout(self):
|
|
scheduler = self._new_scheduler()
|
|
req = FlushCacheReqInput(timeout_s=1.0)
|
|
scheduler.flush_wrapper._pending = (req, 99.0)
|
|
|
|
with patch(
|
|
"sglang.srt.managers.scheduler_components.flush_wrapper.time.monotonic",
|
|
return_value=100.0,
|
|
):
|
|
scheduler.flush_wrapper.check_pending()
|
|
|
|
self.assertIsNone(scheduler.flush_wrapper._pending)
|
|
scheduler.flush_cache.assert_not_called()
|
|
out = scheduler.ipc_channels.send_to_tokenizer.send_output.call_args.args[0]
|
|
self.assertFalse(out.success)
|
|
|
|
def test_pending_flush_survives_before_deadline(self):
|
|
scheduler = self._new_scheduler()
|
|
req = FlushCacheReqInput(timeout_s=5.0)
|
|
scheduler.flush_wrapper._pending = (req, 101.0)
|
|
|
|
with patch(
|
|
"sglang.srt.managers.scheduler_components.flush_wrapper.time.monotonic",
|
|
return_value=100.0,
|
|
):
|
|
scheduler.flush_wrapper.check_pending()
|
|
|
|
self.assertIsNotNone(scheduler.flush_wrapper._pending)
|
|
scheduler.ipc_channels.send_to_tokenizer.send_output.assert_not_called()
|
|
|
|
|
|
if __name__ == "__main__":
|
|
unittest.main()
|