Prefill và decode: Vì sao token đầu tiên chậm?
Prefill bị giới hạn bởi năng lực tính toán và quyết định time to first token; decode bị giới hạn bởi băng thông bộ nhớ và quyết định token/giây. Đo riêng trên máy bạn.
Prefill và decode trong một đoạn văn
Prefill và decode là một phân biệt giúp giải thích phần lớn các câu hỏi về độ trễ của LLM (large language model) tự host. Prefill đọc toàn bộ prompt trong một lượt và bị giới hạn bởi năng lực tính toán. Decode tạo câu trả lời từng token một và bị giới hạn bởi băng thông bộ nhớ. Thời gian đến token đầu tiên là chỉ số của prefill. Số token mỗi giây là chỉ số của decode.
Cả hai giai đoạn đều chạy trên cùng GPU (graphics processing unit), dùng cùng weights và nằm trong cùng một process, nên việc xem chúng là một workload là điều tự nhiên. Chúng hoạt động như hai chương trình khác nhau cùng chia sẻ một thiết bị. Khi tách riêng hai giai đoạn này, một danh sách dài các kết quả khó hiểu sẽ không còn khó hiểu nữa.
Vì sao prefill bị giới hạn bởi năng lực tính toán?
Prefill đưa toàn bộ prompt qua từng layer đúng một lần. Với prompt 2,000 token, mỗi phép nhân ma trận có 2,000 hàng cần xử lý, nên GPU thực hiện rất nhiều phép tính cho mỗi byte weight được tải. Tỷ lệ giữa số phép tính và số byte được di chuyển này gọi là arithmetic intensity, và prefill có arithmetic intensity cao. Thiết bị hoạt động gần giới hạn tính toán, còn memory bus vẫn chưa bị tận dụng hết.
Prefill tạo ra 2 thứ: KV cache (các tensor key và value) cho từng token trong prompt, và token đầu tiên trong output. Reader không nhận được gì cho đến khi pass này hoàn tất. Vì vậy, trên server đang rảnh, prefill chiếm phần lớn thời gian để tạo token đầu tiên (TTFT). Theo định nghĩa trong hướng dẫn benchmark của NVIDIA, TTFT cũng bao gồm thời gian request nằm trong queue và network latency. Vì vậy, trên server bận, thời gian chờ trong queue có thể ảnh hưởng tương đương với độ dài prompt.
Chi phí prefill tăng theo độ dài prompt. Phần tuyến tính là công việc nhân ma trận ở mỗi layer. Phần bậc hai là attention, trong đó mỗi token chú ý đến mọi token đứng trước nó. Phần này bắt đầu đáng kể khi context dài. Vì vậy, khi tăng gấp đôi prompt, phần prefill trong TTFT ít nhất cũng tăng gấp đôi.
Bạn có thể kiểm tra điều này trong 1 phút. Gửi prompt 200 token đến server, sau đó gửi prompt 2,000 token. Mỗi lần yêu cầu cùng một số lượng output token. TTFT sẽ tăng mạnh. Tốc độ streaming sau token đầu tiên gần như không thay đổi.
Vì sao decode bị giới hạn bởi memory bandwidth?
Decode tạo ra một token trong mỗi step. Để tạo token đó, GPU phải đọc toàn bộ weight của model từ memory, dùng mỗi weight cho một vài phép toán rồi loại bỏ nó. Arithmetic intensity gần bằng 1, nên các compute unit dành phần lớn thời gian để chờ.
Decode chậm vì mỗi token yêu cầu đọc toàn bộ model từ memory. Vì vậy memory bus quyết định tốc độ, còn các compute unit phần lớn ở trạng thái nhàn rỗi.
Do đó, giới hạn trên của tốc độ decode một stream đơn là tốc độ tính toán lý thuyết. Lấy memory bandwidth chia cho số byte mà các weight chiếm dụng.
Dữ liệu đằng sau biểu đồ này
[
{
"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
}
]Cột bandwidth chứa thông số do từng vendor công bố. Cột ceiling là thông số đó chia cho 16 GB, tương ứng với model 8 tỷ parameter được lưu ở độ chính xác 16 bit. Đây là phép tính lý thuyết, không phải kết quả benchmark. Tốc độ đo được sẽ thấp hơn mức này. Biết mức chênh lệch là bao nhiêu rất hữu ích, vì nó cho biết bạn nên tối ưu serving stack hay nâng cấp hardware.
Đọc 6 dòng theo thứ tự, bạn sẽ thấy quy luật rõ ràng. CPU dùng dual channel DDR5 đạt khoảng 90 GB/s, nên tốc độ decode của model đó bị giới hạn ở gần 6 token mỗi giây. L40S đạt gần 54. H100 SXM có bandwidth được công bố là 3350 GB/s, nên đạt gần 209.
Đây cũng là lý do quantization là đòn bẩy đơn lẻ mạnh nhất để tăng tốc decode. Lưu cùng các weight ở 8 bit thay vì 16 bit sẽ giảm một nửa số byte của weight phải đọc cho mỗi token, nên ceiling tăng gần gấp đôi. Tuy nhiên, ceiling không phải tốc độ thực tế. KV cache vẫn được đọc theo kích thước riêng, và một số format 8 bit làm tăng lượng công việc cho mỗi token, chẳng hạn dynamic per-token activation quantization được vLLM mô tả cho một trong các scheme FP8 của nó. Vì vậy, mức tăng đo được thường thấp hơn 2x. Đòn bẩy này có hiệu quả vì cùng lý do ceiling tăng: bạn phải di chuyển ít memory hơn.
Làm thế nào để đo từng phase trên server của tôi?
Ollama trả về phần tách trong response body. Gửi yêu cầu completion không streaming và đọc các counter.
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}'Dùng model tag mà bạn đã pull thực tế; ollama list sẽ hiển thị tag đó. prompt_eval_count và prompt_eval_duration là prefill: số lượng prompt token và thời gian xử lý chúng. eval_count và eval_duration là decode. Thời lượng tính bằng nanosecond, nên tốc độ decode là eval_count / eval_duration * 1e9 và tốc độ prefill là prompt_eval_count / prompt_eval_duration * 1e9. Tài liệu API của Ollama cho biết prompt_eval_duration chỉ tính các prompt token chưa có trong cache, vì vậy hãy lấy tốc độ prefill từ một prompt mà server chưa vừa xử lý. Trên cùng một request, tốc độ prefill thường cao hơn nhiều so với tốc độ decode. Phần chênh lệch đó được giải thích trong các phần còn lại.
Với OpenAI compatible server như vLLM, curl có thể đo thời điểm nhận byte đầu tiên.
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 là thời điểm byte đầu tiên của body được nhận, nên khi dùng cùng "stream": true, giá trị này bao gồm TTFT và thời gian thiết lập connection. Trừ time_pretransfer để loại bỏ chi phí thiết lập. Chạy 2 lần và giữ kết quả lần 2, vì lần gọi đầu tiên có thể bao gồm thời gian load model khi cache đang cold.
vLLM cũng công bố phần tách này dưới dạng Prometheus metrics tại /metrics. Chạy curl -s http://localhost:8000/metrics | grep -E 'time_to_first_token|inter_token_latency' để lấy các histogram vllm:time_to_first_token_seconds và vllm:inter_token_latency_seconds. Thêm vllm:num_requests_running và vllm:num_requests_waiting để theo dõi queue depth, và vllm:kv_cache_usage_perc để theo dõi áp lực cache. 5 tên này là toàn bộ dashboard.
Khi có tải, vllm bench serve --model <name> --num-prompts 200 --request-rate 4 điều khiển server đang chạy và báo cáo time to first token cùng latency của từng output token theo percentile. Đây là cách trực tiếp nhất để thấy 2 phase cạnh tranh nhau trên stack bạn đang chạy. NVIDIA's GenAI-Perf và LLMPerf cũng đo các chỉ số tương tự nếu bạn muốn dùng một tool riêng. Trước khi tuning, hãy lấy baseline sạch: phương pháp trong đo token mỗi giây trên LLM local cung cấp một baseline vẫn dùng được sau khi reboot.
Vì sao system prompt dài làm chậm token đầu tiên nhưng không làm giảm tốc độ streaming?
Vì system prompt là phần việc prefill, không có tác động nào khác. Nó được xử lý một lần, trong cùng lượt với phần còn lại của prompt, trước khi token đầu tiên xuất hiện. Sau lượt đó, nội dung chỉ còn dưới dạng các entry trong KV cache, và quá trình decode đọc chúng cùng với mọi thành phần khác. Vì vậy, nếu không có prefix caching, system prompt dài 3,000 token sẽ làm tăng TTFT trong mọi request, nhưng hầu như không thay đổi số token mỗi giây.
Không hoàn toàn như vậy. Các entry KV bổ sung vẫn được đọc lại ở mỗi bước decode, nên prompt rất dài vẫn làm giảm nhẹ tốc độ decode. Phần tiếp theo sẽ giải thích việc này.
Cách khắc phục là không tính toán lại cùng một prefix. Server có prefix caching sẽ giữ KV cache của một prefix dùng chung và tái sử dụng nó, nên request thứ hai có cùng system prompt sẽ bỏ qua hoàn toàn phần prefill đó. vLLM gọi tính năng này là automatic prefix caching; hãy kiểm tra vllm serve --help trên phiên bản bạn đang dùng, vì giá trị mặc định đã thay đổi qua các bản release. KV cache nằm trong GPU này khác với prompt cache mà API provider dùng để tính phí, và sự khác nhau giữa KV cache và prompt cache đáng để đọc trước khi bạn tinh chỉnh một trong hai loại cache này.
Vì sao decode chậm dần khi context đầy?
Có 2 nguyên nhân, cả hai đều liên quan đến KV cache.
Nguyên nhân thứ nhất là băng thông. Ở mỗi bước decode, attention đọc key và value của mọi token trước đó. Weights là chi phí cố định trên mỗi token. KV cache thì tăng dần. Bạn có thể tính kích thước của nó từ config.json của model: số byte trên mỗi token bằng 2 nhân với num_hidden_layers, với num_key_value_heads, với head dimension, rồi với số byte trên mỗi phần tử. Dùng head_dim khi config có khai báo giá trị này, và chỉ dùng hidden_size chia cho num_attention_heads khi config không có, vì một số model đặt 2 giá trị này độc lập. Ví dụ, Mistral NeMo có width 5,120 và 32 head nhưng head dimension là 128, không phải 160. Số 2 ở đầu là 1 key và 1 value.
Với một layout phổ biến cho model 8 billion parameter, gồm 32 layer, 8 key và value head khi dùng GQA (grouped query attention), head dimension 128 và precision 16 bit, phép tính là 2 x 32 x 8 x 128 x 2 = 131,072 byte, tương đương khoảng 128 KiB trên mỗi token. Một cuộc hội thoại 8,000 token vì vậy mang theo khoảng 1 GB KV cache cho mỗi request.
Nguyên nhân thứ hai là capacity. 1 GB đó là phần memory không thể dùng để chứa weights hoặc context của user khác. Server cấp phát KV pool một lần khi khởi động, trên vLLM thông qua --gpu-memory-utilization, và khi pool đầy, các request mới sẽ phải chờ. vllm:num_requests_waiting tăng trong khi vllm:kv_cache_usage_perc ở gần 1 là dấu hiệu chính xác của trạng thái này. Một số stack sẽ preempt request đang chạy rồi tính lại cache sau, thay vì đưa request vào queue. User sẽ thấy stream bị stall giữa chừng.
Context dài gây tốn tài nguyên theo 2 cách: cần nhiều công việc prefill hơn lúc bắt đầu và cần đọc nhiều memory hơn ở mỗi token trong phần còn lại của câu trả lời.
Vì sao batching giúp tăng throughput nhưng làm xấu tail latency?
Vì decode bị giới hạn bởi bandwidth, các request bổ sung gần như không tốn thêm chi phí ở phía compute. Một lần đọc weights có thể tạo ra một token cho mọi sequence trong batch, nên tổng throughput tăng gần tuyến tính theo batch size cho đến khi KV pool hết chỗ hoặc batch đủ lớn để lại bị giới hạn bởi compute. Continuous batching tạo lại batch ở mỗi step, nên request đã hoàn tất sẽ rời đi và request đang xếp hàng sẽ tham gia mà không phải chờ các request lân cận.
Chi phí xuất hiện trong các percentile. Next token của mỗi user giờ phải chờ phần chậm nhất của một step dùng chung, nên p50, tức median, vẫn ở mức chấp nhận được còn p99, tức 1 request chậm nhất trong 100 request, tăng lên. Người dùng nhận thấy p99 vì đó là khoảng dừng xảy ra giữa một câu.
Prefill làm vấn đề rõ hơn. Một prompt lớn đến giữa stream sẽ chiếm device trong một step dài, khiến tất cả request đang stream bị gián đoạn. Chunked prefill giảm phần lớn ảnh hưởng này bằng cách chia prompt dài thành nhiều phần rồi trộn từng phần vào các batch decode. Tính đến October 2026, vLLM V1 engine thực hiện việc này theo mặc định và cho phép điều chỉnh mức cân bằng qua --max-num-batched-tokens. Tài liệu tuning của vLLM nêu rõ trade-off: các giá trị nhỏ hơn, khoảng 2048, cho inter token latency (ITL) tốt hơn vì ít prefill interrupt decode hơn; các giá trị lớn hơn cho TTFT tốt hơn vì có nhiều prefill token hơn trong một batch. Flag này biểu diễn trực tiếp quan hệ giữa prefill và decode dưới dạng một giá trị có thể điều chỉnh. Mức p99 nào còn chấp nhận được là câu hỏi về capacity, và bao nhiêu user đồng thời mà một LLM tự host có thể phục vụ sẽ phân tích vấn đề này bằng cùng các metric.
Vì sao GPU lớn hơn đôi khi không thay đổi gì?
Vì “lớn hơn” thường có nghĩa là nhiều năng lực tính toán hơn, trong khi decode không cần nhiều năng lực tính toán.
Hãy so sánh hai dòng trong biểu đồ ở trên. A100 80GB có băng thông được công bố là 2039 GB/s, còn L40S là 864 GB/s. Mức trần decode cũng khớp chính xác: 127 token mỗi giây so với 54. RTX 4090 là một card rất nhanh xét theo hầu hết tiêu chí, và băng thông 1008 GB/s đặt mức trần của nó ở 63. Dù hai card còn khác nhau ở điểm nào, decode một stream vẫn bám theo mức băng thông trên bảng thông số.
Vì vậy, có 2 cách để decode nhanh hơn: đọc ít byte hơn cho mỗi token (quantize weight hoặc chạy model nhỏ hơn), hoặc mua GPU có băng thông cao hơn. Prefill thì ngược lại. Prefill cần năng lực tính toán, nên card nhanh hơn thực sự rút ngắn TTFT với prompt dài. Nếu vấn đề là token đầu tiên mất 4 giây mới xuất hiện, phần cứng tốt hơn có thể giải quyết được. Nếu vấn đề là văn bản hiển thị chậm từng token, phần cứng tốt hơn có lẽ không giúp được.
Có nên chạy prefill và decode trên các worker riêng không?
Các stack serving lớn thực hiện đúng việc này. Kỹ thuật này gọi là tách prefill và decode. Một pool worker chỉ chạy prefill. Pool thứ hai chỉ chạy decode. KV cache do pool đầu tiên tạo ra được truyền sang pool thứ hai qua interconnect tốc độ cao. Cách này hiệu quả vì hai phase cần phần cứng và cơ chế scheduling khác nhau. Prefill cần năng lực tính toán và các batch token lớn. Decode cần băng thông và nhiều sequence chạy đồng thời. Tách hai phase cho phép mỗi pool scale độc lập. Nó cũng ngăn một prompt rất lớn làm stall mọi stream đang hoạt động.
Trên một VPS (virtual private server) chỉ có một GPU, cách này gần như không bao giờ đáng làm. Bạn sẽ chia một thiết bị thành hai phần để tự phục vụ lẫn nhau. Đồng thời, bạn sẽ biến thao tác truyền pointer thành việc truyền hàng gigabyte cache qua network. Kỹ thuật này chỉ đem lại hiệu quả khi bạn có đủ accelerator để dành hẳn từng máy cho mỗi phase, và có đủ traffic ổn định để giữ cả hai pool luôn bận. Nếu chưa đạt mức đó, chunked prefill mang lại phần lớn khả năng cô lập tương tự chỉ với một flag.
Cần thay đổi gì khi các chỉ số không đạt
Khi TTFT quá cao:
- Rút ngắn prompt. Chi phí prefill tăng theo số token trong prompt. Nếu không bật prefix caching, system prompt sẽ được tính lại trong mọi request.
- Bật prefix caching để phần prefix lặp lại chỉ được tính một lần thay vì tính lại mỗi lần.
- Tăng
--max-num-batched-tokensđể đưa nhiều tác vụ prefill hơn vào mỗi step. - Kiểm tra queue trước khi đổ lỗi cho model.
vllm:num_requests_waitinglớn hơn 0 nghĩa là request chưa bắt đầu xử lý. Đây là vấn đề về capacity.
Khi số token mỗi giây quá thấp:
- Quantize các weight. Mỗi weight cần ít byte hơn thì phải đọc ít byte hơn cho mỗi token.
- Kiểm tra memory bandwidth được công bố cho card của bạn, đối chiếu với biểu đồ ở trên và xem tốc độ hiện tại gần giới hạn đến đâu.
- Giảm
--max-num-batched-tokensđể prefill ít làm gián đoạn decode hơn. - Kiểm tra context length. Khi một cuộc hội thoại tăng lên hàng nghìn token, mỗi step phải đọc một KV cache lớn hơn nhiều.
Runtime cũng có vai trò ở đây, vì Ollama và vLLM lên lịch prefill và decode khác nhau, và một setting có thể giúp runtime này nhưng không có tác dụng trên runtime kia. Trước tiên hãy đo ở cả hai phase, sau đó chỉ thay đổi một yếu tố mỗi lần.
FAQ
Vì sao token đầu tiên mất vài giây nhưng các token sau lại stream nhanh?
Thời gian chờ đó là prefill, còn quá trình stream là decode. Prefill xử lý toàn bộ prompt trong một lượt bị giới hạn bởi năng lực tính toán trước khi có output, nên chi phí tăng theo độ dài prompt. Sau đó, decode sinh một token trong mỗi bước với tốc độ phụ thuộc vào memory bandwidth và gần như không phụ thuộc vào độ dài prompt. Nguyên nhân thường gặp là system prompt dài được gửi lại trong mọi request. Prefix caching loại bỏ phần chi phí lặp lại này.
Prompt dài hơn có làm giảm số token mỗi giây không?
Có, nhưng chỉ một chút và vì lý do khác với TTFT. Mỗi bước decode phải đọc key và value của tất cả token trước đó, nên KV cache lớn hơn đồng nghĩa với nhiều byte phải đọc hơn cho mỗi token. Với layout 8 billion parameter phổ biến, cache chiếm khoảng 128 KiB cho mỗi token, nên context 8,000 token tương đương khoảng 1 GB phải được đọc ở mỗi bước. Tác động lớn hơn của prompt dài vẫn nằm ở TTFT, không phải tốc độ stream.
Thông số GPU nào dự đoán decode speed?
Memory bandwidth. Lấy bandwidth được công bố chia cho kích thước weights trong memory, bạn sẽ có giới hạn lý thuyết cho một stream. Một card có năng lực tính toán cao hơn nhưng cùng bandwidth sẽ không stream nhanh hơn. Đây cũng là lý do quantize weights xuống 8 bit có thể gần như tăng gấp đôi giới hạn decode: số byte weights phải đọc cho mỗi token giảm một nửa. Mức tăng đo được thường thấp hơn vì KV cache vẫn được đọc theo kích thước riêng, và một số format 8 bit phát sinh thêm công việc cho mỗi token, chẳng hạn quantize activation.
Vì sao throughput tăng khi tôi thêm user nhưng mỗi user lại thấy chậm hơn?
Một lần đọc weights có thể phục vụ một token cho mọi sequence trong batch, nên tổng số token mỗi giây tăng theo batch size. Mỗi token riêng lẻ hiện phải chờ một bước dùng chung, vì vậy latency trên mỗi user cũng tăng. Hãy theo dõi p99 inter-token latency thay vì chỉ xem số throughput tổng, và kiểm tra vllm:num_requests_waiting để biết request đang xếp hàng hay đang được xử lý.