Ascend NPU 성능 테스트

1. 네트워크 문제가 있다면 export HF_ENDPOINT=https://hf-mirror.com를 설정해 국내 미러를 사용하세요.
2. 다운로드가 여전히 실패하면 데이터셋 파일 ShareGPT_V3_unfiltered_cleaned_split.json을 로컬에 직접 다운로드해 서버에 업로드한 뒤, --dataset-path로 파일 디렉토리를 지정해 오프라인으로 실행하세요.

입출력 길이를 고정하려면 --random-range-ratio 1을(일관된 비교에 권장), 균등 분포를 원하면 0(기본값)을 설정하세요. 요청 속도를 제어하려면 --request-rate를 추가하세요. 모든 백엔드, 데이터셋, 고급 옵션은 전체 Bench Serving 가이드를 참고하세요.

출력 예시 (참고용일 뿐 — 실제 결과는 하드웨어와 구성에 따라 달라져요):

============ Serving Benchmark Result ============
Backend:                                 sglang-oai
Traffic request rate:                    inf
Max request concurrency:                 32
Successful requests:                     100
Benchmark duration (s):                  47.51
Total input tokens:                      102400
Total input text tokens:                 102400
Total generated tokens:                  51200
Total generated tokens (retokenized):    51195
Request throughput (req/s):              2.10
Input token throughput (tok/s):          2155.35
Output token throughput (tok/s):         1077.68
Peak output token throughput (tok/s):    1587.00
Peak concurrent requests:                64
Total token throughput (tok/s):          3233.03
Concurrency:                             26.93
----------------End-to-End Latency----------------
Mean E2E Latency (ms):                   12793.49
Median E2E Latency (ms):                 12940.17
P90 E2E Latency (ms):                    13049.86
P99 E2E Latency (ms):                    13051.61
---------------Time to First Token----------------
Mean TTFT (ms):                          1423.99
Median TTFT (ms):                        1489.29
P99 TTFT (ms):                           2325.56
-----Time per Output Token (excl. 1st token)------
Mean TPOT (ms):                          22.25
Median TPOT (ms):                        22.22
P99 TPOT (ms):                           25.08
---------------Inter-Token Latency----------------
Mean ITL (ms):                           22.26
Median ITL (ms):                         20.74
P95 ITL (ms):                            21.40
P99 ITL (ms):                            23.62
Max ITL (ms):                            2229.30
==================================================

SGLang 서빙 벤치마크 결과 — 전체 참고 자료

출력 형식은 bench_serving.py에 하드코딩되어 있어요. 열 너비, 정렬, 소수점 정밀도를 포함한 모든 형식 결정은 소스에 정적으로 정의되어 있고 커맨드라인 인자로는 바꿀 수 없어요.

테스트 구성 (Test Configuration)

<tr>
  <td><code>Traffic request rate</code></td>
  <td>초당 요청 생성 속도 (req/s). <code>inf</code>는 최대 속도(동시성 제한)를 의미해요. <code>trace</code>는 trace 타임스탬프 모드를 나타냅니다. 고정값은 일정한 도착 간격을 강제해요.</td>
</tr>

<tr>
  <td><code>Max request concurrency</code></td>
  <td>클라이언트 측의 최대 동시 요청 수. 미지정 시 <code>not set</code>로 표시돼요.</td>
</tr>

핵심 통계 및 처리량 지표 (Core Statistics & Throughput Metrics)

종단 간 지연 시간 (End-to-End Latency, E2E)

첫 토큰까지의 시간 (Time to First Token, TTFT)

출력 토큰당 시간 (Time per Output Token, TPOT) — 첫 토큰 제외

공식: (E2E Latency - TTFT) / (Number of output tokens - 1)

토큰 간 지연 시간 (Inter-Token Latency, ITL)

3. 온라인 서비스: 멀티모달 모델

비전-언어 작업용으로 Qwen/Qwen2.5-VL-7B-Instruct를 테스트해요.

이 섹션의 어떤 벤치마크를 실행하기 전에 SGLang 멀티모달 서버가 http://127.0.0.1:30000에서 실행 중인지 확인하세요. SGLang 서버 시작하기를 참고하고 실행 명령은 Multimodal 탭을 사용하세요.

일관되고 반복 가능한 결과를 위해 --random-range-ratio 1로 입출력 길이를 고정하거나, 균등 분포를 위해 0(기본값)을 설정하세요.

3.1 Evalscope 사용하기

전제 조건: Evalscope 설치 후 가상 환경 활성화(source .evalscope_venv/bin/activate). SGLang 멀티모달 서버가 http://127.0.0.1:30000에서 실행 중.

Evalscope의 perf 도구는 OpenAI 호환 /v1/chat/completions 엔드포인트를 사용해요. 이미지 생성과 함께 랜덤 멀티모달 데이터를 쓰려면 --dataset random_vl을 사용하세요:

evalscope perf \
  --parallel 10 \
  --number 20 \
  --model Qwen/Qwen2.5-VL-7B-Instruct \
  --url http://127.0.0.1:30000/v1/chat/completions \
  --api openai \
  --dataset random_vl \
  --min-tokens 1024 \
  --max-tokens 1024 \
  --prefix-length 0 \
  --min-prompt-length 1024 \
  --max-prompt-length 1024 \
  --image-width 512 \
  --image-height 512 \
  --image-format RGB \
  --image-num 1 \
  --tokenizer-path Qwen/Qwen2.5-VL-7B-Instruct \
  --extra-args '{"ignore_eos": true}'

모델이 이미 다운로드되어 있다면 --tokenizer-path를 모델 id 대신 로컬 모델 경로로 지정할 수 있어요.

3.2 AISBench 사용하기

전제 조건: AISBench 설치 후 가상 환경 활성화(source .aisbench_venv/bin/activate). 모든 명령어는 benchmark/ 디렉토리에서 실행. SGLang 멀티모달 서버가 http://127.0.0.1:30000에서 실행 중. AISBench에는 내장 멀티모달 데이터셋이 없어요 — 직접 제공해야 합니다.

먼저 ais_bench/benchmark/configs/models/vllm_api/vllm_api_stream_chat.py를 편집해 비전 모델을 설정하세요:

from ais_bench.benchmark.models import VLLMCustomAPIChat
from ais_bench.benchmark.utils.postprocess.model_postprocessors import extract_non_reasoning_content

models = [
    dict(
        attr="service",
        type=VLLMCustomAPIChat,
        abbr="vllm-api-stream-chat",
        path="Qwen/Qwen2.5-VL-7B-Instruct",
        model="Qwen/Qwen2.5-VL-7B-Instruct",
        stream=True,
        request_rate=0,
        use_timestamp=False,
        retry=2,
        api_key="",
        host_ip="127.0.0.1",
        host_port=30000,
        url="",
        max_out_len=256,
        batch_size=16,
        trust_remote_code=False,
        generation_kwargs=dict(
            temperature=0.01,
            ignore_eos=True,
        ),
        pred_postprocessor=dict(type=extract_non_reasoning_content),
    )
]

모델이 이미 다운로드되어 있다면 path를 모델 id 대신 로컬 모델 경로로 지정하세요.

다음으로 mmstar 같은 멀티모달 데이터셋을 다운로드하세요:

# Download the mmstar dataset (from within the benchmark/ directory)
cd ais_bench/datasets
mkdir mmstar
cd mmstar
wget https://www.modelscope.cn/datasets/evalscope/MMStar/resolve/master/MMStar.tsv

성능 테스트를 실행하세요:

ais_bench --models vllm_api_stream_chat --datasets mmstar_gen -m perf

출력 예시 (참고용일 뿐 — 실제 결과는 하드웨어와 구성에 따라 달라져요):

╒══════════════════════════╤═════════╤═════════════════╤════════════════╤═════════════════╤═════════════════╤═════════════════╤═════════════════╤═════════════════╤══════╕
│ Performance Parameters   │ Stage   │ Average         │ Min            │ Max             │ Median          │ P75             │ P90             │ P99             │  N   │
╞══════════════════════════╪═════════╪═════════════════╪════════════════╪═════════════════╪═════════════════╪═════════════════╪═════════════════╪═════════════════╪══════╡
│ E2EL                     │ total   │ 6190.9 ms       │ 5071.4 ms      │ 8464.8 ms       │ 6126.6 ms       │ 6475.2 ms       │ 6833.5 ms       │ 7897.9 ms       │ 1500 │
├──────────────────────────┼─────────┼─────────────────┼────────────────┼─────────────────┼─────────────────┼─────────────────┼─────────────────┼─────────────────┼──────┤
│ TTFT                     │ total   │ 693.3 ms        │ 96.0 ms        │ 2161.5 ms       │ 747.4 ms        │ 870.9 ms        │ 1032.3 ms       │ 1620.8 ms       │ 1500 │
├──────────────────────────┼─────────┼─────────────────┼────────────────┼─────────────────┼─────────────────┼─────────────────┼─────────────────┼─────────────────┼──────┤
│ TPOT                     │ total   │ 21.6 ms         │ 17.8 ms        │ 32.1 ms         │ 21.3 ms         │ 23.1 ms         │ 24.5 ms         │ 29.1 ms         │ 1500 │
├──────────────────────────┼─────────┼─────────────────┼────────────────┼─────────────────┼─────────────────┼─────────────────┼─────────────────┼─────────────────┼──────┤
│ ITL                      │ total   │ 25.5 ms         │ 0.0 ms         │ 1951.1 ms       │ 18.8 ms         │ 19.7 ms         │ 37.3 ms         │ 121.8 ms        │ 1500 │
├──────────────────────────┼─────────┼─────────────────┼────────────────┼─────────────────┼─────────────────┼─────────────────┼─────────────────┼─────────────────┼──────┤
│ InputTokens              │ total   │ 0.0             │ 0.0            │ 0.0             │ 0.0             │ 0.0             │ 0.0             │ 0.0             │ 1500 │
├──────────────────────────┼─────────┼─────────────────┼────────────────┼─────────────────┼─────────────────┼─────────────────┼─────────────────┼─────────────────┼──────┤
│ OutputTokens             │ total   │ 256.0           │ 256.0          │ 256.0           │ 256.0           │ 256.0           │ 256.0           │ 256.0           │ 1500 │
├──────────────────────────┼─────────┼─────────────────┼────────────────┼─────────────────┼─────────────────┼─────────────────┼─────────────────┼─────────────────┼──────┤
│ OutputTokenThroughput    │ total   │ 41.6779 token/s │ 30.243 token/s │ 50.4791 token/s │ 41.7847 token/s │ 44.6424 token/s │ 45.6484 token/s │ 46.0932 token/s │ 1500 │
╘══════════════════════════╧═════════╧═════════════════╧════════════════╧═════════════════╧═════════════════╧═════════════════╧═════════════════╧═════════════════╧══════╛
╒═════════════════════════╤═════════╤══════════════════╕
│ Common Metric           │ Stage   │ Value            │
╞═════════════════════════╪═════════╪══════════════════╡
│ Benchmark Duration      │ total   │ 582099.6816 ms   │
├─────────────────────────┼─────────┼──────────────────┤
│ Total Requests          │ total   │ 1500             │
├─────────────────────────┼─────────┼──────────────────┤
│ Failed Requests         │ total   │ 0                │
├─────────────────────────┼─────────┼──────────────────┤
│ Success Requests        │ total   │ 1500             │
├─────────────────────────┼─────────┼──────────────────┤
│ Concurrency             │ total   │ 15.9532          │
├─────────────────────────┼─────────┼──────────────────┤
│ Max Concurrency         │ total   │ 16               │
├─────────────────────────┼─────────┼──────────────────┤
│ Request Throughput      │ total   │ 2.5769 req/s     │
├─────────────────────────┼─────────┼──────────────────┤
│ Total Input Tokens      │ total   │ 0                │
├─────────────────────────┼─────────┼──────────────────┤
│ Total Generated Tokens  │ total   │ 384000           │
├─────────────────────────┼─────────┼──────────────────┤
│ Input Token Throughput  │ total   │ 0.0 token/s      │
├─────────────────────────┼─────────┼──────────────────┤
│ Output Token Throughput │ total   │ 659.6808 token/s │
├─────────────────────────┼─────────┼──────────────────┤
│ Total Token Throughput  │ total   │ 659.6808 token/s │
╘═════════════════════════╧═════════╧══════════════════╛

자세한 내용은 AISBench 문서를 참고하세요.

3.3 bench_serving 사용하기 (이미지 데이터셋)

이미지 데이터셋에는 --dataset-name image를 설정하세요. bench_serving이 이미지 입력이 포함된 랜덤 프롬프트를 생성해요. 벤치마크를 실행하기 전에 서버가 http://127.0.0.1:30000에서 실행 중인지 확인하세요.

이미지 관련 플래그 전체 목록은 Bench Serving 가이드를 참고하세요.

python -m sglang.bench_serving \
  --backend sglang \
  --base-url http://127.0.0.1:30000 \
  --model Qwen/Qwen2.5-VL-7B-Instruct \
  --dataset-name image \
  --random-input-len 1024 \
  --random-output-len 512 \
  --random-range-ratio 1 \
  --num-prompts 32 \
  --max-concurrency 16 \
  --image-count 1 \
  --image-resolution 720p

출력 예시 (참고용일 뿐 — 실제 결과는 하드웨어와 구성에 따라 달라져요):

============ Serving Benchmark Result ============
Backend:                                 sglang
Traffic request rate:                    inf
Max request concurrency:                 16
Successful requests:                     32
Benchmark duration (s):                  51.74
Total input tokens:                      73464
Total input text tokens:                 35128
Total input vision tokens:               38336
Total generated tokens:                  16384
Total generated tokens (retokenized):    9300
Request throughput (req/s):              0.62
Input token throughput (tok/s):          1419.96
Output token throughput (tok/s):         316.68
Peak output token throughput (tok/s):    800.00
Peak concurrent requests:                32
Total token throughput (tok/s):          1736.64
Concurrency:                             15.98
----------------End-to-End Latency----------------
Mean E2E Latency (ms):                   25841.84
Median E2E Latency (ms):                 25842.85
P90 E2E Latency (ms):                    26296.42
P99 E2E Latency (ms):                    26303.13
---------------Time to First Token----------------
Mean TTFT (ms):                          12211.59
Median TTFT (ms):                        14405.77
P99 TTFT (ms):                           15837.60
-----Time per Output Token (excl. 1st token)------
Mean TPOT (ms):                          26.67
Median TPOT (ms):                        21.75
P99 TPOT (ms):                           41.89
---------------Inter-Token Latency----------------
Mean ITL (ms):                           26.67
Median ITL (ms):                         20.34
P95 ITL (ms):                            20.85
P99 ITL (ms):                            21.70
Max ITL (ms):                            11309.91
==================================================

4. 온라인 서비스: 임베딩 모델

임베딩 API 엔드포인트에서 Qwen/Qwen3-Embedding-8B를 테스트해요.

이 섹션의 어떤 벤치마크를 실행하기 전에 SGLang 임베딩 서버가 --is-embedding과 함께 http://127.0.0.1:30000에서 실행 중인지 확인하세요. SGLang 서버 시작하기를 참고하고 실행 명령은 Embedding 탭을 사용하세요. AISBench는 임베딩 엔드포인트를 지원하지 않아요 — bench_serving이나 Evalscope를 사용하세요.

4.1 Evalscope 사용하기

전제 조건: Evalscope 설치 후 가상 환경 활성화(source .evalscope_venv/bin/activate). SGLang 임베딩 서버가 --is-embedding과 함께 http://127.0.0.1:30000에서 실행 중.

Evalscope는 임베딩 평가를 지원해요. 임베딩 API를 직접 성능 테스트하려면:

evalscope perf \
  --parallel 10 \
  --number 20 \
  --model Qwen/Qwen3-Embedding-8B \
  --url http://127.0.0.1:30000/v1/embeddings \
  --api openai_embedding \
  --dataset random_embedding \
  --min-prompt-length 1024 \
  --max-prompt-length 1024 \
  --tokenizer-path Qwen/Qwen3-Embedding-8B

모델이 이미 다운로드되어 있다면 --tokenizer-path를 모델 id 대신 로컬 모델 경로로 지정할 수 있어요.

Evalscope의 임베딩 성능 테스트 지원은 버전에 따라 다를 수 있어요. perf 명령이 임베딩 엔드포인트를 받아들이지 않으면 기본 옵션으로 bench_serving + --backend sglang-embedding을 사용하세요.

4.2 bench_serving 사용하기 (임베딩 백엔드)

bench_serving은 SGLang에 내장되어 있어요. /v1/embeddings 엔드포인트를 대상으로 하려면 --backend sglang-embedding을 사용하세요. 서버가 --is-embedding과 함께 http://127.0.0.1:30000에서 실행 중인지 확인하세요.

python -m sglang.bench_serving \
  --backend sglang-embedding \
  --base-url http://127.0.0.1:30000 \
  --model Qwen/Qwen3-Embedding-8B \
  --dataset-name random \
  --random-input-len 512 \
  --random-output-len 0 \
  --num-prompts 1000 \
  --max-concurrency 64 \
  --request-rate 32

--dataset-name random은 ShareGPT 데이터셋에서 토큰 id를 샘플링해요; 첫 실행 시 ShareGPT가 Hugging Face에서 자동으로 다운로드됩니다. 네트워크가 없으면 export HF_ENDPOINT=https://hf-mirror.com을 설정하세요. 임베딩 벤치마크에는 --random-output-len 0을 설정하세요 — 출력 토큰이 생성되지 않아요.

출력 예시 (참고용일 뿐 — 실제 결과는 하드웨어와 구성에 따라 달라져요):

============ Serving Benchmark Result ============
Backend:                                 sglang-embedding
Traffic request rate:                    32.0
Max request concurrency:                 64
Successful requests:                     1000
Benchmark duration (s):                  31.86
Total input tokens:                      257891
Total input text tokens:                 257891
Request throughput (req/s):              31.39
Input token throughput (tok/s):          8094.67
Peak concurrent requests:                62
Concurrency:                             6.67
----------------End-to-End Latency----------------
Mean E2E Latency (ms):                   212.34
Median E2E Latency (ms):                 160.97
P90 E2E Latency (ms):                    267.31
P99 E2E Latency (ms):                    1445.94
==================================================

5. 오프라인 성능 테스트

SGLang의 Engine API는 HTTP 서버 없이 프로세스 내에서 추론을 실행해 최대 처리량을 측정할 수 있어요. bench_offline_throughput은 SGLang에 내장되어 있어 추가 설치나 실행 중인 서버가 필요 없어요.

bench_offline_throughput은 현재 텍스트 생성(LLM) 벤치마크만 지원해요. 멀티모달과 임베딩 모델은 지원되지 않습니다.

5.1 bench_offline_throughput 사용하기

bench_offline_throughput은 내부적으로 Engine API를 사용하며 HTTP 오버헤드 없이 순수 추론 처리량을 측정해요:

python -m sglang.benchmark.offline_throughput \
  --model-path Qwen/Qwen2.5-7B-Instruct \
  --dataset-name random \
  --random-input-len 1024 \
  --random-output-len 512 \
  --num-prompts 500

--dataset-name random은 ShareGPT 데이터셋에서 토큰 id를 샘플링해요; 첫 실행 시 ShareGPT가 Hugging Face에서 자동으로 다운로드됩니다. 네트워크가 없으면 export HF_ENDPOINT=https://hf-mirror.com을 설정하세요.

--dataset-name random과 --random-input-len, --random-output-len을 쓰면 입출력 토큰 수를 완전히 제어할 수 있어요. 고정 길이의 랜덤 데이터는 실제 데이터셋의 변동을 제거해 실행 간 처리량 비교를 결정적이고 신뢰할 수 있게 만들어요.

참고 자료 (See also)

• Bench Serving 가이드 — bench_serving의 모든 백엔드, 데이터셋, 고급 옵션
• Ascend NPU 퀵스타트 — Ascend NPU용 환경 설정
• Evalscope 성능 테스트 가이드 — Evalscope 전체 문서
• AISBench 문서 — AISBench 전체 문서

더 알아보기 (Learn more)

• SGLang 성능 테스트 공식 문서