Introduction Les performances d une machine sont liées au: 1. nombre d instructions 2. temps de cycle horloge 3. nombre de cycle horloge par instructions. C est: le compilateur et l architecture du jeu d instructions qui déterminent le nombre d instructions pour un programme donnée (point 1) la mise en oeuvre du processeur qui déterminent le temps de cycle horloge et le nombre de cycle horloge par instructions (points 2 et 3). 1
Objectifs de ce cours: Présentation d un processeur basé sur une architecture RISC (Reduced Instruction Set Computer): MIPS (Berkeley) (partie 1) Description d un sous ensemble du jeu d instructions (inst. reference mémoire, arithmétiques et logiques et de branchement) et de leurs mises en oeuvre (partie 2). 2
Architecture du jeu d instructions (partie 1) L ordinateur execute du binaire qui décrit le langage de la machine. Le langage assembleur est la représentation symbolique du langage machine: lecture plus facile car manipulation de symbole et pas de bits nommer les configurations de bits fréquement utilisées tels que les codes-op et les spécificateurs de registres utilisation d étiquettes afin d identifier et de nommer des mots mémoire particuliers qui détiennent des instructions ou des données La traduction du langage assembleur en langage machine est effectué par un assembleur 3
Le langage machine: #include <stdio.h> void main (int argc, char *argv[]) { int i; int somme =0; for (i=0;i<=100;i=i+1) somme=somme+i*i; printf("la somme de 0..1000 vaut ^d\n",somme); } La procédure écrite dans le langage de programmation C. main: boucle:.text.align 2.globl main subu $29, $sp,32 sw $31, 20($29) sd $4, 32($29) sw $0, 24($29) sw $0, 28($29) lw $14, 28($29) mul $15, $14, $14 lw $24, 24($29) addu $25, $24, $15 sw $25, 24($29) addu $8, $14, 1 sw $8, 28($29) ble $8, 100, boucle la $4, str lw $5, 24($29) jal printf move $2, $0 lw $31, 20($29) addu $29, $29, 32 jr $31 str:.data.align 0..asciiz "La somme de 0.. 100 vaut %d\n" Le code en langage machine MIPS pour le programme C ci dessus. La meme procédure écrite en langage assembleur avec des étiquettes. Les commandes qui commencent par des points sont des directives d assemblage. Par exemple.text indique que les lignes qui contiennent des instructions et.data des données..align n indique que les éléments des lignes qui suivent doivent etre alignés sur une frontière 2 puissance n octets..global main déclare que <<main>> est un symbole global qui doit etre visible pour du code stocké dans d autres fichiers..ascciz enrigistre en mémoire une chaine de caractères à terminaison nulle. 4
Une hiérarchie de traduction Programme C Compilateur Programme en langage assembleur Assembleur Programme en langage machine chargeur Mémoire Une hierarchie de traduction: un prog écrit en langage de haut niveau est d abord compilé en programme écrit en langage assembleu puis assemblé en un programme écrit en langage machine. Le chargeur place ensuite le code machine en mémoire dans des emplacements mémoires appropriés afin qu il soit exécuté par le processeur. 5
Le processus de production d un fichier exécutable Fichier source Assembleur Fichier objet Fichier source Assembleur Fichier objet Editeur de liens Fichier exécutable Fichier source Assembleur Fichier objet Bibliothèque de programmes Un assembleur traduit un fichier écrit en langage assembleur en un fichier objet. Celui ci est assemblé avec d autres fichiers et la bibliothèques en un fichier exécutable. programme en langage de haut niveau Programme Compilateur Assembleur Editeur de liens Oridnateur programme en langage assembleur Le langage assembleur est soit écrit par un programmeur soit géré par le compilateur 6
Fichier objet: associe des adresses aux etiquettes externes appartenant au fichier source et enumere les refs non resolues entete du fichier objet segment texte segment donnees infos de relocalisation table des symboles infos de mise au point taille et position des zones suivantes identification de toutes les instructions contenant des adressages absolues description de la facon dont le prog a ete compile -> debugger 7
Chargeur: lecture de l entête du fichier executable pour définir la taille des segments de textes et données création d un nouvel espace d adressage pour le programme copie des instructions et données depuis la memoire secondaire copie sur la pile des arguments passés au programme initialisation des registres machine saut vers la procedure de démarrage (main en C) et copie des arguments du prog depuis la pile dans les registres 8
Editeurs de liens: 3 tâches fouiller dans les biliothéques de programmes pour trouver les procédures qui y sont référencées insertion dans le programme utilisateur détermine les emplacements mémoire qu occupera le code de chaque module et relocalise les instructions de ce code en ajustant les références absolues résout les références entre fichiers: mise en correspondances des symboles externes et des références non résolues création d un exécutable dans la structure est équivalente à un fichier objet sauf que toutes les reférences sont résolues et adressages sont relocalisés 9
Utilisation de la mémoire: segment de pile donnees dynamiques donnees statiques segement de donnees segment de texte 10
Instructions arithmétiques: ADD et SUB Exemple add a,b,c? additionner deux variables b et c et placer la somme dans a Rmq: dans l architecture MIPS les instructions arithmétiques ont toujours le même nombre d opérandes Principe RISC: la simplicité favorise la régularité. 11
Exple: Soit les 2 programmes C suivants: a=b+c; d=a-e; et f=(g+h)-(i+j); add a,b,c sub d,a,e add t0,g,h add t1,i,j sub f,t0,t1 Opérandes des instructions ne peuvent pas être des variables comme dans un langage de haut niveau proviennent d un emplacement limité: les registres (dans le cas d une archi RISC). 12
MIPS: 32 registres $0 à $31. Trop de registres augmenterait le temps de cycle horloge: le plus petit le plus rapide. Pour le deuxième programme C add $8,$17,$18? (f,g,h,i rangées dans $16 à $20) add $9,$19,$20 sub $16,$8,$9?$8 et $9 variables intermédiaires 13
les programmes possèdent plus de variables ou des structures complexes (par exple tableaux) que la machine posséde de registres compilateur conserve dans les registres les données les plus fréquements utilisées et le reste en mémoire instructions de chargement et de rangement en mémoire. On appelle vidage des registres l opération qui consiste à placer en mémoire les données les moins couramment utilisées. 14
Instructions de chargement-rangement: lw et sw Exemple: T tableau de 100 éléments. g, h et i sont situés dans les registres $17, $18,$19 et le tableau débute à l adresse Tstart. Traduire les deux expressions suivantes: g = h + T [i]; et T [i] = h + T [i] lw $8, Tstart($19) lw $8,Tstart($19) add $17,$18,$8 add $8,$18,$8 sw $8,Tstart($19) Remarque: ajout de l adresse de Tstart à l index i contenu dans $19 ce registre fait office de registre d index 15
Instruction de branchement: beq registre1, registre2, E, branch if equal (saut conditionnel) bne registre1, registre2, E, branch if not equal (saut conditionnel) j jump (saut inconditionnel) Utilisation dans le cadre des structures de contrôle: Exple 1: if (i==j) f=g+h; else f=g-h;? f,g,h,i,j $16 à $20 bne $19, $20, Else add $16,$17,$18 j exit Else: sub $16,$17,$18 Exit: 16
Exple 2: while (stock[i]==k) i=i+j;? tableau débute à Sstart et i,j,k $19 à $21 loop: EXIT: lw $8, Sstart($19) bne $8, $21, EXIT add $19,$19,$20 j loop Instruction slt (set on less than): slt registre1, registre2, registre3 [reg1] = 1 si [reg2] < [reg3] traitement des conditionnelles avec test d inégalité: pseudo-instruction blt (branch on less than) blt -> slt $1, $16, $17 bne $1, $0, Inf 17
Instruction jr (jump register) saut incoditionnel vers une adresse specifié dans un registre traitement des instructions d aiguillage. Exple (f à k de $16 à $21): switch(k) { Loop: lw $8, Tablesaut($21) case 0: f = i+j; break; jr $8 case 1: f=g+h; break; E0: add $16,$19,$20 case 2: f=g-h;break; j EXIT case 3: f=i-j; E1: add $16,$17,$18 } j EXIT E2: sub $16,$17,$18 j EXIT E3: sub $16,$19,$20 EXIT: 18
Traitement de procédure au niveau matériel: jal (jump and link) et jr: jal: conserve dans un registre ($31) l adresse de l instruction suivante. jr: branchement à l adresse de retour. Remarque 1: Nécessité d avoir un registre qui pointe sur l instruction courante: CP (compteur programme) Remarque 2: Une procédure pouvant en appeler une autre et anisi de suite la pile (LIFO) structure idéale pour vider les registres. 19
Soit une procédure A qui appelle une procédure B qui elle-même appelle une procédure C. $29: pointeur de pile et $24 valeur servant à ajuster le sommet: A:... jal B... B:... add $29,$29,$24 sw $31, 0($29) jal C lw $31, 0($29) sub $29,$29,$24... jr $31 C:... jr $31 Les paramétres d une procédure sont sauvegardés dans des registres ($4 à $7 pour MIPS). Les autres paramétres sont sauvegardés dans la pile. 20
$31 Après que B ait appelé C $31 $31 $31 juste avant que B n appelle C Après que A ait appelé B $29(pointeur de pile) Juste avant que B ne retourne $29 $29 $29 Mémoire sommet de pile bas de pile Bas de pile adresse retour de B adresse de retour de B adresse retour B sommet de pile bas de pile nouveau sommet de pile bas de pile Nouveau sommet de pile adresse retour B adresse retour B adresse de retour de C adresse retour B 21
Représentation des instructions au niveau du processeur Les instructions représentées en binaire définir des formats de traduction entre le langage assembleur et le langage machine Exple: add $8, $17, $18 ---------------- 0 17 18 8 0 32 ---------------- 6 5 5 5 5 6 = 32bits Toutes les instructions ont la même taille mais suivent des formats différents. 22
Par exemple les instructions arithmétiques: op rs rt rd decval f onct op: opération correspond à l instruction rs: 1er registre source rt: 2eme registre source rd: registre destination decval: valeur du décalage (décalage logique) fonct: fonction détermine la variante de l opération décrite dans op 23
Les instructions de chargement-rangement nécessite des champs plus long pour adresser des données en mémoire format d instruction différents mais même taille d instructions (32 bits): op rs rt adresse Rmq: Les formats sont repérées à partir du contenu du premier champ ie le code-op. 24
A partir du codage des instructions MIPS suivantes: Instruction Format op rs rt rd decval fonct adresse add R 0 reg reg reg 0 32 n.a sub R 0 reg reg reg 0 34 n.a. lw I 35 reg reg n.a. n.a. n.a. adresse sw I 43 reg reg n.a. n.a. n.a. adresse Quel est le code du langage machine de T [i] = h + T [i] compilée en: lw $8, Tstart($19)? On suppose que T débute add $8, $18, $8? à l adresse 1200 sw $8,Tstart($19) 25
Table des codes op 26
Mode d adressage: Adressage par registre op rs rt rd... fonct registre Exemple: add $8, $7, $6 Adressage indexé op rs rt adresse registre Exemple: lw $8, Tstart($19) + mémoire Adressage immédiat op rs rt immédiat Adressage relatif à CP op rs rt adresse cp + 27
1) immédiat: un programme utilise de nombreuses fois les constantes. Charger les constantes depuis la mémoire prendrait trop de temps: il faut faire en sorte que les cas les plus fréquents soient les plus rapides instructions ayant un opérande constant. Exple: addi $29,$29,4 code machine 8 29 29 4 Pour les constantes de tailles supérieures à 16 bits: instruction lui (load upper immediate). Exple quel est le code assembleur MIPS pour charger la constante 32 bits dans le registre $16 : 00000000001111010000100100000000 lui $16, 61? correspond à la valeur décimales des 16bits de poids fort addi $16, $16, 2304? valeur des 16 bits de poids faible 28
2) branchements relatifs à CP: La description du code machine pour un branchement conditionnel laisse uniquement 16 bits pour l adresse de branchement. Exple: bne$8, $21, Exit: ---------------- 5 8 21 Exit ---------------- 6 5 5 16 = 32bits programme ne pourrait être plus long que 2 16 instructions ce qui trop petit de nos jours solution: se brancher à une distance Exit de CP (2 16 ) au plus. MIPS utilise l adressage relatifs pour les branchements conditionnels (description des boucles et des instructions if) et l adressage long (format j) pour les appels de procédures car celles-ci peuvent se trouver n importe où en mémoire 29
Conclusion 1er partie: Les ordinateurs actuels repose sur 2 grands principes: les instructions sont désignées par des nombres les programmes peuvent être lus ou modifiées exactement comme des nombres principe des programmes enregistrés. 30
Un jeu d instructions d une architecture RISC repose, entre autres, sur les principes suivants: le plus petit le plus rapide (MIPS n a que 32 registres) la simplicité favorise la régularité: taille unique à toutes les intructions, toujours trois opérandes dans trois registres dans les instructions arithmétiques, opérandes toujours dans les registres (architecture chargement-rangement), adressage simple, beaucoup de registres généraux et les champs correspondant aux registres sont à la même place dans chaque format d instruction faire en sorte que les cas les plus fréquents soient les plus rapides: adressage immédiat pour les constantes et l adressage relatifs pour les branchements conditionnels. 31