EXAMEN D’ARCHITECTURE DES SYSTEMES A PROCESSEURS

Exercice 1 :
Le tableau ci-dessous présente les étages du pipeline d’un processeur

Etage 1 La lecture de l’instruction (Instruction Fetch) – IF

La prochaine instruction à exécuter est chargée à partir de la case mémoire pointée par le compteur
de programme PC dans le registre d’instruction IR
Etage 2 Décodage de l’instruction (Instruction Decode) – ID
Cette étape consiste à préparer les arguments de l’instruction pour l’étape suivante où ils seront
utilisés. Ces arguments sont placés dans deux registres A et B
Etage 3 Exécution de l’instruction (Instruction Execution) – IE
Cette étape utilise l’unité arithmétique et logique pour combiner les arguments
Etage 4 Accès à la mémoire (Memory Access) – MA
Cette étape est uniquement utile pour les instructions de chargement et de rangement (mémoire).
Pour les instructions arithmétiques et logiques ou les branchements, rien n’est effectué.
Etage 5 Rangement du résultat (Write Back) – WB
Le résultat des opérations arithmétiques et logiques est rangé dans le registre destination.

1. Sachant que chaque étage du pipeline est exécuté en un cycle d’horloge, compléter le tableau
ci-dessous correspondant à l’exécution des 5 instructions dans le pipeline (le premier cycle de
la première instruction est donnée).

Prog Cycles d’horloge

1 2 3 4 5 6 7 8 9
Instr- 1 IF ID IE MA WB
Instr- 2 IF ID IE MA WB
Instr- 3 IF ID IE MA WB
Instr- 4 IF ID IE MA WB
Instr- 5 IF ID IE MA WB

2. Sachant que les instructions LDI et STI correspondent respectivement à un chargement et

rangement indirect nécessitent deux accès mémoires (2 cycles d’horloge), expliquez pourquoi
cette structure de pipeline n’est pas adaptée à ces instructions.

3. Considérons le morceau de code suivant :

LDR R7, [R6,#(0)16]
ADD R6, R6, #(1)16
ADD R0, R0, #(1)16
ADD R1, R1, #(1)16

Représenter l’exécution de ce code dans le pipeline.

Code Cycles d’horloge
1 2 3 4 5 6 7 8
LDR R7, [R6,#(0)16] IF ID IE MA WB
ADD R6, R6, #(1)16 IF ID IE MA WB
ADD R0, R0, #(1)16 IF ID IE MA WB
ADD R1, R1, #(1)16 IF ID IE MA WB
 Ce code génère un problème d’exécution dans le pipeline (aléa)
a. De quel type d’aléas s’agit-il ?
R : Aléa structurel.

b. Expliquez-le ?
R : L’étape MA (Accès Mémoire) de l’instruction LDR R7, [R6,#(0)16] a lieu en même
temps que l’étape IF (chargement de l’instruction) ADD R1, R1, #(1)16 . Ces deux étapes
nécessitent simultanément l’accès à la mémoire. Comme cela est impissible,
l’instruction ADD R1, R1, #(1)16 et celle qui suivent sont retardées d’un cycle.

c. Donnez une solution pour le résoudre.

R : Le conflit d'accès à la mémoire se produit à chaque fois qu'une instruction de
chargement ou de rangement est exécutée. Celle-ci rentre systématiquement en conflit
avec le chargement d'une instruction qui a lieu à chaque cycle d'horloge. Ce problème
est généralement résolu en séparant la mémoire où se trouvent les instructions de celle
où se trouvent les données.

Exercice 2 :
Le tableau ci-dessous présente une liste d’instructions d’un processeur 8-bit dont le banc de registre
contient les registres R1, R2, R3. Le processeur n’a pas de pipeline et son jeu d’instructions est décrit
dans le tableau 1.
1. Indiquez pour chacune des instructions, les valeurs (en binaire et en hexa) des registres R1, R2,
R3 (remplissez directement le tableau).

N° Instruction Registre R1 Registre R2 Registre R3

1 Init 0000 0000 0x00 0000 0000 0x00 0000 0000 0x00

2 LDR R1, #(A0)16 1010 0000 (A0)16 0000 0000 0x00 0000 0000 0x00
3 LDR R2, #(0A)16 1010 0000 (A0)16 0000 1010 (0A)16 0000 0000 0x00
4 ADD R3, R1, R2 1010 0000 (A0)16 0000 1010 (0A)16 1010 1010 (AA)16
5 SHR R3, #(2)16 1010 0000 (A0)16 0000 1010 (0A)16 0010 1010 (2A)16
6 ADD R3, R2, R3 1010 0000 (A0)16 0000 1010 (0A)16 0011 0100 (34)16
7 SHL R3, #(4)16 1010 0000 (A0)16 0000 1010 (0A)16 0100 0000 (40)16
8 NOT, R3 1010 0000 (A0)16 0000 1010 (0A)16 1011 1111 (BF) 16
9 MOV R1, #(81)16 1000 0001 (81)16 0000 1010 (0A)16 1011 1111 (BF) 16
10 ADD R3, R1, R3 1000 0001 (81)16 0000 1010 (0A)16 0100 0000 (40)16
11 INC, R3 1000 0001 (81)16 0000 1010 (0A)16 0100 0001 (41)16
 Tableau 1 : Jeu d’instructions
Instruction Description
LDR Rx, #(Val) Charge le registre Rx avec la valeur Val
LDR Rx, [Ry, #(Val)] Rx = Mémoire [Ry + Val]
ADD Rx, Ry, Rw Registre Rx = Ry + Rw
ADD Rx, Ry, #Val Registre Rx = Ry + Val
SHR Rx, #Val Effectue un décalage logique à droite de la valeur du registre Rx et charge le
résultat dans Rx. Val représente le nombre de décalage à exécuter.
SHL Rx, #Val Effectue un décalage logique à gauche de la valeur de Rx et charge le résultat dans
Rx. Val représente le nombre de décalage à exécuter.
MOV Rx, #(Val) Charge le registre Rx avec la valeur Val
NOT, Rx Effectue un complement logique de la valeur de Rx et charge le résultat dans Rx
INC, Rx Incrémente la valeur de Rx de 1

Corrigé par les étudiants de LET 2 :

EYET TCHAULLY Yanne Michma

HOHISSA Enoch Vérold Rifa
ITOUA IKOBO Frédérique Pricine
KIMPALOU LOUTAYA Anisie Priscille
NGOULOU WAMENA Joresse Merveil
MOUSSITOU NZOUSSI Jéssica Clécie

Année académique : 2021 – 2022

S’il y a des erreurs, veuillez bien nous pardonner !!!  Surtout ne nous jugez pas et ne pensez pas que
c’est fait exprès, vous n’aurez qu’à corriger vos solutions mais celui-ci sera un document non
modifiable. De toutes les façons, c’est notre document  donc votre avis n’importe pas. Merciii !!! 
Meilleurs que nous    tu meurs †

Fait, à Brazzaville le 04 Septembre 2022