[Perf][TTS] Add deadline-aware audio scheduling

Signed-off-by: Sy03 <1370724210@qq.com>
This commit is contained in:
Sy03 committed 2026-08-25 12:35:35 +08:00
1 parent 072bfc02dd
commit 5740ca8e01
8 files changed
+559 -19

No files matched your search

@@ -0,0 +1,39 @@
# SPDX-License-Identifier: Apache-2.0
# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
from types import SimpleNamespace
import pytest
import torch
from vllm_omni.core.sched.omni_generation_scheduler import OmniGenerationScheduler
pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
def test_generation_scheduler_records_audio_output_for_edf(mocker):
scheduler = OmniGenerationScheduler.__new__(OmniGenerationScheduler)
scheduler.chunk_transfer_adapter = SimpleNamespace(
playback_deadline_enabled=True,
record_audio_output=mocker.Mock(),
)
multimodal_output = {
"model_outputs": torch.zeros(24000),
"sr": torch.tensor(24000),
}
scheduler._record_playback_deadline_output("req", multimodal_output)
scheduler.chunk_transfer_adapter.record_audio_output.assert_called_once_with("req", 24000, 24000)
def test_generation_scheduler_skips_audio_accounting_when_edf_is_disabled(mocker):
scheduler = OmniGenerationScheduler.__new__(OmniGenerationScheduler)
scheduler.chunk_transfer_adapter = SimpleNamespace(
playback_deadline_enabled=False,
record_audio_output=mocker.Mock(),
)
scheduler._record_playback_deadline_output("req", {"model_outputs": torch.zeros(24000)})
scheduler.chunk_transfer_adapter.record_audio_output.assert_not_called()
@@ -113,6 +113,7 @@ def build_adapter(monkeypatch, mocker: MockerFixture):
*,
stage_id: int = 1,
model_mode: str = "ar",
engine_output_type: str | None = None,
max_num_seqs: int = 2,
active_stream_window: int = 0,
connector_extra: dict | None = None,
@@ -143,6 +144,7 @@ def build_adapter(monkeypatch, mocker: MockerFixture):
model_config = SimpleNamespace(
worker_type=model_mode,
engine_output_type=engine_output_type or ("audio" if model_mode == "generation" else None),
max_num_seqs=max_num_seqs,
active_stream_window=active_stream_window,
stage_connector_config={
@@ -843,6 +845,218 @@ def test_fifo_promotion(build_adapter):
assert reqs[2].status == RequestStatus.WAITING_FOR_CHUNK
def test_edf_requires_active_window(build_adapter):
with pytest.raises(ValueError, match="requires active_stream_window"):
build_adapter(
stage_id=1,
model_mode="generation",
active_stream_window=0,
connector_extra={"active_stream_policy": "edf"},
)
def test_edf_rejects_unknown_policy(build_adapter):
with pytest.raises(ValueError, match="active_stream_policy"):
build_adapter(
stage_id=1,
model_mode="generation",
active_stream_window=1,
connector_extra={"active_stream_policy": "unknown"},
)
@pytest.mark.parametrize(
("key", "value", "message"),
[
("playback_deadline_first_chunk_ms", float("nan"), "first_chunk"),
("playback_deadline_safety_margin_ms", float("inf"), "safety_margin"),
],
)
def test_edf_rejects_non_finite_timing_config(build_adapter, key, value, message):
with pytest.raises(ValueError, match=message):
build_adapter(
stage_id=1,
model_mode="generation",
active_stream_window=1,
connector_extra={"active_stream_policy": "edf", key: value},
)
def test_edf_selects_earliest_playback_deadline(build_adapter, monkeypatch):
monkeypatch.setattr(
"vllm_omni.distributed.omni_connectors.transfer_adapter.chunk_transfer_adapter.time.monotonic",
lambda: 100.0,
)
adapter, _ = build_adapter(
stage_id=1,
model_mode="generation",
max_num_seqs=2,
active_stream_window=1,
connector_extra={"active_stream_policy": "edf"},
)
later = _req("later", RequestStatus.WAITING)
urgent = _req("urgent", RequestStatus.WAITING)
adapter.record_audio_output(later.request_id, 5, 1, emitted_at=100.0)
adapter.record_audio_output(urgent.request_id, 2, 1, emitted_at=100.0)
adapter.requests_with_ready_chunks.update({later.request_id, urgent.request_id})
waiting_queue = DummyWaitingQueue([later, urgent])
adapter.process_pending_chunks(waiting_queue, [])
assert list(adapter._active_streams) == [urgent.request_id]
assert waiting_queue == [urgent]
assert list(adapter.waiting_for_chunk_waiting_requests) == [later]
def test_edf_balances_first_audio_against_playback_deadline(build_adapter, monkeypatch):
monkeypatch.setattr(
"vllm_omni.distributed.omni_connectors.transfer_adapter.chunk_transfer_adapter.time.monotonic",
lambda: 100.0,
)
adapter, _ = build_adapter(
stage_id=1,
model_mode="generation",
max_num_seqs=2,
active_stream_window=1,
connector_extra={
"active_stream_policy": "edf",
"playback_deadline_first_chunk_ms": 100,
"playback_deadline_safety_margin_ms": 0,
},
)
new_request = _req("new", RequestStatus.WAITING)
buffered = _req("buffered", RequestStatus.WAITING)
adapter.record_audio_output(buffered.request_id, 5, 1, emitted_at=100.0)
adapter.requests_with_ready_chunks.update({new_request.request_id, buffered.request_id})
waiting_queue = DummyWaitingQueue([buffered, new_request])
adapter.process_pending_chunks(waiting_queue, [])
assert list(adapter._active_streams) == [new_request.request_id]
adapter.cleanup_receiver(new_request.request_id)
adapter.restore_queues(waiting_queue, [])
starving = _req("starving", RequestStatus.WAITING)
adapter.record_audio_output(starving.request_id, 1, 1, emitted_at=98.0)
adapter.requests_with_ready_chunks.update({new_request.request_id, starving.request_id})
waiting_queue = DummyWaitingQueue([new_request, starving])
adapter.process_pending_chunks(waiting_queue, [])
assert list(adapter._active_streams) == [starving.request_id]
def test_edf_protects_near_underrun_stream_from_overdue_first_audio(build_adapter, monkeypatch):
monkeypatch.setattr(
"vllm_omni.distributed.omni_connectors.transfer_adapter.chunk_transfer_adapter.time.monotonic",
lambda: 100.0,
)
adapter, _ = build_adapter(
stage_id=1,
model_mode="generation",
max_num_seqs=2,
active_stream_window=1,
connector_extra={
"active_stream_policy": "edf",
"playback_deadline_first_chunk_ms": 100,
"playback_deadline_safety_margin_ms": 250,
},
)
overdue_startup = _req("startup", RequestStatus.WAITING)
near_underrun = _req("playing", RequestStatus.WAITING)
adapter._playback_deadline_key(overdue_startup, order=0, now=90.0)
adapter.record_audio_output(near_underrun.request_id, 100, 1000, emitted_at=100.0)
adapter.requests_with_ready_chunks.update({overdue_startup.request_id, near_underrun.request_id})
waiting_queue = DummyWaitingQueue([overdue_startup, near_underrun])
adapter.process_pending_chunks(waiting_queue, [])
assert list(adapter._active_streams) == [near_underrun.request_id]
def test_edf_reselects_at_chunk_boundaries(build_adapter, monkeypatch):
monkeypatch.setattr(
"vllm_omni.distributed.omni_connectors.transfer_adapter.chunk_transfer_adapter.time.monotonic",
lambda: 100.0,
)
adapter, _ = build_adapter(
stage_id=1,
model_mode="generation",
max_num_seqs=2,
active_stream_window=1,
connector_extra={"active_stream_policy": "edf", "playback_deadline_safety_margin_ms": 0},
)
first = _req("first", RequestStatus.WAITING)
second = _req("second", RequestStatus.WAITING)
adapter.record_audio_output(first.request_id, 1, 1, emitted_at=100.0)
adapter.record_audio_output(second.request_id, 2, 1, emitted_at=100.0)
adapter.requests_with_ready_chunks.update({first.request_id, second.request_id})
waiting_queue = DummyWaitingQueue([first, second])
adapter.process_pending_chunks(waiting_queue, [])
assert list(adapter._active_streams) == [first.request_id]
scheduler_output = SimpleNamespace(
scheduled_new_reqs=[SimpleNamespace(req_id=first.request_id)],
scheduled_cached_reqs=None,
)
adapter.postprocess_scheduler_output(scheduler_output)
adapter.restore_queues(waiting_queue, [])
adapter.record_audio_output(first.request_id, 5, 1, emitted_at=100.0)
adapter.requests_with_ready_chunks.add(first.request_id)
adapter.process_pending_chunks(waiting_queue, [])
assert list(adapter._active_streams) == [second.request_id]
def test_edf_k2_orders_ready_running_and_waiting_requests(build_adapter, monkeypatch):
monkeypatch.setattr(
"vllm_omni.distributed.omni_connectors.transfer_adapter.chunk_transfer_adapter.time.monotonic",
lambda: 100.0,
)
adapter, _ = build_adapter(
stage_id=1,
model_mode="generation",
max_num_seqs=4,
active_stream_window=2,
connector_extra={"active_stream_policy": "edf", "playback_deadline_safety_margin_ms": 0},
)
later_running = _req("later-running", RequestStatus.RUNNING)
urgent_waiting = _req("urgent-waiting", RequestStatus.WAITING)
middle_running = _req("middle-running", RequestStatus.RUNNING)
adapter.record_audio_output(later_running.request_id, 5, 1, emitted_at=100.0)
adapter.record_audio_output(urgent_waiting.request_id, 1, 1, emitted_at=100.0)
adapter.record_audio_output(middle_running.request_id, 2, 1, emitted_at=100.0)
adapter.requests_with_ready_chunks.update(
{later_running.request_id, urgent_waiting.request_id, middle_running.request_id}
)
waiting_queue = DummyWaitingQueue([urgent_waiting])
running_queue = [later_running, middle_running]
adapter.process_pending_chunks(waiting_queue, running_queue)
assert list(adapter._active_streams) == [urgent_waiting.request_id, middle_running.request_id]
assert waiting_queue == [urgent_waiting]
assert running_queue == [middle_running]
assert list(adapter._held_non_active) == [later_running]
def test_edf_cleanup_drops_playback_state(build_adapter):
adapter, _ = build_adapter(
stage_id=1,
model_mode="generation",
active_stream_window=1,
connector_extra={"active_stream_policy": "edf"},
)
adapter.record_audio_output("req", 24000, 24000, emitted_at=100.0)
assert "req" in adapter._playback_deadlines
adapter.cleanup_receiver("req")
assert "req" not in adapter._playback_deadlines
def test_non_active_waiting_request_is_held_off_scheduler(build_adapter):
adapter, _ = build_adapter(stage_id=2, max_num_seqs=2, active_stream_window=1)
active = _req("req-active", RequestStatus.WAITING)
@@ -105,6 +105,122 @@ def test_flush_on_finish():
assert len(p.codes.audio) == _Q * 24
def _record_successful_chunk(tm, rid):
tm.put_req_chunk[rid] += 1
tm.ramp_chunk_count[rid] += 1
def test_fixed_chunk_terminal_after_exact_initial_boundary_emits_no_audio():
tm = _tm(initial_chunk_frames=10)
rid = "fixed-exact-initial"
first = _call(tm, rid, n_frames=10, req_ic=10)
assert first is not None
_record_successful_chunk(tm, rid)
terminal = _call(tm, rid, n_frames=10, finished=True, req_ic=10)
assert terminal is not None
assert terminal.meta.finished.item() is True
assert terminal.codes.audio.numel() == 0
def test_fixed_chunk_terminal_after_exact_steady_boundary_emits_no_audio():
tm = _tm(initial_chunk_frames=10)
rid = "fixed-exact-steady"
first = _call(tm, rid, n_frames=10, req_ic=10)
assert first is not None
_record_successful_chunk(tm, rid)
steady = _call(tm, rid, n_frames=35, req_ic=10)
assert steady is not None
_record_successful_chunk(tm, rid)
terminal = _call(tm, rid, n_frames=35, finished=True, req_ic=10)
assert terminal is not None
assert terminal.meta.finished.item() is True
assert terminal.codes.audio.numel() == 0
def test_fixed_chunk_terminal_flushes_exact_boundary_not_previously_sent():
tm = _tm(initial_chunk_frames=10)
rid = "fixed-unsent-boundary"
first = _call(tm, rid, n_frames=10, req_ic=10)
assert first is not None
_record_successful_chunk(tm, rid)
terminal = _call(tm, rid, n_frames=35, finished=True, req_ic=10)
assert terminal is not None
assert terminal.meta.finished.item() is True
assert terminal.codes.audio.numel() == _Q * 25
def test_fixed_chunk_without_initial_terminal_after_exact_boundary_emits_no_audio():
tm = _tm(chunk_frames=4, initial_chunk_frames=4)
rid = "fixed-no-initial-exact"
first = _call(tm, rid, n_frames=4, req_ic=4)
assert first is not None
_record_successful_chunk(tm, rid)
second = _call(tm, rid, n_frames=8, req_ic=4)
assert second is not None
_record_successful_chunk(tm, rid)
terminal = _call(tm, rid, n_frames=8, finished=True, req_ic=4)
assert terminal is not None
assert terminal.codes.audio.numel() == 0
def test_fixed_chunk_terminal_after_exact_boundary_flushes_only_new_tail():
tm = _tm(initial_chunk_frames=10)
rid = "fixed-tail-after-boundary"
first = _call(tm, rid, n_frames=10, req_ic=10)
assert first is not None
_record_successful_chunk(tm, rid)
steady = _call(tm, rid, n_frames=35, req_ic=10)
assert steady is not None
_record_successful_chunk(tm, rid)
terminal = _call(tm, rid, n_frames=40, finished=True, req_ic=10)
assert terminal is not None
assert terminal.codes.audio.numel() == _Q * 5
def test_fixed_chunk_stream_sends_every_codec_frame_exactly_once():
tm = _tm(chunk_frames=4, initial_chunk_frames=2)
rid = "fixed-unique"
frames = [[frame * 10 + quantizer for quantizer in range(_Q)] for frame in range(10)]
emitted = []
for length in (2, 6, 10):
tm.code_prompt_token_ids[rid] = frames[:length]
payload = talker2code2wav_async_chunk(
transfer_manager=tm,
multimodal_output={"codes": {"audio": torch.zeros((0,))}},
request=_req(rid, finished=False, initial_codec_chunk_frames=2),
)
assert payload is not None
emitted.extend(payload.codes.audio.reshape(_Q, -1).transpose(0, 1).tolist())
_record_successful_chunk(tm, rid)
terminal = talker2code2wav_async_chunk(
transfer_manager=tm,
multimodal_output=None,
request=_req(rid, finished=True, initial_codec_chunk_frames=2),
is_finished=True,
)
assert terminal is not None
assert terminal.codes.audio.numel() == 0
assert emitted == frames
_CASES = [
# ── IC boundary rule ──────────────────────────────────────────────
# initial_codec_chunk_frames only controls the first emitted chunk.