Chapitre2 La technique du Pipeline

Présentation au sujet: "Chapitre2 La technique du Pipeline"— Transcription de la présentation:

1 Chapitre2 La technique du Pipeline
Architecture Des Ordinateurs Master Info Première Année Master1/IUP 3

2 Introduction Idée : Ne pas attendre la fin de l ’instruction pour démarrer une nouvelle Découper l ’exécution de l ’instruction en phase +- indépendantes et de même degrés de complexité Si non perte de temps A B C D 4 Paquets Laver Essorer Plier 30 mn 40mn mn

3 Solution naïve : Un paquet à la fois
6h 7h 8h 9h 10h 11h 12h Time 30 40 20 30 40 20 30 40 20 30 40 20 A B C D 6h pour laver les 4 paquets

4 Laver mes vêtements en pipeline: Possible mais !!
6 PM 7 8 9 10 11 Time 40 40 30 40 40 20 A Perte de temps à transférer les paquets B C D Les 4 paquets sont lavés en 3.5h au lieu de 6h

5 Appliquant le principe à l’architecture
Rappel : L’exécution de l’instruction se fait toujours en 5 étapes Lecture de l’instruction Décodage et en même temps lecture des registres Calcul dans l’UAL Instruction UAL : appliquer l’opération Instruction Mémoire : Calculer l’adresse Instruction de branchement : Calculer l’adresse de branchement et évaluer la condition Accès mémoire Mise à jour du registre destination (pour les UAL et loads) ou CP (pour les branchements)

6 Chemin de données de la machine MIPS sans Pipeline
F : I n s t r u c t i o n f e t c h I D : I n s t r u c t i o n d e c o d e / E X : E x e c u t e / M E M : M e m o r y a c c e s s W B : W r i t e b r e g i s t e r f i l e r e a d a d d r e s s c a l c u l a t i o n a c k I n s t r u c i o m e y A d 4 3 2 l S h f M x 1 P C W a R g Contenu reg Branchement terminé étape 4 Num de reg CP+4 e g i s t e r 1 R e a d r e g i s t e r 2 Z e r o A L U A L U W r i t e r e s u l t A d d r e s s R e a d r e g i s t e r M d a t a u D a t a W r i t e x m e m o r y d a t a 1 1 6 S i g n e x t e n d L’exécution de l’instruction se fait toujours de gauche à droite, sauf pour l’écriture du résultat et la mise à jour de CP en cas de branchement pris.

7 Branchement terminé étape 4
EXEMPLE I F : I n s t r u c t i o n f e t c h I D : I n s t r u c t i o n d e c o d e / E X : E x e c u t e / M E M : M e m o r y a c c e s s W B : W r i t e b r e g i s t e r f i l e r e a d a d d r e s s c a l c u l a t i o n a c k I n s t r u c i o m e y A d 4 3 2 l S h f M x 1 P C W a R g Contenu reg Branchement terminé étape 4 Num de reg 3 e g i s t e r 1 1 2 100 ADD R1, R2, R3 R e a d r e g i s t e r 2 Z e r o A L U A L U W r i t e r e s u l t A d d r e s s R e a d r e g i s t e r M d a t a u D a t a W r i t e x m e m o r y d a t a 1 1 6 3 S i g n e x t e n d 3 L’exécution de l’instruction se fait toujours de gauche à droite, sauf pour l’écriture du résultat et la mise à jour de CP en cas de branchement pris.

8 Exécution des instructions sans et avec pipileine
F D Ex Mem Er F D Ex Mem Er Temps 10 Idéalement : CPI = 1 1 Instruction par cycle

9 Les instructions ne sont pas sauvegardées
F : I n s t r u c t i o n f e t c h I D : I n s t r u c t i o n d e c o d e / E X : E x e c u t e / M E M : M e m o r y a c c e s s W B : W r i t e b r e g i s t e r f i l e r e a d a d d r e s s c a l c u l a t i o n a c k I n s t r u c i o m e y A d 4 3 2 l S h f M x 1 P C W a R g Contenu reg Branchement terminé étape 4 Num de reg 104 Sub R5, R6, R7 5 6 7 1 2 3 e g i s t e r 1 100 ADD R1, R2, R3 R e a d r e g i s t e r 2 Z e r o A L U A L U W r i t e r e s u l t A d d r e s s R e a d r e g i s t e r M d a t a u D a t a W r i t e 3 7 x m e m o r y d a t a 1 1 6 S i g n e x t e n d L’instruction contient des informations (numéros des registres, signaux de contrôle, …) qui seront utilisées bien après la lecture de l’instruction. Il faut les mémoriser.

10 Chemin de données pipeliné : ajout des buffers
Buffer pour stocker le résultat : le tapis roulant M u x 1 I F / I D I D / E X E X / M E M M E M / W B A d d A d d 4 A d d r e s u l t S h i f t l e f t 2 o n R e a d P C A d d r e s s t i r e g i s t e r 1 u c R e a d t r R e a d d a t a 1 n s Z e r o I n s t r u Add R1, R2, R3 c t i o n I r e g i s t e r 2 R e g i s t e r s m e m o r y R e a d A L U A L U W r i t e d a t a 2 r e s u l t A d d r e s s R e a d 1 r e g i s t e r M d a t a u D a t a M W r i t e x u m e m o r y d a t a x 1 W r i t e d a t a 1 6 3 2 S i g n e x t e n d Ces « buffers » sont utilisés non seulement pour stocker les données mais aussi les signaux de contrôle. L'écriture dans les buffers est faite à chaque fin de cycle par les signaux : FI/IDWrite, ID/ExWrite, EX/MemWrite, Mem/RbWrite

11 Chemin de données pipeliné : ajout des buffers
Buffer pour stocker le résultat : le tapis roulant M u x 1 I F / I D I D / E X E X / M E M M E M / W B A d d A d d 4 A d d r e s u l t S h i f t l e f t 2 o n R e a d P C A d d r e s s t i r e g i s t e r 1 R e a d u c t r R e a d Add R1, R2, R3 d a t a 1 Sub R5, R6, R7 n s Z e r o I n s t r u c t i o n I r e g i s t e r 2 R e g i s t e r s m e m o r y R e a d A L U A L U W r i t e d a t a 2 r e s u l t A d d r e s s R e a d 1 r e g i s t e r M d a t a u D a t a M W r i t e x u m e m o r y d a t a x 1 W r i t e d a t a 1 6 3 2 S i g n e x t e n d Ces « buffers » sont utilisés non seulement pour stocker les données mais aussi les signaux de contrôle. L'écriture dans les buffers est faite à chaque fin de cycle par les signaux : FI/IDWrite, ID/ExWrite, EX/MemWrite, Mem/RbWrite

12 Chemin de données pipeliné : ajout des buffers
Buffer pour stocker le résultat : le tapis roulant M u x 1 I F / I D I D / E X E X / M E M M E M / W B A d d A d d 4 A d d r e s u l t S h i f t l e f t 2 o n R e a d P C A d d r e s s t i r e g i s t e r 1 c R e a d u t r R e a d d a t a 1 Add R1, R2, R3 s n Z e r o I n s t r u LW ….. c t i o n I r e g i s t e r 2 Sub …. R e g i s t e r s m e m o r y R e a d A L U A L U W r i t e d a t a 2 r e s u l t A d d r e s s R e a d r e g i s t e r M d a t a 1 u D a t a M W r i t e x u m e m o r y d a t a x 1 W r i t e d a t a 1 6 3 2 S i g n e x t e n d Ces « buffers » sont utilisés non seulement pour stocker les données mais aussi les signaux de contrôle. L'écriture dans les buffers est faite à chaque fin de cycle par les signaux : FI/IDWrite, ID/ExWrite, EX/MemWrite, Mem/RbWrite

13 Chemin de données pipeliné : ajout des buffers
Buffer pour stocker le résultat : le tapis roulant M u x 1 I F / I D I D / E X E X / M E M M E M / W B A d d A d d 4 A d d r e s u l t S h i f t l e f t 2 n o R e a d P C A d d r e s s t i r e g i s t e r 1 c R e a d u t r R e a d d a t a 1 n s Z e r o I n s t r u Add …… c t i o n I r e g i s t e r 2 R e g i s t e r s m e m o r y R e a d A L U A L U Add R1, R2, R3 W r i t e LW ….. d a t a 2 Sub …. r e s u l t A d d r e s s R e a d r e g i s t e r M d a t a 1 u D a t a M W r i t e x u m e m o r y d a t a x 1 W r i t e d a t a 1 6 3 2 S i g n e x t e n d Ces « buffers » sont utilisés non seulement pour stocker les données mais aussi les signaux de contrôle. L'écriture dans les buffers est faite à chaque fin de cycle par les signaux : FI/IDWrite, ID/ExWrite, EX/MemWrite, Mem/RbWrite

14 Représentation graphique
M R e g D C 1 2 3 4 5 6 l w $ , ( ) s u b A L U Ordre d ’exécution Lecture Mémoire Ecriture Registre

15 Les signaux de contrôle des étages
Write-back Execution/Address Calculation Memory access stage stage control stage control lines control lines lines Reg ALU ALU ALU Mem Mem Reg Mem Instruction Dst Op1 Op0 Src Branch Read Write write to Reg R-format 1 1 1 lw 1 1 1 1 sw X 1 1 X beq X 1 1 X RegDst = 1; On écrit dans rd, si non dans rt ALUOpx : donne l’opération à réaliser dans l’UAL exemple 001 : addition, 010 : soustracation , …. 100: regarder le champ fonction Branch =1 si c’est une instr de branchement MemRead = 1 on fait une lecture en mémoire MemWrite = 1 on fait une écriture en mémoire RegWrite =1 on écrit dans un registre rd ou rt (suivant RegDst) MemToReg = 1 ; la donnée écrite dans le reg provient de la mémoire ; si non du regsitre

16 Mémorisation des signaux de contrôle
Une fois l’instruction décodée et pour éviter de redécoder de nouveau; On stocke les signaux de contrôle dans les buffers de pipeleine C o n t r l E X M W B I F / D s u c i

17 Le chemin de données avec les signaux de contrôle
P C S r c I D / E X M u W B x E X / M E M 1 C o n t r o l M W B M E M / W B E X M W B I F / I D A d d 4 A d d e A d d t r e s u l t r i W S h i f t B r a n c h g R e l e f t 2 e i t A L U S r c W r n o R e a d m e g P C A d d r e s s i M R e c t r e g i s t e r 1 u R e a d o r t s t R e a d d a t a 1 m n I r e g i s t e r 2 Z e r o e I n s t r u c t i o n M m e m o r y R e g i s t e r s R e a d A L U A L U W r i t e d a t a 2 r e s u l t A d d r e s s R e a d r e g i s t e r M d a t a 1 u D a t a M W r i t e x m e m o r y u d a t a x 1 W r i t e d a t a I n s t r u c t i o n [ 1 5 – ] 1 6 3 2 6 S i g n A L U M e m R e a d Il faut garder le num du reg destination rt ou rd e x t e n d c o n t r o l I n s t r u c t i o n [ 2 – 1 6 ] A L U O p M I n s t r u c t i o n u [ 1 5 – 1 1 ] x 1 R e g D s t

18 Le chemin de données avec les signaux de contrôle
P C S r c 104 1 I D / E X M u W B x E X / M E M 1 C o n t r o l M W B 104 M E M / W B 100 E X M W B I F / I D 104 104 A d d 4 A d d e A d d t r e s u l t r i W S h i f t B r a n c h g e 1 R l e f t 2 e t i A L U S r c r W 11 n o R e a d m e g e 100 A d d r e s s i c t r e g i s t e r 1 M R u 2 R e a d 100 Add r3, r2, r1 o r t s t R e a d d a t a 1 5 + m n e I n s t r u c t i o n I r e g i s t e r 2 Z e r o 16 16 M m e m o r y Add r3, r2, r1 R e g i s t e r s R e a d A L U A L U W r i t e d a t a 2 r e s u l t A d d r e s s R e a d 1 r e g i s t e r M d a t a u D a t a M W r i t e x m e m o r y u x 16 d a t a 1 W r i t e d a t a I n s t r u c t i o n 16 [ 1 5 – ] 1 6 3 2 fonc 6 S i g n A L U M e m R e a d e x t e n d c o n t r o l I n s t r u c t i o n 2 11 [ 2 – 1 6 ] 3 A L U O p 3 3 M I n s t r u c t i o n u [ 1 5 – 1 1 ] x 1 1 3 R e g D s t

19 Problèmes liés à l exploitation du pipeline
Pourquoi ne peut-on pas obtenir un CPI = 1? 3 causes : Les aléas Les aléas de structurels : Plusieurs instructions veulent utiliser la même unité: exemple 1’instruction lie en mémoire (Fetch) et une autre écrit en mémoire un store d ’une données. Solution : dédoubler les unités ou multiplier les ports de lecture/Ecriture (ex Transparent suivant) Les aléas de données : Dépendance de données L’instruction J a besoin d’une donnée qui est entrain de se calculer par I . J dépend de I et toute les deux sont dans le pipeline. Les aléas de contrôle : Instruction de branchement La décision de prendre le branchement ou non n ’est connu qu ’ à la fin de la phase 4. Risque : Il ne faut pas exécuter les instructions se trouvant juste après le branchement. Risque d’écraser les registres

20 Détourner les aléas structurels en multipliant les unités fonctionnelles
Aléas structurel sur la mémoire Avoir une mémoire (cache) Instruction et une mémoire (cache) données

21 Les aléas de données Les instructions : and, or et add utilisent
CC : clock cycle au début à la fin I M R e g C 1 2 3 4 5 6 T i m ( n c l o k y s ) u b $ , P r a x t d D 7 8 9 / – w V f : Les instructions : and, or et add utilisent l’ancien contenu du reg 2 !!!

22 Quelles solutions pour les dépendances de données (DD)?
1) Compter sur le compilateur pour détecter les DD, et insérer les instructions NOP. Inconv. : perte de temps Dans notre cas à chaque dépendance entre deux instructions : Il faut insérer 1, 2 ou 3 Nop suivant la distance entre les instructions. sub $2, $1, $3 and $12, $2, $5 or $13, $6, $2 add $14, $2, $2 sw $15, 100($2) Remarque le compilateur peut aussi déplacer du code pour l ’insérer entre deux instructions dépendantes. (cf. TD) Nop

23 Résoudre les aléas de données par des instructions sans effet (les NOP)
Valeur dans R2 disponible s u b $ 2 , $ 1 , $ 3 I M R e g D M R e g I M R e g D NOP NOP NOP I M R e g D a n d $ 1 2 , $ 2 , $ 5 o r $ 1 3 , $ 6 , $ 2 a d d $ 1 4 , $ 2 , $ 2

24 Autres solutions 2) Utiliser le matériel adéquat pour détecter la dépendance et suspendre l ’arrivée de nouvelle instruction tant que le résultat n ’est pas calculé. Aléas résolu. On bloque l ’arrivé des instruction: And, Or et Add jusqu’à ce que le reg 2 soit écrit. Un comparateur pour comparer le no du reg lue avec no du registre destination même chose que le schéma précédent mais des suspensions au lieu de NOP

25 3) Par Envoi direct Direct « Forwarding » ou « By-pass »
Le résultat est envoyé directement vers l’instruction destination avant qu’il ne soit écrit dans le registre destination: Il y a transmission directe entre instructions sans passer par les regs I M R e g C 1 2 3 4 5 6 T i m ( n c l o k y s ) u b $ , P r a x t d D 7 8 9 / – w V f : X E W B Lorsqu’un reg est lu et écrit dans le même cycle, on lit la nouvelle valeur

26 L ’envoi direct (direct forwarding)
Les registres UAL Sans envoi direct Les registres UAL Mx Avec envoi direct

27 SANS ENVOI DIRECT Add $6, $12, $13 Add $2, $3, $4 Sub $5, $6, $6
M u x A L U I D / E X W B a t m e o r y R g i s SANS ENVOI DIRECT R e g i s t r M u x A L U I D / E X W B a m o y F w d n b . h f AVEC ENVOI DIRECT Add $6, $12, $13 Add $2, $3, $4 Sub $5, $6, $6 … Rs Rt

28 Le chemin de données complet avec l’envoi direct
TD Donnez le schéma de l’unité Forward Unit P C I n s t r u c i o m e y R g M x l A L U E X W B D / a F w d . regWrite regWrite

29 L ’envoie direct ne marche à chaque coup!!!
Le problème des instructions de chargement T i m e ( i n c l o c k c y c l e s ) P r o g r a m C C 1 C C 2 C C 3 C C 4 C C 5 C C 6 C C 7 C C 8 C C 9 e x e c u t i o n o r d e r ( i n i n s t r u c t i o n s ) l w $ 2 , 2 ( $ 1 ) I M R e g D M R e g ? a n d $ 4 , $ 2 , $ 5 I M R e g D M R e g o r $ 8 , $ 2 , $ 6 I M R e g D M R e g a d d $ 9 , $ 4 , $ 2 I M R e g D M R e g s l t $ 1 , $ 6 , $ 7 I M R e g D M R e g

30 Solution : Retarder d ’un cycle l ’instruction AND
P r o g r a m T i m e ( i n c l o c k c y c l e s ) e x e c u t i o n C C 1 C C 2 C C 3 C C 4 C C 5 C C 6 C C 7 C C 8 C C 9 C C 1 o r d e r ( i n i n s t r u c t i o n s ) Pour ne pas avancer il faut mettre à zéro les sng de contrôle l w $ 2 , 2 ( $ 1 ) I M R e g D M R e g Pour ne pas avancer il ne faut pas charger une nouvelle instruction et ne pas modifier PC a n d $ 4 , $ 2 , $ 5 I M R e g D M R e g o r $ 8 , $ 2 , $ 6 I M R e g D M R e g Bulle a d d $ 9 , $ 4 , $ 2 I M R e g D M R e g

31 L ’aléas de données avec une instruction de chargement
And Rs, Rt, Rd Lw rt, 100(Rs) H a z a r d I D / E X . M e m R e a d d e t e c t i o n u n i t I D / E X Rs, Rt RAZ e i t rt W B r E X / M E M W D I M F / I C o n t r o l u M W B x M E M / W B I F / I D E X M W B e t r i W C n M P o i t u u c x r t n s R e g i s t e r s I n s t r u c t i o n I D a t a P C A L U m e m o r y m e m o r y M u M x u x I F / I D . R e g i s t e r R s I F / I D . R e g i s t e r R t I F / I D . R e g i s t e r R t R t M E X / M E M . R e g i s t e r R d I F / I D . R e g i s t e r R d R d u l w $ 2 , 2 ( $ 1 ) x rt I D / E X . R e g i s t e r R t R s F o r w a r d i n g M E M / W B . R e g i s t e r R d R t u n i t a n d $ 4 , $ 2 , $ 5 rs rt

32 Dernier type d ’aléas : les aléas de contrôle les branchements pris
Le résultat de la condition du branchement n’est connu qu ’à la fin de la phase 4. Pendant la phase 2, et 3 et 4, les trois instructions suivantes ont été chargées Problème si la condition est vérifiée , On écrase des registres !!!!!! R e g C 1 T i m ( n c l o k y s ) 4 b q $ , 3 7 P r a x u t d I M D 2 5 8 6 w 9

33 Deux solutions possibles pour lutter contre les aléas de branchement
1 : Dés qu ’une instruction de branchement est chargée dans IF/D, on bloque l’arrivée de nouvelle instruction jusqu’à ce que la condition soit évaluée: Perte de 3 cycles P r o g r a m T i m e ( i n c l o c k c y c l e s ) e x e c u t i o n C C 1 C C 2 C C 3 C C 4 C C 5 C C 6 C C 7 C C 8 C C 9 o r d e r ( i n i n s t r u c t i o n s ) 4 b e q $ 1 , $ 3 , 7 I M R e g D M R e g I M I M I M 7 2 l w $ 4 , 5 ( $ 7 ) I M R e g D M R e g

34 2) Continuer l ’exécution des instructions chargées Mais vider les buffers si branchement pris.
1 1 1 I D / E X M u W B x E X / M E M M M M COP C o n t r o l u M u u W B x x x M E M / W B I I F F / / I I D D E X M W B Branchement pris I n s t r u c t i o n P C Les instructions se trouvant après l’instruction branchement sont toujours chargées Si la condition est vérifiée, les instructions sont vidées des buffers IF/ID, ID/EXE, EXE/MEM, on met des zéros partout. m e m o r y

35 3) On peut remplir le vide par des instructions utiles Delayed Branch
. F r o m b e f d $ s 1 , 2 3 i = t h n D l y b . F r o m t a g e s u $ 4 , 5 6 … d 1 2 3 i f = h n D l y Exemple avec une instruction

36 Exemples de quelques processeurs pipelinés
ARM7 (1990) : processeur pour applications embarqués à 3 étages de pipeline. Les instructions sont exécutées dans le même ordre de leurs lectures (in order) PC FETCH Instruction fetched from memory Decoding of registers used in instruction Register(s) read from Register Bank Shift and ALU operation Write register(s) back to Register Bank PC - 4 DECODE PC - 8 EXECUTE

37 Pipeline sur le PentiumI (1995)
Les étapes (pipeline) du Pentium I (instructions arithmétiques entières) Prefetch. Chargement des instructions du cache (ou de la mémoire) dans les tampons de pré-chargement. Decode 1. Décodage de l’instruction. Decode 2. Calcul de l'adresse des opérandes présentes en mémoire. Execute. Exécution des instructions et accès à la mémoire. Write Back. Modification de l'état du processeur par l'achèvement de l'exécution des instructions. Pipeline de 10 étages sur l’Athlon, 12 étages sur le Pentium III et 20 étages sur le pentium IV

38 Micro-acrhitecture Pentium4

39 Pipeline sur MIPS R3000 et R4000 Le MIPS R3000 implémente un pipeline de cinq étages typique d'un processeur RISC traditionnel (chargement de l'instruction, décodage, exécution ou calcul de l'adresse, accès à la mémoire, mise à jour du banc de registres). La gestion des interblocages (aléas de données) au sein du pipeline est effectuée par logiciel. Le MIPS R4000 est le premier des processeurs RISC à mettre en œuvre la technique du superpipeline. Division de chaque étage du pipeline en sous phases. Les étages critiques ont été divisés en deux, voire en trois, pour permettre à ce processeur d'atteindre des fréquences élevées. Le pipeline a au total une profondeur de huit étages.

40 Le pipeline sur les processeurs Alpha 21064
le DEC utilise la technique du superpipeline avec un pipeline de sept étages. Les quatre premiers servent au chargement des instructions, à leur décodage, à la prédiction de branchement ainsi qu'à la résolution des conflits sur un processeur superscalaire de degré deux. Ces quatre premiers étages sont dit statiques dans la mesure où les instructions peuvent attendre à ce niveau la résolution des conflits de ressources, par opposition aux étages d'exécution dits dynamiques, et dans lesquels la phase d'exécution des instructions ne peut être interrompue. Ces quatre premiers étages sont donc communs aux pipelines entier et flottant. Le pipeline flottant du DEC a une profondeur de dix étages.

41 PowerPC 603 PowerPc : Les pipelines d'exécution des instructions entières et flottantes ont une profondeur respective de cinq et six étages

42 PowerPc 970 (alias G4) 58 million transistors
Execution core • Support for up to 215 in-flight instructions • Simultaneous issue of up to 10 out-of-order operations: –One Velocity Engine permute operation (SIMD) –One Velocity Engine arithmetic logic operation (SIMD) –Two floating-point operations –Two fixed-point register-to-register operations –Two load or store operations –One condition register operation –One branch operation • 64K L1 instruction cache; 32K L1 data cache • 512K internal L2 cache • Support for up to eight outstanding L1 cache line misses • Hardware-initiated instruction prefetching from L2 cache 58 million transistors Maximum core frequency: 2GHz

43 P4 : un pipeline à 20 étages

44 Pipeline du core-Duo

45 Plus de détails : Intel P4 : PowerPc : Cours du Pr Sanchez , Ecole Polytechnique de Lausanne