Architectures vectorielles

Architectures vectorielles
Architecture des microprocesseurs – GIF-3000
Professeur : Christian Gagné
Semaine 10 : 6 novembre 2012
GIF-3000 (U. Laval)
Architectures vectorielles
C. Gagné
1 / 43
Partie I
SIMD
GIF-3000 (U. Laval)
Architectures vectorielles
C. Gagné
2 / 43
Rappel : taxonomie de Flynn (1966)
Single Instruction, Single Data stream (SISD) : ordinateurs à un
processeur
Single Instruction, Multiple Data stream (SIMD) : la même
instruction est exécutée sur plusieurs processeurs, permettant ainsi un
parallélisme de données
I
Correspond aux architectures vectorielles et aux GPU
Multiple Instruction, Single Data stream (MISD) : aucun ordinateur
commercial basé sur cette organisation n’a été construit jusqu’à
présent
Multiple Instruction, Multiple Data stream (MIMD) : chaque
processeur exécute ses instructions propres sur des données
différentes, ce qui permet un parallélisme de tâches
I
Correspond aux architectures multi-cœurs, SMP, grappes de calcul,
supercalculateurs, centres informatiques, etc.
GIF-3000 (U. Laval)
Architectures vectorielles
C. Gagné
3 / 43
Rappel : classes et approches de parallélisme
Classes de parallélismes
I
I
Parallélisme de données : plusieurs données peuvent être traitées
simultanément
Parallélisme de tâches : plusieurs tâches peuvent être traitées
indépendamment et largement en parallèle
Approches pour exploiter le parallélisme
I
I
I
I
Parallélisme d’instructions : exploite le parallélisme de données, à
l’aide du compilateur, d’un pipeline et d’une exécution spéculative
Architectures vectorielles et GPU : exploite le parallélisme de
données en appliquant une instruction à un ensemble de données
Parallélisme multifilaire : effectue du parallélisme à l’aide de matériel
permettant interaction étroite entre plusieurs fils d’exécution parallèles
Parallélisme de requêtes : permet un parallélisme par l’exécution de
tâches fortement découplées
GIF-3000 (U. Laval)
Architectures vectorielles
C. Gagné
4 / 43
Architectures SIMD pour parallélisme de données
Architectures SIMD idéales pour applications avec bonne densité de
parallélisme de données
I
I
Calcul matriciel dans les applications scientifiques
Applications multimédias pour traitement de l’image et du son
Meilleure efficacité énergétique avec SIMD que MIMD
I
I
Une instruction lancée pour traiter plusieurs données
Particulièrement pertinent avec dispositifs mobiles personnels
Architectures SIMD populaires
I
I
I
Architectures vectorielles
Instructions SIMD multimédias des processeurs modernes
Processeurs graphiques (GPU)
F
Pas couvert dans le cours
GIF-3000 (U. Laval)
Architectures vectorielles
C. Gagné
5 / 43
Gains avec architectures SIMD
Architectures MIMD (multi-cœurs) reçues beaucoup d’attention ces
dernières années
I
I
I
Essentiel des gains possibles avec le parallélisme d’instructions sont
maintenant acquis
Quantité de transistors disponibles sur les puces continue de croı̂tre
(Loi de Moore)
Ajouter des cœurs permet des gains en performance avec peu d’efforts
Cependant, système MIMD reste difficile à programmer
I
SIMD permet au programmeur de développer un programme séquentiel
Croissance des performances projetées dans la prochaine décennie
I
I
MIMD : deux cœurs de plus par puce à chaque 2 ans
SIMD : nombre de données traitées par instructions double à chaque 4
ans
Gain potentiel avec architectures SIMD est 2 fois plus important
qu’avec MIMD
GIF-3000 (U. Laval)
Architectures vectorielles
C. Gagné
6 / 43
Croissance du parallélisme projetée, processeurs x86
1000
MIMD*SIMD (32 b)
MIMD*SIMD (64 b)
SIMD (32 b)
SIMD (64 b)
Potential parallel speedup
MIMD
100
10
1
2003
GIF-3000 (U. Laval)
2007
2011
2015
Architectures vectorielles
2019
2023
C. Gagné
7 / 43
Partie II
Architectures vectorielles
GIF-3000 (U. Laval)
Architectures vectorielles
C. Gagné
8 / 43
Architectures vectorielles
Architectures vectorielles
I
I
I
Pipeline spécialisé pour application d’opérations sur plusieurs données
Chaque opération vectorielle peut traiter des dizaines de données à la
fois
Proposé il y a plus de 30 ans, utilisé dans les supercalculateurs
F
I
Jusqu’à récemment considéré comme trop coûteux pour les
microprocesseurs
Coûteux en nombre de transistors et en bande passante à la mémoire
Principe de fonctionnement
I
I
I
I
Lit de larges ensembles de données distribuées en mémoire
Place ces ensembles dans de grands registres séquentiels
Effectue des opérations sur ces registres séquentiels
Écrit les résultats en mémoire
Chaque opération traite un vecteur de données
I
I
Dizaines d’opérations registre-registre indépendantes
Permet l’amortissement de la latence des accès mémoire
GIF-3000 (U. Laval)
Architectures vectorielles
C. Gagné
9 / 43
Processeur VMIPS
Processeur VMIPS
I
I
I
Utilisé pour illustrer les propos, n’existe pas d’implantation réelle
Inspiré du Cray-1 (1976), un célèbre supercalculateur à architecture
vectorielle
Partie scalaire du jeux d’instructions correspond à MIPS
Composantes de VMIPS
I
I
I
I
Huit registres vectoriels, chacun contenant 64 valeurs représentées sur
64 bits
Cinq unités fonctionnelles, pleinement pipelinées
Unités de lecture/écriture vectorielles pleinement pipelinées
Registres scalaires de MIPS
GIF-3000 (U. Laval)
Architectures vectorielles
C. Gagné
10 / 43
Structure de l’architecture VMIPS
Main memory
Vector
load/store
FP add/subtract
FP multiply
FP divide
Vector
registers
Integer
Logical
Scalar
registers
GIF-3000 (U. Laval)
Architectures vectorielles
C. Gagné
11 / 43
Instructions VMIPS
Registres de VMIPS
I
I
Registres vectoriels : V0 à V7
Registre de la longueur du vecteur
F
I
Utilisé lorsque la taille naturelle des vecteurs n’est pas sur un multiple
de 64
Registre du masque du vecteur
F
Pour gérer efficacement les énoncés conditionnels
Instructions de VMIPS
I
I
I
Opérations vecteur-vecteur (suffixe VV)
Opérations vecteur-scalaire (suffixe VS)
Lecture et écriture de vecteurs (LV et SV)
GIF-3000 (U. Laval)
Architectures vectorielles
C. Gagné
12 / 43
Instructions vectorielles de VMIPS
GIF-3000 (U. Laval)
Architectures vectorielles
C. Gagné
13 / 43
Consommation énergétique et architectures vectorielles
Enjeux de la consommation énergétique
I
I
I
Puissance consommée est un enjeux important considérant limites du
refroidissement à l’air
Architectures avec exécution dans le désordre sont complexes et
énergivores
Comment obtenir hautes performances sans augmenter
significativement consommation énergétique ?
Architectures vectoriels répondent bien à cette tendance
I
I
Peut augmenter significativement la performance de processeurs
scalaires avec exécution dans l’ordre, sans augmenter énormément la
complexité et la consommation
Réimplantations vectorielles plus efficaces de programmes ayant déjà de
bonnes performances sur processeurs avec exécution dans le désordre
GIF-3000 (U. Laval)
Architectures vectorielles
C. Gagné
14 / 43
Attraits des architectures vectorielles
Flexibilité dans la conception de processeurs vectoriels
I
I
Traitements des éléments composant les vecteurs peuvent se faire de
différentes façons
Différents compromis entre performance et consommation énergétique
Indépendance des données formant un vecteur
I
I
Traitements fortement parallèles possibles, par duplication des unités
fonctionnelles
Ne requiert pas de vérification de dépendances par le matériel
Vecteurs peuvent traiter différentes configuration de tailles/nombre
d’éléments
I
I
64 données sur 64 bits, ou 128 données sur 32 bits, ou 256 données sur
16 bits, ou même 512 données sur 8 bits
Représentations sur nombre réduit de bits particulièrement
intéressantes pour applications multimédias
GIF-3000 (U. Laval)
Architectures vectorielles
C. Gagné
15 / 43
Exemple : DAXPY
DAXPY : Double precision a × X + Y
Code MIPS de DAXPY :
Loop:
L.D
DADDIU
L.D
MUL.D
L.D
ADD.D
S.D
DADDIU
DADDIU
DSUBU
BNEZ
F0,a
R4,Rx,#512
F2,0(Rx)
F2,F2,F0
F4,0(Ry)
F4,F4,F2
F4,0(Ry)
Rx,Rx,#8
Ry,Ry,#8
R20,R4,Rx
R20,Loop
Code VMIPS correspondant :
L.D
LV
MULVS.D
LV
ADDVV.D
SV
F0,a
V1,Rx
V2,V1,F0
V3,Ry
V4,V2,V3
V4,Ry
578 instructions MIPS exécutées vs 6 instructions avec VMIPS
I
Chaque instruction vectorielle de VMIPS prend cependant 64 cycles
GIF-3000 (U. Laval)
Architectures vectorielles
C. Gagné
16 / 43
Vectorialisation du code
Retrait des instructions de contrôle de la boucle avec VMIPS
I
4 instructions de contrôle sur les 9 de la boucle MIPS
Code vectorialisable : compilateur peut produire un programme
fonctionnant essentiellement en mode vectoriel
I
Code vectorialisable pour une boucle s’il n’y a pas de dépendance entre
les itérations
Blocage du pipeline réduit avec code vectoriel
I
I
Avec code MIPS, chaque S.D doit attendre après le ADD.D, qui doit
attendre après le MUL.D
Avec VMIPS, une seule attente sur le premier élément des vecteurs
F
I
I
Autres éléments des vecteurs suivent dans le pipeline
Appelé chaı̂nage dans les architectures vectorielles
Dans l’exemple, réduction de la fréquence des blocages d’un facteur
64×
Effet similaire au déroulement de boucles sur le blocage du pipeline
I
Sans le surcoût important sur le nombre d’instructions devant être
exécutées
GIF-3000 (U. Laval)
Architectures vectorielles
C. Gagné
17 / 43
Pipelines, convois et chaı̂nage
Architectures vectorielles modernes utilisent des pipelines parallèles
I
I
I
Chaque unité fonctionnelle peut donc traiter plusieurs éléments à
chaque cycle
Cependant, architectures modernes peuvent avoir des unités
fonctionnelles non-pipelinées
Pour la discussion, implantation VMIPS utilise un seul pipeline dans
chaque unité fonctionnelle
F
Temps d’exécution d’une instruction vectorielle correspond donc au
nombre d’éléments
Convoi : suite d’instructions vectorielles pouvant s’exécuter ensemble
I
I
I
Regroupe la suite d’instructions pouvant s’exécuter sans aléa structurel
Chaı̂nage permet d’intégrer plusieurs instructions dans un convoi même
avec dépendances RAW
Pour l’analyse, suppose que l’exécution d’un convoi est terminée avant
l’exécution d’autres instructions
Chaı̂nage fait de l’envoi de données entre les unités fonctionnelles
traitant un même convoi
I
Écriture simultanée possible à plusieurs éléments distincts d’un même
registre vecteur
GIF-3000 (U. Laval)
Architectures vectorielles
C. Gagné
18 / 43
Temps d’exécution d’instructions vectorielles
Chime (carillon) : temps d’exécution d’un convoi d’instructions
vectorielles
I
I
Une séquence d’instructions vectorielles formées de m convois prend
donc m chimes
Pour VMIPS, avec vecteur de n éléments, temps d’exécution de m
convois correspond approximativement à m × n cycles
Mesure en chime ne tient pas compte de certaines approximations
I
Ne tient pas compte du nombre d’instructions vectorielles pouvant être
lancées simultanément
F
I
La plupart des processeurs vectoriels permettent le lancement d’une
seule instruction vectorielle par cycle
Reste tout de même une bonne approximation avec de grands vecteurs
Temps de lancement est généralement négligeable relativement au
temps d’un chime
I
Cependant le temps de démarrage des pipelines d’unités fonctionnelles
vectorielles peut être significatif
GIF-3000 (U. Laval)
Architectures vectorielles
C. Gagné
19 / 43
Exemple d’estimation du temps d’exécution
LV
MULVS.D
LV
ADDVV.D
SV
V1,Rx
V2,V1,F0
V3,Ry
V4,V2,V3
V4,Ry
;
;
;
;
;
Lecture vecteur X
Multiplication vecteur-scalaire
Lecture vecteur Y
Addition des deux vecteurs
Écriture résultat dans Y
Combien de chimes cette séquence vectorielle prendra à s’exécuter ?
I
On suppose une seule copie de chaque unité fonctionnelle
Solution : la séquence comporte trois convois, donc prendra trois
chimes
1
2
3
LV V1,Rx
LV V3,Ry
SV V4,Ry
MULVS.D V2,V1,F0
ADDVV.D V4,V2,V3
Cette séquence prend donc une moyenne de 1,5 cycles par instruction
à virgule flottante, en ignorant les temps de lancement
I
Trois chimes pour deux instructions à VF (MULVS.D et ADDVV.D)
GIF-3000 (U. Laval)
Architectures vectorielles
C. Gagné
20 / 43
Partie III
Optimisation des architectures vectorielles
GIF-3000 (U. Laval)
Architectures vectorielles
C. Gagné
21 / 43
Questions d’optimisation pour architectures vectorielles
Comment traiter plus d’un élément par cycle ?
Comment traiter des vecteurs n’ayant pas la même taille que les
registres vecteurs ?
Comment gérer des énoncées conditionnels avec les opérations
vectorielles ?
Quels sont les besoins des opérations vectorielles relativement au
système de mémoire ?
De quelle façon gère-t’on les matrices multidimensionnelles avec ces
architectures ?
De quelle façon gère-t’on les matrices creuses (sparse matrices) ?
GIF-3000 (U. Laval)
Architectures vectorielles
C. Gagné
22 / 43
Couloirs d’exécution parallèles
Éléments formant un vecteur sont indépendants, donc aisément
parallélisables
I
I
I
Exécution dans des unités fonctionnelles fortement pipelinées
Exécution simultanée dans de multiples unités fonctionnelles (pas
pipelinées)
Exécution dans une combinaison d’UF avec pipelines parallèles et
pipelinées
Exploiter indépendance des éléments pour plusieurs instructions
I
I
I
Dans VMIPS, élément N d’un vecteur interagit qu’avec éléments à la
même position des autres vecteurs
Donc, on peut assigner couloir d’exécution pour chaque position
d’élément dans les vecteurs
Ces couloirs parallèles permettent d’augmenter significativement débit
des unités fonctionnelles
Réduit significativement nombre de cycles pour exécuter un chime
I
I
Avec 4 couloirs parallèles, vecteurs de 64 éléments prennent 16 cycles
Requiert cependant de longs vecteurs, sinon exécution trop rapide et
taux de lancement ne suivra pas
GIF-3000 (U. Laval)
Architectures vectorielles
C. Gagné
23 / 43
Couloirs d’exécution parallèles
Element group
(a)
GIF-3000 (U. Laval)
(b)
Architectures vectorielles
C. Gagné
24 / 43
Implantation des couloirs d’exécution parallèles
Composantes de chaque couloir d’exécution
I
I
Éléments des registres vecteurs associés au couloir
Un pipeline d’exécution pour chaque unité fonctionnelle
Indépendance des couloirs implique aucune communication entre eux
I
Donc pas de câblage complexe et de ports de registres pour
transmettre l’information entre eux
Possible d’exécuter 64 opérations par cycle !
I
2 ALU et 2 unités load/store dans 16 couloirs
Approche populaire pour augmenter la performance de processeurs
vectoriels
I
I
I
Augmentation faible de la complexité de contrôle
Pas de changement au jeu d’instructions
Permet de faire un compromis entre l’aire des dés, la fréquence
d’horloge, le voltage et l’énergie consommée, sans affecter la
performance
F
Couper de moitié la fréquence d’horloge et doubler le nombre de
couloirs résulte en la même performance
GIF-3000 (U. Laval)
Architectures vectorielles
C. Gagné
25 / 43
Implantation de quatre couloirs parallèles
Lane 0
FP add
pipe 0
Vector
registers:
elements
0, 4, 8, . . .
FP mul.
pipe 0
Lane 1
Lane 2
Lane 3
FP add
pipe 1
FP add
pipe 2
FP add
pipe 3
Vector
registers:
elements
1, 5, 9, . . .
Vector
registers:
elements
2, 6, 10, . . .
Vector
registers:
elements
3, 7, 11, . . .
FP mul.
pipe 2
FP mul.
pipe 3
FP mul.
pipe 1
Vector load-store unit
GIF-3000 (U. Laval)
Architectures vectorielles
C. Gagné
26 / 43
Taille variable des vecteurs
Peu probable que la taille naturel d’un vecteur corresponde au nombre
d’éléments des registres (ou à un multiple de)
I
I
La taille d’une opération vectorielle est souvent inconnue à la
compilation
for (i=0; i<n; ++i)
Y[i] = a * X[i] + Y[i];
Taille du vecteur dépend de n, qui pourrait changer au cours de
l’exécution
Solution : registre donnant la longueur du vecteur (VLR,
vector-length register)
I
I
I
Contrôle les opérations vectorielles, incluant load-store
Ne peut excéder la taille maximale des registres vecteurs (MVL,
maximum vector length)
Donc, même code peut être exécuté avec différentes tailles de vecteurs
GIF-3000 (U. Laval)
Architectures vectorielles
C. Gagné
27 / 43
Strip mining
Strip mining : générer du code de sorte que chaque itération sera sur
un vecteur de taille égale ou inférieure à la taille maximale
Exemple avec DAXPY :
m = 0;
VL = (n % MVL);
for (j=0; j<=(n/MVL); ++j) {
for (i=m; i<(m+VL); ++i)
Y[i] = a * X[i] + Y[i];
m += VL;
VL = MVL;
}
I Première itération sur le reste entre n et MVL
I Autres itérations sur vecteurs de taille MVL
Value of j
Range of i
GIF-3000 (U. Laval)
0
1
m
0
..
..
(m − 1) (m − 1)
+ MVL
2
3
...
...
n/MVL
(m + MVL) (m + 2 × MVL) . . .
..
..
(m − 1)
(m − 1)
+ 2 × MVL + 3 × MVL
...
(n − MVL)
..
(n − 1)
Architectures vectorielles
C. Gagné
28 / 43
Gestion d’énoncés conditionnels
Énoncés conditionnels limite le niveau de vectorialisation possible
I
I
Exemple de boucle avec énoncé conditionnel :
for (i=0; i<64; ++i) {
if (X[i] != 0) X[i] -= Y[i];
}
Ne peut être exécuté tel quel dans une opération vectorielle
F
Mais on pourrait vectorialiser l’exécution seulement avec les itérations
où X[i] != 0
Solution : masque de contrôle de vecteur
I
I
I
Détermine la condition de contrôle pour chaque élément des vecteurs
Valeur booléenne pour chaque élément, traite l’élément pour une valeur
à 1
Opérations pour calculer valeur du masque et tout réinitialiser à 1
GIF-3000 (U. Laval)
Architectures vectorielles
C. Gagné
29 / 43
Code VMIPS avec masque de contrôle
Exemple de code VMIPS avec masque de contrôle :
LV
LV
L.D
SNEVS.D
SUBVV.D
SV
V1,Rx
V2,Ry
F0,#0
V1,F0
V1,V1,V2
V1,Rx
;
;
;
;
;
;
Lecture vecteur X
Lecture vecteur Y
Assigner valeur 0 à F0
VM(i) vaut 1 si Vi(1)!=F0
Soustraction sous masque VM
Écrire résultat dans X
Version avec masque de contrôle fait du travail inutile
I
Reste que même avec plusieurs zéros dans le masque, version
vectorielle peut être significativement plus rapide que version scalaire
GIF-3000 (U. Laval)
Architectures vectorielles
C. Gagné
30 / 43
Banques de mémoire
Architectures vectorielles sont exigeantes en accès mémoires
I
I
I
I
Lecture/écriture implique autant d’accès aux données que d’éléments
dans le vecteur
Données d’un vecteur ne sont pas nécessairement séquentielles en
mémoire
Plusieurs architectures supportent plusieurs lectures/écritures
simultanées
Architectures vectorielles modernes supportent également exploitation
de plusieurs processeurs
Utilisation de banques de mémoire permet des accès multiples
simultanés
I
I
I
I
Banques de mémoire : séparer la mémoire principales en plusieurs
morceaux indépendants, éléments contiguës dans banques distinctes
Accès à chaque banque peut être simultané
Adresses peuvent être contrôlées indépendamment par chaque banque
Pour de bonnes performances avec architectures vectorielles, utiliser un
grand nombre de banques indépendantes
GIF-3000 (U. Laval)
Architectures vectorielles
C. Gagné
31 / 43
Tableaux multidimensionnels
Code de multiplication de matrices en C :
for (i=0; i<100; ++i) {
for (j=0; j<100; ++j) {
A[i][j] = 0.0;
for (k=0; k<100; ++k) {
A[i][j] += B[i][k] * D[k][j];
}
}
}
I On peut utiliser du strip mining pour la boucle interne (compteur k)
F
I
Positions en mémoire des éléments adjacents ne seront pas séquentielles
En langage C, position en mémoire de tableau 2D est ligne à ligne
F
Donc, accès à valeur D[k][j] à chaque itération de boucle interne est
séparé par 8 × nombre d’éléments d’une ligne de D
Foulée (stride) : distance entre chaque élément collecté dans un
registre vectoriel
I
Foulée de D est de 100 éléments (800 octets) ; foulée de B est de 1
élément (8 octets)
GIF-3000 (U. Laval)
Architectures vectorielles
C. Gagné
32 / 43
Traitement de tableaux multidimensionnels
Avec architecture vectorielle, foulée peut être différente de 1
I
I
Données non-séquentielles en mémoire peuvent ainsi être colligées dans
un registre
Permet une gestion de caches efficace pour les accès mémoire dans
certains cas
Avec VMIPS, instructions LVWS et SVWS permettent lecture/écriture
avec foulée non-unitaire
Support de foulée complexifie le système de mémoire
I
I
Avec foulée non-unitaire, possible d’accéder à la même banque de
mémoire fréquemment
Conflits d’accès simultanés à une banque peuvent générer des blocages
F
Blocages surviennent lorsque :
Nombre de banques
< Temps d’attente d’une banque
PPCM(Foulée,Nombre de banques)
GIF-3000 (U. Laval)
Architectures vectorielles
C. Gagné
33 / 43
Exemple : temps accès mémoire avec foulée
Supposons 8 banques, temps d’attente d’une banque de 6 cycles et
latence d’accès mémoire de 12 cycles
I
Temps de lecture d’un vecteur de 64 éléments avec une foulée de 1 ?
F
I
Comme nombre de banque > foulée, lecture prend 12 + 64 = 72 cycles,
soit 1,2 cycles par élément
Temps de lecture d’un vecteur avec foulée de 32 ?
F
F
F
F
PPCM(Foulée,Nombre de banques) = PPCM(32,8) = 32
Nombre de banques / PPCM(32,8) = 8 / 32 = 4
4 < 6 ⇒ collisions à chaque accès subséquent au premier
Temps de lecture : 12 + 1 + 6 × 63 = 391 cycles, soit 6,1 cycles par
élément
GIF-3000 (U. Laval)
Architectures vectorielles
C. Gagné
34 / 43
Matrices creuses
Matrices creuses (sparse matrices) : matrice contenant une majorité
de valeurs nulles
I
I
I
Courantes dans de nombreuses applications numériques
Conserver les matrices explicitement est souvent très inefficace
Conserver plutôt structure indirecte, dans une liste de (indices,valeurs)
des valeurs non-nulles
Exemple d’une boucle avec matrices creuses :
for (i=0; i<n; ++i) {
A[K[i]] += C[M[i]];
}
I
I
A et C sont des matrices creuses et K et M donnent les indices des
valeurs non-nulles
On suppose que A et C ont toutes deux n éléments non-nuls
GIF-3000 (U. Laval)
Architectures vectorielles
C. Gagné
35 / 43
Gestion des matrices creuses
Opérations de collecte-dispersion (gather-scatter) : utiliser un vecteur
d’indices pour lecture/écriture
I
Opérations LVI et SVI font collecte et dispersion des données
Exemple de la boucle avec matrices creuses :
LV
LVI
LV
LVI
ADDVV.D
SVI
Vk,Rk
Va,(Ra+Vk)
Vm,Rm
Vc,(Rc+Vm)
Va,Va,Vc
(Ra+Vk),Va
;
;
;
;
;
;
Lecture K
Lecture A[K[]]
Lecture M
Lecture C[M[]]
Addition
Écriture A[K[]]
Instructions de collecte-dispersion sont pratiques et peuvent être
pipelinées
I
I
I
Elles sont en général plus lentes que des instructions de lecture/écriture
standards
Une adresse distincte pour chaque élément, implique une latence
significative
Adresses individuelles génèrent plus de conflits d’accès mémoires
GIF-3000 (U. Laval)
Architectures vectorielles
C. Gagné
36 / 43
Partie IV
Extensions SIMD pour multimédia
GIF-3000 (U. Laval)
Architectures vectorielles
C. Gagné
37 / 43
Extensions SIMD pour multimédia
Nombreuses applications multimédias utilisent des données
représentées sur peu de bits
I
I
Pixels représentés sur 32 bits (3×8 bits pour RGB + 8 bits de
transparence)
Échantillons audios sur 8 ou 16 bits
En modifiant la gestion des retenues d’un additionneur sur 256 bits,
plusieurs opérations peuvent être faites simultanément
I
32 additions d’opérandes 8 bits, 16 additions d’opérandes 16 bits, 8
additions d’opérandes 32 bits, ou 4 additions d’opérandes 64 bits
Extensions SIMD pour multimédia
I
I
I
Extensions aux microprocesseurs modernes (ex. MMX, SSE, AVX dans
x86)
Instructions similaires à celles d’architectures vectorielles
Cependant, utilise un petit nombre de registres de plus petites tailles
GIF-3000 (U. Laval)
Architectures vectorielles
C. Gagné
38 / 43
Extensions SIMD multimédias vs opérations vectorielles
Éléments manquants dans extensions SIMD multimédias
I
N’incluent pas de registre de longueur de vecteur
F
I
I
Dans MMX, SSE et AVX, le nombre d’opérandes est fixé dans
l’opcode, ce qui a mené a des centaines d’opérations distinctes
N’offrent pas de mode d’adressage sophistiqué comme les accès avec
foulées et les opérations de collecte-dispersion
N’offrent pas de masque de contrôle de registres pour exécution
conditionnelle
Ces omissions font que les compilateurs et les programmeurs ont de la
difficulté à utiliser ces extensions dans leurs programmes
GIF-3000 (U. Laval)
Architectures vectorielles
C. Gagné
39 / 43
Historique des extensions SIMD multimédias x86
MMX (1996)
I
Réutilise les registres à virgule flottante 64 bits
F
I
I
8 opérations 8 bits ou 4 opérations 16 bits simultanément
Variété d’opérations : min, max, masques et opérations conditionnelles,
opérations de DSP, etc.
Accès mémoires via instructions à virgule flottante 64 bits
SSE (1999)
I
I
I
Registres sur 128 bits distincts
Opérations sur nombres à virgule flottante à simple précision (32 bits)
SSE2 et + ajoutent des opérations sur nombres à VF à double précision
AVX (2010)
I
Double la taille des registres à 256 bits
F
I
Donc deux fois plus d’éléments peuvent être traités simultanément
Dispositions pour étendre la taille des registres à 512 bits et 1024 bits
dans le futur
GIF-3000 (U. Laval)
Architectures vectorielles
C. Gagné
40 / 43
Popularité des extensions SIMD
Objectif des extensions : accélérer les traitements de librairies
spécialisées
I
Difficile pour les compilateurs d’exploiter ces extensions
Raisons de la popularité de ces instructions
I
I
I
I
Coût faible et facilité d’implantation
Requiert beaucoup moins de stockage (registres) que architectures
vectorielles
Pas besoin de grande bande passante à la mémoire ou de gérer les
manquements de pages
Vecteurs courts de taille fixe sont plus versatiles
Également, un certain scepticisme relativement aux architectures
vectorielles reste présent chez les concepteurs
I
I
Dans le passé, plusieurs problèmes ont jeté du discrédit sur
architectures vectorielles
Principaux problèmes sont cependant réglés depuis
GIF-3000 (U. Laval)
Architectures vectorielles
C. Gagné
41 / 43
Exploitation des extensions SIMD
Nature ad hoc des extensions SIMD rend leur utilisation difficile par le
compilateur
I
I
I
Versions plus récentes sont plus cohérentes, rendant leur utilisation plus
aisées par le compilateur
Compilateurs récents tentent de les utiliser pour applications
scientifiques, lorsqu’il y a beaucoup d’opérations à VF
Accès mémoire doivent cependant être alignés sur la largeur des
registres des extensions
Intensité arithmétique : ratio du nombre d’opérations à VF par octet
de mémoire accédé
O(1)
O(log(N))
O(N)
Arithmetic Intensity
Sparse
matrix
(SpMV)
Structured
grids
(Stencils,
PDEs)
GIF-3000 (U. Laval)
Spectral
methods
(FFTs)
Structured
grids
(Lattice
methods)
Architectures vectorielles
Dense
matrix
(BLAS3)
N-body
(Particle
methods)
C. Gagné
42 / 43
Modèle roofline
Comment caractériser la performance de processeurs selon l’intensité
arithmétique ?
I
I
Calculs à faible densité : limités par les accès mémoires
Calculs à plus forte densité : limités par la capacité de traitement du
processeur
Comparaison entre un processeur standard et un processeur vectoriel
NEC SX-9 est un supercalculateur (2008) coûtant des millions de
dollars
32
16
(S 2 G
tre B
am /s
)
Double precision GLFOP/sec
102.4 GFLOP/sec
128
64
256
16
8
4
2
1/8 1/4 1/2 1
2
4
8
Arithmetic intensity
GIF-3000 (U. Laval)
16
Intel Core i7 920
(Nehalem)
128
64
42.66 GFLOP/sec
32
16
8
16
(S .4 G
tre B
am /s
)
NEC SX-9 CPU
256
Double precision GLFOP/sec
I
4
2
1/8 1/4 1/2 1
2
4
8
Arithmetic intensity
Architectures vectorielles
16
C. Gagné
43 / 43