Unité Centrale de Traitement Processeur

Unité Centrale de Traitement Processeur

Introduction on a vu comment des éléments de logique combinatoire ou séquentielle permettaient de faire des additions, des comparaisons lire ou écrire dans des registres lire ou écrire dans de la mémoire on va voir maintenant comment exécuter des séquences cohérentes d'opérations : instructions Cf le cours de Logiciels de Base approche simplifiée, basée sur l'architecture MIPS Référence pour les figures : Patterson et Hennessy : Computer organisation and design, the hardware/software interface, 5th edition, Morgan Kaufmann (2014)

Introduction étude d'un sous-ensemble des instructions du processeur MIPS incluant : l'accès aux données mémoire en lecture (load, lw) et en écriture (store, sw) les opérations arithmétiques et logiques add, sub, and, or, slt l'instruction de branchement conditionnel sur égalité beq l'instruction de saut inconditionnel j

Introduction toutes les instructions vont d'abord
aller chercher dans la mémoire du programme l'instruction qui correspond au contenu du registre de programme (Program Counter) décoder l'instruction et lire un ou deux registres indiqués dans les champs de l'instruction (rs, rt) ensuite ça va dépendre de la classe de l'instruction, mais les comportements sont souvent les mêmes utilisation de l'ALU arithmétique, logique calcul d'adresse accès mémoire et/ou aux registres PH Chap 5

Introduction représentation schématique

Introduction représentation schématique
Le PC peut recevoir l'adresse par une simple incrémentation

Le PC peut recevoir l'adresse par une simple incrémentation ou par une instruction (saut)

Les données écrites dans les registres peuvent venir de l'ALU

Les données écrites dans les registres peuvent venir de l'ALU ou de la mémoire

l'origine des instructions comme celle des données est multiple on ne peut pas connecter simplement des lignes électriques différentes

Pour choisir le bon chemin, on va utiliser des multiplexeurs

Introduction représentation schématique

utilisation de 3 multiplexeurs pour choisir l'origine des données

une unité de contrôle utilisant l'instruction permet de gérer le fonctionnement des circuits et des multiplexeurs

l'incrémentation du PC est gérée par la sortie de l'ALU utilisée pour effectuer la comparaison pour l'instruction beq

plan du cours réalisation d'une ALU effectuant les opérations de base arithmétiques et logiques CPU en mode cycle unique réalisation d'un chemin de données réalisation une unité de contrôle CPU en mode multicycle chemin de données contrôle gestion des interruptions CPU en mode pipeline gestion des aléas Hiérarchie des mémoires. Caches

Implémentation d'une ALU
réalisation des opérations arithmétiques : addition et soustraction logiques : ET et OU on a vu comment réaliser un additionneur en logique combinatoire on le considère maintenant comme une boîte noire a b + CarryIn CarryOut Result Cf PH Appendix B(basics of logic design)

ALU 1 bit addition opérations logiques ET, OU Combien de bits pour coder Op ? Op 1 2 Result + a b CarryIn CarryOut Cf PH Appendix B(basics of logic design)

réalisation d'une ALU 32 bits Op le CarryIn du bit le moins significatif est forcé à 0 a1 b1 Résultat1 ALU31 a31 b31 Résultat31 CarryOut ALU1 CarryIn a0 ALU0 CarryIn Résultat0 b0 CarryOut le CarryIn du bit le plus significatif est perdu

pour effectuer la soustraction a−b=a+ b +1 CarryIn du bit le moins significatif forcé à 1 pour la soustraction + a b CarryOut Op 1 2 Result b Invert CarryIn

pour effectuer les autres opérations logiques utilisation du théorème de De Morgan NOR : NAND : a+b = a . b a.b = a + b + a b CarryIn CarryOut Op 1 2 Result b Invert a Invert

notre ALU effectue les opérations arithmétiques et logiques de base on voudrait qu'elle puisse exécuter l'instruction slt (set on less than) le résultat vaut 1 si rs < rt sinon 0 met les 31 bits de poids fort à 0 et le bit le moins significatif à 0 ou 1 suivant le résultat de la comparaison une opération supplémentaire pour le multiplexeur : Less

nouvelle version de l'ALU 1 bit : + a b CarryIn CarryOut Op 1 2 Result binvert a invert 3 Less

nouvelle version de l'ALU 32 bits : pour les 31 bits de poids fort, on connecte l'entrée Less à 0 et ce sera la sortie de l'ALU 1 bit correspondante (ALU31 à ALU1) le bit le moins significatif (ALU0) doit être à 1 si a<b. c'est la valeur du bit de signe du résultat de a-b le bit de signe du résultat de a-b est le bit de poids le plus fort de l'additionneur (qui n'est pas la sortie de l'ALU31) nécessité d'une ALU31 spécifique pour le bit de poids le plus fort avec une sortie spéciale (Set) donnant le bit de signe (bit de sortie de l'additioneur) et utilisée uniquement pour l'opération slt

+ a b CarryIn CarryOut Op 1 2 Result b Invert a Invert 3 Less Set

ALU 31 : il faut aussi détecter les dépassements de capacité + a b CarryIn Op 1 2 Result b Invert a Invert 3 Less Set Détection du dépassement de capacité Overflow Cf TD

CarryIn ALU0 Less CarryOut a0 b0 Résultat0 ALU1 a1 b1 Résultat1 ALU2 a2 b2 Résultat2 ALU31 a31 b31 Résultat31 Set Overflow Operation binvert ainvert v ALU 32 bits

si l'on veut aussi effectuer des branchements conditionnels, il faut pouvoir effectuer des tests de comparaison sur le contenu de 2 registres on va tester si a-b vaut 0 si oui a=b si non a≠b la façon la plus simple de tester l'égalité est Zero= Résultat31+Résultat Résultat1+Résultat0

CarryIn ALU0 Less CarryOut a0 b0 Résultat0 ALU1 a1 b1 Résultat1 ALU2 a2 b2 Résultat2 ALU31 a31 b31 Résultat31 Set Overflow Operation binvert ainvert Zero ALU 32 bits

CarryIn ALU0 Less CarryOut a0 b0 Résultat0 ALU1 a1 b1 Résultat1 ALU2 a2 b2 Résultat2 ALU31 a31 b31 Résultat31 Set Overflow Operation binvert ainvert v Zero ALU 32 bits

Représentation symbolique a b ALU operation CarryOut Zero Result Overflow 32 4

Réalisation d'un chemin de données
les éléments du processeur qui permettent d'exécuter une opération arithmétique ou logique la liste des éléments nécessaires va dépendre du type de l'instruction

rappel : toutes les instructions vont d'abord aller chercher dans la mémoire du programme l'instruction qui correspond au contenu du registre de programme (Program Counter) : Instruction fetch (IF) décoder l'instruction et lire un ou deux registres indiqués dans les champs de l'instruction (rs, rt) : Instruction decode (ID) ensuite ça va dépendre de la classe de l'instruction, mais les comportements sont souvent les mêmes utilisation de l'ALU : Execute (EX) arithmétique, logique calcul d'adresse accès mémoire : Memory Access (Mem) accès aux registres : Write back (WB)

pour réaliser un chemin de données, on a besoin d'un registre pour stocker l'adresse de l'instruction d'une mémoire pour stocker les instructions à des adresses données d'un additionneur pour calculer l'adresse de l'instruction suivante PC adresse de l'instruction instruction Mémoire des instructions Add

ensuite on peut assembler les éléments pour obtenir une partie du chemin de données allant chercher une instruction et incrémentant le compteur de programme pour obtenir l'adresse de l'instruction suivante adresse de l'instruction instruction Mémoire des instructions PC Add 4

instructions de type R (MIPS) lisent le contenu de 2 registres effectuent une opération arithmétique ou logique écrivent le résultat dans un registre add, sub, and, or, slt add $t0,$t1,$t2 place la somme de $t1 et $t2 dans $t0 les 32 registres de travail de l'architecture MIPS sont regroupés dans une structure appelée register file chaque registre a une utilisation spécifique registres pour les variables : $s0, $s1, ... registres pour les données temporaires : $t0, $t1, ... stack pointer : $sp, zéro : $zero, registre d'adresse de retour : $ra les registres sont identifiés par leur numéro (cf cours LdB) $zero → 0 $t0 → $t7 : 8 →15 $s0 → $s7 : 16 →23

éléments nécessaires pour implémenter une instruction de type R : sert à stocker temporairement les données manipulées par l'ALU stocke en lecture les données provenant de la mémoire avant de les traiter avec l'ALU stocke en écriture les résultats de l'ALU avant de les écrire en mémoire Registres 5 numéro des registres Données en entrée Registre lecture #1 lecture #2 écriture en sortie Ecriture registre TD

éléments nécessaires pour implémenter une instruction de type R : Registres 5 numéro des registres Données en entrée Registre lecture #1 lecture #2 écriture en sortie Ecriture registre ALU Code opération Zéro Résultat ? 4

instructions d'accès à la mémoire lw $t1, offset_value($t2) sw $t1, offset_value($t2) lw : lu de la mémoire et chargé dans le registre $t1 → mémoire calcul de l'adresse en ajoutant offset_value à l'adresse de base stockée dans $t2 → ALU offset_value est un entier signé de 16 bits → il va falloir l'étendre à 32 bits en recopiant le bit de signe de l'entier 16 bits dans les bits de poids forts de l'entier 32 bits → module dédié

modules nécessaires : les éléments déjà vus register file ALU pour incrémenter le PC une unité mémoire dans laquelle on va lire ou écrire les données module pour l'extension de l'offset de 16 bits non signés à 32 bits signés Mémoire données adresse données en écriture lecture Contrôle écriture mémoire lecture mémoire Extension du bit de signe de l'offset 16 32

instructions de branchement beq $t1, $t2, offset 3 opérandes 2 registres dont les contenus vont être comparés un offset pour calculer la nouvelle adresse de l'instruction à exécuter en cas d'égalité des registres l'adresse de base est celle de l'instruction qui suit beq (déjà calculé quand on va chercher l'intruction en cours) l'offset est basé sur le "mot" de 4 octets : on peut le décaler à gauche de 2 bits de façon à augmenter l'échelle d'un facteur 4)

instructions de branchement beq $t1, $t2, offset 3 opérandes on prend le branchement si les contenus des registres sont égaux : l'adresse de la prochaine instruction est le nouveau contenu du PC + l'offset sinon le branchement n'est pas pris et l'adresse de la prochaine instruction est simplement le nouveau contenu du PC

PC+4 (venant du chemin de données) ALU Adresse de branchement Somme Décalage à gauche de 2 Registres Registre lecture #1 code opération 4 Instruction Registre lecture #2 Données lecture #1 ALU Logique de contrôle Zéro Données lecture #2 Registre écriture Données écriture Ecriture registre Extension du bit de signe 16 32

on vient de voir comment réaliser les composants d'un chemin de données pour différents types d'instructions on va voir maintenant comment assembler ces éléments pour réaliser un chemin de données unique capable d'exécuter toutes les instructions cas le plus simple où chaque instruction est exécutée en un seul cycle de l'horloge chaque ressource ne peut être utilisée qu'une fois par instruction ® duplication des ressources sources de données multiples et utilisation de multiplexeurs gérés par des signaux de contrôle

Exemple : exécution des instructions de type R et de recherche en mémoire les chemins de données pour les deux types d'opérations sont assez semblables, mais : les opérations de type R utilisent l'ALU avec des entrées provenant de 2 registres stockent le résultat de l'ALU dans un registre du register file les opérations d'accès à la mémoire utilisent l'ALU pour le calcul de l'adresse avec pour second opérande la valeur d'offset provenant directement de l'instruction stockent le contenu de la mémoire dans le register file

Exemple : exécution des instructions de type R et de recherche en mémoire code opération 4 Ecriture mémoire Registres Registre lecture #1 lecture #2 écriture Données Instruction Mémoire vers registre Zéro ALU Mémoire données Résultat Adresse Source ALU Données lues M u x 1 M u x 1 Ecriture registre Données à écrire Extension du bit de signe 16 32 Lecture mémoire

pour toutes les opérations envisagées, on va combiner les chemins de données vus pour les opérations de type R les opérations d'accès à la mémoire les branchements

x Add Add 4 Décal. gauche 2 bits Résultat 1 Source PC Registres Registre lecture #1 lecture #2 écriture Données Ecriture registre Ecriture mémoire Mémoire vers registre PC Lecture adresse Mém. instr. instruction (31:0) Zéro Source ALU ALU Mémoire données Adresse 1 M u x M u x Résultat M u x Données lues 1 Contrôle ALU 1 Données à écrire Destination registre Lecture mémoire Ext. bit de signe 32

Implémentation d'une unité de contrôle
prend le contenu des instructions pour gérer les signaux d'écriture, la sélection sur les multiplexeurs, le contrôle de l'ALU première approche simplifiée couvrant les instructions lw, sw beq add, sub, and, or, set on less than

Contrôle de l'ALU 4 bits pour le contrôle seulement 6 opérations pour notre implémentation + a b CarryOut Op 1 2 Result binvert (+CarryIn) a invert 3 Less Lignes de contrôle de l'ALU ainv binv Op1 Op0 Fonction AND OR add sub set on less than NOR

Contrôle de l'ALU 4 bits pour le contrôle seulement 6 opérations pour notre implémentation + a b CarryOut Op 1 2 Result binvert (+CarryIn) a invert 3 Less Lignes de contrôle de l'ALU ainv binv Op1 Op0 Fonction 0000 AND OR add sub set on less than NOR

Contrôle de l'ALU 4 bits pour le contrôle seulement 6 opérations pour notre implémentation + a b CarryOut Op 1 2 Result binvert (+CarryIn) a invert 3 Less Lignes de contrôle de l'ALU ainv binv Op1 Op0 Fonction 0000 AND 0001 OR 0010 add 0110 sub 0111 set on less than 1100 NOR

Contrôle de la CPU « cycle unique » rappel : format des instructions MIPS pour les instructions de type R, de branchement et d'accès à la mémoire champ rs rt rd shamt funct position des bits 31:26 25:21 20:16 15:11 10:6 5:0 instructions de type R (exemple : add rd, rs, rt ) 3510 ou 4310 offset 0:15 instructions d'accès à la mémoire (exemple : lw rt, offset(rs) ) 410 instructions de saut conditionnel (exemple : beq rs, rt, offset)

remarques : le champ d'opération (opcode) est toujours contenu dans les bits [31:26] : Op[5:0] les registres à lire sont toujours spécifiés par les champs rs [25:21] et rt [20:16] le registre de base pour les opérations d'accès en mémoire est donné par le champ rs [25:21] l'offset pour les branchements et les accès mémoire est toujours contenu dans les bits [15:0] le registre de destination est soit dans rt [20:16] pour un lw dans rd [15:11] pour les instructions de type R  nécessité d'un multiplexeur supplémentaire

les entrées de contrôle pour l'ALU vont pouvoir être générées par le champ de fonction de l'instruction (bits 0 à 5 pour les instructions de type R, cf cours LdB) un champ de 2 bits nommé ALUOp qui vaut 00 pour les add liées aux instructions lw et sw 01 pour les sub liées aux instruction beq 10 pour les instructions dont l'identité est définie par le champ de fonction

bits de contrôle de l'ALU utilise le champ de fonction et un champ de contrôle de 2 bits on va maintenant relier les champs de l'instruction au chemin de données Code opérationnel ALUOp Opération Champ de fonction Action de l'ALU Entrées de contrôle de l'ALU ainv binv Op1 Op0 LW 00 load word XXXXXX add 0010 SW store word Branch equal 01 branch equal substract 0110 R type 10 100000 100010 AND 100100 and 0000 OR 100101 or 0001 set on less than 101010 0111

table de vérité (limitée aux opérations qui requièrent un code opérationnel pour l'ALU) ALUOp Champ de fonction Opération Op3 Op2 Op1 Op0 ALUOp1 ALUOp0 F5 F4 F3 F2 F1 F0 X 0010 1 0110 0000 0001 0111 11 jamais utilisé toujours 10

table de vérité (limitée aux opérations qui requièrent un code opérationnel pour l'ALU) ALUOp Champ de fonction Opération Op3 Op2 Op1 Op0 ALUOp1 ALUOp0 F5 F4 F3 F2 F1 F0 X 0010 1 0110 0000 0001 0111 implémentation en TD

x Add Add 4 Décal. gauche 2 bits Résultat 1 Source PC instruction [25:21] Registres Registre lecture #1 lecture #2 écriture Données Ecriture registre Ecriture mémoire Mémoire vers registre PC instruction [20:16] Lecture adresse Mém. instr. instruction (31:0) Zéro Source ALU ALU Mémoire données Adresse 1 M u x M u x Résultat M u x Données lues instruction [15:11] 1 1 Données à écrire Destination registre Lecture mémoire Contrôle ALU Ext. bit de signe 32 instruction [15:0] 2 instruction [5:0] ALUOp

x Add Add 4 Décal. gauche 2 bits Résultat 1 Source PC instruction [25:21] Registres Registre lecture #1 lecture #2 écriture Données Ecriture registre Ecriture mémoire Mémoire vers registre PC instruction [20:16] Lecture adresse Mém. instr. instruction (31:0) Zéro Source ALU ALU Mémoire données Adresse M u x M u x Résultat 1 M u x Données lues instruction [15:11] 1 1 Données à écrire Destination registre Lecture mémoire Contrôle ALU Ext. bit de signe 32 instruction [15:0] Lignes de contrôle 2 instruction [5:0] ALUOp

effet des lignes de contrôle

x Add RegDest Add Contrôle Branch MemRead Décal. gauche 2 bits 4 MemWrite Résultat ALUOp 1 instruction [31:26] MemtoReg ALUSrc Source PC RegWrite instruction [25:21] Registres Registre lecture #1 lecture #2 écriture Données PC instruction [20:16] Lecture adresse Mém. instr. instruction (31:0) Zéro ALU Mémoire données Adresse M u x Résultat 1 M u x M u x Données lues instruction [15:11] 1 1 Données à écrire Contrôle ALU Ext. bit de signe 16 32 instruction [15:0] instruction [5:0]

x Add RegDest Add Contrôle Branch MemRead Décal. gauche 2 bits 4 MemWrite Résultat ALUOp 1 instruction [31:26] MemtoReg ALUSrc Source PC RegWrite instruction [25:21] Registres Registre lecture #1 lecture #2 écriture Données PC instruction [20:16] Lecture adresse Mém. instr. instruction (31:0) Zéro ALU Mémoire données Adresse 1 M u x M u x Résultat M u x Données lues instruction [15:11] 1 1 Données à écrire Contrôle ALU Ext. bit de signe 16 32 instruction [15:0] add $t1,$t2,$t3 instruction [5:0]

x Add RegDest Add Contrôle Branch MemRead Décal. gauche 2 bits 4 MemWrite Résultat ALUOp 1 instruction [31:26] MemtoReg ALUSrc Source PC RegWrite PC chargé instruction [25:21] Registres Registre lecture #1 lecture #2 écriture Données PC instruction [20:16] Lecture adresse Mém. instr. instruction (31:0) Zéro ALU Mémoire données Adresse 1 M u x M u x Résultat M u x Données lues instruction [15:11] 1 1 Données à écrire Contrôle ALU Ext. bit de signe 16 32 instruction [15:0] add $t1,$t2,$t3 instruction [5:0]

PC incrémenté de 4 M u x Add RegDest Add Contrôle Branch MemRead Décal. gauche 2 bits 4 MemWrite Résultat ALUOp 1 instruction [31:26] MemtoReg ALUSrc Source PC RegWrite instruction [25:21] Registres Registre lecture #1 lecture #2 écriture Données PC instruction [20:16] Lecture adresse Mém. instr. instruction (31:0) Zéro ALU Mémoire données Adresse 1 M u x M u x Résultat M u x Données lues instruction [15:11] 1 1 Données à écrire Contrôle ALU Ext. bit de signe 16 32 instruction [15:0] add $t1,$t2,$t3 instruction [5:0]

x Add RegDest Add Contrôle Branch MemRead Décal. gauche 2 bits 4 MemWrite Résultat ALUOp 1 instruction [31:26] MemtoReg ALUSrc Source PC RegWrite $t3 $t2 et $t3 chargés dans l'ALU $t2 instruction [25:21] Registres Registre lecture #1 lecture #2 écriture Données PC instruction [20:16] Lecture adresse Mém. instr. instruction (31:0) Zéro ALU Mémoire données Adresse 1 M u x M u x Résultat M u x Données lues instruction [15:11] 1 1 Données à écrire Contrôle ALU Ext. bit de signe 16 32 instruction [15:0] add $t1,$t2,$t3 instruction [5:0]

x Add RegDest Add Contrôle Branch MemRead Décal. gauche 2 bits 4 MemWrite Résultat ALUOp 1 instruction [31:26] MemtoReg ALUSrc Source PC RegWrite l'ALU fait l'addition instruction [25:21] Registres Registre lecture #1 lecture #2 écriture Données PC instruction [20:16] Lecture adresse Mém. instr. instruction (31:0) Zéro ALU Mémoire données Adresse 1 M u x M u x Résultat M u x Données lues instruction [15:11] 1 1 Données à écrire Contrôle ALU Ext. bit de signe 16 32 instruction [15:0] add $t1,$t2,$t3 instruction [5:0]

x Add RegDest Add Contrôle Branch MemRead Décal. gauche 2 bits 4 MemWrite Résultat ALUOp 1 instruction [31:26] MemtoReg ALUSrc Source PC RegWrite instruction [25:21] Registres Registre lecture #1 lecture #2 écriture Données PC instruction [20:16] Lecture adresse Mém. instr. instruction (31:0) Zéro ALU Mémoire données Adresse 1 M u x M u x Résultat M u x Données lues instruction [15:11] 1 1 Données à écrire résultat chargé dans $t1 Contrôle ALU $t1 Ext. bit de signe 16 32 instruction [15:0] add $t1,$t2,$t3 instruction [5:0]

x Add RegDest Add Contrôle Branch MemRead Décal. gauche 2 bits 4 MemWrite Résultat ALUOp 1 instruction [31:26] MemtoReg ALUSrc Source PC RegWrite pas d'accès mémoire instruction [25:21] Registres Registre lecture #1 lecture #2 écriture Données PC instruction [20:16] Lecture adresse Mém. instr. instruction (31:0) Zéro ALU Mémoire données Adresse 1 M u x M u x Résultat M u x Données lues instruction [15:11] 1 1 Données à écrire Contrôle ALU Ext. bit de signe 16 32 instruction [15:0] add $t1,$t2,$t3 instruction [5:0]

x Add RegDest Add Contrôle Branch MemRead Décal. gauche 2 bits 4 MemWrite Résultat ALUOp 1 instruction [31:26] MemtoReg ALUSrc Source PC RegWrite instruction [25:21] Registres Registre lecture #1 lecture #2 écriture Données PC instruction [20:16] Lecture adresse Mém. instr. instruction (31:0) Zéro ALU Mémoire données Adresse 1 M u x M u x Résultat M u x Données lues instruction [15:11] 1 1 Données à écrire Contrôle ALU Ext. bit de signe 16 32 instruction [15:0] lw $t1,offset($t2) instruction [5:0]

x Add RegDest Add Contrôle Branch MemRead Décal. gauche 2 bits 4 MemWrite Résultat ALUOp 1 instruction [31:26] MemtoReg ALUSrc Source PC RegWrite PC chargé instruction [25:21] Registres Registre lecture #1 lecture #2 écriture Données PC instruction [20:16] Lecture adresse Mém. instr. instruction (31:0) Zéro ALU Mémoire données Adresse 1 M u x M u x Résultat M u x Données lues instruction [15:11] 1 1 Données à écrire Contrôle ALU Ext. bit de signe 16 32 instruction [15:0] lw $t1,offset($t2) instruction [5:0]

PC incrémenté de 4 M u x Add RegDest Add Contrôle Branch MemRead Décal. gauche 2 bits 4 MemWrite Résultat ALUOp 1 instruction [31:26] MemtoReg ALUSrc Source PC RegWrite instruction [25:21] Registres Registre lecture #1 lecture #2 écriture Données PC instruction [20:16] Lecture adresse Mém. instr. instruction (31:0) Zéro ALU Mémoire données Adresse 1 M u x M u x Résultat M u x Données lues instruction [15:11] 1 1 Données à écrire Contrôle ALU Ext. bit de signe 16 32 instruction [15:0] lw $t1,offset($t2) instruction [5:0]

x Add RegDest Add Contrôle Branch MemRead Décal. gauche 2 bits 4 MemWrite Résultat ALUOp 1 instruction [31:26] MemtoReg ALUSrc Source PC RegWrite $t2 lu et chargé dans l'ALU offset étendu à 32 bits et chargé dans l'ALU $t2 instruction [25:21] Registres Registre lecture #1 lecture #2 écriture Données PC instruction [20:16] Lecture adresse Mém. instr. instruction (31:0) Zéro ALU Mémoire données Adresse M u x M u x Résultat 1 M u x Données lues instruction [15:11] 1 1 Données à écrire Contrôle ALU Ext. bit de signe 16 32 instruction [15:0] lw $t1,offset($t2) instruction [5:0]

x Add RegDest Add Contrôle Branch MemRead Décal. gauche 2 bits 4 MemWrite Résultat ALUOp 1 instruction [31:26] MemtoReg ALUSrc Source PC RegWrite offset + $t2 est l'adresse mémoire instruction [25:21] Registres Registre lecture #1 lecture #2 écriture Données PC instruction [20:16] Lecture adresse Mém. instr. instruction (31:0) Zéro ALU Mémoire données Adresse 1 M u x M u x Résultat M u x Données lues instruction [15:11] 1 1 Données à écrire Contrôle ALU Ext. bit de signe 16 32 instruction [15:0] lw $t1,offset($t2) instruction [5:0]

x Add RegDest Add Contrôle Branch MemRead Décal. gauche 2 bits 4 MemWrite Résultat ALUOp 1 instruction [31:26] MemtoReg ALUSrc Source PC RegWrite instruction [25:21] Registres Registre lecture #1 lecture #2 écriture Données PC instruction [20:16] Lecture adresse Mém. instr. instruction (31:0) Zéro ALU Mémoire données Adresse 1 M u x M u x Résultat M u x Données lues instruction [15:11] 1 1 mémoire lue Données à écrire Contrôle ALU Ext. bit de signe 16 32 instruction [15:0] lw $t1,offset($t2) instruction [5:0]

x Add RegDest Add Contrôle Branch MemRead Décal. gauche 2 bits 4 MemWrite Résultat ALUOp 1 instruction [31:26] MemtoReg ALUSrc Source PC RegWrite $t1 le contenu est stocké dans $t1 instruction [25:21] Registres Registre lecture #1 lecture #2 écriture Données PC instruction [20:16] Lecture adresse Mém. instr. instruction (31:0) Zéro ALU Mémoire données Adresse M u x M u x Résultat 1 M u x Données lues instruction [15:11] 1 1 Données à écrire Contrôle ALU Ext. bit de signe 16 32 instruction [15:0] lw $t1,offset($t2) instruction [5:0]

x Add RegDest Add Contrôle Branch MemRead Décal. gauche 2 bits 4 MemWrite Résultat ALUOp 1 instruction [31:26] MemtoReg ALUSrc Source PC RegWrite PC chargé instruction [25:21] Registres Registre lecture #1 lecture #2 écriture Données PC instruction [20:16] Lecture adresse Mém. instr. instruction (31:0) Zéro ALU Mémoire données Adresse 1 M u x M u x Résultat M u x Données lues instruction [15:11] 1 1 Données à écrire Contrôle ALU Ext. bit de signe 16 32 instruction [15:0] beq $t1,$t2,offset instruction [5:0]

PC incrémenté de 4 M u x Add RegDest Add Contrôle Branch MemRead Décal. gauche 2 bits 4 MemWrite Résultat ALUOp 1 instruction [31:26] MemtoReg ALUSrc Source PC RegWrite instruction [25:21] Registres Registre lecture #1 lecture #2 écriture Données PC instruction [20:16] Lecture adresse Mém. instr. instruction (31:0) Zéro ALU Mémoire données Adresse 1 M u x M u x Résultat M u x Données lues instruction [15:11] 1 1 Données à écrire Contrôle ALU Ext. bit de signe 16 32 instruction [15:0] beq $t1,$t2,offset instruction [5:0]

calcul de l'adresse en cas de branchement M u x Add RegDest Add Contrôle Branch MemRead Décal. gauche 2 bits 4 MemWrite Résultat ALUOp 1 instruction [31:26] MemtoReg ALUSrc Source PC RegWrite instruction [25:21] Registres Registre lecture #1 lecture #2 écriture Données PC instruction [20:16] Lecture adresse Mém. instr. instruction (31:0) Zéro ALU Mémoire données Adresse 1 M u x M u x Résultat M u x Données lues instruction [15:11] 1 1 Données à écrire Contrôle ALU Ext. bit de signe 16 32 instruction [15:0] beq $t1,$t2,offset instruction [5:0]

x Add RegDest Add Contrôle Branch MemRead Décal. gauche 2 bits 4 MemWrite Résultat ALUOp 1 instruction [31:26] MemtoReg ALUSrc Source PC RegWrite $t1 et $t2 chargés instruction [25:21] Registres Registre lecture #1 lecture #2 écriture Données PC instruction [20:16] Lecture adresse Mém. instr. instruction (31:0) Zéro ALU Mémoire données Adresse 1 M u x M u x Résultat M u x Données lues instruction [15:11] 1 1 Données à écrire Contrôle ALU Ext. bit de signe 16 32 instruction [15:0] beq $t1,$t2,offset instruction [5:0]

x Add RegDest Add Contrôle Branch MemRead Décal. gauche 2 bits 4 MemWrite Résultat ALUOp 1 instruction [31:26] MemtoReg ALUSrc Source PC RegWrite soustraction de $t1 et $t2 instruction [25:21] Registres Registre lecture #1 lecture #2 écriture Données PC instruction [20:16] Lecture adresse Mém. instr. instruction (31:0) Zéro ALU Mémoire données Adresse 1 M u x M u x Résultat M u x Données lues instruction [15:11] 1 1 Données à écrire Contrôle ALU Ext. bit de signe 16 32 instruction [15:0] beq $t1,$t2,offset instruction [5:0]

x Add RegDest Add Contrôle Branch MemRead Décal. gauche 2 bits 4 MemWrite Résultat ALUOp 1 instruction [31:26] MemtoReg ALUSrc Source PC RegWrite instruction [25:21] Registres Registre lecture #1 lecture #2 écriture Données PC instruction [20:16] Lecture adresse Mém. instr. instruction (31:0) Zéro la source du PC dépend du zéro du résultat ALU Mémoire données Adresse 1 M u x M u x Résultat M u x Données lues instruction [15:11] 1 1 Données à écrire Contrôle ALU Ext. bit de signe 16 32 instruction [15:0] beq $t1,$t2,offset instruction [5:0]

x Add RegDest Add Contrôle Branch MemRead Décal. gauche 2 bits 4 MemWrite Résultat ALUOp 1 instruction [31:26] MemtoReg ALUSrc Source PC RegWrite pas d'accès mémoire instruction [25:21] Registres Registre lecture #1 lecture #2 écriture Données PC instruction [20:16] Lecture adresse Mém. instr. instruction (31:0) Zéro ALU Mémoire données Adresse 1 M u x M u x Résultat M u x Données lues instruction [15:11] 1 1 Données à écrire Contrôle ALU Ext. bit de signe 16 32 instruction [15:0] beq $t1,$t2,offset instruction [5:0]

x Add RegDest Add Contrôle Branch MemRead Décal. gauche 2 bits 4 MemWrite Résultat ALUOp 1 instruction [31:26] MemtoReg ALUSrc Source PC RegWrite instruction [25:21] Registres Registre lecture #1 lecture #2 écriture Données PC instruction [20:16] Lecture adresse Mém. instr. instruction (31:0) Zéro ALU Mémoire données Adresse 1 M u x M u x Résultat M u x Données lues instruction [15:11] 1 1 Données à écrire Contrôle ALU Ext. bit de signe 16 32 instruction [15:0] j address instruction [5:0]

x Add en TD : jump + combinatoire RegDest Add Contrôle Branch MemRead Décal. gauche 2 bits 4 MemWrite Résultat ALUOp 1 instruction [31:26] MemtoReg ALUSrc Source PC RegWrite instruction [25:21] Registres Registre lecture #1 lecture #2 écriture Données PC instruction [20:16] Lecture adresse Mém. instr. instruction (31:0) Zéro ALU Mémoire données Adresse 1 M u x M u x Résultat M u x Données lues instruction [15:11] 1 1 Données à écrire Contrôle ALU Ext. bit de signe 16 32 instruction [15:0] j address instruction [5:0]

implémentation multicycle
l'exécution d'une instruction par l'unité de traitement que l'on vient de décrire demande un seul cycle d'horloge l'exécution d'opérations plus complexes (par exemple une multiplication) demanderait un chemin de données et un contrôle beaucoup plus complexes la fréquence de l'horloge doit être adaptée à l'instruction la plus longue (qui n'est pas généralement la plus fréquemment utilisée) pour optimiser la vitesse de la CPU, on peut décomposer des opérations plus complexes en une série d'opérations élémentaires une autre possibilité est la technique du « pipelining » étudié plus tard...

le chemin de données devra avoir une organisation différente et posséder des registres supplémentaires pour stocker des résultats intermédiaires Instruction register PC Address Data A Instruction or data Register # Registers ALU ALUOut Memory Register # Memory data register B Data Register #

le chemin de données devra avoir une organisation différente et posséder des registres supplémentaires pour stocker des résultats intermédiaires une seule ALU (au lieu d'une ALU et de 2 additionneurs Instruction register Address Data PC A Instruction or data Register # Registers ALU ALUOut Memory Register # Memory data register B Data Register #

le chemin de données devra avoir une organisation différente et posséder des registres supplémentaires pour stocker des résultats intermédiaires une seule unité de mémoire pour les instructions et les données Instruction register Address Data PC A Instruction or data Register # Registers ALU ALUOut Memory Register # Memory data register B Data Register #

le chemin de données devra avoir une organisation différente et posséder des registres supplémentaires pour stocker des résultats intermédiaires plusieurs registres de stockage intermédiaire Instruction register PC Address Data A Instruction or data Register # Registers ALU ALUOut Memory Register # Memory data register B Data Register #

registre données A ou PC nécessité de multiplexeurs supplémentaires une seule mémoire une seule ALU M u x 1 PC Instruction [25-21] Registre instructions [20-16] [15-0] Registres Registre lecture #1 lecture #2 écriture Données M u x 1 adresse Mémoire données écriture ALU résultat zéro A M u x 1 ALUOut [15-11] B 3 M u x 1 2 4 choix de l'origine de l'adresse M u x 1 registre données B ou offset ou incrémentation du PC de 4 ou offset Registre données mémoire Ext. bit de signe Décal. gauche 2 bits 16 32

PCWriteCond PCSource PCWrite Outputs ALUOp IorD ALUSrcB MemRead Control ALUSrcA MemWrite MemtoReg RegWrite Op [5-0] IRWrite RegDest M u x 1 2 Jump address [31-0] 26 Shift left 2 28 Instruction [25-0] Instruction [31-26] PC M u x 1 PC [31-28] Instruction [25-21] Read register 1 M u x 1 Address Read data 1 A Memory Instruction [20-16] Read register 2 Zero M u x 1 MemData Instruction [15-0] Registers ALU ALU result ALUOut Write register Instruction [15-11] Read data 2 Write data B M u x 3 2 1 Instruction register 4 Write data M u x 1 Instruction [15-0] Memory data register 16 32 Sign extend Shift left 2 ALU Control Instruction [5-0]

découpage de chaque instructions en une série de pas un pas est exécuté à chaque top de l'horloge un pas peut être constitué de plusieurs opérations exécutées en parallèle à l’intérieur d’un pas, certaines opérations pourront se révéler inutiles, mais cela n’aura pas rallongé le temps d’exécution on n'effectue pas un accès mémoire et un accès registre dans le même pas en général aller chercher l'instruction décoder l'instruction exécuter l'instruction terminer l'exécution de l'instruction

PCWriteCond PCSource PCWrite Outputs ALUOp IorD ALUSrcB MemRead Control ALUSrcA MemWrite MemtoReg RegWrite Op [5-0] IRWrite RegDest M u x 1 2 Jump address [31-0] 26 Shift left 2 28 Instruction [25-0] Instruction [31-26] PC M u x 1 PC [31-28] Instruction [25-21] Read register 1 M u x 1 Address Read data 1 A Memory Instruction [20-16] Read register 2 Zero M u x 1 MemData Instruction [15-0] Registers ALU ALU result ALUOut Write register Instruction [15-11] Read data 2 Write data B M u x 3 2 1 Instruction register 4 Write data M u x 1 Instruction [15-0] Memory data register 16 32 Sign extend Shift left 2 ALU Control Instruction [5-0]

PCWriteCond PCSource PCWrite Outputs ALUOp IorD ALUSrcB MemRead Control ALUSrcA MemWrite MemtoReg RegWrite Op [5-0] IRWrite RegDest M u x 1 2 Jump address [31-0] 26 Shift left 2 28 Instruction [25-0] Instruction [31-26] PC M u x 1 PC [31-28] Instruction [25-21] Read register 1 M u x 1 Address Read data 1 A Memory Instruction [20-16] Read register 2 Zero M u x 1 MemData ALU Instruction [15-0] Registers ALU result ALUOut Write register Instruction [15-11] Read data 2 Write data B M u x 3 2 1 Instruction register 4 Write data M u x 1 Instruction [15-0] Memory data register 16 32 Sign extend Shift left 2 ALU Control Instruction [5-0] 1. aller chercher l'instruction

PCWriteCond PCSource PCWrite Outputs ALUOp IorD ALUSrcB 1 MemRead Control ALUSrcA MemWrite MemtoReg RegWrite Op [5-0] IRWrite RegDest M u x 1 2 1 Jump address [31-0] 26 Shift left 2 28 Instruction [25-0] Instruction [31-26] PC M u x 1 PC [31-28] Instruction [25-21] Read register 1 M u x 1 Address Read data 1 A Memory Instruction [20-16] Read register 2 Zero M u x 1 MemData Instruction [15-0] Registers ALU ALU result ALUOut Write register Instruction [15-11] Read data 2 Write data B M u x 3 2 1 Instruction register 4 Write data M u x 1 Instruction [15-0] IR <= Memory[PC] Memory data register 16 32 Sign extend Shift left 2 ALU Control Instruction [5-0] 1. aller chercher l'instruction

PCWriteCond PCSource PCWrite Outputs ALUOp IorD ALUSrcB 1 MemRead Control ALUSrcA MemWrite MemtoReg RegWrite Op [5-0] IRWrite RegDest M u x 1 2 1 Jump address [31-0] 26 Shift left 2 28 Instruction [25-0] Instruction [31-26] PC M u x 1 PC [31-28] Instruction [25-21] Read register 1 M u x 1 dérivé du langage Verilog pour : charger dans le registre IR le contenu de la mémoire à l'adresse « PC » Address Read data 1 A Memory Instruction [20-16] Read register 2 Zero M u x 1 MemData Registers ALU Instruction [15-0] ALU result ALUOut Write register Instruction [15-11] Read data 2 Write data B M u x 3 2 1 Instruction register 4 Write data M u x 1 Instruction [15-0] IR <= Memory[PC] Memory data register 16 32 Sign extend Shift left 2 ALU Control Instruction [5-0] 1. aller chercher l'instruction

PCWriteCond PCSource PCWrite Outputs ALUOp 00 IorD ALUSrcB 01 1 MemRead Control ALUSrcA MemWrite MemtoReg RegWrite Op [5-0] IRWrite RegDest M u x 1 2 1 Jump address [31-0] 26 Shift left 2 28 Instruction [25-0] Instruction [31-26] PC M u x 1 PC [31-28] Instruction [25-21] Read register 1 M u x 1 Address Read data 1 A Memory Instruction [20-16] Read register 2 Zero M u x 1 MemData Instruction [15-0] Registers ALU ALU result ALUOut Instruction [15-11] Write register Read data 2 Write data B M u x 3 2 1 Instruction register 4 Write data M u x 1 0010 Instruction [15-0] IR <= Memory[PC] PC <= PC+4 Memory data register 16 32 Sign extend Shift left 2 ALU Control Instruction [5-0] 1. aller chercher l'instruction

PCWriteCond PCSource PCWrite Outputs ALUOp IorD ALUSrcB MemRead Control ALUSrcA MemWrite MemtoReg RegWrite Op [5-0] IRWrite RegDest M u x 1 2 Jump address [31-0] 26 Shift left 2 28 Instruction [25-0] Instruction [31-26] PC M u x 1 PC [31-28] Instruction [25-21] Read register 1 M u x 1 Address Read data 1 A Memory Instruction [20-16] Read register 2 Zero M u x 1 MemData ALU Instruction [15-0] Registers ALU result ALUOut Write register Instruction [15-11] Read data 2 Write data B M u x 3 2 1 Instruction register 4 Write data M u x 1 Instruction [15-0] Memory data register 16 32 Sign extend Shift left 2 ALU Control Instruction [5-0] 2. décoder l'instruction

A <= Reg[IR[25:21]] PCWriteCond PCSource PCWrite Outputs ALUOp IorD ALUSrcB MemRead Control ALUSrcA MemWrite MemtoReg RegWrite Op [5-0] IRWrite RegDest M u x 1 2 Jump address [31-0] 26 Shift left 2 28 Instruction [25-0] Instruction [31-26] PC M u x 1 PC [31-28] Instruction [25-21] Read register 1 M u x 1 Address Read data 1 A Memory Instruction [20-16] Read register 2 Zero M u x 1 MemData ALU Instruction [15-0] Registers ALU result ALUOut Write register Instruction [15-11] Read data 2 Write data B M u x 3 2 1 Instruction register 4 Write data M u x 1 Instruction [15-0] Memory data register 16 32 Sign extend Shift left 2 ALU Control Instruction [5-0] 2. décoder l'instruction

A <= Reg[IR[25:21]] B <= Reg[IR[20:16]] PCWriteCond PCSource PCWrite Outputs ALUOp IorD ALUSrcB MemRead Control ALUSrcA MemWrite MemtoReg RegWrite Op [5-0] IRWrite RegDest M u x 1 2 Jump address [31-0] 26 Shift left 2 28 Instruction [25-0] Instruction [31-26] PC M u x 1 PC [31-28] Instruction [25-21] Read register 1 M u x 1 Address Read data 1 A Memory Instruction [20-16] Read register 2 Zero M u x 1 MemData ALU Instruction [15-0] Registers ALU result ALUOut Write register Instruction [15-11] Read data 2 Write data B M u x 3 2 1 Instruction register 4 Write data M u x 1 Instruction [15-0] Memory data register 16 32 Sign extend Shift left 2 ALU Control Instruction [5-0] 2. décoder l'instruction

A <= Reg[IR[25:21]] B <= Reg[IR[20:16]] AluOut <= PC+(sign-extend[IR[15:0]>>2) PCWriteCond PCSource PCWrite Outputs ALUOp 00 IorD ALUSrcB 11 MemRead Control ALUSrcA MemWrite MemtoReg RegWrite Op [5-0] IRWrite RegDest M u x 1 2 Jump address [31-0] 26 Shift left 2 28 Instruction [25-0] Instruction [31-26] PC M u x 1 PC [31-28] Instruction [25-21] Read register 1 M u x 1 Address Read data 1 A Memory Instruction [20-16] Read register 2 Zero M u x 1 MemData ALU Instruction [15-0] Registers ALU result ALUOut Write register Instruction [15-11] Read data 2 Write data B M u x 3 2 1 Instruction register 4 Write data M u x 1 0010 Instruction [15-0] Memory data register 16 32 Sign extend Shift left 2 ALU Control Instruction [5-0] 2. décoder l'instruction

3. exécution, calcul d'une adresse mémoire ou branchement PCWriteCond PCSource PCWrite Outputs ALUOp IorD ALUSrcB MemRead Control ALUSrcA MemWrite MemtoReg RegWrite Op [5-0] IRWrite RegDest M u x 1 2 Jump address [31-0] 26 Shift left 2 28 Instruction [25-0] Instruction [31-26] PC M u x 1 PC [31-28] Instruction [25-21] Read register 1 M u x 1 Address Read data 1 A Memory Instruction [20-16] Read register 2 Zero M u x 1 MemData Instruction [15-0] Registers ALU ALU result ALUOut Write register Instruction [15-11] Read data 2 Write data B M u x 3 2 1 Instruction register 4 Write data M u x 1 Instruction [15-0] Memory data register 16 32 Sign extend Shift left 2 ALU Control Instruction [5-0]

3. exécution, calcul d'une adresse mémoire ou branchement PCWriteCond PCSource PCWrite Outputs ALUOp va dépendre de la classe de l'instruction IorD ALUSrcB MemRead Control ALUSrcA MemWrite MemtoReg RegWrite Op [5-0] IRWrite RegDest M u x 1 2 Jump address [31-0] 26 Shift left 2 28 Instruction [25-0] Instruction [31-26] PC M u x 1 PC [31-28] Instruction [25-21] Read register 1 M u x 1 Address Read data 1 A Memory Instruction [20-16] Read register 2 Zero M u x 1 MemData Instruction [15-0] Registers ALU ALU result ALUOut Write register Instruction [15-11] Read data 2 Write data B M u x 3 2 1 Instruction register 4 Write data M u x 1 Instruction [15-0] Memory data register 16 32 Sign extend Shift left 2 ALU Control Instruction [5-0]

accès mémoire PCWriteCond PCSource PCWrite Outputs ALUOp IorD ALUSrcB MemRead Control ALUSrcA MemWrite MemtoReg RegWrite Op [5-0] IRWrite RegDest M u x 1 2 Jump address [31-0] 26 Shift left 2 28 Instruction [25-0] Instruction [31-26] PC M u x 1 PC [31-28] Instruction [25-21] Read register 1 M u x 1 Address Read data 1 A Memory Instruction [20-16] Read register 2 Zero M u x 1 MemData Instruction [15-0] Registers ALU ALU result ALUOut Write register Instruction [15-11] Read data 2 Write data B M u x 3 2 1 Instruction register 4 Write data M u x 1 Instruction [15-0] Memory data register 16 32 Sign extend Shift left 2 ALU Control Instruction [5-0]

accès mémoire AluOut <= A+sign-extend(IR[15:0] PCWriteCond PCSource PCWrite Outputs ALUOp 00 IorD ALUSrcB 10 MemRead Control ALUSrcA 1 MemWrite MemtoReg RegWrite Op [5-0] IRWrite RegDest M u x 1 2 Jump address [31-0] 26 Shift left 2 28 Instruction [25-0] Instruction [31-26] PC M u x 1 PC [31-28] Instruction [25-21] Read register 1 M u x 1 Address Read data 1 A Memory Instruction [20-16] Read register 2 Zero M u x 1 MemData ALU Instruction [15-0] Registers ALU result ALUOut Write register Instruction [15-11] Read data 2 Write data B M u x 3 2 1 Instruction register 4 Write data M u x 1 0010 Instruction [15-0] Memory data register 16 32 Sign extend Shift left 2 ALU Control Instruction [5-0]

instructions de type R PCWriteCond PCSource PCWrite Outputs ALUOp IorD ALUSrcB MemRead Control ALUSrcA MemWrite MemtoReg RegWrite Op [5-0] IRWrite RegDest M u x 1 2 Jump address [31-0] 26 Shift left 2 28 Instruction [25-0] Instruction [31-26] PC M u x 1 PC [31-28] Instruction [25-21] Read register 1 M u x 1 Address Read data 1 A Memory Instruction [20-16] Read register 2 Zero M u x 1 MemData ALU Instruction [15-0] Registers ALU result ALUOut Write register Instruction [15-11] Read data 2 Write data B M u x 3 2 1 Instruction register 4 Write data M u x 1 Instruction [15-0] Memory data register 16 32 Sign extend Shift left 2 ALU Control Instruction [5-0]

instructions de type R PCWriteCond PCSource PCWrite ALUOut <= A op B Outputs ALUOp 10 IorD ALUSrcB 00 MemRead Control ALUSrcA 1 MemWrite MemtoReg RegWrite Op [5-0] IRWrite RegDest M u x 1 2 Jump address [31-0] 26 Shift left 2 28 Instruction [25-0] Instruction [31-26] PC M u x 1 PC [31-28] Instruction [25-21] Read register 1 M u x 1 Address Read data 1 A Memory Instruction [20-16] Read register 2 Zero M u x 1 MemData Instruction [15-0] Registers ALU ALU result ALUOut Write register Instruction [15-11] Read data 2 Write data B M u x 3 2 1 Instruction register 4 Write data M u x 1 xxxx Instruction [15-0] Memory data register 16 32 Sign extend Shift left 2 ALU Control Instruction [5-0]

PCWriteCond PCSource PCWrite Outputs ALUOp IorD ALUSrcB MemRead Control ALUSrcA MemWrite MemtoReg RegWrite Op [5-0] IRWrite RegDest M u x 1 2 Jump address [31-0] 26 Shift left 2 28 Instruction [25-0] Instruction [31-26] PC M u x 1 PC [31-28] Instruction [25-21] Read register 1 M u x 1 Address Read data 1 A Memory Instruction [20-16] Read register 2 Zero M u x 1 MemData Registers ALU Instruction [15-0] ALU result ALUOut Write register Instruction [15-11] Read data 2 Write data B M u x 3 2 1 Instruction register 4 Write data M u x 1 Instruction [15-0] Memory data register 16 32 branchements Sign extend Shift left 2 ALU Control Instruction [5-0]

Zero 1 PCWriteCond PCSource 01 PCWrite Outputs ALUOp 01 IorD ALUSrcB 00 MemRead Control ALUSrcA 1 MemWrite MemtoReg RegWrite Op [5-0] IRWrite RegDest M u x 1 2 Jump address [31-0] 26 Shift left 2 28 Instruction [25-0] Instruction [31-26] PC M u x 1 PC [31-28] Instruction [25-21] Read register 1 M u x 1 Address Read data 1 A Memory Instruction [20-16] Read register 2 Zero M u x 1 MemData Registers ALU Instruction [15-0] ALU result ALUOut Write register Instruction [15-11] Read data 2 Write data B M u x 3 2 1 Instruction register 4 Write data M u x 1 0110 Instruction [15-0] Memory data register 16 32 branchements Sign extend Shift left 2 ALU Control Instruction [5-0] if (A==B) PC <= ALUOut

PCWriteCond PCSource 1 PCWrite Outputs ALUOp IorD ALUSrcB MemRead Control ALUSrcA MemWrite MemtoReg RegWrite Op [5-0] IRWrite RegDest M u x 1 2 Jump address [31-0] 26 Shift left 2 28 Instruction [25-0] Instruction [31-26] PC M u x 1 PC [31-28] Instruction [25-21] Read register 1 M u x 1 Address Read data 1 A Memory Instruction [20-16] Read register 2 Zero M u x 1 MemData Registers ALU Instruction [15-0] ALU result ALUOut Write register Instruction [15-11] Read data 2 Write data B M u x 3 2 1 Instruction register 4 Write data M u x 1 Instruction [15-0] Memory data register 16 32 Sign extend Shift left 2 ALU Control Instruction [5-0] sauts non conditionnels

PCWriteCond PCSource 10 1 PCWrite Outputs ALUOp IorD ALUSrcB MemRead Control ALUSrcA MemWrite MemtoReg RegWrite Op [5-0] IRWrite RegDest M u x 1 2 Jump address [31-0] 26 Shift left 2 28 Instruction [25-0] Instruction [31-26] PC M u x 1 PC [31-28] Instruction [25-21] Read register 1 M u x 1 Address Read data 1 A Memory Instruction [20-16] Read register 2 Zero M u x 1 MemData ALU Instruction [15-0] Registers ALU result ALUOut Write register Instruction [15-11] Read data 2 Write data B M u x 3 2 1 Instruction register 4 Write data M u x 1 Instruction [15-0] Memory data register 16 32 Sign extend Shift left 2 ALU Control PC <= {PC[31:28], (IR[25:0], 2'b00)} Instruction [5-0] sauts non conditionnels

PCWriteCond PCSource PCWrite Outputs ALUOp IorD ALUSrcB MemRead Control ALUSrcA MemWrite MemtoReg RegWrite Op [5-0] IRWrite RegDest M u x 1 2 Jump address [31-0] 26 Shift left 2 28 Instruction [25-0] Instruction [31-26] PC M u x 1 PC [31-28] Instruction [25-21] Read register 1 M u x 1 Address Read data 1 A Memory Instruction [20-16] Read register 2 Zero M u x 1 MemData Registers ALU Instruction [15-0] ALU result ALUOut Write register Instruction [15-11] Read data 2 Write data B M u x 3 2 1 Instruction register 4 Write data M u x 1 Instruction [15-0] Memory data register 16 32 Sign extend Shift left 2 ALU Control Instruction [5-0] 4. terminaison d'un accès mémoire ou d'une instruction de type R

accès mémoire load PCWriteCond PCSource PCWrite Outputs ALUOp IorD ALUSrcB MemRead Control ALUSrcA MemWrite MemtoReg RegWrite Op [5-0] IRWrite RegDest M u x 1 2 Jump address [31-0] 26 Shift left 2 28 Instruction [25-0] Instruction [31-26] PC M u x 1 PC [31-28] Instruction [25-21] Read register 1 M u x 1 Address Read data 1 A Memory Instruction [20-16] Read register 2 Zero M u x 1 MemData Instruction [15-0] Registers ALU ALU result ALUOut Write register Instruction [15-11] Read data 2 Write data B M u x 3 2 1 Instruction register 4 Write data M u x 1 Instruction [15-0] Memory data register 16 32 Sign extend Shift left 2 ALU Control Instruction [5-0]

accès mémoire load MDR <= Memory[ALUOut] PCWriteCond PCSource PCWrite Outputs ALUOp 1 IorD ALUSrcB MemRead Control ALUSrcA MemWrite MemtoReg RegWrite Op [5-0] IRWrite RegDest M u x 1 2 Jump address [31-0] 26 Shift left 2 28 Instruction [25-0] Instruction [31-26] PC M u x 1 PC [31-28] Instruction [25-21] Read register 1 M u x 1 Address Read data 1 A Memory Instruction [20-16] Read register 2 Zero M u x 1 MemData ALU Instruction [15-0] Registers ALU result ALUOut Write register Instruction [15-11] Read data 2 Write data B M u x 3 2 1 Instruction register 4 Write data M u x 1 Instruction [15-0] Memory data register 16 32 Sign extend Shift left 2 ALU Control Instruction [5-0]

accès mémoire store PCWriteCond PCSource PCWrite Outputs ALUOp IorD ALUSrcB MemRead Control ALUSrcA MemWrite MemtoReg RegWrite Op [5-0] IRWrite RegDest M u x 1 2 Jump address [31-0] 26 Shift left 2 28 Instruction [25-0] Instruction [31-26] PC M u x 1 PC [31-28] Instruction [25-21] Read register 1 M u x 1 Address Read data 1 A Memory Instruction [20-16] Read register 2 Zero M u x 1 MemData Instruction [15-0] Registers ALU ALU result ALUOut Write register Instruction [15-11] Read data 2 Write data B M u x 3 2 1 Instruction register 4 Write data M u x 1 Instruction [15-0] Memory data register 16 32 Sign extend Shift left 2 ALU Control Instruction [5-0]

accès mémoire store Memory[ALUOut] <= B PCWriteCond PCSource PCWrite Outputs ALUOp 1 IorD ALUSrcB MemRead Control ALUSrcA MemWrite MemtoReg RegWrite Op [5-0] IRWrite RegDest M u x 1 2 Jump address [31-0] 26 Shift left 2 28 Instruction [25-0] Instruction [31-26] PC M u x 1 PC [31-28] Instruction [25-21] Read register 1 M u x 1 Address Read data 1 A Memory Instruction [20-16] Read register 2 Zero M u x 1 MemData ALU Instruction [15-0] Registers ALU result ALUOut Write register Instruction [15-11] Read data 2 Write data B M u x 3 2 1 Instruction register 4 Write data M u x 1 Instruction [15-0] Memory data register 16 32 Sign extend Shift left 2 ALU Control Instruction [5-0]

instruction de type R PCWriteCond PCSource PCWrite Outputs ALUOp IorD ALUSrcB MemRead Control ALUSrcA MemWrite MemtoReg RegWrite Op [5-0] IRWrite RegDest M u x 1 2 Jump address [31-0] 26 Shift left 2 28 Instruction [25-0] Instruction [31-26] PC M u x 1 PC [31-28] Instruction [25-21] Read register 1 M u x 1 Address Read data 1 A Memory Instruction [20-16] Read register 2 Zero M u x 1 MemData Instruction [15-0] Registers ALU ALU result ALUOut Write register Instruction [15-11] Read data 2 Write data B M u x 3 2 1 Instruction register 4 Write data M u x 1 Instruction [15-0] Memory data register 16 32 Sign extend Shift left 2 ALU Control Instruction [5-0]

instruction de type R Reg[IR[15:11]] <= ALUOut PCWriteCond PCSource PCWrite Outputs ALUOp IorD ALUSrcB MemRead Control ALUSrcA MemWrite MemtoReg RegWrite Op [5-0] IRWrite 1 RegDest M u x 1 2 Jump address [31-0] 26 Shift left 2 28 Instruction [25-0] Instruction [31-26] PC M u x 1 PC [31-28] Instruction [25-21] Read register 1 M u x 1 Address Read data 1 A Memory Instruction [20-16] Read register 2 Zero M u x 1 MemData Instruction [15-0] Registers ALU ALU result ALUOut Write register Instruction [15-11] Read data 2 Write data B M u x 3 2 1 Instruction register 4 Write data M u x 1 Instruction [15-0] Memory data register 16 32 Sign extend Shift left 2 ALU Control Instruction [5-0]

5. terminaison d'un accès mémoire load PCWriteCond PCSource PCWrite Outputs ALUOp IorD ALUSrcB MemRead Control ALUSrcA MemWrite MemtoReg RegWrite Op [5-0] IRWrite RegDest M u x 1 2 Jump address [31-0] 26 Shift left 2 28 Instruction [25-0] Instruction [31-26] PC M u x 1 PC [31-28] Instruction [25-21] Read register 1 M u x 1 Address Read data 1 A Memory Instruction [20-16] Read register 2 Zero M u x 1 MemData Instruction [15-0] Registers ALU ALU result ALUOut Write register Instruction [15-11] Read data 2 Write data B M u x 3 2 1 Instruction register 4 Write data M u x 1 Instruction [15-0] Memory data register 16 32 Sign extend Shift left 2 ALU Control Instruction [5-0]

5. terminaison d'un accès mémoire load Reg[IR[20:16]] <= MDR PCWriteCond PCSource PCWrite Outputs ALUOp IorD ALUSrcB MemRead Control ALUSrcA MemWrite 1 MemtoReg RegWrite Op [5-0] IRWrite RegDest M u x 1 2 Jump address [31-0] 26 Shift left 2 28 Instruction [25-0] Instruction [31-26] PC M u x 1 PC [31-28] Instruction [25-21] Read register 1 M u x 1 Address Read data 1 A Memory Instruction [20-16] Read register 2 Zero M u x 1 MemData Instruction [15-0] Registers ALU ALU result ALUOut Write register Instruction [15-11] Read data 2 Write data B M u x 3 2 1 Instruction register 4 Write data M u x 1 Instruction [15-0] Memory data register 16 32 Sign extend Shift left 2 ALU Control Instruction [5-0]

spécification du contrôle à l'aide de machines à états finis un ensemble d'états des directions pour passer d'un état à un autre tout contrôle non spécifié est réputé à 0 (faux) instructions d'accès mémoire instructions de type R instructions de branchements conditionnels instructions de sauts non conditionnels départ chargement de l'instruction décodage

chargement et décodage chargement décodage 1 Op = type R Op = 'BEQ' machine accès mémoire machine type R machine branchements Op = 'J' machine sauts Op = 'LW' ou Op = 'SW'

implémentation multicycle (rappel)
PCWriteCond PCSource PCWrite Outputs ALUOp 00 IorD ALUSrcB 01 1 MemRead Control ALUSrcA MemWrite MemtoReg RegWrite Op [5-0] IRWrite RegDest M u x 1 2 1 Jump address [31-0] 26 Shift left 2 28 Instruction [25-0] Instruction [31-26] PC M u x 1 PC [31-28] Instruction [25-21] Read register 1 M u x 1 Address Read data 1 A Memory Instruction [20-16] Read register 2 Zero M u x 1 MemData Instruction [15-0] Registers ALU ALU result ALUOut Instruction [15-11] Write register Read data 2 Write data B M u x 3 2 1 Instruction register 4 Write data M u x 1 0010 Instruction [15-0] IR <= Memory[PC] PC <= PC+4 Memory data register 16 32 Sign extend Shift left 2 ALU Control Instruction [5-0] 1. aller chercher l'instruction

chargement et décodage chargement MemRead ALUSrcA = 0 IorD= 0 IRWrite ALUSrcB = 01 ALUOp= 00 PCWrite PCSource = 00 décodage 1 Op = type R Op = 'BEQ' machine accès mémoire machine type R machine branchements Op = 'J' machine sauts Op = 'LW' ou Op = 'SW'

implémentation multicycle (rappel)
A <= Reg[IR[25:21]] B <= Reg[IR[20:16]] AluOut <= PC+(sign-extend[IR[15:0]>>2) PCWriteCond PCSource PCWrite Outputs ALUOp 00 IorD ALUSrcB 11 MemRead Control ALUSrcA MemWrite MemtoReg RegWrite Op [5-0] IRWrite RegDest M u x 1 2 Jump address [31-0] 26 Shift left 2 28 Instruction [25-0] Instruction [31-26] PC M u x 1 PC [31-28] Instruction [25-21] Read register 1 M u x 1 Address Read data 1 A Memory Instruction [20-16] Read register 2 Zero M u x 1 MemData ALU Instruction [15-0] Registers ALU result ALUOut Write register Instruction [15-11] Read data 2 Write data B M u x 3 2 1 Instruction register 4 Write data M u x 1 0010 Instruction [15-0] Memory data register 16 32 Sign extend Shift left 2 ALU Control Instruction [5-0] 2. décoder l'instruction

chargement et décodage chargement MemRead ALUSrcA = 0 IorD= 0 IRWrite ALUSrcB = 01 ALUOp= 00 PCWrite PCSource = 00 décodage 1 ALUSrcA = 0 ALUSrcB =11 ALUOp = 00 Op = type R Op = 'BEQ' machine accès mémoire machine type R machine branchements Op = 'J' machine sauts Op = 'LW' ou Op = 'SW'

accès mémoire depuis 1 (Op='LW') ou (Op='SW') 2 ALUSrcA = 1 ALUSrcB = 10 ALUOp = 00 calcul de l'adresse mémoire (Op='SW') (Op='LW') 5 MemRead IorD = 1 accès mémoire MemWrite IorD = 1 accès mémoire 3 fin de la lecture mémoire RegWrite MemtoReg = 1 RegDst = 0 4 retour vers l'état 0

instructions de type R depuis 1 (Op='type R') ALUSrcA = 1 ALUSrcB = 00 ALUOp = 10 exécution 6 7 RegDst = 1 RegWrite MemtoReg = 0 fin de l'opération retour vers l'état 0

Branchements conditionnels depuis 1 (Op='BEQ') ALUSrcA = 1 ALUSrcB = 00 ALUOp = 01 PCWriteCond PCSource=01 exécution 8 retour vers l'état 0

Sauts inconditionnels depuis 1 (Op='J') PCWrite PCSource=10 exécution 9 retour vers l'état 0

chargement décodage MemRead ALUSrcA = 0 IorD= 0 IRWrite ALUSrcB = 01 ALUOp= 00 PCWrite PCSource = 00 1 ALUSrcA = 0 ALUSrcB =11 ALUOp = 00 (Op = 'J') (Op = 'BEQ') calcul de l'adresse mémoire exécution 6 (Op = type R) 8 exécution exécution 9 2 ALUSrcA = 1 ALUSrcB = 10 ALUOp = 00 ALUSrcA = 1 ALUSrcB = 00 ALUOp = 10 ALUSrcA = 1 ALUSrcB = 00 ALUOp = 01 PCWriteCond PCSource=01 PCWrite PCSource=10 (Op='SW') (Op='LW') accès mémoire fin de l'opération (Op = 'LW' ou Op = 'SW' ) accès mémoire 3 MemRead IorD = 1 5 MemWrite IorD = 1 7 RegDst = 1 RegWrite MemtoReg = 0 fin de la lecture mémoire 4 RegWrite MemtoReg = 1 RegDst = 0

le contrôleur de la machine à états finis est implémenté dans un bloc de logique combinatoire Logique combinatoire de contrôle sorties de contrôle du chemin de données ... sorties entrées TD registre d'état entrées en provenance du champ de contrôle de l'instruction

gestion des exceptions
exception : tout changement inattendu dans le cours de l'exécution de la séquence d'instructions une interruption est une exception provenant d'un élément extérieur (périphérique) NB: dans le cas des architectures IA32 de Intel, toutes les exceptions sont appelées interruptions peuvent être provoquées par la requête d'un dispositif d'entrée/sortie un dépassement de capacité arithmétique une instruction non définie un appel aux fonctions du système d'exploitation etc...

dans ce qui suit, gestion des dépassements de capacité des instructions non définies actions de base : sauver l'adresse de l'instruction ayant causé l'exception dans un registre dédié : EPC (Exception Program Counter) transférer le contrôle à une adresse spécifiée du système d'exploitation en précisant la raison de l'exception ensuite terminer le programme ou reprendre l'exécution au point où on en était au moment de l'occurrence de l'exception 2 méthodes pour le transfert de contrôle : une seule adresse de transfert et la cause est sauvegardée dans un registre d'état (Cause Register) vecteur d'interruption : la cause de l'exception détermine le choix de l'adresse de transfert

l'architecture MIPS suit la première méthode 2 registres supplémentaires EPC Cause stocke la cause dans un mot de 32 bits instruction indéfinie : lsb → 0 dépassement de capacité arithmétique : lsb → 1 lignes de contrôles supplémentaires EPCWrite CauseWrite ligne pour mettre à 0 ou 1 le lsb de Cause adresse du point d'entrée du traitement : 0x PC décrémenté de 4 avant stockage dans EPC

CauseWrite IntCause PCWriteCond EPCWrite PCWrite Outputs PCSource IorD ALUOp MemRead Control ALUSrcB MemWrite ALUSrcA MemtoReg RegWrite IRWrite RegDest M u x 1 2 3 Jump address [31-0] Op [5-0] 26 Shift left 2 28 Instruction [25-0] Instruction [31-26] PC M u x 1 PC [31-28] Instruction [25-21] Read register 1 M u x 1 Address Read data 1 A Memory Instruction [20-16] Read register 2 Overflow Cause Zero EPC M u x 1 MemData ALU Instruction [15-0] Registers ALU result ALUOut Write register Instruction [15-11] Read data 2 Write data B M u x 3 2 1 Instruction register 4 Write data M u x 1 M u x 1 Instruction [15-0] Cause Memory data register 1 16 32 Sign extend Shift left 2 ALU Control Instruction [5-0]

chargement décodage MemRead ALUSrcA = 0 IorD= 0 ALUSrcB = 01 ALUOp= 00 PCWrite PCSource = 00 1 ALUSrcA = 0 ALUSrcB =11 ALUOp = 00 problème potentiel d'écriture d'un résultat faux ! ! (Op='other') (Op = 'J') (Op = 'BEQ') calcul de l'adresse mémoire exécution exécution 6 (Op = type R) 8 ALUSrcA = 1 ALUSrcB = 00 ALUOp = 01 PCWriteCond PCSource=01 exécution 9 2 ALUSrcA = 1 ALUSrcB = 10 ALUOp = 00 ALUSrcA = 1 ALUSrcB = 00 ALUOp = 10 PCWrite PCSource=10 documenté dans l’instruction set MIPS (Op='SW') (Op='LW') accès mémoire (Op = 'LW' ou Op = 'SW' ) fin de l'opération accès mémoire 3 MemRead IorD = 1 6 ALUSrcA = 1 ALUSrcB = 10 ALUOp = 00 7 RegDst = 1 RegWrite MemtoReg = 0 10 IntCause = 1 CauseWrite ALUSrcA = 0 ALUSrcB = 01 ALUOp = 01 EPCWrite PCWrite PCSource = 11 IntCause = 0 CauseWrite ALUSrcA = 0 ALUSrcB = 01 ALUOp = 01 EPCWrite PCWrite PCSource = 11 11 Overflow fin de la lecture mémoire 4 RegWrite MemtoReg = 1 RegDst = 0

pipelining l'approche « multicycle » améliore le temps d'exécution, mais une grande partie du chemin de données reste sous-utilisée pendant l'exécution des différents cycles constituant l'instruction une autre approche utilise un chemin de données proche de celui utilisé pour l'approche « cycle unique » mais en optimise l'utilisation : le « pipelining » où plusieurs instructions seront exécutées en même temps

pipelining une analogie : le lavage du linge 18h 19h 20h 21h 22h 23h
heure

pipelining une meilleure utilisation du matériel :
18h 19h 20h 21h heure le temps d'exécution de chaque instruction reste le même mais pour un grand nombre d 'opérations, le facteur d'accélération peut atteindre 4

pipelining on va réaliser un pipeline avec les 5 étapes (maximum) de l'exécution des instructions aller chercher l'instruction en mémoire (IF : Instruction Fetch) lire les registres impliqués en même temps que l'on décode (ID : Instruction Decode) exécuter l'instruction (R format) ou calculer l'adresse (EX) accéder à un opérande en mémoire (MEM) écrire dans un registre (lw ou R format) (WB : Write Back) EX IF ID MEM WB accès en lecture accès en écriture

pipelining amélioration du temps d'exécution du programme (et non pas de l'instruction) temps typiques pour la réalisation des étapes on a supposé que les multiplexeurs, unités de contrôle, accès au registre PC et unités d'extension du bit de signe n'ont aucun délai Classe instruction fetch Reg read ALU Data access Reg write Total load word (lw) 200ps 100 ps 200 ps 800 ps store word (sw) 700 ps R format (add, ...) 600 ps branch (beq) 500 ps

pipelining exemple pour 3 instructions « indépendantes »
en mode « cycle unique » en mode « pipelining » on est limité par la ressource la plus lente (ALU ou accès mémoire) 200 400 600 800 1000 1200 1400 1600 1800 fetch Reg ALU data access lw $1, 100($0) lw $2, 200($0) lw $3, 300($0) 800 ps temps instructions 2400 ps 200 400 600 800 1000 1200 1400 1600 1800 fetch Reg ALU data access lw $1, 100($0) lw $2, 200($0) lw $3, 300($0) 200 ps temps instructions 1400 ps toutes les étapes ont la même durée <=> le design des instructions est adapté au traitement

pipelining il peut se produire des conflits entre les instructions dans le pipeline : « aléas » aléas « structurels » aléas « de données » aléas « de contrôle »

aléa structurel exemple
si on n'avait qu'une seule mémoire pour les instructions et les données 200 400 600 800 1000 1200 1400 1600 1800 temps fetch Reg ALU data access lw $1, 100($0) fetch Reg ALU data access lw $2, 200($0) fetch Reg ALU data access lw $3, 300($0) fetch Reg ALU data access add $4, $1, $2 instructions

aléa structurel exemple
si on n'avait qu'une seule mémoire pour les instructions et les données aléa structurel dès la 4ème instruction dans le pipeline 200 400 600 800 1000 1200 1400 1600 1800 temps fetch Reg ALU data access lw $1, 100($0) fetch Reg ALU data access lw $2, 200($0) fetch Reg ALU data access lw $2, 300($0) fetch Reg ALU data access add $4, $1, $2 instructions

aléas de données quand le déroulement du pipeline est bloqué car on doit attendre la fin d'une instruction pour exécuter une des suivantes exemple : add $s0, $t0, $t1 sub $t2, $s0, $t3 on a besoin de $s0 produit par add pour décoder sub IF ID EX MEM WB add $s0, $t0, $t1 sub $2, $s0, $t3

aléas de données le compilateur ne peut pas toujours éviter cet aléa
une première solution : bloquer temporairement le pipeline IF ID EX MEM WB add $s0, $t0, $t1 bubble bubble sub $2, $s0, $t3 IF ID EX MEM WB

aléas de données autre solution, plus performante : faire suivre (forward) la donnée (quand c'est possible) EX IF ID MEM WB add $s0, $t0, $t1 EX IF ID MEM WB sub $2, $s0, $t3

aléas de données parfois nécessaire de faire en plus un blocage temporaire EX IF ID MEM WB lw $s0, 20($t1) EX IF ID MEM WB sub $2, $s0, $t3

aléas de données parfois nécessaire de faire en plus un blocage temporaire EX IF ID MEM WB lw $s0, 20($t1) bubble EX IF ID MEM WB sub $2, $s0, $t3

aléas de contrôle quand il faut faire un choix basé sur le résultat d'une instruction exemple : instruction de branchement on suppose que l'on a rajouté du matériel pour comparer le contenu des registres, calculer l'adresse de branchement et mettre à jour le compteur de programme pendant la 2ème étape si le branchement est pris, on va à l'instruction PC+4+offset (ici un or) sinon on va à PC+4 (ici lw) beq $1, $2, 40 lw $3, 300($0) … or $7, $8, $9

aléas de contrôle la solution la plus simple consiste à bloquer systématiquement le pipeline à chaque branchement 200 400 600 800 1000 1200 1400 temps fetch Reg ALU data access add $4, $5, $6 fetch Reg ALU data access beq $1, $2, 40 bubble fetch Reg ALU data access or $7, $8, $9 instructions

aléas de contrôle pour améliorer les performances : prédictions
on suppose a priori que le branchement n'est pas pris si le branchement est pris, on va à l'instruction or en introduisant un blocage 200 400 600 800 1000 1200 1400 temps fetch Reg ALU data access add $4, $5, $6 fetch Reg ALU data access beq $1, $2, 40 fetch Reg ALU data access lw $3, 300($0) instructions 200 400 600 800 1000 1200 1400 temps argument : dans la plupart des cas, le branchement n'est pas pris (emple : dans une boucle for, on teste si on a atteint la fin. Si non, goto debut, sinon (une seule fois), on sort de la boucke fetch Reg ALU data access add $4, $5, $6 fetch Reg ALU data access beq $1, $2, 40 bubble fetch Reg ALU data access or $7, $8, $9 instructions

chemin de données en mode pipeline
rappel : cycle unique Add Add 4 Décal. gauche 2 bits Résultat code opération Registres Registre lecture #1 lecture #2 écriture Données Ecriture registre Source PC 4 Ecriture mémoire Mémoire vers registre PC Lecture adresse Mémoire instructions instruction Zéro M u x Source ALU ALU Mémoire données Adresse M u x Résultat M u x Données lues Données à écrire Ext. bit de signe Lecture mémoire 16 32

Sélection de la valeur suivante du PC Instruction Fetch Instruction Decode Execute Memory Access Write Back aléa de contrôle les transferts se font de gauche à droite Add Add sauf 4 Décal. gauche 2 bits Résultat code opération Registres Registre lecture #1 lecture #2 écriture Données Ecriture registre Source PC 4 Ecriture mémoire Mémoire vers registre PC Lecture adresse Mémoire instructions instruction Zéro M u x Source ALU ALU Mémoire données Adresse M u x Résultat M u x Données lues Données à écrire aléa de données Ext. bit de signe Lecture mémoire 16 32 Écriture du résultat dans le register file

tout se passe comme si chaque étape avait son chemin de données propre représenté par le composant essentiel du chemin pour mémoriser des données pour les étages en aval : besoin de registres intermédiaires temps (en cycles d'horloge) CC1 CC2 CC3 CC4 CC5 CC6 CC7 ALU IM Reg DM Reg lw $1, 100($0) ALU IM Reg DM Reg lw $2, 200($0) ALU IM Reg DM Reg lw $3, 300($0) instructions

exemple de l'exécution d'une instruction lw IF/ID ID/EX EX/MEM MEM//WB Add Add 4 Décal. gauche 2 bits Résultat Registres Registre lecture #1 lecture #2 écriture Données PC Mémoire données Données lues M u x Lecture adresse Mémoire instructions instruction Zéro M u x ALU Adresse Résultat M u x Données à écrire Ext. bit de signe 16 32

lw instruction fetch IF/ID ID/EX EX/MEM MEM//WB Add Add 4 Décal. gauche 2 bits Résultat lecture Registres Registre lecture #1 lecture #2 écriture Données PC Mémoire données Données lues M u x Lecture adresse Mémoire instructions instruction Zéro M u x ALU Adresse Résultat M u x Données à écrire écriture Ext. bit de signe cf Instruction Register 16 32

lw instruction decode IF/ID ID/EX EX/MEM MEM//WB écriture lecture Add Add 4 Décal. gauche 2 bits Résultat lecture Registres Registre lecture #1 lecture #2 écriture Données PC Mémoire données Données lues M u x Lecture adresse Mémoire instructions instruction Zéro M u x ALU Adresse Résultat M u x Données à écrire Ext. bit de signe 16 32

lw execution IF/ID ID/EX EX/MEM MEM//WB Add Add 4 Décal. gauche 2 bits Résultat Registres Registre lecture #1 lecture #2 écriture Données PC Mémoire données Données lues M u x Lecture adresse Mémoire instructions instruction Zéro M u x ALU Adresse Résultat M u x Données à écrire Ext. bit de signe 16 32

lw Memory IF/ID ID/EX EX/MEM MEM//WB Add Add 4 Décal. gauche 2 bits Résultat Registres Registre lecture #1 lecture #2 écriture Données PC Mémoire données Données lues M u x Lecture adresse Mémoire instructions instruction Zéro M u x ALU Adresse Résultat M u x Données à écrire Ext. bit de signe 16 32

lw Write-back IF/ID ID/EX EX/MEM MEM//WB Add Add 4 Décal. gauche 2 bits Résultat Registres Registre lecture #1 lecture #2 écriture Données PC Mémoire données Données lues M u x Lecture adresse Mémoire instructions instruction Zéro M u x ALU Adresse Résultat M u x Données à écrire Ext. bit de signe 16 32

exemple de l'exécution d'une instruction sw sw execution IF/ID ID/EX EX/MEM MEM//WB Add Add 4 Décal. gauche 2 bits Résultat Registres Registre lecture #1 lecture #2 écriture Données PC Mémoire données Données lues M u x Lecture adresse Mémoire instructions instruction Zéro M u x ALU Adresse Résultat M u x Données à écrire différent du lw Ext. bit de signe 16 32

sw Memory IF/ID ID/EX EX/MEM MEM//WB Add Add 4 Décal. gauche 2 bits Résultat Registres Registre lecture #1 lecture #2 écriture Données PC Mémoire données Données lues M u x Lecture adresse Mémoire instructions instruction Zéro M u x ALU Adresse Résultat M u x Données à écrire Ext. bit de signe 16 32

sw Write-back IF/ID ID/EX EX/MEM MEM//WB rien à faire !... Add Add 4 Décal. gauche 2 bits Résultat Registres Registre lecture #1 lecture #2 écriture Données PC Mémoire données Données lues M u x Lecture adresse Mémoire instructions instruction Zéro M u x ALU Adresse Résultat M u x Données à écrire Ext. bit de signe 16 32

lw Write-back IF/ID ID/EX EX/MEM MEM//WB Add Add 4 Décal. gauche 2 bits Résultat Registres Registre lecture #1 lecture #2 écriture Données PC Mémoire données Données lues M u x Lecture adresse Mémoire instructions instruction Zéro M u x ALU Adresse Résultat M u x Données à écrire ? Ext. bit de signe 16 32

chemin de données corrigé IF/ID ID/EX EX/MEM MEM//WB Add Add 4 Décal. gauche 2 bits Résultat Registres Registre lecture #1 lecture #2 écriture Données PC Mémoire données Données lues M u x Lecture adresse Mémoire instructions instruction Zéro M u x ALU Adresse Résultat M u x Données à écrire Ext. bit de signe 16 32

IF/ID ID/EX EX/MEM MEM//WB Add Add 4 Décal. gauche 2 bits Résultat Registres Registre lecture #1 lecture #2 écriture Données PC Mémoire données Données lues M u x Lecture adresse Mémoire instructions instruction Zéro M u x ALU Adresse Résultat M u x Données à écrire portions du chemin de données utilisées pour une instruction lw Ext. bit de signe 16 32

vision sur plusieurs cycles d'horloge CC1 CC2 CC3 CC4 CC5 CC6 CC7 CC8 CC9 instructions du programme ALU lw $10, 20($1) IM Reg DM Reg ALU sub $1, $2, $3 IM Reg DM Reg ALU IM Reg DM Reg add $12, $3, $4 ALU lw $13, 24($1) IM Reg DM Reg ALU add $14, $5, $6 IM Reg DM Reg

vision sur plusieurs cycles d'horloge CC1 CC2 CC3 CC4 CC5 CC6 CC7 CC8 CC9 instructions du programme Instruction fetch Instruction decode Execution data access Write-back lw $10, 20($1) Instruction fetch Instruction decode Execution data access Write-back sub $1, $2, $3 Instruction fetch Instruction decode Execution data access Write-back add $12, $3, $4 Instruction fetch Instruction decode Execution data access Write-back lw $13, 24($1) Instruction fetch Instruction decode Execution data access Write-back add $14, $5, $6

vision sur un seul cycle d'horloge CC1 CC2 CC3 CC4 CC5 CC6 CC7 CC8 CC9 instructions du programme Instruction fetch Instruction decode Execution data access Write-back lw $10, 20($1) Instruction fetch Instruction decode Execution data access Write-back sub $1, $2, $3 Instruction fetch Instruction decode Execution data access Write-back add $12, $3, $4 Instruction fetch Instruction decode Execution data access Write-back lw $13, 24($1) Instruction fetch Instruction decode Execution data access Write-back add $14, $5, $6

vision sur un seul cycle add $14, $5, $6 lw 13, 24($1) add $12, $3, $4 sub $11, $2, $3 lw 10, 20($1) instruction fetch instruction decode execution memory write-back IF/ID ID/EX EX/MEM MEM//WB quel cycle ? Add Add 4 Décal. gauche 2 bits Résultat Registres Registre lecture #1 lecture #2 écriture Données PC Mémoire données Données lues M u x Lecture adresse Mémoire instructions instruction Zéro M u x ALU Adresse Résultat M u x Données à écrire Ext. bit de signe 16 32

le 5ème

contrôle en mode pipeline
on réutilise autant que faire se peut les éléments de l'implémentation cycle unique même nomenclature même logique de contrôle pour l'ALU compteur PC chargé à chaque cycle de l'horloge : pas besoin d'une ligne de contrôle spécifique (même raisonnement pour les registres du pipeline)

implémentation cycle unique M u x Add RegDest Add Contrôle Branch 4 MemRead Décal. gauche 2 bits MemWrite Résultat ALUOp 1 instruction [31:26] MemtoReg ALUSrc Source PC RegWrite instruction [25:21] Registres Registre lecture #1 lecture #2 écriture Données PC instruction [20:16] Lecture adresse Mém. instr. instruction (31:0) Zéro ALU Mémoire données M u x Adresse Résultat 1 M u x M u x Données lues instruction [15:11] 1 1 Données à écrire Contrôle ALU Ext. bit de signe 16 32 instruction [15:0] instruction [5:0]

PCSrc IF/ID ID/EX EX/MEM MEM//WB Branch Add Add Décal. gauche 2 bits Résultat 4 RegWrite Registres Registre lecture #1 lecture #2 écriture Données PC Lecture adresse Mémoire instructions instruction Zéro M u x ALUSrc ALU MemWrite MemtoReg Résultat M u x 1 Mémoire données Données lues M u x 1 Adresse Données à écrire Ext. bit de signe 1 32 Contrôle ALU Instr 6 [15-0] MemRead Instr ALUOp M u x [20-16] Instr 1 [15-11] RegDest

on établit les lignes de contrôle à chaque étape du pipeline chaque composant du chemin de données n'est utilisé qu'à une étape → 5 groupes de lignes

IF ID PCSrc IF/ID ID/EX EX/MEM MEM//WB Branch Add Add Décal. gauche 2 bits Résultat 4 RegWrite Registres Registre lecture #1 lecture #2 écriture Données PC Lecture adresse Mémoire instructions instruction Zéro M u x ALUSrc ALU MemWrite MemtoReg Résultat M u x 1 Mémoire données Données lues M u x 1 Adresse Données à écrire Ext. bit de signe 1 32 Contrôle ALU Instr 6 [15-0] MemRead Instr ALUOp M u x [20-16] Instr 1 [15-11] RegDest

on établit les lignes de contrôle à chaque étape du pipeline chaque composant du chemin de données n'est utilisé qu'à une étape → 5 groupes de lignes IF : rien de spécial (les lignes pour écrire le PC et la lecture de la mémoire instruction sont toujours assertées) ID : rien de spécial (la lecture du register file est toujours assertée

EX PCSrc IF/ID ID/EX EX/MEM MEM//WB Branch Add Add Décal. gauche 2 bits Résultat 4 RegWrite Registres Registre lecture #1 lecture #2 écriture Données PC Lecture adresse Mémoire instructions instruction Zéro M u x ALUSrc ALU MemWrite MemtoReg Résultat M u x 1 Mémoire données Données lues M u x 1 Adresse Données à écrire Ext. bit de signe 1 32 Contrôle ALU Instr 6 [15-0] MemRead Instr ALUOp M u x [20-16] Instr 1 [15-11] RegDest

on établit les lignes de contrôle à chaque étape du pipeline chaque composant du chemin de données n'est utilisé qu'à une étape → 5 groupes de lignes IF : rien de spécial (les lignes pour écrire le PC et la lecture de la mémoire instruction sont toujours assertées) ID : rien de spécial (la lecture du register file est toujours assertée) EX : il faut établir RegDest, ALUOp et ALUSrc

MEM PCSrc IF/ID ID/EX EX/MEM MEM//WB Branch Add Add Décal. gauche 2 bits Résultat 4 RegWrite Registres Registre lecture #1 lecture #2 écriture Données PC Lecture adresse Mémoire instructions instruction Zéro M u x ALUSrc ALU MemWrite MemtoReg Résultat M u x 1 Mémoire données Données lues M u x 1 Adresse Données à écrire Ext. bit de signe 1 32 Contrôle ALU Instr 6 [15-0] MemRead Instr ALUOp M u x [20-16] Instr 1 [15-11] RegDest

on établit les lignes de contrôle à chaque étape du pipeline chaque composant du chemin de données n'est utilisé qu'à une étape → 5 groupes de lignes IF : rien de spécial (les lignes pour écrire le PC et la lecture de la mémoire instruction sont toujours assertées) ID : rien de spécial (la lecture du register file est toujours assertée) EX : il faut établir RegDest, ALUOp et ALUSrc Mem : il faut établir Branch, MemRead et MemWrite PCSrc est établi à partir de Branch et éventuellement la ligne Zero de l'ALU (si Branch est vrai)

WB PCSrc IF/ID ID/EX EX/MEM MEM//WB Branch Add Add Décal. gauche 2 bits Résultat 4 RegWrite Registres Registre lecture #1 lecture #2 écriture Données PC Lecture adresse Mémoire instructions instruction Zéro M u x ALUSrc ALU MemWrite MemtoReg Résultat M u x 1 Mémoire données Données lues M u x 1 Adresse Données à écrire Ext. bit de signe 1 32 Contrôle ALU Instr 6 [15-0] MemRead Instr ALUOp M u x [20-16] Instr 1 [15-11] RegDest

on établit les lignes de contrôle à chaque étape du pipeline chaque composant du chemin de données n'est utilisé qu'à une étape → 5 groupes de lignes IF : rien de spécial (les lignes pour écrire le PC et la lecture de la mémoire instruction sont toujours assertées) ID : rien de spécial (la lecture du register file est toujours assertée) EX : il faut établir RegDest, ALUOp et ALUSrc Mem : il faut établir Branch, MemRead et MemWrite PCSrc est établi à partir de Branch et éventuellement la ligne Zero de l'ALU (si Branch est vrai) WB : il faut établir MemtoReg et RegWrite

Instr. Execution Memory Write-back RegDest ALUOP1 ALUOP0 ALUSrc Branch Mem-Read Mem-Write Reg-Write Memto-Reg R-format 1 lw sw X beq

les lignes de contrôle sont établies au décodage puis transmises via les registres du pipeline EX Mem WB Contrôle IF/ID ID/EX EX/MEM MEM/WB Instruction

PCSrc ID/EX Contrôle WB EX/MEM M MEM//WB IF/ID WB EX M WB Add Branch Add Décal. gauche 2 bits Résultat 4 RegWrite Registres Registre lecture #1 lecture #2 écriture Données ALUSrc MemWrite PC Lecture adresse Mémoire instructions instruction Zéro M u x ALU MemtoReg Résultat M u x 1 Mémoire données Données lues M u x 1 Adresse Données à écrire 1 Ext. bit de signe 32 Contrôle ALU Instr 6 [15-0] MemRead Instr ALUOp M u x [20-16] Instr 1 [15-11] RegDest

gestion des aléas les exemples précédents sont « sympas » : pas d'interférences entre les différentes instructions autre exemple (moins sympa) sub $2, $1, $3 and $12, $2, $5 or $13, $6, $2 add $14, $2, $2 lw $15, 100($2)

gestion des aléas CC1 CC2 CC3 CC4 CC5 CC6 CC7 CC8 CC9 valeur du
registre $2 10 10 10 10 10/-20 -20 -20 -20 -20 instructions du programme ALU sub $2, $1, $3 IM Reg DM Reg ALU and $12, $2, $5 IM Reg DM Reg ALU IM Reg DM Reg or $13, $8, $2 ALU add $14, $2, $2 IM Reg DM Reg ALU IM Reg DM Reg sw $15, 100($2)

gestion des aléas pas de problème CC1 CC2 CC3 CC4 CC5 CC6 CC7 CC8 CC9
valeur du registre $2 10 10 10 10 10/-20 -20 -20 -20 -20 instructions du programme ALU sub $2, $1, $3 IM Reg DM Reg pas de problème ALU and $12, $2, $5 IM Reg DM Reg ALU IM Reg DM Reg or $13, $8, $2 ALU add $14, $2, $2 IM Reg DM Reg ALU IM Reg DM Reg sw $15, 100($2)

gestion des aléas peut être résolu en modifiant le hardware :
CC1 CC2 CC3 CC4 CC5 CC6 CC7 CC8 CC9 valeur du registre $2 10 10 10 10 10/-20 -20 -20 -20 -20 instructions du programme peut être résolu en modifiant le hardware : écriture pendant la 1ère moitié du cycle lecture pendant la 2nde moitié du cycle ALU sub $2, $1, $3 IM Reg DM Reg ALU and $12, $2, $5 IM Reg DM Reg ALU IM Reg DM Reg or $13, $8, $2 ALU add $14, $2, $2 IM Reg DM Reg ALU IM Reg DM Reg sw $15, 100($2)

gestion des aléas aléas (ligne de dépendance vers l'arrière) CC1 CC2
valeur du registre $2 10 10 10 10 10/-20 -20 -20 -20 -20 instructions du programme aléas (ligne de dépendance vers l'arrière) ALU sub $2, $1, $3 IM Reg DM Reg ALU and $12, $2, $5 IM Reg DM Reg ALU IM Reg DM Reg or $13, $8, $2 ALU add $14, $2, $2 IM Reg DM Reg ALU IM Reg DM Reg sw $15, 100($2)

gestion des aléas le résultat dont a besoin est disponible dès la fin de l'étape EX de l'instruction sub $2, $1, $3 : CC3 les instructions and $12, $2, $5 et or $13, $6, $2 en ont besoin au début de leur étape EX, soit CC4 et CC5 il « suffit » de forwarder le résultat dès qu'il est disponible, sans attendre qu'il soit disponible à la lecture dans le register file nécessaire d'être capable de détecter les aléas

détection des aléas (1) on se limite au cas où l'on veut forwarder vers une instruction dans l'étape EX opération d'ALU (instruction de type R) opération de calcul d'adresse aléa quand une instruction a besoin du contenu d'un registre pour son étape EX alors qu'une instruction précédente va écrire ce même registre dans son étape WB on se repère en utilisant les buffers entre les étapes : ID/EX.RegisterRs se réfère au numéro du registre Rs se trouvant dans le buffer ID/EX du pipeline

Rappel format des instructions MIPS pour les instructions de type R, de branchement et d'accès à la mémoire champ rs rt rd shamt funct position des bits 31:26 25:21 20:16 15:11 10:6 5:0 instructions de type R (exemple : add rd, rs, rt ) 3510 ou 4310 offset 0:15 instructions d'accès à la mémoire (exemple : lw rt, offset(rs) ) 410 instructions de saut conditionnel (exemple : beq rs, rt, offset)

détection des aléas (1) on se limite au cas où l'on veut forwarder vers une instruction dans l'étape EX opération d'ALU (instruction de type R) opération de calcul d'adresse aléa quand une instruction a besoin du contenu d'un registre pour son étape EX alors qu'une instruction précédente va écrire ce même registre dans son étape WB on se repère en utilisant les buffers entre les étapes : exemple : ID/EX.RegisterRs se réfère au numéro du registre Rs se trouvant dans le buffer ID/EX du pipeline 2 paires de conditions d'aléas 1.a : EX/MEM.RegisterRd = ID/EX.RegisterRs 1.b : EX/MEM.RegisterRd = ID/EX.RegisterRt 2.a : MEM/WB.RegisterRd = ID/EX.RegisterRs 2.b : MEM/WB.RegisterRd = ID/EX.RegisterRt

détection des aléas (2) sub $2, $1, $3 and $12, $2, $5
est un aléa de type 1.a EX/MEM.RegisterRd = ID/EX.RegisterRs = $2 sub $2, $1, $3 or $13, $6, $2 est un aléa de type 2.b MEM/WB.RegisterRd = ID/EX.RegisterRt = $2 pas d'aléa pour les autres dépendances

détection des aléas (3) les règles précédentes ne sont pas suffisantes
certaines instructions n'écrivent pas dans le register file et elles provoqueraient un forward là où il n'est pas utile test de la ligne de commande RegWrite dans le champ WD des buffers du pipeline certaines instructions qui utilisent le registre $0 comme destination (exemple : sll $0 $1, 2) pas nécessaire de forwarder des résultats vers $0 les conditions 1 et 2 sont valides si EX/MEM.RegisterRd ≠ 0 et MEM/WB.RegisterRd ≠ 0 nécessaire aussi d'identifier correctement les données à forwarder

gestion des aléas CC1 CC2 CC3 CC4 CC5 CC6 CC7 CC8 CC9 valeur du
registre $2 10 10 10 10 10/-20 -20 -20 -20 -20 valeur de EX/MEM X X X -20 X X X X X valeur de MEM/WB X X X X -20 X X X X instructions du programme ALU sub $2, $1, $3 IM Reg DM Reg ALU and $12, $2, $5 IM Reg DM Reg ALU IM Reg DM Reg or $13, $8, $2 ALU add $14, $2, $2 IM Reg DM Reg ALU IM Reg DM Reg sw $15, 100($2)

gestion des aléas les dépendances sont marquées à partir des registres
CC1 CC2 CC3 CC4 CC5 CC6 CC7 CC8 CC9 valeur du registre $2 10 10 10 10 10/-20 -20 -20 -20 -20 valeur de EX/MEM X X X -20 X X X X X valeur de MEM/WB X X X X -20 X X X X instructions du programme les dépendances sont marquées à partir des registres du pipeline au lieu du register file ALU sub $2, $1, $3 IM Reg DM Reg ALU and $12, $2, $5 IM Reg DM Reg ALU IM Reg DM Reg or $13, $8, $2 ALU add $14, $2, $2 IM Reg DM Reg ALU IM Reg DM Reg sw $15, 100($2)

gestion des aléas toutes vers l'avant : les données sont
CC1 CC2 CC3 CC4 CC5 CC6 CC7 CC8 CC9 valeur du registre $2 10 10 10 10 10/-20 -20 -20 -20 -20 valeur de EX/MEM X X X -20 X X X X X valeur de MEM/WB X X X X -20 X X X X instructions du programme toutes vers l'avant : les données sont disponibles venant des registres du pipelines ALU sub $2, $1, $3 IM Reg DM Reg ALU and $12, $2, $5 IM Reg DM Reg ALU IM Reg DM Reg or $13, $8, $2 ALU add $14, $2, $2 IM Reg DM Reg ALU IM Reg DM Reg sw $15, 100($2)

gestion des aléas modifier le datapath pour prendre les
CC1 CC2 CC3 CC4 CC5 CC6 CC7 CC8 CC9 valeur du registre $2 10 10 10 10 10/-20 -20 -20 -20 -20 valeur de EX/MEM X X X -20 X X X X X valeur de MEM/WB X X X X -20 X X X X instructions du programme modifier le datapath pour prendre les données à partir de n'importe quel registre du pipeline ALU sub $2, $1, $3 IM Reg DM Reg ALU and $12, $2, $5 IM Reg DM Reg ALU IM Reg DM Reg or $13, $8, $2 ALU add $14, $2, $2 IM Reg DM Reg ALU IM Reg DM Reg sw $15, 100($2)

gestion des aléas modification du chemin de données
ID/EX EX/MEM MEM/WB ALU registers data memory M u x modification du chemin de données pour les seules instructions de type R (add, sub, and, or)

gestion des aléas ID/EX EX/MEM MEM/WB M u x ALU registers ForwardA data memory M u x M u x ForwardB Rs Rt M u x Rt EX/MEM.RegisterRd Rd Forwarding unit MEM/WB.RegisterRd pour les seules instructions de type R (add, sub, and, or)

gestion des aléas Mux control Source Explication ForwardA = 00 ID/EX
le premier opérande de l'ALU vient du register file ForwardA = 10 EX/MEM le premier opérande de l'ALU est forwardé du résultat précédent de l'ALU ForwardA = 01 MEM/WB le premier opérande de l'ALU est forwardé de la mémoire donnée ou d'un résultat précédent de l'ALU ForwardB = 00 le second opérande de l'ALU vient du register file ForwardB = 10 le second opérande de l'ALU est forwardé du résultat précédent de l'ALU ForwardB = 01 le second opérande de l'ALU est forwardé de la mémoire donnée ou d'un résultat précédent de l'ALU

gestion des aléas détection des aléas EX if (EX/MEM.RegWrite and (EX/MEM.RegisterRd ≠0) and (EX/MEM.RegisterRd = ID/EX.RegisterRs)) ForwardA=10 if (EX/MEM.RegWrite and (EX/MEM.RegisterRd ≠0) and (EX/MEM.RegisterRd = ID/EX.RegisterRt)) ForwardB=10 détection des aléas MEM if (MEM/WB.RegWrite and (MEM/WB.RegisterRd ≠0) and (MEM/WB.RegisterRd = ID/EX.RegisterRs)) ForwardA=01 if (MEM/WB.RegWrite and (MEM/WB.RegisterRd ≠0) and (MEM/WB.RegisterRd = ID/EX.RegisterRt)) ForwardB=01

gestion des aléas dans l'exemple précédent, pas d'aléa dans l'étage WB car résolu par un mécanisme interne au register file si on considère la suite d'instructions add $1, $1, $2 add $1, $1, $3 add $1, $1, $4 problème à l'étage WB nécessitant un forward depuis l'étage MEM équations modifiées pour en tenir compte : if (MEM/WB.RegWrite and (MEM/WB.RegisterRd ≠0) and not (EX/MEM.RegWrite and (EX/MEM.RegisterRd ≠0) and (EX/MEM.RegisterRd ≠ ID/EX.RegisterRs)) and (MEM/WB.RegisterRd = ID/EX.RegisterRs)) ForwardA=01 if (MEM/WB.RegWrite and (MEM/WB.RegisterRd ≠0) and not (EX/MEM.RegWrite and (EX/MEM.RegisterRd ≠0) and (EX/MEM.RegisterRd ≠ ID/EX.RegisterRt)) and (MEM/WB.RegisterRd = ID/EX.RegisterRt)) ForwardB=01

gestion des aléas Modifications nécessaires ID/EX EX/MEM MEM//WB IF/ID
Contrôle WB EX/MEM M MEM//WB IF/ID WB EX M WB M u x Registres Registre lecture #1 lecture #2 écriture Données ForwardA PC Lecture adresse Mémoire instructions instruction Zéro ALU Résultat M u x Mémoire données Données lues M u x Adresse Données à écrire ForwardB IF/ID.RegisterRs IF/ID.RegisterRt IF/ID.RegisterRt M u x EX/MEM.RegisterRd IF/ID.RegisterRd Forwarding unit MEM/WB.RegisterRd

gestion des aléas ID/EX NB : EX/MEM beaucoup d'éléments
du chemin de données non représentés (branchements, extension du bit de signe, etc...) Contrôle WB EX/MEM M MEM//WB IF/ID WB EX M WB M u x Registres Registre lecture #1 lecture #2 écriture Données ForwardA PC Lecture adresse Mémoire instructions instruction Zéro ALU Résultat M u x Mémoire données Données lues M u x Adresse Données à écrire ForwardB IF/ID.RegisterRs IF/ID.RegisterRt IF/ID.RegisterRt M u x EX/MEM.RegisterRd IF/ID.RegisterRd Forwarding unit MEM/WB.RegisterRd

gestion des aléas les développements précédents montrent la complexité de la gestion de quelques aléas ce ne sont pas les seuls... succession d'opérations lw et sw instructions de type li (load immediate) sauts conditionnels etc... nécessaire de prévoir les conditions de forwarding prenant en compte ces aléas complexité accrue du chemin de données et du contrôle

gestion des aléas certaines situations imposent de bloquer temporairement le pipeline (« stalls ») par exemple quand une instruction veut lire un registre qui vient d'être accédé en écriture par l'instruction précédente (lw)

encore en train de lire en
gestion des aléas IM Reg ALU DM CC1 CC2 CC3 CC4 CC5 CC6 CC7 CC8 CC9 encore en train de lire en mémoire quand on en a besoin dans l'ALU instructions du programme lw $2,20( $1) and $4, $2, $5 or $13, $8, $2 add $9, $4, $2 slt $1, $6, $3

l'instruction est un load
gestion des aléas nécessaire de bloquer temporairement le pipeline nécessaire de détecter l'aléa durant l'étape ID pour ajouter le blocage dans le contrôle if (ID/EX.MemRead and ((ID/EX.RegisterRt = IF/EX.RegisterRs) or (ID/EX.RegisterRt = IF/ID.RegisterRt))) stall the pipeline ensuite la logique de forwarding peut gérer la dépendance et le processus d'exécution peut se poursuivre le registre de destination du load correspond à un des registres source dans l'instruction à l'étape ID l'instruction est un load

gestion des aléas si l'instruction dans l'étape ID est bloquée, alors l'instruction dans l'étape IF doit l'être aussi gel du registre PC et du buffer IF/ID les étapes en aval (EX et suivantes) sont « occupées » en exécutant une instruction nop (no operation) Instr. Execution Memory Write-back RegDest ALUOP1 ALUOP0 ALUSrc Branch Mem-Read Mem-Write Reg-Write Memto-Reg R-format 1 lw sw X beq

gestion des aléas si l'instruction dans l'étape ID est bloquée, alors l'instruction dans l'étape IF doit l'être aussi gel du registre PC et du buffer IF/ID les étapes en aval (EX et suivantes) sont « occupées » en exécutant une instruction nop (no operation) obtenu en forçant à 0 les lignes de contrôle dans ID/EX automatiquement transmis aux buffers en aval Instr. Execution Memory Write-back RegDest ALUOP1 ALUOP0 ALUSrc Branch Mem-Read Mem-Write Reg-Write Memto-Reg R-format lw sw beq

gestion des aléas l'instruction and est chargée
CC1 CC2 CC3 CC4 CC5 CC6 CC7 CC8 CC9 instructions du programme l'instruction and est chargée et décodée aux cycles 2 et 3 Son étape EX est retardée jusqu'au cycle 5 l'instruction or est chargée au cycle 3 mais son étape ID est retardée au cycle 5 ALU lw $2,20( $1) IM Reg DM Reg ALU and devient nop IM Reg DM Reg ALU and $4, $2, $5 IM Reg DM Reg ALU IM Reg DM Reg or $13, $8, $2 ALU add $9, $4, $2 IM Reg DM Reg

gestion des aléas PCWrite ID/EX.MemRead unité de détection d'aléas
Contrôle M u x WB EX/MEM M MEM//WB M u x WB IF/ID EX M WB IF/ID.Write Registres Registre lecture #1 lecture #2 écriture Données ForwardA PC Lecture adresse Mémoire instructions instruction Zéro ALU Résultat M u x Mémoire données Données lues M u x Adresse Données à écrire ForwardB IF/ID.RegisterRs IF/ID.RegisterRt IF/ID.RegisterRt M u x EX/MEM.RegisterRd IF/ID.RegisterRd Forwarding unit MEM/WB.RegisterRd

gestion des aléas les aléas vus jusqu'à présent sont des aléas structurels ou de données les aléas de contrôles sont liés aux branchements complexes à gérer supposer que le branchement n'est pas pris tester le plus rapidement possible (dès l'étape ID) la condition si nécessaire (branchement pris) vider le pipeline (flush) et aller vers la nouvelle branche les exceptions sont gérées comme les aléas de contrôle stockage de la cause et du compteur PC dans des registres dédiés, puis branchement non conditionnel à une adresse réservée ( hex) hors du champ de ce cours...

hiérarchie des mémoires - caches
l'accès à la mémoire est pénalisant (lent par rapport à l'horloge de la CPU) difficile d'avoir une grande quantité de mémoire à proximité immédiate du processeur pour créer une situation optimisant les ressources disponibles, on utilise le fait que toutes les données ou les instructions ne sont pas accédées avec la même probabilité localité temporelle : si un item a été référencé, il sera probablement référencé encore dans un court laps de temps localité spatiale : si un item a été référencé, les items voisins le seront probablement aussi la mémoire disponible sera organisée en plusieurs couches suivant une hiérarchie

hiérarchie des mémoires
organisation de la mémoire en plusieurs niveaux pour fournir la quantité nécessaire avec la technologie fournissant le meilleur compromis vitesse/coût plus on est « loin » de la CPU, moins on a besoin de vitesse CPU vitesse taille coût technologie mémoire la plus rapide la plus petite la plus chère SRAM mémoire DRAM en 2010 SRAM : 5000$ /GB DRAM : 20$ / GB Flash : 4$ /GB Disque : 0,02$ /GB mémoire la plus lente la plus grande la moins chère disque magnétique, mémoire flash, SDD

les mouvements de données ne se font qu'entre niveaux adjacents la quantité minimum transférée est un « bloc » CPU niveau 0 si les données cherchées sont dans le niveau supérieur : « succès » ou « hit » sinon : « échec » ou « miss » (avec pénalité temporelle) la bonne compréhension de la hiérarchie est essentielle pour obtenir les meilleures performances niveau 1 niveau 2

La hiérarchie le plus souvent rencontrée CPU mémoire cache mémoire principale disque dans les chemins de données que nous avons utilisés, les mémoires d'instructions et de données sont en fait des caches de la mémoire principale, extérieure à la CPU (sur la carte mère) les points importants pour optimiser la performance : placement du bloc dans le niveau supérieur identification du bloc remplacement du bloc en cas d'échec stratégie d'écriture

exemple d'un cache très simple
dans notre exemple les requêtes du processeur sont d'un seul mot les blocs du cache sont constitués d'un seul mot problème : comment savoir si un mot est dans le cache ? si il y est, comment le trouver ? un mot ⇔ un bloc ⇒ facile de savoir si le mot est présent pour placer de façon ordonnée les mots dans le cache, on va faire correspondre la position dans le cache avec l'adresse en mémoire du mot (« direct mapping ») si la taille du cache est une puissance de 2, la position dans le cache sera donnée par les bits de poids faible de l'adresse en mémoire

cache à 8 places pour une mémoire de 32 mots 000 001 010 011 100 101 110 111 00000 11111

cache à 8 places pour une mémoire de 32 mots 000 001 010 011 100 101 110 111 00001 00101 01001 01101 10001 10101 11001 11101

pour savoir si la donnée dans le cache correspond au mot demandé : ajout d'un ensemble de tags au contenu du cache les bits de poids fort de l'adresse mémoire non utilisés pour l'adresse dans le cache plus un bit indiquant si le contenu du cache est valide (adresse cache déjà utilisée pour une donnée mémoire) état du cache TD

taille du cache adresse du mot cherché codée sur 32 bits
les 2 derniers bits sont 00 (on adresse des octets) les blocs peuvent contenir plusieurs mots pour un cache de 2n blocs, chacun contenant 2m mots (2m+2 octets) n bits pour identifier l'index des blocs 32 – (n+m+2) bits pour le tag + 1 bit de validation nombre de bits dans le cache = n x (taille du bloc + taille du tag + 1)

accès au cache pour un cache de 1024 blocs de 1 mot
… … = Tag 20 Données 32 10 Index Hit 1 1022 1023 1021 Index V Tag Données ...

accès au cache dans le cas d'un échec du cache, la procédure pour accéder à la donnée dans le niveau suivant de la hiérarchie est complexe, nécessitant, entre autres, des blocages du pipeline hors du champ de ce cours...

accès au cache en écriture
contrainte : garder la cohérence entre le contenu du cache et le contenu de la mémoire plusieurs stratégies possibles : écrire systématiquement dans le cache et aussi dans la mémoire (write-through) peut ralentir considérablement le processeur écrire dans le cache et dans un buffer et vider le buffer dans la mémoire par un système indépendant les performances vont dépendre de la vitesse d'accès à la mémoire en écriture vis-à-vis du taux d'opérations d'écriture que génère le processeut n'écrire que dans le cache et vider le cache dans la mémoire uniquement quand le bloc doit être remplacé (write-back) complexe à gérer

Conclusions on a vu comment implémenter un processeur « simple » dans différentes configurations d'exécution cycle unique multi-cycles pipeliné même pour cette architecture simple, l'obtention de meilleures performances se fait au prix d'une complexité accrue, en particulier pour les opérations de contrôle la compréhension du fonctionnement interne du processeur peut aider à optimiser la façon de programmer en particulier pour les accès aux données

à suivre... Périphériques

Unité Centrale de Traitement Processeur

Présentations similaires

Présentation au sujet: "Unité Centrale de Traitement Processeur"— Transcription de la présentation:

Présentations similaires

Notre projet

Feed-back

Entrer

S'autoriser via un réseau social:

Unité Centrale de Traitement Processeur

Présentations similaires

Présentation au sujet: "Unité Centrale de Traitement Processeur"— Transcription de la présentation:

Présentations similaires

Notre projet

Feed-back