Conception mono_cycle

Chapitre 5 : Conception mono_cycle 

Ou somme nous jusqu’à maintenant? 

• Les cinq composants classiques d’un ordinateur. 

Processeur 

Entrées Contrôle 

Mémoire 

Ch. Données 

Sorties 

• Objectif: Conception (chemin de données +contrôle) d’un processeur mono-cycle. 

– Un cycle d’horloge par instruction – Long temps d’exécution 

Page : 1 

Comment concevoir un processeur (étape par étape)? 

1. Analyse de l’ensemble d’instructions pour fixer les besoins en 

Chemin de données: 

Le chemin de données doit permettre le transfert des registres. 2. Choix d’un ensemble de composantes nécessaires pour le chemin de 

données et établissement de la méthodologie horloge. 3. Assemblage des différentes composantes pour la satisfaction des 

besoins. 4. Analyse de l’implémentation de chaque instruction pour déterminer 

les points de contrôles nécessaires pour effectuer le transfert des registres. 5. Assemblage de la logique de contrôle. 

L’objet de chaque instruction est donnée en fonction des transferts de registres. 

Le chemin de données inclut les éléments mémoires . 

Page : 2 

Les formats d’instructions MIPS (Rappel) 

• Tous les instructions MIPS possède 32 bits. Les trois formats d’ instruction sont : 

31 26 21 16 11 6 0 – R-type 

op rs rt rd decval funct 6 bits 5 bits 5 bits 5 bits 5 bits 6 bits 31 26 21 16 0 – I-type 

op rs rt immediate 6 bits 5 bits 5 bits 16 bits – J-type 

31 

op 26 target address 0 6 bits 26 bits 

• Les différents champs sont : 

– op: Code opération de l’instruction – rs, rt, rd: Les numéros de registres sources et destination. – Decval: Valeur de décalage. – funct: Choix de différentes opérations pour un même code op. – address / immediate: Adresse ou valeur immédiate – target address: Adresse de l’instruction de saut. 

Page : 3 

• ADD and SUB 

– addU rd, rs, rt – subU rd, rs, rt 

• OR Immediate: 

– ori rt, rs, imm16 

• LOAD et STORE 

– lw rt, rs, imm16 – sw rt, rs, imm16 

• BRANCH: 

– beq rs, rt, imm16 

Étape 1: Un sous ensemble d’instructions MIPS 

op 31 

26 21 16 11 6 0 rs rt rd decval funct 6 bits 5 bits 5 bits 5 bits 5 bits 6 bits op rs rt immediate 31 26 21 16 0 31 

6 bits 26 5 bits 21 5 bits 16 16 bits 0 op rs rt immediate 6 bits 5 bits 5 bits 16 bits 31 

26 21 16 0 op rs rt immediate 6 bits 5 bits 

5 bits 16 bits 

Page : 4 

Transfert logique des registres 

Toute les instructions commencent par la recherche(Fetch inst.). 

op | rs | rt | rd | decval | funct = MEM[ PC ] 

op | rs | rt | Imm16 = MEM[ PC ] 

Inst. Transfert des registres 

ADDU R[rd] <– R[rs] + R[rt]; PC <– PC + 4 

SUBU R[rd] <– R[rs] – R[rt]; PC <– PC + 4 

ORi R[rt] <– R[rs] + zero_ext(Imm16); PC <– PC + 4 

LOAD R[rt] <– MEM[ R[rs] + sign_ext(Imm16)]; PC <– PC + 4 

STORE MEM[ R[rs] + sign_ext(Imm16) ] <– R[rt]; PC <– PC + 4 

BEQ if ( R[rs] == R[rt] ) then PC <– PC +4+sign_ext(Imm16)] | 00 

else PC <– PC + 4 

Page : 5 

Étape 1:Les besoins pour le transfert des registres 

• Mémoire : 

–instructions & données 

• Registres (32 x 32) 

– Lire RS – Lire RT – Écrire RT or RD 

• PC 
• Étendre signe 
• Add et Sub registre or du champs immédiate étendu 
• Add 4 pour PC 

Page : 6 

Étape 2:Composants du chemin de données 

• Adder 

Éléments logique 

• MUX 

combinatoire (blocks de base) 

• UAL 

A B 

32 32 

32 Somme 

Carry 

32 32 

Selec A 32 t 

B 32 

OP A B 

Adder 

MUX 

ALU 

CarryIn 

Y 32 

32 Résultat 

Page : 7 

Éléments mémoires : Registre, banc de registre 

• Registre 

–Similaire à un bistable D sauf que: 

• N-bit entrées et sorties 
• Entrée de validation d’écriture –Write Enable (écriture validée) 
• (0): La sortie (Data Out) ne peut être changée. 
• (1): La sortie peut devenir celle de l’entrée (Data In). 

Write Enable 

Data Out N N •Banc de registre 

Clk 

Data In 

Clk 

Write Enable 

RW 5 RA RB 5 5 

RA or RB valide => busA or busB valide après « temps d’accès » 

busA busW 

32 

32 32-bit 

32 Registres 

busB 32 

Page : 8 

Élément mémoire: Mémoire idéale 

Write Enable 

Address 

• Mémoire (idéale) 

– Un seul bus d’entrées : Data In 

Data In 

DataOut – Un seul bus de sortie : Data Out 

• Le mot mémoire est sélectionner par : 

32 Clk 

32 

– L’adresse qui choisie la sortie sur Data Out. – Write Enable = 1: adresse sélectionne le mot mémoire ou l’entrée 

Data In sera écrite. 

• Clock input (CLK) 

– CLK pour la synchronisation de l’écriture(fixer le moment 

d’écriture) . – Durant l’opération de lecture, La mémoire fonctionne comme un 

block logique combinatoire. 

• Adresse valide => Data Out valide après « temps d’accès ». 

Page : 9 

3a: Rappel sur la recherche (Fetch) d’une instruction 

• Pour toutes les opérations RTL. 

– Décodage de l’instruction : Mem[PC] –Maître à jour le PC: 

• Code séquentielle: PC <- PC + 4 
• Branch et Jump: PC <- « autre chose » 

Clk 

PC Adresse 

Logique suivante 

Adresse Instruction (mot) Mémoire d’instructions 

32 

Chemin de données Mono-Cycle Based on UCB Page : 10 

3b: Addition et soustraction 

• R[rd] <- R[rs] op R[rt] Exemple: addU rd, rs, rt 

–Ra, Rb, et Rw s’obtiennent des champs rs, rt, et rd. –ALUctr et RegWr: logique de contrôle après le décodage de 

l’instruction 

31 

26 21 16 11 6 0 op rs rt rd decval funct 6 bits 5 bits 5 bits 5 bits 5 bits 6 bits RegWr 

5 Rd 

5 Rs 5 

Rt ALUctr 

Rw Ra Rb AL32 32-bit 

U 32 

Clk 

Registers 

32 busA busW 

32 

32 

Result 

busB 

Page : 11 

Temps op. Registre-Registre 

Clk 

Temps propagation du PC PC Anc. val Nouv. valeur Rs, Rt, Rd, Op, Func 

Temps d’accès dans la mémoire d’instructions Anc. Val. Nouvelle valeur 

Délai logique de contrôle ALUctr 

Anc. Val. Nouvelle valeur 

RegWr Anc. Val. Nouvelle valeur 

Temps d’accès registres busA, B 

Anc. Val. Nouvelle valeur 

Délai ALU busW 

Anc. Val. Nouvelle valeur 

RegWr 

5 Rd 

5 Rs 5 

Rt ALUctr 

Rw Ra Rb 

busA Écriture Registre 

Se fait ici 

AbusW 

32 L32 32-bit 

Result U 32 

Clk 

Registres 

busB 

32 

32 

Page : 12 

3c: Opérations logiques avec val. immédiate 

• R[rt] <- R[rs] op ZeroExt[imm16] ] 

31 

26 21 16 11 0 op rs rt immediate 

31 

6 bits 5 bits 5 bits 16 15 rd? 16 bits 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 

immediate 16 bits 16 bits Rd Rt RegDst 

Mux 

RegWr 

5 5 Rs 

5 

ALUctr 

busW 

Rw Ra Rb 

busA 

32 32-bit 

32 

Résultat 32 

Registers Clk 

busB 

32 32 

ZeroEimm16 

x32 t 16 ALUSrc 

Mux 

ALU 

Page : 13 

3d: Opération de chargement 

• R[rt] <- Mem[R[rs] + SignExt[imm16]] Exemple: lw rt, rs, imm16 

31 

26 21 16 11 0 op rs rt immediate 6 bits 5 bits 5 bits rd 16 bits Rd Rt RegDst 

Mux 

Rs RegWr 

5 5 5 

ALUctr 

Rw Ra Rb 32 32-bit 32 

Clk 

Registres 

32 

Exten32 dimm16 

e16 r 

ALUSrc 

ExtOp 

busA busW 

32 

32 

busB 

Mux 

Data In WrEn 

32 

Clk 

ALU 

MemWr Mux W_Src 

Adr 

Mémoire données 

32 

Page : 14 

3e: Opération de rangement 

• Mem[ R[rs] + SignExt[imm16] <- R[rt] ] Exemple: sw rt, rs, imm16 

31 

26 21 16 0 op rs rt immediate 6 bits 5 bits 5 bits 16 bits Rd 

Rt RegDst 

Rt 

32 

Exte32 

nder 

ALUctr 

Clk 

Mux 

RegWr 

5 5 

Rs 5 busW 

Rw Ra Rb 

busA 

32 32-bit 

32 32 

Registres busB 32 

imm16 

16 32 ExtOp 

ALUSrc 

Mux 

Data In WrEn 

32 

Clk 

MemWr 

ALU 

Adr 

Mémoire données 

Mux W_Src 

Page : 15 

3f: Saut conditionnel (Branch) 

• beq rs, rt, imm16 

– mem[PC] Chercher l’instruction de la mémoire 

– Equal <- R[rs] == R[rt] Calculer la condition du saut. 

– if (COND eq 0) Calculer l’adresse de la prochaine instruction 

• PC <- PC + 4 + ( SignExt(imm16) x 4 ) – else 
• PC <- PC + 4 

31 

26 21 16 0 op rs rt immediate 6 bits 5 bits 

5 bits 16 bits 

Page : 16 

3f: Saut conditionnel (Branch) 

• beq rs, rt, imm16 Chemin de données génère le siganl equal 

op rs rt immediate 31 

26 21 16 0 6 bits 5 bits 5 bits 16 bits 4 nPC_sel 

RegWr 5 5 32 

Clk 

imm16 

Rs 5 

Rt 

busW Rw Ra Rb 

busA ? 

32 e32 32-bit lagRegistres ÉbusB 32 

Adder 

00 Adder 

Mux 

PC Clk 

Adresse Inst. 

equal 

PC Ext 

Page : 17 

4 

00 

Assemblage : Chemin de données mono-cycle 

imm16 

Rd RegDst 

Extender 

ALUctr 

Clk 

Rt 

RegWr 

5 5 

Rs 

5 Rt 

busW Rw Ra Rb 

32 32-bit 32 

Registres busA 

32 

32 

busB 

32 

Adder Adder 

nPC_sel 

PC Ext 

Mux 

PC 

Clk 

Mémoire Inst. 

Adr 

Mux 

32 16 imm16 

ALUSrc ExtOp 

<0:15> 

Rs Rt Rd Imm16 1 

0 = 

<21:25> 

<16:20> 

<11:15> 

Equal 

0 1 

Instruction<31:0> 

MemtoReg 

0 1 

Clk 

MemWr 

ALU 

32 Data In WrEn Adr 

Mémoire données 

Page : 18 

Mux 

Vue simplifiée du chemin critique 

• Banc de registres et mémoire idéalisée: 

– Le signal CLK est important seulement durant l’opération d’écriture. – Durant la lecture, même comportement qu’un circuit combinatoire: 

• Adresse valide => Sortie valide après le « temps d’accès » 

Chemin critique (Load) = 

Temps propagation PC + Temps d’accès mémoire instructions + Temps d’accès banc de registre + Temps ALU pour addition 32 bits + Temps d’accès mémoires de données+ Temps établissement banc de registre Clk Mémoire Instruction idéale 

5 Rw Ra Rb 32 32-bit Registres 

k 

lCInstruction 

Instruction Address 

Rd 

Data Address AMémoire Ldonnées U 

Data In idéale 

Clk 

PC 

5 Rs 

Rt 

Imm 5 16 

A s 

32 se32 

r32 ddAt B 

xeN32 

Page : 19 

Temps op. Registre-Registre 

Clk 

PC Rs, Rt, Rd, Op, Func 

Temps propagation du PC Anc. val 

Nouv. valeur Temps d’accès dans la mémoire d’instructions Anc. Val. Nouvelle valeur 

Délai logique de contrôle ALUctr 

Anc. Val. Nouvelle valeur 

RegWr Anc. Val. Nouvelle valeur 

Temps d’accès registres busA, B 

Anc. Val. Nouvelle valeur 

Délai ALU 

Address Valeur Anc. Nouv. Valeur 

Temps Accés mémoire busW Valeur Anc. Nouv. Valeur 

NHA/MMY Chemin de données Mono-Cycle Based on UCB Page : 20 

Étape 4: Chemin de données et RTL -> Contrôle 

Instruction<31:0> 

<<<<022Mémoire 

0:156::1> :2instruction 

3551> > > Adr 

Op 

Fun 

Rt Rs Rd Imm16 nPC_sel 

RegWr RegDst ExtOp ALUSrc ALUctr MemWr MemtoReg Equal 

Chemin de données 

Contrôle 

NHA/MMY Chemin de données Mono-Cycle Based on UCB Page : 21 

<16:20> 

<11:15> 

Signification des signaux de contrôle 

• nPC_sel: 0 => PC <– PC + 4; 1 => PC <– PC + 4 + SignExt(Im16) | 00 
  

Adder Adder 

4 

00 

nPC_sel 

PC Ext imm16 

Clk 

Clk 

Mux 

PC 

Mémoire instruction 

Adr 

Page : 22 

Signification des signaux de contrôle 

• ExtOp: “zéro”, “signe” 
• ALUsrc: 0 => regB; 1 => immed 
• ALUctr: “add”, “sub”, “or” 

RegDst 

Rd 32 

Extender 

ALUctr 

Clk 

Rt 

RegWr 

5 5 

Rs 

5 Rt 

busW Rw Ra Rb 

32 32-bit 32 

Registers busA 

32 

32 

busB 

Mux 

32 16 imm16 

ALUSrc ExtOp 

0 1 

° MemWr: Écrire mémoire ° MemtoReg: 1 => Mem ° RegDst: 0 => “rt”; 1 => “rd” ° RegWr: Écrire registre destination Equal 

MemWr 

MemtoReg 

= 

ALU 0 0 1 32 Data In WrEn Adr 

Data 

1 

Clk 

Memory 

Mux 

Page : 23 

Signaux de contrôle 

inst Register Transfer 

ADD R[rd] <– R[rs] + R[rt]; PC <– PC + 4 

ALUsrc = RegB, ALUctr = “add”, RegDst = rd, RegWr, nPC_sel = “+4” 

SUB R[rd] <– R[rs] – R[rt]; PC <– PC + 4 

ALUsrc = RegB, ALUctr = “sub”, RegDst = rd, RegWr, nPC_sel = “+4” 

ORi R[rt] <– R[rs] + zero_ext(Imm16); PC <– PC + 4 

ALUsrc = Im, Extop = “Z”, ALUctr = “or”, RegDst = rt, RegWr, nPC_sel = “+4” 

LOAD R[rt] <– MEM[ R[rs] + sign_ext(Imm16)]; PC <– PC + 4 

ALUsrc = Im, Extop = “Sn”, ALUctr = “add”, MemtoReg, RegDst = rt, RegWr, nPC_sel = “+4” 

STORE MEM[ R[rs] + sign_ext(Imm16)] <– R[rs]; PC <– PC + 4 

ALUsrc = Im, Extop = “Sn”, ALUctr = “add”, MemWr, nPC_sel = “+4” 

BEQ if ( R[rs] == R[rt] ) then PC <– PC + sign_ext(Imm16)] || 00 else PC <– PC + 4 

nPC_sel = EQUAL, ALUctr = “sub” 

NHA/MMY Chemin de données Mono-Cycle Based on UCB Page : 24 

Logique pour chaque signal de contrôle 

• nPC_sel <= if (OP == BEQ) then EQUAL else 0 
• ALUsrc <= if (OP == “000000”) then “regB” else “immed” 
• ALUctr <= if (OP == “000000”) then funct 

elseif (OP == ORi) then “OR” 

elseif (OP == BEQ) then “sub” 

else “add” 

• ExtOp <= if (OP == ORi) then “zero” else “signe” 
• MemWr <= (OP == Store) 
• MemtoReg <= (OP == Load) 
• RegWr: <= if ((OP == Store) || (OP == BEQ)) then 0 else 1 
• RegDst: <= if ((OP == Load) || (OP == ORi)) then 0 else 1 

NHA/MMY Chemin de données Mono-Cycle Based on UCB Page : 25 

Exemple: Instruction de chargement (Load) RegDst Rd 32 

Extender 

ALUctr 

Clk 

Rt 

4 

RegWr 

5 5 

Rs 

5 Rt 

busW Rw Ra Rb 

32 32-bit 32 

Registres busA 

32 

32 

busB 

NHA/MMY Chemin de données Mono-Cycle Based on UCB Page : 26 

Adder Adder 

nPC_sel 

PC Ext 

add rt +4 

1 0 

00 Mux 

Mémoire <0:15instruction 

> Adr 

Rs Rt Rd Imm16 1 

0 = 

PC 

Mux 

Clk 

imm16 

32 6 16 1mmisign ext 

ExtOp 

ALUSrc 

<21:25> 

<16:20> 

<11:15> 

Equal 

0 1 

Instruction<31:0> 

MemtoReg 

0 1 

Clk 

MemWr 

ALU 

32 Data In WrEn Adr 

Mémoire données 

Mux 

Exemple réel d’un chemin de données MIPS 

NHA/MMY Chemin de données Mono-Cycle Based on UCB Page : 27 

Conclusions 

• 5 étapes pour la conception d’un processeur 

– 1. Analyse du jeux d’instructions => exigences du chemins de données – 2. Sélection des composants et établissement de la méthodologie horloge – 3. Assemblage du chemin de données en vue de satisfaction des exigences – 4. Analyse de l’implémentation de chaque instruction pour déterminer les 

valeurs nécessaires des contrôles. – 5. Assemblage de la logique de contrôle. 

• Contrôle est plus difficile 
• MIPS facilite la logique de contrôle – Mêmes tailles d’instructions – Registres sources toujours au même endroit dans l’instruction – Immédiate toujours même place et taille – Opérations toujours sur registres /immédiate 
• Chemin de données mono-cycle => CPI=1, CCT => long 
• Partie suivante du cours : implémentation de la logique de contrôle 

Page : 28 

 

télécharger gratuitement cours de Conception mono_cycle