Como o Ollama trata solicitações paralelas

Configurando ollama para execução de solicitações em paralelo.

Conteúdo da página

Quando o servidor Ollama recebe duas solicitações ao mesmo tempo, seu comportamento depende de sua configuração e dos recursos do sistema disponíveis.

Para mais informações sobre throughput, latência, VRAM e benchmarks em diferentes runtimes e hardware, veja LLM Performance: Benchmarks, Bottlenecks & Optimization.

cinco lhamas incríveis estão paradas no campo

Tratamento de Solicitações Concorrentes

  • Processamento Paralelo: Ollama suporta o processamento paralelo de solicitações. Se o sistema tiver memória suficiente disponível (RAM para inferência em CPU, VRAM para inferência em GPU), vários modelos podem ser carregados ao mesmo tempo, e cada modelo carregado pode processar várias solicitações simultaneamente. Isso é controlado pela variável de ambiente OLLAMA_NUM_PARALLEL, que define o número máximo de solicitações paralelas que cada modelo pode processar simultaneamente. Por padrão, esse valor está definido como 4 (ou 1, dependendo da disponibilidade de memória), mas pode ser ajustado.

  • Agrupamento: Quando várias solicitações para o mesmo modelo chegam ao mesmo tempo, o Ollama as agrupa e as processa juntas. Isso significa que ambas as solicitações são processadas em paralelo, e os usuários verão as respostas sendo enviadas de volta ao mesmo tempo. O servidor não espera intencionalmente para preencher um lote; o processamento começa assim que as solicitações estão disponíveis.

Filas e Limites

  • Filas: Se o número de solicitações concorrentes exceder a paralelismo configurado (por exemplo, mais de OLLAMA_NUM_PARALLEL solicitações para um modelo), solicitações adicionais serão colocadas em uma fila. A fila opera em uma ordem primeiro-entrando, primeiro-saindo (FIFO).

  • Limites da Fila: O número máximo de solicitações em fila é controlado por OLLAMA_MAX_QUEUE (padrão: 512). Se a fila estiver cheia, novas solicitações receberão um erro 503 indicando que o servidor está sobrecarregado.

  • Carregamento de Modelos: O número de modelos diferentes que podem ser carregados ao mesmo tempo é controlado por OLLAMA_MAX_LOADED_MODELS. Se uma solicitação exigir o carregamento de um novo modelo e a memória for insuficiente, o Ollama descarregará modelos ociosos para liberar espaço, e a solicitação será colocada em fila até que o modelo seja carregado.

Cenário Exemplo

Se duas solicitações para o mesmo modelo chegarem ao mesmo tempo e a paralelismo do servidor estiver configurado para pelo menos 2, ambas as solicitações serão processadas juntas em um lote, e ambos os usuários receberão respostas simultaneamente. Se a paralelismo estiver configurada para 1, uma solicitação será processada imediatamente, e a outra será colocada em fila até que a primeira termine.

Se as solicitações forem para modelos diferentes e houver memória suficiente, ambos os modelos podem ser carregados e as solicitações processadas em paralelo. Se não houver, um modelo poderá precisar ser descarregado, e a solicitação será colocada em fila.

Tabela de Resumo

Cenário Resultado
Duas solicitações, mesmo modelo, paralelismo suficiente Ambas processadas juntas em paralelo (agrupadas)
Duas solicitações, mesmo modelo, paralelismo=1 Uma processada, segunda em fila até que a primeira termine
Duas solicitações, modelos diferentes, memória suficiente Ambos modelos carregados, solicitações processadas em paralelo
Duas solicitações, modelos diferentes, memória insuficiente Uma em fila até que a memória esteja disponível ou um modelo seja descarregado

Em resumo, o Ollama foi projetado para lidar com múltiplas solicitações simultâneas de forma eficiente, desde que o servidor esteja configurado para concorrência e tenha recursos suficientes. Caso contrário, as solicitações serão colocadas em fila e processadas em ordem.

Gerenciamento de Insuficiência de Memória

Quando o Ollama encontra memória insuficiente para lidar com solicitações entrantes, ele emprega uma combinação de mecanismos de fila e estratégias de gerenciamento de recursos para manter a estabilidade:

Filas de Solicitações

  • Novas solicitações são colocadas em uma fila FIFO (Primeiro a Entrar, Primeiro a Sair) quando a memória não pode ser alocada imediatamente.
  • O tamanho da fila é controlado por OLLAMA_MAX_QUEUE (padrão: 512 solicitações).
  • Se a fila atingir sua capacidade, novas solicitações receberão erros 503 “Servidor Sobrecarregado”.

Gerenciamento de Modelos

  • Modelos ativos podem ser descarregados da memória quando ficarem ociosos, liberando recursos para solicitações em fila.
  • O número de modelos carregados simultaneamente é limitado por OLLAMA_MAX_LOADED_MODELS (padrão: 3×contagem de GPU ou 3 para CPU).

Otimização de Memória

  • Tentativas de processar solicitações para o mesmo modelo em lotes para maximizar a eficiência de memória.
  • Para inferência em GPU, é necessária a alocação completa de VRAM por modelo – carregamentos parciais não são suportados.

Cenários de Falha

Exaustão Crítica de Memória: Quando até as solicitações em fila excederem os recursos disponíveis, o Ollama pode:

  • Paginar para o disco (severamente prejudicando o desempenho)
  • Retornar erros “fora de memória”
  • Em casos extremos, crashar a instância do modelo
Configuração de Controle Propósito Valor Padrão
OLLAMA_MAX_QUEUE Número máximo de solicitações em fila 512
OLLAMA_NUM_PARALLEL Número de solicitações paralelas por modelo carregado 4 (ou 1 se limitado)
OLLAMA_MAX_LOADED_MODELS Número máximo de modelos carregados simultaneamente 3×contagem de GPU ou 3

Administradores devem monitorar o uso de memória e ajustar esses parâmetros com base nas capacidades do hardware. O gerenciamento de memória insuficiente torna-se crucial ao executar modelos maiores (7B+ parâmetros) ou ao processar várias solicitações simultâneas.

Estratégias de Otimização do Ollama

Ative a aceleração por GPU com export OLLAMA_CUDA=1 e defina o número de threads da CPU com export OLLAMA_NUM_THREADS=84. Melhorias de Hardware

  • RAM: 32GB+ para modelos de 13B, 64GB+ para modelos de 70B
  • Armazenamento: SSDs NVMe para carregamento/swap mais rápido de modelos
  • GPU: NVIDIA RTX 3080/4090 com 16GB+ VRAM para modelos maiores

Estratégias Operacionais

  • Agrupar Solicitações: Processar múltiplas consultas simultaneamente para amortizar a sobrecarga de memória
  • Descarregar Automaticamente Modelos: Permitir que o Ollama limpe modelos ociosos da memória
  • Cachear Modelos Frequentemente Usados: Manter modelos comuns residentes na memória

Monitoramento e Solução de Problemas

  • Use nvidia-smi (GPU) e htop (CPU/RAM) para identificar gargalos
  • Para erros de memória:
  • Migre para modelos quantizados
  • Reduza o número de solicitações simultâneas
  • Aumente o espaço de swap

Exemplo de fluxo de otimização:

# Use um modelo quantizado com aceleração por GPU
export OLLAMA_CUDA=1
ollama run llama2:7b-q4_0 --context-size 2048

# Limite os modelos carregados e as solicitações paralelas
export OLLAMA_MAX_LOADED_MODELS=2
export OLLAMA_NUM_PARALLEL=4

Esses ajustes podem reduzir o uso de memória em 30-60% enquanto mantém a qualidade das respostas, especialmente útil ao executar múltiplos modelos ou ao lidar com volumes altos de solicitações.

Ollama: Agrupamento de Solicitações vs Execução Paralela

Agrupamento no Ollama refere-se à prática de agrupar várias solicitações entrantes e processá-las como uma unidade. Isso permite um uso mais eficiente dos recursos computacionais, especialmente em hardware que se beneficia de operações paralelizadas (como GPUs).

Quando várias solicitações para o mesmo modelo chegam ao mesmo tempo, o Ollama pode processá-las juntas em um lote, se a memória permitir. Isso aumenta o throughput e pode reduzir a latência de cada solicitação, pois o modelo pode aproveitar operações matriciais otimizadas sobre o lote.

O agrupamento é especialmente eficaz quando as solicitações são semelhantes em tamanho e complexidade, pois isso permite um melhor uso do hardware.

Execução paralela no Ollama significa lidar com múltiplas solicitações ao mesmo tempo, seja para o mesmo modelo ou para modelos diferentes, dependendo da memória disponível e da configuração.

O Ollama suporta dois níveis de paralelismo:

  • Carregamento de Vários Modelos: Se houver memória suficiente disponível, vários modelos podem ser carregados e servir solicitações simultaneamente.
  • Solicitações Paralelas por Modelo: Cada modelo carregado pode processar várias solicitações simultaneamente, controlado pela configuração OLLAMA_NUM_PARALLEL (o padrão é 1 ou 4, dependendo da memória).

Quando as solicitações excederem o limite de paralelismo, elas serão colocadas em fila (FIFO) até o limite de OLLAMA_MAX_QUEUE.

Conclusão

O Ollama aproveita tanto o agrupamento quanto a execução paralela para processar múltiplas solicitações de forma eficiente. O agrupamento agrupa solicitações para processamento simultâneo, enquanto a execução paralela permite que múltiplas solicitações (ou modelos) sejam executadas simultaneamente. Ambos métodos dependem da memória do sistema e são configuráveis para um desempenho ótimo.

Para mais benchmarks, ajustes de concorrência e orientações de desempenho, consulte nossa LLM Performance: Benchmarks, Bottlenecks & Optimization.