suJayhh/rtx5090-5m-bench

Manual RTX 5090 NVFP4 vLLM Benchmark Plan

Objective

Find the concurrency N that maximizes aggregate output token throughput on one rented RTX 5090 while every simulated user receives at least 15 output tokens/second over an exact five-minute measurement window.

The result is conditional on the fixed context-length mixture below. It is not a universal capacity number for every traffic distribution.

Primary optimization problem:

maximize aggregate_output_tok_s(N, config)
subject to min(user_output_tok_s) >= 15.0
           measurement_window == 300 seconds
           prompt_tokens + requested_output_tokens <= 30,000
           request_errors == 0
           engine_restarts == 0
           OOM_events == 0

Definitions:

aggregate_output_tok_s = sum(output tokens delivered to all users) / 300
user_output_tok_s[i]   = output tokens delivered to user i / 300
mean_user_tok_s        = aggregate_output_tok_s / N

The strict constraint is the minimum individual user rate, not merely aggregate/N. Prompt tokens are never included in the headline throughput.

Model decision

Use:

nvidia/Llama-3.1-8B-Instruct-NVFP4

No replacement model is needed. NVIDIA publishes this checkpoint as the NVFP4-quantized derivative of Meta Llama 3.1 8B Instruct. Its model card lists an eight-billion-parameter Llama architecture, a 128k native context limit, vLLM support, and NVIDIA Blackwell compatibility. It quantizes transformer-block linear weights and activations to FP4 while leaving selected components, including lm_head, at higher precision. NVIDIA model card

The repository configuration declares quant_algo: NVFP4 and quant_method: modelopt. Use NVFP4 for both the model and KV cache when the pinned vLLM build exposes a working Blackwell NVFP4 KV-cache implementation. NVFP4 KV storage is packed 4-bit data with FP8 block scales, so it is not a completely scale-free 4-bit representation. Therefore:

• Load the checkpoint using vLLM's ModelOpt FP4 path.
• Let unquantized layers use their checkpoint dtype with --dtype auto.
• Use NVFP4 for the primary KV cache (--kv-cache-dtype nvfp4).
• If the pinned vLLM version does not support NVFP4 KV cache, stop and select a newer compatible pinned image; do not silently substitute FP8 for the primary result.
• Do not re-quantize the model unless the published checkpoint proves unusable.

The checkpoint was released before the optional six-month replacement window, but that condition only applies if NVFP4 is unavailable for Llama 3.1 8B. NVFP4 is available, so model substitution is not triggered.

Execution compatibility notes (2026-07-10)

• An RTX 5090 offer with driver 570.144 was rejected and destroyed before benchmarking. The pinned CUDA 13.0 vLLM image could see the GPU through nvidia-smi, but PyTorch failed during CUDA initialization with error 804 (forward compatibility was attempted on non supported HW).
• An RTX 5090 offer with driver 595.58.03 passed CUDA initialization and reported compute capability (12, 0). The stable v0.22.1 image was then rejected and destroyed because its native NVFP4 KV startup path failed in FlashInfer with AttributeError: module 'torch' has no attribute 'nvfp4'.
• The failed rentals produced no benchmark data and were closed. A third fresh trial used the pinned vLLM nightly image manifest sha256:a671d5fcda70fe9ac6f245f9780821de459fb4ee22c018fd07a0f10a55279bf9 (build commit 95ed0feaa5cd7fb16d72c53ce04950aaf07c4698). Stock startup on SM120 reported trtllm_prefill=false, trtllm_decode=false, and rejected NVFP4 KV before model load; that rental was destroyed without benchmark data.
• A narrowly scoped compatibility patch then selected the installed FlashInfer 0.6.13 FA2 NVFP4-KV path for SM120, mapped packed NVFP4 storage to torch.uint8, and added BF16 query/output scratch conversion required by this build. The patched server reached init engine, reported kv_cache_dtype=torch.uint8, arch=sm120, served token-ID completions, and completed the benchmark. This is a pinned-image/runtime-patch result, not evidence that the stock nightly supports SM120 NVFP4 KV.
• The same VM was reused for the BF16-KV comparison. BF16 startup used FlashAttention v2 and allocated 179,376 KV-cache tokens (5.98x 30k-request concurrency). It completed, but the selected 32/31/28-user fixed-output scenarios saturated BF16 KV at about 100% and all failed the 15 tok/s minimum-user constraint. The separate unlimited-output variation also completed; natural EOS ended answers very early and produced about 24 tok/s aggregate, so it is not comparable to the forced-512-token result.

Execution reports are maintained separately for each non-user variation: EXECUTION_REPORT.md (NVFP4 KV benchmark 1), EXECUTION_REPORT_BF16_KV.md (BF16 KV with forced 512-token output), and EXECUTION_REPORT_BF16_UNLIMITED.md (BF16 KV with the output limiter removed).

1. Orchestrator preparation

Install and authenticate the Vast.ai CLI locally if needed:

python -m pip install vastai
vastai set api-key VAST_API_KEY
vastai show user

Use a local, untracked .env file for the orchestration inputs. The file must contain the following names; values are intentionally omitted here:

VAST_API_KEY=
HF_DATASET_REPO=
HF_WRITE_TOKEN=
HF_READ_TOKEN=

# Optional pinned-run metadata and deployment inputs.
MODEL_REPO=nvidia/Llama-3.1-8B-Instruct-NVFP4
MODEL_REVISION=
VLLM_IMAGE=
RUN_ID=
VAST_INSTANCE_ID=

Variable use and secret-handling rules:

• VAST_API_KEY is used only by the local orchestrator for Vast.ai actions.
• HF_DATASET_REPO identifies the Hugging Face dataset repository used for the seeded workload, if the workload is published or retrieved through the Hub.
• HF_WRITE_TOKEN is local-only and may be used to create or update the dataset repository. Never copy it to the rental.
• HF_READ_TOKEN is optional and read-only; this is the only token copied to the rental, and only for downloading the pinned model or dataset revision.
• MODEL_REPO and MODEL_REVISION identify the exact model artifact. MODEL_REVISION must be resolved and recorded before download.
• VLLM_IMAGE records the exact pinned vLLM image tag and digest selected for the run.
• RUN_ID identifies all artifacts for one benchmark run. Generate it if absent.
• VAST_INSTANCE_ID is populated after provisioning and is not a secret.

Load secrets from the local environment rather than putting them in scripts, result files, command-line metadata, or copied logs. The .env file must remain untracked; verify git status before every commit and before copying results off the rental.

Create a local run identifier such as:

5090-llama31-8b-nvfp4-YYYYMMDD-HHMMSS

Every artifact, server configuration, and five-minute result row should contain that run ID.

2. Find and rent the instance

Search for a single on-demand RTX 5090 on a verified, reliable host with direct SSH, sufficient disk, and a recent CUDA/driver stack:

vastai search offers 'gpu_name=RTX_5090 num_gpus=1 verified=true rentable=true reliability>0.99 direct_port_count>=1 gpu_ram>=30 disk_space>=100 cuda_vers>=12.8' -o 'dph_total' --raw

Choose reliability before price. Prefer adequate effective CPU cores, system RAM, disk bandwidth, and a host with no conflicting stopped rental. Save the full selected-offer JSON in the run manifest.

Use a current stable vLLM image whose release notes include Blackwell SM120 and NVFP4 support. Pin the exact tag and image digest; do not benchmark latest or an unpinned nightly.

vastai create instance OFFER_ID --image vllm/vllm-openai:PINNED_TAG --disk 100 --ssh --direct --label llama31-8b-nvfp4-5090-bench
vastai show instance INSTANCE_ID
vastai ssh-url INSTANCE_ID

The Vast CLI supports this search, create, poll, SSH, copy, and destroy lifecycle. Vast.ai CLI guide

Run the load generator on the rented host against 127.0.0.1. This removes WAN and SSH-tunnel latency from user-rate measurements.

3. Validate the 5090 and software path

Immediately record:

nvidia-smi
nvidia-smi --query-gpu=name,uuid,driver_version,memory.total,power.limit,temperature.gpu --format=csv
python -c "import torch; print(torch.__version__, torch.version.cuda); print(torch.cuda.get_device_name()); print(torch.cuda.get_device_capability())"
vllm --version
python -c "import modelopt; print(modelopt.__version__)"

The RTX 5090 should report compute capability (12, 0), the SM120 Blackwell family. Reject the rental if:

• The GPU identity or memory does not match the offer.
• Another process occupies the GPU.
• CUDA or the driver cannot run the pinned vLLM build.
• Xid errors, severe power limiting, or sustained thermal throttling appear.
• NVFP4 initialization reports unsupported architecture or falls back to CPU execution.

Current vLLM/LLM Compressor documentation describes NVFP4 as a Blackwell SM100-or-later W4A4 format with global tensor scales, FP8 local scales, and groups of 16. NVFP4 compression scheme

4. Download and pin the checkpoint

Authenticate interactively on the rental with a read-only Hugging Face token:

read -s HF_TOKEN
hf auth login --token "$HF_TOKEN"
hf auth whoami
unset HF_TOKEN

Resolve the current model commit, record it in manifest.json, and download that exact revision:

hf download nvidia/Llama-3.1-8B-Instruct-NVFP4 \
  --revision PINNED_COMMIT \
  --local-dir /workspace/model

Preserve these model files in the manifest:

• Model repository and commit.
• Hash of config.json and the safetensors index.
• quantization_config, including the producer and ModelOpt version.
• Tokenizer and chat-template revisions.

5. Prove native NVFP4 execution before benchmarking

Start with an explicit ModelOpt FP4 load:

vllm serve /workspace/model \
  --served-model-name llama31-8b-nvfp4 \
  --quantization modelopt_fp4 \
  --dtype auto \
  --kv-cache-dtype nvfp4 \
  --max-model-len 30000 \
  --gpu-memory-utilization 0.92 \
  --max-num-seqs 256 \
  --enable-chunked-prefill \
  --no-enable-prefix-caching \
  --generation-config vllm \
  --host 127.0.0.1 \
  --port 8000

If the pinned vLLM version uses modelopt rather than modelopt_fp4 as the CLI spelling, confirm with vllm serve --help, use the documented spelling for that version, and record it. vLLM documents modelopt_fp4 as the NVFP4 ModelOpt backend and supports serving local ModelOpt checkpoints. vLLM ModelOpt documentation

Capture startup logs at debug level once and confirm all of the following:

• The checkpoint is recognized as NVFP4 W4A4, not generic INT4/NF4.
• Activation quantization remains enabled on SM120.
• Native Blackwell NVFP4 kernels load; there is no dequantized BF16 execution path.
• KV cache is NVFP4 as requested, with the expected packed FP4 data and FP8 block scales.
• Native NVFP4 KV-cache attention kernels are active; there is no silent FP8 or BF16 fallback.
• Model maximum length is capped at exactly 30,000 total tokens.

Perform unscored smoke tests:

1. /health, /v1/models, and /metrics respond.
2. A short chat completion produces coherent output.
3. A request with prompt + output = 30,000 succeeds.
4. Streaming token IDs and usage counts agree.
5. Repeated requests do not leak memory or trigger preemptions at concurrency one.

If the NVIDIA checkpoint format does not load directly, use the documented compressed-tensors convert_checkpoint path for ModelOpt NVFP4, then retry with a new configuration ID. Do not silently serve BF16. LLM Compressor specifically documents conversion of ModelOpt NVFP4 checkpoints. Checkpoint conversion guidance

6. Freeze the simulated-user workload

Use seven equal-weight total-context buckets. Each total includes both prompt and requested output:

Total context	Fully templated prompt	Forced output
1,000	488	512
2,000	1,488	512
4,000	3,488	512
8,000	7,488	512
16,000	15,488	512
24,000	23,488	512
30,000	29,488	512

Generate a seeded workload.jsonl with the downloaded Hugging Face tokenizer:

• Prompt counts include the system message, chat template, BOS, and other special tokens.
• Use varied natural-language/chat content rather than a single repeated filler string.
• Assume every benchmark request is a prefix-cache miss. Make prompts unique enough that no system prompt, organization/application instruction, conversation prefix, or prior user turn is reused by the cache.
• Prefix caching is disabled for the primary result. This measures the conservative uncached serving case; cache-enabled results may be collected separately under a different config_id.
• Pad or truncate after applying the chat template to hit exact token counts.
• Fix and record the workload seed and SHA-256 hash.
• Verify the server-reported prompt token IDs before accepting the workload.

Each request uses:

temperature = 0
max_tokens = 512
min_tokens = 512, if supported
ignore_eos = true
stream = true
return_token_ids = true

Each simulated user is a persistent asynchronous coroutine. As soon as one request completes, that user submits another with zero think time. Use a balanced round-robin or Latin-square assignment so all seven context buckets remain represented when concurrency is not divisible by seven.

Do not change the workload, context weights, output length, seed, prefix-cache policy, or cache-miss assumption while comparing concurrency or engine settings.

7. Five-minute measurement window

For each candidate concurrency N:

1. Drain the previous run and confirm zero running/waiting requests.
2. Start N persistent users.
3. Allow 30–60 seconds of unmeasured warm-up and stabilization.
4. Start an exact monotonic 300-second timer.
5. Read vllm:generation_tokens_total at the window boundary.
6. Count streamed output token IDs separately for every user.
7. Sample /metrics and nvidia-smi once per second.
8. At exactly 300 seconds, stop counting and read the final generation counter.
9. Stop launching new requests, drain in-flight work, and wait for idle. Requests dispatched during the measurement window remain eligible for latency measurement until they complete or hit the configured timeout.

For every request, record monotonic client timestamps for dispatch, first streamed output token, and completion. Calculate:

ttft_ms = (first_output_token_time - dispatch_time) * 1000
request_latency_ms = (completion_time - dispatch_time) * 1000

Report request-level p50, p95, and p99 TTFT and end-to-end request latency across requests dispatched during the 300-second window. Also report these percentiles separately for each context bucket. A request that fails before its first token is a request error and must not be silently omitted from the latency sample. Drain in-flight requests after the boundary so their latency can be recorded, but do not count their post-boundary output tokens toward the 300-second throughput total.

Primary reported value:

aggregate_output_tok_s = sum(client-delivered token IDs in window) / 300

Audit value:

server_output_tok_s = delta(vllm:generation_tokens_total) / 300

Invalidate the window if client and server counts differ by more than 1%. vLLM exposes generation-token totals, running/waiting requests, KV-cache utilization, latency, and preemption telemetry through /metrics. vLLM production metrics

8. Append every result

Append and flush one JSONL row after every complete five-minute window:

{
  "timestamp_utc": "...",
  "run_id": "...",
  "config_id": "nvfp4-w4a4-nvfp4kv-batch-default",
  "window_s": 300.0,
  "users": 28,
  "aggregate_output_tok_s": 0.0,
  "server_output_tok_s": 0.0,
  "mean_user_tok_s": 0.0,
  "min_user_tok_s": 0.0,
  "p05_user_tok_s": 0.0,
  "ttft_p50_ms": 0.0,
  "ttft_p95_ms": 0.0,
  "ttft_p99_ms": 0.0,
  "request_latency_p50_ms": 0.0,
  "request_latency_p95_ms": 0.0,
  "request_latency_p99_ms": 0.0,
  "request_errors": 0,
  "preemptions": 0,
  "peak_kv_cache_pct": 0.0,
  "gpu_util_avg_pct": 0.0,
  "power_avg_w": 0.0,
  "valid": false
}

Also append a concise CSV row and console line:

users=28 window=300s aggregate_output_tok_s=... min_user_tok_s=... ttft_p99_ms=... request_latency_p99_ms=... PASS|FAIL

Keep per-user and per-context-bucket throughput and latency measurements in the detailed result so a fast short-context population cannot conceal long-context starvation or latency spikes. The primary pass/fail decision remains the 300-second throughput and minimum-user-rate constraint; latency percentiles are reported diagnostics unless an explicit latency SLO is added.

9. Adaptive concurrency search

Use a bracket-and-refine search rather than guessing the final user count:

1. Begin with seven users so every context bucket is represented.
2. If valid, double concurrency: 7 -> 14 -> 28 -> 56 -> ....
3. If seven fails, halve until a valid lower bound exists.
4. Stop doubling at the first constraint failure, OOM, or two consecutive windows with negligible aggregate improvement.
5. Binary-search between the last valid and first invalid concurrency.
6. Test every integer in a small neighborhood around both the throughput peak and the 15 tok/s boundary.
7. Re-test the provisional best N and its two neighbors three times each.
8. Choose the highest median aggregate throughput for which every confirmation window has min_user_tok_s >= 15.0.

Use 15.5–15.75 tok/s as a coarse-search safety margin, but make the final pass/fail decision against the requested 15.0 threshold.

10. Engine tuning outer loop

Keep the checkpoint and workload fixed. Give every changed server setup a new config_id, restart the server, warm it, and re-run the concurrency bracket.

Tune in this order:

1. max-num-batched-tokens.
2. max-num-seqs, always at least as large as the candidate user count.
3. Chunked-prefill size, partial-prefill concurrency, and long-prefill threshold.
4. gpu-memory-utilization, cautiously moving from 0.92 toward 0.95–0.96 if startup and runtime headroom permit.
5. NVFP4 KV scale handling if the checkpoint scales or vLLM warnings indicate a problem.

Decision cues:

• Low GPU utilization with waiting requests: raise scheduler/batch ceilings and check for a CPU frontend bottleneck.
• High KV utilization or preemption: reduce concurrency, tune prefill admission, or increase safe cache allocation.
• Long-context users below 15 while aggregate is high: tune chunked-prefill admission or reduce N.
• Native NVFP4 kernel failure: change/pin the software image or checkpoint conversion; never count a fallback precision as NVFP4.
• Thermal or power throttling: invalidate the host/window and move to another Vast offer.

Do not mix BF16, FP8-weight, NVFP4A16 weight-only, NVFP4 W4A4 with FP8 KV, and NVFP4 W4A4 with NVFP4 KV results on one leaderboard. The required primary result family is NVFP4 W4A4 weights/activations with NVFP4 KV cache. FP8-KV results may be retained as a separately identified comparison configuration.

Budget approximately two to four GPU hours for provisioning, compilation/warm-up, coarse search, refinement, one tuning round, and confirmation windows.

11. Final report and teardown

The final summary must contain:

Model: nvidia/Llama-3.1-8B-Instruct-NVFP4@COMMIT
GPU and host offer: ...
vLLM/image/CUDA/driver versions: ...
Quantization backend confirmed: ModelOpt NVFP4 W4A4, native SM120
KV cache: NVFP4 (packed 4-bit data with FP8 block scales)
Context distribution: equal 1k/2k/4k/8k/16k/24k/30k
Best valid concurrency: N
Median aggregate output throughput: X tok/s
Minimum user throughput: Y tok/s
Mean user throughput: Z tok/s
TTFT p99: A ms
Request latency p99: B ms
Workload hash: ...

Copy the manifest, workload hash, JSONL/CSV results, server logs, telemetry, and final report off the rental before destroying it:

vastai copy INSTANCE_ID:/workspace/results/ local:./results/
vastai destroy instance INSTANCE_ID

Stopping rather than destroying continues to incur storage charges, so destroy the rental after verifying the copied artifacts.

12. Corrected natural-output results

The earlier nvfp4-unlimited and bf16-unlimited result folders are historical-invalid: omitting max_tokens invoked vLLM's hidden 16-token default. The corrected natural-output result trees are kept separately:

• Local source: results/results_nvfp4_natural_eos/ and results/results_bf16_natural_eos/.
• Publish names: nvfp4-natural-eos/ and bf16-natural-eos/.
• Corrected reports: EXECUTION_REPORT_NVFP4_NATURAL_EOS.md and EXECUTION_REPORT_BF16_NATURAL_EOS.md.

The corrected NVFP4-KV optimum was 16 users at 1327.787 aggregate output tok/s, 82.890 minimum output tok/s/user, and 769.120 aggregate input tok/s. The corrected BF16-KV optimum was 16 users at 644.530 aggregate output tok/s, 15.320 minimum output tok/s/user, and 1052.133 aggregate input tok/s; 17 users failed fairness at 7.653 minimum output tok/s/user.

Compatibility reminder: this result is specific to the pinned RTX 5090 SM120 host, driver 595.58.03, pinned vLLM image digest, and the documented FlashInfer FA2 compatibility patch. Stock nightly NVFP4-KV startup was rejected on SM120, while the older CUDA/driver offer failed with CUDA error 804. Do not generalize the NVFP4-KV result to another VM, driver, image, or unpatched runtime without a fresh startup and kernel-path validation.