Parallélisme d`instructions : Superscalaires versus VLIW

Parallélisme d’instructions :
Superscalaires versus VLIW
Daniel Etiemble
[email protected]
Parallélisme d’instructions
• Pipeline simple et superpipeline
– 1 instruction par cycle. CPImax=1
• Amélioration de la performance
– Exécuter plusieurs instructions en parallèle
• IPC = 1/CPI (Instructions par cycle)
• Deux approches
– Superscalaires
– VLIW (mots d’instructions très long)
IFIPS-2
2007-2008
Architecture des ordinateurs
Daniel Etiemble
2
1
Processeurs : superscalaire/VLIW
I1
I2
I3
I4
I5
I6
I7
I8
PROGRAMME
Exécution
(Matériel)
C
I1 I2 I3
C+1 I4 I5 I6 I7
C+2 I8
C
I1 N I2 I3
C+1 I4 I5 I6 I7
C+2 N N I8 N
Compilation
VLIW
SUPERSCALAIRE
•
Superscalaire
– Le matériel est responsable à l’exécution du lancement parallèle des
instructions
• Contrôle des dépendances de données et de contrôle par matériel
•
VLIW
– Le compilateur est responsable de présenter au matériel des instructions
exécutables en parallèle
• Contrôle des dépendances de données et de contrôle par le compilateur
Architecture des ordinateurs
Daniel Etiemble
IFIPS-2
2007-2008
3
Principes des superscalaires
pipeline
LI
DI/LR
LI
EX
ER
DI/LR
EX
LI
DI/LR
EX
LI
DI/LR
ER
ER
EX
ER
superscalaire
Superscalaire de degré n :
n instructions par cycle
LI
DI/LR
EX
ER
LI
DI/LR
EX
ER
LI
DI/LR
EX
ER
LI
DI/LR
EX
ER
IFIPS-2
2007-2008
Architecture des ordinateurs
Daniel Etiemble
4
2
Le contrôle des aléas
• Contrôle des dépendances de données
– Réalisé par matériel
• Tableau de marques (Scoreboard)
• Tomasulo
• Existe à la fois pour les processeurs scalaires (à
cause des instructions multi-cycles) et les
processeurs superscalaires (problèmes accentués)
IFIPS-2
2007-2008
Architecture des ordinateurs
Daniel Etiemble
5
Problèmes liés aux superscalaires
• Nombre d’instructions lues
• Types d’instructions exécutables en parallèles
• Politique d’exécution
– Exécution dans l’ordre
– Exécution non ordonnée
• Dépendances de données
• Branchements
IFIPS-2
2007-2008
Architecture des ordinateurs
Daniel Etiemble
6
3
Problèmes superscalaires (2)
• Coût matériel accentué
– Plusieurs accès aux bancs de registres
– Plusieurs bus pour les opérandes et les résultats
– Circuits d’envoi (forwarding) plus complexes
• Davantage d’unités fonctionnelles avec latences
différentes
– plusieurs fonctions (Entiers, Flottants, Contrôle)
– plusieurs unités entières
• Plusieurs instructions exécutées simultanément
– Débit d’instructions plus important
– Débit d’accès aux données plus important
– Problème des sauts et branchements accentués
Architecture des ordinateurs
Daniel Etiemble
IFIPS-2
2007-2008
7
Exécution superscalaire
LI
DI
LR
Lancement des instructions
(ressources disponibles)
Démarrage de l’exécution quand
les opérandes sont disponibles
• Exécution dans l’ordre
– Acquisition par groupe d’instructions
– Traitement du groupe suivant quand toutes les instructions d’un groupe
ont été lancées et démarrées.
• Exécution non ordonnée
– Acquisition des instructions par groupe, rangées dans un tampon
– Exécution non ordonnée des instructions, en fonction du flot de données
– Fenêtre d’instructions liée à la taille du tampon.
IFIPS-2
2007-2008
Architecture des ordinateurs
Daniel Etiemble
8
4
Exécution superscalaire x86
• Exécution directe du code x86
– Pentium
• Traduction dynamique du code x86 en instructions
de type RISC
– Pentium Pro et successeur
– AMD K6 et K7
• Emulation : traduction dynamique en code VLIW
– Transmeta
Architecture des ordinateurs
Daniel Etiemble
IFIPS-2
2007-2008
9
Exécution dans l’ordre (21164)
• 4 instructions acquises par cycle
• 4 pipelines indépendants E0
– 2 entiers
– 2 flottants
LD
ST
UAL
CMOV
COMP
E1
LD
IBR
Jump
UAL
CMOV
COMP
FA
FM
FADD
FDIV
FBR
FMUL
• 1 groupe de 4 instructions considéré à chaque cycle
– si les 4 instructions se répartissent dans E0, E1, FA et FM,
elles démarrent leur exécution. Sinon, certaines utilisent les
cycles suivants jusqu’à ce que les 4 aient démarré.
– Les 4 suivantes sont traitées quand les 4 précédentes ont
démarré.
IFIPS-2
2007-2008
Architecture des ordinateurs
Daniel Etiemble
10
5
Exécution non ordonnée
ORDRE DU PROGRAMME
TAMPON
INSTRUCTIONS
ACQUISITION ET DECODAGE
LANCEMENT
FENETRE
EXECUTION
UF
EXECUTION
UF
UF
TAMPON
REORDONNANCEMENT
UF
GARANTIE
RETRAIT
Architecture des ordinateurs
Daniel Etiemble
IFIPS-2
2007-2008
11
ARCHITECTURE VLIW
•
PRINCIPE
–
–
–
–
•
Plusieurs unités fonctionnelles
ORDONNANCEMENT STATIQUE
(compilateur)
• Aléas de données
• Aléas de contrôle
Exécution pipelinée des instructions
Exécution parallèle dans N unités
fonctionnelles
Mémoire principale
UF 1
UF 2
UF 3
UF 4
Inst.2
Inst.3
Inst.4
Tâches du compilateur
–
–
Graphe de dépendances locales : Bloc
de base
Graphe de dépendance du programme :
Ordonnancement de traces
•
Pour:
•
Contre:
–
–
IFIPS-2
2007-2008
Inst.1
Contrôleur
central
Very Long Instruction Word (VLIW)
Matériel simplifié (contrôle)
La compatibilité binaire entre
générations successives est difficile ou
impossible
Architecture des ordinateurs
Daniel Etiemble
12
6
Schéma fonctionnel du C6x
Control/Status
Registers
PROGRAM FETCH
INSTRUCTION DISPATCH
INSTRUCTION DECODE
256
Register Bank B
(16 x 32)
Register Bank A
(16 x 32)
32
32
32
32
32
32
S1
L1
ALU
M1
Multiply
ALU,
Shifter
8
L2
ALU
D1
Add/Sub
S2
ALU,
Shifter
M2
Multiply
D2
Add/Sub
32
Data Memory
(32K x 16)
Program
Memory
(16K x 32)
DATA BUS 1 (32 bits)
PROGRAM BUS 2 (32 bits)
Architecture des ordinateurs
Daniel Etiemble
IFIPS-2
2007-2008
13
Jeu d ’instructions C6x
• VLIW : 8 x 32 bits
• Instructions 32 bits, correspondant à 4 x 2 unités
fonctionnelles
– voir schéma fonctionnel
• 2 ensemble A et B de 16 registres généraux
• Instructions à exécution conditionnelle
– 5 registres généraux A1, A2, B0, B1, B2 peuvent
contenir la condition
• différent zéro
• égal 0
IFIPS-2
2007-2008
Architecture des ordinateurs
Daniel Etiemble
14
7
Modes d’adressage
Type
d’adressage
No
modification
Registre
Indirect
Registre +
déplacement
Base + Index
*R
*+R[ucst5]
*-R[ucst5]
*+R[offsetR]
*-R[offsetR]
Préincrement
ou Décrement
du registre
adresse
*++R
*--R
*++R[ucst5]
*--R[ucst5]
*++R[offsetR]
*--R[offsetR]
Postincrément
ou Décrement
du registre
adresse
*R++
*R-*R++[ucst5]
*R--[ucst5]
*R++
*R--
Architecture des ordinateurs
Daniel Etiemble
IFIPS-2
2007-2008
15
Instructions et unités fonctionnelles
.L Unit
ABS
ADD
AND
CMPEQ
C.PGT
CMPGTU
CMPLT
CMPLTU
LMBD
MV
NEG
NORM
NOT
OR
IFIPS-2
2007-2008
.M Unit .S Unit
SADD MPY
SAT
SMPY
SSUB MPYH
SUB
SUBC
XOR
ZERO
ADD
ADDK
ADD2
AND
B disp
B IRP
B NRP
Breg
CLR
EXT
EXTU
MVC (S2)
MV
MVK
.D Unit
MVKH
NEG
NOT
OR
SET
SHL
SHR
SHRU
SSHL
SUB
SUB2
XOR
ZERO
Architecture des ordinateurs
Daniel Etiemble
ADD
ADDA
LD mem
LD mem (15 bit) (D2)
MV
NEG
ST mem
ST mem (15 bit) (D2)
SUB
SUBA
ZERO
16
8
Loads
Multiplies
Branches
PIPELINE C6x
IFIPS-2
2007-2008
PG
Generate Program Address
PS
Program Address sent
PW
Program Memory Access
PR
Fetch reaches CPU boundary
DP
Instruction dispatch
DC
Instruction decode
E1
Execute 1
E2
Execute 2
E3
Execute 3
E4
Execute 4
E5
Execute 5
Délai de branchement : 5 cycles
Délai de chargement : 4 cycles
Délai de multiplication : 1
Architecture des ordinateurs
Daniel Etiemble
17
Programmation VLIW (C6x)
• Allocation des ressources
– Instructions et unités fonctionnelles
• Graphes de dépendances
– Latences (Chargement, Multiplication, Branchement)
• Déroulage de boucle
• Pipeline logiciel
– Intervalle d’itérations
– Cas des conditionnelles
– Durée de vie des registres
IFIPS-2
2007-2008
Architecture des ordinateurs
Daniel Etiemble
18
9
Programmation C6x : produit scalaire (1)
Code C
Code assembleur
int dotp(short[a], short[b])
{
int sum, i;
sum=0;
for (i=0; i<100;i++)
sum+=a[i]*b[i];
return (sum);
}
LOOP:
LDH
LDH
MPY
ADD
SUB
B
[A1]
bi
(A5)
ai
LDH (A2)
GRAPHE
DEPENDANCE
5
.D1
.D1
.M1
.L1
.S1
.S2
*A4++,A2
*A3++,A5
A2, A5, A6
A6, A7,A7
A1,1,A1
LOOP
LDH
SUB
5
pi
(A6)
MPY
; load ai
; load bi
; ai*bi
; sum+=(ai*bi)
; decrement loop counter
; branch to loop
1
cntr
(A1)
B
2
LOOP
ADD
1
IFIPS-2
2007-2008
sum
(A7) Architecture des ordinateurs
Daniel Etiemble
19
Programmation C6x : produit scalaire (2)
CODE ASSEMBLEUR NON PARALLELE
MVK
ZERO
.S1
.L1
100,A1
A7
; set up loop counter
; zero out accumulator
LDH
LDH
NOP
MPY
NOP
ADD
SUB
B
NOP
.D1
.D1
4
.M1
1
.L1
.S1
.S2
5
*A4++,A2 ; load ai
*A3++,A5 ; load ai
; delay slots for LDH
A2, A5, A6 ; ai*bi
; delay slot for MPY
A6, A7,A7 ; sum+=(ai*bi)
A1,1,A1
; decrement loop counter
LOOP
; branch to loop
; delay slots for branch
LOOP
[A1]
16 cycles/itération
IFIPS-2
2007-2008
Architecture des ordinateurs
Daniel Etiemble
20
10
Programmation C6x : produit scalaire (3)
||
LOOP:
MVK
ZERO
LDH
LDH
SUB
[A1]
B
NOP
MPY
NOP
ADD
; branch occurs here
||
.S1
.L1
100,A1
A7
; set up loop counter
; zero out accumulator
.D1
.D2
.S1
.S2
2
.M1
1
.L1
*A4++,A2
*B4++,B2
A1,1,A1
LOOP
; load ai
; load bi
; decrement loop counter
; branch to loop
; delay slots for LDH
A2, A5, A6 ; ai*bi
; delay slot for MPY
A6, A7,A7 ; sum+=(ai*bi)
.D1
.D2
ai
(A2) LDH
5
LDH
5
pi
(A6)
.M1X
bi
(B2)
SUB
MPY
1
cntr
(A1)
2
8 cycles/itération
ADD
1
sum
(A7)
.L1
Architecture des ordinateurs
Daniel Etiemble
IFIPS-2
2007-2008
B
LOOP
21
Programmation C6x : produit scalaire (4)
int dotp(short[a], short[b])
{
int sum, sum0, sum1, i;
sum0=0;
sum1=0
for (i=0; i<100;i+=2){
sum0+=a[i]*b[i];
sum1+=a[i+1]*b[i+1];
}
sum=sum0+sum1;
return (sum);
}
IFIPS-2
2007-2008
[A1]
LDW
LDW
MPY
MPYH
ADD
ADD
SUB
B
.D1
.D2
.M1X
.M2X
.L1
.L2
.S1
.S2
Architecture des ordinateurs
Daniel Etiemble
*A4++,A2
*B4++,B2
A2, B2, A6
A2, B2, B6
A6, A7,A7
B6, B7,B7
A1,1,A1
LOOP
; load ai and ai+1
; load bi and bi+1
; ai*bi
; ai+1*bi+1
; sum0+=(ai*bi)
; sum1+=(ai+1*bi+1)
; decrement loop counter
; branch to loop
22
11
Programmation C6x : produit scalaire (5)
||
||
LOOP:
MVK
ZERO
ZERO
LDW
LDW
SUB
[A1]
B
NOP
MPY
||
MPYH
NOP
ADD
||
ADD
; branch occurs here
ADD
||
.S1
.L1
.L2
100,A1
A7
B7
; set up loop counter
; zero out sum0
; zero out sum1
.D1
.D2
.S1
.S2
2
.M1X
.M2X
1
.L1
.L2
*A4++,A2
*B4++,B2
A1,1,A1
LOOP
.L1X
A7,B7,A4
; load ai and ai+1
; load bi and bi+1
; decrement loop counter
; branch to loop
; delay slots for LDH
A2, B2, A6 ; ai*bi
A2, B2, B6 ; ai+1*bi+1
; delay slot for MPY
A6, A7,A7 ; sum0+=(ai*bi)
B6,B7,B7 ; sum1+=(ai+1*bi+1)
; sum=sum0+sum1
8 cycles/2 itérations
Architecture des ordinateurs
Daniel Etiemble
IFIPS-2
2007-2008
23
Programmation C6x : produit scalaire (6)
Table des intervalles entre itérations
Unit/cycle 0
1
.D1
LDW
.D2
LDW
.M1
.M2
.L1
.L2
.S1
SUB
.S2
B
2
Unit/cycle
2
.D1
.D2
.M1
.M2
.L1
.L2
.S1
.S2
IFIPS-2
2007-2008
LDW
LDW
0
1
3
4
5
6
7
MPY
MPYH
ADD
ADD
3
4
5
6
LDW1
LDW1
LDW2
LDW2
LDW3
LDW3
LDW4
LDW4
LDW5
LDW5
MPY
MPYH
LDW6
LDW6
MPY1
MPYH1
SUB
SUB1
B
SUB2
B1
SUB3
B2
SUB4
B3
SUB5
B4
Architecture des ordinateurs
Daniel Etiemble
7
LDW7
LDW7
MPY2
MPYH2
ADD
ADD
SUB6
B5
24
12
Programmation C6x : produit scalaire (7)
Pipeline logiciel
LOOP:
||
||[A1]
||[A1]
||
||
||
||
LDW
LDW
SUB
B
MPY
MPYH
ADD
ADD
; branch occurs here
ADD
.D1
.D2
.S1
.S2
.M1X
.M2X
.L1
.L2
*A4++,A2
*B4++,B2
A1,1,A1
LOOP
A2, B2, A6
A2, B2, B6
A6, A7,A7
B6,B7,B7
; load ai and ai+1 (+7)
; load bi and bi+1 (+7)
; decrement loop counter (+6)
; branch to loop (+5)
; ai*bi (+2)
; ai+1*bi+1 (+2)
; sum0+=(ai*bi)
; sum1+=(ai+1*bi+1)
.L1X
A7,B7,A4
; sum=sum0+sum1
1 cycle /itération
PROLOGUE
EPILOGUE
IFIPS-2
2007-2008
Architecture des ordinateurs
Daniel Etiemble
25
13