Architectures de calcul

classification. Bien qu’ils soient relativement g´en´eriques, les mod`eles de programmation parall`ele sont li´es aux architectures de calcul. En effet, la mani`ere dont on parall´elise un algorithme d´ependra du type de parall´elisme support´e par le hardware. Ainsi il est n´ecessaire de connaitre sa topologie avant de r´ealiser le portage de l’algorithme. Dans ce cadre, la classification de Flynn, d´ecrite `a la table 1.1, permet de caract´eriser les architectures en fonction des flots de donn´ees et de contrˆole.

Table 1.1: Classification de Flynn.

instructions single multi single SISD MISD data multi SIMD MIMD

Dans cette taxonomie,SISDcorrespond aux machines s´equentiels : une seule instructionest ex´ecut´ee sur une seule donn´ee, `a tout instant. D’un autre cˆot´e, une machineMISD(tr`es rare) permet l’ex´ecution de plusieurs instructionssurune mˆeme donn´ee, et est utilis´e dans certains ´equipements critiques. Par ailleurs, une machine SIMDpermet l’ex´ecution d’une mˆeme instruction sur plusieurs donn´ees simul-tan´ement (par pipelining ou vectorisation). Enfin,MIMDcorrespond aux machines multi-processeurs : chaque processeur peut ex´ecuter des instructions diff´erentes sur des donn´ees diff´erentes. Ces machines peuvent ˆetre class´ees selon leur topologie m´emoire ainsi que leur espace d’adressage qui peuvent ˆetre (virtuellement) partag´es ou distribu´es.

c2018.HOBYRAKOTOARIVELO

m´emoire. Dans notre cas, nos architectures cibles correspondent aux machines MIMD `a plusieurs cores et `a m´emoire partag´ee (multicore, manycore ou gpu). Ainsi l’espace d’adressage virtuel est commun `a tous les cores, ce qui est adapt´e pour du multithreading. Selon le mode d’acc`es-m´emoire support´e par ces machines, on distingue trois classes d’architectures : COMA (m´emoire locale se comportant comme un cache, pas de replication de donn´ees en cas d’acc`es distants),UMA(uniforme), cc-NUMA(non uniforme avec protocole de coh´erence de caches). Ici, laRAMpeut ˆetre physiquement ou virtuellement partag´ee par le biais d’unDSM¹¹. Les threads communiquent par le biais de variables globales ou segments de m´emoire partag´ee, tandis que les processus peuvent communiquer directement via un protocoleRDMA¹². Dans les deux cas, la consistance des donn´ees doit ˆetre g´er´ee explicitement.

Ici, le coˆut des acc`es de donn´ees sont relatives `a la latence m´emoire qui peut ˆetre uniforme dans le cas des machinesUMA, ou in´egale dans le cas des machinesNUMA.

caches. Afin de r´eduire le coˆut des acc`es-m´emoire, les machines multicore ou manycore r´ecents int`egrent plusieurs niveaux de caches (deux ou trois en g´en´eral). Ce sont des m´emoires interm´ediaires entre leCPUet la RAM, avec une capacit´e et une latence nettement r´eduites compar´ees `a la RAM. `A cette fin, un cache fournit de mani`ere transparente les donn´ees qui ont ´et´e charg´ees dans un pass´e proche. Notons toutefois que les politiques de chargement et remplacement de blocs de donn´ees au sein d’un cache ob´eissent `a un principe dit delocalit´eau sens de la d´efinition17.

D´efinition 17 (localit´e).Le principe de localit´e stipule que les donn´ees d’un programme ne sont pas acc´ed´ees de mani`ere statistiquement uniforme. Il y a plusieurs types de localit´es dont :

• temporelle: les donn´ees r´ecemment acc´ed´ees seront tr`es probablement bientˆot r´eutilis´ees;

• spatiale: les donn´ees voisines seront tr`es probablement bientˆot acc´ed´ees.

Afin de r´eduire le coˆut des acc`es-m´emoire et obtenir un bon rendement d’utilisation des caches, il est donc n´ecessaire de structurer les instructions de l’algorithme de mani`ere `a maximiser la r´eutilisation de donn´ees et le r´ef´erencement de donn´ees voisines. Cela peut ˆetre fait par la renum´erotation de maillages ou de matrices creuses en calcul num´erique, des techniques decache blocking, ou encore le prefetching. Notons toutefois que n’est pas toujours possible si les acc`es-m´emoire sont non pr´edictibles.

Listing (1.1) sans blocking 1 for(i=0; i < N; i++)

2 for(j=0; j < N; j++) 3 for(k=0; k < N; k++) 4 C[i,j] = A[i,k]*B[k,j]

Listing (1.2) avec blocking 1 for(ii=0; ii < N; i+=R)

2 for(jj=0; jj < N; j+=R) 3 for(k=0; k < N; k++)

4 for(i=ii; i < min(ii+R,N); i++) 5 for(j=jj; j < min(jj+R,N); j++) 6 C[i,j] = A[i,k]*B[k,j]

Figure 1.13: Multiplication matricielle efficace en cache[Intel].

exemple. Un cas concret de restructuration d’instructions par cache-blocking est donn´e `a la figure 1.13pour la multiplication de matrices denses (de tailleN). Il consiste `a d´ecouper les deux matrices carr´ees enmblocs de tailleR, avecRla taille d’une ligne de cache de la machine cible. Pour chaque

11DSMpourDistributed-Shared Memory: couche logicielle permettant d’´emuler un espace d’adressage global sur un machine `a m´emoire distribu´ee.

12RDMA pourRemote Direct Memory Access : protocole r´eseau permettant un acc`es direct des processus `a une m´emoire distante (z´ero copie), sans intervention ducpuou du noyau.

c2018.HOBYRAKOTOARIVELO

30 1.2. Notions de parall´elisme

ligne d’une matrice, le fait d’it´erer sur les Ncolonnes va induire un nombre important de d´efaut de cache. En effet celui-ci va syst´ematiquement ˆetre purg´e dans ce cas. Par contre, on va mieux r´eutiliser les coefficients de chaque matrice en organisant le calcul par bloc. Notons que cela est possible car on sait exactement quelle donn´ee on va acc´eder `a un instantt de l’ex´ecution : ici les motifs d’acc`es-m´emoire sont pr´evisibles. Ce n’est malheureusement pas le cas pour nos noyaux de remaillage.

multithreading. Nos architectures cibles int`egrent une forme de parall´elisme tr`es fin au niveau des instructions d’un core du processeur. Rappelons qu’une instruction est trait´ee en plusieurs phases (fetch,decode,memaccess,execute,writeetc.) par lecpu. Au sein d’un core d’uncpusuperscalaire¹³, on dispose d’un pipeline d’instructions qui permet de traiter chaque phase sur plusieurs instructions en mˆeme temps¹⁴. Dans ce type de core, un cycle¹⁵ peut comporter des p´eriodes d’inactivit´es (ou bulles) dans le pipeline, dˆues `a des facteurs divers comme les d´ependances d’instructions, une mau-vaise pr´ediction de branchements, ou encore la latence due `a un acc`es-m´emoire. Une mani`ere d’y rem´edier consiste `a permettre plusieurs threads d’utiliser ces slots inoccup´es. Notons n´eanmoins que remplir efficacement le pipeline est un probl`eme r´eellement complexe car on doit g´erer les d´ependances d’instructions de plusieurs threads cette fois.

Selon la mani`ere dont on remplit ces bulles, on dispose de plusieurs niveaux de parall´elisme d´ecrits

`

a la figure1.14. En(1)les unit´es fonctionnelles (ALU, FPU, etc.) sont r´eserv´ees `a un seul thread, tandis qu’en(2)elles sont disponibles `a plusieurs threads mais sur des blocs de cyclescpu distincts. En(3), ces unit´es sont disponibles `a plusieurs threads sur des cyclescpudiff´erents (pas forc´ement des blocs), tandis qu’en(4)elles peuvent carr´ement ˆetre allou´ees `a plusieurs threads sur le mˆeme cyclecpu.

cycles

phases sequential

(1)

phases coarse-grained

(2)

phases fine-grained

(3)

phases simultaneous

(4)

thread 1 thread 2 thread 3

Figure 1.14: Pipeline d’instructions d’un core d’un processeur superscalaire et multithreading.

D´efinition 18 (simultaneous multithreading).Il s’agit d’une forme de parall´elisme au niveau des instructions d’un core d’un processeur superscalaire. Il d´esigne le fait de partager les ressources du core (unit´es de calcul et caches)entre plusieurs threads sur un mˆeme cycle cpu.

Ainsi, il permet de r´eduire lesbulles horizontales^aetverticales^bau sein du pipeline d’instructions.

aOn a une bullehorizontalequand un slot d´edi´e `a une phase n’est pas occup´e pour un cyclecpudonn´e.

bOn a une bulleverticaledans le pipeline quand lecpune peut traiter aucune instruction dans un cycle entier

Le recours auSIMULTANEOUS MULTITHREADING(ouhyperthreadingsur les pucesintel, cf. d´efinition18) permet de remplir les slots inoccup´es du pipeline (dues `a un acc`es-m´emoire ou l’attente d’un r´esultat

13Il s’agit d’un core de processeur permettant l’ex´ecution de plusieurs instructions simultan´ement grˆace `a un pipeline, et capable de d´etecter les d´ependances d’instructions.

14Pour faire simple, on peut faire unfetchsur plusieurs instructions sur un mˆeme cyclecpu. N´eanmoins, on ne peut pas faire unfetchet undecodesimultan´ement sur une mˆeme instruction

15Un cycle correspond `a la terminaison de toutes les phases de traitement d’une instruction par lecpu:fetch,decode, memaccess,execute,writeetc.

c2018.HOBYRAKOTOARIVELO

d’une instruction pr´ec´edente par exemple) en permettant `a d’autres threads d’exploiter les unit´es fonctionnelles du core (ALU, FPU etc.). Ainsi il permet de masquer les p´enalit´es li´es `a la latence, ce qui est tr`es int´eressant pour les processeurs manycore `a large bande-passante mais `a forte latence m´emoire. Notons n´eanmoins que le gain de performances qu’il procure n’est pas toujours garanti. En effet, comme chaque thread doit charger ses propres donn´ees, cela peut entrainer une perte de localit´e en cache (voir d´efinition17), ainsi qu’une forte contention et/ou une saturation du cache partag´e. Par cons´equent, cela peut engendrer un nombre plus important de d´efauts de cache qu’en s´equentiel.