SSD Nodes Learn Hosting plans →
Panduan Matt ConnorOleh Matt Connor · Diperbarui 2026-10-23

Prefill vs Decode: Mengapa Token Pertama Lambat

Prefill menentukan time to first token karena terikat komputasi, sedangkan decode menentukan tokens per second karena terikat bandwidth memori. Ukur keduanya terpisah.

Prefill vs decode dalam satu paragraf

Prefill vs decode adalah satu perbedaan yang menjelaskan sebagian besar pertanyaan tentang latensi LLM (large language model) yang di-host sendiri. Prefill membaca seluruh prompt dalam satu lintasan dan dibatasi oleh kemampuan komputasi. Decode menulis jawaban satu token setiap kali dan dibatasi oleh bandwidth memori. Time to first token adalah nilai prefill. Tokens per second adalah nilai decode.

Kedua fase berjalan pada GPU (graphics processing unit) yang sama, menggunakan weights yang sama, di dalam proses yang sama. Karena itu, wajar jika keduanya dianggap sebagai satu workload. Namun, perilakunya seperti dua program berbeda yang berbagi satu perangkat. Jika dipisahkan, berbagai hasil yang membingungkan tidak lagi membingungkan.

Mengapa prefill terikat pada komputasi?

Prefill meneruskan seluruh prompt melalui setiap layer satu kali. Prompt sepanjang 2,000 token membuat setiap operasi perkalian matriks memproses 2,000 baris, sehingga GPU melakukan banyak operasi aritmetika untuk setiap byte bobot yang dimuat. Rasio antara operasi aritmetika dan byte yang dipindahkan disebut intensitas aritmetika, dan prefill memiliki intensitas yang tinggi. Perangkat bekerja mendekati batas komputasinya, sedangkan bus memori masih memiliki kapasitas yang tidak terpakai.

Prefill menghasilkan dua hal: cache KV (tensor key dan value) untuk setiap token prompt, serta token output pertama. Tidak ada keluaran yang sampai ke pembaca sebelum proses tersebut selesai. Karena itu, pada server yang tidak sibuk, prefill mencakup sebagian besar waktu hingga token pertama (TTFT). Menurut definisi dalam panduan benchmarking NVIDIA, TTFT juga mencakup antrean request dan latensi jaringan. Jadi, pada server yang sibuk, waktu tunggu dalam antrean dapat sama pentingnya dengan panjang prompt.

Biaya prefill bertambah seiring panjang prompt. Bagian linear berasal dari operasi matriks pada setiap layer. Bagian kuadratik berasal dari attention, ketika setiap token memperhatikan semua token sebelumnya. Bagian ini mulai berpengaruh pada context yang panjang. Jadi, menggandakan panjang prompt setidaknya menggandakan bagian prefill dari TTFT.

Anda dapat mengamati hal ini dalam satu menit. Kirim prompt sepanjang 200 token ke server Anda, lalu prompt sepanjang 2,000 token. Minta jumlah token output yang sama setiap kali. TTFT meningkat tajam. Kecepatan streaming setelah token pertama hampir tidak berubah.

Mengapa decode dibatasi bandwidth memori?

Decode menghasilkan satu token pada setiap langkah. Untuk menghasilkan satu token tersebut, GPU harus membaca semua bobot model dari memori, menggunakan setiap bobot untuk beberapa operasi, lalu membuangnya. Intensitas aritmetiknya mendekati 1, sehingga unit komputasi menghabiskan sebagian besar waktunya untuk menunggu.

Decode lambat karena setiap token memerlukan pembacaan seluruh model dari memori. Dengan demikian, bus memori menentukan kecepatannya dan unit komputasi menganggur.

Hal ini menentukan batas atas kecepatan decode satu stream berdasarkan perhitungan aritmetika. Bagi bandwidth memori dengan jumlah byte yang ditempati bobot.

GrafikPublished memory bandwidth and the decode ceiling it implies for a 16 GB model
Data di balik grafik ini
[
  {
    "device": "CPU, dual channel DDR5-5600",
    "mem_bandwidth_gb_s": 90,
    "decode_ceiling_tok_s": 6
  },
  {
    "device": "NVIDIA A10G",
    "mem_bandwidth_gb_s": 600,
    "decode_ceiling_tok_s": 38
  },
  {
    "device": "NVIDIA L40S",
    "mem_bandwidth_gb_s": 864,
    "decode_ceiling_tok_s": 54
  },
  {
    "device": "NVIDIA RTX 4090",
    "mem_bandwidth_gb_s": 1008,
    "decode_ceiling_tok_s": 63
  },
  {
    "device": "NVIDIA A100 80GB SXM",
    "mem_bandwidth_gb_s": 2039,
    "decode_ceiling_tok_s": 127
  },
  {
    "device": "NVIDIA H100 SXM",
    "mem_bandwidth_gb_s": 3350,
    "decode_ceiling_tok_s": 209
  }
]

Kolom bandwidth berisi angka spesifikasi yang dipublikasikan oleh setiap vendor. Kolom ceiling berisi angka tersebut yang dibagi dengan 16 GB, yaitu ukuran model dengan 8 miliar parameter yang disimpan pada presisi 16 bit. Ini adalah perhitungan aritmetika, bukan hasil benchmark. Laju yang Anda ukur akan berada di bawah angka tersebut. Mengetahui selisihnya berguna karena hal itu menunjukkan apakah Anda perlu memperbaiki stack serving atau perangkat keras.

Baca 6 baris tersebut secara berurutan. Polanya jelas. CPU dengan DDR5 dual-channel memiliki throughput sekitar 90 GB/s, yang membatasi decode hingga sekitar 6 token per detik untuk model tersebut. L40S berada di sekitar 54. H100 SXM, dengan bandwidth yang dipublikasikan sebesar 3350 GB/s, berada di sekitar 209.

Inilah juga alasan kuantisasi menjadi tuas tunggal terkuat untuk meningkatkan kecepatan decode. Simpan bobot yang sama pada 8 bit, bukan 16 bit, maka jumlah byte bobot yang dibaca untuk setiap token menjadi setengahnya dan ceiling kira-kira menjadi dua kali lipat. Namun, ceiling bukan hasil aktual. KV cache tetap dibaca sesuai ukurannya sendiri. Selain itu, beberapa format 8 bit menambahkan pekerjaan pada setiap token, seperti kuantisasi aktivasi dinamis per token yang didokumentasikan vLLM untuk salah satu skema FP8-nya. Karena itu, peningkatan yang terukur biasanya berada di bawah 2x. Tuas ini bekerja karena alasan yang sama dengan bergesernya ceiling: jumlah memori yang dipindahkan lebih sedikit.

Bagaimana cara mengukur setiap fase di server saya sendiri?

Ollama mengembalikan pembagian waktu dalam body respons. Minta completion non-streaming, lalu baca counternya.

curl -s http://localhost:11434/api/generate -d '{
  "model": "llama3.2",
  "prompt": "Explain memory bandwidth in two sentences.",
  "stream": false
}' | jq '{prompt_eval_count, prompt_eval_duration, eval_count, eval_duration}'

Gunakan model tag yang benar-benar sudah Anda pull. ollama list akan menampilkannya. prompt_eval_count dan prompt_eval_duration adalah prefill: jumlah token prompt dan waktu yang digunakan untuk memprosesnya. eval_count dan eval_duration adalah decode. Durasi dinyatakan dalam nanodetik, sehingga kecepatan decode adalah eval_count / eval_duration * 1e9 dan kecepatan prefill adalah prompt_eval_count / prompt_eval_duration * 1e9. Dokumentasi API Ollama menyatakan bahwa prompt_eval_duration hanya mencakup token prompt yang tidak berasal dari cache. Karena itu, ambil laju prefill dari prompt yang belum baru saja diproses oleh server. Pada request yang sama, laju prefill biasanya jauh lebih tinggi daripada laju decode. Perbedaan tersebut menjelaskan seluruh pembahasan berikutnya.

Untuk server yang kompatibel dengan OpenAI, seperti vLLM, curl dapat mengukur waktu hingga byte pertama untuk Anda.

curl -N -s -o /dev/null \
  -w 'pretransfer %{time_pretransfer}s  first_byte %{time_starttransfer}s\n' \
  http://localhost:8000/v1/completions \
  -H 'Content-Type: application/json' \
  -d '{"model": "meta-llama/Llama-3.1-8B-Instruct", "prompt": "Explain memory bandwidth.", "max_tokens": 128, "stream": true}'

time_starttransfer adalah waktu saat byte pertama dari body tiba. Dengan demikian, bersama "stream": true, nilainya mencakup TTFT dan penyiapan koneksi. Kurangi time_pretransfer untuk menghapus biaya penyiapan tersebut. Jalankan dua kali dan gunakan hasil kedua karena pemanggilan pertama dapat mencakup pemuatan model yang masih cold.

vLLM juga menerbitkan pembagian waktu tersebut sebagai metrik Prometheus pada /metrics. Jalankan curl -s http://localhost:8000/metrics | grep -E 'time_to_first_token|inter_token_latency' untuk mendapatkan histogram vllm:time_to_first_token_seconds dan vllm:inter_token_latency_seconds. Tambahkan vllm:num_requests_running dan vllm:num_requests_waiting untuk kedalaman antrean, serta vllm:kv_cache_usage_perc untuk tekanan cache. Kelima nama tersebut sudah mencakup seluruh dashboard.

Saat menerima beban, vllm bench serve --model <name> --num-prompts 200 --request-rate 4 menguji server yang sedang berjalan dan melaporkan waktu hingga token pertama serta latensi per token output dengan persentil. Ini merupakan cara paling langsung untuk melihat kedua fase tersebut saling bersaing pada stack yang sudah Anda jalankan. NVIDIA's GenAI-Perf dan LLMPerf mengukur metrik yang sama jika Anda lebih memilih tool terpisah. Sebelum melakukan tuning, ambil baseline yang bersih. Metode dalam mengukur token per detik pada LLM lokal menghasilkan baseline yang tetap dapat digunakan setelah reboot.

Mengapa system prompt yang panjang menunda token pertama, tetapi tidak memperlambat streaming?

Karena system prompt hanya menambah pekerjaan prefill. System prompt diproses sekali, dalam pass yang sama dengan bagian prompt lainnya, sebelum token pertama muncul. Setelah pass tersebut selesai, isinya hanya berada sebagai entri KV cache, dan proses decode membacanya bersama entri lainnya. Jadi, tanpa prefix caching, system prompt sepanjang 3,000 token menambah TTFT pada setiap request, tetapi hampir tidak mengubah jumlah token per detik.

Hampir, bukan sepenuhnya. Entri KV tambahan tersebut tetap dibaca pada setiap langkah decode, sehingga prompt yang sangat panjang sedikit memperlambat proses decode. Bagian berikutnya membahas hal ini.

Solusinya adalah menghentikan penghitungan ulang prefix yang sama. Server dengan prefix caching menyimpan KV cache dari prefix bersama dan menggunakannya kembali. Dengan demikian, request kedua yang membawa system prompt yang sama dapat melewati bagian prefill tersebut sepenuhnya. vLLM menyebut fitur ini automatic prefix caching. Periksa vllm serve --help pada versi yang Anda gunakan karena nilai defaultnya berubah pada berbagai rilis. KV cache di GPU ini berbeda dari prompt cache yang menjadi dasar penagihan oleh penyedia API. Baca perbedaan antara KV cache dan prompt cache sebelum mengoptimalkan salah satunya.

Mengapa decode melambat saat context semakin penuh?

Ada dua alasan, dan keduanya berkaitan dengan KV cache.

Alasan pertama adalah bandwidth. Pada setiap langkah decode, attention membaca key dan value dari setiap token sebelumnya. Bobot model merupakan biaya tetap per token. KV cache terus bertambah. Ukurannya dapat dihitung dari config.json model: jumlah byte per token sama dengan 2 dikalikan num_hidden_layers, num_key_value_heads, dimensi head, dan jumlah byte per elemen. Gunakan head_dim jika konfigurasi mencantumkannya. Gunakan hidden_size dibagi num_attention_heads hanya jika konfigurasi tidak mencantumkannya, karena beberapa model menetapkan kedua nilai tersebut secara terpisah. Sebagai contoh, Mistral NeMo memiliki width 5,120 dan 32 head, tetapi dimensi head-nya 128, bukan 160. Angka 2 di awal menghitung satu key dan satu value.

Pada layout umum dengan 8 miliar parameter, 32 layer, 8 key dan value head di bawah GQA (grouped query attention), dimensi head 128, dan presisi 16 bit, perhitungannya adalah 2 x 32 x 8 x 128 x 2 = 131,072 byte, atau sekitar 128 KiB per token. Percakapan sepanjang 8,000 token dengan demikian menggunakan sekitar 1 GB KV cache untuk setiap request.

Alasan kedua adalah kapasitas. Memori sebesar 1 GB tersebut tidak dapat digunakan untuk menyimpan bobot atau context pengguna lain. Server menentukan ukuran pool KV satu kali saat startup, pada vLLM melalui --gpu-memory-utilization. Saat pool penuh, request baru harus menunggu. Nilai vllm:num_requests_waiting yang terus naik ketika vllm:kv_cache_usage_perc berada mendekati 1 merupakan tanda yang tepat untuk kondisi tersebut. Beberapa stack melakukan preemption terhadap request yang sedang berjalan, lalu menghitung ulang cache-nya nanti, alih-alih memasukkannya ke antrean. Bagi pengguna, hal ini terasa sebagai jeda di tengah stream.

Context yang panjang menimbulkan dua biaya: pekerjaan prefill yang lebih besar di awal dan pembacaan memori yang lebih banyak untuk setiap token sepanjang sisa jawaban.

Mengapa batching meningkatkan throughput tetapi memperburuk tail latency?

Karena decode dibatasi oleh bandwidth, request tambahan hampir tidak menambah beban pada sisi komputasi. Satu kali pembacaan bobot dapat menghasilkan satu token untuk setiap sequence dalam batch, sehingga throughput total meningkat hampir secara linear seiring ukuran batch sampai KV pool habis atau batch menjadi cukup besar sehingga kembali dibatasi oleh komputasi. Continuous batching membentuk ulang batch pada setiap langkah. Dengan demikian, request yang selesai keluar dan request yang mengantre masuk tanpa menunggu request lain dalam batch.

Biayanya terlihat pada persentil. Token berikutnya untuk setiap pengguna kini menunggu bagian paling lambat dari langkah bersama. Akibatnya, p50, yaitu median, tetap dapat diterima, sedangkan p99, yaitu 1 request paling lambat dari setiap 100 request, menjadi lebih panjang. p99 paling mudah dirasakan pengguna karena berupa jeda di tengah kalimat.

Prefill membuat efek ini lebih jelas. Prompt besar yang tiba di tengah streaming akan menggunakan device selama satu langkah panjang, sehingga semua pengguna yang sedang menerima token melihat jeda. Chunked prefill mengurangi sebagian besar masalah ini dengan membagi prompt panjang menjadi beberapa bagian dan mencampurkan setiap bagian ke dalam batch decode. Per Oktober 2026, engine vLLM V1 melakukan ini secara default dan menyediakan pengaturan keseimbangannya melalui --max-num-batched-tokens. Dokumentasi tuning vLLM menjelaskan tradeoff ini secara langsung: nilai yang lebih kecil, sekitar 2048, menghasilkan inter token latency (ITL) yang lebih baik karena lebih sedikit prefill yang menyela decode, sedangkan nilai yang lebih besar menghasilkan TTFT yang lebih baik karena lebih banyak token prefill dapat dimasukkan ke dalam satu batch. Flag tunggal ini mengekspos perbandingan prefill dan decode sebagai angka yang dapat diatur. Batas ketika p99 tidak lagi dapat diterima bergantung pada kapasitas. berapa banyak pengguna bersamaan yang dapat dilayani oleh LLM self-hosted membahasnya menggunakan metrik yang sama.

Mengapa GPU yang lebih besar terkadang tidak mengubah apa pun?

Karena ukuran yang lebih besar biasanya berarti komputasi yang lebih besar, sedangkan decode tidak membutuhkan komputasi.

Bandingkan dua baris pada bagan di atas. A100 80GB memiliki bandwidth yang dipublikasikan sebesar 2039 GB/s, sedangkan L40S memiliki 864 GB/s. Batas decode juga mengikuti angka tersebut: 127 token per detik dibandingkan dengan 54. RTX 4090 merupakan kartu yang sangat cepat menurut sebagian besar ukuran, dan bandwidth 1008 GB/s menempatkan batasnya pada 63. Terlepas dari perbedaan lain antara dua kartu, decode single-stream mengikuti angka bandwidth pada lembar spesifikasi.

Jadi, ada dua cara untuk mempercepat decode: membaca lebih sedikit byte untuk setiap token (mengkuantisasi weight, atau menjalankan model yang lebih kecil), atau membeli bandwidth yang lebih besar. Prefill merupakan kasus yang berlawanan. Prefill membutuhkan komputasi, sehingga kartu yang lebih cepat benar-benar mengurangi TTFT pada prompt yang panjang. Jika masalahnya adalah token pertama membutuhkan waktu empat detik, hardware yang lebih baik mungkin dapat mengatasinya. Jika masalahnya adalah teks muncul secara perlahan, kemungkinan besar hardware yang lebih baik tidak akan membantu.

Jalankan prefill dan decode pada worker terpisah?

Stack serving berskala besar memang melakukan hal ini. Teknik tersebut disebut disaggregation prefill dan decode. Satu pool worker hanya menjalankan prefill, sedangkan pool kedua hanya menjalankan decode. KV cache yang dibuat oleh pool pertama kemudian ditransfer ke pool kedua melalui interkoneksi berkecepatan tinggi. Teknik ini berfungsi karena kedua fase memerlukan perangkat keras dan penjadwalan yang berbeda. Prefill memerlukan komputasi dan batch token yang besar. Decode memerlukan bandwidth dan banyak sequence yang berjalan secara bersamaan. Pemisahan ini memungkinkan setiap pool diskalakan secara independen. Cara ini juga mencegah satu prompt yang sangat besar menahan semua stream aktif.

Pada satu VPS (virtual private server) dengan satu GPU, penerapan ini hampir tidak pernah sepadan. Anda membagi satu perangkat untuk dirinya sendiri. Selain itu, pointer akan diubah menjadi transfer jaringan yang membawa cache berukuran gigabyte. Teknik ini mulai bermanfaat setelah Anda memiliki akselerator yang cukup untuk mendedikasikan seluruh mesin bagi setiap fase, serta trafik stabil yang cukup untuk menjaga kedua pool tetap sibuk. Sebelum mencapai kondisi tersebut, chunked prefill memberikan sebagian besar isolasi yang sama hanya dengan satu flag.

Hal yang perlu diubah ketika angkanya buruk

Jika TTFT terlalu tinggi:

  • Persingkat prompt. Biaya prefill mengikuti jumlah token prompt, dan tanpa prefix caching, system prompt diproses pada setiap request.
  • Aktifkan prefix caching agar prefix yang berulang dihitung satu kali, bukan pada setiap request.
  • Naikkan --max-num-batched-tokens agar lebih banyak pekerjaan prefill diproses dalam setiap langkah.
  • Periksa antrean sebelum menyalahkan model. vllm:num_requests_waiting di atas nol berarti request belum mulai diproses. Ini menunjukkan masalah kapasitas.

Jika jumlah token per detik terlalu rendah:

  • Lakukan kuantisasi pada weight. Semakin sedikit byte per weight, semakin sedikit byte yang harus dibaca untuk setiap token.
  • Bandingkan memory bandwidth kartu yang dipublikasikan dengan grafik di atas, lalu periksa seberapa dekat nilainya dengan batas maksimum.
  • Turunkan --max-num-batched-tokens agar prefill lebih jarang menginterupsi decode.
  • Periksa panjang context. Percakapan yang telah berkembang hingga ribuan token membaca KV cache yang jauh lebih besar pada setiap langkah.

Runtime juga berpengaruh karena Ollama dan vLLM menjadwalkan prefill dan decode secara berbeda, dan pengaturan yang membantu salah satunya mungkin tidak berpengaruh pada yang lain. Lakukan pengukuran terlebih dahulu pada kedua fase, lalu ubah satu hal pada satu waktu.

FAQ

Mengapa token pertama memerlukan waktu beberapa detik, tetapi token berikutnya dihasilkan dengan cepat?

Waktu tunggu tersebut adalah prefill, sedangkan proses streaming adalah decode. Prefill memproses seluruh prompt dalam satu tahap yang dibatasi oleh komputasi sebelum output apa pun tersedia, sehingga biayanya meningkat seiring panjang prompt. Decode kemudian menghasilkan satu token per langkah dengan kecepatan yang ditentukan oleh bandwidth memori, yang hampir tidak bergantung pada panjang prompt. System prompt yang panjang pada setiap request biasanya menjadi penyebabnya. Prefix caching menghilangkan pengulangan biaya tersebut.

Apakah prompt yang lebih panjang memperlambat jumlah token per detik?

Sedikit, dan alasannya berbeda dari TTFT. Setiap langkah decode membaca key dan value dari semua token sebelumnya, sehingga KV cache yang lebih besar berarti lebih banyak byte yang dibaca untuk setiap token. Pada layout umum dengan 8 billion parameter, cache berukuran sekitar 128 KiB per token. Jadi, context sepanjang 8,000 token kira-kira berukuran 1 GB yang diakses pada setiap langkah. Dampak terbesar dari prompt yang panjang tetap terjadi pada TTFT, bukan pada kecepatan streaming.

Spesifikasi GPU mana yang memprediksi kecepatan decode?

Bandwidth memori. Bagi bandwidth yang dipublikasikan dengan ukuran weight di memori, dan Anda mendapatkan batas aritmetis untuk satu stream. GPU dengan kemampuan komputasi lebih besar tetapi bandwidth yang sama tidak akan menghasilkan streaming yang lebih cepat. Itu juga sebabnya quantization weight menjadi 8 bit secara kasar menggandakan batas decode: jumlah byte weight yang dibaca per token berkurang setengah. Peningkatan yang terukur biasanya lebih kecil karena KV cache tetap dibaca sesuai ukurannya, dan beberapa format 8 bit menambahkan pekerjaan per token, seperti quantization activation.

Mengapa throughput meningkat ketika saya menambahkan user, tetapi setiap user terasa lebih lambat?

Satu pembacaan weight dapat melayani satu token untuk setiap sequence dalam batch, sehingga total token per detik meningkat seiring ukuran batch. Setiap token individual kini harus menunggu langkah bersama, sehingga latensi per user meningkat pada saat yang sama. Pantau latensi inter-token p99, bukan angka throughput agregat, dan periksa vllm:num_requests_waiting untuk mengetahui apakah request sedang mengantre, bukan berjalan.

Apakah artikel ini bermanfaat?