@tduncan / Nvidia-Optimization-Stack-VLLM Mirror · read-only / commits / 1bf2ddd0ee

Fork 0

A high-throughput and memory-efficient inference and serving engine for LLMs

Mirrored from https://github.com/tduncan-lum/Nvidia-Optimization-Stack---VLLM.git

Synced Nov 6, 00:45 UTC

[Refactor] Rename `WAITING_FOR_FSM` to `WAITING_FOR_STRUCTURED_OUTPUT_GRAMMAR` (#38048)

Signed-off-by: yewentao256 <zhyanwentao@126.com>

Wentao Ye committed Mar 25, 2026 at 11:41 UTC 1bf2ddd0ee24cf878a87b643536b749676e8f902

5 files changed +34 -25

tests/v1/core/test_scheduler.py

+24 -19

@@ -3652,7 +3652,7 @@ def test_prepend_skipped_requests_order():

3652 assert waiting_reqs == expected_waiting_reqs

3653

3654

3655 -def test_remote_kv_promotion_keeps_fcfs_with_fsm_prefix():

3655 +def test_remote_kv_promotion_keeps_fcfs_with_grammar_prefix():

3656 scheduler = create_scheduler(max_num_seqs=1)

3657 scheduler.connector = Mock()

3658 scheduler.connector.get_num_new_matched_tokens.return_value = (0, False)

@@ -3661,19 +3661,20 @@ def test_remote_kv_promotion_keeps_fcfs_with_fsm_prefix():

3661 for request in requests:

3662 scheduler.add_request(request)

3663

3664 - req_fsm_1, req_fsm_2, req_remote, req_tail = list(scheduler.waiting)

3664 + req_grammar_1, req_grammar_2, req_remote, req_tail = list(scheduler.waiting)

3665

3666 - # simulate two FSM requests at the waiting head that become ready now.

3667 - req_fsm_1.status = RequestStatus.WAITING_FOR_FSM

3668 - req_fsm_1.structured_output_request = Mock(grammar=object())

3669 - req_fsm_2.status = RequestStatus.WAITING_FOR_FSM

3670 - req_fsm_2.structured_output_request = Mock(grammar=object())

3666 + # simulate two structured-output grammar requests at the waiting head

3667 + # that become ready now.

3668 + req_grammar_1.status = RequestStatus.WAITING_FOR_STRUCTURED_OUTPUT_GRAMMAR

3669 + req_grammar_1.structured_output_request = Mock(grammar=object())

3670 + req_grammar_2.status = RequestStatus.WAITING_FOR_STRUCTURED_OUTPUT_GRAMMAR

3671 + req_grammar_2.structured_output_request = Mock(grammar=object())

3672

3673 # simulate a remote-KV request that is ready to be promoted now.

3674 req_remote.status = RequestStatus.WAITING_FOR_REMOTE_KVS

3674 - scheduler.waiting.remove_requests([req_fsm_1, req_fsm_2, req_remote])

3675 - scheduler.skipped_waiting.add_request(req_fsm_1)

3676 - scheduler.skipped_waiting.add_request(req_fsm_2)

3675 + scheduler.waiting.remove_requests([req_grammar_1, req_grammar_2, req_remote])

3676 + scheduler.skipped_waiting.add_request(req_grammar_1)

3677 + scheduler.skipped_waiting.add_request(req_grammar_2)

3678 scheduler.skipped_waiting.add_request(req_remote)

3679 scheduler.finished_recving_kv_req_ids.add(req_remote.request_id)

3680 scheduler._update_waiting_for_remote_kv = Mock()

@@ -3681,13 +3682,13 @@ def test_remote_kv_promotion_keeps_fcfs_with_fsm_prefix():

3682 output = scheduler.schedule()

3683

3684 assert output.scheduled_new_reqs

3684 - assert output.scheduled_new_reqs[0].req_id == req_fsm_1.request_id

3685 + assert output.scheduled_new_reqs[0].req_id == req_grammar_1.request_id

3686 waiting_req_ids = [

3687 req.request_id

3688 for req in list(scheduler.skipped_waiting) + list(scheduler.waiting)

3689 ]

3690 assert waiting_req_ids == [

3690 - req_fsm_2.request_id,

3691 + req_grammar_2.request_id,

3692 req_remote.request_id,

3693 req_tail.request_id,

3694 ]

@@ -3700,28 +3701,32 @@ def test_fcfs_mixed_skipped_waiting_types_keep_order():

3701 mk_req = lambda req_id, num_tokens=1: create_requests( # noqa: E731

3702 num_requests=1, num_tokens=num_tokens, req_ids=[req_id]

3703 )[0]

3703 - req_fsm, req_remote, req_stream = mk_req("fsm"), mk_req("remote"), mk_req("stream")

3704 + req_grammar, req_remote, req_stream = (

3705 + mk_req("grammar"),

3706 + mk_req("remote"),

3707 + mk_req("stream"),

3708 + )

3709 req_regular, req_tail = mk_req("regular", 20), mk_req("tail")

3705 - req_fsm.status = RequestStatus.WAITING_FOR_FSM

3706 - req_fsm.structured_output_request = Mock(grammar=None)

3710 + req_grammar.status = RequestStatus.WAITING_FOR_STRUCTURED_OUTPUT_GRAMMAR

3711 + req_grammar.structured_output_request = Mock(grammar=None)

3712 req_remote.status = RequestStatus.WAITING_FOR_REMOTE_KVS

3713 req_stream.status = RequestStatus.WAITING_FOR_STREAMING_REQ

3714

3710 - for req in (req_fsm, req_remote, req_stream, req_regular, req_tail):

3715 + for req in (req_grammar, req_remote, req_stream, req_regular, req_tail):

3716 scheduler.add_request(req)

3717 scheduler.schedule()

3713 - assert list(scheduler.skipped_waiting) == [req_fsm, req_remote, req_stream]

3718 + assert list(scheduler.skipped_waiting) == [req_grammar, req_remote, req_stream]

3719

3720 scheduler.finish_requests(req_regular.request_id, RequestStatus.FINISHED_ABORTED)

3721 assert not scheduler.running

3722

3718 - req_fsm.structured_output_request = Mock(grammar=object())

3723 + req_grammar.structured_output_request = Mock(grammar=object())

3724 scheduler.finished_recving_kv_req_ids.add(req_remote.request_id)

3725 req_stream.status = RequestStatus.WAITING

3726

3727 second_output = scheduler.schedule()

3728 expected_order = [

3724 - req_fsm.request_id,

3729 + req_grammar.request_id,

3730 req_remote.request_id,

3731 req_stream.request_id,

3732 req_tail.request_id,

tests/v1/test_request.py

+4 -1

@@ -6,7 +6,10 @@ from vllm.v1.request import RequestStatus

6 def test_request_status_fmt_str():

7 """Test that the string representation of RequestStatus is correct."""

8 assert f"{RequestStatus.WAITING}" == "WAITING"

9 - assert f"{RequestStatus.WAITING_FOR_FSM}" == "WAITING_FOR_FSM"

9 + assert (

10 + f"{RequestStatus.WAITING_FOR_STRUCTURED_OUTPUT_GRAMMAR}"

11 + == "WAITING_FOR_STRUCTURED_OUTPUT_GRAMMAR"

12 + )

13 assert f"{RequestStatus.WAITING_FOR_REMOTE_KVS}" == "WAITING_FOR_REMOTE_KVS"

14 assert f"{RequestStatus.WAITING_FOR_STREAMING_REQ}" == "WAITING_FOR_STREAMING_REQ"

15 assert f"{RequestStatus.RUNNING}" == "RUNNING"

vllm/v1/core/sched/scheduler.py

+2 -2

@@ -1550,7 +1550,7 @@ class Scheduler(SchedulerInterface):

1550 @staticmethod

1551 def _is_blocked_waiting_status(status: RequestStatus) -> bool:

1552 return status in (

1553 - RequestStatus.WAITING_FOR_FSM,

1553 + RequestStatus.WAITING_FOR_STRUCTURED_OUTPUT_GRAMMAR,

1554 RequestStatus.WAITING_FOR_REMOTE_KVS,

1555 RequestStatus.WAITING_FOR_STREAMING_REQ,

1556 )

@@ -2084,7 +2084,7 @@ class Scheduler(SchedulerInterface):

2084 request.status = RequestStatus.WAITING

2085 return True

2086

2087 - if request.status == RequestStatus.WAITING_FOR_FSM:

2087 + if request.status == RequestStatus.WAITING_FOR_STRUCTURED_OUTPUT_GRAMMAR:

2088 structured_output_req = request.structured_output_request

2089 if not (structured_output_req and structured_output_req.grammar):

2090 return False

vllm/v1/request.py

+2 -2

@@ -102,7 +102,7 @@ class Request:

102 assert sampling_params.max_tokens is not None

103 self.max_tokens = sampling_params.max_tokens

104 if self.structured_output_request is not None:

105 - self.status = RequestStatus.WAITING_FOR_FSM

105 + self.status = RequestStatus.WAITING_FOR_STRUCTURED_OUTPUT_GRAMMAR

106

107 if sampling_params.extra_args is not None:

108 self.kv_transfer_params = sampling_params.extra_args.get(

@@ -296,7 +296,7 @@ class RequestStatus(enum.IntEnum):

296 """Status of a request."""

297

298 WAITING = enum.auto()

299 - WAITING_FOR_FSM = enum.auto()

299 + WAITING_FOR_STRUCTURED_OUTPUT_GRAMMAR = enum.auto()

300 WAITING_FOR_REMOTE_KVS = enum.auto()

301 WAITING_FOR_STREAMING_REQ = enum.auto()

302 RUNNING = enum.auto()

vllm/v1/structured_output/__init__.py

+2 -1

@@ -42,7 +42,8 @@ class StructuredOutputManager:

43 # When in external_launcher mode, async grammar compilation causes deadlocks

44 # due to external_launcher mode having a scheduler for each TP rank.

45 - # Async grammar compilation causes the WAITING_FOR_FSM → WAITING transition to

45 + # Async grammar compilation causes the

46 + # WAITING_FOR_STRUCTURED_OUTPUT_GRAMMAR → WAITING transition to

47 # happen at different times on different TP ranks,

48 # breaking the determinism assumption that external_launcher relies on.

49 self._use_async_grammar_compilation = (