de microprocesseurs

La présente invention concerne un procédé de gestion de tâches dans un microprocesseur ou dans un ensemble de microprocesseurs, et plus particulièrement un procédé gérant l'interruption de tâches dans un microprocesseur.

Un microprocesseur est un dispositif électronique qui peut réaliser diverses tâches, chaque tâche étant une suite de plusieurs instructions. Des moyens sont associés au microprocesseur pour former avec lui un microcontrôleur. Ces moyens supplémentaires permettent la gestion des tâches confiées au microprocesseur.

Un microprocesseur n'effectue habituellement qu'une seule tâche à la fois. Il convient alors de gérer les situations dans lesquelles plusieurs tâches sont à exécuter simultanément ou bien encore le cas où une ou plusieurs tâches sont à exécuter alors qu'une tâche précédente est en cours d'exécution.

Il est par exemple prévu pour certains microprocesseurs de pouvoir interrompre une tâche afin d'en exécuter une autre et de terminer la tâche interrompue une fois la nouvelle tâche achevée.

Une telle gestion est problématique notamment lorsque l'exécution des tâches par le microprocesseur utilise des accès à une mémoire. La réalisation de la nouvelle tâche risque alors de perturber les valeurs mémorisées pour la tâche en cours d'exécution, ce qui bien entendu vient perturber la tâche en cours et peut aboutir à des incohérences dues à l'état instable des données intermédiaires.

Pour remédier à ces problèmes, on peut simplement proscrire toute interruption. Le risque est alors que des tâches soient perdues. On peut également utiliser un logiciel de stockage des tâches en attente. Un tel logiciel gère alors une liste de tâches qui sera appelée par la suite "JobRow". Avec un tel logiciel, la tâche en cours d'exécution est stoppée momentanément, le temps que le logiciel liste des tâches en attente. Ainsi, pendant l'exécution d'une tâche, les tâches arrivant sont stockées par l'intermédiaire du logiciel dans la liste JobRow et seront effectuées une fois la tâche en cours d'exécution terminée.

Cette alternative pose toutefois des problèmes. Si l'interruption d'exécution d'un logiciel est autorisée, l'interruption du logiciel gérant la liste JobRow est également autorisée. Ainsi, une tâche de type "gestion de JobRow" pourra être interrompue par une nouvelle tâche de même type. Le logiciel gérant une liste JobRow peut ainsi être interrompu par lui-même. Pour éviter cet inconvénient, il convient alors de prévoir d'empêcher toute interruption de tâches pendant le fonctionnement de ce logiciel.

Cette gestion d'interruption de tâches fonctionne mais présente l'inconvénient de ralentir la vitesse d'exécution des tâches. En effet, ces arrêts et remises en marche de tâches consomment du temps. En outre, autoriser ces arrêts et remises en marche augmente également le risque de faire une erreur humaine lors de l'écriture du logiciel gérant la « JobRow ». Une telle erreur peut même conduire à un blocage du système.

La présente invention a alors pour but de fournir un procédé de gestion de tâches dans un microprocesseur, permettant notamment de gérer aussi des interruptions de tâches, qui permette un bon fonctionnement du système avec une exécution aussi rapide que possible des tâches. Il convient notamment d'éviter des pertes de temps dues à des arrêts et remises en marche d'une exécution de tâche.

Dans certains systèmes, une ressource est commune à plusieurs microprocesseurs. Ainsi, plusieurs microprocesseurs sont susceptibles d'accéder à cette ressource, dite ressource partagée, pour l'exécution des tâches qui leur sont confiées. Cette ressource partagée ne peut toutefois être utilisée que par un seul microprocesseur à la fois. Il est alors connu d'utiliser des algorithmes d'exclusion mutuelle (ou en anglais "mutual exclusion"), appelés également "mutex", pour gérer l'accès aux ressources partagées.

Avantageusement, la présente invention permettra de gérer également l'accès successif à une ressource partagée commune à plusieurs microprocesseurs.

À cet effet, la présente invention propose un procédé de gestion du traitement de tâches dans un microprocesseur, caractérisé en ce qu'il comporte des étapes pour la gestion parallèle d'une première liste et d'une seconde liste,

• en ce que la première liste correspond à une liste de tâches à effectuer,

• en ce que la seconde liste correspond à une liste de variables reflétant la présence ou non de tâches à effectuer,

• en ce que la liste de tâches est gérée de manière "FIFO", « First In, First Out », en anglais ; ou premier entrant, premier sortant, c'est-à-dire que la première tâche rentrée dans la liste est la première tâche exécutée, et

• en ce qu'une interruption de tâche est gérée à l'aide d'une fonction "Test And Set" exécutée sur les éléments de la seconde liste, la fonction "Test And Set" étant une fonction ne pouvant pas être interrompue et comportant les étapes suivantes :

- lecture de la valeur de l'élément considéré,

- stockage de la valeur lue dans une mémoire locale,

- affectation d'une valeur prédéterminée à l'élément qui vient d'être lu. L'utilisation originale d'une fonction de type "Test And Set" qui ne peut pas être interrompue au niveau justement d'une interruption de tâche permet de conserver des données cohérentes et ainsi un bon déroulement des tâches.

Quand il s'agit d'une liste de tâches, il faut comprendre que les tâches ne sont pas forcément listées mais que des pointeurs associés à des tâches sont les éléments contenus dans la liste. On peut étendre les éléments de la liste à tout type d'élément qui permettrait d'identifier clairement une tâche à exécuter (adresse, etc.).

La présente invention propose également un algorithme détaillé pour mettre en œuvre un tel procédé. Elle propose ainsi également un procédé de gestion du traitement de tâches dans un microprocesseur, caractérisé en ce qu'il comporte des étapes pour la gestion d'une première liste et d'une seconde liste,

• en ce que la première liste est une liste contenant des éléments donnant une indication sur une tâche à effectuer par le microprocesseur,

• en ce que la seconde liste est une liste de variables représentatives d'un état, chaque variable de la seconde liste étant associée à un et un seul élément de la première liste et pouvant prendre une première valeur représentative d'un premier état et une seconde valeur représentative d'un second état,

• en ce qu'une variable globale est définie, cette variable globale pouvant prendre autant de valeurs distinctes qu'il y a d'éléments dans la seconde liste, ladite variable globale permettant de pointer sur une variable dans la première liste ainsi que dans la seconde liste,

• en ce que ladite variable globale est une variable destinée à être incrémentée de manière à pointer dans un ordre donné les éléments de la première liste et de la seconde liste, la première liste et la seconde liste étant considérée comme des listes circulaires, c'est-à-dire que dans ledit ordre donné, le premier élément de la liste est considéré comme l'élément suivant du dernier élément de la liste et inversement, le dernier élément de la liste est considéré comme l'élément précédent du premier élément de la liste,

• en ce que la première étape du procédé, lorsqu'une tâche, dite tâche courante, est confiée au microprocesseur, consiste à effectuer une lecture de la valeur de la seconde liste pointée par la variable globale, à recopier la valeur lue dans une première variable locale et à écrire dans la seconde liste, à la place de la valeur lue, la valeur représentative du second état, cette première étape formant une seule opération, appelée "Test And Set" et ne pouvant être interrompue, en ce que ledit procédé met en œuvre un premier sous procédé dans le cas où la première variable locale a pris la valeur représentative du premier état et un second sous procédé dans le cas où la première variable locale a pris la valeur représentative du second état,

en ce que le premier sous procédé comporte les étapes suivantes :

- 3a) mise à jour de la première liste de telle sorte que l'élément correspondant à la variable locale donne une indication correspondant à la tâche courante,

- 4a) la variable de la seconde liste précédent la variable correspondant à la variable globale est mise à la valeur représentative du premier état,

- 5a) exécution de la tâche courante,

- 6a) incrémentation de la variable globale,

en ce qu'après l'étape 6a), le premier sous procédé retourne à l'étape 4a) si la valeur de la seconde liste correspondant à la variable globale, incrémentée, est représentative du second état, et le procédé est terminé sinon,

en ce que le second sous procédé comporte les étapes suivantes :

- 3b) initialisation d'une seconde variable locale à la valeur 1 , cette seconde variable locale étant destinée à être utilisée pour l'incrémentation de la variable globale,

- 4b) exécution d'une opération "Test And Set" sur la variable de la seconde liste correspondant à la variable globale incrémentée de la valeur de la seconde variable locale, la valeur lue étant recopiée dans une troisième variable locale et la valeur représentative du second état étant prise par l'élément de la seconde liste correspondant à la variable globale incrémentée de la valeur de la seconde variable locale,

- 5b) test sur la troisième variable locale et exécution d'une étape 6b) consistant à mettre à jour la première liste de telle sorte que la variable correspondant à la variable globale incrémentée de la seconde variable locale donne une indication correspondant à la tâche courante puis fin du procédé de gestion des tâches dans la mesure où le résultat du test sur la troisième variable locale indique que celle-ci a une valeur représentative du premier état, dans un cas contraire, une incrémentation de la seconde variable locale est réalisée suivie d'un retour à l'étape 4b) tant que la valeur de la seconde variable locale est strictement inférieure à une valeur limite correspondant au nombre d'éléments de la seconde liste diminué de 1 , et fin du procédé avec perte de la tâche courante si cette valeur limite est dépassée par la seconde variable locale.

Un tel procédé ne contient aucune partie qui ne soit pas interruptible. Il peut donc être interrompu à n'importe quel moment de son exécution et redémarrer une autre exécution. Bien entendu, comme mentionné, la fonction "Test And Set" ne peut pas être interrompue. On peut aussi prévoir une interruption de cet algorithme par lui-même.

L'algorithme du procédé ci-dessus a deux branches, l'une pour l'exécution des tâches, l'autre pour le stockage des nouvelles tâches à exécuter. Il permet d'assurer une cohérence des valeurs produites par les tâches en cours d'exécution sans bloquer l'exécution des autres tâches qui arrivent, ce procédé pouvant être interrompu à tout moment.

Dans ce procédé détaillé, la troisième variable locale est avantageusement confondue avec la première variable locale. Ceci permet d'éviter de multiplier le nombre de variables à gérer.

En outre, pour favoriser une rapidité d'exécution d'un procédé selon la présente invention, les variables de la seconde liste sont de préférence des variables booléennes.

La présente invention concerne également un procédé de gestion du traitement de tâches au niveau d'un ensemble d'au moins deux microprocesseurs. Dans ce procédé, chaque microprocesseur utilise un procédé de gestion de tâches tel que décrit plus haut.

Lorsqu'en outre une mémoire partagée est accessible par chaque microprocesseur de l'ensemble considéré, il est proposé :

• qu'une liste de tâches commune à l'ensemble des microprocesseurs soit définie,

• que cette liste de tâches soit gérée de manière "FIFO" c'est-à-dire que la première tâche rentrée dans la liste est la première tâche exécutée,

• que deux index soient définis en commun pour l'ensemble des microprocesseurs, un premier index indiquant quelle tâche est la prochaine tâche à exécuter et un second index indiquant l'emplacement dans lequel la liste de tâches sera à occuper par la prochaine tâche entrant dans la liste des tâches à effectuer, la gestion de la liste de tâches étant effectuée de manière cyclique, • que l'accès à la mémoire partagée soit géré par un mécanisme "mutex" définissant une variable dont la valeur est représentative de l'état de la mémoire partagée et à l'aide d'une fonction "Test And Set" exécutée sur cette dernière variable, la fonction "Test And Set" étant une fonction ne pouvant pas être interrompue et comportant les étapes suivantes :

- lecture de la valeur de la variable,

- stockage de la valeur lue dans une mémoire locale,

- affectation d'une valeur prédéterminée à la variable qui vient d'être lue.

Une telle gestion au niveau d'un ensemble de microprocesseurs permet une gestion cohérente des ressources (mémoire) communes. Les tâches peuvent s'exécuter les unes après les autres en fonction de leur ordre d'arrivée dans la liste. Toutefois, avec cette gestion, lorsqu'une tâche doit être exécutée, il n'est pas possible de savoir d'avance par quel microprocesseur de l'ensemble de microprocesseurs utilisant la ressource partagée cette tâche sera exécutée.

La présente invention concerne également un programme d'ordinateur stocké sur un support d'informations, ledit programme comportant des instructions permettant la mise en œuvre d'un procédé de gestion de tâches tel que décrit plus haut, lorsque ce programme est chargé et exécuté par un système informatique, tel un microprocesseur.

Enfin, la présente invention concerne aussi un microprocesseur, caractérisé en ce qu'il comporte des instructions d'un programme permettant la mise en œuvre d'un procédé de gestion de tâches tel que décrit plus haut.

Des détails et avantages de la présente invention ressortiront mieux de la description qui suit, faite en référence aux dessins schématiques annexés sur lesquels :

· La figure 1 est un algorithme illustrant un procédé de gestion de tâches selon la présente invention,

• La figure 2 illustre schématiquement une mémoire partagée par plusieurs microprocesseurs, et

• La figure 3 illustre un algorithme pour la gestion de tâches des microprocesseurs et de l'accès à la mémoire partagée représentés schématiquement sur la figure 2.

La figure 1 représente un algorithme permettant la mise en œuvre d'une forme de réalisation préférée d'un procédé de gestion de tâches selon la présente invention. Différents éléments sont utilisés dans cet algorithme. Parmi ceux-ci, on a notamment :

· RowSize, il s'agit d'une variable qui est un nombre entier supérieur à deux.

Il correspond au nombre de tâches pouvant être mises en attente dans le microprocesseur. • rjndex : il s'agit d'un nombre entier pouvant prendre toutes les valeurs de 0 à (RowSize-1 ).

• JobRow : il s'agit d'une liste d'éléments qui sont au nombre de RowSize. Ces éléments peuvent être directement des tâches ou bien un pointeur indiquant l'emplacement d'une tâche, ou tout autre élément qui permet de définir des tâches, notamment des tâches à exécuter.

• TasRow : il s'agit ici d'une liste de variables, de préférence des variables booléennes. Il y a autant de variables dans cette liste que dans JobRow. Cette liste est le reflet de JobRow et permet de connaître les positions des tâches stockées dans JobRow.

• Get : il s'agit d'une variable locale, disponible uniquement au niveau du microprocesseur et dont un nouvel exemplaire est créé à chaque fois que le procédé est interrompu dans son exécution pour être exécuté de nouveau depuis le début. Il s'agit de préférence d'une variable booléenne. · N : il s'agit ici aussi d'une variable locale. On supposera par la suite qu'il s'agit d'un nombre entier. Comme indiqué par la suite, cette variable locale est utilisée pour la lecture des éléments de TasRow.

Lorsque le programme correspondant à l'algorithme représenté sur la figure 1 est initialisé, rjndex est mis à zéro ainsi que tous les éléments de la liste TasRow.

Le point noir en haut de la figure 1 correspond au point d'entrée du programme qui va être décrit ci-après.

L'étape 1 met en œuvre une fonction appelée par la suite "Test And Set". Il s'agit d'une fonction qui ne peut être interrompue. Elle sera appliquée ici à des variables booléennes. Cette fonction Test And Set effectue une lecture de la variable booléenne, stocke la valeur de cette variable dans une mémoire tampon, une mémoire locale, puis donne à la variable booléenne lue une valeur prédéterminée, ici la valeur 1. À l'étape 1 , la fonction Test And Set est appliquée à l'élément de la liste TasRow d'indice rjndex. La valeur, 0 ou 1 , de cet élément de la liste TasRow est alors placée dans la mémoire locale Get puis l'élément de rang rjndex dans TasRow prend la valeur 1.

À l'étape 2, la valeur de Get est analysée et en fonction de la réponse obtenue, le programme exécute la branche de gauche de l'algorithme ou la branche de droite de cet algorithme. La branche de gauche de l'algorithme permet d'exécuter les tâches tandis que la branche de droite est utilisée pour stocker les nouvelles tâches à exécuter.

À l'étape 3a, si la valeur de Get est donc 0, la tâche "Job" est mise dans la liste JobRow au rang rjndex. Ensuite, à l'étape 4a, la valeur de rang précédent au rang r_index est alors mise à 0 dans la liste TasRow.

Il est à remarquer ici que la gestion de toutes les listes est une gestion circulaire (également dans le procédé par la suite concernant plusieurs microprocesseurs). Ainsi par exemple, si RowSize vaut 10, rjndex peut varier entre 0 et 9. Lorsque rjndex vaut alors 9 et qu'il est incrémenté d'une unité, sa valeur devient 0. Une telle gestion cyclique d'une liste est tout à fait habituelle pour l'homme du métier.

À l'étape suivante, étape 5a, Job, qui correspond à l'élément rangé dans la liste JobRow au rang rjndex, est exécuté. Ce n'est que lorsque la tâche est entièrement exécutée que la variable rjndex est incrémentée d'une unité (étape 6a).

À l'étape 7a, on regarde dans la liste TasRow l'élément de rang rjndex, ce rang étant le nouveau rang incrémenté. Si la valeur de cet élément vaut 1 , cela signifie qu'une tâche est à exécuter. L'algorithme renvoie alors dans ce cas à l'étape 4a. Par contre, s'il n'y a plus de tâche à exécuter, le programme est achevé. Le point en bas de la figure 1 représente la sortie du programme correspondant à l'algorithme.

La branche de gauche de l'algorithme ayant maintenant été décrite, intéressons-nous à la branche de droite. Cette branche concerne le stockage de tâches dans la liste de tâches JobRow.

À l'entrée de la branche de droite, à l'étape 3b, la variable locale N est initialisée à la valeur 1. On réalise ensuite à l'étape 4b une fonction Test And Set sur l'élément de la liste TasRow de rang rjndex + N, bien entendu modulo RowSize. Une troisième variable locale pourrait être utilisée ici comme mémoire tampon. En fait, il est inutile d'utiliser ici une troisième variable, la variable locale Get étant disponible pour empiler les tâches confiées au microprocesseur et ne pouvant être de suite exécutées. Le résultat de la fonction Test and Set au niveau de l'étape 4b est alors enregistré dans la variable locale Get. Si celle-ci vaut alors 0 (étape 5b), la place de rang rjndex + N est alors libre dans la liste JobRow et la tâche Job, qui est la tâche courante ayant déclenché le programme, est alors stockée dans JobRow au rang rjndex + N (modulo RowSize bien entendu). La tâche étant dans la liste d'attente, le programme est alors terminé.

Par contre, à l'étape 5b, si la valeur de Get n'est pas 0, c'est-à-dire qu'elle vaut 1 , il convient d'incrémenter N d'une unité pour regarder si la place suivante dans la liste des tâches JobRow est libre. On continue alors à regarder toutes les places dans la liste JobRow jusqu'à trouver une place libre (boucle 4b, 5b, 6c, 7c, 4b). Si la liste des tâches est entièrement remplie (étape 7c), la tâche courante "Job" est alors perdue. Le programme est alors également terminé.

Le procédé de gestion des tâches qui vient d'être décrit ici présente l'avantage qu'il ne contient aucune partie qui ne soit pas interruptive. Il est toutefois rappelé ici que la fonction Test And Set ne peut pas être interrompue. Le procédé décrit ci-dessus et illustré sur la figure 1 peut être interrompu à n'importe quel moment de son exécution pour redémarrer une autre exécution. Dans le cas de l'interruption de ce procédé par lui-même, son exécution est suspendue jusqu'à ce que la prochaine exécution soit finie.

L'algorithme proposé ici permet d'enregistrer des tâches dans la liste des tâches dès qu'une tâche en cours d'exécution est terminée. Les tâches sont stockées et lues par leur ordre d'arrivée. On a donc ici une gestion "FIFO" (de l'anglais First In First Out, ou en français, premier entré premier sorti).

La mise en oeuvre de cet algorithme permet d'assurer une cohérence des valeurs produites par les tâches en cours d'exécution sans bloquer l'exécution des autres tâches qui arrivent, puisque le procédé correspondant est à tout moment interruptible. Cette cohérence est notamment obtenue grâce au fait que l'algorithme servant à l'exécution et au stockage des tâches est basé sur une fonction, la fonction Test And Set qui n'est pas interruptive et ne peut donc être interrompue.

La présente invention prévoit également de gérer des tâches d'un ensemble de microprocesseurs, cet ensemble présentant une mémoire partagée à laquelle chacun des microprocesseurs de l'ensemble peut accéder.

À titre d'exemple non-limitatif et simplement illustratif, la figure 2 représente quatre microprocesseurs, appelés CPU A, CPU B, CPU C et CPU D. On suppose ici par exemple que ces quatre microprocesseurs sont tous les quatre identiques mais bien entendu l'invention fonctionne également avec des microprocesseurs qui ne seraient pas semblables. Une mémoire au centre de la figure 2 contient des données accessibles et modifiables par les quatre microprocesseurs de l'ensemble des microprocesseurs. On suppose ici, toujours à titre d'exemple non-limitatif, que chaque microprocesseur possède quatre niveaux ("Level") d'interruption.

Pour la cohérence du système, il convient de prévoir un mécanisme de sécurité qui permette de mettre en attente une tâche qui devrait être exécutée lorsqu'une autre tâche utilisant des données communes est déjà en cours d'exécution. Il convient ici de gérer plusieurs microprocesseurs avec chacun plusieurs niveaux d'interruption. Il convient ainsi de trouver un mécanisme de verrouillage qui permette d'assurer une cohérence des données pour l'exécution de chaque programme. On souhaite ainsi s'assurer qu'il soit accédé à la mémoire partagée séquentiellement par toutes les tâches, c'est-à-dire que chaque tâche soit entièrement réalisée avant qu'une autre ne soit démarrée. Comme illustré à titre d'exemple sur la figure 2, on souhaite gérer par exemple une situation où le niveau 3 du CPU A, le niveau 1 du CPU A, le niveau 4 du CPU B, le niveau 2 du CPU B, le niveau 3 du CPU C et le niveau 1 du CPU D nécessitent un accès à une même mémoire en même temps. L'algorithme de la figure 3 est destiné à la gestion de tâches pour plusieurs microprocesseurs ainsi qu'à la gestion d'une mémoire partagée entre ces microprocesseurs.

Il est proposé ici tout d'abord que chacun des microprocesseurs gère ses tâches selon un procédé tel celui décrit plus haut en référence à la figure 1. Le procédé de la figure 3 concerne quant à lui une gestion de tâches au niveau de l'ensemble des microprocesseurs, c'est-à-dire ici les microprocesseurs CPU A, CPU B, CPU V et CPU D.

La présente invention propose ici d'utiliser une liste commune de tâches, appelée ici également JobRow. On reprendra ici les mêmes noms que précédemment pour des éléments semblables. Toutefois, dans la description qui suit, les éléments concernent l'ensemble des microprocesseurs et la mémoire partagée.

Le procédé représenté sur l'algorithme de la figure 3 met ainsi notamment en œuvre les éléments suivants :

• JobRow, déjà évoqué plus haut. Il s'agit d'une liste de tâches concernant l'ensemble des microprocesseurs,

• RowSize, il s'agit du nombre d'éléments pouvant se trouver dans JobRow,

• r_index, il s'agit d'une variable entière pouvant prendre RowSize valeur. On supposera ici que rjndex peut prendre les valeurs allant de 0 à RowSize - 1. Comme on le verra plus loin, le procédé prévoit de lire les tâches pour les exécuter d'un côté et d'un autre côté de placer des tâches à exécuter dans la liste de tâches. L'indice rjndex est utilisé pour la lecture (r de "read" en anglais ou lire en français),

• wj ^' ndex, de même que rjndex, il s'agit d'une variable entière pouvant prendre RowSize valeur. Dans la pratique, elle prendra les valeurs de 0 à RowSize -1. Cet indice wj ^' ndex est utilisé pour empiler des tâches dans la liste de tâches JobRow (w de "write" en anglais ou écrire en français),

• mutex, cette variable indique l'état de la mémoire partagée. Elle sert notamment à bloquer l'accès à cette mémoire. Dans la pratique, on choisira pour mutex une variable booléenne prenant soit la valeur 0 lorsque la mémoire est accessible, soit la valeur 1 pour indiquer que la mémoire est bloquée,

• Get, il s'agit ici d'une variable locale qui est ici également choisie, de préférence, comme étant une variable booléenne.

Au départ, les variables sont initialisées en mettant à 0 les valeurs de rjndex, wj ^' ndex et mutex. On considère ici que RowSize est au moins égal à 3.

Dans le procédé qui suit, la liste des tâches, JobRow, est gérée de manière "FIFO". La liste JobRow est, comme déjà mentionné précédemment, gérée comme une liste cyclique. Dans cette liste cyclique, toutes les tâches à exécuter sont regroupées. Il ne peut pas y avoir de "place(s) libre(s)" entre deux tâches de la liste JobRow. Le procédé décrit ci-après prévoit simplement l'exécution de la première tâche à exécuter (suivi avec l'index r_index) et d'empiler dans la liste de tâches JobRow les tâches qui arrivent à l'aide de la liste w_index. L'accès à la mémoire partagée, notamment pour la gestion des indices rjndex et w_index met en œuvre un mécanisme mutex utilisant la variable du même nom et la fonction Test And Set.

Ainsi, la première étape, l'étape a1 de la figure 3, prévoit l'exécution d'une fonction Test And Set sur la variable mutex. Cette variable est représentative de l'état de la mémoire partagée par tous les microprocesseurs de l'ensemble de microprocesseurs. Le résultat de la fonction Test And Set est placé dans la variable locale Get. Comme il est habituel pour la fonction Test And Set, la variable mutex prend donc la valeur 1 et la valeur Get est égale soit à 0, soit à 1.

À l'étape a2, si la valeur Get ne vaut pas 0, on retourne à l'étape a1 , ceci est réalisé jusqu'à ce que la mémoire partagée soit accessible et que donc la valeur Get soit à O.

À l'étape a3, la valeur Get est réinitialisée à 0 (facultatif) et la variable rjndex est comparée à la variable wj ^' ndex. En effet, si ces deux variables sont égales, cela signifie que la liste des tâches est vide. Si c'est le cas, le procédé suit alors la branche de gauche de l'algorithme représenté sur la figure 3 qui correspond à l'exécution des tâches. La branche de droite (séparation au niveau de l'étape a4) concerne quant à elle l'empilage de tâches dans la liste de tâches.

La description ci-après commente tout d'abord la branche de gauche (étapes b1 à b7) puis ensuite la branche de droite de l'algorithme de la figure 1.

Dans la première étape (étape b1) de la branche de gauche, la tâche courante

Job est recopiée dans la liste de tâches JobRow au rang wj ^' ndex. En outre, la variable wj ^' ndex est incrémentée d'une unité. Comme déjà mentionné, cette incrémentation se fait modulo RowSize. De ce fait, lorsque wj ^' ndex doit prendre la valeur RowSize, elle prend la valeur 0.

L'indice wj ^' ndex étant maintenant modifiée, la mémoire peut être libérée et la valeur mutex est mise à 0 à l'étape b2. La tâche se trouvant dans la liste de tâches JobRow au rang rjndex est alors exécutée (étape b3).

De même que précédemment, pour le procédé décrit en référence à la figure 1 , une fois la tâche réalisée, l'indice de rang rjndex peut être incrémenté. Toutefois, il faut ici s'assurer que l'accès à la mémoire partagée est disponible. On réalise alors à l'étape b4 une fonction Test And Set sur la variable mutex. Comme déjà suggéré précédemment pour le procédé illustré sur la figure 1 , il est inutile de choisir une variable locale supplémentaire. On reprend ici la variable Get. Tant que cette variable Get vaut 1 , c'est-à-dire tant que la variable partagée est utilisée par une autre ressource, on revient à l'étape b4. Toutefois, quand la mémoire devient accessible, Get prend alors la valeur 0 et on peut passer à l'étape b6 qui prévoit l'incrémentation d'une unité de l'indice rjndex.

Une fois l'indice rjndex incrémenté, il est à nouveau comparé à l'indice wj ^' ndex. Si ces deux indices sont égaux, c'est-à-dire si la liste des tâches est vide, le programme peut être achevé. Toutefois, avant de sortir du programme, il est prévu, à l'étape a5, de libérer l'accès à la mémoire partagée en donnant à la variable mutex la valeur 0.

Dans le cas contraire (rjndex différent de wj ^' ndex, à l'étape b7), on retourne à l'étape b2 pour effectuer la tâche suivante.

La branche de gauche de l'algorithme de la figure 3 étant maintenant décrite, la suite de la description va porter sur la branche de droite de cet algorithme.

La valeur de la variable (wj ^' ndex + 1) est alors comparée à la valeur de la variable rjndex (modulo RowSize bien entendu). Si ces valeurs sont égales, on affecte la valeur 1 à la variable locale Get à l'étape d1 ; cela permet de voir que la liste de tâches est remplie. On peut ici aussi utiliser la variable locale Get, et non pas définir une variable locale particulière car cette variable Get sera remise à 0 après exécution d'une tâche par le procédé (ou quand une nouvelle tâche est ajoutée à la liste de tâches).

À l'étape c1 , si la liste de tâches JobRow n'est pas pleine, la tâche courante

Job est alors inscrite dans la liste JobRow au rang wj ^' ndex. Une fois l'inscription réalisée, l'indice wj ^' ndex peut être incrémenté d'une unité.

La tâche étant correctement empilée, les indices étant mis à jour, le programme peut être terminé. Toutefois, pour libérer l'accès à la mémoire partagée, l'étape a5 réinitialisant la variable mutex à la valeur 0 est réalisée.

Le procédé correspondant à l'algorithme représenté sur la figure 3 n'est pas bloquant. Il ne conduit jamais à une mise en attente potentiellement infinie d'un microprocesseur. On est sûr d'éviter un tel blocage si tous les processeurs utilisent la variable mutex concernant la mémoire partagée uniquement avec cet algorithme (figure 3).

De cette manière, si un microprocesseur a une tâche à effectuer en accédant à des données partagées, il va mettre cette tâche dans la liste de tâches et lui-même ou un autre microprocesseur exécutera cette tâche ultérieurement lorsque la ressource partagée sera disponible.

L'algorithme décrit présente cette caractéristique que si plusieurs microprocesseurs partagent une même ressource, et de ce fait une même liste de tâches, alors lorsqu'une exécution de tâche est requise, il n'est pas possible de savoir quel microprocesseur va l'exécuter. Toutefois, cet algorithme garantit que la tâche va être exécutée par l'un des microprocesseurs partageant la ressource, aussitôt que possible, avec une gestion de type "FIFO".

La présente invention ne se limite pas aux procédés décrits ci-dessus à titre d'exemples non-limitatifs. Elle concerne toutes les variantes de réalisation de tels procédés dans le cadre des revendications ci-après. Cette invention concerne également un microprocesseur permettant la mise en œuvre d'un procédé tel que décrit plus haut.