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

Isso geralmente significa que muitas camadas permanecem na CPU, causando uma queda acentuada na velocidade dos tokens. Você pode tentar aumentar o offload de camadas para a 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 uso do cache KV 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 uma única placa de 16 GB.

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

Os quants com menor número de bits usam menos VRAM e podem aumentar os tokens por segundo, mas podem prejudicar a qualidade. Os quants 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.

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

Modelos MoE podem atingir altos tokens por segundo porque apenas parte da rede é executada em cada passo forward, mas ainda é necessária 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 menor se isso se adequar à sua tarefa ou migre para uma quantização mais leve, permitindo que mais camadas permaneçam no dispositivo e aliviando a pressão sobre o cache KV.

Benchmarks de LLMs 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 estou comparando a velocidade de vários LLMs rodando 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.

Estilização de GPU com blocos de VRAM e gráficos estilo benchmark

Neste post, registro meus esforços para extrair o máximo de desempenho possível em termos de velocidade.

Tabela comparativa de velocidade de LLMs (tokens por segundo e VRAM)

Modelo	Tamanho	VRAM 19K	GPU/CPU 19K	T/s 19K	VRAM 32K	Carga 32K	T/s 32K	VRAM 64K	Carga 64K	T/s 64K
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.

A carga acima refere-se à Carga da GPU. Se você ver um número baixo nesta coluna, isso significa que o modelo está rodando principalmente na CPU e não consegue obter boa velocidade neste hardware. Esse padrão corresponde ao que as pessoas observam quando pouca parte do modelo cabe na GPU ou quando o contexto transfere o trabalho 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, batching, -ngl), comece por Início Rápido do llama.cpp 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 encaixam entre hardware e runtimes), consulte Desempenho de LLMs em 2026: Benchmarks, Gargalos & 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 Início Rápido do OpenCode: Instalar, Configurar e Usar o Agente de Codificação AI no Terminal.
Comparação da qualidade de tradução de páginas Hugo - LLMs no Ollama

Executei um teste semelhante para LLMs no Ollama: Melhores LLMs para Ollama em GPU com 16GB de VRAM.

Se você executar Qwen 3.6 27B ou 35B via llama.cpp e quiser aumentar ainda mais a velocidade de geração, consulte Qwen 3.6 MTP vs Decodificação Padrão em GPU 16GB — a decodificação especulativa MTP adiciona até 67% de throughput de geração para o modelo denso de 27B, com tabelas mostrando o custo de VRAM e o trade-off da janela de contexto em cada nível de --spec-draft-n-max.

Por que o comprimento do contexto altera os tokens por segundo

Ao passar de 19K para 32K ou 64K tokens, o cache KV cresce e a pressão na 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 offloading de camadas, em vez de assumir que o modelo é “lento” em geral.

Os modelos e quants que escolhi para testar são para rodar eu mesmo e ver se eles oferecem um bom ganho em termos de custo/benefício neste equipamento ou não. Então, não há quants q8 aqui com contexto de 200k :) …

GPU/CPU é uma carga, medida por nvitop.

O llama.cpp, ao autoconfigurar as camadas descarregadas para a GPU, tenta manter 1GB livre. Especificamos manualmente esse parâmetro via parâmetro de linha de comando -ngl, mas não estou ajustando isso 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 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)

Modelo	Carga 128K	T/s 128K
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 especiais de linha de comando do llama-cpp para utilizar melhor 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 de VRAM

Meu favorito atual, Qwen3.5-27B-UD-IQ3_XXS, está se saindo bem em 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 desempenho nos contextos acima de 64K.
Consigo forçar o Qwen3.5-35B-A3B-UD-IQ3_S a lidar com contexto de 100k tokens, e ele cabe na vram, então não há queda de desempenho
Não usarei o gemma-4-31B em 16GB de VRAM, mas o gemma-4-26B talvez seja médio/bem…, preciso testar.
Preciso testar como funcionam bem o Nemotron cascade 2 e o GLM-4.7 Flash REAP 23B. Eles serão melhores que o Qwen3.5-35B q3? Duvido, mas ainda assim, posso testar para confirmar a suspeita.