4. 1 Recherche instruction Recherche opérandes Exécution Ecriture résultat
4. 2 1. Cycle d'exécution des instructions Modèle de Von Neuman Le CPU fait une boucle sans fin pour exécuter le programme chargé en mémoire centrale Chaque étape correspond à une modification d'un composant du chemin de données (la mémoire ou les registres) Les étapes dépendent de l'instruction à exécuter : opération à effectuer et mode d'adressage Quelle que soit l'architecture, on retrouve des étapes similaires (même fonction) mais les étapes dépendent du chemin de données
4. 3 lecture en mémoire instruction à l'adresse PC lecture du ou des opérandes écriture des résultats lecture et interprétation des champs d'instruction calculs calcul de la nouvelle valeur de PC (dépend du format de l'instruction) traitement des interruptions matérielles (souris, clavier,...) conditions d'erreur (division par 0,overflow,...), défaut de page W. Stallings «Computer Organization and Architecture»
4. 4 Lecture d instruction Charger le 1 er mot d'instruction de la mémoire principale vers le registre d'instruction Décodage Lecture éventuelle des autres mots d'instruction (selon le format) Ces valeurs sont stockées dans l'unité centrale dans des registres internes (registre d'opérande et de données) Recherche d opérandes Accès aux registres (si mode registre) Calcul d adresse et recherche d opérandes mémoire (si mode mémoire) Exécution Calcul dans l ALU pour les instructions arithmétiques ou logiques Calcul de l adresse de branchement pour les instructions de contrôle Ecriture résultat Modification de l opérande destination pour les instructions arithmétiques ou logiques Modification de PC pour les instructions de contrôle
4. 5 Exemple : PROCSI RD1 RD2 R/Wreg SR 3 REG CSreg SP ROP PC IR BUS 16 ADDRESS_BUS RAD DATA_BUS MEMOIRE AS DS contrôle instructions données R/W
4. 6 Exemple de décomposition en étapes pour PROCSI lecture instruction décodage recherche opérande exécution add R2, # 80 rad pc ir mem[rad] pc pc + 1 rad pc rop mem[rad] pc pc + 1 rd1 reg[ir(0..2)] rd2 rop rd1 rd1 + rd2 R2 <- R2 + 80 lecture du code instruction lecture du 2ème mot d instruction (constante 80) ir(0..2) : bits 0, 1 et 2 de ir qui contiennent le code du registre destination reg[ir(0..2)] est le registre destination écriture résultat reg[ir(0..2)] rd1
4. 7 ADD R2, #80 RD1 RD2 SP SR ROP PC + 1 PC IR 3 6 REG R/Wreg CSreg BUS 000000 0100X010 16 RAD ADDRESS_BUS DATA_BUS MEMOIRE PC:000000 0100X010 80 instructions données AS DS R/W 1) Lecture instruction Légende : en 1er en 2ème en 3ème
4. 8 RD1 RD2 SP SR 80 ROP PC + 1 PC IR 3 6 REG R/Wreg CSreg BUS 000000 0100X010 16 RAD ADDRESS_BUS DATA_BUS MEMOIRE PC :000000 0100X010 80 instructions données AS DS R/W 2) décodage
4. 9 6 RD1 RD2 80 SR 010 3 6 REG R/Wreg CSreg SP ROP PC IR 000000 0100X010 BUS 16 RAD 17 ADDRESS_BUS DATA_BUS MEMOIRE AS DS 3) recherche opérande 000000 0100X010 instructions données 80 R/W
4. 10 RD1 86 6 RD2 80 R/Wreg + SR 3 6 REG CSreg SP ROP PC IR BUS 16 RAD 17 ADDRESS_BUS DATA_BUS MEMOIRE AS DS 4) Exécution 000000 0100X010 instructions données 80 R/W
4. 11 RD1 86 RD2 SR 010 3 86 6 REG R/Wreg CSreg SP ROP PC IR BUS 16 RAD 17 ADDRESS_BUS DATA_BUS MEMOIRE AS DS 5) Ecriture résultat 000000 0100X010 instructions données 80 R/W
4. 12 Exemple de décomposition en étapes pour PROCSI add [80], R3 MEM[80] <- MEM[80] + R3 lecture instruction décodage recherche opérande exécution écriture résultat rad pc ir mem[rad] pc pc + 1 rad pc rop mem[rad] pc pc + 1 rd1 reg[ir(3..5)] rad rop rd2 mem[rad] rd1 rd1 + rd2 mem[rad] rd1 rop contient 80 ir(3..5) : bits 3, 4 et 5 de ir qui contiennent le numéro du registre source reg[ir(3..5)] est le registre source (R3 ici) rd2 contient MEM[80]
4. 13 2. Cycle d'exécution pipeline Sens du parcours Durée : 3 mn Eve Julie Anne Pour manger : - il faut passer par tous les stands, - 4 personnes sont servies en même temps. Aladin Une personne met 12mn pour être servie. Toutes les 3mn une personne sort de la chaîne.
4. 14 2.1. Les principes Une instruction est divisée en k étapes indépendantes Les étapes de plusieurs instructions s'exécutent en parallèle Si une étape dure t unités de temps alors pour n instructions : sans pipeline : t * k * n unités de temps avec pipeline : t * k + t * (n-1) unités de temps 8 ns 2 2 2 2 i SANS PIPELINE 8 ns 8 ns 2 2 2 2 2 2 2 2 i+1 i+2 24 ns i: i+1: AVEC PIPELINE 8 ns 2 2 2 2 2 2 2 2 i+2: 2 2 2 2 12 ns
4. 15 Contraintes pour que le pipeline soit efficace : chaque étape a la même durée : pas d'embouteillage! chaque instruction passe par les mêmes étapes : contrôle simplifié, pas de trou dans le pipeline! Architecture RISC (commercialisé ~ 1986) : Jeu d'instructions et modes d adressage simples, Accès mémoire par instructions spécialisées (LOAD/STORE), Débit d'une instruction par cycle : chaque étape dure un cycle donc une instruction sort du pipeline sur chaque cycle i: i+1: i+2: 1 1 1 1 1 1 1 1 1 1 1 1
4. 16 Jeu d'instruction RISC plus de registres AMD 64 bits : registres AX, BX, CX, DX, DI,... étendus à 32 bits (EAX, EBX,...) et à 64 bits (RAX,...) + 8 registres R8,..., R15 moins de modes d'adressage : instructions de calcul en mode registre + instructions LOAD /STORE instructions à 3 opérandes ARM : add R1, R4, R5 instructions conditionnelles AMD 64 bits : cmp eax, ebx bnez suite mov ecx, edx cmp eax, ebx cmovz ecx, edx
4. 17 2.2. Etages de base LI lecture d'instruction dans le cache d'instruction DE décodage CA calcul dans l'alu (ou calcul d'adresse mémoire ou de branchement) MEM accès à la mémoire dans le cache des données (pour les instructions LOAD/STORE) ER écriture résultat (modification des registres ou de PC ou du cache de données)
4. 18 Schéma d'exécution temps / étage Numéro d instruction i: i+1: i+2: i+3: LI DE CA ER LI DE CA ER LI DE CA ER LI DE CA ER 1 2 3 4 5 6 7 Etages d exécution Top d horloge Sur le top d horloge 4, il y a exécution en parallèle de l écriture résultat (ER) de l instruction i, du calcul (CA) de l instruction i + 1, du décodage (DE) de l instruction i+2 et de la lecture (LI) de l instruction i+3
4. 19 Exemples de pipeline Pentium 4 : 20 étages AMD 64 12 étages pipeline entier et 17 étages pipeline flottant, 8 premiers étages = "Fetch/Decode" + "Pack/Decode" et "Dispatch", communs aux entiers et aux flottants ARM ARM 7, 3 niveaux (lecture d'instruction, décodage, exécution)5 StrongARM (ARM 8, 9 et SA-1) 5 niveaux (lecture d'instruction, lecture des registres et test de branchement, exécution, écriture cache, écriture registre)
4. 20 2.3. Comment ça marche? Chaque étage est autonome : il contient les composants nécessaires pour réaliser l'étape d'exécution LI: accès à la file d'instructions DE : accès aux registres CA : unité de calcul ER : accès registre et mémoire de données Accès en parallèle aux ressources Registres : deux accès en lecture et un en écriture simultanément Mémoire centrale : cache d'instructions et cache de données Deux étages successifs partagent les données registres de stockages intermédiaires l'étage i écrit le résultat, l'étage i+1 lit le résultat
Exemple : Exécution de «add R2,R1,R2» suivi de «add R3,R4,R5» R2 <-R1 + R2 R3 < - R4 + R5» LI DE CA ER PC ALU Inst Données Mémoire Registres R1=10 R2=8 R3=0 R4=6 R5=3 4. 21
Exécution de «add R2,R1,R2» suivi de «add R3,R4,R5» TOP 1 LI DE CA ER add R2,R1,R2 PC Add R2 R1 R2 ALU Inst Données Mémoire Registres R1=10 R2=8 R3=0 R4=6 R5=3 4. 22
Exécution de «add R2,R1,R2» suivi de «add R3,R4,R5» TOP 2 LI DE CA ER add R3,R4,R5 PC Add R3 R4 R5 accès à R1 et R2 Add R2 10 8 ALU Inst Données Mémoire Registres R1=10 R2=8 R3=0 R4=6 R5=3 4. 23
Exécution de «add R2,R1,R2» suivi de «add R3,R4,R5» TOP 3 LI DE CA ER PC accès à R4 et R5 Add R3 6 3 10 + 8 ALU Add R2 18 Inst Données Mémoire Registres R1=10 R2=8 R3=0 R4=6 R5=3 4. 24
Exécution de «add R2,R1,R2» suivi de «add R3,R4,R5» TOP 4 LI DE CA ER PC 6 + 3 ALU Add R3 9 accès à R2 Inst Données Mémoire Registres R1=10 R2=8 R3=0 R4=6 R5=3 18 4. 25
Exécution de «add R2,R1,R2» suivi de «add R3,R4,R5» TOP 5 LI DE CA ER accès à R3 PC ALU Inst Données Mémoire Registres R1=10 R2=18 R3=0 R4=6 R5=3 9 4. 26
4. 27 L'exécution en parallèle rend le contrôle de l'exécution plus complexe : Gestion de l'accès simultané aux ressources partagées Aléas de données : un étage peut lire une donnée avant qu'elle ait été mise à jour Gestion des instructions de branchement : les instructions dans le pipeline ne sont pas forcément exécutées Aléas de contrôle Accès à des données d'autres unités fonctionnelles (cas superscalaire) Aléas structurel 3. Aléas du pipeline
4. 28 3.1. Aléas de données lecture avant écriture d un résultat, écriture du résultat avant lecture de la donnée (exécution dans le désordre) Exemple: ADD R1, R2, R3 SUB R4, R1, R5 instruction ADD LI DE CA ER SUB LI DE CA ER Ecriture de R1 Aléa de type «lecture avant écriture» lecture de R1
4. 29 Solution 1 : suspension d'exécution ADD R1, R2, R3 SUB R4, R1, R5 Ecriture de R1 ADD LI DE CA ER SUB LI DE CA ER lecture de R1 Ecriture de R1 ADD LI DE CA ER SUB LI susp susp DE CA ER lecture de R1
4. 30 Solution 2 : bypass la sortie de l ALU est utilisée directement Pour l exemple «add R1,R2,R3» suivi de «add R6,R1,R5», lors du décodage de «add R6,R1,R5», on utilise la valeur de bypass (i.e sortie de l'alu après calcul de R2 + R3) au lieu d aller lire la valeur de R1 dans la RAM. LI DE CA ER PC accès à R1 et R5 Add R6 8 3 8 8+0 ALU R1 8
4. 31 Exemple de bypass avec l'arm SA-110 Programme LDR r1,[r0 + 4] MOV r2,r1
4. 32 3.2. Aléas de contrôle Les instructions qui suivent une instruction de branchement (jmp) ne doivent pas être exécutées. Pourtant, elles sont dans le pipeline suspension du pipeline i : jmp 360 i + 1 i + 2 i + 3 LI DE LI A la fin du décodage du «jmp» on sait qu il s agit d un saut - il ne faut pas exécuter les instructions suivantes - il faut suspendre l exécution jusqu à ce que l adresse de branchement soit connue étage ER
4. 33 A la fin de l étage ER du jmp, on connaît l adresse de branchement (PC a été modifié) l exécution peut reprendre à l'adresse de branchement H 1 2 3 4 i : jmp 360 LI DE CA ER 5 i + 1 LI susp susp i + 2 i + 3 inst 360 susp susp susp LI DE CA ER Pénalité de 3 tops d horloge!!! Problème : - on a exécuté l'étape LI de i+1 inutilement - l'étape LI est un accès mémoire donc coûteux
4. 34 Solution : branchement avec délai jmp 360 i + 1 LI DE CA ER LI DE CA ER Toujours exécutée i + 2 i + 3 susp susp susp LI DE CA ER inst 360 Si i est une instruction de saut, on exécute toujours l'intruction i+1 Après décodage du jmp, on sait qu il faut suspendre l instruction i+2 pas d étape LI inutile Le compilateur se charge de choisir l'instruction qu'il faut placer dans le délai
4. 35 Branchement avec délai : Optimisation de code Objectif : remplir au mieux le pipeline tout en gardant la sémantique du programme le compilateur «choisit» l instruction à mettre derrière le branchement réorganisation du code ou insertion de NOP (instruction "no operation") Insertion de NOP ADD R1,R2,R3 jmp boucle délai Instruction avant ADD R1,R2,R3 jmp boucle délai ADD R1,R2,R3 jmp boucle NOP jmp boucle ADD R1,R2,R3 Généré par compilateur
4. 36 Branchement avec délai: cas des branchements conditionnels (bcc) on sait dans l étage DE du bcc si le branchement doit être pris ou non avec le délai, on n'a aucune suspension dans le cas où le branchement est pris Bcc 360 i + 1 bcc PRIS bcc NON PRIS Toujours exécutée LI DE CA ER LI DE CA ER susp susp LI DE CA ER LI DE CA ER Inst i + 2 inst 360
4. 37 Dans le cas des branchements conditionnels, pour savoir quelle instruction mettre dans le délai, il faut décider si le branchement sera pris ou non : c'est la prédiction de branchement Une première prédiction est faite de façon statique (on choisit d'office que le branchement est pris par exemple); le compilateur tient compte de ce choix pour réorganiser le code Ensuite on corrige les prédictions de façon dynamique : la partie contrôle change la prédiction si elle était mauvaise
4. 38 Branchement conditionnel avec délai: Optimisation de code Prédiction STATIQUE Instruction avant ADD R1,R2,R3 si R2 =0 alors délai MOV R0,R1 SUB R5,R6,R7 pas de dépendance entre inst. avant et condition de test si R2 =0 alors ADD R1,R2,R3 MOV R0,R1 SUB R5,R6,R7 Instruction cible ADD R1,R2,R3 si R1 =0 alors délai MOV R0,R1 SUB R5,R6,R7 dépendance entre inst. avant et condition de test. spéculation branch pris ADD R1,R2,R3 si R1 =0 alors SUB R5,R6,R7 MOV R0,R1 SUB R5,R6,R7 Instruction après ADD R1,R2,R3 si R1 =0 alors délai MOV R0,R1 SUB R5,R6,R7 dépendance entre inst. avant et condition de test. spéculation branch non pris ADD R1,R2,R3 si R1 =0 alors MOV R0,R1 SUB R5,R6,R7
4. 39 Prédiction de branchement DYNAMIQUE : (bas niveau, par la partie contrôle) Pendant que le processeur travaille, l unité de pré-extraction des instructions travaille et lit les instructions qu il faudra exécuter bientôt prédiction spéculative du fait que le branchement courant sera pris ou pas. Algorithme de Smith (prédiction à 2 bits): pris non pris non pris non pris non pris P FP FNP NP pris pris pris P: Pris FP: Faiblement Pris FNP: Faiblement Non Pris NP: Non Pris
4. 40 Pourquoi tant de mal? Instructions de branchement : 20% des instructions d un programme Branchement conditionnel pris dans 60% des cas Branchement pris - des instructions ont été chargées dans le pipeline inutilement (il faut stopper leur exécution) - l instruction peut ne pas être dans la file des instructions (ni dans le cache d instruction, ni dans la mémoire centrale) -> accès disque -> coûteux! Branchements avec délais + optimisation de code : dans les DSP (ex : téléphones portables) Dans les CPU actuels, la prédiction des branchements permet d'anticiper l'exécution dans le désordre
4. 41 4. Une version pipeline de PROCSI: PIPSI Pipeline de 4 étages: LI (instruction fetch), DE (decode), EX (execute), EC (écriture) Opérations arithmétiques/logiques : seulement modes registre/registre et immédiat / registre Accès mémoire par instruction load/store en mode direct et indirect Toutes les instructions sont codées sur 2 mots de 16 bits Cache de données (1 cycle processeur) Cache d instruction (1 cycle processeur) Le banc de registres internes (REG) permet 2 accès lecture et un accès écriture simultanément (i.e sur un même top)
out1 out2 4. 42 Data-out FEtch DEcode EXecute ECriture RD1 RD2 res ex ROP ROP de ROP ex PC +2 Pc de Pc ex Data_low Data_high IR Ir de Ir ex Cache instruction Address 3 3 in 3 Ad-read1 REG Ad-read2 Ad-write Adress Cache données Data-in
4. 43 FE accès mémoire inst. 1 er mot dans ir 2 ème mot dans rop DE recherche d'opérandes EX calculs lecture mém. data EC écriture reg écriture mém. data add R7, #1 FE ir <- mem i [pc] rop <- mem i [pc+1] pc <- pc + 2 DE rd1 <- rop rd2 <- reg[ir[0..2]] pc de <- pc ir de <- ir rop de <- rop EX res ex <- rd1 + rd2 pc ex <- pc de ir ex <- ir de rop ex <- rop de EC reg[ir ex [0..2]] <- res ex store [80], R0 FE ir <- mem i [pc] rop <- mem i [pc+1] pc <- pc + 2 DE rd1 <- reg[ir[3..5]] pc de <- pc ir de <- ir rop de <- rop EX res ex <- rd1 pc ex <- pc de ir ex <- ir de rop ex <- rop de EC mem d [rop ex ] <- res ex