benchmark_serving.py 46.1 KB
Newer Older
1
r"""Benchmark online serving throughput.
2
3

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

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

On the client side, run:
    python benchmarks/benchmark_serving.py \
        --backend <backend> \
15
16
17
18
19
        --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
20

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

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

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

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

57
58
MILLISECONDS_TO_SECONDS_CONVERSION = 1000

59
60
61
62
63
64
65

@dataclass
class BenchmarkMetrics:
    completed: int
    total_input: int
    total_output: int
    request_throughput: float
66
    request_goodput: float
67
    output_throughput: float
68
    total_token_throughput: float
69
70
    mean_ttft_ms: float
    median_ttft_ms: float
71
    std_ttft_ms: float
72
    percentiles_ttft_ms: List[Tuple[float, float]]
73
74
    mean_tpot_ms: float
    median_tpot_ms: float
75
    std_tpot_ms: float
76
    percentiles_tpot_ms: List[Tuple[float, float]]
77
78
    mean_itl_ms: float
    median_itl_ms: float
79
    std_itl_ms: float
80
81
82
83
84
85
86
87
    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]]
88
89


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

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

108
    # Filter out sequences that are too long or too short
109
    filtered_dataset: List[Tuple[str, int, int]] = []
110
111
112
113
114
115
116
117
118
    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
119
        prompt_len = len(prompt_token_ids)
120
121
        output_len = len(completion_token_ids
                         ) if fixed_output_len is None else fixed_output_len
122
        if prompt_len < 4 or (fixed_output_len is None and output_len < 4):
123
124
125
126
127
            # Prune too short sequences.
            continue
        if prompt_len > 1024 or prompt_len + output_len > 2048:
            # Prune too long sequences.
            continue
128
        filtered_dataset.append((prompt, prompt_len, output_len, None))
129

130
    return filtered_dataset
131
132


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

    # Load the dataset.
146
    with open(dataset_path, encoding='utf-8') as f:
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
        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)

164
165
166
    assert (
        input_len > base_prompt_offset
    ), f"Please set 'args.sonnet-input-len' higher than {base_prompt_offset}."
167
168
169
170
171
172
173
    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
174
    ), f"Please set 'args.sonnet-prefix-len' higher than {base_prompt_offset}."
175
176
177
178
179
180
181
182

    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):
183
184
185
        num_lines_needed = num_input_lines - num_prefix_lines
        sampled_lines = "".join(prefix_lines +
                                random.choices(poem_lines, k=num_lines_needed))
186
187
188
189
190
191
192
193
194
195
196
197

        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(
198
199
200
201
202
            (prompt, prompt_formatted, prompt_len, output_len, None))

    return sampled_requests


203
def sample_vision_arena_requests(
204
205
206
207
208
209
210
211
212
213
214
    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

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

        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(
227
            data["images"][0],
228
229
            Image), ("Input image format must be `PIL.Image.Image`, "
                     f"given {type(data['image'])}.")
230
        image: Image = data["images"][0]
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
        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


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

257
258
259
260
    # 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"
261
262
263
264
        dataset = load_dataset(dataset_path,
                               name=dataset_subset,
                               split=dataset_split,
                               streaming=True)
265
266
267
        dataset = dataset.shuffle(seed=random_seed)
        return sample_vision_arena_requests(dataset, num_requests, tokenizer,
                                            fixed_output_len)
268

269
270
271
272
273
274
    dataset = load_dataset(dataset_path,
                           name=dataset_subset,
                           split=dataset_split,
                           streaming=True)
    assert "conversations" in dataset.features, (
        "HF Dataset must have 'conversations' column.")
275
276
    filter_func = lambda x: len(x["conversations"]) >= 2
    filtered_dataset = dataset.shuffle(seed=random_seed).filter(filter_func)
277
278
279
280
281
282
283
284
285
286
287
288
289
290
    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
291
        if fixed_output_len is None and (prompt_len < 4 or output_len < 4):
292
293
            # Prune too short sequences.
            continue
294
295
        if fixed_output_len is None and \
            (prompt_len > 1024 or prompt_len + output_len > 2048):
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
            # 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}"
                },
            }
312
313
314
315
316
317
318
319
320
321
322
323
324
        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
                },
            }
325
326
327
328
        else:
            mm_content = None

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

    return sampled_requests


333
def sample_random_requests(
334
335
336
337
338
339
340
341
342
343
    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()
344
345
346
347
348
349
350
351
352
353
354
355
356

    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 = []
357
    for i in range(num_prompts):
358
359
        prompt = tokenizer.decode(prefix_token_ids +
                                  [(offsets[i] + i + j) % tokenizer.vocab_size
360
                                   for j in range(input_lens[i])])
361

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

    return input_requests


368
369
370
async def get_request(
    input_requests: List[Tuple[str, int, int]],
    request_rate: float,
371
    burstiness: float = 1.0,
372
) -> AsyncGenerator[Tuple[str, int, int], None]:
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
    """
    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.
    """
391
    input_requests = iter(input_requests)
392
393
394
395
396
397

    # 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)

398
399
400
401
402
403
    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
404

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


412
413
414
415
416
def calculate_metrics(
    input_requests: List[Tuple[str, int, int]],
    outputs: List[RequestFuncOutput],
    dur_s: float,
    tokenizer: PreTrainedTokenizerBase,
417
418
    selected_percentile_metrics: List[str],
    selected_percentiles: List[float],
419
    goodput_config_dict: Dict[str, float],
420
) -> Tuple[BenchmarkMetrics, List[int]]:
421
    actual_output_lens: List[int] = []
422
423
    total_input = 0
    completed = 0
424
    good_completed = 0
425
426
    itls: List[float] = []
    tpots: List[float] = []
427
    all_tpots: List[float] = []
428
    ttfts: List[float] = []
429
    e2els: List[float] = []
430
431
    for i in range(len(outputs)):
        if outputs[i].success:
432
433
434
435
436
437
438
439
440
441
442
            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)
443
            actual_output_lens.append(output_len)
444
            total_input += input_requests[i][1]
445
            tpot = 0
446
            if output_len > 1:
447
448
                latency_minus_ttft = outputs[i].latency - outputs[i].ttft
                tpot = latency_minus_ttft / (output_len - 1)
449
450
451
                tpots.append(tpot)
            # Note: if output_len <= 1, we regard tpot as 0 for goodput
            all_tpots.append(tpot)
452
            itls += outputs[i].itl
453
            ttfts.append(outputs[i].ttft)
454
            e2els.append(outputs[i].latency)
455
            completed += 1
456
457
        else:
            actual_output_lens.append(0)
458

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

463
        if "ttft" in goodput_config_dict:
464
            valid_metrics.append(ttfts)
465
            slo_values.append(goodput_config_dict["ttft"] /
466
                              MILLISECONDS_TO_SECONDS_CONVERSION)
467
        if "tpot" in goodput_config_dict:
468
            valid_metrics.append(all_tpots)
469
            slo_values.append(goodput_config_dict["tpot"] /
470
                              MILLISECONDS_TO_SECONDS_CONVERSION)
471
        if "e2el" in goodput_config_dict:
472
            valid_metrics.append(e2els)
473
            slo_values.append(goodput_config_dict["e2el"] /
474
475
476
477
478
479
480
                              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

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

517
    return metrics, actual_output_lens
518

519
520
521
522

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

545
    print("Starting initial single prompt test run...")
546
547
548
549
550
551
    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.")
552
553
    test_input = RequestFuncInput(
        model=model_id,
554
        model_name=model_name,
555
556
557
558
        prompt=test_prompt,
        api_url=api_url,
        prompt_len=test_prompt_len,
        output_len=test_output_len,
559
        logprobs=logprobs,
560
        best_of=best_of,
561
        multi_modal_content=test_mm_content,
562
        ignore_eos=ignore_eos,
563
564
565
566
567
568
569
570
    )
    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...")
571
572
573

    if profile:
        print("Starting profiler...")
574
        profile_input = RequestFuncInput(model=model_id,
575
                                         model_name=model_name,
576
577
578
579
580
581
582
583
                                         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)
584
585
586
587
        profile_output = await request_func(request_func_input=profile_input)
        if profile_output.success:
            print("Profiler started")

588
589
590
591
592
    if burstiness == 1.0:
        distribution = "Poisson process"
    else:
        distribution = "Gamma distribution"

593
    print(f"Traffic request rate: {request_rate}")
594
    print(f"Burstiness factor: {burstiness} ({distribution})")
595
    print(f"Maximum request concurrency: {max_concurrency}")
596

597
598
    pbar = None if disable_tqdm else tqdm(total=len(input_requests))

599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
    # 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)

614
    benchmark_start_time = time.perf_counter()
615
    tasks: List[asyncio.Task] = []
616
    async for request in get_request(input_requests, request_rate, burstiness):
617
        prompt, prompt_len, output_len, mm_content = request
618
        request_func_input = RequestFuncInput(model=model_id,
619
                                              model_name=model_name,
620
621
622
623
624
625
626
627
                                              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)
628
629
        tasks.append(
            asyncio.create_task(
630
631
                limited_request_func(request_func_input=request_func_input,
                                     pbar=pbar)))
632
    outputs: List[RequestFuncOutput] = await asyncio.gather(*tasks)
633

634
635
636
637
638
639
640
641
    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,
642
            logprobs=logprobs,
643
644
645
646
647
648
            best_of=best_of,
        )
        profile_output = await request_func(request_func_input=profile_input)
        if profile_output.success:
            print("Profiler stopped")

649
    if pbar is not None:
650
651
652
653
        pbar.close()

    benchmark_duration = time.perf_counter() - benchmark_start_time

654
    metrics, actual_output_lens = calculate_metrics(
655
656
657
658
        input_requests=input_requests,
        outputs=outputs,
        dur_s=benchmark_duration,
        tokenizer=tokenizer,
659
660
        selected_percentile_metrics=selected_percentile_metrics,
        selected_percentiles=selected_percentiles,
661
        goodput_config_dict=goodput_config_dict,
662
663
    )

664
665
666
667
668
669
670
671
672
    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))
673
    if goodput_config_dict:
674
675
        print("{:<40} {:<10.2f}".format("Request goodput (req/s):",
                                        metrics.request_goodput))
676
677
    print("{:<40} {:<10.2f}".format("Output token throughput (tok/s):",
                                    metrics.output_throughput))
678
679
    print("{:<40} {:<10.2f}".format("Total Token throughput (tok/s):",
                                    metrics.total_token_throughput))
680
681
682
683
684
685

    result = {
        "duration": benchmark_duration,
        "completed": metrics.completed,
        "total_input_tokens": metrics.total_input,
        "total_output_tokens": metrics.total_output,
686
        "request_throughput": metrics.request_throughput,
687
        "request_goodput:":
688
        metrics.request_goodput if goodput_config_dict else None,
689
        "output_throughput": metrics.output_throughput,
690
        "total_token_throughput": metrics.total_token_throughput,
691
692
693
694
695
696
        "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],
697
    }
698
699
700
701
702
703
704
705
706

    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,
    ):
707
        # This function prints and adds statistics of the specified
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
        # 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)

739
    return result
740
741


742
743
def check_goodput_args(args):
    # Check and parse goodput arguments
744
    goodput_config_dict = {}
745
746
    VALID_NAMES = ["ttft", "tpot", "e2el"]
    if args.goodput:
747
748
        goodput_config_dict = parse_goodput(args.goodput)
        for slo_name, slo_val in goodput_config_dict.items():
749
750
751
752
753
754
755
756
757
758
            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.")
759
    return goodput_config_dict
760
761
762


def parse_goodput(slo_pairs):
763
    goodput_config_dict = {}
764
765
766
    try:
        for slo_pair in slo_pairs:
            slo_name, slo_val = slo_pair.split(":")
767
            goodput_config_dict[slo_name] = float(slo_val)
768
769
770
771
772
773
    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
774
    return goodput_config_dict
775
776


777
778
779
780
781
def main(args: argparse.Namespace):
    print(args)
    random.seed(args.seed)
    np.random.seed(args.seed)

782
783
    backend = args.backend
    model_id = args.model
784
    model_name = args.served_model_name
785
    tokenizer_id = args.tokenizer if args.tokenizer is not None else args.model
786
    tokenizer_mode = args.tokenizer_mode
787
788
789

    if args.base_url is not None:
        api_url = f"{args.base_url}{args.endpoint}"
790
        base_url = f"{args.base_url}"
791
792
    else:
        api_url = f"http://{args.host}:{args.port}{args.endpoint}"
793
        base_url = f"http://{args.host}:{args.port}"
794
795

    tokenizer = get_tokenizer(tokenizer_id,
796
                              tokenizer_mode=tokenizer_mode,
797
                              trust_remote_code=args.trust_remote_code)
798
799
800
801
802
803
804
805
806
807
808

    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,
809
            fixed_output_len=args.sharegpt_output_len,
810
811
812
813
814
815
816
        )

    elif args.dataset_name == "sharegpt":
        input_requests = sample_sharegpt_requests(
            dataset_path=args.dataset_path,
            num_requests=args.num_prompts,
            tokenizer=tokenizer,
817
            fixed_output_len=args.sharegpt_output_len,
818
819
820
821
822
823
824
825
        )

    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,
826
827
828
                input_len=args.sonnet_input_len,
                output_len=args.sonnet_output_len,
                prefix_len=args.sonnet_prefix_len,
829
830
                tokenizer=tokenizer,
            )
831
            input_requests = [(prompt, prompt_len, output_len, None)
832
                              for prompt, prompt_formatted, prompt_len,
833
                              output_len, _ in input_requests]
834
835
836
837
838
839
840
        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,
841
842
843
                input_len=args.sonnet_input_len,
                output_len=args.sonnet_output_len,
                prefix_len=args.sonnet_prefix_len,
844
845
                tokenizer=tokenizer,
            )
846
            input_requests = [(prompt_formatted, prompt_len, output_len, None)
847
                              for prompt, prompt_formatted, prompt_len,
848
                              output_len, _ in input_requests]
849

850
851
852
853
854
855
856
    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,
857
            random_seed=args.seed,
858
859
860
            fixed_output_len=args.hf_output_len,
        )

861
862
    elif args.dataset_name == "random":
        input_requests = sample_random_requests(
863
            prefix_len=args.random_prefix_len,
864
865
            input_len=args.random_input_len,
            output_len=args.random_output_len,
866
            num_prompts=args.num_prompts,
867
            range_ratio=args.random_range_ratio,
868
869
870
            tokenizer=tokenizer,
        )

871
872
    else:
        raise ValueError(f"Unknown dataset: {args.dataset_name}")
873

874
875
876
877
878
    goodput_config_dict = check_goodput_args(args)

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

880
881
882
883
    benchmark_result = asyncio.run(
        benchmark(
            backend=backend,
            api_url=api_url,
884
            base_url=base_url,
885
            model_id=model_id,
886
            model_name=model_name,
887
888
            tokenizer=tokenizer,
            input_requests=input_requests,
889
            logprobs=args.logprobs,
890
891
            best_of=args.best_of,
            request_rate=args.request_rate,
892
            burstiness=args.burstiness,
893
            disable_tqdm=args.disable_tqdm,
894
            profile=args.profile,
895
896
897
898
            selected_percentile_metrics=args.percentile_metrics.split(","),
            selected_percentiles=[
                float(p) for p in args.metric_percentiles.split(",")
            ],
899
            ignore_eos=args.ignore_eos,
900
            goodput_config_dict=goodput_config_dict,
901
            max_concurrency=args.max_concurrency,
902
903
904
905
        ))

    # Save config and results to json
    if args.save_result:
906
        result_json: Dict[str, Any] = {}
907
908
909
910
911
912
913
914
915
916

        # 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

917
918
919
920
921
922
923
924
925
926
927
        # 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."
                    )

928
929
930
        # Traffic
        result_json["request_rate"] = (
            args.request_rate if args.request_rate < float("inf") else "inf")
931
        result_json["burstiness"] = args.burstiness
932
        result_json["max_concurrency"] = args.max_concurrency
933
934
935
936
937
938

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

        # Save to file
        base_model_id = model_id.split("/")[-1]
939
940
941
        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
942
943
        if args.result_filename:
            file_name = args.result_filename
944
945
        if args.result_dir:
            file_name = os.path.join(args.result_dir, file_name)
946
        with open(file_name, "w", encoding='utf-8') as outfile:
947
            json.dump(result_json, outfile)
948
949
950


if __name__ == "__main__":
951
    parser = FlexibleArgumentParser(
952
        description="Benchmark the online serving throughput.")
953
954
955
956
957
958
959
960
961
962
963
964
    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.",
    )
965
    parser.add_argument("--host", type=str, default="localhost")
966
    parser.add_argument("--port", type=int, default=8000)
967
968
969
    parser.add_argument(
        "--endpoint",
        type=str,
970
        default="/v1/completions",
971
972
        help="API endpoint.",
    )
973
974
975
976
977
978
979
980
981
982
983
    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",
984
        choices=["sharegpt", "sonnet", "random", "hf"],
985
986
987
        help="Name of the dataset to benchmark on.",
    )
    parser.add_argument("--dataset-path",
988
                        type=str,
989
                        default=None,
990
991
                        help="Path to the sharegpt/sonnet dataset. "
                        "Or the huggingface dataset ID if using HF dataset.")
992
993
994
995
996
997
998
999
1000
1001
1002
1003
1004
    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.")

1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
    parser.add_argument(
        "--model",
        type=str,
        required=True,
        help="Name of the model.",
    )
    parser.add_argument(
        "--tokenizer",
        type=str,
        help=
1015
        "Name or path of the tokenizer, if not using the default tokenizer.",  # noqa: E501
1016
1017
1018
1019
1020
1021
1022
1023
    )
    parser.add_argument(
        "--best-of",
        type=int,
        default=1,
        help="Generates `best_of` sequences per prompt and "
        "returns the best one.",
    )
1024
    parser.add_argument("--use-beam-search", action="store_true")
1025
1026
1027
1028
1029
1030
    parser.add_argument(
        "--num-prompts",
        type=int,
        default=1000,
        help="Number of prompts to process.",
    )
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
    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"),
    )
1041
1042
1043
1044
1045
1046
    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. "
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
        "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.",
1061
    )
1062
    parser.add_argument("--seed", type=int, default=0)
1063
1064
1065
1066
1067
1068
1069
1070
    parser.add_argument(
        "--trust-remote-code",
        action="store_true",
        help="Trust remote code from huggingface",
    )
    parser.add_argument(
        "--disable-tqdm",
        action="store_true",
1071
        help="Specify to disable tqdm progress bar.",
1072
1073
    )
    parser.add_argument(
1074
1075
1076
1077
1078
1079
        "--profile",
        action="store_true",
        help="Use Torch Profiler. The endpoint must be launched with "
        "VLLM_TORCH_PROFILER_DIR to enable profiler.",
    )
    parser.add_argument(
1080
1081
1082
1083
        "--save-result",
        action="store_true",
        help="Specify to save benchmark results to a json file",
    )
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
    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.",
    )
1099
1100
1101
1102
1103
1104
1105
1106
1107
    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.",
    )
1108
1109
1110
1111
1112
    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.")
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129
    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.",
    )
1130
1131
1132
1133
1134
1135
1136
1137
1138
1139
1140
    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")
1141

1142
1143
1144
1145
1146
1147
1148
1149
1150
1151
1152
1153
1154
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
    # 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.",
    )

1222
1223
1224
1225
1226
1227
1228
1229
1230
1231
    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.')

1232
1233
1234
1235
1236
1237
1238
    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. ")

1239
    args = parser.parse_args()
1240
    main(args)