benchmark_serving.py 47 KB
Newer Older
1
# SPDX-License-Identifier: Apache-2.0
2
r"""Benchmark online serving throughput.
3
4

On the server side, run one of the following commands:
5
    vLLM OpenAI API server
Ethan Xu's avatar
Ethan Xu committed
6
7
    vllm serve <your_model> \
        --swap-space 16 \
8
        --disable-log-requests
9
10

    (TGI backend)
Ronen Schaffer's avatar
Ronen Schaffer committed
11
    ./launch_tgi_server.sh <your_model> <max_batch_total_tokens>
12
13
14
15

On the client side, run:
    python benchmarks/benchmark_serving.py \
        --backend <backend> \
16
17
18
19
20
        --model <your_model> \
        --dataset-name sharegpt \
        --dataset-path <path to dataset> \
        --request-rate <request_rate> \ # By default <request_rate> is inf
        --num-prompts <num_prompts> # By default <num_prompts> is 1000
21

22
23
24
    when using tgi backend, add
        --endpoint /generate_stream
    to the end of the command above.
25
26
27
"""
import argparse
import asyncio
28
import base64
29
import gc
30
import io
31
import json
32
import os
33
34
import random
import time
35
import warnings
36
37
from dataclasses import dataclass
from datetime import datetime
38
from typing import Any, AsyncGenerator, Collection, Dict, List, Optional, Tuple
39
40

import numpy as np
41
42
from backend_request_func import (ASYNC_REQUEST_FUNCS, RequestFuncInput,
                                  RequestFuncOutput)
43
44
from datasets import load_dataset
from PIL.Image import Image
45
from tqdm.asyncio import tqdm
46
from transformers import PreTrainedTokenizerBase
47

48
49
50
51
try:
    from vllm.transformers_utils.tokenizer import get_tokenizer
except ImportError:
    from backend_request_func import get_tokenizer
52

53
54
55
56
57
try:
    from vllm.utils import FlexibleArgumentParser
except ImportError:
    from argparse import ArgumentParser as FlexibleArgumentParser

58
59
MILLISECONDS_TO_SECONDS_CONVERSION = 1000

60
61
62
63
64
65
66

@dataclass
class BenchmarkMetrics:
    completed: int
    total_input: int
    total_output: int
    request_throughput: float
67
    request_goodput: float
68
    output_throughput: float
69
    total_token_throughput: float
70
71
    mean_ttft_ms: float
    median_ttft_ms: float
72
    std_ttft_ms: float
73
    percentiles_ttft_ms: List[Tuple[float, float]]
74
75
    mean_tpot_ms: float
    median_tpot_ms: float
76
    std_tpot_ms: float
77
    percentiles_tpot_ms: List[Tuple[float, float]]
78
79
    mean_itl_ms: float
    median_itl_ms: float
80
    std_itl_ms: float
81
82
83
84
85
86
87
88
    percentiles_itl_ms: List[Tuple[float, float]]
    # E2EL stands for end-to-end latency per request.
    # It is the time taken on the client side from sending
    # a request to receiving a complete response.
    mean_e2el_ms: float
    median_e2el_ms: float
    std_e2el_ms: float
    percentiles_e2el_ms: List[Tuple[float, float]]
89
90


91
def sample_sharegpt_requests(
92
93
94
    dataset_path: str,
    num_requests: int,
    tokenizer: PreTrainedTokenizerBase,
95
    fixed_output_len: Optional[int] = None,
96
) -> List[Tuple[str, int, int, None]]:
97
    # Load the dataset.
98
    with open(dataset_path, encoding='utf-8') as f:
99
100
        dataset = json.load(f)
    # Filter out the conversations with less than 2 turns.
101
    dataset = [data for data in dataset if len(data["conversations"]) >= 2]
102
    # Only keep the first two turns of each conversation.
103
104
    dataset = [(data["conversations"][0]["value"],
                data["conversations"][1]["value"]) for data in dataset]
105

106
107
    # Shuffle the dataset.
    random.shuffle(dataset)
108

109
    # Filter out sequences that are too long or too short
110
    filtered_dataset: List[Tuple[str, int, int]] = []
111
112
113
114
115
116
117
118
119
    for i in range(len(dataset)):
        if len(filtered_dataset) == num_requests:
            break

        # Tokenize the prompts and completions.
        prompt = dataset[i][0]
        prompt_token_ids = tokenizer(prompt).input_ids
        completion = dataset[i][1]
        completion_token_ids = tokenizer(completion).input_ids
120
        prompt_len = len(prompt_token_ids)
121
122
        output_len = len(completion_token_ids
                         ) if fixed_output_len is None else fixed_output_len
123
        if prompt_len < 4 or (fixed_output_len is None and output_len < 4):
124
125
126
127
128
            # Prune too short sequences.
            continue
        if prompt_len > 1024 or prompt_len + output_len > 2048:
            # Prune too long sequences.
            continue
129
        filtered_dataset.append((prompt, prompt_len, output_len, None))
130

131
    return filtered_dataset
132
133


134
135
136
137
138
139
140
def sample_sonnet_requests(
    dataset_path: str,
    num_requests: int,
    input_len: int,
    output_len: int,
    prefix_len: int,
    tokenizer: PreTrainedTokenizerBase,
141
) -> List[Tuple[str, str, int, int, None]]:
142
143
144
    assert (
        input_len > prefix_len
    ), "'args.sonnet-input-len' must be greater than 'args.prefix-input-len'."
145
146

    # Load the dataset.
147
    with open(dataset_path, encoding='utf-8') as f:
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
        poem_lines = f.readlines()

    # Tokenize the poem lines.
    poem_token_ids = tokenizer(poem_lines).input_ids
    average_poem_len = sum(
        len(token_ids) for token_ids in poem_token_ids) / len(poem_token_ids)

    # Base prefix for all requests.
    base_prompt = "Pick as many lines as you can from these poem lines:\n"
    base_message = [{
        "role": "user",
        "content": base_prompt,
    }]
    base_prompt_formatted = tokenizer.apply_chat_template(
        base_message, add_generation_prompt=True, tokenize=False)
    base_prompt_offset = len(tokenizer(base_prompt_formatted).input_ids)

165
166
167
    assert (
        input_len > base_prompt_offset
    ), f"Please set 'args.sonnet-input-len' higher than {base_prompt_offset}."
168
169
170
171
172
173
174
    num_input_lines = round(
        (input_len - base_prompt_offset) / average_poem_len)

    # First approximately `prefix_len` number of tokens in the
    # prompt are fixed poem lines.
    assert (
        prefix_len > base_prompt_offset
175
    ), f"Please set 'args.sonnet-prefix-len' higher than {base_prompt_offset}."
176
177
178
179
180
181
182
183

    num_prefix_lines = round(
        (prefix_len - base_prompt_offset) / average_poem_len)
    prefix_lines = poem_lines[:num_prefix_lines]

    # Sample the rest of lines per request.
    sampled_requests: List[Tuple[str, int, int]] = []
    for _ in range(num_requests):
184
185
186
        num_lines_needed = num_input_lines - num_prefix_lines
        sampled_lines = "".join(prefix_lines +
                                random.choices(poem_lines, k=num_lines_needed))
187
188
189
190
191
192
193
194
195
196
197
198

        prompt = f"{base_prompt}{sampled_lines}"
        message = [
            {
                "role": "user",
                "content": prompt,
            },
        ]
        prompt_formatted = tokenizer.apply_chat_template(
            message, add_generation_prompt=True, tokenize=False)
        prompt_len = len(tokenizer(prompt_formatted).input_ids)
        sampled_requests.append(
199
200
201
202
203
            (prompt, prompt_formatted, prompt_len, output_len, None))

    return sampled_requests


204
def sample_vision_arena_requests(
205
206
207
208
209
210
211
212
213
214
215
    dataset,
    num_requests: int,
    tokenizer: PreTrainedTokenizerBase,
    fixed_output_len: Optional[int] = None,
) -> List[Tuple[str, str, int, Optional[Dict[str, Collection[str]]]]]:
    sampled_requests: List[Tuple[str, int, int, Dict[str,
                                                     Collection[str]]]] = []
    for data in dataset:
        if len(sampled_requests) == num_requests:
            break

216
        prompt = data["turns"][0][0]['content']
217
218
219
220
221
222
223
224
225
226
227

        prompt_token_ids = tokenizer(prompt).input_ids
        if fixed_output_len is None:
            # Default max output len is set to 128
            print("--hf-output-len is not provided. Using default value 128.")
            fixed_output_len = 128

        prompt_len = len(prompt_token_ids)
        output_len = fixed_output_len

        assert isinstance(
228
            data["images"][0],
229
230
            Image), ("Input image format must be `PIL.Image.Image`, "
                     f"given {type(data['image'])}.")
231
        image: Image = data["images"][0]
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
        image = image.convert("RGB")
        image_data = io.BytesIO()
        image.save(image_data, format='JPEG')
        image_base64 = base64.b64encode(image_data.getvalue()).decode("utf-8")
        mm_content = {
            "type": "image_url",
            "image_url": {
                "url": f"data:image/jpeg;base64,{image_base64}"
            },
        }

        sampled_requests.append((prompt, prompt_len, output_len, mm_content))

    return sampled_requests


248
249
def sample_hf_requests(
    dataset_path: str,
250
    dataset_subset: Optional[str],
251
252
253
    dataset_split: str,
    num_requests: int,
    tokenizer: PreTrainedTokenizerBase,
254
    random_seed: int,
255
256
    fixed_output_len: Optional[int] = None,
) -> List[Tuple[str, str, int, Optional[Dict[str, Collection[str]]]]]:
257

258
259
260
261
    # Special case for vision_arena dataset
    if dataset_path == 'lmarena-ai/vision-arena-bench-v0.1' \
        and dataset_subset is None:
        assert dataset_split == "train"
262
263
264
265
        dataset = load_dataset(dataset_path,
                               name=dataset_subset,
                               split=dataset_split,
                               streaming=True)
266
267
268
        dataset = dataset.shuffle(seed=random_seed)
        return sample_vision_arena_requests(dataset, num_requests, tokenizer,
                                            fixed_output_len)
269

270
271
272
273
274
275
    dataset = load_dataset(dataset_path,
                           name=dataset_subset,
                           split=dataset_split,
                           streaming=True)
    assert "conversations" in dataset.features, (
        "HF Dataset must have 'conversations' column.")
276
277
    filter_func = lambda x: len(x["conversations"]) >= 2
    filtered_dataset = dataset.shuffle(seed=random_seed).filter(filter_func)
278
279
280
281
282
283
284
285
286
287
288
289
290
291
    sampled_requests: List[Tuple[str, int, int, Dict[str,
                                                     Collection[str]]]] = []
    for data in filtered_dataset:
        if len(sampled_requests) == num_requests:
            break

        # Tokenize the prompts and completions.
        prompt = data["conversations"][0]["value"]
        prompt_token_ids = tokenizer(prompt).input_ids
        completion = data["conversations"][1]["value"]
        completion_token_ids = tokenizer(completion).input_ids
        prompt_len = len(prompt_token_ids)
        output_len = len(completion_token_ids
                         ) if fixed_output_len is None else fixed_output_len
292
        if fixed_output_len is None and (prompt_len < 4 or output_len < 4):
293
294
            # Prune too short sequences.
            continue
295
296
        if fixed_output_len is None and \
            (prompt_len > 1024 or prompt_len + output_len > 2048):
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
            # Prune too long sequences.
            continue

        if "image" in data and isinstance(data["image"], Image):
            image: Image = data["image"]
            image = image.convert("RGB")
            image_data = io.BytesIO()
            image.save(image_data, format='JPEG')
            image_base64 = base64.b64encode(
                image_data.getvalue()).decode("utf-8")
            mm_content = {
                "type": "image_url",
                "image_url": {
                    "url": f"data:image/jpeg;base64,{image_base64}"
                },
            }
313
314
315
316
317
318
319
320
321
322
323
324
325
        elif "image" in data and isinstance(data["image"], str):
            if (data["image"].startswith("http://") or \
                data["image"].startswith("file://")):
                image_url = data["image"]
            else:
                image_url = f"file://{data['image']}"

            mm_content = {
                "type": "image_url",
                "image_url": {
                    "url": image_url
                },
            }
326
327
328
329
        else:
            mm_content = None

        sampled_requests.append((prompt, prompt_len, output_len, mm_content))
330
331
332
333

    return sampled_requests


334
def sample_random_requests(
335
336
337
338
339
340
341
342
343
344
    prefix_len: int,
    input_len: int,
    output_len: int,
    num_prompts: int,
    range_ratio: float,
    tokenizer: PreTrainedTokenizerBase,
) -> List[Tuple[str, int, int]]:
    prefix_token_ids = np.random.randint(0,
                                         tokenizer.vocab_size,
                                         size=prefix_len).tolist()
345
346
347
348
349
350
351
352
353
354
355
356
357

    input_lens = np.random.randint(
        int(input_len * range_ratio),
        input_len + 1,
        size=num_prompts,
    )
    output_lens = np.random.randint(
        int(output_len * range_ratio),
        output_len + 1,
        size=num_prompts,
    )
    offsets = np.random.randint(0, tokenizer.vocab_size, size=num_prompts)
    input_requests = []
358
    for i in range(num_prompts):
359
360
        prompt = tokenizer.decode(prefix_token_ids +
                                  [(offsets[i] + i + j) % tokenizer.vocab_size
361
                                   for j in range(input_lens[i])])
362

363
364
        input_requests.append((prompt, int(prefix_len + input_lens[i]),
                               int(output_lens[i]), None))
365
366
367
368

    return input_requests


369
370
371
async def get_request(
    input_requests: List[Tuple[str, int, int]],
    request_rate: float,
372
    burstiness: float = 1.0,
373
) -> AsyncGenerator[Tuple[str, int, int], None]:
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
    """
    Asynchronously generates requests at a specified rate 
    with OPTIONAL burstiness.
    
    Args:
        input_requests: 
            A list of input requests, each represented as a tuple.
        request_rate: 
            The rate at which requests are generated (requests/s).
        burstiness (optional): 
            The burstiness factor of the request generation. 
            Only takes effect when request_rate is not inf.
            Default value is 1, which follows a Poisson process.
            Otherwise, the request intervals follow a gamma distribution.
            A lower burstiness value (0 < burstiness < 1) results 
            in more bursty requests, while a higher burstiness value 
            (burstiness > 1) results in a more uniform arrival of requests.
    """
392
    input_requests = iter(input_requests)
393
394
395
396
397
398

    # Calculate scale parameter theta to maintain the desired request_rate.
    assert burstiness > 0, (
        f"A positive burstiness factor is expected, but given {burstiness}.")
    theta = 1.0 / (request_rate * burstiness)

399
400
401
402
403
404
    for request in input_requests:
        yield request

        if request_rate == float("inf"):
            # If the request rate is infinity, then we don't need to wait.
            continue
405

406
407
408
        # Sample the request interval from the gamma distribution.
        # If burstiness is 1, it follows exponential distribution.
        interval = np.random.gamma(shape=burstiness, scale=theta)
409
410
411
412
        # The next request will be sent after the interval.
        await asyncio.sleep(interval)


413
414
415
416
417
def calculate_metrics(
    input_requests: List[Tuple[str, int, int]],
    outputs: List[RequestFuncOutput],
    dur_s: float,
    tokenizer: PreTrainedTokenizerBase,
418
419
    selected_percentile_metrics: List[str],
    selected_percentiles: List[float],
420
    goodput_config_dict: Dict[str, float],
421
) -> Tuple[BenchmarkMetrics, List[int]]:
422
    actual_output_lens: List[int] = []
423
424
    total_input = 0
    completed = 0
425
    good_completed = 0
426
427
    itls: List[float] = []
    tpots: List[float] = []
428
    all_tpots: List[float] = []
429
    ttfts: List[float] = []
430
    e2els: List[float] = []
431
432
    for i in range(len(outputs)):
        if outputs[i].success:
433
434
435
436
437
438
439
440
441
442
443
            output_len = outputs[i].output_tokens

            if output_len is None:
                # We use the tokenizer to count the number of output tokens
                # for some serving backends instead of looking at
                # len(outputs[i].itl) since multiple output tokens may be
                # bundled together
                # Note : this may inflate the output token count slightly
                output_len = len(
                    tokenizer(outputs[i].generated_text,
                              add_special_tokens=False).input_ids)
444
            actual_output_lens.append(output_len)
445
            total_input += input_requests[i][1]
446
            tpot = 0
447
            if output_len > 1:
448
449
                latency_minus_ttft = outputs[i].latency - outputs[i].ttft
                tpot = latency_minus_ttft / (output_len - 1)
450
451
452
                tpots.append(tpot)
            # Note: if output_len <= 1, we regard tpot as 0 for goodput
            all_tpots.append(tpot)
453
            itls += outputs[i].itl
454
            ttfts.append(outputs[i].ttft)
455
            e2els.append(outputs[i].latency)
456
            completed += 1
457
458
        else:
            actual_output_lens.append(0)
459

460
    if goodput_config_dict:
461
462
463
        valid_metrics = []
        slo_values = []

464
        if "ttft" in goodput_config_dict:
465
            valid_metrics.append(ttfts)
466
            slo_values.append(goodput_config_dict["ttft"] /
467
                              MILLISECONDS_TO_SECONDS_CONVERSION)
468
        if "tpot" in goodput_config_dict:
469
            valid_metrics.append(all_tpots)
470
            slo_values.append(goodput_config_dict["tpot"] /
471
                              MILLISECONDS_TO_SECONDS_CONVERSION)
472
        if "e2el" in goodput_config_dict:
473
            valid_metrics.append(e2els)
474
            slo_values.append(goodput_config_dict["e2el"] /
475
476
477
478
479
480
481
                              MILLISECONDS_TO_SECONDS_CONVERSION)

        for req_metric in zip(*valid_metrics):
            is_good_req = all([s >= r for s, r in zip(slo_values, req_metric)])
            if is_good_req:
                good_completed += 1

482
483
484
485
486
    if completed == 0:
        warnings.warn(
            "All requests failed. This is likely due to a misconfiguration "
            "on the benchmark arguments.",
            stacklevel=2)
487
488
489
    metrics = BenchmarkMetrics(
        completed=completed,
        total_input=total_input,
490
        total_output=sum(actual_output_lens),
491
        request_throughput=completed / dur_s,
492
        request_goodput=good_completed / dur_s,
493
        output_throughput=sum(actual_output_lens) / dur_s,
494
        total_token_throughput=(total_input + sum(actual_output_lens)) / dur_s,
495
496
        mean_ttft_ms=np.mean(ttfts or 0) *
        1000,  # ttfts is empty if streaming is not supported by backend
497
        std_ttft_ms=np.std(ttfts or 0) * 1000,
498
499
500
        median_ttft_ms=np.median(ttfts or 0) * 1000,
        percentiles_ttft_ms=[(p, np.percentile(ttfts or 0, p) * 1000)
                             for p in selected_percentiles],
501
        mean_tpot_ms=np.mean(tpots or 0) * 1000,
502
        std_tpot_ms=np.std(tpots or 0) * 1000,
503
504
505
        median_tpot_ms=np.median(tpots or 0) * 1000,
        percentiles_tpot_ms=[(p, np.percentile(tpots or 0, p) * 1000)
                             for p in selected_percentiles],
506
        mean_itl_ms=np.mean(itls or 0) * 1000,
507
        std_itl_ms=np.std(itls or 0) * 1000,
508
509
510
        median_itl_ms=np.median(itls or 0) * 1000,
        percentiles_itl_ms=[(p, np.percentile(itls or 0, p) * 1000)
                            for p in selected_percentiles],
511
        mean_e2el_ms=np.mean(e2els or 0) * 1000,
512
        std_e2el_ms=np.std(e2els or 0) * 1000,
513
        median_e2el_ms=np.median(e2els or 0) * 1000,
514
515
        percentiles_e2el_ms=[(p, np.percentile(e2els or 0, p) * 1000)
                             for p in selected_percentiles],
516
    )
517

518
    return metrics, actual_output_lens
519

520
521
522
523

async def benchmark(
    backend: str,
    api_url: str,
524
    base_url: str,
525
    model_id: str,
526
    model_name: str,
527
    tokenizer: PreTrainedTokenizerBase,
528
    input_requests: List[Tuple[str, int, int]],
529
    logprobs: Optional[int],
530
531
    best_of: int,
    request_rate: float,
532
    burstiness: float,
533
    disable_tqdm: bool,
534
    profile: bool,
535
536
    selected_percentile_metrics: List[str],
    selected_percentiles: List[str],
537
    ignore_eos: bool,
538
    goodput_config_dict: Dict[str, float],
539
    max_concurrency: Optional[int],
540
    lora_modules: Optional[List[str]],
541
542
):
    if backend in ASYNC_REQUEST_FUNCS:
543
        request_func = ASYNC_REQUEST_FUNCS[backend]
544
545
546
    else:
        raise ValueError(f"Unknown backend: {backend}")

547
    print("Starting initial single prompt test run...")
548
549
550
551
552
553
    test_prompt, test_prompt_len, test_output_len, test_mm_content = (
        input_requests[0])
    if backend != "openai-chat" and test_mm_content is not None:
        # multi-modal benchmark is only available on OpenAI Chat backend.
        raise ValueError(
            "Multi-modal content is only supported on 'openai-chat' backend.")
554
555
    test_input = RequestFuncInput(
        model=model_id,
556
        model_name=model_name,
557
558
559
560
        prompt=test_prompt,
        api_url=api_url,
        prompt_len=test_prompt_len,
        output_len=test_output_len,
561
        logprobs=logprobs,
562
        best_of=best_of,
563
        multi_modal_content=test_mm_content,
564
        ignore_eos=ignore_eos,
565
    )
566

567
568
569
570
571
572
573
    test_output = await request_func(request_func_input=test_input)
    if not test_output.success:
        raise ValueError(
            "Initial test run failed - Please make sure benchmark arguments "
            f"are correctly specified. Error: {test_output.error}")
    else:
        print("Initial test run completed. Starting main benchmark run...")
574

575
576
577
578
579
    if lora_modules:
        # For each input request, choose a LoRA module at random.
        lora_modules = iter(
            [random.choice(lora_modules) for _ in range(len(input_requests))])

580
581
    if profile:
        print("Starting profiler...")
582
        profile_input = RequestFuncInput(model=model_id,
583
                                         model_name=model_name,
584
585
586
587
588
589
590
591
                                         prompt=test_prompt,
                                         api_url=base_url + "/start_profile",
                                         prompt_len=test_prompt_len,
                                         output_len=test_output_len,
                                         logprobs=logprobs,
                                         best_of=best_of,
                                         multi_modal_content=test_mm_content,
                                         ignore_eos=ignore_eos)
592
593
594
595
        profile_output = await request_func(request_func_input=profile_input)
        if profile_output.success:
            print("Profiler started")

596
597
598
599
600
    if burstiness == 1.0:
        distribution = "Poisson process"
    else:
        distribution = "Gamma distribution"

601
    print(f"Traffic request rate: {request_rate}")
602
    print(f"Burstiness factor: {burstiness} ({distribution})")
603
    print(f"Maximum request concurrency: {max_concurrency}")
604

605
606
    pbar = None if disable_tqdm else tqdm(total=len(input_requests))

607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
    # This can be used once the minimum Python version is 3.10 or higher,
    # and it will simplify the code in limited_request_func.
    #    semaphore = (asyncio.Semaphore(max_concurrency)
    #                 if max_concurrency else contextlib.nullcontext())
    semaphore = (asyncio.Semaphore(max_concurrency)
                 if max_concurrency else None)

    async def limited_request_func(request_func_input, pbar):
        if semaphore is None:
            return await request_func(request_func_input=request_func_input,
                                      pbar=pbar)
        async with semaphore:
            return await request_func(request_func_input=request_func_input,
                                      pbar=pbar)

622
    benchmark_start_time = time.perf_counter()
623
    tasks: List[asyncio.Task] = []
624
    async for request in get_request(input_requests, request_rate, burstiness):
625
        prompt, prompt_len, output_len, mm_content = request
626
627
628
629
630
631
632
        req_model_id, req_model_name = model_id, model_name
        if lora_modules:
            req_lora_module = next(lora_modules)
            req_model_id, req_model_name = req_lora_module, req_lora_module

        request_func_input = RequestFuncInput(model=req_model_id,
                                              model_name=req_model_name,
633
634
635
636
637
638
639
640
                                              prompt=prompt,
                                              api_url=api_url,
                                              prompt_len=prompt_len,
                                              output_len=output_len,
                                              logprobs=logprobs,
                                              best_of=best_of,
                                              multi_modal_content=mm_content,
                                              ignore_eos=ignore_eos)
641
642
        tasks.append(
            asyncio.create_task(
643
644
                limited_request_func(request_func_input=request_func_input,
                                     pbar=pbar)))
645
    outputs: List[RequestFuncOutput] = await asyncio.gather(*tasks)
646

647
648
649
650
651
652
653
654
    if profile:
        print("Stopping profiler...")
        profile_input = RequestFuncInput(
            model=model_id,
            prompt=test_prompt,
            api_url=base_url + "/stop_profile",
            prompt_len=test_prompt_len,
            output_len=test_output_len,
655
            logprobs=logprobs,
656
657
658
659
660
661
            best_of=best_of,
        )
        profile_output = await request_func(request_func_input=profile_input)
        if profile_output.success:
            print("Profiler stopped")

662
    if pbar is not None:
663
664
665
666
        pbar.close()

    benchmark_duration = time.perf_counter() - benchmark_start_time

667
    metrics, actual_output_lens = calculate_metrics(
668
669
670
671
        input_requests=input_requests,
        outputs=outputs,
        dur_s=benchmark_duration,
        tokenizer=tokenizer,
672
673
        selected_percentile_metrics=selected_percentile_metrics,
        selected_percentiles=selected_percentiles,
674
        goodput_config_dict=goodput_config_dict,
675
676
    )

677
678
679
680
681
682
683
684
685
    print("{s:{c}^{n}}".format(s=' Serving Benchmark Result ', n=50, c='='))
    print("{:<40} {:<10}".format("Successful requests:", metrics.completed))
    print("{:<40} {:<10.2f}".format("Benchmark duration (s):",
                                    benchmark_duration))
    print("{:<40} {:<10}".format("Total input tokens:", metrics.total_input))
    print("{:<40} {:<10}".format("Total generated tokens:",
                                 metrics.total_output))
    print("{:<40} {:<10.2f}".format("Request throughput (req/s):",
                                    metrics.request_throughput))
686
    if goodput_config_dict:
687
688
        print("{:<40} {:<10.2f}".format("Request goodput (req/s):",
                                        metrics.request_goodput))
689
690
    print("{:<40} {:<10.2f}".format("Output token throughput (tok/s):",
                                    metrics.output_throughput))
691
692
    print("{:<40} {:<10.2f}".format("Total Token throughput (tok/s):",
                                    metrics.total_token_throughput))
693
694
695
696
697
698

    result = {
        "duration": benchmark_duration,
        "completed": metrics.completed,
        "total_input_tokens": metrics.total_input,
        "total_output_tokens": metrics.total_output,
699
        "request_throughput": metrics.request_throughput,
700
        "request_goodput:":
701
        metrics.request_goodput if goodput_config_dict else None,
702
        "output_throughput": metrics.output_throughput,
703
        "total_token_throughput": metrics.total_token_throughput,
704
705
706
707
708
709
        "input_lens": [output.prompt_len for output in outputs],
        "output_lens": actual_output_lens,
        "ttfts": [output.ttft for output in outputs],
        "itls": [output.itl for output in outputs],
        "generated_texts": [output.generated_text for output in outputs],
        "errors": [output.error for output in outputs],
710
    }
711
712
713
714
715
716
717
718
719

    def process_one_metric(
        # E.g., "ttft"
        metric_attribute_name: str,
        # E.g., "TTFT"
        metric_name: str,
        # E.g., "Time to First Token"
        metric_header: str,
    ):
720
        # This function prints and adds statistics of the specified
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
        # metric.
        if metric_attribute_name not in selected_percentile_metrics:
            return
        print("{s:{c}^{n}}".format(s=metric_header, n=50, c='-'))
        print("{:<40} {:<10.2f}".format(
            f"Mean {metric_name} (ms):",
            getattr(metrics, f"mean_{metric_attribute_name}_ms")))
        print("{:<40} {:<10.2f}".format(
            f"Median {metric_name} (ms):",
            getattr(metrics, f"median_{metric_attribute_name}_ms")))
        result[f"mean_{metric_attribute_name}_ms"] = getattr(
            metrics, f"mean_{metric_attribute_name}_ms")
        result[f"median_{metric_attribute_name}_ms"] = getattr(
            metrics, f"median_{metric_attribute_name}_ms")
        result[f"std_{metric_attribute_name}_ms"] = getattr(
            metrics, f"std_{metric_attribute_name}_ms")
        for p, value in getattr(metrics,
                                f"percentiles_{metric_attribute_name}_ms"):
            p_word = str(int(p)) if int(p) == p else str(p)
            print("{:<40} {:<10.2f}".format(f"P{p_word} {metric_name} (ms):",
                                            value))
            result[f"p{p_word}_{metric_attribute_name}_ms"] = value

    process_one_metric("ttft", "TTFT", "Time to First Token")
    process_one_metric("tpot", "TPOT",
                       "Time per Output Token (excl. 1st token)")
    process_one_metric("itl", "ITL", "Inter-token Latency")
    process_one_metric("e2el", "E2EL", "End-to-end Latency")

    print("=" * 50)

752
    return result
753
754


755
756
def check_goodput_args(args):
    # Check and parse goodput arguments
757
    goodput_config_dict = {}
758
759
    VALID_NAMES = ["ttft", "tpot", "e2el"]
    if args.goodput:
760
761
        goodput_config_dict = parse_goodput(args.goodput)
        for slo_name, slo_val in goodput_config_dict.items():
762
763
764
765
766
767
768
769
770
771
            if slo_name not in VALID_NAMES:
                raise ValueError(
                    f"Invalid metric name found, {slo_name}: {slo_val}. "
                    "The service level objective name should be one of "
                    f"{str(VALID_NAMES)}. ")
            if slo_val < 0:
                raise ValueError(
                    f"Invalid value found, {slo_name}: {slo_val}. "
                    "The service level objective value should be "
                    "non-negative.")
772
    return goodput_config_dict
773
774
775


def parse_goodput(slo_pairs):
776
    goodput_config_dict = {}
777
778
779
    try:
        for slo_pair in slo_pairs:
            slo_name, slo_val = slo_pair.split(":")
780
            goodput_config_dict[slo_name] = float(slo_val)
781
782
783
784
785
786
    except ValueError as err:
        raise argparse.ArgumentTypeError(
            "Invalid format found for service level objectives. "
            "Specify service level objectives for goodput as \"KEY:VALUE\" "
            "pairs, where the key is a metric name, and the value is a "
            "number in milliseconds.") from err
787
    return goodput_config_dict
788
789


790
791
792
793
794
def main(args: argparse.Namespace):
    print(args)
    random.seed(args.seed)
    np.random.seed(args.seed)

795
796
    backend = args.backend
    model_id = args.model
797
    model_name = args.served_model_name
798
    tokenizer_id = args.tokenizer if args.tokenizer is not None else args.model
799
    tokenizer_mode = args.tokenizer_mode
800
801
802

    if args.base_url is not None:
        api_url = f"{args.base_url}{args.endpoint}"
803
        base_url = f"{args.base_url}"
804
805
    else:
        api_url = f"http://{args.host}:{args.port}{args.endpoint}"
806
        base_url = f"http://{args.host}:{args.port}"
807
808

    tokenizer = get_tokenizer(tokenizer_id,
809
                              tokenizer_mode=tokenizer_mode,
810
                              trust_remote_code=args.trust_remote_code)
811
812
813
814
815
816
817
818
819
820
821

    if args.dataset is not None:
        warnings.warn(
            "The '--dataset' argument will be deprecated in the next "
            "release. Please use '--dataset-name' and "
            "'--dataset-path' in the future runs.",
            stacklevel=2)
        input_requests = sample_sharegpt_requests(
            dataset_path=args.dataset,
            num_requests=args.num_prompts,
            tokenizer=tokenizer,
822
            fixed_output_len=args.sharegpt_output_len,
823
824
825
826
827
828
829
        )

    elif args.dataset_name == "sharegpt":
        input_requests = sample_sharegpt_requests(
            dataset_path=args.dataset_path,
            num_requests=args.num_prompts,
            tokenizer=tokenizer,
830
            fixed_output_len=args.sharegpt_output_len,
831
832
833
834
835
836
837
838
        )

    elif args.dataset_name == "sonnet":
        # Do not format the prompt, pass to message directly
        if args.backend == "openai-chat":
            input_requests = sample_sonnet_requests(
                dataset_path=args.dataset_path,
                num_requests=args.num_prompts,
839
840
841
                input_len=args.sonnet_input_len,
                output_len=args.sonnet_output_len,
                prefix_len=args.sonnet_prefix_len,
842
843
                tokenizer=tokenizer,
            )
844
            input_requests = [(prompt, prompt_len, output_len, None)
845
                              for prompt, prompt_formatted, prompt_len,
846
                              output_len, _ in input_requests]
847
848
849
850
851
852
853
        else:
            assert (
                tokenizer.chat_template or tokenizer.default_chat_template
            ), "Tokenizer/model must have chat template for sonnet dataset."
            input_requests = sample_sonnet_requests(
                dataset_path=args.dataset_path,
                num_requests=args.num_prompts,
854
855
856
                input_len=args.sonnet_input_len,
                output_len=args.sonnet_output_len,
                prefix_len=args.sonnet_prefix_len,
857
858
                tokenizer=tokenizer,
            )
859
            input_requests = [(prompt_formatted, prompt_len, output_len, None)
860
                              for prompt, prompt_formatted, prompt_len,
861
                              output_len, _ in input_requests]
862

863
864
865
866
867
868
869
    elif args.dataset_name == "hf":
        input_requests = sample_hf_requests(
            dataset_path=args.dataset_path,
            dataset_subset=args.hf_subset,
            dataset_split=args.hf_split,
            num_requests=args.num_prompts,
            tokenizer=tokenizer,
870
            random_seed=args.seed,
871
872
873
            fixed_output_len=args.hf_output_len,
        )

874
875
    elif args.dataset_name == "random":
        input_requests = sample_random_requests(
876
            prefix_len=args.random_prefix_len,
877
878
            input_len=args.random_input_len,
            output_len=args.random_output_len,
879
            num_prompts=args.num_prompts,
880
            range_ratio=args.random_range_ratio,
881
882
883
            tokenizer=tokenizer,
        )

884
885
    else:
        raise ValueError(f"Unknown dataset: {args.dataset_name}")
886

887
888
889
890
891
    goodput_config_dict = check_goodput_args(args)

    # Avoid GC processing "static" data - reduce pause times.
    gc.collect()
    gc.freeze()
892

893
894
895
896
    benchmark_result = asyncio.run(
        benchmark(
            backend=backend,
            api_url=api_url,
897
            base_url=base_url,
898
            model_id=model_id,
899
            model_name=model_name,
900
901
            tokenizer=tokenizer,
            input_requests=input_requests,
902
            logprobs=args.logprobs,
903
904
            best_of=args.best_of,
            request_rate=args.request_rate,
905
            burstiness=args.burstiness,
906
            disable_tqdm=args.disable_tqdm,
907
            profile=args.profile,
908
909
910
911
            selected_percentile_metrics=args.percentile_metrics.split(","),
            selected_percentiles=[
                float(p) for p in args.metric_percentiles.split(",")
            ],
912
            ignore_eos=args.ignore_eos,
913
            goodput_config_dict=goodput_config_dict,
914
            max_concurrency=args.max_concurrency,
915
            lora_modules=args.lora_modules,
916
917
918
919
        ))

    # Save config and results to json
    if args.save_result:
920
        result_json: Dict[str, Any] = {}
921
922
923
924
925
926
927
928
929
930

        # Setup
        current_dt = datetime.now().strftime("%Y%m%d-%H%M%S")
        result_json["date"] = current_dt
        result_json["backend"] = backend
        result_json["model_id"] = model_id
        result_json["tokenizer_id"] = tokenizer_id
        result_json["best_of"] = args.best_of
        result_json["num_prompts"] = args.num_prompts

931
932
933
934
935
936
937
938
939
940
941
        # Metadata
        if args.metadata:
            for item in args.metadata:
                if "=" in item:
                    kvstring = item.split("=")
                    result_json[kvstring[0].strip()] = kvstring[1].strip()
                else:
                    raise ValueError(
                        "Invalid metadata format. Please use KEY=VALUE format."
                    )

942
        # Traffic
943
944
        result_json["request_rate"] = (args.request_rate if args.request_rate
                                       < float("inf") else "inf")
945
        result_json["burstiness"] = args.burstiness
946
        result_json["max_concurrency"] = args.max_concurrency
947
948
949
950
951
952

        # Merge with benchmark result
        result_json = {**result_json, **benchmark_result}

        # Save to file
        base_model_id = model_id.split("/")[-1]
953
954
955
        max_concurrency_str = (f"-concurrency{args.max_concurrency}"
                               if args.max_concurrency is not None else "")
        file_name = f"{backend}-{args.request_rate}qps{max_concurrency_str}-{base_model_id}-{current_dt}.json"  #noqa
956
957
        if args.result_filename:
            file_name = args.result_filename
958
959
        if args.result_dir:
            file_name = os.path.join(args.result_dir, file_name)
960
        with open(file_name, "w", encoding='utf-8') as outfile:
961
            json.dump(result_json, outfile)
962
963
964


if __name__ == "__main__":
965
    parser = FlexibleArgumentParser(
966
        description="Benchmark the online serving throughput.")
967
968
969
970
971
972
973
974
975
976
977
978
    parser.add_argument(
        "--backend",
        type=str,
        default="vllm",
        choices=list(ASYNC_REQUEST_FUNCS.keys()),
    )
    parser.add_argument(
        "--base-url",
        type=str,
        default=None,
        help="Server or API base url if not using http host and port.",
    )
979
    parser.add_argument("--host", type=str, default="localhost")
980
    parser.add_argument("--port", type=int, default=8000)
981
982
983
    parser.add_argument(
        "--endpoint",
        type=str,
984
        default="/v1/completions",
985
986
        help="API endpoint.",
    )
987
988
989
990
991
992
993
994
995
996
997
    parser.add_argument(
        "--dataset",
        type=str,
        default=None,
        help="Path to the ShareGPT dataset, will be deprecated in the "
        "next release.",
    )
    parser.add_argument(
        "--dataset-name",
        type=str,
        default="sharegpt",
998
        choices=["sharegpt", "sonnet", "random", "hf"],
999
1000
1001
        help="Name of the dataset to benchmark on.",
    )
    parser.add_argument("--dataset-path",
1002
                        type=str,
1003
                        default=None,
1004
1005
                        help="Path to the sharegpt/sonnet dataset. "
                        "Or the huggingface dataset ID if using HF dataset.")
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
    parser.add_argument(
        "--max-concurrency",
        type=int,
        default=None,
        help="Maximum number of concurrent requests. This can be used "
        "to help simulate an environment where a higher level component "
        "is enforcing a maximum number of concurrent requests. While the "
        "--request-rate argument controls the rate at which requests are "
        "initiated, this argument will control how many are actually allowed "
        "to execute at a time. This means that when used in combination, the "
        "actual request rate may be lower than specified with --request-rate, "
        "if the server is not processing requests fast enough to keep up.")

1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
    parser.add_argument(
        "--model",
        type=str,
        required=True,
        help="Name of the model.",
    )
    parser.add_argument(
        "--tokenizer",
        type=str,
        help=
1029
        "Name or path of the tokenizer, if not using the default tokenizer.",  # noqa: E501
1030
1031
1032
1033
1034
1035
1036
1037
    )
    parser.add_argument(
        "--best-of",
        type=int,
        default=1,
        help="Generates `best_of` sequences per prompt and "
        "returns the best one.",
    )
1038
    parser.add_argument("--use-beam-search", action="store_true")
1039
1040
1041
1042
1043
1044
    parser.add_argument(
        "--num-prompts",
        type=int,
        default=1000,
        help="Number of prompts to process.",
    )
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
    parser.add_argument(
        "--logprobs",
        type=int,
        default=None,
        help=("Number of logprobs-per-token to compute & return as part of "
              "the request. If unspecified, then either (1) if beam search "
              "is disabled, no logprobs are computed & a single dummy "
              "logprob is returned for each token; or (2) if beam search "
              "is enabled 1 logprob per token is computed"),
    )
1055
1056
1057
1058
1059
1060
    parser.add_argument(
        "--request-rate",
        type=float,
        default=float("inf"),
        help="Number of requests per second. If this is inf, "
        "then all the requests are sent at time 0. "
1061
1062
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
        "Otherwise, we use Poisson process or gamma distribution "
        "to synthesize the request arrival times.",
    )
    parser.add_argument(
        "--burstiness",
        type=float,
        default=1.0,
        help="Burstiness factor of the request generation. "
        "Only take effect when request_rate is not inf. "
        "Default value is 1, which follows Poisson process. "
        "Otherwise, the request intervals follow a gamma distribution. "
        "A lower burstiness value (0 < burstiness < 1) results in more "
        "bursty requests. A higher burstiness value (burstiness > 1) "
        "results in a more uniform arrival of requests.",
1075
    )
1076
    parser.add_argument("--seed", type=int, default=0)
1077
1078
1079
1080
1081
1082
1083
1084
    parser.add_argument(
        "--trust-remote-code",
        action="store_true",
        help="Trust remote code from huggingface",
    )
    parser.add_argument(
        "--disable-tqdm",
        action="store_true",
1085
        help="Specify to disable tqdm progress bar.",
1086
1087
    )
    parser.add_argument(
1088
1089
1090
1091
1092
1093
        "--profile",
        action="store_true",
        help="Use Torch Profiler. The endpoint must be launched with "
        "VLLM_TORCH_PROFILER_DIR to enable profiler.",
    )
    parser.add_argument(
1094
1095
1096
1097
        "--save-result",
        action="store_true",
        help="Specify to save benchmark results to a json file",
    )
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
    parser.add_argument(
        "--metadata",
        metavar="KEY=VALUE",
        nargs="*",
        help="Key-value pairs (e.g, --metadata version=0.3.3 tp=1) "
        "for metadata of this run to be saved in the result JSON file "
        "for record keeping purposes.",
    )
    parser.add_argument(
        "--result-dir",
        type=str,
        default=None,
        help="Specify directory to save benchmark json results."
        "If not specified, results are saved in the current directory.",
    )
1113
1114
1115
1116
1117
1118
1119
1120
1121
    parser.add_argument(
        "--result-filename",
        type=str,
        default=None,
        help="Specify the filename to save benchmark json results."
        "If not specified, results will be saved in "
        "{backend}-{args.request_rate}qps-{base_model_id}-{current_dt}.json"
        " format.",
    )
1122
1123
1124
1125
1126
    parser.add_argument(
        "--ignore-eos",
        action="store_true",
        help="Set ignore_eos flag when sending the benchmark request."
        "Warning: ignore_eos is not supported in deepspeed_mii and tgi.")
1127
1128
1129
1130
1131
1132
1133
1134
1135
1136
1137
1138
1139
1140
1141
1142
1143
    parser.add_argument(
        "--percentile-metrics",
        type=str,
        default="ttft,tpot,itl",
        help="Comma-seperated list of selected metrics to report percentils. "
        "This argument specifies the metrics to report percentiles. "
        "Allowed metric names are \"ttft\", \"tpot\", \"itl\", \"e2el\". "
        "Default value is \"ttft,tpot,itl\".")
    parser.add_argument(
        "--metric-percentiles",
        type=str,
        default="99",
        help="Comma-seperated list of percentiles for selected metrics. "
        "To report 25-th, 50-th, and 75-th percentiles, use \"25,50,75\". "
        "Default value is \"99\". "
        "Use \"--percentile-metrics\" to select metrics.",
    )
1144
1145
1146
1147
1148
1149
1150
1151
1152
1153
1154
    parser.add_argument(
        "--goodput",
        nargs="+",
        required=False,
        help="Specify service level objectives for goodput as \"KEY:VALUE\" "
        "pairs, where the key is a metric name, and the value is in "
        "milliseconds. Multiple \"KEY:VALUE\" pairs can be provided, "
        "separated by spaces. Allowed request level metric names are "
        "\"ttft\", \"tpot\", \"e2el\". For more context on the definition of "
        "goodput, refer to DistServe paper: https://arxiv.org/pdf/2401.09670 "
        "and the blog: https://hao-ai-lab.github.io/blogs/distserve")
1155

1156
1157
1158
1159
1160
1161
1162
1163
1164
1165
1166
1167
1168
1169
1170
1171
1172
1173
1174
1175
1176
1177
1178
1179
1180
1181
1182
1183
1184
1185
1186
1187
1188
1189
1190
1191
1192
1193
1194
1195
1196
1197
1198
1199
1200
1201
1202
1203
1204
1205
1206
1207
1208
1209
1210
1211
1212
1213
1214
1215
1216
1217
1218
1219
1220
1221
1222
1223
1224
1225
1226
1227
1228
1229
1230
1231
1232
1233
1234
1235
    # group for dataset specific arguments
    sonnet_group = parser.add_argument_group("sonnet dataset options")
    sonnet_group.add_argument(
        "--sonnet-input-len",
        type=int,
        default=550,
        help=
        "Number of input tokens per request, used only for sonnet dataset.",
    )
    sonnet_group.add_argument(
        "--sonnet-output-len",
        type=int,
        default=150,
        help=
        "Number of output tokens per request, used only for sonnet dataset.",
    )
    sonnet_group.add_argument(
        "--sonnet-prefix-len",
        type=int,
        default=200,
        help=
        "Number of prefix tokens per request, used only for sonnet dataset.",
    )

    sharegpt_group = parser.add_argument_group("sharegpt dataset options")
    sharegpt_group.add_argument(
        "--sharegpt-output-len",
        type=int,
        default=None,
        help="Output length for each request. Overrides the output length "
        "from the ShareGPT dataset.")

    random_group = parser.add_argument_group("random dataset options")
    random_group.add_argument(
        "--random-input-len",
        type=int,
        default=1024,
        help=
        "Number of input tokens per request, used only for random sampling.",
    )
    random_group.add_argument(
        "--random-output-len",
        type=int,
        default=128,
        help=
        "Number of output tokens per request, used only for random sampling.",
    )
    random_group.add_argument(
        "--random-range-ratio",
        type=float,
        default=1.0,
        help="Range of sampled ratio of input/output length, "
        "used only for random sampling.",
    )
    random_group.add_argument(
        "--random-prefix-len",
        type=int,
        default=0,
        help="Number of fixed prefix tokens before random "
        " context. The length range of context in a random "
        " request is [random-prefix-len, "
        " random-prefix-len + random-prefix-len * random-range-ratio).")

    hf_group = parser.add_argument_group("hf dataset options")
    hf_group.add_argument("--hf-subset",
                          type=str,
                          default=None,
                          help="Subset of the HF dataset.")
    hf_group.add_argument("--hf-split",
                          type=str,
                          default=None,
                          help="Split of the HF dataset.")
    hf_group.add_argument(
        "--hf-output-len",
        type=int,
        default=None,
        help="Output length for each request. Overrides the output lengths "
        "from the sampled HF dataset.",
    )

1236
1237
1238
1239
1240
1241
1242
1243
1244
1245
    parser.add_argument(
        '--tokenizer-mode',
        type=str,
        default="auto",
        choices=['auto', 'slow', 'mistral'],
        help='The tokenizer mode.\n\n* "auto" will use the '
        'fast tokenizer if available.\n* "slow" will '
        'always use the slow tokenizer. \n* '
        '"mistral" will always use the `mistral_common` tokenizer.')

1246
1247
1248
1249
1250
1251
1252
    parser.add_argument("--served-model-name",
                        type=str,
                        default=None,
                        help="The model name used in the API. "
                        "If not specified, the model name will be the "
                        "same as the ``--model`` argument. ")

1253
1254
1255
1256
1257
1258
1259
    parser.add_argument("--lora-modules",
                        nargs='+',
                        default=None,
                        help="A subset of LoRA module names passed in when "
                        "launching the server. For each request, the "
                        "script chooses a LoRA module at random.")

1260
    args = parser.parse_args()
1261
    main(args)