You are on page 1of 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 jreg ra

Fetch icode: ifun = M[PC]


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

Decode valA = R[ra]

Execute

Memory

Write Back

PC update 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 l’ajout 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 jmem D(rB)

Fetch icode:ifun = M1[PC]


ra:rb = M1[PC+1]
valC = M4[PC+2]
valP = PC+6

Decode valB = R[rb]

Execute valE = valB + valC

Memory valM = M4[valE]

Write Back

PC update PC = valM

Les caractéristiques de jreg sont:


 L’utilisation d’un registre,
 l’utilisation 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,
 L’addition 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 l’ajout 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é.