LLM performansında prefill ve decode farkı nedir?
Prefill islemi hesaplama gucuyle, decode ise bellek bant genisligiyle sinirlidir. Ilk token suresi ve saniyedeki token sayisini ayri olcerek model performansini optimize edin.
Prefill ve decode karşılaştırması
Prefill ve decode ayrımı, self-hosted LLM (büyük dil modeli) kurulumlarında karşılaşılan gecikme sorunlarının çoğunu açıklayan temel unsurdur. Prefill aşaması, tüm istemi tek bir geçişte okur ve işlem gücü (compute) ile sınırlıdır. Decode aşaması ise yanıtı her seferinde tek bir token olacak şekilde yazar ve bellek bant genişliği (memory bandwidth) ile sınırlıdır. İlk token'a ulaşma süresi (time to first token) bir prefill değeridir; saniyedeki token sayısı (tokens per second) ise bir decode değeridir. Her iki aşama da aynı GPU (grafik işlem birimi) üzerinde, aynı ağırlıklarla ve aynı süreç içerisinde çalıştığından, bunları tek bir iş yükü olarak değerlendirmek doğaldır. Ancak bu aşamalar, tek bir cihazı paylaşan iki farklı program gibi davranır. Bu iki süreci birbirinden ayırdığınızda, karmaşık görünen birçok performans sonucu anlam kazanmaya başlar.
Prefill işlemi neden hesaplama (compute) sınırlıdır?
Prefill, tüm istemi (prompt) her katmandan bir kez geçirir. 2.000 token'lık bir istem, her matris çarpımı için 2.000 satırlık iş yükü oluşturur; bu nedenle GPU, yüklediği her bir ağırlık baytı için yoğun aritmetik işlem yapar. Taşınan bayt başına düşen aritmetik işlem oranı "aritmetik yoğunluk" olarak adlandırılır ve prefill aşamasında bu oran yüksektir. Cihaz, hesaplama sınırına yakın çalışır ve bellek veri yolu (memory bus) boşta kalır.
Prefill iki sonuç üretir: her istem token'ı için KV cache (key ve value tensörleri) ve ilk çıktı token'ı. Bu işlem tamamlanana kadar kullanıcıya herhangi bir veri ulaşmaz; bu nedenle boş bir sunucuda TTFT (ilk token'a kadar geçen süre) değerinin büyük kısmını prefill oluşturur. NVIDIA'nın kıyaslama kılavuzunda tanımladığı TTFT; istek kuyruğunu ve ağ gecikmesini de içerir, dolayısıyla yoğun bir sunucuda kuyrukta bekleme süresi, istemin kendisi kadar önemli olabilir.
Prefill maliyeti, istem uzunluğu ile birlikte artar. Maliyetin doğrusal kısmı, katman başına düşen matris işlemleridir. Karesel (quadratic) kısmı ise her token'ın kendinden önceki tüm token'lara odaklandığı attention mekanizmasıdır ve uzun bağlamlarda (context) önem kazanmaya başlar. Bu nedenle istemi iki katına çıkarmak, TTFT içindeki prefill süresini en az iki katına çıkarır.
Bunu bir dakika içinde gözlemleyebilirsiniz. Sunucunuza önce 200 token'lık, ardından 2.000 token'lık bir istem gönderin ve her seferinde aynı sayıda çıktı token'ı isteyin. TTFT değerinin hızla yükseldiğini göreceksiniz. İlk token'dan sonraki akış hızı ise neredeyse hiç değişmeyecektir.
Decode işlemi neden bellek bant genişliği ile sınırlıdır?
Decode işlemi her adımda bir token üretir. GPU, bu tek token'ı üretmek için modeldeki her bir ağırlığı bellekten okumak, her ağırlığı birkaç işlem için kullanmak ve ardından atmak zorundadır. Aritmetik yoğunluk 1'e yakın olduğundan, işlem birimleri zamanlarının çoğunu bekleyerek geçirir.
Decode işlemi yavaştır çünkü her token, tüm modelin bellekten okunmasını gerektirir; bu nedenle bellek veri yolu hızı belirler ve işlem birimleri boşta kalır.
Bu durum, tek akışlı decode hızının tavanını kağıt üzerinde hesaplanabilir bir aritmetik haline getirir. Bellek bant genişliğini, ağırlıkların kapladığı bayt miktarına bölün.
Bu grafiğin arkasındaki veriler
[
{
"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
}
]Bant genişliği sütunu, her satıcının yayınladığı teknik özellik değerini içerir. Tavan sütunu ise bu değerin, 16 bit hassasiyetle saklanan 8 milyar parametreli bir modelin boyutu olan 16 GB'a bölünmesiyle elde edilir. Bu bir kıyaslama sonucu değil, aritmetik bir hesaptır. Ölçülen hızınız bunun altında kalacaktır; ne kadar altında kaldığını bilmek, sunum yığınınızı mı yoksa donanımınızı mı iyileştirmeniz gerektiğini gösterdiği için faydalıdır.
6 satırı sırasıyla okuduğunuzda örüntü netleşir. Çift kanallı DDR5 kullanan bir CPU yaklaşık 90 GB/s hızla veri taşır ve bu, söz konusu model için decode hızını 6 token/saniye civarında sınırlar. Bir L40S, 54 civarında bir değer verir. Yayınlanan bant genişliği 3350 GB/s olan bir H100 SXM ise 209 civarında kalır.
Kuantizasyonun decode hızı üzerindeki en güçlü tekil kaldıraç olmasının nedeni de budur. Aynı ağırlıkları 16 bit yerine 8 bit olarak saklarsanız, token başına okunan ağırlık bayt miktarını yarıya indirirsiniz, böylece tavan değeri kabaca iki katına çıkar. Ancak tavan değeri nihai sonuç değildir. KV cache hala kendi boyutu kadar okunur ve bazı 8 bit formatları token başına ek iş yükü getirir; örneğin vLLM'in FP8 şemalarından biri için belgelediği dinamik token bazlı aktivasyon kuantizasyonu gibi. Bu nedenle ölçülen kazanç genellikle 2 katın altında kalır. Kaldıraç, tavan değerinin yükselmesiyle aynı nedenden dolayı işe yarar: daha az bellek verisi taşımış olursunuz.
Kendi sunucumda her aşamayı nasıl ölçerim?
Ollama, yanıt gövdesinde bu ayrımı döndürür. Akışsız (non-streaming) bir tamamlama isteyin ve sayaçları okuyun.
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}'Gerçekten çektiğiniz bir model etiketini kullanın; bunu ollama list size gösterecektir. prompt_eval_count ve prompt_eval_duration ön doldurma (prefill) değerleridir: istem belirteç sayısı ve buna harcanan süre. eval_count ve eval_duration ise kod çözme (decode) değerleridir. Süreler nanosaniye cinsindendir, bu nedenle kod çözme hızı eval_count / eval_duration * 1e9, ön doldurma hızı ise prompt_eval_count / prompt_eval_duration * 1e9 olur. Ollama API referansı, prompt_eval_duration değerinin yalnızca önbelleğe alınmamış istem belirteçlerini kapsadığını belirtir; bu yüzden ön doldurma oranını sunucunun henüz görmediği bir istemden alın. Ön doldurma hızının, aynı istekteki kod çözme hızından çok daha yüksek çıkmasını bekleyin. Buradaki diğer tüm açıklamalar bu farka dayanmaktadır.
vLLM gibi OpenAI uyumlu bir sunucu için curl, ilk bayt süresini sizin için ölçebilir.
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, gövdenin ilk baytının ulaştığı andır; dolayısıyla "stream": true ile birlikte bu, TTFT ve bağlantı kurulum süresinin toplamıdır. Kurulum maliyetini çıkarmak için time_pretransfer değerini çıkarın. Bunu iki kez çalıştırın ve ikinci sonucu baz alın, çünkü ilk çağrı soğuk model yükleme süresini içerebilir.
vLLM ayrıca bu ayrımı /metrics adresinde Prometheus metrikleri olarak yayınlar. curl -s http://localhost:8000/metrics | grep -E 'time_to_first_token|inter_token_latency' komutunu çalıştırın; vllm:time_to_first_token_seconds ve vllm:inter_token_latency_seconds histogramlarını elde edersiniz. Kuyruk derinliği için vllm:num_requests_running ve vllm:num_requests_waiting, önbellek baskısı için ise vllm:kv_cache_usage_perc değerlerini ekleyin. Bu beş isim, tüm kontrol panelini oluşturur.
Yük altındayken, vllm bench serve --model <name> --num-prompts 200 --request-rate 4 çalışan sunucuyu yönetir ve ilk belirteç süresi ile çıktı belirteci başına gecikmeyi yüzdelik dilimlerle raporlar; bu, halihazırda kullandığınız yığın üzerinde iki aşamanın birbirini nasıl etkilediğini görmenin en doğrudan yoludur. Ayrı bir araç tercih ederseniz, NVIDIA'nın GenAI-Perf ve LLMPerf araçları da aynı nicelikleri ölçer. Herhangi bir ayar yapmadan önce temiz bir temel değer (baseline) oluşturun: yerel bir LLM üzerinde saniye başına belirteç ölçümü içindeki yöntem, yeniden başlatma sonrasında da geçerliliğini koruyan bir temel değer sağlar.
Uzun bir sistem istemi neden ilk belirteci geciktirir ancak akış hızını etkilemez?
Çünkü sistem istemi, yalnızca ön doldurma (prefill) işleminden ibarettir. İlk belirteç görünmeden önce, istemin geri kalanıyla aynı geçişte bir kez işlenir. Bu geçişten sonra yalnızca KV önbelleği girdileri olarak varlığını sürdürür ve kod çözme (decode) işlemi, diğer her şeyle birlikte bunları da okur. Dolayısıyla, önek önbellekleme (prefix caching) kullanılmadığında, 3.000 belirteçlik bir sistem istemi her istekte TTFT süresini artırırken, saniyedeki belirteç hızını neredeyse hiç değiştirmez.
Neredeyse, tam olarak değil. Bu fazladan KV girdileri her kod çözme adımında tekrar okunduğu için, çok uzun bir istem kod çözme hızını bir miktar yavaşlatır. Bir sonraki bölüm bunu ele almaktadır.
Çözüm, aynı öneki tekrar hesaplamayı durdurmaktır. Önek önbellekleme özelliğine sahip bir sunucu, paylaşılan bir önekin KV önbelleğini tutar ve yeniden kullanır; böylece aynı sistem istemini taşıyan ikinci istek, ön doldurma kısmını tamamen atlar. vLLM buna otomatik önek önbellekleme adını verir; varsayılan ayarlar sürümler arasında değiştiği için vllm serve --help üzerinden kendi sürümünüzü kontrol edin. GPU içindeki bu KV önbelleği, bir API sağlayıcısının sizden ücretlendirdiği istem önbelleğinden farklı bir şeydir ve KV önbelleği ile istem önbelleği arasındaki fark, her ikisinden birini yapılandırmadan önce okunmaya değerdir.
Kod çözme işlemi bağlam doldukça neden yavaşlar?
Bunun KV cache ile ilgili iki temel nedeni vardır.
Birincisi bant genişliğidir. Her kod çözme adımında, attention mekanizması önceki tüm token'ların key ve value değerlerini okur. Ağırlıklar her token için sabit bir maliyete sahipken, KV cache sürekli büyüyen bir maliyettir. Boyutunu modelin config.json değerinden hesaplayabilirsiniz: token başına bayt miktarı; 2, num_hidden_layers, num_key_value_heads, head dimension ve element başına bayt değerlerinin çarpımına eşittir. Yapılandırma dosyasında listelendiğinde head_dim değerini kullanın; bazı modeller bu iki değeri birbirinden bağımsız ayarladığı için, yalnızca liste dışı kaldığında hidden_size değerini num_attention_heads değerine bölerek hesaplayın. Örneğin Mistral NeMo, 5,120 genişliğe ve 32 head'e sahip olmasına rağmen 160 değil, 128'lik bir head dimension kullanır. Baştaki 2 çarpanı, bir key ve bir value değerini temsil eder.
Yaygın bir 8 milyar parametreli düzen, 32 katman, GQA (grouped query attention) altında 8 key ve value head, 128 head dimension ve 16 bit hassasiyet için hesaplama şöyledir: 2 x 32 x 8 x 128 x 2 = 131,072 bayt, yani token başına yaklaşık 128 KiB. Bu nedenle 8,000 token'lık bir görüşme, istek başına yaklaşık 1 GB KV cache taşır.
İkincisi ise kapasitedir. Bu 1 GB'lık alan, ağırlıkları veya başka bir kullanıcının bağlamını tutamayacak olan bellektir. Sunucu, KV havuzunu başlangıçta bir kez boyutlandırır; vLLM üzerinde bu işlem --gpu-memory-utilization ile yapılır ve havuz dolduğunda yeni istekler beklemeye alınır. vllm:num_requests_waiting değerinin yükselirken vllm:kv_cache_usage_perc değerinin 1 civarında seyretmesi, tam olarak bu durumun göstergesidir. Bazı yığınlar, kuyruğa almak yerine çalışan bir isteği yarıda kesip önceliklendirir ve önbelleğini daha sonra yeniden hesaplar; kullanıcı bunu akışın ortasında bir duraksama olarak deneyimler.
Uzun bağlam size iki şekilde maliyet çıkarır: başlangıçta daha fazla prefill iş yükü ve yanıtın geri kalanında token başına daha fazla bellek okuma ihtiyacı.
Toplu işleme (batching) neden iş hacmini artırıp kuyruk gecikmesini (tail latency) kötüleştirir?
Kod çözme (decode) işlemi bant genişliği sınırlı olduğundan, hesaplama tarafında ek istekler neredeyse maliyetsizdir. Ağırlıkların bir kez okunması, gruptaki her dizi için bir token üretebilir; bu nedenle toplam iş hacmi, KV havuzu tükenene veya grup hesaplama sınırlı hale gelecek kadar büyüyene dek neredeyse doğrusal olarak artar. Sürekli toplu işleme (continuous batching), grubu her adımda yeniden oluşturur; böylece tamamlanan bir istek çıkar ve kuyruktaki bir diğeri, komşularını beklemeden gruba dahil olur.
Fatura yüzdelik dilimlerde ortaya çıkar. Her kullanıcının bir sonraki token'ı artık paylaşılan bir adımın en yavaş kısmını beklemek zorundadır; bu yüzden medyan değer olan p50 kabul edilebilir seviyede kalırken, 100 istekten en yavaş 1'ini temsil eden p99 uzar. İnsanların fark ettiği p99 değeridir, çünkü bu, bir cümlenin ortasındaki duraksamadır.
Ön doldurma (prefill) bu durumu daha belirgin hale getirir. Akış sırasında gelen büyük bir istem, cihazı uzun bir adım boyunca meşgul eder ve o sırada akış yapan herkes bir boşlukla karşılaşır. Parçalı ön doldurma (chunked prefill), uzun bir istemi parçalara bölüp her parçayı kod çözme gruplarına karıştırarak bu sorunun çoğunu ortadan kaldırır. Ekim 2026 itibarıyla vLLM V1 motoru bunu varsayılan olarak yapar ve dengeyi --max-num-batched-tokens üzerinden sunar. vLLM ayarlama belgeleri bu ödünleşimi açıkça belirtir: 2048 civarındaki daha küçük değerler, daha az ön doldurma işlemi kod çözme işlemlerini böldüğü için daha iyi token arası gecikme (ITL) sağlar; daha büyük değerler ise bir gruba daha fazla ön doldurma token'ı sığdığı için daha iyi ilk token süresi (TTFT) sağlar. Bu tek bayrak, ön doldurma ile kod çözme arasındaki dengedir ve üzerinde oynayabileceğiniz bir sayı olarak sunulur. p99 değerinin nerede kabul edilemez hale geldiği bir kapasite sorusudur ve tek bir self-hosted LLM'in kaç eşzamanlı kullanıcıya hizmet verebileceği konusu aynı metriklerle incelenir.
Daha büyük bir GPU neden bazen hiçbir şeyi değiştirmez?
Çünkü daha büyük olması genellikle daha fazla işlem gücü anlamına gelir, ancak kod çözme (decode) işlem gücüne ihtiyaç duymaz.
Yukarıdaki tablodaki iki satırı karşılaştırın. A100 80GB, 2039 GB/s'lik yayınlanmış bir bant genişliğine sahipken, L40S 864 GB/s'ye sahiptir ve kod çözme tavanı tam olarak bunu takip eder: saniyede 127 token'a karşılık 54. RTX 4090 çoğu ölçüme göre çok hızlı bir karttır ve 1008 GB/s'lik değeri, tavanını 63 seviyesine koyar. İki kart arasında başka ne farklı olursa olsun, tek akışlı kod çözme işlemi teknik özellik sayfasındaki bant genişliği hattını takip eder.
Dolayısıyla kod çözmeyi hızlandırmanın iki yolu vardır: token başına daha az bayt okumak (ağırlıkları nicemlemek veya daha küçük bir model çalıştırmak) ya da daha fazla bant genişliği satın almak. Prefill durumu ise bunun tam tersidir. İşlem gücü gerektirir, bu nedenle daha hızlı bir kart, uzun istemlerde TTFT süresini gerçekten kısaltır. Eğer şikayet ilk token'ın dört saniye sürmesi ise, daha iyi donanım bunu çözebilir. Eğer şikayet metnin yavaş yazılması ise, donanım değişikliği muhtemelen bunu çözmeyecektir.
Prefill ve decode işlemlerini ayrı çalışanlar (worker) üzerinde mi çalıştırmalısınız?
Büyük sunucu yığınları tam olarak bunu yapar ve bu teknik, prefill ve decode ayrıştırması olarak adlandırılır. Bir çalışan havuzu yalnızca prefill işlemini, ikinci bir havuz ise yalnızca decode işlemini yürütür; ilki tarafından oluşturulan KV cache, hızlı bir ara bağlantı üzerinden ikinciye aktarılır. Bu yöntem, her iki aşamanın farklı donanım ve zamanlama gereksinimleri olması nedeniyle işe yarar. Prefill, hesaplama gücü ve büyük token grupları gerektirir. Decode ise bant genişliği ve aynı anda yürütülen çok sayıda dizi gerektirir. Bunları ayırmak, her havuzun kendi ölçeğinde büyümesini sağlar ve tek bir devasa istemin tüm aktif akışları durdurmasını engeller.
Tek bir GPU'ya sahip tek bir VPS (sanal özel sunucu) üzerinde bunu yapmak neredeyse hiçbir zaman mantıklı değildir. Tek bir cihazı kendi içinde bölmüş olursunuz ve bir işaretçi (pointer) aktarımını, gigabaytlarca cache verisinin ağ üzerinden transferine dönüştürürsünüz. Bu teknik, her aşamaya tüm makineleri adayacak kadar hızlandırıcıya ve her iki havuzu da meşgul edecek kadar sürekli trafiğe sahip olduğunuzda avantaj sağlar. Bunun altındaki seviyelerde, chunked prefill özelliği tek bir bayrak (flag) ile benzer bir izolasyon sağlar.
Sayı hatalı olduğunda ne değiştirilmeli
TTFT değeri çok yüksekse:
- İstemi kısaltın. Prefill maliyeti istem token'ları üzerinden hesaplanır; prefix caching kullanılmadığında sistem istemi her istekte yeniden ücretlendirilir.
- Tekrarlanan bir önekin her seferinde değil, yalnızca bir kez hesaplanması için prefix caching özelliğini açın.
- Her adımda daha fazla prefill işleminin gerçekleşmesi için
--max-num-batched-tokensdeğerini yükseltin. - Modeli suçlamadan önce kuyruğu kontrol edin.
vllm:num_requests_waitingdeğerinin sıfırın üzerinde olması, isteğin henüz başlamadığını gösterir; bu bir kapasite sorunudur.
Saniye başına üretilen token sayısı (tokens per second) çok düşükse:
- Ağırlıkları nicemleyin (quantize). Ağırlık başına daha az bayt, token başına daha az veri okunması demektir.
- Kartınızın yayınlanan bellek bant genişliğini yukarıdaki tabloyla karşılaştırın ve sınıra ne kadar yakın olduğunuzu görün.
- Prefill işlemlerinin decode sürecini daha az kesintiye uğratması için
--max-num-batched-tokensdeğerini düşürün. - Bağlam uzunluğunu (context length) kontrol edin. Binlerce token'a ulaşan bir konuşma, her adımda çok daha büyük bir KV cache okur.
Çalışma zamanı (runtime) burada da önemlidir; çünkü Ollama ve vLLM, prefill ve decode işlemlerini farklı şekilde zamanlar; birinde işe yarayan bir ayar diğerinde hiçbir etki yaratmayabilir. Önce her iki aşamada da ölçüm yapın, ardından yalnızca tek bir ayarı değiştirin.
FAQ
İlk token neden saniyeler sürüyor ancak geri kalanı hızlı akıyor?
Bekleme süresi prefill (ön dolum), akış ise decode (kod çözme) aşamasıdır. Ön dolum, herhangi bir çıktı oluşmadan önce tüm istemi tek bir hesaplama yoğunluklu geçişte işler, bu nedenle maliyeti istem uzunluğuyla artar. Kod çözme aşaması ise bellek bant genişliği tarafından belirlenen bir hızda her adımda bir token üretir; bu hız, istemin ne kadar uzun olduğundan neredeyse bağımsızdır. Her istekte gönderilen uzun bir sistem istemi genellikle bu durumun nedenidir. Prefix caching, bu maliyetin tekrarlanan kısmını ortadan kaldırır.
Daha uzun bir istem, saniyedeki token hızını yavaşlatır mı?
Bir miktar yavaşlatır, ancak bu durum TTFT'den farklı bir nedene dayanır. Her kod çözme adımı, önceki tüm token'ların anahtar ve değerlerini okur; bu nedenle daha büyük bir KV cache, token başına daha fazla bayt okunması anlamına gelir. Yaygın bir 8 milyar parametreli yapı için cache, token başına yaklaşık 128 KiB'dir; dolayısıyla 8.000 token'lık bir bağlam, her adımda erişilen yaklaşık 1 GB'lık veri demektir. Uzun bir istemin daha büyük etkisi, akış hızından ziyade hala TTFT üzerindedir.
Hangi GPU özelliği kod çözme hızını belirler?
Bellek bant genişliği. Yayınlanan bant genişliğini bellekteki ağırlıkların boyutuna böldüğünüzde, tek bir akış için aritmetik üst sınırı elde edersiniz. Daha fazla işlem gücüne sahip ancak aynı bant genişliğine sahip bir kart, daha hızlı akış sağlamaz. Ağırlıkları 8 bite quantize etmenin kod çözme üst sınırını yaklaşık iki katına çıkarmasının nedeni de budur: token başına okunan ağırlık baytlarını yarıya indirir. Ölçülen kazanç genellikle daha düşüktür, çünkü KV cache hala kendi boyutunda okunur ve bazı 8 bit formatlar, aktivasyonların quantize edilmesi gibi token başına ek iş yükü getirir.
Kullanıcı eklediğimde toplam iş hacmi neden artıyor ancak her kullanıcı neden daha yavaş hissediyor?
Ağırlıkların tek bir okuması, batch içindeki her dizi için bir token'a hizmet eder; bu nedenle saniyedeki toplam token sayısı batch boyutuyla birlikte artar. Her bir token artık paylaşılan bir adımı beklediği için, kullanıcı başına gecikme aynı anda artar. Toplam iş hacmi rakamı yerine p99 token arası gecikmeyi izleyin ve isteklerin çalışmak yerine kuyruğa alınıp alınmadığını görmek için vllm:num_requests_waiting değerini kontrol edin.