FR 3157585 A1 20250627 FR 2315090 A 20231222 L’invention est relative à un processeur comprenant de multiples cœurs (10) comprenant chacun un cache local (L1) ; de multiples banques mémoire (12) formant une mémoire partagée par les multiples cœurs ; un gestionnaire de protocole de cohérence de cache basé sur des répertoires (DIR), comprenant pour chaque cœur un circuit (16) de consolidation de multiples commandes d'invalidation de ligne de cache (INVAL) reçues des différentes banques mémoire. Le circuit de consolidation comprend un compteur de commandes d'invalidation reçues (PARCNT) ; un circuit de sélection (32) configuré pour, selon que le compte (N) de commandes d'invalidation reçues est égal à 1 ou est supérieur, transmettre au cache la seule commande d'invalidation reçue ou une commande d'invalidation consolidant les lignes de cache identifiées dans les commandes d'invalidation reçues, dans un format exploitable par le cache pour invalider simultanément les lignes de cache identifiées. Figure pour l’abrégé : Fig. 3 Gestion de multiples invalidations d'une mémoire cache L’invention est relative à la gestion de cohérence de cache dans un système multicœurs de processeur dont les cœurs peuvent accéder simultanément à différentes banques formant une mémoire partagée. Arrière-plan Il existe plusieurs protocoles de cohérence de cache conçus pour assurer, dans un système multicœurs, que le cache local de chaque cœur de processeur reflète les données mises à jour en mémoire partagée par les autres cœurs. Une opération communément utilisée dans les protocoles de cohérence est l'invalidation de lignes de cache. A un moment donné, il peut y avoir duplication d'un même bloc mémoire, ou ligne de cache, dans différents caches locaux. Si un cœur écrit en mémoire à une adresse correspondant à cette ligne de cache, les copies dans les autres cœurs deviennent obsolètes. Pour tenir compte de cela, lorsqu'un cœur écrit en mémoire, le protocole de cohérence de cache envoie une commande d'invalidation aux autres cœurs possédant la ligne de cache correspondante. Cette commande d'invalidation indique aux contrôleurs des caches locaux d'invalider leurs copies locales. Un cœur accédant à une ligne de cache ainsi invalidée dans son cache local devra de nouveau récupérer la ligne à jour à partir de la mémoire. Pour gérer les envois de commandes d'invalidation, le protocole de cohérence peut être basé sur un répertoire dans lequel le contrôleur mémoire enregistre les lignes de cache utilisées et les cœurs qui les ont dans leurs caches. Lorsque la mémoire partagée est structurée en plusieurs banques simultanément accessibles par tous les cœurs, chaque banque est susceptible d'envoyer une commande d'invalidation simultanée aux cœurs concernés. Ainsi, un cœur donné peut recevoir plusieurs commandes d'invalidation simultanées. Le traitement de ces multiples commandes par le contrôleur de cache peut entraîner une latence de plusieurs cycles pendant laquelle les banques mémoire ayant envoyé ces commandes d’invalidation ne peuvent normalement pas acquitter les accès en écriture ayant déclenché ces envois. Pour éviter une telle latence, on a proposé des techniques permettant au contrôleur de cache de traiter simultanément plusieurs commandes d'invalidation. Un exemple de telle technique est décrit dans le brevet US6701417, qui utilise un protocole basé sur des répertoires et des caches en mode écriture directe ("write-through"). Plus spécifiquement, ce brevet propose de partitionner le cache local en plusieurs banques dont chacune est conçue pour traiter une commande d'invalidation respective. Ainsi, le contrôleur de cache peut traiter simultanément au plus autant de commandes d'invalidation que de banques. Résumé On prévoit de façon générale un procédé de gestion de la cohérence de cache dans un système de processeur multicœur, où chaque cœur dispose d’un cache respectif et a accès à plusieurs banques d’une mémoire partagée entre les cœurs, le procédé comprenant les étapes consistant à gérer un répertoire dans chaque banque mémoire pour la mise en œuvre d'une cohérence de cache basée sur des répertoires ; accéder en écriture à une adresse mémoire courante par un cœur ; rechercher dans le répertoire gérant l’adresse courante les cœurs qui possèdent une ligne de cache correspondant à l’adresse courante ; envoyer aux cœurs identifiés par le répertoire des commandes respectives d’invalidation de la ligne de cache, les commandes incluant l'adresse mémoire de la ligne de cache ; et pour chaque cœur, servir de multiples commandes d’invalidation reçues de différentes banques mémoire. Le service des multiples commandes d’invalidation comprend les étapes consistant à compter le nombre de commandes d'invalidation reçues depuis un dernier cycle d'horloge ; lorsque le compte de commandes d'invalidation reçues vaut un, transmettre au cache la commande d'invalidation reçue ; et lorsque le compte de commandes d'invalidation reçues est supérieur à un, transmettre au cache une seule commande consolidant les lignes de cache identifiées dans les commandes d'invalidation reçues, dans un format exploitable par le cache pour invalider simultanément les lignes de cache identifiées. Chaque cœur peut disposer d’un cache respectif associatif par ensembles à multiples voies, le procédé comprenant alors les étapes consistant à enregistrer dans les répertoires les voies dans lesquelles les caches stockent les lignes de cache ; transmettre les voies dans les commandes d'invalidation envoyées aux cœurs ; et inclure dans la commande d'invalidation consolidée, pour chaque commande d’invalidation reçue, un couple de coordonnées incluant un index d'ensemble, extrait de l’adresse mémoire, et la voie. Le procédé peut comprendre l'étape de répondre par le cache à la commande d'invalidation consolidée en invalidant simultanément chaque ligne de cache se trouvant à l'intersection de l'ensemble et de la voie déterminés par un couple respectif de coordonnées. Le service des multiples commandes d’invalidation peut comprendre les étapes consistant à former un masque de bits comprenant un bit à 1 aux positions identifiées par des index d'ensembles extraits des adresses mémoire des commandes d'invalidation reçues ; lorsque le compte de commandes d'invalidation reçues est supérieur à un seuil, inclure le masque de bits dans la commande d'invalidation consolidée ; et répondre par le cache à la commande consolidée en invalidant simultanément les ensembles de cache marqués dans le masque de bits. Le répertoire peut enregistrer les cœurs et les voies pour chaque ligne de cache sous la forme d'un masque de bits combiné marquant les cœurs ayant la ligne dans leur cache et les voies dans lesquelles la ligne est présente dans les caches de ces cœurs, l'information de voie transmise dans les commandes d'invalidation incluant alors les bits du masque de bits identifiant les voies. Les commandes d'invalidation consolidées peuvent être configurées pour véhiculer un champ comprenant un nombre fixe de bits dont une première partie identifie un type de commande parmi une commande d'invalidation originale, une commande consolidée avec coordonnées, et une commande consolidée avec masque de bits, et une deuxième partie définit pour les types respectifs : l'adresse de la ligne de cache, les couples de coordonnées, et le masque de bits. On prévoit également un processeur comprenant de multiples cœurs comprenant chacun un cache local ; de multiples banques mémoire formant une mémoire partagée par les multiples cœurs ; un gestionnaire de protocole de cohérence de cache basé sur des répertoires, comprenant pour chaque cœur un circuit de consolidation de multiples commandes d'invalidation de ligne de cache reçues des différentes banques mémoire. Le circuit de consolidation comprend un compteur de commandes d'invalidation reçues ; un circuit de sélection configuré pour, selon que le compte de commandes d'invalidation reçues est égal à 1 ou est supérieur, transmettre au cache la seule commande d'invalidation reçue ou une commande d'invalidation consolidant les lignes de cache identifiées dans les commandes d'invalidation reçues, dans un format exploitable par le cache pour invalider simultanément les lignes de cache identifiées. Chaque cœur peut disposer d’un cache respectif associatif par ensembles à multiples voies, le processeur comprenant en outre un répertoire associé à chaque banque, configuré pour enregistrer avec chaque ligne de cache, les voies dans laquelle la ligne de cache est présente dans les différents cœurs et pour inclure les voies dans les commandes d'invalidation envoyées aux cœurs ; et le circuit de consolidation configuré pour inclure dans la commande d'invalidation consolidée, pour chaque commande d’invalidation de ligne de cache reçue, un couple de coordonnées incluant un index d'ensemble, extrait d'une adresse mémoire de la ligne de cache, et la voie. Le circuit de consolidation peut être configuré pour inclure dans la commande d'invalidation consolidée, lorsque le compte de commandes d'invalidations reçues est supérieur à un seuil, un masque de bits marquant des ensembles de cache à invalider, où chaque ensemble inclut la ligne de cache identifiée par une commande d'invalidation reçue respective. Selon une alternative, dans un système de processeur multicœur, où chaque cœur dispose d’un cache respectif associatif par ensembles à multiples voies, et a accès à plusieurs banques d’une mémoire partagée entre les cœurs, un procédé de gestion de cohérence de cache comprend les étapes consistant à gérer un répertoire dans chaque banque mémoire pour la mise en œuvre d'une cohérence de cache basée sur des répertoires ; accéder en écriture à une adresse mémoire courante par un cœur ; rechercher dans le répertoire gérant l’adresse courante les cœurs qui possèdent une ligne de cache correspondant à l’adresse courante ; envoyer aux cœurs identifiés par le répertoire des commandes respectives d’invalidation de la ligne de cache, les commandes incluant l'adresse mémoire de la ligne de cache ; pour chaque cœur, servir de multiples commandes d’invalidation reçues de différentes banques mémoire ; enregistrer dans les répertoires les voies dans lesquelles les caches stockent les lignes de cache ; transmettre les voies dans les commandes d'invalidation envoyées aux cœurs ; servir les multiples commandes d'invalidation reçues par un cœur en transmettant au cache du cœur une seule commande consolidée incluant, pour chaque commande d’invalidation reçue, un couple de coordonnées incluant un index d'ensemble, extrait de l’adresse mémoire de la ligne de cache, et la voie ; et répondre par un cache à une commande d'invalidation consolidée en invalidant simultanément chaque ligne de cache se trouvant à l'intersection de l'ensemble et de la voie déterminés par un couple respectif de coordonnées. Le service des multiples commandes d’invalidation peut comprendre les étapes consistant à compter le nombre de commandes d'invalidation reçues depuis un dernier cycle d'horloge ; former un masque de bits comprenant un bit à 1 aux positions identifiées par les index d'ensemble ; lorsque le compte de commandes d'invalidation reçues est supérieur à un seuil, inclure le masque de bits dans la commande d'invalidation consolidée à la place des couples de coordonnées ; et répondre par le cache à la commande consolidée en invalidant simultanément les ensembles de cache marqués dans le masque de bits. Description sommaire des dessins Des modes de réalisation seront exposés dans la description suivante, faite à titre non limitatif en relation avec les figures jointes parmi lesquelles : La FIG. 1 représente partiellement un mode de réalisation d'architecture de processeur multicœurs configurée pour mettre en œuvre un protocole de cohérence de cache basé sur des répertoires ; La FIG. 2 représente trois types de commandes d'invalidation consolidées, selon un mode de réalisation, permettant à un contrôleur de cache d'invalider simultanément plusieurs lignes de cache ; La FIG. 2 représente un exemple d'enregistrement dans un répertoire servant à un protocole de cohérence de cache ; et La FIG. 3 est un schéma bloc d'un circuit logique configuré pour générer les commandes consolidées de la FIG. 2 . Description détaillée Le protocole de cohérence de cache décrit dans le brevet US6701417 nécessite une structure de cache particulière et le nombre de commandes d'invalidation pouvant être traitées simultanément est limité au nombre de banques du cache, en pratique quatre. On expose ci-après un protocole de cohérence de cache avec lequel le contrôleur de cache peut simultanément traiter toutes les commandes d'invalidation susceptibles de lui arriver, au prix d'un compromis sur les performances à partir d'un nombre seuil de commandes traitées simultanément. Dans le pire cas, le compromis est, pour un cache associatif par ensembles à multiples voies, l'invalidation grossière de tout un ensemble de lignes de cache, au lieu d'invalider une seule ligne de cache. La notion de simultanéité de traitement de plusieurs commandes d'invalidation est relative à un cycle d'horloge des cœurs. En pratique, le traitement est réalisé de manière asynchrone par des circuits logiques combinatoires qui produisent les opérations souhaitées en un temps plus ou moins long selon les cas, mais qui reste inférieur à une période d'horloge. Par ailleurs, le protocole est adaptatif en opérant une sélection entre plusieurs modes en fonction du nombre de commandes d'invalidation à traiter. Dans le premier mode, sélectionné pour une seule commande à traiter, c'est une commande d'invalidation classique qui peut être utilisée, précise, permettant d'identifier la ligne de cache concernée et de l'invalider seulement si elle est toujours présente dans le cache, à savoir répertoriée dans la mémoire d'étiquettes du cache. Dans un mode grossier, pouvant être sélectionné pour n'importe quel nombre de commandes à traiter, une commande consolidée est produite qui invalide simultanément les ensembles contenant les lignes de cache concernées. Un mode intermédiaire moins brutal est de préférence utilisé jusqu'à un certain seuil de nombre de commandes à traiter, produisant une commande d'invalidation consolidée qui identifie chaque ligne de cache par un couple de coordonnées (ensemble contenant la ligne, voie contenant la ligne). Le contrôleur de cache invalide alors simultanément toutes les lignes identifiées par ces couples de coordonnées. La présence de ces lignes dans le cache n'est alors pas vérifiée, ce qui constitue un faible prix à payer pour la possibilité de traiter simultanément ces plusieurs commandes d'invalidation. En pratique, l'invalidation d'une ligne absente du cache provoque l'invalidation d'une case mémoire destinée à contenir une ligne de cache. Cette case peut être vide, auquel cas elle est déjà invalide et l'opération n'a aucun effet. La case peut aussi contenir une nouvelle ligne de cache, auquel cas cette nouvelle ligne est invalidée "pour rien", mais cela entraîne simplement une latence ultérieure pour recharger la ligne lorsque le cœur tente d'y accéder. Le nombre d'invalidations pouvant être traitées dans ce mode dépend de la taille d'un paramètre de la commande consolidée, laquelle taille conditionne le nombre de couples pouvant être transmis. L'efficacité de ce protocole, en termes de granularité dans la sélection des lignes de cache à invalider, est liée à la fréquence des cas où surviennent des salves de multiples commandes d'invalidation simultanées, et au nombre de commandes à traiter dans chaque salve. Il s'avère en pratique que les cas où une seule commande d'invalidation est à traiter sont plus fréquents que les salves de plusieurs commandes. De surcroît, les salves ayant un faible nombre de commandes (par exemple entre 2 et 4) sont plus fréquentes que celles ayant un plus grand nombre de commandes. La FIG. 1 représente partiellement une architecture de processeur multicœurs utilisable pour mettre en œuvre un tel protocole de cohérence de cache sur la base de répertoires. Deux cœurs de processeur 10 ont un accès simultané en lecture et écriture RW à plusieurs banques 12 (dont seulement trois sont représentées) d'une mémoire partagée à travers un commutateur matriciel ("crossbar") géré par des arbitres ARBITER. Chaque cœur comprend un cache local de niveau 1 L1. La cohérence de cache est gérée par un répertoire DIR qui peut être centralisé ou distribué, comme cela est représenté, dans chaque banque mémoire 12. Les répertoires sont configurés pour enregistrer les lignes de cache en cours d'utilisation dans chaque cœur. Chaque répertoire DIR associé à une banque ne répertorie que les lignes de cache correspondant aux adresses physiques attribuées à la banque. Les répertoires communiquent avec les cœurs par ce qu'on appelle des "côtés maître" ("master-side") respectifs 16, qui peuvent faire partie des caches L1 ou du commutateur matriciel. Les côtés maître sont reliés aux répertoires DIR par des liaisons point-à-point de signalisation, représentées en pointillés. De manière classique, un répertoire reçoit un nouvel enregistrement à chaque fois qu'un cœur rate une lecture dans son cache et récupère la ligne de cache dans la banque correspondante. Le nouvel enregistrement identifie la ligne de cache et le cœur. Un enregistrement est gardé dans le répertoire jusqu'au moment où cette ligne de cache est invalidée. Ainsi, les informations du répertoire peuvent être obsolètes dans l'intervalle. Les enregistrements du répertoire sont généralement stockés dans une mémoire associative indexée par les adresses physiques des lignes de cache. Lorsqu'un cœur donné accède en écriture à une ligne mémoire soumise à la cohérence, cet événement est signalé aux répertoires. Le répertoire qui est responsable de la gestion de la cohérence de cette adresse émet alors une invalidation INVAL aux autres cœurs enregistrés comme possesseurs de cette ligne de cache. Afin de gérer de multiples invalidations de façon simultanée selon le mode adaptatif précédemment évoqué, chaque côté maître comprend un circuit de consolidation CONSLD recevant les commandes d'invalidation individuelles provenant de tous les répertoires. A partir des commandes d'invalidation individuelles, ce circuit produit une commande d'invalidation consolidée C-INVAL à destination de la mémoire cache L1 correspondante. Comme on l'a précédemment indiqué, la commande consolidée peut être de deux, ou de préférence trois types : PRECISE (précis), ARRAY_OF_SLOTS (tableau de cases), et MASK_OF_SETS (masque d'ensembles). La FIG. 2 illustre un exemple de formats des trois types de commandes consolidées, en supposant à titre d'exemple que les adresses mémoire physiques sont de 40 bits et le cache est un cache associatif à 64 ensembles de 8 voies dont les lignes comportent 64 octets (soit une cache de 32 ko). Chaque commande consolidée comprend deux bits d'identifiant de type IType[65:64] suivis d'un champ de 64 bits IData[63:0] dont la fonction dépend du type. Un identifiant binaire 00 indique qu'il n'y a aucune invalidation à traiter. L'identifiant binaire 01 correspond au type PRECISE. Cette commande consolidée est produite lorsqu'une seule commande d'invalidation est en attente depuis le dernier cycle d'horloge. Elle fournit dans son champ IData ce que fournit normalement l'unique commande d'invalidation entrante, à savoir l'adresse physique @PHY[39:0] utilisée pour l'accès mémoire. En principe, un certain nombre de bits de poids faible de l'adresse physique, appelés décalage ou "offset" et définissant la position de la donnée dans une ligne de cache, ne sont pas utiles, de sorte qu'on peut enlever ici 6 bits de poids faible et ne conserver que @PHY[39:6]. Dans l'adresse ainsi tronquée, les 6 bits de poids faible [11:6] constituent ce qu'on appelle l'index, et servent à identifier l'ensemble contenant la ligne de cache. Les bits de poids fort restants [39:12] sont ce qu'on appelle l'étiquette ou "tag", à l'aide de laquelle on consulte la mémoire d'étiquettes du cache, qui identifie entre autres la voie contenant la ligne de cache. Si la mémoire d'étiquettes ne fournit pas de valeur correspondante, c'est que la ligne de cache a été évincée après que le répertoire a émis la commande d'invalidation. Une commande consolidée de type PRECISE est traitée par le contrôleur de cache comme une commande d'invalidation classique, en invalidant la ligne de cache identifiée sans équivoque. L'identifiant binaire 10 correspond au type ARRAY_OF_SLOTS. Cette commande consolidée est produite lorsque deux commandes d'invalidation ou plus sont reçues simultanément au même cycle d'horloge. Le nombre de commandes pouvant être traitées simultanément est limité par la taille du champ IData, ici de 64 bits. Ce champ IData véhicule dans cet exemple quatre données de 14 bits servant à identifier quatre lignes de cache à invalider. Les 56 bits correspondant à ces données peuvent être calés à droite dans le champ IData. Chaque donnée de 14 bits correspond à un couple de coordonnées, à savoir dans cet exemple un index de 6 bits IDX[5:0] et une voie de 8 bits W[7:0]. La ligne de cache à invalider est donc celle se trouvant à l'intersection de l'ensemble identifié par l'index IDX et la voie identifiée par le champ W. Pour des raisons évoquées ultérieurement, le champ W est dans cet exemple un masque de 8 bits, identifiant une à huit voies par la position d'un bit à 1. Selon une alternative, le numéro de voie peut être codé sur 3 bits, auquel cas le champ IData pourrait contenir 7 couples de coordonnées. Les index IDX correspondent dans cet exemple aux bits [11:6] des adresses physiques respectives fournies par les commandes d'invalidation individuelles entrantes. Si moins de quatre commandes d'invalidation sont à traiter, les masques W associés aux commandes manquantes peuvent être mis à 0, indiquant qu'elles seront ignorées. Quant aux valeurs des champs W identifiant les voies, les répertoires DIR sont configurés pour enregistrer en outre les voies dans lesquelles les lignes sont stockées dans les caches, et diffuser également ces voies dans les commandes d'invalidation. Ces voies diffusées par les commandes d'invalidation sont alors reprises dans les champs W de la commande d'invalidation consolidée de type ARRAY_OF_SLOTS. Au niveau des répertoires DIR, idéalement chaque ligne de cache est enregistrée avec les cœurs qui la possèdent et, pour chaque cœur, la voie dans laquelle elle se trouve. Cela peut représenter un nombre de bits conséquent à manipuler pour chaque ligne dans un système ayant un grand nombre de cœurs. Par exemple, pour 16 cœurs avec des caches à 8 voies, on aurait besoin 16 champs de 3 bits, soit 48 bits, pour coder une voie parmi 8 pour chacun des 16 cœurs. La FIG. 2 illustre un mode de réalisation d'enregistrement de répertoire réduisant la complexité et le coût matériel, avec en contrepartie une réduction de la précision de l'identification des voies. Dans chaque répertoire on tient à jour pour chaque ligne de cache enregistrée @PHY[39:6] un masque de cœurs CORE[15:0] possédant un bit pour chaque cœur et un masque de voies W[7:0] possédant un bit pour chaque voie. Cela réduit le nombre de bits à 24 pour un système de 16 cœurs avec des caches à 8 voies. C'est alors le masque de voies W de cet enregistrement qui est transmis dans la commande d'invalidation correspondante. Avec de tels masques de voies, si plusieurs cœurs utilisent la même ligne de cache mais que cette ligne est stockée dans une voie différente dans chaque cœur, le masque de voies pour cette ligne de cache aurait plusieurs bits à 1. Le contrôleur de cache est configuré pour traiter une telle commande consolidée en lisant chaque couple de coordonnées (IDX, W) et, pour chaque couple, en invalidant les lignes de cache se trouvant à l'intersection de l'ensemble identifié par IDX et les voies marquées dans W. Si le masque de voies W contient plus d'un bit à 1, des lignes de cache supplémentaires, si elles existent dans le cache, seront inutilement invalidées, mais c'est le prix à payer pour simplifier la structure des répertoires. En pratique, les situations ou plus d'une voie est marquée dans un masque de voies sont peu fréquentes. Une invalidation d'une ligne de cache par le contrôleur de cache peut être opérée classiquement en basculant un drapeau de validité dans une matrice de bascules représentant les intersections des ensembles et des voies du cache. Chacune de ces bascules est accessible individuellement par les circuits logiques du contrôleur, de sorte que ces circuits peuvent être configurés pour basculer simultanément une nombre quelconque de drapeaux. Une fois qu'un drapeau est ainsi passé à l'état "invalide", un accès en lecture ultérieur du cœur à cet emplacement échoue après vérification du drapeau ("cache miss") et est dérouté sur la mémoire partagée pour recharger une ligne de cache à jour. L'identifiant binaire 11 correspond au type MASK_OF_SETS. Cette commande consolidée est produite lorsque le nombre d'invalidations à traiter est supérieur au nombre de commandes que peut traiter une commande consolidée du type ARRAY_OF_SLOTS, à savoir 4 dans le présent exemple. Le champ IData est alors un masque d'ensembles S-MASK[63:0] où chaque bit à 1 indique que l'ensemble correspondant à la position du bit dans le masque doit être invalidé. Ainsi, la taille du champ IData est au moins égale au nombre d'ensembles du cache, 64 dans le présent exemple. Pour générer le masque S-MASK on utilise les champs d'index des adresses physiques des commandes d'invalidation en attente, à savoir les valeurs @PHY[11:6]. Les valeurs @PHY[11:6] déterminent les positions des bits à mettre à 1 dans le masque S-MASK. Ce masque S-MASK peut ensuite être exploité par le contrôleur de cache pour invalider simultanément tous les ensembles marqués dans ce masque. La FIG. 3 est un schéma bloc d'un circuit logique configuré pour générer les commandes consolidées, notamment le contenu du champ IData de chaque type de commande consolidée. Un tel circuit peut être intégré dans chaque côté maître, au niveau du bloc CONSLD de la FIG. 1 . Le circuit opère sur l'ensemble des connexions point-à-point entre le côté maître et les répertoires des banques mémoire. De chacune des banques mémoire, 16 dans cet exemple, le circuit reçoit un faisceau de conducteurs INVAL_i servant à transmettre une commande d'invalidation. Un conducteur véhicule un drapeau EN_i indiquant la présence d'une commande d'invalidation, les conducteurs suivants véhiculent l'adresse de la ligne de cache à invalider @PHY[39:6], et les derniers conducteurs véhiculent le masque de voies W[7:0]. Les drapeaux EN_i sont fournis à des entrées individuelles d'un compteur parallèle PARCNT qui fournit à tout instant le nombre de commandes actives N. La concaténation de ces drapeaux forme un masque de commandes actives de 16 bits EN[15:0]. Le compte N commande deux multiplexeurs à quatre voies 30, 32 qui produisent respectivement les paramètre IType et IData de la commande consolidée d'invalidation C-INVAL. Lorsque N = 0, le multiplexeur 30 sélectionne la valeur binaire 00 pour IType, et le multiplexeur 32 sélectionne la valeur 0 pour IData. Lorsque N = 1, le multiplexeur 30 sélectionne la valeur binaire 01 pour IType, et le multiplexeur 32 sélectionne la sortie d'un circuit logique combinatoire CL0 pour IData. Le circuit CL0 reçoit toutes les adresses de ligne de cache @PHY[39:6] et transmet celle pour laquelle le drapeau EN_i est actif. Lorsque 1 Le circuit CL1 reçoit toutes les valeurs d'index IDX contenues dans les bits de poids faible des adresses de ligne de cache, à savoir les bits @PHY[11:6] dans cet exemple, et reçoit également les masques de voie W[7:0]. Le circuit forme les couples de valeurs (index IDX, masque de voies W) pour les seules valeurs qui ont un drapeau EN_i actif, et les positionne dans 56 bits servant à former le champ IData. Lorsque N > 4, le multiplexeur 30 sélectionne la valeur binaire 11 pour IType, et le multiplexeur 32 sélectionne la sortie d'un circuit logique combinatoire CL2 pour IData. Le circuit CL2 reçoit toutes les valeurs d'index IDX contenues dans les adresses de ligne de cache, à savoir les bits @PHY[11:6] dans cet exemple. Le circuit forme un masque de 64 bits en mettant à 1 tous les bits aux positions déterminées par les index dont le drapeau EN_i actif. Selon une alternative pour la commande d'invalidation consolidée de type PRECISE, du moment que les répertoires stockent et transmettent les informations de voie W, le circuit CL0 peut être conçu simplement pour extraire le couple IDX, W de l'unique commande d'invalidation reçue, formant en fait un cas particulier d'une commande de type ARRAY_OF_SLOTS. Cela économise un cycle d'horloge requis pour consulter la mémoire d'étiquettes du cache, au prix du risque d'invalider "pour rien" une ligne de cache évincée ou des lignes de cache supplémentaires si le masque W marque plusieurs voies. Une telle alternative est de fait mise en œuvre en omettant le circuit CL0 et en utilisant le circuit CL1 pour les comptes N entre 1 et 4. Procédé de gestion de la cohérence de cache dans un système de processeur multicœur, où chaque cœur (10) dispose d’un cache respectif (L1) et a accès à plusieurs banques (12) d’une mémoire partagée entre les cœurs, le procédé comprenant les étapes suivantes : gérer un répertoire (DIR) dans chaque banque mémoire pour la mise en œuvre d'une cohérence de cache basée sur des répertoires ; accéder en écriture à une adresse mémoire courante par un cœur ; rechercher dans le répertoire gérant l’adresse courante les cœurs qui possèdent une ligne de cache correspondant à l’adresse courante ; envoyer aux cœurs identifiés par le répertoire des commandes respectives d’invalidation (INVAL) de la ligne de cache, les commandes incluant l'adresse mémoire de la ligne de cache ; et pour chaque cœur, servir de multiples commandes d’invalidation reçues de différentes banques mémoire ; caractérisé en ce que l’étape de service des multiples commandes d’invalidation comprend les étapes suivantes : compter le nombre (N) de commandes d'invalidation reçues depuis un dernier cycle d'horloge ; lorsque le compte de commandes d'invalidation reçues vaut un, transmettre au cache la commande d'invalidation (PRECISE) reçue ; et lorsque le compte de commandes d'invalidation reçues est supérieur à un, transmettre au cache une seule commande (C-INVAL) consolidant les lignes de cache identifiées dans les commandes d'invalidation reçues, dans un format exploitable par le cache pour invalider simultanément les lignes de cache identifiées. Procédé selon la revendication 1, dans lequel chaque cœur dispose d’un cache respectif associatif par ensembles à multiples voies, le procédé comprenant en outre les étapes suivantes : enregistrer dans les répertoires (DIR) les voies (W) dans lesquelles les caches stockent les lignes de cache ; transmettre les voies dans les commandes d'invalidation envoyées aux cœurs ; et inclure dans la commande d'invalidation consolidée, pour chaque commande d’invalidation reçue, un couple de coordonnées incluant un index d'ensemble (IDX), extrait de l’adresse mémoire, et la voie (W). Procédé selon la revendication 2, comprenant l'étape de répondre par le cache à la commande d'invalidation consolidée en invalidant simultanément chaque ligne de cache se trouvant à l'intersection de l'ensemble et de la voie déterminés par un couple respectif de coordonnées. Procédé selon la revendication 2, dans lequel l’étape de service des multiples commandes d’invalidation comprend les étapes suivantes : former un masque de bits (MASK_OF_SETS) comprenant un bit à 1 aux positions identifiées par des index d'ensembles (IDX) extraits des adresses mémoire des commandes d'invalidation reçues ; lorsque le compte de commandes d'invalidation reçues est supérieur à un seuil, inclure le masque de bits dans la commande d'invalidation consolidée ; et répondre par le cache à la commande consolidée en invalidant simultanément les ensembles de cache marqués dans le masque de bits. Procédé selon la revendication 2, dans lequel le répertoire enregistre les cœurs et les voies pour chaque ligne de cache sous la forme d'un masque de bits combiné marquant les cœurs ayant la ligne dans leur cache et les voies dans lesquelles la ligne est présente dans les caches de ces cœurs, et l'information de voie transmise dans les commandes d'invalidation inclut les bits du masque de bits identifiant les voies. Procédé selon la revendication 2, dans lequel les commandes d'invalidation consolidées sont configurées pour véhiculer un champ comprenant un nombre fixe de bits dont : une première partie (IType) identifie un type de commande parmi une commande d'invalidation originale, une commande consolidée avec coordonnées, et une commande consolidée avec masque de bits, et une deuxième partie (IData) définit pour les types respectifs : l'adresse de la ligne de cache, les couples de coordonnées, et le masque de bits. Processeur comprenant : de multiples cœurs (10) comprenant chacun un cache local (L1) ; de multiples banques mémoire (12) formant une mémoire partagée par les multiples cœurs ; un gestionnaire de protocole de cohérence de cache basé sur des répertoires (DIR), comprenant pour chaque cœur un circuit (16) de consolidation de multiples commandes d'invalidation de ligne de cache (INVAL) reçues des différentes banques mémoire, le circuit de consolidation comprenant : un compteur de commandes d'invalidation reçues (PARCNT) ; un circuit de sélection (32) configuré pour, selon que le compte (N) de commandes d'invalidation reçues est égal à 1 ou est supérieur, transmettre au cache la seule commande d'invalidation reçue ou une commande d'invalidation consolidant les lignes de cache identifiées dans les commandes d'invalidation reçues, dans un format exploitable par le cache pour invalider simultanément les lignes de cache identifiées. Processeur selon la revendication 7, dans lequel chaque cœur dispose d’un cache respectif associatif par ensembles à multiples voies, le processeur comprenant en outre : un répertoire (DIR) associé à chaque banque, configuré pour enregistrer avec chaque ligne de cache, les voies dans laquelle la ligne de cache est présente dans les différents cœurs et pour inclure les voies (W) dans les commandes d'invalidation envoyées aux cœurs ; et le circuit de consolidation configuré pour inclure dans la commande d'invalidation consolidée, pour chaque commande d’invalidation de ligne de cache reçue, un couple de coordonnées incluant un index d'ensemble (IDX), extrait d'une adresse mémoire de la ligne de cache, et la voie (W). Processeur selon la revendication 8, dans lequel le circuit de consolidation est configuré pour inclure dans la commande d'invalidation consolidée, lorsque le compte de commandes d'invalidations reçues est supérieur à un seuil, un masque de bits marquant des ensembles de cache à invalider, où chaque ensemble inclut la ligne de cache identifiée par une commande d'invalidation reçue respective. Procédé de gestion de la cohérence de cache dans un système de processeur multicœur, où chaque cœur (10) dispose d’un cache respectif (L1) associatif par ensembles à multiples voies, et a accès à plusieurs banques (12) d’une mémoire partagée entre les cœurs, le procédé comprenant les étapes suivantes : gérer un répertoire (DIR) dans chaque banque mémoire pour la mise en œuvre d'une cohérence de cache basée sur des répertoires ; accéder en écriture à une adresse mémoire courante par un cœur ; rechercher dans le répertoire gérant l’adresse courante les cœurs qui possèdent une ligne de cache correspondant à l’adresse courante ; envoyer aux cœurs identifiés par le répertoire des commandes respectives d’invalidation (INVAL) de la ligne de cache, les commandes incluant l'adresse mémoire de la ligne de cache ; et pour chaque cœur, servir de multiples commandes d’invalidation reçues de différentes banques mémoire ; caractérisé en ce qu'il comprend les étapes suivantes : enregistrer dans les répertoires (DIR) les voies (W) dans lesquelles les caches stockent les lignes de cache ; transmettre les voies dans les commandes d'invalidation envoyées aux cœurs ; et servir les multiples commandes d'invalidation reçues par un cœur en transmettant au cache du cœur une seule commande consolidée (C-INVAL) incluant, pour chaque commande d’invalidation reçue, un couple de coordonnées incluant un index d'ensemble (IDX), extrait de l’adresse mémoire de la ligne de cache, et la voie (W) ; et répondre par un cache à une commande d'invalidation consolidée en invalidant simultanément chaque ligne de cache se trouvant à l'intersection de l'ensemble et de la voie déterminés par un couple respectif de coordonnées. Procédé selon la revendication 10, dans lequel l’étape de service des multiples commandes d’invalidation comprend les étapes suivantes : compter le nombre (N) de commandes d'invalidation reçues depuis un dernier cycle d'horloge ; former un masque de bits (MASK_OF_SETS) comprenant un bit à 1 aux positions identifiées par les index d'ensemble (IDX) ; lorsque le compte de commandes d'invalidation reçues est supérieur à un seuil, inclure le masque de bits dans la commande d'invalidation consolidée à la place des couples de coordonnées ; et répondre par le cache à la commande consolidée en invalidant simultanément les ensembles de cache marqués dans le masque de bits.