Département Informatique

L3 Mention Informatique
Jean-Michel Richer
Architecture des Ordinateurs
jean-michel.richer@univ-angers.fr 2015/2016

Travaux Dirigés

1 Représentation de l’information
En informatique, on doit pouvoir représenter des nombres entiers naturels ou relatifs ainsi que
des nombres à virgule. On distingue au moins 4 types de représentations :
– la représentation binaire naturelle utilisée pour représenter les entiers naturels,
– la représentation binaire signée
– la représentation binaire en complément à deux utilisée pour représenter les entiers relatifs
– la représentation en virgule flottante utilisée pour représenter les réels

1.1 Représentation binaire naturelle

En informatique les nombres sont codés en base :
– 2 (binaire),
– 8 (octal),
– 10 (décimal),
– 16 (héxadécimal)
Un nombre N exprimé en base B a pour valeur décimale :
i=k
X2
N= xi ∗ B i
i=k1

où les xi sont des coefficients prenant leurs valeurs dans l’intervalle 0, 1, . . . , B − 1.
Exercice 1 - Trouvez l’équivalent décimal des nombres suivants :
• 1010102 , 100112
• 2013 , 11113
• 4218 , 7328
• A016 , F F16

Exercice 2 - Convertir les nombres décimaux suivants

• 11 et 10 en base 2
• 26 et 210 en base 8
• 250 et 49 en base 16

Exercice 3 - Définir un procédé permettant de passer rapidement du binaire à l’hexadécimal.

Prendre par exemple le nombre suivant : 1011.1001.1101.0001
Exercice 4 - Réaliser la somme des nombres naturels suivants en base 2. Que remarquez-vous ?
• 0000.00102 + 0000.00112
• 0000.10102 + 0000.11112

Exercice 5 - Quels sont les plus grands entiers naturels que l’on peut représenter avec 8, 16 ou 32
bits ?

1.2 Représentation signée

En représentation binaire signée le bit de poids le plus fort (c’est à dire, le bit le plus à
gauche) indique le signe du nombre. On utilise 0 pour indiquer que le nombre est positif et 1 pour
un nombre négatif. Par exemple
0111.11112 représente 12710
1111.11112 représente −12710

Exercice 6 - Calculer la somme des nombres signés suivants. Que remarquez vous ?
• 0000.01112 + 0000.01012
• 0000.01112 + 1000.01012

1.3 Représentation en complément à deux

La représentation en complément à deux représente les nombres négatifs différemment (les
nombres positifs ne changent pas). Pour convertir un nombre négatif, on procède comme suit :
• représenter le nombre sous forme positive en binaire,
• complémenter chaque bit (0 est transformé en 1 et 1 en 0),
• ajouter 1 au résultat précédent.
Exercice 7 - Donner la représentation en complément à deux des nombres décimaux suivants :
−1, −2, −127, −128, −129. Combien de nombres peut-on représenter avec 8 bits en notation en
complément à deux ?

Exercice 8 - Calculer la somme des nombres en complément à deux suivants. Que remarquez
vous ?
• 0000.01112 + 0000.01012
• 0000.01112 + 1000.01012
• 0000.00112 + 1111.10112
• 0100.00002 + 0100.00012

Exercice 9 - Calculer le produit des nombres en complément à deux suivants. Que remarquez
vous ?
• 7×5
• 7 × −5
• 48 × −2
• 48 × −3

Exercice 10 -
– comment multiplier simplement un nombre binaire par 2, 4, 8 ou 2n ?
– comment diviser simplement un nombre binaire par 2, 4, 8 ou 2n ?
1.4 Représentation en virgule flottante

31 30 25 23 22 0
S Exposant décalé Mantisse tronquee

F IGURE 1 – Norme IEEE 754

Exercice 11 - Représentez 133, 87510 en norme IEEE 754. Pour ce faire procédez par étapes :
– transformez 133, 875 en base 2.
– normalisez le résultat en supprimant le premier chiffre 1
– ajoutez 127 à l’exposant
– codez le résultat final sur les 32 bits de la norme IEEE

Exercice 12 - Trouvez à quel nombre réel correspond la représentation IEEE 754 : 42 C8 40 0016

N 2N N 2N N 2N
0 1 8 256 16 65536
1 2 9 512 20 1.048.576
2 4 10 1024 31 2.147.483.648
3 8 11 2048 32 4.294.967.296
4 16 12 4096
5 32 13 8192
6 64 14 16384
7 128 15 32768

TABLE 1 – Puissances de 2

Unité Symbole Nombre d’octets

kilo octet ko 210
méga octet Mo 220
giga octet Go 230
téra octet To 240

TABLE 2 – Unités utilisées en Informatique

Exercice 13 - Dans la suite on supposera que :
– les entiers sont modélisés sur 4 octets
– les caractères sont modélisés sur 1 octet
– la procédure appelante libère les paramètres de la pile
– les résultats des fonctions sont retournés dans le registre EAX
1. traduire en assembleur x86 le code C suivant où i1 et i2 représentent des séries d’instruc-
tions quelconques (on supposera que les variables a et b sont des variables entières.
int a, b;

if (a <= b) {
i1;
} else {
i2;
}
2. traduire en assembleur x86 le code C suivant (on supposera que les variables i, n et sum
sont des variables entières.
sum=0;
for (i = 0; i < n; i++) {
sum = sum + i;
}
3. traduire en assembleur x86 le code C suivant :
sum=0;
while ((i > 10) && (i <= n)) {
sum = sum + i;
++i;
}
4. traduire en assembleur x86 le code C suivant :
sum=1;
while ((i % n) ==0) || (i == 3)) {
sum = sum * i;
++i;
}

Exercice 14 - Traduire la procédure suivante en assembleur x86.

void init( char t[], int n) {
int i;
for (i = 0; i < n; i++) {
t[i] = ’0’;
}
}

– donner une traduction assembleur de la procédure

– donner des versions optimisées en utilisant LOOP, puis STOSB
Exercice 15 - Traduire la procédure suivante en assembleur x86.
void init( int t[], int n) {
int i;
for (i = 0; i < n; i++) {
t[i] = 0;
}
}

– donner une traduction mot à mot de la procédure

– donner des versions optimisées en utilisant LOOP, puis STOSD

Exercice 16 - Traduire la fonction suivante en assembleur x86 :

int f( int X, int Y, int Z )
{
if (Z ==0) {
return ((X+Y)*(X-Y))/((X/Y)*3+(X+Y)*(X-Y));
} else {
return (X-Z+Y)*(X+Z+Y)*(1-Z*Z);
}
}

Exercice 17 - Comment multiplier efficacement sur un 8086, la valeur contenue dans le registre
AX par 10 sans utiliser l’instruction mul ? On rappelle que mul r16 utilise 118 à 133 cycles sur
un 8086.

Exercice 18 - Écrire le code assembleur x86 de la fonction de Fibonacci :

int fib( int n ) {
if (n <= 1) return n;
else return fib(n-1) + fib(n-2);
}

Exercice 19 - Écrire le code assembleur x86 de la fonction de Fibonacci optimisée :

int fib_iter( int a, int b, int count ) {
if (count == 0) return b;
else return fib_iter(a+b,a,count-1);
}

L’appel de la procédure se fait par : fib_iter(1,0,n) Implanter et tester ces 2 procédures

et notez les résultats comparatifs entre les 2 versions pour n = 40 à 60.

Exercice 20 - Ecrire un programme assembleur nasm pour processeur x86 et interfacé avec le
langage C qui récupère les arguments en ligne de commande du programme et les affiche en
utilisant la fonction printf du langage C.

Exercice 21 - Ecrire un programme en langage C qui étant donné un tableau de MAX entiers, réalise
l’initialisation du tableau par des valeurs aléatoires comprises entre 0 et 20, puis affiche à l’écran
la somme des valeurs par appel à une fonction assembleur :

int sum(int nbr,int tab[])

 La fonction sum prend en paramètres le nombre de valeurs du tableau et l’adresse du tableau.

Exercice 22 - On désire écrire en assembleur la fonction suivante sans utiliser d’instruction de

branchement :
int mini(int p, int q) {
return (p < q) ? p : q;
}

pour cela, on va utiliser une variable temporaire r telle que :


0, si p > q
r = (p − q) >> 31 =
1, si p < q

on soustrait q à p et on garde le bit le plus significatif que l’on propage (bit 31 = bit de signe, utiliser
l’instruction sar r32,imm8). A partir de ce moment, il suffit de calculer : (p ∧ r) ∨ (q ∧ ¬r)).

Exercice 23 - Réaliser le dépliage de boucle par 4 (loop unrolling) sur le code C suivant :
void f(int *v, int *w, int k, int n) {
for (int i=0; i<n; ++i) {
v[i] += w[i] * k;
}
}

Traduire en assembleur, puis donner une version en utilisant les instructions SSE suivantes
dont on aura pris soin de consulter la documentation afin de comprendre leur comportement :
– movd
– pshufd
– pmulld
– paddd
– movdqu
– movdqa

Exercice 24 - Traduire en assembleur x86 version 64 bits le code C suivant qui correspond au
produit de deux matrices carrées de dimension N (constante) :
void prod(int a[N][N], int b[N][N], int c[N][N]) {
int i,j,k;
for (i=0;i<N;i++) {
for (j=0;j<N;j++) {
int sum=0;
for (k=0;k<N;k++) sum+=a[i][k]*b[k][j];
c[i][j]=sum;
}
}
}
Exercice 25 - Donner le code assembleur du calcul suivant :
√ 1
X + Y + Y 2 + tan( X−Y )
(X + Y ) × sin(X − Y )

Exercice 26 - Ecrire une version SSE du calcul de la suite de Fibonacci.

Exercice 27 - Coder la fonction suivante en assembleur classique puis donner une version qui
utilise les registres SSE.
int chr_replace(char *src, char *dst, int n, char c, char d) {
int changes=0;
for (int i=0; i < n; ++i) {
if (src[i] == c) {
dst[i] = d;
++changes;
} else {
dst[i] = src[i];
}
}
return changes;
}
Exercice 28 - Démontrez à l’aide de tables de vérité, les équivalences suivantes :
(a) XY Z = X̄ + Ȳ + Z̄
(b) X + Y Z = (X + Y )(X + Z)
(c) X + X̄Y = X + Y

Exercice 29 - Démontrez algébriquement les égalités suivantes :

(a) Ȳ Z + Y Z̄ + Y Z + Ȳ Z̄ = 1
(b) AB + AB̄ + ĀB̄ = A + B̄
(c) Ā + AB + AC̄ + AB̄ C̄ = Ā + B + C̄
(d) AB̄ + ĀC̄ D̄ + ĀB̄D + ĀB̄C D̄ = ĀC̄ D̄ + B̄
(e) XY + X̄Z + Y Z = XY + X̄Z
(f) X + X̄Y = X + Y

Exercice 30 - Simplifiez les expressions suivantes :

(a) ABC + AB C̄ + ĀB
(b) (A + B)(Ā + B̄)
(c) (A + B̄ + AB̄)(AB + ĀC + BC)
(d) X + Y (Z + X + Z)
(e) W̄ X(Z̄ + Ȳ Z) + X(W + W̄ Y Z)

Exercice 31 - Soient deux fonctions booléennes E et F de trois variables dont les tables de vérité
sont données. Exprimez E et F en fonction de X, Y, Z et simplifiez ces expressions.

X Y Z E(X, Y, Z) F (X, Y, Z)
0 0 0 1 0
0 0 1 1 0
0 1 0 1 1
0 1 1 0 0
1 0 0 1 0
1 0 1 0 0
1 1 0 0 1
1 1 1 0 1

Exercice 32 - Simplifiez les fonctions suivantes à l’aide d’un tableau de Karnaugh

(a) F (X, Y, Z) = (1, 3, 6, 7)
(b) G(X, Y, Z) = (0, 3, 4, 5, 7)
(c) H(A, B, C, D) = (1, 5, 9, 12, 13, 15)

Exercice 33 - Implantez les circuits suivants avec des portes NAND. Peut-on les simplifier et
pourquoi ?
(a) W X̄ + W XZ + W̄ Ȳ Z̄ + W̄ X Ȳ + W X Z̄
(b) XZ + XY Z̄ + W X̄ Ȳ

Exercice 34 - Imaginer un moyen d’échanger deux variables A et B sans utiliser une troisième
variable ou un registre intermédiaire (pensez à l’instruction XOR).

Exercice 35 - Soit une machine dotée d’un bus d’adresses de 10 bits et d’un bus de données de 8
bits. Cette machine dispose également d’une mémoire cache à accès direct de 8 entrées.
 1. quelle taille mémoire le processeur peut-il adresser ?
2. quelle est la taille du cache ?
3. on accède successivement aux adresses suivantes :
Adresse Donnée Adresse Donnée
0000000000 D1 0000111000 D7
0000010100 D2 0100110010 D8
0000110110 D3 0100111000 D9
0001110000 D4 1100110111 D10
0000001100 D5 0010110011 D11
0000100100 D6 1100110010 D12
Déterminer l’état du cache.

Exercice 36 - On considère le problème de remplacement d’une entrée de la mémoire cache pour

un cache fully associative. On utlise l’algorithme LRU (Least Recently Used) qui consiste à rem-
placer la ligne utilisée la moins récemment. Sa mise en oeuvre utilise une file qui contient en tête
le numéro de l’entrée du cache correspondant à l’élément le plus récemment utilisé. La ligne qui
devra être remplacée est la ligne en queue de file. Si on accède à une donnée présente dans le
cache, le numéro de l’entrée correspondante est déplacée en tête de file.
Soit le cache suivant (on fait abstraction des valeurs des adresses) :
Entrée Donnée
0 a
1 b
2 c
3 d

Simuler le fonctionnement de cet algorithme pour les accès successifs à des valeurs dans les
deux cas suivants :
– Cas 1 : a,b,c,d,e,b,c,a,f,a,b,c
– Cas 2 : a,b,c,d,e,a,b,c,d,f,a,b,c,d
Que remarquez-vous ?