Comment Ollama gère les requêtes parallèles

Ce guide explique comment Ollama gère les requêtes parallèles (concurrence, mise en file d’attente et limites de ressources), et comment l’optimiser à l’aide de la variable d’environnement OLLAMA_NUM_PARALLEL (et des paramètres associés).

Liens rapides : Qu’est-ce que OLLAMA_NUM_PARALLEL ? · Recettes d’optimisation rapide · Fonctionnement de la file d’attente · Dépannage · Connexes : Aide-mémoire des commandes CLI Ollama

Pour en savoir plus sur le débit, la latence, la VRAM et les benchmarks à travers les différents environnements d’exécution et matériels, consultez Performance des LLM : Benchmarks, Goulots d’étranglement & Optimisation.

Les agents multi-étapes multiplient les tentatives lorsque l’échantillonnage est instable ; pour les paramètres par défaut de température, top_p et de pénalité sur les modèles de type Qwen et Gemma, voir Paramètres d’inférence agencés pour Qwen et Gemma.

Gestion des requêtes concurrentes

• Traitement parallèle : Ollama prend en charge le traitement concurrent des requêtes. Si le système dispose d’une mémoire suffisante (RAM pour l’inférence CPU, VRAM pour l’inférence GPU), plusieurs modèles peuvent être chargés simultanément, et chaque modèle chargé peut gérer plusieurs requêtes en parallèle. Cela est contrôlé par la variable d’environnement OLLAMA_NUM_PARALLEL, qui définit le nombre maximum de requêtes parallèles que chaque modèle peut traiter simultanément. Par défaut, cette valeur est fixée à 4 (ou 1, selon la disponibilité de la mémoire), mais elle peut être ajustée.

• Regroupement (Batching) : Lorsque plusieurs requêtes pour le même modèle arrivent simultanément, Ollama les regroupe (batching) et les traite ensemble. Cela signifie que les deux requêtes sont traitées en parallèle, et les utilisateurs verront les réponses diffusées (streaming) en même temps. Le serveur n’attend pas intentionnellement que le lot soit rempli ; le traitement commence dès que les requêtes sont disponibles.

File d’attente et limites

• File d’attente : Si le nombre de requêtes concurrentes dépasse le parallélisme configuré (par exemple, plus de OLLAMA_NUM_PARALLEL requêtes pour un modèle), les requêtes supplémentaires sont mises en file d’attente. La file d’attente fonctionne sur une base premier arrivé, premier servi (FIFO).

• Limites de la file d’attente : Le nombre maximum de requêtes en file d’attente est contrôlé par OLLAMA_MAX_QUEUE (valeur par défaut : 512). Si la file d’attente est pleine, les nouvelles requêtes reçoivent une erreur 503 indiquant que le serveur est surchargé.

• Chargement des modèles : Le nombre de modèles différents qui peuvent être chargés simultanément est contrôlé par OLLAMA_MAX_LOADED_MODELS. Si une requête nécessite le chargement d’un nouveau modèle et que la mémoire est insuffisante, Ollama déchargera les modèles inactifs pour faire de la place, et la requête sera mise en file d’attente jusqu’à ce que le modèle soit chargé.

Scénario d’exemple

Si deux requêtes pour le même modèle arrivent en même temps et que le parallélisme du serveur est défini sur au moins 2, les deux requêtes seront traitées ensemble dans un lot, et les deux utilisateurs recevront des réponses simultanément. Si le parallélisme est défini sur 1, une requête est traitée immédiatement, et l’autre est mise en file d’attente jusqu’à ce que la première se termine.

Si les requêtes concernent des modèles différents et qu’il y a suffisamment de mémoire, les deux modèles peuvent être chargés et les requêtes gérées en parallèle. Sinon, il peut être nécessaire de décharger un modèle, et la requête sera mise en file d’attente.

Tableau récapitulatif

En résumé, Ollama est conçu pour gérer efficacement plusieurs requêtes simultanées, à condition que le serveur soit configuré pour la concurrence et dispose de ressources suffisantes. Sinon, les requêtes sont mises en file d’attente et traitées dans l’ordre.

Gestion de l’insuffisance de mémoire

Lorsqu’Ollama rencontre une mémoire insuffisante pour gérer les requêtes entrantes, il emploie une combinaison de mécanismes de file d’attente et de stratégies de gestion des ressources pour maintenir la stabilité :

Mise en file d’attente des requêtes

• Les nouvelles requêtes sont placées dans une file d’attente FIFO (First-In, First-Out) lorsque la mémoire ne peut pas être allouée immédiatement.
• La taille de la file d’attente est contrôlée par OLLAMA_MAX_QUEUE (valeur par défaut : 512 requêtes).
• Si la file d’attente atteint sa capacité, les nouvelles requêtes reçoivent des erreurs 503 “Serveur surchargé”.

Gestion des modèles

• Les modèles actifs peuvent être déchargés de la mémoire lorsqu’ils deviennent inactifs pour libérer des ressources pour les requêtes en file d’attente.
• Le nombre de modèles chargés simultanément est limité par OLLAMA_MAX_LOADED_MODELS (valeur par défaut : 3 × nombre de GPU ou 3 pour CPU).

Optimisation de la mémoire

• Tentatives de traitement par lots des requêtes pour le même modèle afin de maximiser l’efficacité de la mémoire.
• Pour l’inférence GPU, une allocation complète de la VRAM par modèle est requise - les chargements partiels ne sont pas pris en charge.

Scénarios d’échec

Épuisement critique de la mémoire : Lorsque même les requêtes en file d’attente dépassent les ressources disponibles, Ollama peut :

• Utiliser le swap disque (dégradant sévèrement les performances)
• Retourner des erreurs “mémoire insuffisante” (out of memory)
• Planté l’instance du modèle dans les cas extrêmes

Les administrateurs doivent surveiller l’utilisation de la mémoire et ajuster ces paramètres en fonction des capacités de leur matériel. La gestion de l’insuffisance de mémoire devient cruciale lors de l’exécution de modèles plus grands (7B+ paramètres) ou du traitement de plusieurs requêtes concurrentes.

Stratégies d’optimisation d’Ollama

Activez l’accélération GPU avec export OLLAMA_CUDA=1 et définissez les threads CPU via export OLLAMA_NUM_THREADS=84.

Améliorations matérielles

• RAM : 32 Go+ pour les modèles 13B, 64 Go+ pour les modèles 70B
• Stockage : SSD NVMe pour un chargement/échange de modèles plus rapide
• GPU : NVIDIA RTX 3080/4090 avec 16 Go+ de VRAM pour les modèles plus volumineux

Stratégies opérationnelles

• Regroupement des requêtes : Traiter plusieurs requêtes simultanément pour amortir la surcharge de mémoire
• Déchargement automatique des modèles : Permet à Ollama de purger les modèles inactifs de la mémoire
• Mise en cache des modèles fréquemment utilisés : Conserver les modèles courants en mémoire

Surveillance et dépannage

• Utilisez nvidia-smi (GPU) et htop (CPU/RAM) pour identifier les goulots d’étranglement
• Pour les erreurs de mémoire :
• Passer à des modèles quantifiés
• Réduire les requêtes concurrentes
• Augmenter l’espace swap

Exemple de workflow d’optimisation :

### Utiliser un modèle quantifié avec accélération GPU
export OLLAMA_CUDA=1
ollama run llama2:7b-q4_0 --context-size 2048

### Limiter les modèles chargés et les requêtes parallèles
export OLLAMA_MAX_LOADED_MODELS=2
export OLLAMA_NUM_PARALLEL=4

Ces ajustements peuvent réduire l’utilisation de la mémoire de 30 à 60 % tout en maintenant la qualité des réponses, ce qui est particulièrement bénéfique lors de l’exécution de plusieurs modèles ou de la gestion de volumes de requêtes élevés.

Variable d’environnement OLLAMA_NUM_PARALLEL

OLLAMA_NUM_PARALLEL contrôle le nombre de requêtes qu’Ollama exécutera en parallèle. Si vous envoyez plusieurs requêtes au même serveur Ollama, ce paramètre détermine en grande partie s’elles s’exécutent simultanément ou s’empilent en file d’attente.

• Des valeurs plus élevées peuvent augmenter le débit si vous disposez de suffisamment de CPU/GPU/VRAM, mais peuvent augmenter la latence et la pression sur la mémoire.
• Des valeurs plus faibles réduisent la contention et peuvent améliorer la stabilité, mais les requêtes seront mises en file d’attente plus souvent.

Comment définir OLLAMA_NUM_PARALLEL

Linux / macOS (service systemd ou shell) :

export OLLAMA_NUM_PARALLEL=2
ollama serve

Exécution ponctuelle (préfixe uniquement pour cette commande) :

OLLAMA_NUM_PARALLEL=2 ollama serve

Docker (exemple) :

docker run --rm -e OLLAMA_NUM_PARALLEL=2 -p 11434:11434 ollama/ollama

Comment choisir une valeur

Commencez par 1–2 pour un GPU unique / VRAM limitée, puis augmentez progressivement en surveillant :

• L’utilisation de la VRAM GPU (OOM / évictions)
• L’utilisation du CPU et la charge moyenne
• La latence p95 de vos requêtes typiques
• Le taux d’erreur / les timeouts

Si vous optimisez une page spécifique pour l’utilisation CLI, consultez la section Ollama CLI dans l’aide-mémoire, ainsi que les exemples de commandes pour ollama serve, ollama ps et ollama run.

Recettes d’optimisation rapide

Priorité à la stabilité

• OLLAMA_NUM_PARALLEL=1
• Utiliser des modèles plus petits / quantifiés
• Préférer des tailles de contexte plus courtes

Priorité au débit

• OLLAMA_NUM_PARALLEL=2 (ou plus si vous avez de la marge)
• Envisager le regroupement des requêtes au niveau du client
• S’assurer d’avoir suffisamment de VRAM et de threads CPU

« J’épuise la VRAM lorsque deux requêtes arrivent »

• Réduire OLLAMA_NUM_PARALLEL
• Utiliser un modèle plus agressivement quantifié
• Réduire la longueur du contexte / max tokens

Dépannage

Symptômes indiquant que OLLAMA_NUM_PARALLEL est trop élevé

• Les requêtes échouent intermittemment sous charge
• OOM GPU / déchargement de modèles fréquents
• Pics de latence lors de l’arrivée de la deuxième requête

Symptômes indiquant que OLLAMA_NUM_PARALLEL est trop faible

• Le CPU/GPU est sous-utilisé
• Les délais de file d’attente dominent le temps de réponse total

Astuce : Si vous contrôlez également votre client, ajoutez des retries avec du jitter et maintenez des connections keep-alive. De nombreux problèmes « Ollama est lent » sont en réalité dus à la file d’attente + à la surcharge de connexion.

Ollama : Regroupement des requêtes vs Exécution parallèle

Le regroupement (Batching) dans Ollama fait référence à la pratique de regrouper plusieurs requêtes entrantes et de les traiter comme une unité. Cela permet une utilisation plus efficace des ressources informatiques, en particulier sur du matériel qui bénéficie des opérations parallélisées (telles que les GPU).

Lorsque plusieurs requêtes pour le même modèle arrivent simultanément, Ollama peut les traiter ensemble dans un lot si la mémoire le permet. Cela augmente le débit et peut réduire la latence pour chaque requête, car le modèle peut tirer parti d’opérations matricielles optimisées sur le lot.

Le regroupement est particulièrement efficace lorsque les requêtes sont similaires en taille et en complexité, car cela permet une meilleure utilisation du matériel.

L’exécution parallèle dans Ollama signifie gérer plusieurs requêtes en même temps, soit pour le même modèle, soit pour des modèles différents, selon la mémoire disponible et la configuration.

Ollama prend en charge deux niveaux de parallélisme :

• Chargement de plusieurs modèles : Si suffisamment de mémoire est disponible, plusieurs modèles peuvent être chargés et servir des requêtes simultanément.
• Requêtes parallèles par modèle : Chaque modèle chargé peut traiter plusieurs requêtes en parallèle, contrôlé par le paramètre OLLAMA_NUM_PARALLEL (la valeur par défaut est 1 ou 4, selon la mémoire).

Lorsque les requêtes dépassent la limite de parallélisme, elles sont mises en file d’attente (FIFO) jusqu’à OLLAMA_MAX_QUEUE.

Conclusion

Ollama utilise à la fois le regroupement et l’exécution parallèle pour traiter plusieurs requêtes efficacement. Le regroupement regroupe les requêtes pour un traitement simultané, tandis que l’exécution parallèle permet à plusieurs requêtes (ou modèles) de s’exécuter simultanément. Ces deux méthodes dépendent de la mémoire système et sont configurables pour des performances optimales.

Pour plus de benchmarks, de réglages de concurrence et de conseils de performance, consultez notre hub Performance des LLM : Benchmarks, Goulots d’étranglement & Optimisation.

Liens utiles

• Aide-mémoire des commandes Ollama
• Comparaison des performances LLM - Ollama sur GPU 16 Go VRAM
• Déplacer les modèles Ollama vers un autre lecteur ou dossier
• Comment Ollama utilise les cœurs Performance et Efficient des CPU Intel