O que significa baixa utilização da GPU ao executar um LLM com llama.cpp?

Isso frequentemente significa que muitas camadas permanecem na CPU, o que reduz drasticamente a velocidade de geração de tokens. Você pode tentar aumentar o offload de camadas da GPU com o parâmetro ngl, escolher uma quantização menor ou encurtar o contexto para que mais partes do modelo caibam na GPU.

Como uma janela de contexto maior afeta os tokens por segundo em 16 GB de VRAM?

Contextos mais longos aumentam o cache KV e o uso de VRAM, o que pode reduzir os tokens por segundo ou forçar o offloading parcial. Contextos mais curtos, modelos menores ou quantizações mais agressivas ajudam a manter a velocidade em uma única placa de 16 GB.

Quais compromissos de quantização são relevantes para ajustar modelos grandes em 16 GB?

Quânticos de bits mais baixos consomem menos VRAM e podem aumentar os tokens por segundo, mas podem prejudicar a qualidade. Quânticos no estilo IQ3 e IQ4 são compromissos comuns para o llama.cpp em uma GPU de 16 GB quando você precisa de contexto longo ou checkpoints maiores.

Modelos mixture-of-experts podem ser rápidos em uma única GPU de 16 GB?

Os modelos MoE podem atingir altas taxas de tokens por segundo porque apenas parte da rede é executada em cada passo de inferência, mas ainda é necessário VRAM suficiente para os especialistas ativos, além dos pesos e do cache KV no comprimento de contexto escolhido.

O que você pode tentar se o contexto de 64K for muito mais lento que o de 32K na mesma GPU?

Ajuste quantas camadas são carregadas na GPU com o parâmetro ngl, aceite um contexto mais curto se isso atender à sua tarefa ou migre para uma quantização mais leve para que mais camadas permaneçam no dispositivo e a pressão sobre o cache KV seja aliviada.

Benchmarks de LLM com 16 GB de VRAM usando llama.cpp (velocidade e contexto)

Velocidade de tokens do llama.cpp em 16 GB de VRAM (tabelas).

Conteúdo da página

Aqui comparo a velocidade de vários LLMs executados em uma GPU com 16 GB de VRAM e escolho o melhor para auto-hospedagem.

Executei esses LLMs no llama.cpp com janelas de contexto de 19K, 32K e 64K tokens.

Stylized GPU with VRAM blocks and benchmark-style charts

Neste post, registro minhas tentativas de extrair o máximo de desempenho em termos de velocidade possível.

Tabela de comparação de velocidade de LLM (tokens por segundo e VRAM)

Model	Size	19K VRAM	19K GPU/CPU	19K T/s	32K VRAM	32K Load	32K T/s	64K VRAM	64K Load	64K: T/s
Qwen3.6-35B-A3B-UD-IQ3_XXS	13.2	13.8GB	96%/100%	147.5	14.0GB	96%/101%	149.1	14.7GB	96%/101%	145.8
Qwen3.6-35B-A3B-UD-IQ4_XS	17.7	14.3GB	62%/266%	95.0	14.9GB	58%/279%	92.3	14.9GB	57%/293%	86.4
Qwen3.5-35B-A3B-UD-IQ3_S	13.6	14.3GB	93%/100%	136.4	14.6GB	93%/100%	138.5	14.9GB	88%/115%	136.8
Qwen3.5-27B-IQ3_XXS-bartowsky	11.3	12.8	98/100	44.9	13.5	98/100	44.9	14.5	45/415	23.6
Qwen3.5-27B-UD-IQ3_XXS	11.5	12.9	98/100	45.3	13.7	98/100	45.1	14.7	45/410	22.7
Qwen3.5-27B-IQ4_XS.gguf	15.0	14.6	49/406	20.5	14.7	37/465	17.4	14.7	23/533	13.3
Qwen3.5-122B-A10B-UD-IQ3_XXS	44.7	14.7	30/470	22.3	14.7	30/480	21.8	14.7	28/490	21.5
Qwen3.5-122B-A10B-UD-IQ3_S	46.5	14.7	25/516	19.4	14.7	24/516	19.5	14.7	24/516	19.6
Qwen3-Coder-Next-UD-IQ4_XS	38.4	14.6	32/460	41.1	14.7	29/440	41.3	14.8	32/460	38.3
Nemotron Super 120b IQ3_XXS	56.2	15.0	26/517	17.5	14.6	26/531	17.4	14.6	26/535	17.6
gemma-4-26B-A4B-it-UD-IQ4_XS	13.4	14.7	95/100	121.7	14.9	95/115	114.9	14.9	75/190	96.1
gemma-4-31B-it-UD-IQ3_XXS	11.8	14.8	68/287	29.2	14.8	41/480	18.4	14.8	18/634	8.1
GLM-4.7-Flash-IQ4_XS	16.3	15.0	66/240	91.8	14.9	62/262	86.1	14.9	53/313	72.5
GLM-4.7-Flash-REAP-23B IQ4_XS	12.6	13.7	92/100	122.0	14.4	95/102	123.2	14.9	71/196	97.1

19K, 32K e 64K são os tamanhos de contexto.

O load acima refere-se à Carga da GPU. Se você vir um número baixo nesta coluna, significa que o modelo está rodando principalmente na CPU e não consegue obter nenhuma velocidade decente neste hardware. Esse padrão coincide com o que as pessoas veem quando pouca parte do modelo cabe na GPU ou quando o contexto empurra o trabalho de volta ao host.

Sobre llama.cpp, desempenho de LLM, OpenCode e outras comparações

Se você quiser os caminhos de instalação, exemplos de llama-cli e llama-server, e as flags que importam para VRAM e tokens por segundo (tamanho do contexto, batching, -ngl), comece com llama.cpp Quickstart com CLI e Server.

Para uma visão mais ampla do desempenho (throughput versus latência, limites de VRAM, solicitações paralelas e como os benchmarks se encaçam através de hardware e runtimes), veja LLM Performance in 2026: Benchmarks, Bottlenecks & Optimization.

A qualidade da resposta é analisada em outros artigos, por exemplo:

Best LLMs for OpenCode - Tested Locally. Você pode ler mais sobre Opencode em OpenCode Quickstart: Install, Configure, and Use the Terminal AI Coding Agent
Comparison of Hugo Page Translation quality - LLMs on Ollama

Eu também realizei testes semelhantes para LLMs no Ollama: Best LLMs for Ollama on 16GB VRAM GPU.

Por que o comprimento do contexto altera os tokens por segundo

À medida que você passa de 19K para 32K ou 64K tokens, o cache KV cresce e a pressão na VRAM aumenta. Algumas linhas mostram uma grande queda nos tokens por segundo em 64K, enquanto outras permanecem estáveis; isso é o sinal para revisar quants, limites de contexto ou descarregamento de camadas, em vez de assumir que o modelo é “lento” em geral.

Os modelos e quants que escolhi para testar foram selecionados para serem executados por mim e verificar se eles oferecem um bom ganho em termos de custo/benefício neste equipamento ou não. Portanto, não há quants q8 aqui com contexto de 200k :) …

GPU/CPU é uma carga, medida por nvitop.

O llama.cpp, ao autoconfigurar as camadas para descarregar na GPU, tenta manter 1 GB livre. Nós especificamos manualmente este parâmetro via parâmetro de linha de comando -ngl, mas não estou fazendo ajuste fino aqui, apenas preciso entender que, se houver uma queda significativa de desempenho ao aumentar o tamanho da janela de contexto de 32k para 64k - podemos tentar aumentar a velocidade em 64k ajustando o número de camadas descarregadas.

Hardware de teste e configuração do llama.cpp

Testei a velocidade do LLM em um PC com esta configuração:

CPU i-14700
RAM 64GB 6000Hz (2x32GB)
GPU RTX-4080
Ubuntu com drivers NVidia
llama.cpp/llama-cli, sem camadas descarregadas especificadas
VRAM inicial usada, antes de iniciar o llama-cli: 300MB

Execuções extras em contexto 128K (Qwen3.5 27B e 122B)

Model	128K Load	128K: T/s
Qwen3.5-27B-UD-IQ3_XXS	16/625	9.6
Qwen3.5-122B-A10B-UD-IQ3_XXS	27/496	19.2

Execuções com Ajuste Fino (Finetuned Runs)

Para alguns modelos e quants interessantes, tentei encontrar parâmetros especiais de linha de comando do llama-cpp para melhor utilizar a VRAM. Aqui está o que consegui alcançar:

Model	Context	Layers on GPU	CPU/CPU load	Speed
Qwen3.5-27B-IQ4_XS.gguf	18k	65	98%/100%	38.0
Qwen3.5-27B-IQ4_XS.gguf	64k	53	33%/488%	15.7

Conclusões para builds com 16 GB de VRAM

Meu favorito atual, Qwen3.5-27B-UD-IQ3_XXS, parece estar indo bem no seu ponto ideal de contexto de 50k (estou obtendo aprox. 36t/s)
O Qwen3.5-122B-A10B-UD-IQ3_XXS está superando o Qwen3.5 27B em termos de desempenho nos contextos acima de 64K.
Posso fazer o Qwen3.5-35B-A3B-UD-IQ3_S lidar com contexto de 100k tokens, e ele cabe na VRAM, sem queda de desempenho.
Não usarei gemma-4-31B em 16GB VRAM, mas gemma-4-26B pode ser médio-bom…, preciso testar.
Preciso testar o quão bem o Nemotron cascade 2 e o GLM-4.7 Flash REAP 23B funcionam. Eles serão melhores que o Qwen3.5-35B q3? Eu duvido, mas ainda assim, pode testar para confirmar a suspeita.