O que significa uma baixa carga da GPU ao executar um LLM com o 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 offload de camadas para a GPU com o parâmetro ngl, escolher uma quantização menor ou encurtar o contexto para que mais do modelo caiba na GPU.

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

Contextos mais longos aumentam o uso da KV cache e da VRAM, o que pode reduzir os tokens por segundo ou forçar o offload parcial. Contextos mais curtos, modelos menores ou quants mais agressivos ajudam a manter a velocidade em um único cartão de 16 GB.

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

Quants de bits mais baixos utilizam menos VRAM e podem aumentar os tokens por segundo, mas podem prejudicar a qualidade. Quants no estilo IQ3 e IQ4 são compromissos comuns para o llama.cpp em uma GPU de 16 GB quando se necessita de 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 altos tokens por segundo, pois apenas parte da rede é executada a cada passo de forward, 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 do que o de 32K na mesma GPU?

Ajuste o número de camadas carregadas na GPU com o parâmetro ngl, aceite um contexto menor se isso se adequar à sua tarefa ou utilize uma quantização mais leve para que mais camadas permaneçam no dispositivo e a pressão no KV cache seja reduzida.

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

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

Conteúdo da página

Aqui estou eu comparando a velocidade de vários LLMs executados em GPU com 16GB de VRAM, e escolhendo o melhor para auto-hospedagem.

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

GPU estilizada com blocos de VRAM e gráficos em estilo de benchmark

Neste post, estou registrando meus esforços para extrair o máximo de desempenho, no sentido de velocidade, possível.

Tabela de comparação de velocidade de LLMs (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
Mistral-Small-4-119B UD-IQ3_XXS	42.8	14.8	28/585	30.4	14.7	27/574	28.5	14.9	20/590	31.5
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 é a Carga da GPU. Se você vir um número baixo nesta coluna, isso significa que o modelo está sendo executado principalmente na CPU e não consegue atingir uma velocidade decente neste hardware. Esse padrão corresponde ao que as pessoas observam quando pouca parte do modelo cabe na GPU ou quando o contexto empurra o trabalho de volta para o host.

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

Se você deseja 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, lotes, -ngl), comece com Início Rápido do llama.cpp com CLI e Servidor.

Para uma visão geral mais ampla do desempenho (vazamento versus latência, limites de VRAM, requisições paralelas e como os benchmarks se integram entre hardware e runtimes), veja Desempenho de LLMs em 2026: Benchmarks, Gargalos e Otimização.

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

Melhores LLMs para OpenCode - Testado Localmente. Você pode ler mais sobre o Opencode em Início Rápido do OpenCode: Instalar, Configurar e Usar o Agente de Codificação de IA no Terminal
Comparação da qualidade da Tradução de Páginas Hugo - LLMs no Ollama

Eu realizei um teste similar para LLMs no Ollama: Melhores LLMs para Ollama em GPU de 16GB VRAM.

Se você executa Qwen 3.6 27B ou 35B via llama.cpp e deseja impulsionar ainda mais a velocidade de geração, veja Qwen 3.6 MTP vs Decodificação Padrão em GPU de 16GB — a decodificação especulativa MTP adiciona até 67% de vazamento de geração para o modelo denso de 27B, com tabelas mostrando o custo de VRAM e o compromisso com a janela de contexto em todos os níveis de --spec-draft-n-max.

Por que o comprimento do contexto altera os tokens por segundo

À medida que você passa de 19K para 32K ou 64K tokens, a cache KV cresce e a pressão de VRAM aumenta. Algumas linhas mostram uma grande queda nos tokens por segundo em 64K, enquanto outras permanecem estáveis, o que é o sinal para rever quantizações, limites de contexto ou descarte de camadas, em vez de assumir que o modelo é “lento” em geral. Para o cálculo de orçamento por trás desses números — a fórmula exata para bytes KV por token, tabelas de tipo de cache em 32K/64K/128K e como calcular sua própria folga — veja Cache KV em GPUs de 16 GB: Fazendo Longos Contextos Caber de Verdade.

Os modelos e quantizações que escolhi para testar - são para executar por conta própria e ver se dão um bom ganho no sentido de custo-benefício neste equipamento ou não. Então, sem quantizações q8 aqui com contexto de 200k :) …

GPU/CPU é uma carga, medida por nvitop.

O llama.cpp, ao configurar automaticamente a descarga de camadas 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-o aqui, só 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 dos LLMs 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 de 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 Ajustadas

Para alguns modelos e quantizações interessantes, tentei encontrar parâmetros especiais de linha de comando do llama-cpp para melhor utilizar a VRAM. Aqui está o que pude 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

Considerações para builds com 16 GB de VRAM

Meu favorito atual Qwen3.5-27B-UD-IQ3_XXS está se saindo bem no seu ponto ideal de contexto 50k (estou obtendo aproximadamente 36t/s)
Qwen3.5-122B-A10B-UD-IQ3_XXS está superando em desempenho o Qwen3.5 27B nos contextos acima de 64K.
Posso impulsionar o Qwen3.5-35B-A3B-UD-IQ3_S para lidar com contexto de 100k tokens, e ele cabe na vram, então não há queda de desempenho
Não vou usar o gemma-4-31B em 16GB de VRAM, mas o 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. serão melhores que o Qwen3.5-35B q3? Duvido, mas ainda assim, talvez eu teste para confirmar a suspeita.