56 lines
1.9 KiB
Python
56 lines
1.9 KiB
Python
from dataclasses import dataclass
|
|
from typing import Optional
|
|
|
|
import torch
|
|
|
|
from sglang.srt.managers.schedule_batch import ModelWorkerBatch
|
|
from sglang.srt.utils import get_compiler_backend
|
|
|
|
|
|
@torch.compile(dynamic=True, backend=get_compiler_backend())
|
|
def _resolve_future_token_ids(input_ids, future_token_ids_map):
|
|
input_ids[:] = torch.where(
|
|
input_ids < 0,
|
|
future_token_ids_map[torch.clamp(-input_ids, min=0)],
|
|
input_ids,
|
|
)
|
|
|
|
|
|
@dataclass
|
|
class FutureIndices:
|
|
indices: torch.Tensor
|
|
interval: Optional[slice] = None
|
|
|
|
|
|
class FutureMap:
|
|
def __init__(
|
|
self,
|
|
max_running_requests: int,
|
|
device: torch.device,
|
|
):
|
|
self.future_ct = 0
|
|
# A factor of 3 is used to avoid collision in the circular buffer.
|
|
self.future_limit = max_running_requests * 3
|
|
# A factor of 5 is used to ensure the buffer is large enough.
|
|
self.future_buffer_len = max_running_requests * 5
|
|
self.device = device
|
|
|
|
self.token_ids_buf = torch.empty(
|
|
(self.future_buffer_len,), dtype=torch.int64, device=self.device
|
|
)
|
|
|
|
def alloc_future_indices(self, bs: int) -> FutureIndices:
|
|
"""Update the circular buffer pointer and allocate future indices."""
|
|
cur_future_ct = self.future_ct
|
|
self.future_ct = (cur_future_ct + bs) % self.future_limit
|
|
start = cur_future_ct + 1
|
|
end = cur_future_ct + 1 + bs
|
|
indices = torch.arange(start, end, dtype=torch.int64, device=self.device)
|
|
return FutureIndices(indices=indices, interval=slice(start, end))
|
|
|
|
def resolve_future(self, model_worker_batch: ModelWorkerBatch):
|
|
_resolve_future_token_ids(model_worker_batch.input_ids, self.token_ids_buf)
|
|
|
|
def store_to_map(self, future_indices: FutureIndices, next_token_ids: torch.Tensor):
|
|
self.token_ids_buf[future_indices.interval] = next_token_ids
|