reafator pipeline stage/step pipeline (#1368)

Signed-off-by: asukaqaq-s <1311722138@qq.com>
This commit is contained in:
Wu JIAZHEN authored and GitHub committed 2026-03-20 19:21:50 +08:00
1 parent 199f7832e7
commit da7a8f8014
14 files changed
+1540 -142

No files matched your search

@@ -10,6 +10,7 @@ model-related operations.
from __future__ import annotations
import copy
import time
from collections.abc import Iterable
from contextlib import nullcontext
@@ -26,9 +27,12 @@ from vllm_omni.diffusion.compile import regionally_compile
from vllm_omni.diffusion.data import DiffusionOutput, OmniDiffusionConfig
from vllm_omni.diffusion.forward_context import set_forward_context
from vllm_omni.diffusion.model_loader.diffusers_loader import DiffusersPipelineLoader
from vllm_omni.diffusion.models.interface import supports_step_execution
from vllm_omni.diffusion.offloader import get_offload_backend
from vllm_omni.diffusion.registry import _NO_CACHE_ACCELERATION
from vllm_omni.diffusion.request import OmniDiffusionRequest
from vllm_omni.diffusion.sched.interface import DiffusionSchedulerOutput
from vllm_omni.diffusion.worker.utils import DiffusionRequestState, RunnerOutput
from vllm_omni.distributed.omni_connectors.kv_transfer_manager import OmniKVTransferManager
from vllm_omni.platforms import current_omni_platform
@@ -65,6 +69,9 @@ class DiffusionModelRunner:
self.cache_backend = None
self.offload_backend = None
# Cache for per-request stepwise state.
self.state_cache: dict[str, DiffusionRequestState] = {}
# Initialize KV cache manager for connector management
self.kv_transfer_manager = OmniKVTransferManager.from_od_config(od_config)
@@ -138,6 +145,13 @@ class DiffusionModelRunner:
)
logger.info("Model runner: Model loaded successfully.")
if getattr(self.od_config, "step_execution", False) and not self.supports_step_mode():
raise ValueError(
"step_execution=True requires a pipeline implementing "
"prepare_encode(), denoise_step(), step_scheduler(), and post_decode(); "
f"{self.od_config.model_class_name} does not support that contract."
)
# Apply CPU offloading
self.offload_backend = get_offload_backend(self.od_config, device=self.device)
if self.offload_backend is not None:
@@ -239,3 +253,106 @@ class DiffusionModelRunner:
cache_summary(self.pipeline, details=True)
return output
# ------------------------------------------------------------------
# Step-wise execution
# ------------------------------------------------------------------
def supports_step_mode(self) -> bool:
"""Return whether current pipeline supports step execution."""
return self.pipeline is not None and supports_step_execution(self.pipeline)
def _update_states(self, scheduler_output: DiffusionSchedulerOutput) -> DiffusionRequestState:
"""Step-before update: cleanup finished requests and get/create one running state."""
for req_id in scheduler_output.finished_req_ids:
self.state_cache.pop(req_id, None)
req_states = scheduler_output.req_states
if len(req_states) != 1:
raise ValueError(f"Step mode currently supports batch_size=1, but got {len(req_states)} req_states.")
# TODO: remove req state from SchedulerOutput
# Stepwise mode currently trusts runner-owned cached state more than
# re-validating scheduler-provided request content on every step.
sched_req_state = req_states[0]
req_id = sched_req_state.sched_req_id
if req_id in self.state_cache:
return self.state_cache[req_id]
req = sched_req_state.req
request_ids = req.request_ids or [req_id]
if len(request_ids) != len(req.prompts):
raise ValueError(
f"request_ids length ({len(request_ids)}) does not match prompts length ({len(req.prompts)})"
)
state = DiffusionRequestState(
req_id=req_id,
sampling=copy.deepcopy(req.sampling_params),
prompts=req.prompts,
)
self.state_cache[req_id] = state
return state
def _update_states_after(self, state: DiffusionRequestState, finished: bool) -> None:
"""Step-after update: clear cached state for completed request."""
if finished:
self.state_cache.pop(state.req_id, None)
def execute_stepwise(self, scheduler_output: DiffusionSchedulerOutput) -> RunnerOutput:
"""Execute one step for one scheduled request and return runner output."""
assert self.pipeline is not None, "Model not loaded. Call load_model() first."
if not self.supports_step_mode():
raise ValueError("Current pipeline does not support step execution.")
# Stepwise mode only supports the basic state-driven denoise path for now.
# Request-mode extras such as cache backends, KV transfer, editing inputs,
# and similar features are not supported here yet.
if self.od_config.cache_backend not in (None, "none"):
raise ValueError("Step mode does not support cache_backend yet.")
use_hsdp = self.od_config.parallel_config.use_hsdp
grad_context = torch.no_grad() if use_hsdp else torch.inference_mode()
with grad_context:
state = self._update_states(scheduler_output)
if state.new_request:
# TODO: support kv manager recv
# TODO: support cache backend
if state.sampling.generator is None and state.sampling.seed is not None:
if state.sampling.generator_device is not None:
gen_device = state.sampling.generator_device
elif self.device.type == "cpu":
gen_device = "cpu"
else:
gen_device = self.device
state.sampling.generator = torch.Generator(device=gen_device).manual_seed(state.sampling.seed)
with set_forward_context(vllm_config=self.vllm_config, omni_diffusion_config=self.od_config):
# step0/new request: encode
if state.new_request:
self.pipeline.prepare_encode(state)
noise_pred = self.pipeline.denoise_step(state)
finished = False
# In CFG parallel mode, only rank 0 gets the actual noise_pred; non-rank-0 workers receive None.
# A true interrupt (all ranks return None) is detected by checking self.pipeline.interrupt.
if noise_pred is None and getattr(self.pipeline, "interrupt", False):
finished = True
result = DiffusionOutput(error="stepwise denoise interrupted")
else:
self.pipeline.step_scheduler(state, noise_pred)
finished = state.denoise_completed
if finished:
result = self.pipeline.post_decode(state)
else:
result = None
self._update_states_after(state, finished)
return RunnerOutput(
req_id=state.req_id,
step_index=state.step_index,
finished=finished,
result=result,
)
+20 -1
View File
@@ -38,7 +38,9 @@ from vllm_omni.diffusion.ipc import pack_diffusion_output_shm
from vllm_omni.diffusion.lora.manager import DiffusionLoRAManager
from vllm_omni.diffusion.profiler import CurrentProfiler
from vllm_omni.diffusion.request import OmniDiffusionRequest
from vllm_omni.diffusion.sched.interface import DiffusionSchedulerOutput
from vllm_omni.diffusion.worker.diffusion_model_runner import DiffusionModelRunner
from vllm_omni.diffusion.worker.utils import RunnerOutput
from vllm_omni.lora.request import LoRARequest
from vllm_omni.platforms import current_omni_platform
from vllm_omni.worker.gpu_memory_utils import get_process_gpu_memory
@@ -194,6 +196,19 @@ class DiffusionWorker:
logger.warning("LoRA activation skipped: %s", exc)
return self.model_runner.execute_model(req)
def execute_stepwise(self, scheduler_output: DiffusionSchedulerOutput) -> RunnerOutput:
"""Execute one diffusion step by delegating to the model runner."""
assert self.model_runner is not None, "Model runner not initialized"
if self.lora_manager is not None:
# Step mode does not support LoRA yet. Clear any previously active
# adapter first so worker-local LoRA state cannot leak in.
self.lora_manager.set_active_adapter(None)
if any(req_state.req.sampling_params.lora_request is not None for req_state in scheduler_output.req_states):
raise ValueError("Step mode does not support LoRA yet.")
return self.model_runner.execute_stepwise(scheduler_output)
def load_weights(self, weights) -> set[str]:
"""Load weights by delegating to the model runner."""
assert self.model_runner is not None, "Model runner not initialized"
@@ -376,7 +391,7 @@ class WorkerProc:
)
return wrapper
def return_result(self, output: DiffusionOutput):
def return_result(self, output: object):
"""Reply to client, only on rank 0."""
if self.result_mq is not None:
try:
@@ -623,6 +638,10 @@ class WorkerWrapperBase:
"""
return self.worker.execute_model(reqs, od_config)
def execute_stepwise(self, scheduler_output: DiffusionSchedulerOutput) -> RunnerOutput:
"""Execute one diffusion step."""
return self.worker.execute_stepwise(scheduler_output)
def load_weights(self, weights: Iterable[tuple[str, torch.Tensor]]) -> set[str]:
"""
Load model weights.
+124
View File
@@ -0,0 +1,124 @@
# SPDX-License-Identifier: Apache-2.0
# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
"""Per-request mutable state for step-wise diffusion execution."""
from __future__ import annotations
from dataclasses import dataclass, field
from typing import TYPE_CHECKING, Any
import torch
if TYPE_CHECKING:
from vllm_omni.diffusion.data import DiffusionOutput
from vllm_omni.inputs.data import OmniDiffusionSamplingParams, OmniPromptType
@dataclass
class DiffusionRequestState:
"""Per-request mutable state across all pipeline stages.
Owned by Runner and passed through all step-execution stages:
``prepare_encode()`` initializes/updates fields, ``denoise_step()`` and
``step_scheduler()`` mutate per-step fields, and ``post_decode()``
consumes final latents. This state object is also the cache unit for
future continuous batching.
This dataclass keeps only the minimal cross-model state required by the
step-execution contract. Pipeline-specific state should be stored in
``extra`` and promoted here only when it becomes shared across models.
Examples:
- Wan-style pipelines may keep ``condition``, ``first_frame_mask``, or
``image_embeds`` in ``extra``.
- Bagel-style pipelines may keep ``gen_context``,
``cfg_text_context``, ``cfg_img_context``, or ``image_shape`` in
``extra``.
"""
# ── Identity / request-level inputs ──
req_id: str
sampling: OmniDiffusionSamplingParams
prompts: list[OmniPromptType] | None = None
# ── Encoded prompts (set once by prepare_encode) ──
prompt_embeds: torch.Tensor | None = None
prompt_embeds_mask: torch.Tensor | None = None
negative_prompt_embeds: torch.Tensor | None = None
negative_prompt_embeds_mask: torch.Tensor | None = None
# ── Latent state (mutated every step by step_scheduler) ──
latents: torch.Tensor | None = None
# ── Timestep schedule (set once by prepare_encode) ──
timesteps: torch.Tensor | list[torch.Tensor] | None = None
step_index: int = 0
# ── Per-request scheduler instance (set once by prepare_encode) ──
scheduler: Any | None = None
# ── CFG config (set once by prepare_encode) ──
do_true_cfg: bool = False
guidance: torch.Tensor | None = None
# ── Spatial / sequence metadata (set once by prepare_encode) ──
img_shapes: list | None = None
txt_seq_lens: list[int] | None = None
negative_txt_seq_lens: list[int] | None = None
# Pipeline-specific extras. Keep model-private fields here unless they
# become part of the shared step-execution contract.
# For example: Wan condition tensors / masks, or Bagel KV contexts.
extra: dict[str, Any] = field(default_factory=dict)
# ── Properties ──
@property
def current_timestep(self) -> torch.Tensor | None:
if self.timesteps is None:
return None
if self.step_index >= self.total_steps:
return None
if isinstance(self.timesteps, torch.Tensor):
if self.timesteps.ndim == 0:
return self.timesteps
return self.timesteps[self.step_index]
return self.timesteps[self.step_index]
@property
def total_steps(self) -> int:
if self.timesteps is None:
return 0
if isinstance(self.timesteps, torch.Tensor):
if self.timesteps.ndim == 0:
return 1
return int(self.timesteps.shape[0])
return len(self.timesteps)
@property
def denoise_completed(self) -> bool:
total_steps = self.total_steps
if total_steps == 0:
return False
return self.step_index >= total_steps
@property
def new_request(self) -> bool:
# TODO: this is only an approximation for current stepwise mode.
# A real "new request" signal should eventually come from scheduler/runner state transitions.
return self.step_index == 0 or self.timesteps is None
@dataclass
class RunnerOutput:
"""Output of a single denoising step for a request.
NOTE: `latents` may be None when returned through IPC to avoid
serialization overhead. The actual latents are kept in Worker's
_request_state_cache.
"""
req_id: str
step_index: int | None = None
finished: bool = False
result: DiffusionOutput | None = None