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

Isso frequentemente significa que muitas camadas permanecem na CPU, fazendo com que a velocidade de geração de tokens caia drasticamente. Você pode tentar aumentar o descarregamento de camadas na GPU com o parâmetro ngl, escolher uma quantização menor ou reduzir o contexto para que mais do modelo caiba na GPU.

Como uma janela de contexto mais longa 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 um offload parcial. Contextos mais curtos, modelos menores ou quânticos mais agressivos 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?

Quants de menor bit utilizam menos VRAM e podem aumentar os tokens por segundo, mas podem prejudicar a qualidade. Os quants dos estilos IQ3 e IQ4 são compromissos comuns no llama.cpp em uma GPU de 16 GB quando é necessário contexto longo ou checkpoints maiores.

Modelos de mistura de especialistas 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 forward, mas você ainda precisa de 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 ngl, aceite um contexto mais curto se for adequado à sua tarefa ou migre para uma quantização mais leve para manter mais camadas no dispositivo e aliviar a pressão no cache KV.

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

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

Conteúdo da página

Aqui estou comparando a velocidade de vários LLMs executados em uma GPU com 16 GB de VRAM, escolhendo 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, no sentido de velocidade, possível.

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

Modelo	Tamanho	19K VRAM	19K GPU/CPU	19K T/s	32K VRAM	32K Load	32K T/s	64K VRAM	64K Load	64K: T/s
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-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
Nemotron Cascade 2 30B IQ4_XS	18.2	14.6	60/305	115.8	14.7	57/311	113.6	14.7	55/324	103.4
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 é a Carga da GPU. Se você vir um número baixo nesta coluna, isso significa que o modelo está rodando principalmente no CPU e não consegue obter uma 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 força o trabalho de volta para o host.

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

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

Para o panorama geral de desempenho (vazão versus latência, limites de VRAM, solicitações paralelas e como os benchmarks se encaçam entre hardware e runtimes), veja Desempenho de LLM em 2026: Benchmarks, Gargalos e Otimização.

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

Melhores LLMs para OpenCode - Testados Localmente. Você pode ler mais sobre o Opencode em OpenCode Quickstart: Instalar, Configurar e Usar o Agente de Codificação AI Terminal
Comparação da qualidade de tradução de página Hugo - LLMs no Ollama

Eu fiz testes semelhantes para LLMs no Ollama: Melhores LLMs para Ollama em GPU com 16GB VRAM.

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 sobre a VRAM aumenta. Algumas linhas mostram uma grande queda em tokens por segundo em 64K, enquanto outras permanecem estáveis, o que é um 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 testar são para rodar por mim mesmo e ver 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 pelo nvitop.

O llama.cpp, ao reconfigurar automaticamente as camadas descarregadas para a GPU, tenta manter 1GB livre. Especificamos manualmente este parâmetro via parâmetro de linha de comando -ngl, mas não estou ajustando isso aqui, preciso apenas 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 utilizada, antes de iniciar o llama-cli: 300MB

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

Modelo	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 Ajustadas

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

Modelo	Contexto	Camadas na GPU	Carga CPU/CPU	Velocidade
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 VRAM

Meu favorito atual, Qwen3.5-27B-UD-IQ3_XXS, está se mostrando bem no seu ponto ideal de contexto de 50k (estou obtendo aprox 36t/s)
O Qwen3.5-122B-A10B-UD-IQ3_XXS está superando em desempenho o Qwen3.5 27B nos contextos acima de 64K.
Posso empurrar o Qwen3.5-35B-A3B-UD-IQ3_S para 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 Nemotron cascade 2 e GLM-4.7 Flash REAP 23B funcionam. Serão melhores que Qwen3.5-35B q3? Dúvido, mas ainda assim, talvez teste para confirmar a suspeita.