induwara.lk
induwara.lkAI · LLM serving

LLM Concurrency & GPU Replica Calculator

Enter your measured decode speed, batch slots and output length to see how many concurrent requests one GPU holds, its sustainable QPS and latency, and the GPU replicas your target load needs — all tied together by Little's Law so the numbers stay consistent.

By Induwara AshinsanaUpdated Jul 8, 2026
LLM serving capacityconcurrency · QPS · replicas
Little's Law verified
tok/s

Per-stream tokens/second you measured (or from the inference-speed tool).

Max concurrent sequences — vLLM max_num_seqs.

Mean tokens generated per reply.

s

Prefill + queue delay before the first token streams.

Each user sends a request, waits (think time), then repeats.

s
Try a scenario
Sustainable QPS / GPU
4.27req/s
256 req/min · 15,360 req/hr
Per-request latency
8 s
TTFT + output ÷ decode speed
In-flight concurrency
34.13
Batch slots B = 32
GPU replicas needed
4
1,280 tok/s aggregate per GPU
Offered load: 16.67 req/sTight(2.3% headroom)5 replicas for ~20% headroom
Offered load vs provisioned capacity16.67 / 17.07 req/s

Full breakdown

Aggregate throughput / GPU1,280 tok/s
Sustainable rate / GPU4.27 req/s
Per-request latency (W)8 s
In-flight concurrency (N = λ·W)34.13 ≈ B 32
Offered load16.67 req/s
GPU replicas4
Provisioned capacity17.07 req/s
Headroom2.3%
First-order steady-state model tying concurrency, throughput and latency together with Little's Law (N = λ·W). No speculative decoding, prefix-cache sharing or p95/p99 queue modelling. Anchored to Little (1961), Anyscale continuous batching and NVIDIA inference guidance. Last verified 2026-07-08. Full sources below.

How it works

The calculator turns four measured numbers — per-stream decode speed s (tokens/second), batch slots B(the maximum concurrent sequences your engine runs, vLLM's max_num_seqs), average output tokens O, and time to first token TTFT — into a serving capacity plan. Every step is closed-form arithmetic; nothing is sampled or guessed.

  1. Per-request latency. W = TTFT + O / s. A reply's total time is the prefill/queue delay plus the time to stream its tokens one at a time. Decode is autoregressive and memory-bandwidth bound, so each token costs roughly 1/s seconds (NVIDIA inference-optimization guidance).
  2. Aggregate throughput of one GPU. T = B × s. Under continuous batching, all active streams decode in parallel, so the GPU's total token rate is the per-stream rate times the number of occupied slots (Anyscale).
  3. Sustainable request rate (QPS). λ = T / O = (B × s) / O. Each request consumes O tokens of that aggregate budget, so the number of requests one GPU can finish per second is the aggregate token rate divided by the output length.
  4. Little's Law consistency check.Little's Law says in-flight work N = λ × W. Substituting the two lines above, N = B × (1 + TTFT·s/O), which is just above B. The tool shows N alongside your batch size so the identity is visible: concurrency really does equal the batch, plus a small uplift from prefill time.
  5. Offered load. Your target is converted to requests/second: concurrent users ÷ think time, or a QPS figure directly, or requests-per-minute ÷ 60. A user who sends one request then thinks for T seconds offers 1/T req/s.
  6. Replicas and headroom. replicas = ceil(offered / λ), and headroom is the fraction of provisioned capacity left unused. A green badge means 20% or more spare; amber means it is tight; red means zero slack, where any burst will queue.

This is a first-order steady-state model. It excludes speculative decoding, prefix/KV-cache sharing, chunked and disaggregated prefill, and p95/p99 tail latency — all of which raise real throughput or need a queueing model. The replica count is therefore a safe upper bound: benchmark your stack to reclaim headroom rather than under-provision from an optimistic estimate.

Worked examples

8B chatbot on one A100, short replies

s = 40 tok/s · B = 32 · O = 300 · TTFT = 0.5 s · 500 users, 30 s think time

  1. Latency: W = 0.5 + 300/40 = 0.5 + 7.5 = 8.0 s
  2. Aggregate: T = 32 × 40 = 1,280 tok/s
  3. QPS/GPU: λ = 1,280 / 300 = 4.27 req/s
  4. Little's Law: N = 4.27 × 8.0 = 34.1 ≈ B (32) ✓
  5. Offered: 500 / 30 = 16.67 req/s
  6. Replicas: ceil(16.67 / 4.27) = ceil(3.91) = 4 GPUs
  7. Headroom: (17.07 − 16.67) / 17.07 = 2.3% → amber (add a 5th GPU for safety)

Long-form assistant, 800-token outputs

s = 25 tok/s · B = 16 · O = 800 · TTFT = 1.2 s · 600 requests/min

  1. Latency: W = 1.2 + 800/25 = 1.2 + 32 = 33.2 s
  2. Aggregate: T = 16 × 25 = 400 tok/s
  3. QPS/GPU: λ = 400 / 800 = 0.5 req/s
  4. Little's Law: N = 0.5 × 33.2 = 16.6 ≈ B (16) ✓
  5. Offered: 600 / 60 = 10 req/s
  6. Replicas: ceil(10 / 0.5) = 20 GPUs
  7. Headroom: (10 − 10) / 10 = 0% → red. Long outputs multiply GPU cost.

Fast API endpoint, tight replies

s = 80 tok/s · B = 64 · O = 150 · TTFT = 0.3 s · target 5 QPS

  1. Latency: W = 0.3 + 150/80 = 0.3 + 1.875 = 2.175 s
  2. Aggregate: T = 64 × 80 = 5,120 tok/s
  3. QPS/GPU: λ = 5,120 / 150 = 34.13 req/s
  4. Little's Law: N = 34.13 × 2.175 = 74.2 ≈ B (64) plus TTFT uplift ✓
  5. Offered: 5 req/s (given)
  6. Replicas: ceil(5 / 34.13) = 1 GPU
  7. Headroom: (34.13 − 5) / 34.13 = 85.4% → green (huge slack)

Frequently asked questions

Sources & references

The formulas and both worked examples were last reconciled against these sources on 2026-07-08. The model is closed-form and deterministic, so it is reviewed when serving techniques change the underlying assumptions rather than on a fixed schedule.

Related tools

Rate this tool
Be the first to rate

Comments & feedback

Spotted a bug or want an improvement? Tell us — our team reviews every comment, and good ideas get built. Comments are public and anonymous.

Found a bug, edge case, or want to suggest an improvement?

Email me at [email protected] — most fixes ship within 24 hours.