BroadRouter

LLM latency: TTFT vs tokens per second vs end-to-end na oras

Ng BroadNet Inference team · 4 minutong basa · Nailathala · Na-update

Ang time to first token (TTFT) ay ang paghihintay bago ang unang output token. Ang tokens per second ay kung gaano kabilis mag-stream ang sagot pagkatapos niyon. Ang end-to-end latency ang kabuuan: TTFT dagdag ang oras ng generation (≈ output token ÷ bilis). Haba ng prompt at queueing ang nagpapagalaw sa TTFT, laki ng model at load sa bilis, at haba ng sagot sa kabuuan. Sukatin ang tatlo sa p50 at p95.

Puwedeng tatlong magkakaibang bagay ang ibig sabihin ng “mabagal ang API”, at magkakaiba ang ayos ng bawat isa. Naghihintay ang chat user sa unang salita. Naghihintay ang agent sa buong tool call. Token kada oras ang mahalaga sa batch job. Dinedepina ng post na ito ang tatlong numero, ipinapakita kung paano sukatin ang mga ito mula sa sarili mong code, at itinutugma ang bawat ayos sa numerong talagang ginagalaw nito.

Ano ang TTFT, tokens per second at end-to-end latency?

Malinaw ang mga depinisyon sa benchmarking guide ng NVIDIA, at tugma ang mga ito sa nakikita mo mula sa client:

Metric Ano ang sinusukat Sino ang nakakaramdam Ano ang nagpapagalaw
Time to first token (TTFT) Pagpapadala ng request → pagtanggap ng unang token Mga chat user Network, queueing, haba ng prompt (prefill), cache hit
Inter-token latency (ITL) Karaniwang pagitan ng mga token Mga nagbabasa ng naka-stream na sagot Laki ng model, hardware, load ng server
Tokens per second kada user Output token pagkatapos ng una ÷ oras ng generation (mula unang token hanggang huli); katumbas ng 1 ÷ average na ITL Mga mambabasa, agents Pareho sa ITL
End-to-end latency Pagpapadala ng request → pagtanggap ng huling token Agents, API, batch TTFT + oras ng generation

Ang formula na nag-uugnay sa kanila:

end-to-end ≈ TTFT + (output token − 1) × ITL ≈ TTFT + output token ÷ tokens per second kada user

Hindi pareho ang bilis kada user at ang throughput ng server, ang kabuuang token na ginagawa ng server para sa lahat ng user; puwedeng tumaas ang isa habang bumababa ang isa.

Gamitin ang karaniwang bilis na inilalathala ng BroadNet para sa plan model nito, mga 100 token bawat segundo. Lumalaki ang oras ng generation kasabay ng haba ng sagot: mga walumpung ulit na mas matagal i-generate ang code file na 4,000 token kaysa sa classification na 50 token, habang pareho ang TTFT na hinihintay ng dalawa. Sa maiikling sagot, TTFT ang karamihan ng paghihintay; sa mahahaba, bilis at haba.

Bakit kailangan ng mga reasoning model ng ikaapat na numero?

Nag-iisip muna bago sumagot ang mga reasoning model gaya ng DeepSeek V4.1 Flash, at output token din ang pag-iisip. Kung 800 token ang ginugol ng model sa reasoning sa mga 100 token bawat segundo, hihintayin ng user na ma-generate ang lahat ng 800 bago lumabas ang unang nakikitang salita, kahit mukhang mabilis ang TTFT sa wire. Kaya sukatin nang hiwalay ang time to first content token. Sa BroadNet Inference, pinapaikli ng reasoning_effort: "low" ang pag-iisip para sa mga simpleng hakbang; ipinapaliwanag ng gabay sa reasoning ang trade-off.

Paano sukatin ang latency mula sa client?

I-time ito kung nasaan ang mga user mo, na naka-on ang streaming. Hindi nakikita ng mga timer sa server side ang network at anumang proxy.

import os, time, statistics
from openai import OpenAI

client = OpenAI(base_url="https://inference.broadnet.ai/v1", api_key=os.environ["BROADNET_API_KEY"])

def timed(model, messages, max_tokens=1500):
    t0 = time.perf_counter()
    first = first_content = None
    usage = None
    stream = client.chat.completions.create(
        model=model, messages=messages, max_tokens=max_tokens,
        stream=True, stream_options={"include_usage": True},
    )
    for chunk in stream:
        now = time.perf_counter()
        if chunk.choices:
            if first is None:
                first = now
            if chunk.choices[0].delta.content and first_content is None:
                first_content = now
        if chunk.usage:
            usage = chunk.usage
    end = time.perf_counter()
    out = usage.completion_tokens if usage else 0
    return {
        "ttft": first - t0,
        "ttfct": (first_content or end) - t0,
        "e2e": end - t0,
        "tps": (out - 1) / (end - first) if out > 1 and end > first else 0,
        "prompt_tokens": usage.prompt_tokens if usage else None,
    }

runs = [timed("broadnet/gemma-4-26b-a4b", [{"role": "user", "content": "Summarise SSE in 100 words."}]) for _ in range(50)]
for k in ("ttft", "ttfct", "e2e", "tps"):
    xs = sorted(r[k] for r in runs)
    print(k, "p50", round(statistics.median(xs), 3), "p95", round(xs[int(len(xs) * 0.95) - 1], 3))

Limang patakaran para sa patas na benchmark:

  1. I-fix ang haba ng prompt at i-report ito. Magkaibang numero ang TTFT sa 500 prompt token at sa 200,000. Sinasabi sa iyo ng token counter kung gaano kahaba ang test prompt bago mo ito ipadala.
  2. I-fix ang haba ng output gamit ang max_tokens at isang prompt na pupuno rito, para maihahambing ang tokens per second.
  3. I-report ang p50 at p95, hindi ang mean. Ang tail latency ang naaalala ng mga user.
  4. Ikalat ang mga run sa iba’t ibang oras. Nagbabago ang load sa buong araw.
  5. Mag-warm up muna. Ang unang call ang nagbabayad para sa DNS, TLS at connection setup; gumamit ng iisang client.

Ano talaga ang nagpapabuti sa bawat numero?

Para pabutihin ang Gawin ito Bakit
TTFT Paikliin o i-cache ang prefix ng prompt Humahaba ang prefill time kasabay ng haba ng prompt; nilalaktawan ng mga cached prefix ang trabaho
TTFT Panatilihing warm ang mga connection, gumamit ng malapit na rehiyon Inaalis ang setup at mga round trip
Time to first content token Babaan ang reasoning effort, o gumamit ng non-reasoning model para sa mga simpleng hakbang Mas kaunting nakatagong pag-iisip bago ang sagot
Tokens per second Gumamit ng mas maliit o mas mabilis na model para sa hakbang Nakadepende ang decode speed sa laki ng model at sa pag-serve
End-to-end Humingi ng mas maikling output (schema, limit sa salita) Pinararami ng haba ng output ang ITL
End-to-end para sa maraming call Patakbuhin nang parallel ang magkakahiwalay na call sa loob ng concurrency limit mo Bumababa ang wall-clock time kahit pareho ang bawat call
Nararamdamang latency I-stream sa user Nagbabasa sila habang nagsusulat ang model

Ang haba ng output ang pinaka-hindi napapansing lever. Ang paghingi ng “JSON na may apat na field na ito” sa halip na “ipaliwanag ang sagot mo” ay puwedeng magpaikli ng generation time nang isang order of magnitude, nang walang anumang trabaho sa infrastructure. Nakakatulong dito ang structured output.

Tinatalakay ang cache lever sa istruktura ng prompt para sa caching. Mabilis tumatama sa rate limit ang parallelism lever; tingnan ang pag-handle ng 429 error.

Paano binabago ng haba ng prompt ang trade-off?

Humahaba ang TTFT kasabay ng prompt dahil kailangang iproseso ng model ang bawat input token bago ito makapagsulat. Iyan ang nakatagong gastos ng napakahahabang prompt at bahagi ng desisyon sa long context vs RAG: nasasagot ng 1M-token na prompt ang mga tanong na hindi kaya ng RAG, pero mas mabagal itong magsimula. Kung mahalaga ang interactive na bilis, panatilihing maikli ang hot path at ipadala lang ang malaking context kapag kailangan ito ng tanong.

Saan bagay ang BroadNet Inference

Naglalathala ang BroadNet ng karaniwang bilis na mga 100 token bawat segundo para sa plan model nito at nag-i-stream gamit ang standard na SSE format, kaya gagana nang walang pagbabago ang code sa itaas. Hindi ito naglalathala ng TTFT o latency SLA, kaya sukatin muna sa sarili mong mga prompt bago ka mag-commit; sapat ang $1 na Meteor hour para sa benchmark na 50 run, at sakop ng starting credit ang isang benchmark sa Gemma 4 VL 26B. Kung kailangan mo ng garantisadong latency na wala pang isang segundo sa malaking scale, mag-test nang mabuti: 4 request na in flight ang pinapayagan ng pay-as-you-go key, na mas bagay sa mga app at agent kaysa sa high-volume na real-time serving. Nasa mga page ng models at pricing ang mga model at ang presyo nila.

Mga tanong

Ano ang magandang time to first token para sa isang LLM API?

Para sa chat, mabilis ang pakiramdam kapag wala pang mga isang segundo sa maiikling prompt. Talagang mas matagal ang mahahabang prompt at mga reasoning model. Ihambing lang ang TTFT sa parehong haba ng prompt at parehong model.

Pareho ba ang tokens per second at throughput?

Hindi eksakto. Ang tokens per second kada user ay kung gaano kabilis mag-stream ang isang sagot. Ang throughput ay ang kabuuang token na ginagawa ng server para sa lahat ng user. Puwedeng pataasin ng provider ang kabuuang throughput habang bumabagal ang bilis ng bawat user.

Bakit napakataas ng TTFT sa reasoning model?

Gumagawa ang model ng nakatagong reasoning token bago ang nakikitang sagot. Puwedeng mabilis dumating ang unang token, pero naghihintay ang unang content token hanggang matapos ang pag-iisip. Babaan ang reasoning_effort para sa mga simpleng gawain.

Binabawasan ba ng streaming ang latency?

Hindi nito pinapaikli ang end-to-end na oras. Nababasa ng user ang sagot habang isinusulat pa ito, kaya bumababa ang nararamdamang latency sa halos TTFT lang.

Ilang request ang kailangan ko para sa maaasahang latency benchmark?

Sapat para makita ang tail. Ang limampu hanggang isandaang request kada laki ng prompt ay nagbibigay ng magagamit na p95. Ikalat ang mga ito sa buong araw, dahil nagbabago ang load.

Basahin bilang MarkdownTanungin ang ChatGPTTanungin ang ClaudeTanungin ang Perplexity