Architecture Matérielle et Logicielle (LIF6)

Université Lyon 1, FST, Département Informatique, L2
Corrections d’exercices LIF6 – Printemps 2015
Architecture Matérielle et Logicielle (LIF6)
Exercice 1 : Mémoire, transferts et petits calculs
Justifiez vos réponses en détaillant vos calculs.
Partie 1 : Circuits mémoires
Sur la carte mère d’un certain ordinateur, on trouve :
— un processeur 8 bits, ce qui implique que la mémoire est adressée octet par octet, et que le processeur
peut lire et écrire des mots de 8 bits en mémoire centrale ;
— un bus système, dont le bus d’adresses est d’une largeur de 24 bits ;
— un certain nombre de circuits mémoire 8 bits, chacun d’une capacité de 512 Kio.
1) Quelle est la largeur, en nombre de bits, du bus de données ?
S OLUTION . Il s’agit d’un processeur 8 bits, dont la mémoire est adressée octet par octet : la largeur
du bus de données est de 8 bits.
2) En supposant que le bus d’adresses ne sert à adresser que la mémoire centrale de l’ordinateur, combien
de circuits mémoire sont présents sur la carte mère ?
S OLUTION . Le bus d’adresse est d’une largeur de 24 bits, la mémoire comporte donc au plus 224
adresses, ce qui donne 224 octets en mémoire. En supposant que la mémoire contient effectivement
224 octets, on divise cette taille par la taille d’un circuit mémoire pour obtenir le nombre de circuits
mémoire : (224 o)/(29 ·210 o) = 25 = 32 circuits mémoire.
Partie 2 : Bande passante
On souhaite lire un film se trouvant sur un disque dur, connecter à l’ordinateur via un bus USB 1.1. Le film est
non-compressé, et constitué d’une succession d’images de 1024 × 768 pixels en 256 couleurs. On suppose que
le défilement des images se fait en 24 images par seconde. Une liaison USB 1.1 permet le transfert de données
bit par bit à la fréquence de 12 MHz.
1) Quelle est la taille en octets d’une image du film ? (768 = 3×256)
S OLUTION . Pour coder 256 couleurs, il faut 8 bits par pixel. L’image comporte 210 × 3 × 28 = 3 × 218
pixels, d’où 3 × 218 o par image.
2) Quel est le débit (en Mio/s) requis pour le transfert du film du disque dur à la mémoire vidéo ?
S OLUTION . Comme il faut transférer 24 images par seconde, le débit est de 3×218 ×24 o/s = 3×218 ×
3 × 23 o/s = 9 × 221 o/s = 18 Mio/s.
3) Quelle est la bande passante en Mo/s du bus USB 1.1 envisagé pour la lecture du film ?
S OLUTION . 1 bit × 12·106 /s = 12/8 × 106 octet/s = 1, 5 Mo/s
4) La lecture du film sera-t-elle possible ? Expliquez clairement votre réponse.
S OLUTION . On a 1 Mo < 1 Mio, donc 1.5 Mo/s < 2 Mo/s < 2 Mio/s < 18 Mio/s.
Nicolas Louvet et Laure Gonnord
1/5
Université Lyon 1, FST, Département Informatique, L2
Corrections d’exercices LIF6 – Printemps 2015
Exercice 2 : Instructions de branchement et boucles
Un processeur 8 bits est doté d’un espace mémoire de 64 Kio ; à chaque adresse en mémoire centrale correspond une case de 1 octet. Le processeur dispose de 4 registres de travail, indicés de 0 à 4 et notés R0. . . R3, ainsi
que d’un program status register (le PSR), qui comporte un drapeau nommé z : ce drapeau est à 1 si la dernière
valeur écrite dans l’un des registres était nulle, 0 sinon. Les instructions sont codées sur 1 ou 2 octets, comme
indiqué dans le tableau ci-dessous :
assembleur
action
7
6
premier octet
5 4 3 2
LD RD,adr
ST RS,adr
ADD RD,RS
SUB RD,RS
BR dec5
BRZ dec5
RD <- Mémoire[adr]
Mémoire[adr] <- RS
RD <- RD + RS
RD <- RD - RS
PC <- adins + 1 + dec5
Si z = 1 alors PC <- adins + 1 + dec5
0
0
0
0
1
1
0
0
1
1
0
0
0
1
0
1
0
1
RD
SR
RD
RD
0
0
RS
RS
dec5
dec5
1
0
0
0
0
0
0
0
second octet
7. . . 0
adr
adr
—
—
—
—
Dans ce tableau :
— RD désigne un registre de destination et RS un registre source (R0. . . R3) ;
— PC désigne le compteur de programme (adresse de la prochaine instruction) ;
— adr et adins désignent des adresses en mémoire, codées sur 1 octet ;
— Mémoire[adr] désigne la case mémoire d’adresse adr.
Principe des instructions de branchement BR et BRZ : ces instructions permettent de faire des sauts dans le
programme, en modifiant la valeur de PC. On note adins l’adresse de l’instruction de branchement dans le
programme, et dec5 est un entier (décalage) codé en complément à 2 sur 5 bits par rapport à cette adresse :
— Dans le cas de BR dec5, lorsque l’instruction est exécutée, alors l’instruction qui sera exécutée ensuite est
celle à l’adresse adins + 1 + dec5 (branchement inconditionnel).
— Dans le cas de BRZ dec5 : si z = 1 lorsque l’instruction est exécutée, alors la prochaine instruction exécutée est celle à l’adresse adins + 1 + dec5 (branchement pris), sinon la prochaine instruction sera celle
à l’adresse adins + 1 (branchement non-pris).
Un programmeur qui écrit en langage d’assemblage n’a pas besoin de calculer lui même les adresses de son
programme : il utilise simplement une étiquette pour désigner l’adresse d’une instruction ou d’une donnée,
comme dans le programme ci-dessous. Dans le cas des instructions de branchement, l’assembleur calculera
lui-même les valeurs de décalage (dec5).
one:
n:
r:
1
// case mémoire contenant l'entier 1
15
// case mémoire contenant l'entier 15
0
// case mémoire contenant l'entier 0
LD R0,r
// ...........................................
LD R1,one
// ...........................................
LD R2,n
// ...........................................
loop:
BRZ endloop // ...........................................
ADD R0,R2
// ...........................................
SUB R2,R1
// ...........................................
BR loop
// ...........................................
endloop: ST R0,r
// ...........................................
1) Si un programme comporte une instruction BR dec5 à l’adresse adins, dans quel intervalle pourra se
trouver l’adresse adsuiv de la prochaine instruction à être exécutée ? Justifiez votre réponse.
S OLUTION . Comme indiqué dans l’énoncé, dec5 est un entier codé en complément à 2 sur 5 bits,
donc
(10000)2 ≤ dec5 ≤ (01111)2 .
| {z }
| {z }
=(−16)10
=(15)10
L’adresse de la prochaine instruction à être exécutée est donnée par adsuiv = adins + 1 + dec5. On
a donc adins − (15)10 ≤ adsuiv ≤ adins + (16)10 .
2) Les instructions LD et ST décrites dans l’énoncé ne permettent pas d’accéder à tout l’espace mémoire dont
dispose le processeur : pourquoi ?
Nicolas Louvet et Laure Gonnord
2/5
Université Lyon 1, FST, Département Informatique, L2
Corrections d’exercices LIF6 – Printemps 2015
S OLUTION . Dans le codage des instructions LD et ST, seul 1 octet est consacré au codage de l’adresse
de chargement ou de rangement : cela ne permet coder que 28 = 256 adresses. . . On est donc loin des
64 kio = 216 o adressables par le processeur.
3) Ajouter des commentaires succincts au programme ci-dessus, en indiquant l’action algorithmique effectuée par chaque instruction. Expliquez ensuite ce que calcule ce programme.
S OLUTION . Il n’est pas très difficile d’identifier le fait que le programme comporte une boucle, entre
l’instruction à l’adresse désignée par loop et l’instruction BR loop. L’instruction de branchement
conditionnel BRZ endloop provoque la sortie de boucle lorsque la dernière valeur écrite dans l’un
des registres généraux est nulle, i.e., lorsque R2 = 0.
one:
n:
r:
1
15
0
LD R0,r
LD R1,one
LD R2,n
loop:
BRZ endloop
ADD R0,R2
SUB R2,R1
BR loop
endloop: ST R0,r
//
//
//
//
//
//
//
//
//
//
//
case mémoire contenant l'entier
case mémoire contenant l'entier
case mémoire contenant l'entier
R0 <- mem[r] = 0 (contenu de la
R1 <- mem[one] = 1
R2 <- mem[n] = 15
si R2 est nul, sortie de boucle
R0 <- R0 + R2
R2 <- R2 + R1
retour au début de boucle
mem[r] <- R0
1
15
0
case mémoire désignée par l'étiquette r)
En langage pseudo-algorithmique, le programme précédant peut être traduit de la façon suivante :
R0 <- 0;
R1 <- 1;
R2 <- 15;
while(R2 != 0) {
R0 <- R0 + R2;
R2 <- R2 - 1;
}
r <- R0;
Le programme calcule donc la somme des entiers naturels compris entre 1 et 15, et place le résultat
dans le case mémoire désignée par l’étiquette r.
4) On suppose que l’étiquette one sera rangée en mémoire à l’adresse (001A)H . Complétez le tableau cidessous, en indiquant pour chaque donnée son adresse, et pour chaque instruction l’adresse de son premier octet.
adresse
(001A)H
instruction
one:
n:
r:
begin:
loop:
endloop:
1
15
0
LD R0,r
LD R1,one
LD R2,n
BRZ endloop
ADD R0,R2
SUB R2,R1
BR loop
ST R0,r
S OLUTION . Il n’y a rien de très compliqué, il faut juste faire attention au fait que les instructions d’accès à la mémoire occupent deux cases mémoires consécutives, alors que les autres instructions n’en
occupent qu’une seule. Les constantes entières n’occupent elles aussi qu’une seule case mémoire.
Nicolas Louvet et Laure Gonnord
3/5
Université Lyon 1, FST, Département Informatique, L2
adresse
(001A)H
(001B )H
(001C )H
(001D)H
(001F )H
(0021)H
(0023)H
(0024)H
(0025)H
(0026)H
(0027)H
Corrections d’exercices LIF6 – Printemps 2015
instruction
one:
n:
r:
begin:
loop:
endloop:
1
15
0
LD R0,r
LD R1,one
LD R2,n
BRZ endloop
ADD R0,R2
SUB R2,R1
BR loop
ST R0,r
5) Calculez la valeur de décalage dec5 pour l’instruction BRZ endloop, puis pour l’instruction BR loop :
détaillez bien vos calculs. Donnez votre résultat en décimal puis en binaire.
S OLUTION . Dans le cas de l’instruction BRZ endloop, on sait d’après la question précédente que
l’adresse de cette instruction est (0023)H , et que la destination du branchement s’il est pris est l’instruction ST R0,r, qui se trouve rangée à l’adresse (0027)H . D’après l’énoncé, l’adresse de destination
est addest = adins + 1 + dec5, donc dec5 = addest − adins − 1 = (0027)H − (0023)H − 1 = (3)10 . Notez que cela pouvez se lire directement dans le tableau de la questions précédente : en partant de la
case mémoire suivant celle de l’instruction BRZ endloop, combien de cases mémoire doit-on sauter
pour arriver à l’instruction ST R0,r ? Justement, 3.
Dans le cas de l’instruction BR loop, on doit s’attendre à un résultat négatif, puisqu’il faut « remonter » dans le programme. On a dec5 = (0023)H − (0026)H − 1 = −(4)10 . Pour la suite, il est utile de
calculer la représentation de −(4)10 en complément à 2 sur 5 bits ; on trouve −(4)10 = (11100)2 .
6) Donnez le codage en binaire du programme (rayez les octets inutiles) :
instruction
7
one:
n:
r:
begin:
loop:
endloop:
6
premier octet
5 4 3 2
1
0
7
6
second octet
5 4 3 2
1
0
1
15
0
LD R0,r
LD R1,one
LD R2,n
BRZ endloop
ADD R0,R2
SUB R2,R1
BR loop
ST R0,r
S OLUTION . A défaut de rayer les octets inutiles, dans cette correction les cases correspondantes seront laissées vides. . . Le tableau est complété simplement en utilisant le codage proposé dans l’énoncé.
Nicolas Louvet et Laure Gonnord
4/5
Université Lyon 1, FST, Département Informatique, L2
instruction
one:
n:
r:
begin:
loop:
endloop:
1
15
0
LD R0,r
LD R1,one
LD R2,n
BRZ endloop
ADD R0,R2
SUB R2,R1
BR loop
ST R0,r
7
0
0
0
0
0
0
1
0
0
1
0
6
0
0
0
0
0
0
0
1
1
0
0
Corrections d’exercices LIF6 – Printemps 2015
premier octet
5 4 3 2
0 0 0 0
0 0 1 1
0 0 0 0
0 0 0 0
0 0 1 0
0 1 0 0
1 0 0 0
0 0 0 1
1 1 0 0
0 1 1 1
1 0 0 0
1
0
1
0
0
0
0
1
0
1
0
0
0
1
1
0
0
0
0
1
0
0
0
0
7
6
second octet
5 4 3 2
1
0
0
0
0
0
0
0
0
0
0
1
1
1
1
1
1
1
0
0
0
1
1
0
0
1
0
0
0
1
1
1
0
0
7) Donnez le codage en mémoire du programme, en donnant le contenu des cases de la mémoire en hexadécimal :
adresse
contenu
(001A)H
S OLUTION .
Nicolas Louvet et Laure Gonnord
adresse
contenu
(001A)H
(001B )H
(001C )H
(001D)H
(001E )H
(001F )H
(0020)H
(0021)H
(0022)H
(0023)H
(0024)H
(0025)H
(0026)H
(0027)H
(0028)H
(01)H
(0F )H
(00)H
(00)H
(1C )H
(08)H
(1A)H
(10)H
(1B )H
(A3)H
(44)H
(72)H
(9C )H
(20)H
(1C )H
5/5