بخش 5.1 · سنجش و اندازه‌گیری

بنچمارک سرور در 15 دقیقه

Benchmark your server in 15 minutes

فهرست مطالب
  1. اجرای یک پیمایش
  2. خواندن نقطه زانو (Knee)
  3. دوری از چهار خطا
  4. بازنشانی کش پیشوند بین اجراها
  5. انتخاب بین حلقه‌ی بسته یا نرخ ثابت
  6. استفاده از کلاینت vLLM

با یک پیمایش روی همروندی (Concurrency)، نقطه‌ای را پیدا می‌کنید که تاخیر شروع به افزایش می‌کند؛ و چهار مقدار پیش‌فرض هم نتیجه را کاملاً تغییر می‌دهند.

فلگی را تغییر داده‌اید و می‌خواهید بدانید تاثیری داشته یا نه. با خواندن این بخش، می‌توانید یک پیمایش همروندی اجرا کنید، جهش تاخیر را بیابید و از چهار خطایی که باعث اختلاف نتایج در دو اجرای پیاپی می‌شوند دوری کنید.

نتیجه‌ی ما: روی پردازنده‌ی L4 ما، نرخ پردازش خروجی در 32 کاربر به اوج خود یعنی نزدیک 275 توکن بر ثانیه رسید و در 64 کاربر افت کرد.

اجرای یک پیمایش

جدول‌های ما با کلاینت بنچمارک SGLang 0.5.22 تولید شده‌اند، نه کلاینت vLLM، و دما روی 0 تنظیم شده بود. ما برای هر دو موتور از یک کلاینت یکسان استفاده کردیم تا صفحه‌ی مقایسه‌ی موتورها آن‌ها را با روشی واحد مقایسه کند. برای مقایسه‌ی GPU خودتان با جدول ما، از همین کلاینت استفاده کنید. آن را در یک محیط مجازی (Virtual environment) جداگانه نصب کنید تا به نصب vLLM شما دست نخورد:

uv venv bench --python 3.12 --seed
source bench/bin/activate
uv pip install sglang==0.5.22

سرور vLLM را در یک ترمینال اجرا کنید. در ترمینال دوم، کلاینت را به ازای هر سطح همروندی یک بار اجرا کنید. این همان دستوری است که جدول ما را ساخت:

for c in 1 2 4 8 16 32 64; do
  python -m sglang.benchmark.serving --backend vllm --port 8000 \
    --dataset-name random --random-input-len 512 --random-output-len 128 --random-range-ratio 1.0 \
    --max-concurrency $c --num-prompts $((c * 4 > 16 ? c * 4 : 16)) --seed 1 \
    --output-file sweep-c$c.jsonl --output-details
done

ما این حلقه را سه بار با مقادیر --seed 1، 2 و 3 اجرا کردیم و میانه‌ی آن‌ها را گزارش می‌دهیم. کلاینت با فلگ --backend vllm، هر درخواست را به مسیر /v1/completions می‌فرستد. در آغاز یک درخواست برای گرم‌کردن (Warmup) ارسال می‌کند و به سرور می‌گوید توکن پایان توالی (End-of-sequence) را نادیده بگیرد؛ به این ترتیب هر پاسخ شامل 128 توکن کامل خواهد بود.

هر اجرا خلاصه‌ای شامل چهار عدد چاپ می‌کند: نرخ پردازش خروجی، تاخیر تا اولین توکن (Time to First Token یا TTFT)، زمان به ازای هر توکن خروجی (Time Per Output Token یا TPOT) و تاخیر بین‌توکنی (Inter-token Latency یا ITL). این چهار عدد را همیشه در کنار هم نگه دارید. گزارش نرخ پردازش به‌تنهایی، تاخیری را که کاربرانتان حس می‌کنند پنهان می‌کند.

خواندن نقطه زانو (Knee)

نقطه زانو (Knee): میزان همروندی مشخصی است که در آن، تاخیر با شتاب بالا می‌رود در حالی که خروجی دیگر رشد نمی‌کند. پس از این نقطه، کاربران بیشتری پاسخ‌های کندتری می‌گیرند و سرور تقریباً هیچ توکن اضافه‌ای تولید نمی‌کند.

این پیمایشی است که روی کارت L4 ما با مدل Qwen/Qwen3-8B در فرمت BF16 در تاریخ 2026-10-21 و در نشست با فرکانس کامل اجرا شد. هر عدد، میانه‌ی سه مقدار seed است. مخزن حافظه (Pool) برابر با 24,096 توکن بود.

کاربران، نشست فرکانس کامل L4 خروجی (توکن بر ثانیه) میانه‌ی TTFT میانه‌ی TPOT صدک 99 تاخیر ITL میانه‌ی فرکانس SM
1 13.5 191 ms 60.4 ms 105 ms 1,275 MHz
8 112.8 253 ms 65.8 ms 67 ms 1,485 MHz
16 201.3 288 ms 69.5 ms 85 ms 1,455 MHz
32 275.1 1,800 ms 101.8 ms 613 ms 1,275 MHz
64 242.3 11,181 ms 129.2 ms 1,233 ms 1,005 MHz

تا 16 کاربر، هر کاربر تازه به حجم خروجی اضافه می‌کند و زمان پردازش هر توکن فقط از 60 به 70 میلی‌ثانیه می‌رسد. در این جدول، میانه‌ی زمان اولین توکن بین 16 تا 32 کاربر از 0.3 ثانیه به 1.8 ثانیه می‌رسد. صدک 99 تاخیر ITL نیز از 85 به 613 میلی‌ثانیه می‌پرد.

این جهش را نقطه‌ی زانو در نظر نگیرید. در این پیمایش، کش پیشوند (Prefix cache) بین تغییر تعداد کاربران بازنشانی نشده بود و هر seed همان پرامپت‌های اولیه را در تمام دفعات ارسال می‌کرد. در کمتر از 32 کاربر، بسیاری از درخواست‌ها پرامپت خود را آماده در کش پیدا می‌کردند. ما این پیمایش را دوباره در تاریخ 2026-10-23 تکرار کردیم؛ این بار با بازنشانی کش پیش از هر اجرا و با فرکانس قفل‌شده روی 900 مگاهرتز:

میانه‌ی TTFT با و بدون پاک‌سازی کش، مدل Qwen3-8B روی L4 در فرکانس 900 مگاهرتز capture/gpu/out-l4/load-flushed-vs-unflushed.txt
median TTFT, flushed against unflushed
users   vLLM                                   SGLang
4       650 / 145 ms (4.5x)                    532 to 645 / 141 ms (3.8 to 4.6x)
8       951 to 978 / 264 to 274 ms (3.6x)      1,174 to 1,273 / 173 to 178 ms (6.6 to 7.3x)
16      1,550 to 1,587 / 294 to 295 ms (5.3x)  1,804 to 1,944 / 218 ms (8.3 to 8.9x)
32      1,982 to 2,084 / 2,012 to 3,091 ms     3,216 to 3,228 / 2,710 to 2,917 ms
…

سطرهای میانه‌ی TTFT. درصد برآورده‌شدن تارگت و خطوط P99 ITL حذف شده‌اند.

با بازنشانی کش، میانه‌ی زمان اولین توکن در هر گام بالا رفت؛ حدود 0.65 ثانیه در 4 کاربر، 1.0 ثانیه در 8 کاربر و 1.6 ثانیه در 16 کاربر. تاخیر P99 ITL نیز از حدود 70 میلی‌ثانیه در 8 کاربر به 522 میلی‌ثانیه در 16 کاربر جهش کرد. بنابراین در این کارت، نقطه‌ی زانو بین 8 و 16 کاربر قرار دارد؛ کش آن را پنهان کرده بود. همروندی سامانه‌ی خود در محیط عملیاتی (Production) را حتماً پایین‌تر از نقطه‌ی زانویی تعیین کنید که با بازنشانی کش اندازه گرفته‌اید.

در 64 کاربر، خروجی افت کرد. اینجا دو عامل همپوشانی دارند: با در نظر گرفتن 640 توکن برای هر درخواست، 64 کاربر به ظرفیتی فراتر از مخزن 24,096 توکنی نیاز دارند و بنابراین درخواست‌ها منتظر ماندند. از سوی دیگر، GPU دچار افت توان حرارتی (Throttling) شد و میانه‌ی فرکانس آن به 1,005 مگاهرتز در مقایسه با 1,455 مگاهرتز در 16 کاربر کاهش یافت. پیمایش ما نمی‌تواند سهم این دو عامل را از هم تفکیک کند.

نقطه‌ی اوج نرخ پردازش در پیمایش قبلیبدون بازنشانی کش، خروجی در 32 کاربر به اوج 275 توکن بر ثانیه رسید، که اوج نرخ پردازش است نه زانوی تاخیر.
پیمایش نقطه‌ی زانو را می‌یابد: خروجی روی L4 در 32 کاربر به اوج می‌رسد توکن خروجی بر ثانیه در برابر کاربران همزمان برای vLLM 0.31.0 روی NVIDIA L4 با مدل Qwen3-8B، سه seed به ازای هر نقطه. خروجی از 13.5 در یک کاربر به 275.1 در 32 کاربر افزایش یافته و سپس در 64 کاربر به 242.3 کاهش می‌یابد، جایی که درخواست‌ها برای فضای کش کلید-مقدار در صف می‌مانند. 0 100 200 300 1 2 4 8 16 32 64 کاربران همزمان توکن خروجی بر ثانیه زانو، 275 242 میانه‌ی سه اجرا، بازه از کمترین تا بیشترین
تعداد کاربران در هر گام روی محور دو برابر می‌شود. نوار نشان‌دهنده کمترین و بیشترین مقدار از بین سه بار اجرا است. نمودار و جدول همان پیمایش 2026-10-21 را نشان می‌دهند که در آن کش بازنشانی نشده بود. همان‌طور که در متن آمده، زانوی تاخیر با بازنشانی کش بین 8 تا 16 کاربر است. برگرفته از capture/gpu/summary/l4.json.

دوری از چهار خطا

  1. استفاده‌ی دوباره از کش گرم. با مجموعه‌داده‌ی تصادفی و seed ثابت، اجرای دوم همان پرامپت‌ها را دوباره می‌فرستد. کش پیشوند بخشی از آن‌ها را پاسخ می‌دهد و اجرای دوم سریع‌تر به نظر می‌رسد. شیوه‌نامه‌ی درست در بخش بعدی آمده است.
  2. اجازه‌دادن به توقف زودهنگام مدل. بدون پارامتر --ignore-eos، برخی پاسخ‌ها پیش از رسیدن به طول خروجی تمام می‌شوند. در نتیجه بنچمارک توکن‌های کمتری نسبت به خواسته‌ی شما اندازه می‌گیرد.
  3. جاانداختن مرحله‌ی گرم‌کردن. درخواست‌های نخست پس از راه‌اندازی، تاوان کامپایل کرنل‌ها (Kernels) و کش‌های سرد را می‌پردازند. از --num-warmups استفاده کنید یا پیش از اندازه‌گیری، چند درخواست بفرستید.
  4. بی‌توجهی به فرکانس. پردازنده‌ای که داغ می‌کند یا وظایف پردازشی دیگری در آن شریک هستند، کندتر کار می‌کند. در طول اجرا وضعیت را با دستور nvidia-smi --query-gpu=clocks.sm,temperature.gpu --format=csv -l 1 ضبط کنید. دو اجرا را فقط در صورتی با هم مقایسه کنید که فرکانس‌های مشابهی داشته باشند.

بازنشانی کش پیشوند بین اجراها

کش پیشوند، بلوک‌های حافظه‌ی KV مربوط به پرامپت‌های پیشین را نگه می‌دارد. این کار دو چیز را بین اجراها تغییر می‌دهد: سرعت، و گاهی خروجی درخواست‌هایی با استراتژی حریصانه (Greedy). صفحه‌ی بازتولیدپذیری اثر آن را روی خروجی نشان می‌دهد.

برای مشاهده‌ی اثر روی سرعت، یک بار کاری یکسان را دو بار با seed یکسان و بدون بازنشانی کش اجرا کردیم. این کار روی GPU دوم نود L4 ما در تاریخ‌های 2026-10-22 و 2026-10-23 انجام شد. از مدل Qwen/Qwen3-0.6B، تعداد 64 پرامپت در 16 کاربر، با 512 توکن ورودی و 128 توکن خروجی استفاده کردیم. آن GPU با مالکش به اشتراک گذاشته شده بود و فرکانس قفل‌شده نداشت؛ بنابراین به نسبت‌ها اعتماد کنید، نه به زمان‌ها.

میانه‌ی TTFT بر حسب میلی‌ثانیه، بار یکسان برای چهار بار متوالی capture/gpu/out-l4/prefix-cache-flush.txt
engine        fresh   repeat, not flushed   repeat after a flush   repeat, not flushed
…
vLLM 0.6B     925     148                   1,163                  184

سطر مربوط به vLLM در خلاصه. سطر SGLang حذف شده است.

در تکرار تست بدون بازنشانی، میانه‌ی TTFT حدود 6 برابر کمتر از اجرای تازه ثبت شد. پس از بازنشانی کش، TTFT دوباره به سطح اجرای تازه برگشت. زمان به ازای هر توکن کمتر از 15 درصد تغییر کرد؛ چرا که اصابت به کش (Cache hit) بار مرحله‌ی پیش‌پرکنی (Prefill) را حذف می‌کند اما کار رمزگشایی (Decode) را بدون تغییر باقی می‌گذارد.

برای هر اجرایی که می‌خواهید مقایسه کنید، این پروتکل را به کار ببرید:

  1. هر اجرا را با کش خالی آغاز کنید. سرور را ری‌استارت کنید یا متد POST /reset_prefix_cache را فراخوانی کنید. این مسیر تنها با VLLM_SERVER_DEV_MODE=1 فعال می‌شود و سروری با این وضعیت هرگز نباید در معرض عموم قرار گیرد.
  2. برای هر اجرا از یک --seed جدید استفاده کنید تا مجموعه‌داده‌ی تصادفی پرامپت‌های جدیدی بفرستد.
  3. توکن‌های کش‌شده را ثبت کنید. معیارهای vllm:prefix_cache_hits_total و vllm:prefix_cache_queries_total را پیش و پس از اجرا بخوانید.
  4. برای شمارش به ازای هر پاسخ، سرور را با فلگ --enable-prompt-tokens-details راه‌اندازی کنید. سپس مقدار usage.prompt_tokens_details.cached_tokens را در هر پاسخ بخوانید.
  5. تنظیمات کش و تعداد توکن‌های کش‌شده را کنار نتیجه یادداشت کنید.

دستور vllm bench sweep serve کش‌های سرور را بین اجراهایش به‌طور خودکار برای شما پاک می‌کند.

انتخاب بین حلقه‌ی بسته یا نرخ ثابت

پارامتر --max-concurrency تعداد مشخصی از کاربران را همواره مشغول نگه می‌دارد. وقتی سرور کند می‌شود، کاربران درخواست بعدی خود را دیرتر می‌فرستند؛ در نتیجه بار کاری خودبه‌خود کم می‌شود. این حلقه‌ی بسته هرگز عقب نمی‌افتد.

پارامتر --request-rate درخواست‌ها را با نرخی ثابت می‌فرستد؛ چه سرور برسد پاسخ دهد و چه نرسد. فراتر از نرخی که سرور توان پاسخگویی دارد، صف رشد می‌کند و زمان اولین توکن با هر درخواست طولانی‌تر می‌شود. ترافیک واقعی بیشتر شبیه به یک نرخ ثابت عمل می‌کند. پیش از آنکه محدودیت ظرفیت تعیین کنید، هر دو حالت را بسنجید.

استفاده از کلاینت vLLM

خود vLLM کلاینت اختصاصی دارد: vllm bench serve. این ابزار همان چهار عدد را گزارش می‌دهد و به نصب دوم هم نیازی ندارد. در نسخه‌ی 0.31.0، با تنظیم VLLM_USE_RUST_BENCH=1 نسخه‌ی Rust همین کلاینت اجرا می‌شود. حلقه‌ی زیر همین پیمایش را با آن انجام می‌دهد:

for c in 1 2 4 8 16 32 64; do
  vllm bench serve --model Qwen/Qwen3-8B \
    --dataset-name random --random-input-len 512 --random-output-len 128 \
    --max-concurrency $c --num-prompts $((c * 4 > 16 ? c * 4 : 16)) \
    --seed $c --ignore-eos --num-warmups 2 \
    --save-result --result-filename sweep-c$c.json
done

ما این حلقه را دقیقاً به همین شکل در تاریخ 2026-10-23 با مدل Qwen/Qwen3-8B-FP8 روی کارت اشتراکی دوم نود L4 اجرا کردیم. هر اجرا تمام شد و فایل نتیجه‌اش را ذخیره کرد. فرکانس پردازنده به دلیل حرارت افت کرده بود، بنابراین اعدادی از آن اجرا درج نمی‌کنیم.

سپس در همان تاریخ 2026-10-23، سه کلاینت را در برابر یک سرور vLLM با مدل Qwen/Qwen3-0.6B اجرا کردیم: کلاینت SGLang، ابزار vllm bench serve، و نسخه‌ی Rust آن. این آزمایش روی پردازنده‌ی دومِ اشتراکی نود L4 بود. فرکانس افت کرده بود، اما در تمام طول اجراها بین 420 تا 495 مگاهرتز ثابت ماند. کش را پیش از هر اجرا بازنشانی کردیم و کلاینت‌ها را در دو دور یکی‌در‌میان تغییر دادیم.

توکن خروجی بر ثانیه از سه کلاینت، هر کدام در دو دور capture/gpu/out-l4/bench-client-bias.txt
users   temperature   SGLang client    vllm bench       vllm bench, Rust
…
64      0             359, 348         379, 377         371, 365
64      0.7           331, 343         360, 363         356, 353

سطرهای مربوط به 64 کاربر از جدول نرخ پردازش. سایر سطرها و جدول TTFT حذف شده‌اند.

  • هر دو کلاینت vLLM توافق داشتند. نسخه‌های پایتون و Rust دستور vllm bench serve در 1، 16 و 64 کاربر، در دامنه‌ی نویز آماری، اعداد یکسانی ارائه دادند.
  • کلاینت SGLang سرور را کندتر خواند. میانه‌ی TTFT در آن بین 3 تا 10 درصد بیشتر از vllm bench serve بود. در 16 و 64 کاربر، نرخ پردازش خروجی آن 2 تا 8 درصد کمتر بود. در حالت یک کاربر، یکی از دورهای اجرای آن نرخ پردازشی بالاتر از تمام دورهای دیگر ثبت کرد؛ از این رو برای آن بخش اختلاف نرخی ارائه نمی‌دهیم.
  • پرامپت‌ها متفاوت‌اند. این دو کلاینت توکن‌های پرامپت متفاوتی از مجموعه‌داده‌های تصادفی خود می‌فرستند، بنابراین بخشی از این اختلاف جزئی می‌تواند ناشی از خود پرامپت‌ها باشد.
  • دما نتیجه را تغییر می‌دهد. دمای 0.7 در مقایسه با دمای 0 میانه‌ی TPOT را بالا برد. این رقم در حالت یک کاربر 10 تا 13 درصد و در 16 و 64 کاربر بین 3 تا 6 درصد بیشتر بود.

بنابراین جدول‌های ما که با کلاینت SGLang و در دمای 0 تهیه شده‌اند، ممکن است چند درصدی کندتر از اجرای مشابه با vllm bench serve به نظر برسند. یک کلاینت و یک دما انتخاب کنید و در تمام مقایسه‌ها منحصراً از همان‌ها استفاده کنید.

منابع: مستندات vLLM در نسخه‌ی v0.31.0 (فایل‌های docs/benchmarking/cli.md و docs/benchmarking/sweeps.md)، کد منبع vLLM در v0.31.0 (فایل vllm/benchmarks/serve.py)، فایل capture/gpu/summary/l4.json (ورودی load.vllm-b)، ابزار پیمایش راهنمای SGLang 101 (فایل capture/gpu/sweep.py)، کد منبع کلاینت بنچمارک SGLang 0.5.22 (فایل‌های python/sglang/benchmark/serving.py و python/sglang/benchmark/datasets/random.py)، capture/gpu/out-l4/prefix-cache-flush.txt، capture/gpu/out-l4/bench-client-bias.txt، capture/gpu/out-l4/livecheck-2026-10-23.txt و capture/gpu/out-l4/load-flushed-vs-unflushed.txt.

ترجمه‌ی فارسی Benchmark your server in 15 minutes از راهنمای vLLM 101 دوره‌ی AI Engineering from Scratch، نوشته‌ی Rohit Ghumare، تحت مجوز MIT. دستورها، لاگ‌ها و اعداد عیناً از اجراهای ثبت‌شده‌ی متن اصلی‌اند. فهرست راهنما