1 / 60

Chapitre1: CONCEPTION DE L’UNITE DE CONTRÔLE

Chapitre1: CONCEPTION DE L’UNITE DE CONTRÔLE. IUP 2 INFORMATIQUE Smail.Niar@univ-valenciennes.fr 2003/2004. PLAN DU CHAPITRE. Rappels: Architecture d’un Ordinateur Introduction : Rôle de l’unité de contrôle Les unités pour construire le chemin de données

muriel
Download Presentation

Chapitre1: CONCEPTION DE L’UNITE DE CONTRÔLE

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. Chapitre1:CONCEPTION DE L’UNITE DE CONTRÔLE IUP 2 INFORMATIQUE Smail.Niar@univ-valenciennes.fr 2003/2004

  2. PLAN DU CHAPITRE • Rappels: Architecture d’un Ordinateur • Introduction : Rôle de l’unité de contrôle • Les unités pour construire le chemin de données Le banc (fichier) de registre, l’UAL, CP, RI, … • Le format des Instructions : Représentation en mémoire • Comment Contrôler l’UAL? Comment lui demander du travail ? • Tout Rassembler : Le chemin de données en action !!!!!! • Les phases pour exécuter les instructions • Les équations logiques pour réaliser l’unité de contrôle • Réalisation par éléments circuits logiques (Hardwired Control Unit) • Réalisation par microprogrammation (microprogrammed Control Unit)

  3. Architecture des Ordinateurs: Pourquoi, Comment, ……? • Objectif : comprendre le fonctionnement des ordinateurs (l’étudier). • Pourquoi ? • Ecrire des programmes, compilateurs, drivers, … efficaces (rapides, consomment le moins de mémoire, …) • Savoir ce qui convient à une application • Permettre un dialogue avec le concepteur • Concevoir des architectures (à haut niveau)

  4. Rappels • Jeu d’instruction MIPS : • Registres: • Instructions courantes

  5. Introduction : Structure d’un processeur Unité Centrale CPU Central Processing Unit Processeur Bus d’adresse Bus de données Mémoire Centrale Organes d’entrées/Sortie

  6. Place de l’Unité de contrôle dans le processeur Signal d’état Registres Unité de contrôle ual Signaux de contrôle Les bus

  7. 1: Introduction • Rôle de l’unité de contrôle: • Décodage de l ’instruction (comprendre) : Quelles tâches à faire? • Contrôler l’exécution des instruction (le chemin de Données) • Les multiplexeurs (quelle entrée choisir, ..) • les mémoires (read ou write, .. • L ’UAL quelle opération réaliser • Chemin de Données: Ensembles des unités (UAL, Mémoire, registres, E/S, Bus, ..) utilisées pour réaliser une instruction

  8. Registre Instruction RI Code Op No R1 No R2 No RD Écrire sortieUAl dés que addition terminée Registres additionner Résultat Rôle de l’unité de contrôle Unité de contrôle Addition de 2 registres UAL

  9. Ce qu’il faut savoir: • Une instruction est exécuter en plusieurs étapes (phases) • Exemple: • Lecture Instruction, • Décodage, Lecture de opérandes, • Applications de l’opération, • Accès à la mémoire (si nécessaire) • Ecriture Résultat • Le début et la fin d’une étape est déterminé par un signal d’horloge • 1 Phase de l ’exécution = 1 Période Horloge= 1 cycle horloge = temps pour faire une tâche • Jeu d ’instruction : 3 groupes • Mémoire: Lw, Sw • UAL: Add, Sub, And, Or, Slt • Branchement (avec condition): Beq et Saut (sans condition) J

  10. Num Reg Lecture1 5 bits 32 Données Lues1 32 bits A R e g i s t e r 0 R e g i s t e r 1 M u x R e g i s t e r n – 1 R e g i s t e r n Num Reg Lecture2 5 bits Données Lues2 32 bits B M u x 2: Les Eléments Utilisés Pour Construire le Chemin de données • Un Banc de 32 Registres Opération : Lecture des données

  11. No Reg à lire 1 Données Lues1 32 bits A Mux $0 $1 No Reg à lire 2 Données Lues2 32 bits B Mux $31

  12. Le banc de Registres (suite….) Banc de registres : Opération Ecriture 1 1 EcrireReg =1 0 0 C 0 R e g i s t e r 0 1 1 D Num Reg Ecrire n - t o - 1 C 1 d e c o d e r R e g i s t e r 1 5 25 =00001 D n – 2 N-1 0 0 C R e g i s t e r n – 1 D C Données A Ecrire = 25 32 R e g i s t e r n D

  13. R e g i s t e r f i l e Lecture: Read Reg Num1 (5bits) Read Reg Num2 (5bits) Read data1 (32 Bits) Read data2 (32 Bits) Ecriture: Num reg (5 Bits) Write data (32 Bits) EcrireReg (1 bit) Fusionner les deux opérations 5 32 R e a d r e g i s t e r R e a d n u m b e r 1 d a t a 1 5 R e a d r e g i s t e r n u m e r 2 b 5 W r i t e 32 r e g i s t e r R e a d d a t a 2 W r i t e 32 d a t a W r i t e 1 EcrireReg Signal de contrôle

  14. A L U c o n t r o l 3 Z e r o A L U A L U r e s u l t b . A L U Les Autres Unités Prog e0 M e m W r i t e e15 e15 1 6 3 2 e15 e15 R e a d A d d r e s s S i g n d a t a e x t e n d e1 e1 D a t a W r i t e e0 e0 m e m o r y d a t a Arithmetic and logic unit M e m R e a d a . D a t a m e m o r y u n i t b . S i g n - e x t e n s i o n u n i t

  15. 3: Format des instructions • Le format d ’une instruction : Quelle est la forme (l’image de l ’instruction) en mémoire • Format Instruction : Plusieurs Champs ex code opération, registre, Adresse MC • Architecture MIPS : 3 Format : R (registre), I (Immédiat), J (jump ou saut) • Exemple1 :Format R add $18, $17, $8 # $18=$17+$8 Instruction Format:000000 10001 01000 10010 00000 100000 codop rs rt rd decVal fonct FORMAT R (registre) • L ’opération faite par l ’UAL Dépend du code op et de Fonct • CodOp toujours = 0 pour les opérations Ual (sur les entiers) DecVal est utilisés pour les instructions de décalage

  16. Format suite…. • Exemple2 : Format I Lw $1, $2(100) Charger $1 par MC[$2+100] 35 2 1 100 codop rs rt 16 bit offset Format I • Ce format est utilisé pour représenter les instructions utilisant une valeur immédiate (valeur explicite dans l ’instruction): • Instruction Mémoire : LW et SW • Opération Ual Immédiate : Addi , Subi, …… • Branchement avec Condition : BEQ, BNE, BNE $1, $2, 200 3 1 2 200 • c.f poly TP pour les codeops et le format des instructions $1  MC[$2+100] LW $1 MC[$2+100] SW 6 5 5 16

  17. Format suite ….. • Exemple 3: Format J J 1000 2 1000 Codeop(6 bits) Adresse absolue(26bits) 6 26

  18. Résumé • 3 Groupes d instructions 3 Formats • UAL R • Mémoire I • Branchement et Saut avec cond • Branchement : Beq • Saut : J J add addi Lw et sw … Sans cond

  19. 4 : Contrôle de L ’UAL A L U c o n t r o l SrcA Z e r o ALU Circuit logique À concevoir A L U SrcB r e s u l t UALContrôle 3 bits Contrôle UAL Champ Fonct 6 2 ALUOp envoyé par l’unité de contrôle

  20. Contrôle de L ’UAL ….suite • Opération de l ’UAL UalControl Opération réalisée 000 AND 001 OR 010 add 110 subtract 111 set-on-less-than • Cette UAL a été étudiée dans le chapitre 4 « Les circuits combinatoires » au paragraphe 4.4

  21. Le contrôle de L ’UAL Suite …. • Le contrôle de l ’Ual est réalisé grâce à 3 signaux • Pour les générer : 1) le type de l ’instruction 00 = lw, sw 01 = beq, 11 = arithmetique • 2) Le Champ Fonction • Table de Vérité ALUOp Fonction UalControl lw ou sw + beq - add + sub - and or slt ALUOp1 ALUOp0 F5 F4 F3 F2 F1 F0 0 0 X X X X X X 010 0 1 X X X X X X 110 1 X X X 0 0 0 0 010 1 X X X 0 0 1 0 110 1 X X X 0 1 0 0 000 1 X X X 0 1 0 1 001 1 X X X 1 0 1 0 111

  22. Contrôle de l ’Ual suite …... ALUOP 2 bits Block Contrôle Ual A L U O p 0 A L U O p 1 ualControl2 F 3 UalControl F 2 ualControl1 Fonct (F5..F0) F 1 ualControl0 F 0

  23. 2 Décodage et Lecture des Registres D 5 Ecriture Résultat ER A D a t a RI R e g i s t e r # A d d r e s s P C I n s t r u c t i o n Registres A L U A d d r e s s R e g i s t e r # I n s t r u c t i o n B m e m o r y D a t a m e m o r y R e g i s t e r # D a t a 1 Lecture Instruction LI 3 Exécution Exe 4 Lecture/Ecriture Mémoire Mem

  24. 5 Ecriture Résultat ER U.Contrôle A D a t a RI R e g i s t e r # A d d r e s s P C I n s t r u c t i o n Registres A L U A d d r e s s R e g i s t e r # I n s t r u c t i o n B m e m o r y D a t a m e m o r y R e g i s t e r # D a t a 1 Lecture Instruction LI 3 Exécution Exe 4 Lecture/Ecriture Mémoire Mem 2 Décodage et Lecture des Registres D Tout Rassembler ….suite SW $1, 20($2)

  25. Conception De l ’unité de contrôle P C 0 0 I n s t r u c t i o n R e a d M M A d d r e s s [ 2 5 – 2 1 ] r e g i s t e r 1 u u x x R e a d A I n s t r u c t i o n R e a d Z e r o M e m o r y 1 d a t a 1 1 [ 2 0 – 1 6 ] r e g i s t e r 2 A L U A L U A L U O u t 0 M e m D a t a R e g i s t e r s r e s u l t I n s t r u c t i o n W r i t e M R e a d [ 1 5 – 0 ] r e g i s t e r B u 0 AluOut d a t a 2 I n s t r u c t i o n W r i t e x [ 1 5 – 1 1 ] M I n s t r u c t i o n 4 1 W r i t e d a t a u 1 r e g i s t e r d a t a 2 x Contrôle UAL 0 I n s t r u c t i o n 3 [ 1 5 – 0 ] M u x M e m o r y 1 1 6 3 2 d a t a S h i f t Fonct S i g n r e g i s t e r l e f t 2 e x t e n d

  26. 6: Exécution en 5 étapes • 1 Lecture Instruction (LI) • 2 Décodage de l ’instruction et lecture des deux registres (D) • 3 (EX) • Exécution Ual si Instruction UAL • Ou bien Calcul d ’adresse mémoire donnée ou instruction (si instruction mémoire ou branchement) • Ou bien Fin de saut (instruction de saut) • 4 (Mem ou ER) • Accès Mémoire si LW ou LW (fin pour SW) • Ou Fin Instruction UAL • 5 Instruction LW : Ecriture dans le registre (ER) INSTRUCTIONS TAKE FROM 3 - 5 CYCLES!

  27. Résumé…... Instruction Type R: Add $1, $2, $3 Exécution Opération UAl Ecriture Résultat Registre Rechercher Instruction Fetch Décodage lecture reg Instruction: LW $1, 100($2) Lecture Donnée Mémoire Ecriture Donnée registre Rechercher Instruction Fetch Décodage lecture reg Calcul Adresse donnée ds UAl @=100+$2 d=Mc[@] $1=d Instruction: SW $1, 100($2) Ecriture Registre en mémoire Rechercher Instruction Fetch Décodage lecture reg Calcul Adresse donnée ds UAl Mc[@]<- $1 @=100+$2

  28. BEQ $1, $2, étiquette Comparaison entre Reg Ecriture adresse dans CP si cond Rechercher Instruction Fetch Décodage, lecture reg, Calcul Adresse ds UAl UAlout=$1-$2 Dest= @ branch J étiquette Ecriture adresse dans CP Rechercher Instruction Fetch Décodage, lecture reg, Calcul Adresse ds UAl

  29. Step 1: Instruction Fetch (Lecture Instruction) • Lire dans la mémoire avec PC et écrire dans IR • Incrémenter PC de 4 (on pense que la prochaine instruction sera celle qui se trouve à PC+4 , spéculation) RTL "Register-Transfer Language"IR = Memory[PC];PC = PC + 4;What is the advantage of updating the PC now? • L ’Ual sera Occupée dans les cycles suivants à faire d ’autres calculs. • Si on ne le fait pas maintenant, il va falloir rajouter un cycle • dans 90% des cas, si on exécute une instruction à l ’@ i , la prochaine sera à i+4 les branchements et sauts sont peu nombreux dans les programmes (moins de 10%)

  30. Step 2: Instruction Decode and Register FetchDécodage, Lecture des registres, calcul adresse branchement (D) • Lire les deux registres rs et rt (même si on ne les utilise pas) A = Reg[IR[25-21]]; (RS)B = Reg[IR[20-16]]; (RT) • Calculer l ’adresse de branchement et la stocker dans un registre (Dest) même si ce n ’est pas une instruction de branchement et même si on ne prend pas le branchement. • L’adresse de l’instruction cible du branchement est relative à la position courante, elle se trouve dans RI BNE $1, $2, 200 31 26 26 21 20 16 15 0 3 2 1 200 Dest = PC + (sign-extend(IR[15-0]) << 2);

  31. Un exemple cp+4+(valeur*4) si valeur < 0 CP=100 BNE $R1, $R2, valeur signée ADD ….. cp+4 = 104 si valeur >0 cp+4+(valeur*4) ex : 104 + 400 = 504

  32. Step 3 (Dépend du codeOp) • L’UAL réalise l’une des 3 tâches en fonction du codeOp • Si Instruction Mémoire : calcul @ mémoire ALUOut = A + sign-extend(IR[15-0]); • L ’Ual fait une addition, il y a un seul mode d’adressage Adresse = Registre Source Rs + Valeur Immédiate • Si Type R:Application de l ’opération dans l ’Ual en fonction du code Op et de Fonct ALUOut = A op B; L ’Ual réalise l ’opération demandée par l instruction • Si Branchement:Comparaison dans l’Ual en faisant une soustraction if (A==B) PC = Dest; L’Ual réalise une soustraction pour comparer

  33. Step 4 (pour type R et accès mémoire) • Si accès mémoireSi LW Memory Data Reg (MDR) = Memory[ALUOut]; Si SW Memory[ALUOut] = B; • R-type instructions finish Reg[IR[15-11]] = ALUOut; écriture dans rd

  34. Step 5 (Ecriture Dans un registre) Write-Back pour LW uniquement Reg[IR[20-16]]= MDR; Rt

  35. Summary: Action for R-type Action for memory-reference Action for Action for Step name instructions instructions branches jumps Instruction fetch IR = Memory[PC] PC = PC + 4 Instruction A = Reg [IR[25-21]] decode/register fetch B = Reg [IR[20-16]] Dest = PC + (sign-extend (IR[15-0]) << 2) Execution, address ALUOut = A op B ALUOut = A + sign-extend if (A ==B) then PC = PC [31-28] II (IR[25-0]<<2) computation, branch/ (IR[15-0]) PC = Dest jump completion Memory access or R-type Reg [IR[15-11]] = Load: MDR = Memory[ALUOut] ALUOut or completion Store: Memory [ALUOut] = B Load: Reg[IR[20-16]] = MDR Memory read completion

  36. 6 Conception De l ’unité de contrôle ecrirePC pcWrite ecrireReg ecritureMem MemWrite ecrireRI IRwrite selA ecrireUalOut P C 0 ecrireA 0 I n s t r u c t i o n R e a d M M A d d r e s s [ 2 5 – 2 1 ] r e g i s t e r 1 regDest u u x x R e a d A I n s t r u c t i o n R e a d Z e r o M e m o r y 1 d a t a 1 1 [ 2 0 – 1 6 ] r e g i s t e r 2 A L U A L U A L U O u t 0 M e m D a t a R e g i s t e r s r e s u l t I n s t r u c t i o n W r i t e M R e a d [ 1 5 – 0 ] r e g i s t e r B 0 u AluOut d a t a 2 I n s t r u c t i o n iorD W r i t e x [ 1 5 – 1 1 ] M I n s t r u c t i o n 1 4 W r i t e d a t a u 1 r e g i s t e r d a t a 2 x Contrôle UAL 0 I n s t r u c t i o n 3 ecrireB [ 1 5 – 0 ] M u x lectMem MemRead M e m o r y 1 selB 1 6 3 2 d a t a ualop S h i f t Fonct S i g n r e g i s t e r l e f t 2 e x t e n d memversReg MemToReg ecrireMDR EcrireDest

  37. s t r u c t i o n d e c o d e / I n I n s t r u c t i o n f e t c h r e g i s t e r f e t c h 0 M e m R e a d 1 A L U S r c A = 0 A L U S r c A = 0 L U S r c B = 1 1 I o r D = 0 A A L U O p = 0 0 I R W r i t e ecrireDst S t a r t A L U S r c B = 0 1 WriteA WriteB A L U O p = 0 0 P C W r i t e ) ) P C S o u r c e = 0 0 ' ) e Q p y t ' E - R J B = ' ' p = = O ( ) ' p W p M e m o r y a d d r e s s S O ' = B r a n c h O ( J u m p p O ( c o m p u t a t i o n ( r o E x e c u t i o n c o m p l e t i o n ) c o m p l e t i o n ' W L ' = p O 2 6 8 9 ( A L U S r c A = 1 A L U S r c A = 1 A L U S r c B = 0 0 A L U S r c A = 1 P C W r i t e A L U S r c B = 1 0 A L U O p = 0 1 A L U S r c B = 0 0 P C S o u r c e = 1 0 A L U O p = 0 0 P C W r i t e C o n d A L U O p = 1 0 writeUAL P C S o u r c e = 0 1 writeUAL ( O ) p ' = W ' S L ' W ' = ) p M e m o r y M e m o r y O ( a c c e s s a c c e s s R - t y p e c o m p l e t i o n 3 5 7 R e g D s t = 1 M e m R e a d M e m W r i t e R e g W r i t e I o r D = 1 I o r D = 1 M e m t o R e g = 0 WriteMDR W r i t e - b a c k s t e p 4 R e g D s t = 0 R e g W r i t e M e m t o R e g = 1

  38. La mis à jour de CP source CP séquence PC+4 MUX 00 branchement 32 bits Dest 01 (cp31_28//Ri25_0)<<2 10 Saut ZERO ET OU WritePcCond PC clock writePC (Sans cond)

  39. Implémentation de L ’unité de Contrôle WriteMDR writeUAL • Implementation: WriteA WriteB P C W r i t e P C W r i t e C o n d I o r D M e m R e a d Vers le chemin de données 20 signaux M e m W r i t e I R W r i t e C o n t r o l l o g i c M e m t o R e g P C S o u r c e A L U O p O u t p u t s A L U S r c B A L U S r c A R e g W r i t e R e g D s t N S 3 N S 2 N S 1 I n p u t s N S 0 état suivant 2 5 3 0 4 1 état actuel p p p p p p 1 3 2 0 O O O O S O O S S S CLK Registre d ’ETAT I n s t r u c t i o n r e g i s t e r o p c o d e f i e l d CodeOP

  40. 7 Les équations logiques pour implémenter l ’unité de Contrôle • Les équations des signaux de contrôle: • PcWrite (ou écrireCP) = état0+état9 • PcWriteCond= état8 • IouD (IorD) = état3+état5 • MemRead=état0+état3 • UalSelA==état2+état6+état8 • UALselB0 = Etat0 + Etat1 • UALselB1= Etat1 + Etat2 • WriteUAl = etat2 + Etat6 • …. • ….. • …

  41. Code OP Etat Actuel E3..E0 Etat Suivant ES3..ES0 0000 0 0 0 1 Lw (35) ou 0001 0 0 1 0 SW(43) LW (35) 0010 0 0 1 1 0011 0 1 0 0 0100 0 0 0 0 Sw(43) 0010 0 1 0 1 0101 0 0 0 0 Les Signaux Pour l ’état Suivant (ES)(ou NS dans le schéma) Type R (0) 0001 0 1 1 0 0110 0 1 1 1 BEQ (4) 0001 1 0 0 0 J (2) 0001 1 0 0 1

  42. Suite • ES3= J.état1 + BEQ.état1 • ES2= état6+R.état1+SW.état2+état3 • ES1=état6+R.état1+Lw.état2+LW.état1+SW.état1 • ES0=état0+ état6+ LW.état2+SW.état2+état1.J

  43. 8 Première Implémentation : Par des circuits Logiques Convention pour simplifier le circuits a b c a c b matrice des ET a a b c b c x x x= a.c+a.b y=a.b Matrice des Ou y y

  44. O p 5 O p 4 O p 3 O p 2 O p 1 O p 0 S 3 S 2 S 1 S 0 P C W r i t e P C W r i t e C o n d I o r D M e m R e a d M e m W r i t e I R W r i t e M e m t o R e g P C S o u r c e 1 P C S o u r c e 0 A L U O p 1 A L U O p 0 A L U S r c B 1 A L U S r c B 0 A L U S r c A R e g W r i t e R e g D s t N S 3 N S 2 N S 1 N S 0 Implémentation par des circuits logiquesPLA (Réseaux logique programmable) 0 1 2 3 4 5 6 7 8 9 a b c d e f i Matrice Des Et 0..9 = état0..9 a = Cop2.état1=J.état1 b = Cop4.Etat1=BEQ.état1 c = Cop0.état1=R.état1 d = Cop43.état2=Sw.état2 e = Cop35.état1=LW.état1 f = Cop43.état1=SW.état1 i= Cop35.état2=Lw.état2 Matrices Des OU

  45. m n Implémentation en utilisant Des Mémoires à Lecture seulement ROM • ROM = "Read Only Memory" • les valeurs dans la ROM sont fixées d’avance • Une mémoire ROM peut être utilisée pour réaliser une table de vérité • Chaque combinaison des variables est représentée par une ligne (1mot) de la ROM. • S ’il y a m variables , il faut une ROM avec 2m lignes. • S ’il y a n signaux de contrôle il faut n bits par mot de la ROMil faut m lignes d ’adresse et n ligne de données @ données 0 0 0 0 0 1 1 0 0 1 1 1 0 0 0 1 0 1 1 0 0 0 1 1 1 0 0 0 1 0 0 0 0 0 0 1 0 1 0 0 0 1 1 1 0 0 1 1 0 1 1 1 0 1 1 1

  46. Un exemple simple : ET OU OUX Et Ou Oux 0 0 0 0 0 0 1 1 0 1 1 0 1 1 0 1 1 1 1 0

  47. Implémentation par une ROM • Quelle est la capacité de ROM? • Il y a 6 bits pour le code OP et 4 bits pour le registre état • Il faut 210 mots contenant ……? • 20 bits pour les signaux de contrôle, 4 bits d ’états = 24 bits • taille de la ROM = 210 x 20 = 24K bits N S 0 N S 2 N S 3 N S 1 Mem Re ad I Ou D Pc w r t e Pc W c o n d ……... State codeOp 0 0 0 1 ………………………… 0 0 0 1 0000 000000 0000 000001 0000 000010 ………… 1111 111111 0 0 0 1 ………………………… 0 0 0 1 0 0 0 1 ………………………… 0 0 0 1

  48. 9 La Microprogrammation • L ’inconvénient d ’une solution basée sur le matériel=Rigidité • Dans 1 UC microprogrammée • 1 instruction = 1 programme à exécuter (le microProg) • 1 prog = 1 suite de instructions • 1 instructions = ensemble de bits = signaux de contrôle Maurice Wilkes Pionnier dans le domaine de l’architecture des ordinateurs L ’un des premier à avoir travailler sur la Microprogrammation (année 60) La Mémoire de microprogs microProg 1 Code Opération microProg 2 microProg 3

  49. Microprogramme Load : Ri=MC[CP], CP=Cp+4 Lire RS1 et RS2 dans A et B, Dest = ……. UalSortie= A+ExtSigne (RI 15..0) Lire MDR=MC[UalSortie] Reg Dest = MDR Microprogramme ADD, SUB, OR, …….: Ri=MC[CP], CP=Cp+4 Lire RS1 et RS2 dans A et B, Dest = ……. UalSortie = A Op B Reg Dest = UalSortie adresse Début Microprog ADD, SUB, • Ri=MC[CP], CP=Cp+4 • Lire RS1 et RS2 dans A et B, Dest = ……. • UalSortie = A Op B • Reg Dest = UalSortie Mémoire Des microprogrammes • Ri=MC[CP], CP=Cp+4 • Lire RS1 et RS2 dans A et B, Dest = ……. • UalSortie= A+ExtSigne (RI 15..0) • Lire MDR=MC[UalSortie] • Reg Dest = MDR Adresse début MicroProg Load

  50. MicroProgrammation suite • Il existe plusieurs micro-Instructions communes entres les microprogrammes, exemple: Lecture de l’instruction, décodage • Au lieu de multiplier le nombre de micro-Instruction • On Ecrit une seule fois la micro_Instruction et on met une indication dans la micro_Instruction pour indiquer ou se situe la prochaine micro_Instruction • Pour la machine MIPS, il y a 4 Cas: • La prochaine micro Instruction est la suivante (seq) ex passage de 0 à 1 • La prochaine micro Instruction est la micro Instruction correspondante à l ’étape 0 (fetch) • La prochaine micro Instruction est déterminée par le codeOP Point de commutation 1 (distpatch 1) • La prochaine micro Instruction est déterminé par le codeOP Point de commutation 2 (dispatch 2) • C ’est les deux bits adressControl qui détermine le quel des 4 cas il faut considérer

More Related