
Vous êtes votre propre voisin bruyant : conteneurs, multi-location et ressources garanties

Réponse courte : Les voisins bruyants proviennent de ressources sur-vendues, et non du partage d'une machine. Une plateforme de conteneurs qui garantit à chaque serveur de jeu son processeur et sa mémoire offre une isolation égale, et souvent supérieure, à celle d'un serveur dédié physique exécutant de nombreux matchs d'un même jeu. Traiter la colocation comme un risque pousse les studios vers des flottes dédiées inactives ou les éloigne des serveurs autoritaires au profit du peer-to-peer ou des relais, deux solutions coûteuses à un problème que des ressources garanties résolvent déjà.
Vous êtes votre propre voisin bruyant : Un serveur dédié exécute des dizaines de matchs à la fois, et le noyau traite vos propres matchs chargés exactement comme ceux d'un autre studio.
Les ressources garanties éliminent la majeure partie des conflits : Avec un processeur et de la mémoire alloués via cgroups et sans sur-allocation, un voisin actif est limité à sa propre allocation, et le projet Heracles de Google a atteint une utilisation moyenne de 90 % avec zéro violation d'engagement de niveau de service (SLO) de latence en isolant chaque ressource partagée.
Certains incidents de "voisin bruyant" ont été mal diagnostiqués : Chez Indeed (un service web, pas un jeu), la latence attribuée à des conteneurs bruyants s'est avérée provenir de la gestion par le noyau de ses propres quotas de processeur, et sa correction a réduit le temps de réponse dans le pire des cas de plus de 2 secondes à 30 ms.
Le matériel physique n'échappe pas au partage des composants : Le cache L3, la bande passante mémoire, les E/S, l'alimentation et le SMT sont partagés par chaque match sur une machine physique, quel qu'en soit le propriétaire, et la plupart de ces effets n'ajoutent que quelques pourcents de latence.
Le temps d'attente du processeur est la métrique qui révèle un vrai voisin bruyant : L'utilisation montre à quel point un serveur est occupé, mais pas s'il est privé de ressources, tandis que les informations sur les blocages de pression Linux (PSI) indiquent combien de temps ses threads ont attendu un cœur, ce qu'Edgegap surveille par déploiement.
La peur du « voisin bruyant » (« noisy neighbor ») est l'une des objections les plus courantes soulevées par les studios contre l'exécution de serveurs de jeu dans des conteneurs sur une infrastructure partagée. Le remède habituellement proposé est le déploiement dédié (single tenancy) : louer une machine bare-metal dédiée afin qu'aucune charge de travail d'une autre entreprise ne se trouve à côté de la vôtre.
Cette peur elle-même relève peut-être plus du mythe que de la mesure réelle. Elle a principalement pris racine sur les machines virtuelles cloud à cœurs partagés : des instances économiques et délibérément sursouscrites, conçues pour des serveurs web à faible trafic, où le pic d'activité d'un voisin peut réellement vous priver de temps processeur. Les serveurs de jeu ont des besoins très différents, et Edgegap n'utilise pas cette catégorie de machines.
Le déploiement dédié passe à côté du sujet. Un serveur bare-metal moderne dispose de 32, 64 cœurs ou plus, et aucun studio n'exécute un seul match par machine. Il rassemble des dizaines d'instances de match sur le même hôte, et chacune de ces instances est un voisin pour toutes les autres. Si une grande bataille éclate dans le match 17 alors que le match 18 se trouve dans un lobby, la physique de la contention est identique, que le match 18 appartienne au même studio ou à un autre. Sur un serveur dédié, vous êtes votre propre voisin bruyant.
En d'autres termes, le modèle d'hébergement n'est pas la variable qui compte. Ce qui importe, c'est de savoir si chaque charge de travail dispose de ressources garanties que personne d'autre, ni un autre studio ni vos propres autres matches, ne peut lui retirer. Cet article explique, du processeur jusqu'aux applications, comment la contention se produit réellement, contre quoi les ressources garanties protègent ou non, quelle est l'ampleur des effets résiduels selon les recherches publiées, et quelle métrique un studio devrait réellement surveiller.
1. Comment fonctionne un processeur : la cuisine
Un processeur est un cuisinier très rapide et extrêmement littéral. Il ne comprend pas ce qu'est un jeu, un match ou un joueur. Il exécute de minuscules instructions, les unes après les autres, des milliards de fois par seconde. Tout au long de cet article, nous garderons une image à l'esprit : la cuisine d'un restaurant.

La boucle d'instruction
Chaque programme se compile en instructions machine : charger une valeur, additionner deux valeurs, les comparer, sauter à une autre instruction si le résultat est zéro. Le cœur du processeur exécute une boucle consistant à charger (lire l'instruction suivante), décoder (comprendre ce qu'elle signifie) et exécuter (l'accomplir). Dans la cuisine, cela correspond à un cuisinier qui lit une ligne de recette, l'exécute et lit la suivante. Le cuisinier ne voit jamais le plat dans son ensemble, seulement la ligne suivante.
L'horloge
Un cœur fait progresser son travail à chaque tic d'horloge. Un cœur à 3,5 GHz effectue 3,5 milliards de cycles par seconde. Imaginez un métronome qui donne le rythme de chaque coup de couteau. Les processeurs modernes font également varier ce rythme de façon dynamique (turbo boost), tournant plus vite lorsqu'ils ont de la marge thermique et électrique, et plus lentement lorsqu'ils n'en ont pas. Nous y reviendrons.
Pipeline et spéculation
Un cœur n'attend pas qu'une instruction soit terminée avant de commencer la suivante. Il fait se chevaucher les étapes, de la même manière qu'un cuisinier attrape les carottes tout en finissant de couper les oignons. Lorsque le code comporte un embranchement (« si le joueur est à portée, calculer les dégâts »), le cœur prédit le résultat probable et commence à y travailler avant même de connaître la réponse. Une prédiction correcte fait gagner du temps ; une mauvaise oblige à jeter le travail effectué et à recommencer. Les prédicteurs modernes ont raison la grande majorité du temps.
La hiérarchie de la mémoire
Un cœur ne peut travailler que sur des données qu'il a sous la main, et la distance est primordiale :
Niveau | Équivalent en cuisine | Temps d'accès typique |
|---|---|---|
Registres | Les ingrédients entre les mains du cuisinier | moins de 1 ns |
Cache L1 / L2 (propre à chaque cœur) | La planche à découper personnelle du cuisinier | environ 1 à 4 ns |
Cache L3 (partagé par les cœurs de la puce) | L'étagère à épices partagée | environ 10 à 20 ns |
Mémoire vive (RAM) | La chambre froide à l'autre bout de la cuisine | environ 60 à 100 ns |
SSD / stockage réseau | L'épicerie au bout de la rue | 10 000 ns et plus |
Une grande partie de la conception des processeurs consiste à prédire de quels ingrédients le cuisinier aura besoin ensuite et à les poser sur le plan de travail avant même qu'il ne les demande. Un cuisinier qui passe son temps à faire des allers-retours au réfrigérateur est un cuisinier lent, quelle que soit la rapidité de ses mains. Notez que le cache L3 et la voie d'accès à la RAM sont partagés entre les cœurs ; cela aura son importance plus tard.
Cœurs et threads matériels
Un processeur de serveur moderne comporte de nombreux cœurs, ce qui correspond à de nombreux cuisiniers dans la même cuisine. Ils travaillent en véritable parallèle. Certains processeurs proposent également le multithreading simultané (SMT, appelé Hyper-Threading chez Intel) : chaque cuisinier physique se présente comme deux cuisiniers auprès du restaurant, passant d'une recette à l'autre dès que l'une est bloquée dans l'attente d'un ingrédient. Cela permet de tirer davantage de travail de chaque cuisinier, mais deux « cuisiniers » en SMT se partagent une seule paire de mains.
L'ordonnanceur (scheduler)
Un serveur exécute bien plus de programmes qu'il n'a de cœurs. L'ordonnanceur du système d'exploitation est l'aboyeur au passe-plat : il décide sur quelle commande chaque cuisinier travaille et pendant combien de temps. Sous Linux, l'ordonnanceur par défaut (CFS, et depuis le noyau 6.6 son successeur EEVDF) accorde à chaque tâche exécutable une tranche de temps équitable, mesurée en millisecondes, puis change de tâche. Lorsqu'une tâche est prête à tourner mais qu'aucun cuisinier n'est libre, elle attend dans une file d'attente d'exécution (run queue). Ce temps d'attente est le chiffre le plus important de tout cet article.
Les interruptions
Lorsqu'un paquet réseau arrive ou qu'une minuterie sonne, le matériel fait tinter une cloche au passe-plat. Le cuisinier s'arrête, gère brièvement l'événement urgent, puis reprend son travail. Pour un serveur de jeu, l'arrivée des paquets constitue un flux incessant de ces cloches.
2. Les conteneurs : des postes de travail scellés dans une cuisine partagée
Un conteneur n'est pas une petite machine virtuelle. Il s'agit d'un processus Linux ordinaire que le noyau enveloppe dans deux ensembles de mécanismes de contrôle : les espaces de noms (namespaces), qui déterminent ce que le processus peut voir, et les groupes de contrôle (cgroups), qui déterminent quelle part de la machine il peut utiliser.
Les espaces de noms : les parois du poste de travail
Les espaces de noms procurent à un processus sa propre vision du système de fichiers, des identifiants de processus, des interfaces réseau, du nom d'hôte et des utilisateurs. Un serveur de jeu dans un conteneur ne voit que ses propres fichiers et ses propres processus, et pense être seul sur la machine. Dans la cuisine, chaque conteneur est un poste de travail scellé doté de ses propres bacs étiquetés : exactement les ingrédients, ustensiles et fiches recettes nécessaires à un plat. Le poste thaïlandais ne peut pas aller piocher dans l'huile d'olive du poste italien.
Les images : le modèle de kit repas
Une image de conteneur est un paquet figé et versionné de tout ce dont le programme a besoin : binaires, bibliothèques, configuration. Un conteneur en cours d'exécution est un poste de travail configuré à partir de ce modèle. Dix postes de travail identiques peuvent être mis en place à partir d'une seule image en quelques secondes, dans n'importe quelle cuisine acceptant les mêmes kits. C'est pourquoi les conteneurs éliminent les problèmes du type « ça marche sur ma machine » et démarrent si vite. La mise en cache des images d'Edgegap pousse cela encore plus loin : Edgegap déploie un serveur de jeu complet à partir d'un démarrage à froid en une médiane de 2 secondes.
Le noyau partagé : mêmes cuisiniers, même bâtiment
Chaque conteneur sur un hôte partage le même noyau Linux, les mêmes cœurs de processeur et la même mémoire physique. Un conteneur n'amène pas son propre cuisinier ; il apporte son propre garde-manger et ses propres règles. C'est ce qui rend les conteneurs si légers, et c'est aussi pourquoi la question de l'isolation des ressources se pose.
Les cgroups : les règles de rationnement
C'est dans les cgroups que l'aboyeur inscrit les allocations de chaque poste. Les contrôleurs pertinents pour les serveurs de jeu sont :
cpu : un quota de temps processeur par période (par exemple, 200 ms de processeur toutes les 100 ms, soit l'équivalent de deux cœurs), et un poids relatif appliqué lorsque la machine est saturée.
cpuset : assigne un conteneur à des cœurs physiques précis, de sorte que ses cuisiniers soient ses cuisiniers et ceux de personne d'autre.
memory : un plafond strict de mémoire vive (RAM), assorti de paramètres de réservation et de protection empêchant le noyau de récupérer la mémoire d'un conteneur pour en alimenter un autre.
io : des limites et des priorités sur le débit disque et les opérations par seconde.
La plupart des studios découvrent d'abord les conteneurs via Docker sur leurs machines de développement, où il s'avère un outil pratique pour construire et tester une image de serveur de jeu. Docker n'est cependant qu'une couche de packaging et d'outillage ; l'isolation elle-même provient des espaces de noms et des cgroups du noyau. Les extensions de moteur d'Edgegap (ses outils d'automatisation de build) s'appuient sur Docker pour empaqueter la compilation d'un studio dans une image de conteneur, et les studios peuvent exécuter cette image localement avec Docker pour la tester. Une fois l'image téléversée, Edgegap la déploie pour le compte du studio sans passer par Docker, en configurant directement ces contrôles du noyau via sa propre orchestration.
Linux compte deux générations de cgroups. La version 1 (2008) laissait chaque contrôleur vivre dans sa propre hiérarchie séparée, ce qui créait une comptabilisation incohérente et certaines dérives bien connues. La version 2 (stable depuis le noyau 4.5, adoptée par défaut dans toutes les distributions majeures depuis environ 2021) unifie l'ensemble dans une arborescence unique, corrige la comptabilisation de la mémoire et des E/S, et intègre le système Pressure Stall Information (PSI), une mesure directe du temps pendant lequel les tâches ont attendu après le processeur, la mémoire ou les E/S. Nous reviendrons sur ces deux points en conclusion.
Les machines virtuelles, à titre de comparaison
Une machine virtuelle repose sur une approche différente : au lieu d'un poste de travail au sein de la cuisine partagée, vous construisez une cuisine entière à l'intérieur du bâtiment, avec son propre exemplaire du règlement intérieur (son propre noyau) tournant sur un hyperviseur. Les machines virtuelles sont plus lourdes et plus lentes à démarrer. Elles ne sont pas non plus automatiquement mieux isolées des voisins bruyants : sur les offres à cœurs partagés et à capacité modulable (burstable), le « vCPU » d'une VM cloud n'est qu'une tranche de temps d'un cœur physique partagé avec d'autres clients, et l'hyperviseur utilise exactement le même type d'ordonnanceur que celui décrit précédemment.
L'orchestration
Faire tourner des conteneurs à l'échelle d'une flotte nécessite un gestionnaire qui décide quelle cuisine accueille quel poste de travail, en ouvre davantage lorsque la demande explose, les ferme lorsqu'elle diminue et déroute les commandes loin d'une cuisine en difficulté. C'est là le rôle d'un orchestrateur, et pour les serveurs de jeu, c'est précisément ce que fait Edgegap : placer chaque match sur un hôte proche de ses joueurs, avec une allocation de ressources bien définie.
3. Ce que fait réellement un voisin bruyant
Un voisin bruyant désigne toute charge de travail dont la hausse soudaine de consommation dégrade les performances d'une autre charge de travail sur la même machine. Dans la cuisine : le poste situé à côté du vôtre reçoit un groupe de quarante personnes, et son cuisinier commence à s'emparer des feux que vous n'utilisiez pas « à cet instant précis », à accaparer le temps des cuisiniers et à encombrer l'accès au réfrigérateur. Votre plat n'a subi aucune erreur, mais il sort en retard.
Techniquement, la dégradation s'opère par le biais de quatre mécanismes.
1. La contention sur la file d'attente du processeur (CPU run queue)
S'il y a plus de threads prêts à s'exécuter que de cœurs disponibles pour les accueillir, certains patientent dans la file d'attente de l'ordonnanceur. Pour un serveur de jeu tournant à 30 ou 60 Hz (son tick rate), chaque cycle dispose d'un budget de 33 ou 16,7 ms. Quelques millisecondes d'attente au mauvais moment font dépasser son échéance au tick, et les joueurs le ressentent sous forme de téléportations (rubber-banding) ou de tirs non comptabilisés. C'est le cas classique du voisin bruyant, et cela ne se produit que lorsque la machine a promis plus de puissance CPU qu'elle n'en possède physiquement.
2. Le bridage par quota (quota throttling)
Lorsqu'un conteneur a une limite de processeur (un quota de cgroup), le noyau cesse de lui allouer du temps dès qu'il a épuisé son quota pour la période en cours, même si des cœurs restent inoccupés. Un serveur de jeu multithread avec des pics d'activité peut consommer tout son quota dès le début d'une période de 100 ms et se retrouver gelé pour le reste de celle-ci. Ce phénomène n'est absolument pas causé par un voisin, mais il y ressemble trait pour trait sur un graphique de latence, et il est à l'origine d'une part importante des signalements de « voisins bruyants » dans la pratique (voir la conclusion pour le bogue du noyau qui a considérablement aggravé la situation entre 2018 et 2019).
3. La pression sur la mémoire
Si la RAM de la machine est survendue et que chaque charge de travail grossit simultanément, le noyau commence à récupérer des pages : en vidant les caches de fichiers, en compressant la mémoire ou en échangeant des données sur le disque (swap). Un serveur de jeu dont l'ensemble de travail actif se retrouve déporté sur disque subit des blocages de l'ordre de plusieurs millisecondes à plusieurs secondes. Dans la cuisine, c'est comme si quelqu'un avait emballé vos ingrédients pour les renvoyer à l'épicerie.
4. La contention sur le matériel partagé
Même avec des cœurs et de la RAM dédiés, certains éléments matériels restent physiquement partagés : le cache L3, la bande passante mémoire, la carte réseau, le disque, le budget énergétique de la puce et, avec le SMT, les unités d'exécution d'un cœur physique. La section 5 quantifie ces éléments.
Vous êtes votre propre voisin bruyant
Remarquez qu'aucun de ces mécanismes ne se soucie de savoir à qui appartient la charge de travail voisine. L'ordonnanceur du noyau n'a aucune notion de « studio ». Une file d'attente ne demande pas à qui appartient le thread situé devant le vôtre ; une mémoire cache L3 ne sait pas quelles sont les données qu'elle est en train d'expulser.
Considérons un studio qui loue un serveur bare-metal dédié de 64 cœurs et y exécute 40 matches. Un vendredi soir, dix de ces matches entrent en phase finale simultanément : plus de joueurs vivants dans une zone réduite, plus de projectiles, plus de physique. Si le studio a regroupé ces 40 matches en utilisant des shares de CPU ou des limites sursouscrites (ce qui est courant, car c'est cette densité qui rentabilise les serveurs dédiés), les dix matches intenses vont voler du temps processeur aux 30 autres via exactement les mêmes mécanismes de file d'attente et de cache décrits plus haut.
Le déploiement dédié ne change que le nom figurant sur la facture du voisin. Il ne supprime pas le voisin. Le constat est identique si vous exploitez votre propre cluster Kubernetes avec Agones sur vos propres serveurs : chaque pod de serveur de jeu sur un nœud est un voisin pour tous les autres, et sans cœurs assignés et requêtes de ressources garanties, vous restez votre propre voisin bruyant. Un studio véritablement soucieux des problèmes de contention devrait se poser une question différente : les ressources de mes matches sont-elles garanties, ou sont-elles partagées sur le pari que tout le monde ne sera pas actif en même temps ?
4. Comment les ressources garanties éliminent l'essentiel du problème
Garantir les ressources signifie que la plateforme ne vend jamais plus que ce que le matériel possède réellement. Chaque conteneur reçoit une allocation de CPU imposée par les cgroups du noyau, une réservation de mémoire qui ne peut être réquisitionnée pour quelqu'un d'autre, et aucun quota de processeur assez contraignant pour brider les pics normaux d'activité. Dans la cuisine : le temps de cuisson sur les feux de chaque poste lui est réservé, même lorsqu'il est inutilisé, et le restaurant n'a jamais accepté plus de postes qu'il n'a de feux disponibles.
Cela supprime directement les mécanismes 1 et 3 de la section 3, et, si la configuration est correcte, le mécanisme 2 :
Aucune contention sur les files d'attente causée par autrui : Comme aucun hôte n'est alloué au-delà de son nombre de threads réels, l'allocation de processeur de chaque conteneur existe physiquement dans le matériel, et un voisin très actif est confiné à sa propre limite au lieu d'empiéter sur le processeur alloué à votre serveur. Il peut toujours partager les unités d'exécution d'un cœur physique avec ce qui tourne sur le thread jumeau (Section 5.4).
Aucune récupération de mémoire par autrui : Une allocation de mémoire réservée n'est pas reprise pour alimenter un voisin, de sorte que l'ensemble de travail du serveur de jeu reste en mémoire vive.
Aucun bridage imprévu : Sans quota sursouscrit, une montée en charge consomme des threads que le conteneur possède déjà.
Hypothèse retenue dans ce document
Un vCPU équivaut à un thread matériel, et non à un cœur physique. Aucun hôte n'est alloué au-delà de son nombre total de threads, et la mémoire est réservée. Comme chaque cœur physique comporte deux threads, la charge de travail d'un conteneur peut partager un cœur physique avec un autre conteneur.
Les données convergent systématiquement dans la même direction :
Constat | Source |
|---|---|
Google a colocalisé des services hautement sensibles à la latence (recherche web, magasin clé-valeur, clustering ML) avec des traitements par lots et a atteint 90 % d'utilisation moyenne des serveurs sans aucune violation de SLO de latence, en combinant l'assignation de cœurs avec l'isolation du cache, de la bande passante mémoire, du réseau et de l'énergie. En utilisant uniquement les priorités de conteneurs (shares) sans assignation de cœurs, les mêmes colocalisations violaient les objectifs de latence, même à faible charge. | Lo et al., Heracles, ISCA 2015 [1][2] |
Dans Heracles, le simple fait d'assigner les tâches critiques en latence et les tâches par lots à des cœurs distincts via cpuset a suffi à éliminer les interférences d'ordonnancement sur un même cœur ainsi que les interférences d'hyperthreading. | Lo et al. [1], résumé par Luu [3] |
Une étude à grande échelle des analyses de performances sur le cloud public a conclu que les performances dépendantes du CPU reposent principalement sur le matériel réellement alloué, tandis que ce sont les charges dépendantes des E/S qui sont sensibles aux voisins bruyants. | Leitner et Cito, ACM TOIT 2016 [4], résumé dans Duet Benchmarking [5] |
Une étude de 2025 exécutant un benchmark réaliste de traitement de flux sur AWS pendant plus de trois mois a révélé que la variabilité du débit était bien moins prononcée que souvent supposé, avec un coefficient de variation inférieur à 3,7 %. | Étude de variabilité du traitement de flux, arXiv 2025 [6] |
Quand Indeed a découvert que la latence de ses conteneurs « bruyants » venait de la gestion des quotas de CPU par le noyau (et non de leurs voisins), la correction du problème a permis de réduire la latence de réponse dans le pire des cas de plus de 2 secondes à 30 ms. | Chiluk, Indeed Engineering, 2019 [7] |
La dernière ligne est plus importante qu'elle n'en a l'air. Une partie de ce que les équipes qualifiaient historiquement de « voisin bruyant » n'a jamais été un voisin : il s'agissait d'un bridage par quota au sein même de leur propre conteneur, provoqué par la configuration ou par un bogue du noyau. Des allocations garanties, sans quotas trop stricts, éliminent purement et simplement ce type de problème. Edgegap est en activité depuis assez longtemps pour avoir vu passer des milliers de configurations de jeux et de serveurs, et cette expérience a renforcé à la fois l'expertise de l'équipe et la qualité de configuration et d'exploitation de la plateforme.
Ce qu'il reste une fois éliminée la contention sur le processeur, la mémoire et les quotas, c'est l'ensemble des composants matériels véritablement partagés. Ils sont réels, ils sont mesurables, mais leur impact est bien plus faible.
5. Mises en garde et limites
Un processeur et une mémoire garantis ne rendent pas un serveur parfaitement isolé, et nous préférons exposer les effets résiduels plutôt que de paraître partiaux. Cinq composants partagés peuvent encore transmettre des interférences entre les conteneurs d'un même hôte, y compris entre les propres matches d'un studio sur son propre serveur dédié (cela peut donc vous toucher que vous utilisiez Edgegap ou votre propre architecture de conteneurs) :
1. L'étagère à épices partagée : le cache de dernier niveau (L3)
Pour les serveurs de jeu, c'est un non-problème : l'état chaud d'un match tient dans la part de cache L3 attribuée à chaque cœur, ce qui maintient l'impact dans une fourchette inférieure à quelques pourcents.
Les cœurs d'une même puce partagent le cache L3. Un voisin qui lit ou écrit continuellement de gros volumes de données peut expulser vos données, ce qui impose des accès supplémentaires à la mémoire vive. L'effet est bien réel : lors d'un test interne d'Intel opposant une tâche sensible à la latence d'interruption à une charge antagoniste saturant la mémoire, la latence moyenne était de 4,53 µs sans partitionnement du cache et de 1,62 µs avec [3][8]. Cependant, les charges de travail typiques des serveurs ne tirent que peu d'avantages au-delà de 4 à 6 Mo de L3 [3][9], et les processeurs de serveur AMD EPYC série 9004 actuels fournissent 4 Mo de cache L3 par cœur [10]. Pour un serveur de jeu dont l'état chaud (positions des entités, phase large de détection des collisions) tient confortablement dans cette limite, l'impact attendu en colocation normale se situe dans les pourcentages à un chiffre très bas.
2. L'accès au réfrigérateur : la bande passante mémoire
Pour les serveurs de jeu, c'est un non-problème : les plateformes modernes ont de la bande passante à revendre, et les serveurs de jeu ne correspondent pas au profil des charges intensives en mémoire qui la saturent.
Chaque cœur accède à la mémoire vive via les mêmes contrôleurs mémoire. Des études antérieures, publiées en 2011 sur des processeurs vieux d'environ 19 ans utilisant un bus frontal (FSB) partagé, mesuraient des variations de performances allant jusqu'à 25 % pour la recherche web et 40 % pour d'autres applications selon le placement des threads [11]. L'architecture des serveurs a radicalement évolué depuis. Les plateformes modernes sont bien plus larges : la série EPYC 9004 d'AMD offre jusqu'à 460,8 Go/s par socket sur 12 canaux DDR5 [10], et les mesures effectuées sur la flotte de Google ont révélé que le 90e percentile d'utilisation de la bande passante mémoire n'était que de 31 % [3][12]. La saturation de la bande passante nécessiterait que de nombreux voisins exécutent simultanément des traitements brassant massivement de la mémoire, ce qui n'est pas le cas d'un serveur de jeu.
3. Le quai de chargement : les entrées/sorties disque et réseau
Pour les serveurs de jeu, c'est un non-problème : de petits paquets UDP envoyés à un tick rate régulier ne sollicitent qu'une fraction infime de la carte réseau, et la régulation par conteneur empêche une charge d'accaparer la liaison.
Les cartes réseau et les disques partagés sont, selon la littérature consacrée au cloud public, les composants les plus sensibles aux voisins bruyants [4][5]. Toutefois, les serveurs de jeu réalisent très peu d'E/S disque après leur démarrage, et leur trafic réseau se résume à de petits paquets UDP émis à une fréquence régulière, ce qui ne représente qu'une part minime des capacités d'une carte réseau de 25 ou 100 Gbps. La régulation du trafic (qdisc de Linux) et les limites par conteneur évitent qu'une charge de travail ne monopolise la connexion, comme cela a été démontré dans Heracles [1].
4. Deux cuisiniers pour une seule paire de mains : le SMT
Géré par le placement et la surveillance : des threads jumeaux atteignent rarement leurs pics simultanément, le temps d'attente CPU par déploiement met en évidence les conflits éventuels, et le fait d'allouer les deux threads d'un même cœur à un seul serveur de jeu supprime cet effet.
Il s'agit là de l'effet résiduel le plus important, et il s'applique de la même manière à une plateforme de conteneurs mutualisée qu'aux propres serveurs bare-metal d'un studio où le SMT est activé. Chaque cœur physique expose deux threads matériels, et si l'on compte un vCPU comme un thread, le jumeau du thread de votre serveur de jeu peut très bien héberger un autre conteneur. Quand les deux jumeaux sont occupés en même temps, ils se disputent les unités d'exécution du cœur, et un contributeur de la liste de diffusion du noyau a documenté une requête de 100 ms s'étirant jusqu'à 165 ms en raison d'un jumeau très sollicité [13]. Les serveurs de jeu fonctionnant par pics intermittents, les deux jumeaux atteignent rarement leur pic au même instant et l'effet réel est nettement plus faible que ce scénario du pire. Lorsque cela se produit, cela se traduit directement dans le temps d'attente CPU, qu'Edgegap surveille pour chaque déploiement (voir la conclusion). Allouer les vCPU par paires de threads jumeaux, afin que les deux threads d'un même cœur soient affectés au même serveur de jeu, supprime ce phénomène ; Heracles a démontré que regrouper les threads jumeaux au sein d'une même charge de travail élimine les interférences d'hyperthreading [1][3].
5. La chaleur des fourneaux : limites énergétiques et thermiques
Pas un problème de mutualisation : un processeur de serveur tournant à pleine charge perd environ 4 % de sa fréquence d'horloge, et un serveur dédié surchargé subit exactement la même perte.
Lorsque chaque cœur est fortement sollicité, un processeur réduit sa fréquence d'horloge pour rester dans son enveloppe thermique et énergétique. Sur un processeur de serveur AMD EPYC moderne, la fréquence maximale sur un seul cœur est de 3,7 GHz tandis que la fréquence tous cœurs actifs est de 3,55 GHz [10], soit un écart d'environ 4 %. C'est le plafond de cet effet lorsque la totalité de la puce est pleinement chargée, et cela relève de la physique du matériel, non de la mutualisation : un serveur dédié saturé subira exactement les mêmes 4 %. L'impact peut se révéler plus prononcé sur les processeurs grand public à haute fréquence souvent commercialisés pour l'hébergement de jeux sur bare-metal. Les puces Ryzen 7000 d'AMD, par exemple, sont « conçues pour consommer toute la marge thermique disponible afin d'offrir des performances maximales » : lors des tests menés par Tom's Hardware, le Ryzen 9 7950X est monté à 90 °C en charge, pour une limite de fonctionnement sécurisée de 95 °C [20]. Sur une puce taillée pour fonctionner à sa limite thermique, la vitesse d'horloge globale dépend directement de la qualité du refroidissement de l'hôte.
Comment Edgegap gère ces aspects
Edgegap met en œuvre les contrôles suivants sur l'ensemble de son parc :
Des allocations de CPU garanties et appliquées via les cgroups, sans sursouscription de processeur sur les hôtes de serveurs de jeu.
Des réservations strictes de mémoire vive, sans surallocation de mémoire sur les hôtes de serveurs de jeu.
Aucun quota de processeur contraignant sur les conteneurs de serveurs de jeu, éliminant ainsi le bridage par quota comme source de gigue (jitter).
Une régulation du trafic réseau par conteneur et des règles de placement qui répartissent les charges lourdes entre plusieurs machines hôtes.
Une surveillance continue de la pression processeur par conteneur, détaillée en conclusion.
Edgegap utilise généralement des machines plus modestes, ce qui allège la sollicitation des composants partagés cités plus haut. La surveillance continue du processeur et de la RAM permet par ailleurs à la plateforme de déterminer avec précision si une machine donnée peut accueillir de nouveaux serveurs de jeu.
6. Impact estimé : conteneur contre bare-metal
Les deux graphiques s'appuient sur le même matériel avec le SMT activé, de sorte que les effets liés au matériel partagé (threads jumeaux, cache, bande passante mémoire, E/S, alimentation) sont identiques. La seule nuance réside dans la configuration : le fait que chaque serveur de jeu dispose ou non d'une allocation CPU garantie, et que l'hôte soit ou non surchargé au-delà de son nombre de threads.

Estimations indicatives issues des fourchettes présentées dans la Section 5 et des références [3], [8] à [13] ; non mesurées sur un jeu spécifique

Estimations indicatives ; le plafond de la file d'attente découle d'une sursouscription de 25 % au-dessus du nombre de cœurs, le plafond de SMT découle du rapport sur le noyau dans [13]
La seule ligne qui change concerne la contention sur la file d'attente d'exécution, qui résulte du fait de faire tourner plus de matches intensifs que l'hôte ne compte de threads. Cette pratique est courante sur les serveurs dédiés, car c'est cette densité qui permet d'amortir leurs coûts. Un serveur bare-metal configuré de la même façon que le conteneur (chaque match bénéficiant d'une allocation garantie, sans sursouscription au-delà du nombre de threads) affiche alors le premier graphique. Les deux configurations présentent la même exposition au SMT, qui ne disparaît que lorsque les vCPU sont alloués par paires de threads jumeaux ou que le SMT est désactivé. Ces chiffres constituent des estimations élaborées d'après les plages de valeurs publiées.
Conclusion : une crainte héritée d'anciens noyaux
La crainte du voisin bruyant, telle qu'elle est habituellement formulée par les studios, trouve bien plus son origine dans l'histoire des technologies que dans le comportement actuel d'un Linux moderne sur une plateforme correctement administrée.
Première source : les machines virtuelles cloud à cœurs partagés
Les fournisseurs de cloud public proposent deux types de machines virtuelles radicalement différents. Les modèles à vCPU dédiés réservent chaque vCPU à une seule VM. Les modèles à cœurs partagés et à capacité modulable (burstable) sont délibérément sursouscrits pour maintenir des tarifs attractifs : les instances e2-micro, e2-small et e2-medium de Google se partagent un cœur physique et sont pensées comme une solution économique pour exécuter de petites applications peu gourmandes [17], tandis que les instances AWS de série T ne garantissent qu'un niveau de base et s'appuient sur un système de crédits processeur pour absorber les pics [18]. Le niveau de base d'une t3.nano ne représente que 5 % d'un vCPU, et en mode standard, une fois ses crédits épuisés, elle est bloquée à ce seuil [19]. Ces gammes de machines sont prévues pour des sites web à faible trafic, des environnements de développement et des tâches intermittentes. Ce sont également elles que la plupart des développeurs ont en tête lorsqu'ils évoquent un voisin bruyant, et un serveur de jeu déployé sur ce type d'instance en souffrira indéniablement. Edgegap n'utilise aucune machine virtuelle à cœurs partagés ou à capacité modulable dans son offre cloud. Chaque déploiement repose sur des ressources dédiées.
Seconde source : les anciennes versions du noyau
Une grande partie des idées reçues remonte à l'époque des cgroups v1. Les hiérarchies séparées pour chaque contrôleur généraient un suivi incohérent, l'isolation de la mémoire et des E/S était précaire, et il n'existait aucun moyen direct d'évaluer combien de temps un conteneur patientait pour obtenir des ressources. Pour couronner le tout, une régression sur le contrôle de bande passante CFS introduite en 2018 (Linux 4.18) a provoqué un bridage massif des conteneurs multithreads alors même qu'ils n'utilisaient qu'une portion de leur quota de processeur. Cette anomalie a durement frappé les utilisateurs de Kubernetes et de Mesos, est devenue tristement célèbre sous le nom de « bogue à 1,5 million de dollars » et a été corrigée dans Linux 5.4 en 2019 [7][14][15]. De nombreux ingénieurs échaudés à cette période en ont conclu que « les conteneurs manquaient d'isolation », alors que le véritable responsable n'était qu'un bogue du noyau lié à la gestion des quotas. Désormais adoptée par défaut dans les distributions majeures, la version 2 des cgroups a unifié la hiérarchie, fiabilisé la mesure de la mémoire et des E/S, et intégré le Pressure Stall Information [16].
La réalité aujourd'hui
Grâce à des ressources garanties et non sursouscrites, la contention du processeur et de la mémoire entre conteneurs est éliminée par conception. Ce qui subsiste se limite à une poignée d'effets matériels partagés, généralement de l'ordre de quelques pourcents, qui s'appliquent de manière rigoureusement identique aux matches d'un studio réunis sur un même serveur dédié. Être seul sur une machine physique ne protège pas de ces effets ; les allocations garanties, oui.
Le positionnement d'Edgegap
L'orchestration d'Edgegap repose directement sur les cgroups, et l'isolation des ressources constitue une compétence clé de la plateforme plutôt qu'un paramètre laissé à sa valeur par défaut. Nous fournissons aux studios des outils et des métriques détaillées pour visualiser la consommation des ressources par déploiement, y compris les indicateurs permettant de déceler la présence d'un véritable voisin bruyant.
La bonne métrique à surveiller : le temps d'attente processeur (CPU wait time)
Le simple taux d'utilisation du processeur ne permet pas de savoir si un serveur de jeu manque de ressources. La métrique déterminante est le temps d'attente CPU (CPU wait time) : la durée pendant laquelle les threads du serveur étaient prêts à tourner mais bloqués dans l'attente d'un cœur disponible. Linux met directement cette donnée à disposition par le biais du PSI, dont le fichier cpu.pressure consigne la proportion de temps durant laquelle une partie au moins des tâches d'un conteneur est restée en attente de processeur, avec des moyennes lissées sur 10, 60 et 300 secondes [16]. Un léger temps d'attente demeure normal et inévitable sur n'importe quel système multithread : les threads se réveillent simultanément, l'ordonnanceur met quelques microsecondes à les assigner, et les interruptions matérielles suspendent très brièvement le travail en cours. Edgegap ne déclenche pas d'alerte pour ce bruit de fond normal. Nous surveillons les pics de temps d'attente qui dépassent significativement les seuils habituels en ampleur comme en durée, car ce sont eux, et non une variation passagère, qui se traduisent par des retards de tick et une altération de l'expérience joueur.
Le coût réel de cette crainte
L'objection du voisin bruyant pousse bien souvent les studios vers des flottes dédiées surdimensionnées qui restent pour l'essentiel inactives en dehors des heures de pointe, ou les incite à abandonner les serveurs faisant autorité au profit d'architectures peer-to-peer ou de relais certes plus économiques sur le papier, mais bien plus vulnérables à la triche et défavorables à l'équité en jeu. Ces deux alternatives s'avèrent onéreuses. Un studio qui remplace la question « qui d'autre se trouve sur cette machine ? » par « mes ressources sont-elles garanties et puis-je visualiser mon temps d'attente processeur ? » peut réaliser d'importantes économies d'infrastructure tout en continuant d'offrir à chaque joueur une expérience fluide garantie par un serveur faisant autorité.
—
Références
Lo, Cheng, Govindaraju, Ranganathan, Kozyrakis. Heracles: Improving Resource Efficiency at Scale. ISCA 2015.
Dan Luu. Why Intel added cache partitioning (synthèse des benchmarks de Heracles, Kanev et al. et d'Intel CAT).
Leitner et Cito. Patterns in the Chaos: A Study of Performance Variation and Predictability in Public IaaS Clouds. ACM Transactions on Internet Technology, 2016.
Duet Benchmarking: Improving Measurement Accuracy in the Cloud. ICPE 2020.
Studying Cloud Performance Variability for the Case of Stream Processing Applications. arXiv, 2025.
Dave Chiluk. Unthrottled: Fixing CPU Limits in the Cloud. Indeed Engineering, 2019.
Intel. Livre blanc sur la technologie Cache Allocation Technology (CAT), avril 2015.
Ferdman et al. Clearing the Clouds: A Study of Emerging Scale-out Workloads on Modern Hardware. ASPLOS 2012.
Tang, Mars, Vachharajani, Hundt, Soffa. The Impact of Memory Subsystem Resource Sharing on Datacenter Applications. ISCA 2011.
Kanev et al. Profiling a Warehouse-Scale Computer. ISCA 2015.
Liste de diffusion du noyau Linux. Real-time scheduling policies and hyper-threading, avril 2014.
Dave Chiluk. Unthrottled: How a Valid Fix Becomes a Regression. Indeed Engineering, 2019.
Phoronix. The Linux Kernel Seeing Backport Progress Finally For The "$1.5 Million Dollar Bug".
Documentation du noyau Linux. PSI: Pressure Stall Information.
Google Cloud. Guide de comparaison et de ressources des familles de machines : types de machines à cœurs partagés.
AWS. Exemples en mode standard pour les instances modulables.
Paul Alcorn, Tom's Hardware. Test de l'AMD Ryzen 9 7900X : Zen 4 a un problème de positionnement tarifaire. Octobre 2022 (page consacrée à la consommation, à la température et à l'overclocking).
Écrit par
Mathieu Duperré (fondateur et PDG)
Sources et/ou collaboration de contenu avec
Gabriel Parent (directeur) pour les illustrations et la mise en page.






