@tduncan / Nvidia-Optimization-Stack-VLLM Mirror · read-only / commits / 15f5632365
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 17, 06:45 UTC

Delay GPU->CPU sync in sampling (#1337)

Antoni Baum committed Oct 30, 2023 at 09:01 UTC 15f5632365a98fd43ea42e4948a995aa399e99b5
3 files changed +66 -47
vllm/model_executor/input_metadata.py
+18 -11
@@ -3,7 +3,7 @@ from typing import Dict, List, Optional, Tuple
3 import torch
4 from xformers.ops import AttentionBias
5
6 -from vllm.sampling_params import SamplingParams
6 +from vllm.sampling_params import SamplingParams, SamplingType
7 from vllm.sequence import SequenceData
8
9
@@ -29,6 +29,8 @@ class InputMetadata:
29 context_lens: torch.Tensor,
30 max_context_len: int,
31 block_tables: torch.Tensor,
32 + selected_token_indices: torch.Tensor,
33 + categorized_sample_indices: Dict[SamplingType, torch.Tensor],
34 sliding_window: Optional[int] = None,
35 ) -> None:
36 self.seq_groups = seq_groups
@@ -38,6 +40,8 @@ class InputMetadata:
40 self.context_lens = context_lens
41 self.max_context_len = max_context_len
42 self.block_tables = block_tables
43 + self.selected_token_indices = selected_token_indices
44 + self.categorized_sample_indices = categorized_sample_indices
45
46 self.max_prompt_len = max(prompt_lens) if prompt_lens else 0
47 self.to_cache = None
@@ -72,13 +76,16 @@ class InputMetadata:
76
77 def __repr__(self) -> str:
78 # Print only useful metadata.
75 - return (f'InputMetadata('
76 - f'num_prompt_tokens={self.num_prompt_tokens}, '
77 - f'num_prompts={self.num_prompts}, '
78 - f'prompt_lens={self.prompt_lens}, '
79 - f'num_generation_tokens={self.num_generation_tokens}, '
80 - f'context_lens={self.context_lens}, '
81 - f'max_context_len={self.max_context_len}, '
82 - f'max_num_blocks_per_seq={self.max_num_blocks_per_seq}, '
83 - f'block_tables={self.block_tables}, '
84 - f'slot_mapping={self.slot_mapping})')
79 + return (
80 + f'InputMetadata('
81 + f'num_prompt_tokens={self.num_prompt_tokens}, '
82 + f'num_prompts={self.num_prompts}, '
83 + f'prompt_lens={self.prompt_lens}, '
84 + f'num_generation_tokens={self.num_generation_tokens}, '
85 + f'context_lens={self.context_lens}, '
86 + f'max_context_len={self.max_context_len}), '
87 + f'max_num_blocks_per_seq={self.max_num_blocks_per_seq}, '
88 + f'block_tables={self.block_tables}, '
89 + f'selected_token_indices={self.selected_token_indices}, '
90 + f'categorized_sample_indices={self.categorized_sample_indices}, '
91 + f'slot_mapping={self.slot_mapping})')
vllm/model_executor/layers/sampler.py
+3 -34
@@ -109,29 +109,8 @@ def _prune_hidden_states(
109 hidden_states: torch.Tensor,
110 input_metadata: InputMetadata,
111 ) -> torch.Tensor:
112 - selected_token_indices: List[int] = []
113 - start_idx = 0
114 - for i, seq_group in enumerate(input_metadata.seq_groups):
115 - seq_ids, sampling_params = seq_group
116 - if i < input_metadata.num_prompts:
117 - assert len(seq_ids) == 1, "Prompt input should have only one seq."
118 - prompt_len = input_metadata.prompt_lens[i]
119 - if sampling_params.prompt_logprobs is not None:
120 - selected_token_indices.extend(
121 - range(start_idx, start_idx + prompt_len - 1))
122 - selected_token_indices.append(start_idx + prompt_len - 1)
123 - start_idx += input_metadata.max_prompt_len
124 - else:
125 - num_seqs = len(seq_ids)
126 - selected_token_indices.extend(
127 - range(start_idx, start_idx + num_seqs))
128 - start_idx += num_seqs
129 -
130 - selected_token_indices = torch.tensor(selected_token_indices,
131 - dtype=torch.long,
132 - device=hidden_states.device)
112 hidden_states = hidden_states.view(-1, hidden_states.shape[-1])
134 - return hidden_states.index_select(0, selected_token_indices)
113 + return hidden_states.index_select(0, input_metadata.selected_token_indices)
114
115
116 def _get_penalties(
@@ -426,21 +405,11 @@ def _sample(
405 input_metadata: InputMetadata,
406 ) -> List[Tuple[List[int], List[int]]]:
407 categorized_seq_group_ids = {t: [] for t in SamplingType}
429 - categorized_sample_indices = {t: [] for t in SamplingType}
430 - start_idx = 0
408 + categorized_sample_indices = input_metadata.categorized_sample_indices
409 for i, seq_group in enumerate(input_metadata.seq_groups):
432 - seq_ids, sampling_params = seq_group
410 + _, sampling_params = seq_group
411 sampling_type = sampling_params.sampling_type
434 - if (i < input_metadata.num_prompts
435 - and sampling_params.prompt_logprobs is not None):
436 - # NOTE: prompt token positions do not need sample, skip
437 - prompt_len = input_metadata.prompt_lens[i]
438 - start_idx += prompt_len - 1
412 categorized_seq_group_ids[sampling_type].append(i)
440 - num_seqs = len(seq_ids)
441 - categorized_sample_indices[sampling_type].extend(
442 - range(start_idx, start_idx + num_seqs))
443 - start_idx += num_seqs
413
414 sample_results_dict: Dict[int, Tuple[List[int], List[int]]] = {}
415 for sampling_type in SamplingType:
vllm/worker/worker.py
+45 -2
@@ -10,7 +10,7 @@ from vllm.config import (CacheConfig, ModelConfig, ParallelConfig,
10 from vllm.model_executor import get_model, InputMetadata, set_random_seed
11 from vllm.model_executor.parallel_utils.parallel_state import (
12 initialize_model_parallel)
13 -from vllm.sampling_params import SamplingParams
13 +from vllm.sampling_params import SamplingParams, SamplingType
14 from vllm.sequence import SamplerOutput, SequenceData, SequenceGroupMetadata
15 from vllm.worker.cache_engine import CacheEngine
16 from vllm.utils import get_gpu_memory, get_max_shared_memory_bytes
@@ -161,6 +161,10 @@ class Worker:
161 input_tokens: List[List[int]] = []
162 input_positions: List[List[int]] = []
163 slot_mapping: List[List[int]] = []
164 + selected_token_indices: List[int] = []
165 + selected_token_start_idx = 0
166 + categorized_sample_indices = {t: [] for t in SamplingType}
167 + categorized_sample_indices_start_idx = 0
168
169 # Add prompt tokens.
170 prompt_lens: List[int] = []
@@ -180,6 +184,14 @@ class Worker:
184 prompt_len = len(prompt_tokens)
185 prompt_lens.append(prompt_len)
186
187 + if sampling_params.prompt_logprobs is not None:
188 + # NOTE: prompt token positions do not need sample, skip
189 + categorized_sample_indices_start_idx += prompt_len - 1
190 +
191 + categorized_sample_indices[sampling_params.sampling_type].append(
192 + categorized_sample_indices_start_idx)
193 + categorized_sample_indices_start_idx += 1
194 +
195 input_tokens.append(prompt_tokens)
196 # NOTE(woosuk): Here we assume that the first token in the prompt
197 # is always the first token in the sequence.
@@ -205,14 +217,37 @@ class Worker:
217 max_num_blocks_per_seq = 0
218 context_lens: List[int] = []
219 generation_block_tables: List[List[int]] = []
220 + max_seq_len = max(prompt_lens) if prompt_lens else 1
221 for seq_group_metadata in seq_group_metadata_list:
222 if seq_group_metadata.is_prompt:
223 + # We need to do this in this loop as we need to know max_seq_len
224 + assert len(
225 + seq_ids) == 1, "Prompt input should have only one seq."
226 + sampling_params = seq_group_metadata.sampling_params
227 + if sampling_params.prompt_logprobs is not None:
228 + selected_token_indices.extend(
229 + range(selected_token_start_idx,
230 + selected_token_start_idx + prompt_len - 1))
231 + selected_token_indices.append(selected_token_start_idx +
232 + prompt_len - 1)
233 + selected_token_start_idx += max_seq_len
234 continue
235
236 seq_ids = list(seq_group_metadata.seq_data.keys())
237 sampling_params = seq_group_metadata.sampling_params
238 seq_groups.append((seq_ids, sampling_params))
239
240 + num_seqs = len(seq_ids)
241 + selected_token_indices.extend(
242 + range(selected_token_start_idx,
243 + selected_token_start_idx + num_seqs))
244 + selected_token_start_idx += num_seqs
245 +
246 + categorized_sample_indices[sampling_params.sampling_type].extend(
247 + range(categorized_sample_indices_start_idx,
248 + categorized_sample_indices_start_idx + num_seqs))
249 + categorized_sample_indices_start_idx += num_seqs
250 +
251 for seq_id in seq_ids:
252 seq_data = seq_group_metadata.seq_data[seq_id]
253 generation_token = seq_data.get_last_token_id()
@@ -242,7 +277,6 @@ class Worker:
277 block_table = block_table[-sliding_window_blocks:]
278 generation_block_tables.append(block_table)
279
245 - max_seq_len = max(prompt_lens) if prompt_lens else 1
280 padded_input_tokens = [
281 _pad_to_max(tokens, max_seq_len, pad=0) for tokens in input_tokens
282 ]
@@ -272,6 +306,13 @@ class Worker:
306 context_lens_tensor = torch.tensor(context_lens,
307 dtype=torch.int,
308 device="cuda")
309 + selected_token_indices = torch.tensor(selected_token_indices,
310 + dtype=torch.long,
311 + device="cuda")
312 + categorized_sample_indices = {
313 + t: torch.tensor(seq_ids, dtype=torch.int, device="cuda")
314 + for t, seq_ids in categorized_sample_indices.items()
315 + }
316 block_tables_tensor = torch.tensor(padded_block_tables,
317 dtype=torch.int,
318 device="cuda")
@@ -288,6 +329,8 @@ class Worker:
329 context_lens=context_lens_tensor,
330 max_context_len=max_context_len,
331 block_tables=block_tables_tensor,
332 + selected_token_indices=selected_token_indices,
333 + categorized_sample_indices=categorized_sample_indices,
334 sliding_window=self.sliding_window,
335 )
336 return tokens_tensor, positions_tensor, input_metadata