FR3014221A1 - Procede de generation d'un code logiciel pour la parallelisation d'une fonction associative, programme d'ordinateur et dispositif associes - Google Patents

Abstract

Procédé de génération d'un code logiciel (Copt) pour la parallélisation d'une fonction associative à appliquer sur un jeu (D) de données d'entrée, selon lequel les instructions suivantes d'un programme logiciel sont générées pour chacune desdites tâches à exécuter en parallèle à partir d'un sous-jeu du jeu de données respectivement associé à chaque tâche : - appliquer la fonction associative à deux éléments chacun issu d'une donnée distincte du sous-jeu respectif, puis tant que toutes les données d'entrée du sous-jeu associé à la tâche n'ont pas été prises en compte, appliquer itérativement la fonction associative à un nouvel élément issu d'une nouvelle donnée d'entrée du sous-jeu respectif et au résultat de la précédente application par le programme logiciel de la fonction associative; - puis, seulement, synchroniser les tâches du groupe de tâches de la tâche considérée.

Description

Procédé de génération d'un code logiciel pour la parallélisation d'une fonction associative, programme d'ordinateur et dispositif associés La présente invention concerne un procédé de génération d'un code logiciel pour la parallélisation d'une fonction, en tout ou partie associative, à appliquer sur un jeu de données d'entrée par un système cible comprenant au moins une unité matérielle comportant une pluralité de processeurs élémentaires. Dans de nombreux domaines, par exemple ceux de l'optronique, des radars, des sonars, des systèmes mettent en oeuvre des algorithmes de traitement de données.

Les performances de ces systèmes, notamment leur vitesse de traitement, sont très liées à l'implémentation des algorithmes. Pour accroître ces performances, il est notamment souhaitable de paralléliser les traitements effectués dans les algorithmes en utilisant des calculateurs parallèles, notamment dans des cartes graphiques. Typiquement, pour exploiter le modèle d'architecture d'une carte graphique, il est nécessaire d'avoir plusieurs milliers de tâches s'exécutant sur des données différentes en même temps. Certains algorithmes élémentaires sont par nature hautement parallèles : un seuillage, une convolution d'image, un cornertum (changement d'axe s'appliquant à chaque point d'un vecteur de données d'entrée de manière indépendante).

D'autres algorithmes nécessitent toutefois une transformation importante du vecteur de données d'entrée pour être parallélisés. La technique de la réduction est une des techniques de parallélisation les plus utilisées. L'application de cette technique nécessite d'opérer avec une fonction f associative, i.e. de ExE dans E et vérifiant f(f(f(a,b),c),d) = f(f(a,b), f(c,d)) = f(X, Y) où les calculs de X et Y peuvent être effectués en parallèle. La charge de travail totale n'a pas diminué, mais ces opérations peuvent être réalisées en parallèle d'où une réduction du temps de traitement. De nombreuses fonctions sont associatives, parmi lesquelles la recherche du minimum et/ou maximum des coordonnées d'un vecteur, la fusion d'histogramme, la somme et donc le moyennage etc. Sur la figure 1 est représenté un graphe de code correspondant à la recherche d'un minimum et maximum (fonction Fminmax) d'un vecteur d'entrée comportant IMAX composantes successives 20 (IMAX pris égal à 16 pour la figure 1). Les cases 20 représentent les données d'entrée de valeur in[i], i = 0 à IMAX-1.

Ce code s'écrirait en pseudo-code, après création d'un vecteur de deux éléments Vminmax. Vminmax[0] contiendra en sortie le minimum, et Vminmax[1] le maximum.: Vminmax[0] = in[0] Vminmax[1] = in[0] Pour i = 1 et tant que i < IMAX { Vminmax[0] = minimum [Vminmax[0], in[i]] Vminmax[1] = maximum [Vminmax[1], in[i]] i = i + 1 Le résultat fourni est référencé 23. L'application de la fonction minmax est représentée par l'opérateur « op » 21.

Le nombre d'étapes successives d'application de la fonction minmax, est ici de 15. En figure 2, la mise en oeuvre d'une parallélisation de la fonction minmax sur le vecteur d'entrée est illustrée. Le résultat fourni est référencé 24. Le nombre d'étapes successives d'application de la fonction minmax, est de 4 et est ainsi nettement réduit. Il existe de nombreuses manières de paralléliser les traitements. Pour un grand nombre de fonctions associatives, il existe des implémentations parallèles fournies par le fabricant Toutefois ces implémentations restent génériques et ne prennent pas en considération la taille des données d'entrée ni l'accélérateur spécifique. Les performances ne sont donc pas optimales. Lorsque de telles implémentations génériques n'existent pas, la parallélisation est réalisée par le développeur, ce qui demande un temps d'implémentation important et/ou donne lieu à des performances sous-optimales. A cet effet, suivant un premier aspect, l'invention propose un procédé de génération d'un code logiciel pour la parallélisation d'une fonction associative du type précité caractérisé en ce que qu'il comprend les étapes suivantes mises en oeuvre par ordinateur : - réception de la définition de la fonction associative, et de la taille du jeu ; - détermination d'au moins un couple indiquant un nombre de groupes de tâches à exécuter par unité matérielle et un nombre de tâches par groupe de tâches ; - une application logicielle de génération étant adaptée pour générer les instructions suivantes d'un programme logiciel pour chacune desdites tâches à exécuter en parallèle à partir d'un sous-jeu du jeu de données respectivement associé à chaque tâche : - appliquer la fonction associative à deux éléments chacun issu d'une donnée distincte du sous-jeu respectif, puis tant que toutes les données d'entrée du sous-jeu associé à la tâche n'ont pas été prises en compte, appliquer itérativement la fonction associative à un nouvel élément issu d'une nouvelle donnée d'entrée du sous-jeu respectif et au résultat de la précédente application par le programme logiciel de la fonction associative; - puis, seulement, synchroniser les tâches du même groupe de tâches que la tâche considérée. L'invention permet ainsi de générer de façon automatique, en un temps réduit, un code logiciel permettant d'exécuter en parallèle une fonction associative sur des données d'entrée, donnant lieu à des performances de traitement accrues. Dans des modes de réalisation, le procédé de génération d'un code logiciel suivant l'invention comporte en outre une ou plusieurs des caractéristiques suivantes : - chaque processeur élémentaire comporte une mémoire privée accessible uniquement par une tâche exécutée par ledit processeur élémentaire, selon lequel ledit programme logiciel commun est adapté pour stocker les résultats des applications de la fonction associative uniquement dans la mémoire privée accessible par la tâche considérée tant que l'application de l'opération n'est pas l'application de l'opération précédant immédiatement l'étape de synchronisation des tâches ; - chaque unité matérielle comprend une mémoire locale partagée exclusivement par les processeurs élémentaires d'une même unité matérielle et selon lequel les tâches d'un groupe de tâches sont partagées en un premier sous-groupe et un deuxième sous- groupe, ledit programme logiciel étant adapté pour, lorsque l'application de l'opération est l'application de l'opération précédant immédiatement l'étape de synchronisation des tâches : - si la tâche considérée fait partie du premier sous-groupe, stocker le résultat de ladite application de la fonction associative dans la mémoire privée accessible par la tâche considérée ; - si la tâche considérée fait partie du deuxième sous-groupe, stocker le résultat de ladite application de la fonction associative dans la mémoire locale de l'unité matérielle de la tâche considérée ; - chaque processeur élémentaire comporte une mémoire privée accessible uniquement par une tâche exécutée par ledit processeur élémentaire et selon lequel l'application de génération est adaptée pour mettre en oeuvre itérativement l'ensemble d'étapes a/ et b/ suivant, avec Dz initialement pris égal à la première puissance de 2 supérieure ou égale au nombre de tâches par groupe de tâches : a/ tant que Dz> 1, générer les instructions suivantes pour le programme logiciel : i/ si la tâche fait partie du deuxième sous-groupe : ne plus rien faire ; ii/ si la tâche fait partie du premier sous-groupe : une desdites moitiés des tâches du premier sous-groupe devient le premier sous-groupe et l'autre desdites moitiés devient le deuxième sous-groupe ; et iii/ si la tâche fait partie du deuxième sous-groupe : stocker le résultat de ladite application de la fonction associative dans la mémoire locale de l'unité matérielle de la tâche considérée ; iv / à réaliser après ii/ et iii/ : synchronisation des tâches du groupe de tâches ; v/ à réaliser après iv/ si la tâche fait partie du premier sous-groupe : appliquer la fonction associative au dernier résultat d'application de la fonction stocké dans la mémoire privée accessible par la tâche considérée et à un résultat stocké dans la mémoire locale par une tâche du deuxième sous-groupe, s'il existe ; et stocker le résultat de ladite application de la fonction associative dans la mémoire privée accessible par la tâche considérée ; b/ Dz=Dz/2 ; - chaque processeur élémentaire comporte une mémoire privée accessible uniquement par une tâche exécutée par ledit processeur élémentaire et selon lequel l'application logicielle est adaptée pour mettre en oeuvre les étapes suivantes, pour une tâche de rang respectif donné B dans le groupe de tâches, B prenant une valeur variant entre 0 et ledit nombre de tâches par groupe moins 1, un numéro respectif A étant affecté audit groupe, A prenant une valeur variant de 0 jusqu'audit nombre de groupes de tâches déterminé moins 1 ; - i = 0 ; - générer, dans le programme logiciel pour la tâche considérée, les instructions de : - stocker un élément issu de la (A*NB_TACHES_PAR_GROUPE + Byème donnée du jeu de données d'entrée dans la mémoire privée ; - appliquer la fonction associative audit élément stocké dans la mémoire privée et à un élément issu de la (A*NB_TACHES_PAR_GROUPE + i* NB_TACHES_PAR_GROUPE +B)Ième donnée du jeu de données d'entrée et stocker le résultat dans la mémoire privée ; - incrémenter i. - le procédé comprend en outre les étapes selon lesquelles : - une pluralité de couples indiquant un nombre de groupes de tâches à exécuter par unité matérielle et un nombre de tâches par groupe de tâche est déterminée ; - un programme logiciel est généré pour chaque couple ; - les performances des programmes logiciels générés issues de l'exécution de ces programmes logiciels sur le système cible sont comparées ; - un programme logiciel parmi lesdits programmes logiciels est sélectionné en fonction de ladite comparaison ; - chaque couple, le nombre de tâches par groupe est déterminé comme multiple entier du nombre de processeurs élémentaires par unité matérielle et le nombre de groupe de tâches est déterminé comme multiple entier du nombre d'unités matérielles ; - un desdits éléments issus d'une donnée distincte du sous-jeu respectif et auxquels la fonction associative est appliquée, est déterminé par application d'une fonction de prologue à une donnée du jeu des données d'entrée conçue pour adapter la dimension de la donnée d'entrée à la dimension de l'ensemble de départ de la fonction associative ; Suivant un deuxième aspect, la présente invention propose un programme d'ordinateur pour générer un code logiciel pour la parallélisation d'une fonction associative à appliquer sur un jeu de données d'entrée par un système cible comprenant au moins une unité matérielle comportant une pluralité de processeurs élémentaires, ledit programme comportant des instructions pour mettre en oeuvre les étapes d'un procédé tel que défini plus haut lors d'une exécution du programme par des moyens de traitement de l'outil de génération d'un code logiciel.

Suivant un troisième aspect, la présente invention propose un outil de génération d'un code logiciel pour la parallélisation d'une fonction associative à appliquer sur un jeu de données d'entrée par un système cible comprenant au moins une unité matérielle comportant une pluralité de processeurs élémentaires, ledit outil étant adapté pour recevoir la définition de la fonction associative et de la taille du jeu et pour déterminer au moins un couple indiquant un nombre de groupes de tâches à exécuter par unité matérielle et un nombre de tâches par groupe de tâches ; ledit outil de génération d'un code logiciel comprenant en outre une application logicielle de génération adaptée pour générer les instructions suivantes d'un programme logiciel pour chacune desdites tâches à exécuter en parallèle à partir d'un sous-jeu du jeu de données respectivement associé à chaque tâche : - appliquer la fonction associative à deux éléments chacun issu d'une donnée distincte du sous-jeu respectif, puis tant que toutes les données d'entrée du sous-jeu associé à la tâche n'ont pas été prises en compte, appliquer itérativement la fonction associative à un nouvel élément issu d'une nouvelle donnée d'entrée du sous-jeu respectif et au résultat de la précédente application par le programme logiciel de la fonction associative; - puis, seulement, synchroniser les tâches du même groupe de tâches que la tâche considérée.

Ces caractéristiques et avantages de l'invention apparaîtront à la lecture de la description qui va suivre, donnée uniquement à titre d'exemple, et faite en référence aux dessins annexés, sur lesquels : la figure 1 représente un graphe de code selon une implémentation d'une fonction conforme au code en langage C ; la figure 2 représente un graphe de code de la même fonction mettant en oeuvre une parallélisation des traitements ; la figure 3 représente une vue d'une plate-forme dans un mode de mise en oeuvre de l'invention ; la figure 4 représente des étapes d'un procédé dans un mode de mise en oeuvre de l'invention ; la figure 5 représente un graphe de code obtenu suite à la mise en oeuvre d'un mode de réalisation de l'invention. Sur la figure 3, une plate-forme 1 comporte un outil de génération de code parallèle 2 et un système cible 3 comportant par exemple une carte graphique. L'outil de génération de code parallèle 2 est adapté pour générer un code parallèle optimal destiné à l'exécution d'une fonction associative f sur un jeu de données d'entrée D par un système cible 3. Le système cible 3 comprend une architecture matérielle parallèle destinée à mettre en oeuvre des traitements logiciels en parallèle. Il comprend notamment un processeur maître 4 et un accélérateur matériel 5 comprenant M tuiles matérielles 6. Chaque tuile matérielle 6, encore appelée unité de calcul matérielle, comprend un ensemble 8 de N processeurs élémentaires 9. Le processeur maître 4 et les processeurs élémentaires 9 sont adaptés pour exécuter des instructions logicielles. Le processeur maître 4 est adapté pour contrôler les processeurs élémentaires 9. Le système cible 3 comprend des mémoires destinées à stocker les données du jeu D de données d'entrée du système, les instructions logicielles diverses, les valeurs intermédiaires et finales des traitements exécutés sur le système cible 3.

Le processeur maître 4 comprend sa propre mémoire (non représentée). L'accélérateur matériel 5 comprend une mémoire 10 dite mémoire globale. Cette mémoire globale 10 de l'accélérateur matériel 5 est accessible en écriture et en lecture par l'ensemble des processeurs élémentaires 9 des différentes tuiles 6. Chaque tuile 6 comprend une mémoire 7 dite mémoire locale. La mémoire locale 7 d'une tuile 6 est accessible en écriture et en lecture par les processeurs élémentaires de cette tuile 6 (et pas par les processeurs élémentaires des autres tuiles 6).

Chaque processeur élémentaire 9 comporte en outre une mémoire 11 qui lui est dédiée en lecture et écriture, dite mémoire privée, qu'il ne partage pas avec un quelconque autre processeur. La mémoire privée 11 est donc accessible aux seules tâches s'exécutant sur le processeur élémentaire.

Tous les processeurs élémentaires 9 de l'accélérateur matériel 5 exécutent en parallèle le même code, qui définit une tâche, mais chaque processeur l'applique sur une section spécifique du jeu de données. L'outil de génération de code parallèle 2 est adapté pour générer ce code de la façon décrite plus bas, en référence à la figure 5.

Une tâche (en anglais « thread ») comporte une succession d'opérations logicielles, dont l'application ou les applications de la fonction associative considérée. Un groupe de tâches est exécuté par une tuile 6. On notera que l'accès à la mémoire privée 11 est beaucoup plus rapide que l'accès à la mémoire locale, qui lui-même est plus rapide que l'accès à la mémoire globale 10. En particulier, lors de l'exécution des tâches respectives par des processeurs élémentaires 9 opérant en parallèle, lorsqu'un processeur élémentaire 9 doit accéder à une donnée écrite en mémoire (locale ou globale) par un autre processeur élémentaire 9, il est nécessaire de s'assurer que la donnée y sera bien présente : si les tâches sont exécutées sur la même tuile 6, il faudra donc synchroniser les tâches (opération coûteuse de plusieurs dizaines de coups d'horloge) ; si les tâches ne sont pas exécutées sur la même tuile, il faudra créer une nouvelle phase d'exécution de tâches, encore appelée « kernel », opération très coûteuse de plusieurs milliers de cycles d'horloge.

L'outil de génération 2 est adapté pour recevoir en entrée un fichier de configuration P décrivant notamment la fonction f. Dans un mode de réalisation, une partie des paramètres est créée par l'outil de génération 2. Le fichier de configuration P est créé via une interface graphique ou écrit en brut dans un fichier texte. Il contient les paramètres suivants P1 à P5 dans un mode de réalisation de l'invention : P1 : la taille du jeu de données d'entrée D, de valeur TAILLE_D ; les indices des données successives sont ainsi 0, 1, ... TAILLE_D-1.

P2 : le type des éléments du jeu de données d'entrée D, le type des données manipulées par la fonction associative f, le type de la donnée de sortie résultant de l'application de la fonction f au jeu D de données d'entrée ; P3 : la définition de la fonction associative f à appliquer au jeu D de données d'entrée, notamment son nom et la formulation de la fonction en langage C ; Par exemple, le code en langage C pour la fonction associative minmax prend la forme suivante : « inout1.x = min(inout1.x, in2.x) ; inout1.y = max(inout1.y, in2.y) ». Le code C pour un histogramme à 256 valeurs : « unsigned int i ; for (i=0 ; i<256 ; i-H-) inouti[i]+=in2[i] ». P4 : fonction à appliquer en prologue, i.e. avant la fonction associative sur chaque donnée du jeu D, ainsi que la fonction à appliquer en épilogue sur la donnée finale. Le prologue a pour fonction de passer de la dimension des données d'entrée à la dimension requise en entrée de la fonction associative. Ainsi par exemple, considérons que chaque donnée d'entrée du jeu de données d'entrée est scalaire. La fonction associative est à appliquer à une première donnée d'entrée et une deuxième donnée d'entrée. Si la fonction associative est une fonction minmax, elle reçoit en entrée deux vecteurs de dimension 2 et délivre en sortie un vecteur de dimension 2 (de première coordonnée le minimum des deux données d'entrée et de deuxième coordonnée le maximum des deux données d'entrée). Il convient donc, avant d'appliquer la fonction associative de transformer, par l'application du prologue, chaque donnée d'entrée en un vecteur de dimension 2 (chaque coordonnée étant égale à la valeur scalaire de la donnée d'entrée).

De même pour une fonction associative histogramme à 256 valeurs, il convient d'appliquer un prologue qui transforme une donnée d'entrée de type scalaire en un tableau de 256 éléments. Chaque élément de ce tableau est égal à zéro excepté, l'élément associé à la valeur scalaire de la donnée d'entrée qui prend la valeur 1. Prologue pour un minmax : "out1.x = vec[position]; out1.y = vec[position]".

Pour un histogramme 256 valeurs : "unsigned int i; for(i=0; i <256; i++) out1[i]=0; outi[img[position]]++;"1. P5 : formulation de la fonction associative f avec prologue intégré pour le second terme de la fonction associative ; cette formulation permet de gagner en performance.

La formulation du prologue et fonction associative fusionnées pour un minmax : vide. Pour un histogramme 256 valeurs : "inouti[img[position]]++".

Dans le mode de réalisation considéré, le fichier de configuration P indique en outre les paramètres suivants : P7 : une initialisation en C, exécutée sur le processeur maître 4 d'un vecteur de test ; P8 : une vérification en C (exécutée sur le processeur maître 4 indiquant le résultat de la fonction f sur le vecteur de test, pour vérifier que le calcul, une fois réalisé par l'accélérateur 5, est valide ; P9 : des options correspondant à une utilisation particulière de la mémoire, par exemple pour utiliser une mémoire plus lointaine, mais de taille plus importante, notamment une mémoire locale au lieu d'une mémoire privée. Dans un mode de réalisation de l'invention, les étapes indiquées ci-dessous sont mises en oeuvre par l'outil de génération 2, en référence à la figure 4. Dans un mode de réalisation, ces étapes sont mises en oeuvre suite à l'exécution sur un processeur de l'outil de génération 2, d'instructions logicielles d'un programme d'ordinateur.

Dans une première étape 101, un ensemble de couples NBk,= (NB_GROUPESk NB_TACHES PAR GROUPEk) k = 1 à K, est défini. Chacun de ces couples est distinct. Il comporte un premier terme, NB_GROUPESk, indiquant le nombre de groupes de tâches du code à générer (un groupe de tâches étant exécuté par tuile) et comporte un deuxième terme, NB_TACHES_PAR_GROUPEk, indiquant le nombre de tâches à réaliser en parallèle par groupe de tâches. Dans le mode de réalisation considéré, cet ensemble de couples est défini automatiquement par l'outil de génération 2 en fonction du système cible 3 pour lequel un code parallèle optimal doit être généré, et en fonction des règles suivantes, si les valeurs N et M sont alors connues : le nombre de tâches par groupe de tâches est égal à un multiple du nombre N de processeurs élémentaires 9 sur une tuile 6 ; dans un mode de réalisation, seuls seront considérés les multiples 1N, 2N, 3N, 4N et 5N ; le nombre de groupes de tâches est égal à un multiple du nombre M de tuiles 6 ou est égal à 1 (si le jeu de données d'entrée D est de petite taille, n'utiliser qu'une seule tuile permet de ne lancer qu'un seul kernel et peut être optimal) ; dans un mode de réalisation, seuls les multiples pM seront considérés, avec p entier allant de 0 à 20. Dans le mode de réalisation concerné, le code optimal est recherché avec des valeurs M et N prédéfinies. Une centaine de couples sont générés, correspondant à des configurations à 32, 64, ...512 tâches par groupe, avec 2, 4, ..., 32 groupes. Il est courant que le nombre de processeurs élémentaires par tuile soit multiple de 32. En testant toutes ces possibilités, on évite de rentrer dans la configuration la moindre assertion sur le matériel. Pour un matériel fixé aux caractéristiques non connues, on pourrait balayer l'espace plus exhaustivement en intégrant dans le script des valeurs M = N = 1, et en testant plus de multiples du nombre de processeurs élémentaires par tuile. Pour un nombre de tâches par groupe égal à NB_TACHES_PAR GROUPE et un nombre de groupe de tâches égal à NB_GROUPES, le nombre d'opérations par tâches avant la première opération de synchronisation dans un groupe de tâches est : NB_OP = ARRSUP[ TAILLE_D NB TACHES PAR GROUPE * NB GROUPES où ARRSUP est la fonction d'arrondi à l'entier supérieur. Comme indiqué plus bas, il sera vérifié que les tâches qui risquent de demander des données après l'indice maximal (TAILLE_D -1) du vecteur d'entrée seront bien sécurisées par des conditions. k est initialisé à la valeur 1. Dans une étape 102 réitérée pour chaque couple NBk = (NB_TACHES_PAR GROUPEk ; NB_GROUPESk) k = 1 à K, le code logiciel CODE_MASTk correspondant au couple NBk et destiné au processeur maître 4, est généré dans une sous-étape 102_1 et le code logiciel CODE_ELEMk correspondant au couple NBk et destiné à chacun des processeurs élémentaires 9 est généré dans une sous-étape 102_2. Dans la sous-étape 102_1, l'outil de génération 2 génère le code CODE_MASTk qui met en oeuvre les instructions suivantes : 1- Ecrire dans la mémoire du processeur maître 4 le vecteur de test tel qu'initialisé dans le paramètre P7 du fichier de configuration P. 2- Transférer dans la mémoire globale 10 de l'accélérateur matériel 5 les données du jeu D de données d'entrée présents dans la mémoire du processeur maître 4. 3- Lancer la phase (ou kernel) (p1 de calcul (dont la définition est donnée plus bas) sur les M tuiles et attendre jusqu'à la fin de cette phase de calcul. Ceci lance en parallèle NB_TACHES_PAR_GROUPEk* NB_GROUPESk tâches. 4- Si NB_GROUPESk >1, lancer la phase (ou kernel) (p2 de calcul (dont la définition est donnée plus bas) sur une tuile qui comprend (NB_GROUPEk + NB_GROUPEk%2)/2 tâches, où % représente l'opération « Modulo ». 5- Rapatrier la donnée de sortie résultant de la phase (p2 dans la mémoire propre au processeur maître 4 ; 6- Ecrire le code de vérification issu du fichier de configuration P, ce qui permet avec l'instruction 1 de valider que les codes générés CODE_MASTk et CODE_ELEMk effectuent bien la fonction associative f considérée sur un jeu de données exemple d'entrée de taille TAILLE_D et de type indiqué dans le fichier de configuration P.

Dans la sous-étape 102_2, l'outil de génération 2 génère le code CODE_ELEMk pour chacune de deux phases successives cp1 et cp2 (chacune des phases correspond à un kernel). Le code CODE_ELEMk sera mis en oeuvre par chaque tâche de la phase concernée avec des données d'entrée différentes.

Ainsi pour la phase 91, les données d'entrée des différentes tâches exécutant chacune CODE_ELEMk sont des données du jeu de données d'entrée d'indices différents. Pour la phase (p2, où il y a un seul groupe , les données d'entrée sont les résultats issus de chaque groupe de la phase (pi. Les tâches sont identifiées par : - leur groupe de tâches, que l'on notera A ci-dessous et sur la figure 5, avec A variant de 0 à NB_GROUPES -1, avec NB_GROUPES = NB_GROUPESk pour une tâche de la phase cp1 et NB_GROUPES = 1 pour une tâche de la phase cp2 ; et par - leur position dans le groupe de tâches, que l'on notera B ci-dessous et sur la figure 5, avec B variant de 0 à NB_TACHES_PAR GROUPE -1, avec NB_TACHES_PAR GROUPE = NB_TACHES_PAR GROUPEk pour une tâche de la phase p1 et NB_TACHES_PAR GROUPE = (NB_GROUPEk + NB_GROUPEk%2)/2 pour une tâche de la phase p2. On notera C = A* NB_TACHES_PAR GROUPE* (NB_OP+1) le décalage initial dans les données ordonnées d'entrée de la phase pour le groupe considéré (ces données d'entrée étant le jeu de données D pour la phase 1, et, pour la phase 2, ces données d'entrée étant les sorties des différents groupes de la phase (p1 ordonnées selon l'ordre des indices de ces groupes). NB OP est calculé selon la formule indiquée plus haut en prenant TAILLE = TAILLE_D pour la phase cpi. Pour la phase cp2, on fixe NB_OP=1.

Le code CODE_ELEMk est généré tel qu'il met en oeuvre les instructions suivantes. Le code en gras correspond à la logique de génération.. 1- Réaliser le prologue indiqué dans le fichier de configuration P sur la donnée C+B. Stocker ce résultat noté TEMPB dans la mémoire privée 11 associée à la tâche considérée de groupe A et position B ; 2- = 1 ; 3- Tant que I 5 NB_OP : 3.1- si C + i*NB_TACHES_PAR_GROUPE + B dépasse la taille des données d'entrée, passer directement à 4; 3.2- prendre la donnée d'entrée d'indice C + i*NB_TACHES_PAR_GROUPE + B, lui appliquer le prologue (le résultat est nommé TEMP2B), puis appliquer la fonction associative f : TEMPB = f(TEMPB, TEMP2B) ; 3.3- i = i+1 4- Commentaires : une fois à ce stade, toutes les données d'entrée assignées au groupe de tâches ont été utilisées. Il s'agit maintenant de regrouper les résultats issus des différentes tâches du même groupe. Soit Dz la première puissance de deux supérieure ou égale à NB_TACHES_PAR_GROUPE. Tant que Dz > 1 : 4.1- si B kDz./2 et B < NB_TACHES_PAR_GROUPE, stocker TEMPB en mémoire locale et synchroniser les tâches du groupe ; 4.2 sinon si B < Dz/2 et si B+Dz/2 < NB_TACHES_PAR_GROUPE : appliquer la fonction f à TEMPB et TEMP B+Dzi2, stocké juste avant en mémoire locale par une autre tâche 4.3 Sinon, ne rien faire. 4.4- Dz = Dz/2 et retour au début de l'étape 4. 5- Commentaire : fin de la phase ; seule la première tâche du groupe A a réalisé la dernière opération. Placer ce résultat en mémoire globale 10 en vue de préparer les données d'entrée de la phase cp2 si on était jusqu'alors en phase cpi ou de rapatrier le résultat en mémoire du processeur maître 4 si non.

A noter que dans un mode de réalisation, il n'est pas nécessaire de dérouler la boucle de l'étape 3 mentionnée ci-dessus pour le code CODE_ELEMk. Il convient à la place de créer dans le code généré une boucle avec l'indice i.

Les codes générés sont particulièrement performants. En effet, l'accès mémoire est optimal, les accès mémoire sont générés de manière à ce que les processeurs élémentaires d'un même groupe accèdent à des données collées en mémoire globale 10 (stratégie nommée « coalescing »), permettant ainsi d'utiliser la bande passante entre la mémoire et les processeurs de façon maximale.

Les synchronisations sont minimales : il n'est pas possible de réaliser moins de synchronisations que celles générées. Chaque tâche réalise un maximum d'opérations. Afin de minimiser le coût temporel dû à la mise en place des calculs, chaque tâche élémentaire contient un maximum d'opérations à réaliser (cf. formule de NB_OP qui indique le nombre d'opérations avant synchronisation. Ce nombre est noté en dur dans le code généré et est fonction de la taille du jeu de données d'entrée D. Un code expert réaliserait peut-être plusieurs opérations par tâche mais pas l'optimum : le code serait alors dépendant de la taille du vecteur donc non portable. A contrario, selon l'invention, la portabilité est assurée par l'outil de génération 2 : il est immédiat de générer un nouveau code pour une nouvelle taille de vecteur. Dans une étape 103, on compare k à K. Si k5 K, dans une étape 104, on incrémente k : k = k+1 et on réitère l'étape 102. Si non, dans une étape 105, les codes CODE_MASTk et CODE_ELEMk sont exécutés sur le système cible 3, successivement pour k = 1 à K. Et leurs performances en termes de rapidité de traitement notamment sont comparées. Soit kopt l'indice correspondant aux codes fournissant les meilleures performances, les codes CODE MASTkopt et CODE ELEMkopt sont retenus pour mise en oeuvre opérationnelle sur le système cible 3.

La figure 5 illustre un graphe de code parallèle tel que généré par l'outil de génération 2 pour un jeu de données d'entrée D de taille TAILLE_D = 42 et une fonction associative. Cette valeur de taille, très inférieure aux tailles réelles usuelles, a été retenue à des fins d'illustration. La phase cp1 comporte 4 groupes (les groupes n°A, avec A = 0, 1, 2, 3).

Chacun de ces groupes comprend 4 tâches, numérotées B avec B = 0, 1, 2, 3.

Les tâches des deux premiers groupes ont été chacune repérées par un trait vertical tracé en gras. La phase cp2 comporte un groupe, comportant 4 données d'entrée. Ces données d'entrée sont les données de sortie des 4 groupes exécutés en parallèle lors de la phase cp 1 . Les carrés représentent les zones mémoires dans lesquelles les données respectives sont stockées. Les carrés hachurés figurent des zones mémoire en mémoire locale (i.e. partagée par les tâches d'une même tuile). Les autres carrés figurent des zones mémoire en mémoire globale. Les carrés présentant un remplissage identique parmi zéro remplissage, hachures, points correspondent à des zones mémoires lues /écrites au même moment. Chaque triangle « op » représente l'application de la fonction associative sur les éléments issus des données qui lui sont fournies en entrée. Les données du jeu de données initial D sont stockées en mémoire globale.

Les données intermédiaires sont stockées dans des registres des processeurs élémentaires. La mémoire locale n'est utilisée que lors de la synchronisation entre les tâches d'un même groupe de tâches. La spécificité de l'implémentation selon l'invention est de faire calculer le maximum de données par tâche. Le code illustré en figure 5 traite ainsi trois données issues du jeu initial D avant que la première synchronisation n'ait lieu. Une synchronisation est représentée par une barre horizontale référencée « sync ». On notera que pour un jeu de données initial de taille usuelle, chaque tâche traitera plus de 100 données initiales avant la première synchronisation.

S'il y a un risque que la donnée n'existe pas (le code généré se base sur un nombre de points d'entrée potentiellement supérieur au nombre nécessaire, afin que la valeur admette les bons diviseurs), l'opération n'est exécutée que sur condition. Bien que cela ne soit pas obligatoire, il est probable que les données d'entrée d'indice voisin dans le jeu de données D soient voisines en mémoire globale. Lors de la récupération des données, le choix du pas i*NB_TACHES_PAR_GROUPE permet de récupérer au même instant des données voisines et ainsi de profiter d'une bande passante proche du maximum théorique. Les données en mémoire globale ne sont chargées qu'une seule fois. Il est nécessaire d'avoir au moins autant de groupes de tâches que de tuiles pour obtenir une performance maximale. Les groupes de tâches ne pouvant communiquer directement entre eux, leur résultat est stocké en mémoire globale à l'issue de la phase (pl, puis récupéré dans la phase (p2. La phase (p2 est identique à la phase (p1, mais avec un seul groupe de tâches et avec un nombre de données d'entrée égal au nombre de groupes de tâches de la phase (pl. Le résultat de la phase (p2 est stocké en mémoire globale. Pour un jeu de données initial de petite taille, une seule étape (pl avec un seul groupe de tâches peut permettre d'obtenir la meilleure performance. On notera que lorsque les données intermédiaires ne sont pas scalaires, mais sont des tableaux (par exemple un tableau de 256*32 bits pour un histogramme 8 bits), il est possible de stocker les résultats intermédiaires uniquement en mémoire locale (ou en mémoire globale, mais dans ce cas, les performances ne sont pas optimales). Le ratio de performance obtenu entre un code généré selon l'invention et une fonction de bibliothèque NPP est environ de 15 pour une fonction de type minmax sur des jeux de données d'entrée de taille comprise entre 5000 et 100000, et est entre 15 et 40 pour une fonction de type histogramme 8 bits sur des jeux de données d'entrée de taille jusqu'à au moins 106.

Claims (17)

1. REVENDICATIONS1.- Procédé de génération d'un code logiciel (Cops) pour la parallélisation d'une fonction associative à appliquer sur un jeu (D) de données d'entrée par un système cible (3) comprenant au moins une unité matérielle (6) comportant une pluralité de processeurs élémentaires (9), ledit procédé étant caractérisé en ce qu'il comprend les étapes suivantes mises en oeuvre par ordinateur : - réception de la définition de la fonction associative, et de la taille du jeu ; - détermination d'au moins un couple indiquant un nombre de groupes de tâches à exécuter par unité matérielle et un nombre de tâches par groupe de tâches ; - une application logicielle de génération étant adaptée pour générer les instructions suivantes d'un programme logiciel pour chacune desdites tâches à exécuter en parallèle à partir d'un sous-jeu du jeu de données respectivement associé à chaque tâche : - appliquer la fonction associative à deux éléments chacun issu d'une donnée distincte du sous-jeu respectif, puis tant que toutes les données d'entrée du sous- jeu associé à la tâche n'ont pas été prises en compte, appliquer itérativement la fonction associative à un nouvel élément issu d'une nouvelle donnée d'entrée du sous-jeu respectif et au résultat de la précédente application par le programme logiciel de la fonction associative; - puis, seulement, synchroniser les tâches du même groupe de tâches que la tâche considérée.
2. 2.- Procédé de génération d'un code logiciel (Copt) selon la revendication 1, selon lequel chaque processeur élémentaire (9) comporte une mémoire privée (11) accessible uniquement par une tâche exécutée par ledit processeur élémentaire, selon lequel ledit programme logiciel commun est adapté pour stocker les résultats des applications de la fonction associative uniquement dans la mémoire privée accessible par la tâche considérée tant que l'application de l'opération n'est pas l'application de l'opération précédant immédiatement l'étape de synchronisation des tâches.
3. 3.- Procédé de génération d'un code logiciel (Cops) selon la revendication 2, selon lequel chaque unité matérielle (6) comprend une mémoire locale (7) partagée exclusivement par les processeurs élémentaires d'une même unité matérielle et selon lequel les tâches d'un groupe de tâches sont partagées en un premier sous-groupe et un deuxième sous- groupe, ledit programme logiciel étant adapté pour, lorsque l'application de l'opération estl'application de l'opération précédant immédiatement l'étape de synchronisation des tâches : - si la tâche considérée fait partie du premier sous-groupe, stocker le résultat de ladite application de la fonction associative dans la mémoire privée accessible par la tâche considérée ; - si la tâche considérée fait partie du deuxième sous-groupe, stocker le résultat de ladite application de la fonction associative dans la mémoire locale de l'unité matérielle de la tâche considérée.
4. 4. Procédé de génération d'un code logiciel (C.pt) selon la revendication 3, selon lequel chaque processeur élémentaire (9) comporte une mémoire privée (11) accessible uniquement par une tâche exécutée par ledit processeur élémentaire et selon lequel l'application de génération est adaptée pour mettre en oeuvre itérativement l'ensemble d'étapes a/ et b/ suivant, avec Dz initialement pris égal à la première puissance de 2 supérieure ou égale au nombre de tâches par groupe de tâches : a/ tant que Dz> 1, générer les instructions suivantes pour le programme logiciel : i/ si la tâche fait partie du deuxième sous-groupe : ne plus rien faire ; ii/ si la tâche fait partie du premier sous-groupe : une desdites moitiés des tâches du premier sous-groupe devient le premier sous-groupe et l'autre desdites moitiés devient le deuxième sous-groupe ; et iii/ si la tâche fait partie du deuxième sous-groupe : stocker le résultat de ladite application de la fonction associative dans la mémoire locale de l'unité matérielle de la tâche considérée ; iv / à réaliser après ii/ et iii/ : synchronisation des tâches du groupe de tâches ; v/ à réaliser après iv/ si la tâche fait partie du premier sous-groupe : appliquer la fonction associative au dernier résultat d'application de la fonction stocké dans la mémoire privée accessible par la tâche considérée et à un résultat stocké dans la mémoire locale par une tâche du deuxième sous-groupe, s'il existe ; et stocker le résultat de ladite application de la fonction associative dans la mémoire privée accessible par la tâche considérée ; b/ Dz=Dz/2.
5. 5.- Procédé de génération d'un code logiciel (C0) selon l'une des revendications précédentes, selon lequel chaque processeur élémentaire (9) comporte une mémoire privée (11) accessible uniquement par une tâche exécutée par ledit processeur élémentaire et selon lequel l'application logicielle est adaptée pour mettre en oeuvre lesétapes suivantes, pour une tâche de rang respectif donné B dans le groupe de tâches, B prenant une valeur variant entre 0 et ledit nombre de tâches par groupe moins 1, un numéro respectif A étant affecté audit groupe, A prenant une valeur variant de 0 jusqu'audit nombre de groupes de tâches déterminé moins 1 ; - i = 0 ; - générer, dans le programme logiciel pour la tâche considérée, les instructions de : - stocker un élément issu de la (A*NB_TACHES_PAR_GROUPE + B)ième donnée du jeu de données d'entrée dans la mémoire privée ; - appliquer la fonction associative audit élément stocké dans la mémoire privée et à un élément issu de la (A*NB_TACHES_PAR_GROUPE + i* NB TACHES_PAR_GROUPE +B)ième donnée du jeu de données d'entrée et stocker le résultat dans la mémoire privée ; - incrémenter i.
6. 6.- Procédé selon l'une des revendications précédentes, comprenant en outre les étapes selon lesquelles : - une pluralité de couples indiquant un nombre de groupes de tâches à exécuter par unité matérielle (6) et un nombre de tâches par groupe de tâche est déterminée ; - un programme logiciel est généré pour chaque couple ; - les performances des programmes logiciels générés issues de l'exécution de ces programmes logiciels sur le système cible sont comparées ; - un programme logiciel parmi lesdits programmes logiciels est sélectionné en fonction de ladite comparaison.
7. 7.- Procédé selon l'une des revendications précédentes, selon lequel dans chaque couple, le nombre de tâches par groupe est déterminé comme multiple entier du nombre de processeurs élémentaires (9) par unité matérielle et le nombre de groupe de tâches est déterminé comme multiple entier du nombre d'unités matérielles (6).
8. 8.- Procédé selon l'une quelconque des revendications précédentes, selon lequel un desdits éléments issus d'une donnée distincte du sous-jeu respectif et auxquels la fonction associative est appliquée, est déterminé par application d'une fonction de prologue à une donnée du jeu des données d'entrée conçue pour adapter la dimension de la donnée d'entrée à la dimension de l'ensemble de départ de la fonction associative.35
9. 9.- Programme d'ordinateur à installer dans un outil de génération (2) d'un code logiciel (Colot) pour la parallélisation d'une fonction associative à appliquer sur un jeu (D) de données d'entrée par un système cible (3) comprenant au moins une unité matérielle (6) comportant une pluralité de processeurs élémentaires (9), ledit programme comportant des instructions pour mettre en oeuvre les étapes d'un procédé selon l'une des revendications 1 à 8 lors d'une exécution du programme par des moyens de traitement de l'outil de génération d'un code logiciel.
10. 10.- Outil de génération (2) d'un code logiciel (Colot) pour la parallélisation d'une fonction associative à appliquer sur un jeu (D) de données d'entrée par un système cible (3) comprenant au moins une unité matérielle (6) comportant une pluralité de processeurs élémentaires (9), ledit outil étant adapté pour recevoir la définition de la fonction associative et de la taille du jeu et pour déterminer au moins un couple indiquant un nombre de groupes de tâches à exécuter par unité matérielle et un nombre de tâches par groupe de tâches ; ledit outil de génération d'un code logiciel comprenant en outre une application logicielle de génération adaptée pour générer les instructions suivantes d'un programme logiciel pour chacune desdites tâches à exécuter en parallèle à partir d'un sous-jeu du jeu de données respectivement associé à chaque tâche : - appliquer la fonction associative à deux éléments chacun issu d'une donnée distincte du sous-jeu respectif, puis tant que toutes les données d'entrée du sous-jeu associé à la tâche n'ont pas été prises en compte, appliquer itérativement la fonction associative à un nouvel élément issu d'une nouvelle donnée d'entrée du sous-jeu respectif et au résultat de la précédente application par le programme logiciel de la fonction associative; - puis, seulement, synchroniser les tâches du même groupe de tâches que la tâche considérée.
11. 11.- Outil de génération (2) d'un code logiciel (Colot) selon la revendication 10, chaque processeur élémentaire (9) comportant une mémoire privée (11) accessible uniquement par une tâche exécutée par ledit processeur élémentaire, dans lequel l'application logicielle de génération est adaptée pour générer ledit programme logiciel commun tel que ledit programme logiciel commun stocke les résultats des applications de la fonction associative uniquement dans la mémoire privée accessible par la tâche considérée tant que l'application de l'opération n'est pas l'application de l'opération précédant immédiatement l'étape de synchronisation des tâches.
12. 12.- Outil de génération (2) d'un code logiciel (Cops) selon la revendication 11, chaque unité matérielle (6) comprenant une mémoire locale (7) partagée exclusivement par les processeurs élémentaires (9) d'une même unité matérielle ; dans lequel l'application logicielle de génération est adaptée pour générer les instructions suivantes d'un programme logiciel dans lequel les tâches d'un groupe de tâches sont partagées en un premier sous-groupe et un deuxième sous-groupe, et tel que ledit programme logiciel étant adapté pour, lorsque l'application de l'opération est l'application de l'opération précédant immédiatement l'étape de synchronisation des tâches : - si la tâche considérée fait partie du premier sous-groupe, stocker le résultat de ladite application de la fonction associative dans la mémoire privée accessible par la tâche considérée ; - si la tâche considérée fait partie du deuxième sous-groupe, stocker le résultat de ladite application de la fonction associative dans la mémoire locale de l'unité matérielle de la tâche considérée.
13. 13. Outil de génération (2) d'un code logiciel (C00) selon la revendication 12, chaque processeur élémentaire (9) comportant une mémoire privée (11) accessible uniquement par une tâche exécutée par ledit processeur élémentaire et dans lequel l'application de génération est adaptée pour mettre en oeuvre itérativement l'ensemble d'étapes a/ et b/ suivant, avec Dz initialement pris égal à la première puissance de 2 supérieure ou égale au nombre de tâches par groupe de tâches : a/ tant que Dz> 1, générer les instructions suivantes pour le programme logiciel : i/ si la tâche fait partie du deuxième sous-groupe : ne plus rien faire ; ii/ si la tâche fait partie du premier sous-groupe : une desdites moitiés des tâches du premier sous-groupe devient le premier sous-groupe et l'autre desdites moitiés devient le deuxième sous-groupe ; et iii/ si la tâche fait partie du deuxième sous-groupe : stocker le résultat de ladite application de la fonction associative dans la mémoire locale de l'unité matérielle de la tâche considérée ; iv / à réaliser après ii/ et iii/ : synchronisation des tâches du groupe de tâches ; v/ à réaliser après iv/ si la tâche fait partie du premier sous-groupe : appliquer la fonction associative au dernier résultat d'application de la fonction stocké dans la mémoire privée accessible par la tâche considérée et à un résultat stocké dans la mémoire locale par une tâche du deuxième sous-groupe, s'il existe ; et stocker lerésultat de ladite application de la fonction associative dans la mémoire privée accessible par la tâche considérée ; b/ Dz=Dz/2.
14. 14.- Outil de génération (2) d'un code logiciel (C0p1) selon l'une des revendications 10 à 13, chaque processeur élémentaire (9) comportant une mémoire privée (11) accessible uniquement par une tâche exécutée par ledit processeur élémentaire, dans lequel l'application logicielle est adaptée pour mettre en oeuvre les étapes suivantes, pour une tâche de rang respectif donné B dans le groupe de tâches, B prenant une valeur variant entre 0 et ledit nombre de tâches par groupe moins 1, un numéro respectif A étant affecté audit groupe, A prenant une valeur variant de 0 jusqu'audit nombre de groupes de tâches déterminé moins 1 ; - i = 0 ; - générer, dans le programme logiciel pour la tâche considérée, les instructions de : - stocker un élément issu de la (A*NB_TACHES_PAR_GROUPE + B)ième donnée du jeu de données d'entrée dans la mémoire privée ; - appliquer la fonction associative audit élément stocké dans la mémoire privée et à un élément issu de la (A*NB_TACHES_PAR_GROUPE + i* NB_TACHES_PAR_GROUPE +B)Ième donnée du jeu de données d'entrée et stocker le résultat dans la mémoire privée ; - incrémenter i.
15. 15.- Outil de génération (2) d'un code logiciel (C00) selon l'une des revendications 10 à 14, adapté pour déterminer une pluralité de couples indiquant un nombre de groupes de tâches à exécuter par unité matérielle (6) et un nombre de tâches par groupe de tâche et dans lequel l'application logicielle de génération est adaptée pour générer un programme logiciel pour chaque couple ; l'outil de génération étant adapté pour comparer les performances des programmes logiciels générés issues de l'exécution de ces programmes logiciels sur le système cible en vue d'une sélection d'un programme logiciel parmi lesdits programmes logiciels en fonction de ladite comparaison.
16. 16.- Outil de génération d'un code logiciel (C00) selon l'une des revendications 10 à 15, adapté pour déterminer, dans chaque couple, le nombre de tâches par groupe comme multiple entier du nombre de processeurs élémentaires (9) par unité matérielle (6) et le nombre de groupe de tâches comme multiple entier du nombre d'unités matérielles.
17. 17.- Outil de génération d'un code logiciel (C0) selon l'une quelconque des revendications 10 à 16, dans lequel l'application logicielle de génération est adaptée pour déterminer un desdits éléments issus d'une donnée distincte du sous-jeu respectif et auxquels la fonction associative est appliquée, par application d'une fonction de prologue à une donnée du jeu des données d'entrée conçue pour adapter la dimension de la donnée d'entrée à la dimension de l'ensemble de départ de la fonction associative.