TP2 : Mémoire

La mémoire contient à la fois le code du programme (appelé code machine ou code objet) et des données. Le processeur installé dans un ordinateur personnel (ou un serveur) contient aujourd'hui une MMU (Memory Management Unit) qui permet entre autres de séparer ces deux parties de la mémoire ; ce n'est pas le cas du processeur simplifié étudié dans cette UE : code et données peuvent être placés n'importe où en mémoire, comme dans certains processeurs embarqués (téléphones mobiles, etc.)

On utilise des étiquettes pour repérer l'emplacement des données en mémoire ; ces données peuvent être initialisées comme suit :

t: .long 5 .long 22

Dans cet exemple t désigne un tableau dont les deux premiers éléments sont les entiers 5 et 22, codés sur 32 bits. Ne pas confondre la directive .long avec une instruction exécutable par le processeur.

Pour transférer des données entre la mémoire et les registres, on utilise deux formes nouvelles de l'instruction movl :

irmovl t, %ebx mrmovl (%ebx), %eax # load rmmovl %ecx, (%ebx) # store

Décryptage : m = memory, r = register. Soit x l'entier qui se trouve à l'adresse t (dans cet exemple x = 5) ; la première instruction place cette adresse dans le registre ebx ; la seconde instruction (lecture) copie x dans le registre eax, et la troisième (écriture) remplace x par le contenu du registre ecx. Le registre ebx est donc utilisé ici comme pointeur ; pour lire ou écrire ailleurs en mémoire, il suffit de modifier la valeur du registre, sans oublier que les adresses de deux entiers consécutifs diffèrent de 4, car un entier occupe 4 octets (on dit que chaque octet est adressable).

Exercice 1

  1. Ecrire un programme qui lit un compteur n stocké en mémoire juste après le code, et écrit les n premiers nombres de la suite de Fibonacci dans la partie de la mémoire qui suit le compteur n. Sauver ce programme dans le fichier ex21.ys et le tester avec le simulateur. Veiller à ce que le programme soit correct, même pour n = 0.

    Attention : l'étiquette de n doit être précédée de la directive .align 4 pour que l'adresse correspondante soit un multiple de 4.

  2. Quel est le plus grand nombre de Fibonacci représentable sur 32 bits ? Modifier le programme pour que le calcul soit arrêté dès que ce nombre est atteint, lorsque n est trop grand.

Exercice 2

A la fin de l'exercice précédent on dispose d'un tableau d'entiers de taille variable, codé comme suit: le premier entier du tableau contient sa taille, et les éléments suivants constituent le tableau proprement dit. Dans cet exercice, tous les tableaux sont codés ainsi.

  1. Ecrire un programme qui fusionne deux tableaux u et v (de tailles respectives m et n) constitués d'entiers croissants. Le résultat sera un nouveau tableau ordonné de taille m + n .

    Pour tester ce programme on utilisera un tableau u constitué des 10 premiers nombres de Fibonacci (1 1 2 3 5 8 13 21 34 55) et un tableau v constitué des 7 premières puissances de 2 (1 2 4 8 16 32 64). Le résultat de la fusion doit être le tableau suivant, constitué de 17 nombres : 1 1 1 2 2 3 4 5 8 8 13 16 21 32 34 55 64.

    Conseil. Développer ce programme par étapes :

    Tester soigneusement chaque étape avec le simulateur avant de passer à l'étape suivante !

  2. On suppose qu'on veut ensuite, dans le même programme et pour une raison quelconque, augmenter la taille de l'un des deux tableaux u ou v : quel est le problème et comment le résoudre ?

    Attention : répondre à cette question (et à la suivante) dans le courrier électronique envoyé en fin de TP.

  3. On suppose qu'on veut au contraire, pour une raison quelconque, diminuer la taille de l'un des deux tableaux u ou v ; c'est facile, mais il reste un problème : lequel ?

Exercice 3

Soit un tableau de 32 entiers u0 , u1 , u2u31 et soit pi le bit qui indique la parité de ui . Ecrire un programme qui calcule dans un registre l'entier p dont les chiffres binaires sont les pi .

Conseil : chaque fois qu'on lit un nouvel élément ui , remplacer p par 2 * p ou 2 * p + 1 suivant la parité de ui .

Exercice 4

Modifier le programme de l'exercice 1 de la façon suivante : après exécution de la boucle qui calcule (et écrit dans la mémoire) les n premiers nombres de la suite de Fibonacci, le programme devra modifier son propre code et exécuter à nouveau la boucle pour calculer les n entiers suivants de la suite, et les écrire en mémoire de bas en haut (en écrasant donc les résultats précédents).

Attention : ne pas abîmer ex21.ys, commencer par le copier dans ex24.ys .