Co-authored-by: Yangmin Li <yangminl@nvidia.com> Co-authored-by: YAMY <74099316+YAMY1234@users.noreply.github.com>
103 lines
3.1 KiB
Python
103 lines
3.1 KiB
Python
import unittest
|
|
from collections import defaultdict, deque
|
|
from contextlib import nullcontext
|
|
from types import SimpleNamespace
|
|
from unittest.mock import Mock, call
|
|
|
|
import torch
|
|
|
|
from sglang.srt.managers.scheduler_pp_mixin import SchedulerPPMixin
|
|
from sglang.test.ci.ci_register import register_cpu_ci
|
|
from sglang.test.test_utils import CustomTestCase
|
|
|
|
register_cpu_ci(est_time=1, suite="base-a-test-cpu")
|
|
|
|
|
|
class FakeStream:
|
|
def __init__(self, stream_id):
|
|
self.cuda_stream = stream_id
|
|
|
|
|
|
class FakeEvent:
|
|
def __init__(self):
|
|
self.recorded_stream = None
|
|
|
|
def record(self, stream):
|
|
self.recorded_stream = stream
|
|
|
|
|
|
def _make_scheduler(**attrs):
|
|
scheduler = object.__new__(SchedulerPPMixin)
|
|
scheduler.__dict__.update(attrs)
|
|
return scheduler
|
|
|
|
|
|
class TestPPCommOverlap(CustomTestCase):
|
|
def test_graph_proxy_send_records_forward_reuse_fence(self):
|
|
comm_stream = FakeStream(4)
|
|
work = Mock()
|
|
works = [SimpleNamespace(work=work)]
|
|
scheduler = _make_scheduler(
|
|
pp_comm_stream=comm_stream,
|
|
pp_comm_stream_ctx=nullcontext(),
|
|
pp_send_done_event=None,
|
|
device_module=SimpleNamespace(Event=FakeEvent),
|
|
)
|
|
|
|
scheduler._pp_commit_comm_work(works, fence_next_forward=True)
|
|
|
|
work.wait.assert_called_once_with()
|
|
self.assertEqual(works, [])
|
|
self.assertIs(scheduler.pp_send_done_event.recorded_stream, comm_stream)
|
|
|
|
def test_no_fence_event_without_comm_stream(self):
|
|
scheduler = _make_scheduler(
|
|
pp_comm_stream=None,
|
|
pp_comm_stream_ctx=nullcontext(),
|
|
pp_send_done_event=None,
|
|
)
|
|
|
|
scheduler._pp_commit_comm_work([SimpleNamespace(work=Mock())], True)
|
|
|
|
self.assertIsNone(scheduler.pp_send_done_event)
|
|
|
|
def test_forward_waits_for_graph_send_and_proxy_receive(self):
|
|
schedule_stream = FakeStream(1)
|
|
send_done_event = object()
|
|
recv_event = object()
|
|
forward_stream = Mock()
|
|
scheduler = _make_scheduler(
|
|
schedule_stream=schedule_stream,
|
|
forward_stream=forward_stream,
|
|
pp_send_done_event=send_done_event,
|
|
pp_proxy_recv_event=recv_event,
|
|
)
|
|
|
|
scheduler._pp_wait_forward_dependencies()
|
|
|
|
forward_stream.wait_stream.assert_called_once_with(schedule_stream)
|
|
self.assertEqual(
|
|
forward_stream.wait_event.call_args_list,
|
|
[call(send_done_event), call(recv_event)],
|
|
)
|
|
self.assertIsNone(scheduler.pp_send_done_event)
|
|
self.assertIsNone(scheduler.pp_proxy_recv_event)
|
|
|
|
def test_inbox_returns_original_receive_event(self):
|
|
recv_event = object()
|
|
tensor_dict = {"__msg_type__": "output", "value": torch.arange(2)}
|
|
scheduler = _make_scheduler(
|
|
_pp_tensor_dict_inbox=defaultdict(
|
|
deque, {"output": deque([(tensor_dict, recv_event)])}
|
|
),
|
|
)
|
|
|
|
received, event = scheduler._pp_recv_typed_dict("output")
|
|
|
|
self.assertIs(received, tensor_dict)
|
|
self.assertIs(event, recv_event)
|
|
|
|
|
|
if __name__ == "__main__":
|
|
unittest.main()
|