Vous êtes sur la page 1sur 10

INF1600

Travail pratique 1
Périphériques et architecture

Département de Génie Informatique et Génie Logiciel


Polytechnique Montréal
Polytechnique Montréal Département de Génie Informatique et Génie Logiciel

1 Introduction et sommaire
Vous commencez aujourd’hui le premier travail pratique du cours INF1600. Le laboratoire porte sur la
manipulation des bits et le processeur à accumulateur.

1.1 Remise
Voici les détails concernant la remise de ce travail pratique :
 Méthode : sur Moodle, une seule remise par équipe, incluant un rapport PDF et les fichiers sources
des exercices 1, 2 et 3.
 Format: un rapport PDF. Incluez une page titre où doivent figurer les noms et matricules des deux
membres de l’équipe, votre groupe de laboratoire, le nom et le sigle du cours, la date de remise et
le nom de l’École. Dans une seconde page, incluez le barème de la section 1.2. Finalement, pensez
à incluez les réponses aux questions et des captures d’écran lorsque requis.
 Pour l’exercice 1, remettez le fichier source complété sous la forme
<matricule1>-<matricule2>-<tp1exo1>.c
 Pour l’exercice 2, remettez le fichier source complété sous la forme
<matricule1>-<matricule2>-<tp1exo2>.vhdl
 Pour l’exercice 3, remettez le fichier source complété sous la forme
<matricule1>-<matricule2>-<tp1exo3>.vhdl
 Distribution : les deux membres de l’équipe recevront la même note.
Attention : L’équipe de deux que vous formez pour ce TP sera définitive jusqu’au TP5. Il ne sera pas
possible de changer d’équipe au cours de la session.

INF1600 2/10 Hiver 2021


Polytechnique Montréal Département de Génie Informatique et Génie Logiciel

1.2 Barème
Le travaux pratiques 1 à 5 sont notés sur 4 points, pour un total de 20/20 Le TP1 est noté selon le barème
suivant. Reproduisez ce tableau dans le document PDF que vous remettrez.

TP 1 /4,00
Exercice 1 /1,50
Q1 /0,50
Q2 /0,50
Q3 /0,50
Exercice 2 /1,00
Q1 /0,25
Q2 /0,25
Q3 /0,25
Q4 /0,25
Exercice 3 /1,50
Q1 /0,50
Q2 /1,00

INF1600 3/10 Hiver 2021


Polytechnique Montréal Département de Génie Informatique et Génie Logiciel

2 Exercice 1 : Opérations binaires et de décalage


L’objectif de cet exercice est de vous familiariser avec les opérateurs binaires (&, |, ^, << , >>). Vous
devez compléter des parties manquantes d’un code afin de décoder un fichier encodé.

Dézipper le dossier INF1600_TP1.zip fourni et changer le dossier de travail :


cd exo1
On vous fournit le fichier à compléter (exo1.cpp), accompagné d’un makefile. Vous pouvez faire les
commandes suivantes dans un terminal depuis le répertoire exo1.
$ make
$ ./exec

Q1 : Compléter la fonction parity qui prend en paramètre un short1 c et retourne 0 ou 1 selon que le
nombre de 1 contenu dans l’encodage binaire de c est respectivement pair ou impair. Par exemple, si c vaut
14 (0b1110), la fonction retournera 1 puisque 14 contient trois 1. Si c vaut 15 (0b1111), la fonction
retournera 0 puisqu’il y a quatre 1 dans ce cas.
Attention : votre fonction ne doit pas compter le nombre de 1 mais utiliser les opérateurs binaires (&, |, ^,
<<, >>) pour déterminer la parité. Cela se fait en effectuant un XOR sur l’ensemble des bits du mot.

Q2 : Compléter la fonction hamming_encoding qui prend en entrée un char et le convertit en short selon
l’encodage de Hamming2. Pour ce faire, votre fonction ne doit utiliser que les opérateurs binaires (&, |, ^,
<<, >>) et la fonction parity réalisée en Q1.

L’encodage se fait selon le schéma suivant :

0 1 1 0 0 0 0 1 char
7 6 5 4 3 2 1 0
forcés à 0

0 0 0 0 0 1 1 0 0 0 0 0 0 1 1 0 short
15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0

p3 p2 p1 p0

Figure 1 Illustratiuon de l’encodage de Hamming.

Les bits de parité p0, à p3 s’obtiennent comme suit :


p0 = parity(b2, b4, b6, b8, b10, b12, b14)
p1 = parity(b2, b5, b6, b9, b10, b13, b14)
p2 = parity(b4, b5, b6, b11, b12, b13, b14)

1
Un short est un mot de 16 bits.
2
Le code de Hamming permet la détection et la correction d’une erreur. Plus d’information peut être trouvé en suivant
ce lien : https://fr.wikipedia.org/wiki/Code_de_Hamming.

INF1600 4/10 Hiver 2021


Polytechnique Montréal Département de Génie Informatique et Génie Logiciel

p3 = parity(b8, b9, b10, b11, b12, b13, b14)


Le calcul des bits de parité est illustré ci-après :

0 0 1 0 0 0 1 0 p0
15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0

0 0 1 1 0 0 1 1 p1
15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0

0 0 0 0 0 0 0 0 p2
15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0

0 0 0 0 1 1 0 0 p3
Q3 : Compléter la fonction hamming_decoding qui prend en entrée un short et le convertit en char selon
le schéma de décodage de Hamming3 qui permet de détecter et de corriger une erreur si elle se produit. Ceci
s’effectue en calculant la bits c0 à c3 comme suit :
c0 = parity(b0, b2, b4, b6, b8, b10, b12, b14)
c1 = parity(b1, b2, b5, b6, b9, b10, b13, b14)
c2 = parity(b3, b4, b5, b6, b11, b12, b13, b14)
c3 = parity(b7, b8, b9, b10, b11, b12, b13, b14)

Si le mot binaire formé par les bits c0 à c3 (c3c2c1c0) donne 0, aucune erreur n’est détectée. Sinon, il suffit
d’inverser le bit à la position c3c2c1c0. Le principe est illustré ci-après :

Cas sans erreur Cas avec erreur

0 0 0 0 0 1 1 0 0 0 0 0 0 1 1 0 short 0 0 0 0 0 1 1 0 0 0 1 0 0 1 1 0 short
15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0

0 0 1 0 0 0 1 0 c0 = 0 0 0 1 0 0 0 1 0 c0 = 0
15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0

0 0 1 1 0 0 1 1 c1 = 0 0 0 1 1 0 1 1 1 c1 = 1
15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0

0 0 0 0 0 0 0 0 c2 = 0 0 0 0 0 0 1 0 0 c2 = 1
15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0

0 0 0 0 1 1 0 0 c3 = 0 0 0 0 0 1 1 0 0 c3 = 0
15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0

c3c2c1c0 = 0, il suffit de recopier le short et de reporter les bits vers leur c3c2c1c0 = 0110(2) = 6, il faut inverser le bit à la position 6 – puis
position dans le char reporter les bits vers leur position dans le char
0 0 0 0 0 1 1 0 0 0 0 0 0 1 1 0 short 0 0 0 0 0 1 1 0 0 0 0 0 0 1 1 0 short
15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0

0 1 1 0 0 0 0 1 char 0 1 1 0 0 0 0 1 char
7 6 5 4 3 2 1 0 7 6 5 4 3 2 1 0

Ici aussi, votre fonction ne doit utiliser que les opérateurs binaires (&, |, ^, << , >>) et la fonction
parity réalisée en Q1.

3
Le code de Hamming permet la détection et la correction d’une erreur. Plus d’information peut être trouvé en suivant
ce lien : https://fr.wikipedia.org/wiki/Code_de_Hamming.

INF1600 5/10 Hiver 2021


Polytechnique Montréal Département de Génie Informatique et Génie Logiciel

Une fois l’exercice complété, le programme exec devrait afficher ce qui suit :
Q1
parity(14) retourne 1
parity(15) retourne 0
Q2
Le code hexadecimal de 'a' est 0x61
Le code de Hamming de 'a' donne 0x0606
Q3
Le code hexadecimal de 'a' est 0x61
Le code de Hamming de 'a' donne 0x0606
Une fois decode, on obtient 0x61, cad 'a'
Et meme altere comme ceci 0x0607, on retrouve 'a'
Et meme altere comme ceci 0x0604, on retrouve 'a'
Et meme altere comme ceci 0x0602, on retrouve 'a'
Et meme altere comme ceci 0x060e, on retrouve 'a'
Et meme altere comme ceci 0x0616, on retrouve 'a'
Et meme altere comme ceci 0x0626, on retrouve 'a'
Et meme altere comme ceci 0x0646, on retrouve 'a'
Et meme altere comme ceci 0x0686, on retrouve 'a'
Et meme altere comme ceci 0x0706, on retrouve 'a'
Et meme altere comme ceci 0x0406, on retrouve 'a'
Et meme altere comme ceci 0x0206, on retrouve 'a'
Et meme altere comme ceci 0x0e06, on retrouve 'a'
Et meme altere comme ceci 0x1606, on retrouve 'a'
Et meme altere comme ceci 0x2606, on retrouve 'a'
Et meme altere comme ceci 0x4606, on retrouve 'a'

INF1600 6/10 Hiver 2021


Polytechnique Montréal Département de Génie Informatique et Génie Logiciel

3 Exercice 2 : Architecture simple d’un microprocesseur


3.1 Introduction
Un microprocesseur à accumulateur vous a été présenté en cours. Les étudiants intéressés sont invités à
consulter la vidéo à ce lien. La Figure 2 illustre grossièrement son architecture.

Figure 2 Processeur à accumulateur.

Le processeur possède trois registres de 16 bits, PC, IR et ACC. Le registre PC est le compteur de programme
et pointe vers le contenu de la mémoire ou l’instruction à exécuter réside. Il est initialisé à l’adresse 0x0000.
Le registre IR contient l’instruction à exécuter. Cette instruction a été lue depuis la mémoire à l’adresse
mem[PC]. Elle sera ensuite décodée par l’unité de contrôle avant exécution.

Le processeur implémente les instructions suivantes :


OPCODE Hexadécimal Description
add 0x0000 ACC  ACC + mem[adresse]

mul 0x0100 ACC  ACC * mem[adresse]

st (store) 0x0200 mem[adresse]  ACC

ld (load) 0x0300 ACC  mem[adresse]

stop 0x0400 La boucle d’exécution arrête.

nop (no operation) 0x0500 Ne fait rien.

Le format d’une instruction est le suivant :


opcode adresse
0x 00 00

Par exemple : (ld,7) = 0x0307.


Le registre ACC sert de tampon pour la mémoire et permet de stocker le résultat des calculs effectués par le
processeur.

INF1600 7/10 Hiver 2021


Polytechnique Montréal Département de Génie Informatique et Génie Logiciel

La boucle d’exécution du processeur est illustrée par le schéma suivant :

Fetch Decode Execute


IR = mem[PC] Interprète IR Met à jour ACC et/ou mem
PC = PC + 1

3.2 Simulation du processeur


La section suivante montre comment exécuter la simulation du processeur à partir des fichiers sources
fournis. Avant de commencer, veuillez installer les logiciels requis pour cet exercice : ghdl pour compiler
et simuler du VHDL et gtkwave pour visualiser les signaux générer par la simulation.
sudo dnf install -y ghdl gtkwave

Dézipper le dossier INF1600_TP1.zip fourni et changer le dossier de travail :

cd exo2

Un script vous est fourni pour faire la simulation du processeur et ouvrir le logiciel gtkwave pour la
visualisation des signaux de la simulation. Voici la commande pour exécuter la simulation :

./start_simulation

Le logiciel gtkwave vous servira à inspecter le contenu de la mémoire, la valeur de chaque registres et
signaux et vous assurer d’avoir le résultat attendu, tel qu’illustré à la Figure 4. Prenez le temps d’inspecter
l’état (state) de l’unité de contrôle et de le relier aux valeurs de PC, IR et ACC.

Figure 3 Capture d'écran de GtkWave, affichage obtenu suite à l’exécution de la commande ./start_simulation.

INF1600 8/10 Hiver 2021


Polytechnique Montréal Département de Génie Informatique et Génie Logiciel

3.3 Travail à faire


Un programme, program_0, a déjà été écrit pour vous dans le fichier acc_proc_programs.vhd. Analysez
ce programme pour répondre aux questions suivantes.
Q1 : Donnez le contenu de la mémoire qui contient le program_0 sous format hexadécimale, de l’adresse
0x0000 à l’adresse 0x000F. Vous pouvez fournir un tableau pour aider la lisibilité de votre réponse.

Q2 : Quelle valeur contient l’accumulateur (ACC) à la fin de l’exécution du programme program_0 ?


Justifiez votre réponse par une capture d’écran de GtkWave et un calcul. À quelle adresse dans la mémoire
principale (mem) cette valeur est-elle stockée ?
Q3 : Le programme calcule une expression mathématique connue, qu’elle est-elle ?

Pour la question suivante, vous devez écrire un programme en modifiant les fichiers
acc_proc_programs.vhd et acc_proc_tb.vhd selon les instructions apparaissant dans ces fichiers :

Figure 4 Fichiers à modifier pour la question 4 .

Q4 : Modifiez le contenu de program_1 dans acc_proc_programs.vhd afin d’implémenter un programme


qui calcule les six (6) premières valeurs d’une suite numérique S(n), soit S(0) à S(5), et les stocke
séquentiellement en mémoire. Les deux premières valeurs S(0) = 1 et S(1) = 2 sont déjà présentes en
mémoire. On admettra que S(n+2) = 1 + S(n+1) + S(n). Attention, en ajoutant de nouvelles instructions,
la position en mémoire de ces données peut changer.

INF1600 9/10 Hiver 2021


Polytechnique Montréal Département de Génie Informatique et Génie Logiciel

4 Exercice 3 : Modes d’adressage et branchements


Pour cet exercice, le jeu d’instructions du microprocesseur de l’exercice 2 a été étendu et un registre MA
est ajouté. La tableau suivant donne une liste actualisée des instructions du nouveau processeur :
OPCODE Hexadécimal Description
add 0x0000 ACC  ACC + mem[adresse]
sub 0x0100 ACC  ACC - mem[adresse]
mul 0x0200 ACC  ACC * mem[adresse]
adda 0x0300 MA  MA + mem[adresse]
suba 0x0400 MA  MA - mem[adresse]
addx 0x0500 ACC  ACC + mem[MA]
subx 0x0600 ACC  ACC - mem[MA]
ld (load) 0x0700 ACC  mem[adresse]
st (store) 0x0800 mem[adresse]  ACC
lda (load) 0x0900 MA  mem[adresse]
sta (store) 0x0A00 mem[adresse]  MA
ldi (load) 0x0B00 ACC  mem[MA]
sti (store) 0x0C00 mem[MA]  ACC
br 0x0D00 PC  adresse
brz 0x0E00 if( ACC = 0) PC  adresse
brnz 0x0F00 if( ACC ≠ 0) PC  adresse
stop 0x1000 La boucle d’exécution arrête.
nop (no operation) 0x1100 Ne fait rien.

Les nouvelles instructions de branchement br, brz et brnz permettent de faire un saut dans le
programme vers une autre instruction. Ceci permet de créer des structures de contrôle (if/else) ou des
boucles (while).
Un programme, program_0, a déjà été écrit pour vous dans le fichier acc_proc_programs.vhd. Analysez
ce programme pour répondre aux sous questions ci-dessous.
Q1 : Donnez le contenu du registre ACC quand le processeur a terminé d’exécuter program_0. Expliquez
brièvement que fait le programme.
Q2 : Modifiez le contenu de program_1 dans acc_proc_programs.vhd afin d’implémenter un programme
qui calcule les six (6) premières valeurs d’une suite numérique S(n), soit S(0) à S(5), et les stocke
séquentiellement en mémoire. Les deux premières valeurs S(0) = 1 et S(1) = 2 sont déjà présentes en
mémoire. On admettra que S(n+2) = 1 + S(n+1) + S(n). Comparez le nombre d’instructions nécessaires
de ce programme par rapport au nombvre d’instructions obtenus à l’exercice 2.

INF1600 10/10 Hiver 2021

Vous aimerez peut-être aussi