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

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 20mn

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

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

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)

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.

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.

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

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.

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

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

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

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

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

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

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

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

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 1 1 0 0 000 10 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

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

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

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 !!!

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Micro-acrhitecture Pentium4

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.

Le pipeline sur les processeurs Alpha 21064 le DEC 21064 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 21064 a une profondeur de dix étages.

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

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

P4 : un pipeline à 20 étages

Pipeline du core-Duo

Plus de détails : Intel P4 : http://www.hardware.fr/html/articles/lire.php3?article=283 http://www.active-hardware.com/francais/reviews/processor/pentium4-2fr.htm PowerPc : http://www.rs6000.ibm.com/resource/technology/603.html Cours du Pr Sanchez , Ecole Polytechnique de Lausanne http://lslwww.epfl.ch/pages/teaching/cours_lsl/ao/home.html