Vous êtes sur la page 1sur 4

ARCHITECTURE DES ORDINATEURS/ Rapport de Projet

Factorisation d’instructions et ajout d’instructions

*Factorisation de MRMOVL/RMMOVL

Pour le fonctionnement de rmmovl et rmmovl on distingue la différence dans l’étage DECODE ,pour le rmmovl : valA et valB vont avoir des registres par contre le mrmovl y’aura uniquement un seul registre ,et dans l’etage Memory ,le rmmovl transforme un registre en mémoire contrairement à mrmovl,du coup dans le résultat écrit (étage Write back) pour le mrmovl va donner ce qui a dans la mémoire en revanche le rmmovl va pas contenir un registre pour le récrire en dans cet étage les modification opérées dans le code HCL de la version séquentiel sont les mêmes avec ceux de la version pipelinée mise à part les instructions suivantes :

La définition de l’intsing

Il faut d’abord ajouter l’instruction ifun intsing ifun

#A l’etage FETCH bool need_regids = icode in {RRMOVL, OPL, IOPL, PUSHL, POPL, IRMOVL, RMMOVL || (icode == MRMOVL && ifun==1)};#Modification apporte la spécification du MRMOVL

# Does fetched instruction require a constant word? bool need_valC = icode in {IRMOVL, RMMOVL || (icode == MRMOVL && ifun==1), JXX, CALL, IOPL};#Modification apporte la spécification du MRMOVL

bool instr_valid = icode in {NOP, HALT, RRMOVL, IRMOVL, RMMOVL|| (icode == MRMOVL && ifun==1), OPL, IOPL, JXX, CALL, RET, PUSHL, POPL};

#A l’etage memory ##Set read control signal

## Set read control signal bool mem_read = icode in {|| (icode == MRMOVL && ifun==1), POPL, RET };#Modification apporte la specification du MRMOVL;

## Set write control signal bool mem_write = icode in {|| (icode == RMMOVL && ifun==0), PUSHL, CALL} ;#Modification apporte la specification du RMMOVL;

## Select memory address int mem_addr = [

icode in {RMMOVL, PUSHL, CALL, MRMOVL} : valE; icode in {POPL, RET} : valA;

# Other instructions don't need address

];

## Select memory input data int mem_data = [

# Value from register

icode in {|| (icode == RMMOVL && ifun==0), PUSHL} : valA;

EXERCICE 2 Instruction LOOP :

L’instruction loop label est équivalente à la combinaison des deux instructions isubl 1,%ecx ; jne label sauf qu’elle ne modifie pas les cc. Elle décrémente donc le registre %ecx puis branche à l’étiquette label si %ecx n’a pas atteint 0. Elle est donc typiquement utilisée pour effectuer des boucles for. L'implémentation du LOOP dans la version pipepliné est très similaire à ce qui a été réalisé en séquentiel. Néanmoins on aura à rajouter certaines instructions notamment :

On ajoute d’abord :

intsing loop et intsing RECX

Le traitement de LOOP à ll’étage FETCH :

#correction de branchement de LOOP dans le cas d'une mauvaise prédiction (cas où il ne fallait pas boucler et donc prendre valp l'adresse de l'instruction suivante) icode == LOOP && valE == 0 : valA ;

bool need_valC = icode in {IRMOVL, RMMOVL || (icode == MRMOVL && ifun==1), JXX, CALL, IOPL, LOOP};#branchement conditionnelle pour LOOP par défaut on branchera à l'adresse fourni par VALC

Le traitement de LOOP à l’étage DECODE:

Le traitement de LOOP à l’étage EXCUTE est presque le même sauf qu’on introduit le loop:

################ Execute Stage

###################################

## Select input A to ALU int aluA = [ icode in {RRMOVL, OPL} : valA;

icode in {IRMOVL, RMMOVL, MRMOVL, IOPL, JMEM} : valC; icode in {CALL, PUSHL} : -4; icode in {RET, POPL} : 4;

# Other instructions don't need ALU

];

## Select input B to ALU

int aluB = [ icode in {RMMOVL, MRMOVL, OPL, IOPL, CALL, PUSHL, RET, POPL, JMEM, LOOP} : valB; icode in {RRMOVL, IRMOVL} : 0;

# Other instructions don't need ALU

];

## Set the ALU function int alufun = [

icode in {OPL, IOPL } : ifun;

1 : ALUADD;

]; Et on modifie le new_pc en remplaçant le booleen BCH par valE!=0 ################ Program Counter Update ############################

## What address should instruction be fetched at

int new_pc =

[

 

#

Call. Use instruction constant

icode == CALL : valC;

#

Taken branch. Use instruction constant

icode == JXX && valE != 0. : valC;

Completion of RET instruction. Use value from stack icode == RET : valM;

#

# Default: Use incremented PC

1 : valP;

];

EXERCICE 1 : Ajout des instructions jreg et jmem

Ajout de jreg

Exécution des instructions et caractéristiques

Etage

Etage jreg ra

jreg ra

Fetch

Fetch icode: ifun = M[PC] ra : rb = M[PC+1] valP = PC+2
Fetch icode: ifun = M[PC] ra : rb = M[PC+1] valP = PC+2

icode: ifun = M[PC] ra : rb = M[PC+1] valP = PC+2

Decode

Decode valA = R[ra]

valA = R[ra]

Execute

Execute

Memory

Memory

Write Back

Write Back

PC update

PC update PC = valA

PC = valA

Les caractéristiques de jreg sont donc : L’utilisation d’un registre, les instructions valides, le registre utilisé comme source (registre A) et new-pc = valA Pour lajout de jreg aux parties need_regids, instr_valid, srcA (rA), new_pc, voir le fichier HCL.

Ajout de jmem

Exécution des instructions et caractéristiques

Etage

Fetch

jmem D(rB)Exécution des instructions et caractéristiques Etage Fetch icode:ifun = M1[PC] ra:rb = M1[PC+1] valC = M4[PC+2]

icode:ifun = M1[PC] ra:rb = M1[PC+1] valC = M4[PC+2] valP = PC+6des instructions et caractéristiques Etage Fetch jmem D(rB) Decode valB = R[rb] Execute valE = valB

Decode

valB = R[rb]M1[PC] ra:rb = M1[PC+1] valC = M4[PC+2] valP = PC+6 Decode Execute valE = valB +

Execute

valE = valB + valCvalC = M4[PC+2] valP = PC+6 Decode valB = R[rb] Execute Memory Write Back PC update

Memory

Write Back

PC update

valM = M4[valE]R[rb] Execute valE = valB + valC Memory Write Back PC update PC = valM Les

= valB + valC Memory Write Back PC update valM = M4[valE] PC = valM Les

PC = valM= valB + valC Memory Write Back PC update valM = M4[valE] Les caractéristiques de jreg

Les caractéristiques de jreg sont:

L’utilisation d’un registre,

lutilisation de val C,

les instructions valides,

le registre utilisé comme source (registre B),

Alu A et Alu B utilisé avec valC et valB dans Execute,

Laddition de valB, val C est égal à une adresse mémorisée par valE,

En mémoire, l’adresse valE est lue et mis dans valM,

new-pc = valM

Pour lajout de jmem aux parties need_regids, need_valC, instr_valid, srcB (rb), aluA (valC), aluB (valB), mem_addr (valE), mem_read, new_pc, voir le fichier HCL modifié.