Couche d’architecture du jeu

d’instructions
Instruction Set Architecture - ISA
M41
2023-2024
ENSA Marrakech

1
Rappel: organisation d’un ordinateur

Trois composantes principales d'un ordinateur: processeur, mémoire et

entrées/sorties (ou I/Os)

 datapath +
control =
processor
(CPU)

2
Comment les ordinateurs fonctionnent?
 Chaque couche fait abstraction de tout ce qui est en dessous.

 À noter comment l’abstraction cache le détail des plus bas niveaux

3
Architecture de jeu d’instruction - ISA
 ISA spécifie
• L'organisation de la mémoire
 Espace d'adressage
 Adressabilité
• L'ensemble des registres
• Le jeu d'instructions
 Opcodes
 Types de données
 Longueur et format des instructions

4
ISA de MIPS
• Catégorie d’instructions
– Load/Store
– Computational
– Jump and Branch
– Floating Point (co-processeur)
R0 - R31

PC
HI
LO
3 Instruction Formats, 32 bits wide
R OP rs rt rd sa funct

I OP rs rt immediate
J OP jump target
5
Niveaux de représentation

temp = v[k];
High Level Language
Program v[k] = v[k+1];
v[k+1] = temp;
Compiler
lw $15, 0($2)
Assembly Language lw $16, 4($2)
Program sw $16, 0($2)
sw $15, 4($2)

Assembler

0000 1001 1100 0110 1010 1111 0101 1000

Machine Language
1010 1111 0101 1000 0000 1001 1100 0110
Program 1100 0110 1010 1111 0101 1000 0000 1001
0101 1000 0000 1001 1100 0110 1010 1111
Machine Interpretation

Control Signal
Specification
°
°
6
Cycles d’exécution
Instruction
Fetch
Obtenir l’instruction de la mémoire du programme

Instruction
Décoder l’instruction et déterminer les actions requises
Decode

Operand Localiser et obtenir les données des opérandes

Fetch

Execute Calculer le résultat ou l’état

Result
Stocker le résultat pour une utilisation ultérieure
Store

Next
Instruction
Déterminer l'instruction suivante

7
Les instructions arithmétiques MIPS

 Instructions arithmétiques en MIPS

add $t0, $s1, $s2

sub $t0, $s1, $s2

 Chaque instruction arithmétique performe une opération

 Chacune spécifie 3 opérandes qui sont dans les registres ($t0, $s1, $s2)
destination  source1 op source2

 Format d’instruction (R) (ex. Sub)

0 17 18 8 0 0x22

8
Champs d’instructions MIPS

R op rs rt rd shamt funct

op 6-bits opcode spécifie l’opération

rs 5-bits adresse du registre du premier opérande source
rt 5-bits adresse du registre du deuxième opérande source
rd 5-bits adresse du registre de l’opérande destination
shamt 5-bits shift amount (pour les instructions de décalage)
funct 6-bits Code de la fonction (function) précisant l’opcode

9
Les opérandes des registres

 Les instructions arithmétiques utilisent les opérandes registres

 MIPS a un fichier registre de 32 × 32-bit
 Utilisé pour les données fréquemment utilisés
 Numérotés de 0 à 31
 Un mot (word) est de 32 bit

 Noms des registres en assembleur

 $t0, $t1, …, $t9
 $s0, $s1, …, $s7

 Registres vs mémoires (quand c’est plus petit c’est plus rapide)

10
Fichier registre MIPS
32
 Contient 32 registres à 32 bits Register File locations
32 bits
32 src1
 2 ports pour lecture src1 addr
5 data
 1 port pour écriture 5
src2 addr

dst addr 5
src2
32 32 data
write data

write control

 L’accès aux registres est beaucoup plus rapide que l’accès à la

mémoire principale

11
Exemple d’utilisation des opérandes

 Code C:
f = (g + h) - (i + j);
 On considère que g,h,i,j sont déjà dans $s1,$S2, $S3 et
dans $s4 respectivement, et le résultat f va être
déposé dans $s0
 Code compilé en MIPS:
add $t0, $s1, $s2
add $t1, $s3, $s4
sub $s0, $t0, $t1

12
Les registres en MIPS

13
Opérandes immédiats

 Données constante spécifiées dans l’instruction

addi $s3, $s3, 4

 La constante est dans l'instruction elle-même!

 Le format immédiat limite les valeurs dans la plage +215–1 à -215

 Pas d’instruction de soustraction immédiate

 Juste ajouter une valeur négative
Addi $s2, $s1, -1

14
Constantes larges
 Si on veut transférer une constante de 32 bit (qui dépasse
16 bits) dans un registre; on le fait en deux étapes: Soit la
constante large: 0xAAAABBBB
 Utiliser l’instruction "load upper immediate"
lui $t0, 0xAAAA

 Par après on charge les 16 bits moins significatifs en utilisant

ori $t0, $t0, 0xBBBB

15
Opérations de décalage

 sll et srl décalent les bits d'un mot à gauche ou à droite

respectivement
sll $t2, $s0, 4 #$t2 = $s0 << 4 bits
srl $t2, $s0, 4 #$t2 = $s0 >> 4 bits
 Format de l’instruction (ex. sll)

0 16 10 4 0x00

 Ces opérations sont logiques car le décalage introduit des

0 dans les places vidées.

16
Opérations logiques
 Il existe un certain nombre d'opérations logiques sur les bits
and $t0, $t1, $t2 #$t0 = $t1 & $t2
or $t0, $t1, $t2 #$t0 = $t1 | $t2
nor $t0, $t1, $t2 #$t0 = not($t1 | $t2)

 Format de l’instruction (R)

andi $t0, $t1, 0xFF00 #$t0 = $t1 & ff00

ori $t0, $t1, 0xFF00 #$t0 = $t1 | ff00

 Format de l’instruction (I)

17
Instructions d'accès à la mémoire MIPS

 MIPS a deux instructions de transfert de données de base pour accéder à

la mémoire
lw $t0, 4($t1) #charger la donnée de la mémoire
sw $t0, 8($t1) #stocker la donnée en mémoire

18
Exemple de load et store
lw $t0, 4($t1)
sw $t0, 8($t1)

19
Instruction lw en langage machine
 Load(I):

lw $t0, 24($s3)

35 19 8 2410

Memory
2410 + $s3 = 0xf f f f f f f f

. . . 0001 1000 0x120040ac

$t0
+ . . . 1001 0100
. . . 1010 1100 = $s3 0x12004094

0x120040ac
0x0000000c
0x00000008
0x00000004
0x00000000
data word address (hex)
20
Organisation de la mémoire en MIPS

La mémoire MIPS est adressable par byte, ce qui signifie que chaque adresse mémoire
fait référence à une quantité de 8 bits de données.
L'architecture MIPS peut avoir jusqu'à 32 lignes d'adresse. Il en résulte une RAM 232 x 8,
ce qui équivaut à 4 Gbytes de mémoire.

21
Big Endian vs Little Endian

 Big Endian: le byte le plus à gauche correspond à l'adresse du mot (ex. IBM
AIX, SPARC, MIPS, etc.)

 Little Endian: le byte le plus à droite est l'adresse du mot (ex: x86 et AMD64
/ x86-64 series)

little endian byte 0

3 2 1 0
msb lsb
0 1 2 3
big endian
byte 0

22
Exemple d’opération impliquant la mémoire

 Code C:

g = h + A[8];
 g dans $s1, h dans $s2, adresse de base de A dans $s3
 Code MIPS compilé:
 l’indice 8 correspond à un offset de 32 bytes (4 bytes par mot)

lw $t0, 32($s3) # load word

add $s1, $s2, $t0

23
Un autre exemple

 Code c:
A[12] = h + A[8];
 h dans $s2, adresse de base de A dans $s3
 Code MIPS compilé:

lw $t0, 32($s3) # load word

add $t0, $s2, $t0
sw $t0, 48($s3) # store word

24
chargement et stockage des Bytes

 MIPS fournit des instructions spéciales pour transférer des

Bytes
lb $t0, 1($s3) #charger le byte de la mémoire

sb $t0, 6($s3) #stocker le byte dans la mémoire

 Format machine (I) (ex: sb)

0x28 19 8 16 bit offset

25
Les opérations des sauts

 Saut à une instruction étiquetée (L1) si une condition est vrai

 sinon, continuer séquentiellement
 beq rs, rt, L1
 si (rs == rt) saut à l’instruction L1;
 bne rs, rt, L1
 si (rs != rt) saut à l’instruction L1;

 j Label1
 saut inconditionnel à l'instruction Label1

26
Compilation de l’instruction If

 Code C:
if (i==j) f = g+h;
else f = g-h;
 f, g, h, i, j … dans $s0, $s1, $s2, $s3, $s4…
 Code compilé (manuellement) en MIPS :
bne $s3, $s4, Else
add $s0, $s1, $s2
j Exit
Else: sub $s0, $s1, $s2
Exit: …

27
Spécification des destinations du saut conditionnel
 Utilisation du registre PC pour calculer l’adresse du destination
du saut

28
Instruction jump
 L’instruction j correspond à un saut inconditionnel:

j label #go to label

 Format de l’instruction (J):

0x02 26-bit address

29
Exemple

Loop: sll $t1, $s3, 2 80000 0 0 19 9 2 0

add $t1, $t1, $s6 80004 0 9 22 9 0 32

lw $t0, 0($t1) 80008 35 9 8 0

bne $t0, $s5, Exit 80012 5 8 21

addi $s3, $s3, 1 80016 8 19 19 1

j Loop 80020 2

Exit: … 80024

30
Exemple

Loop: sll $t1, $s3, 2 80000 0 0 19 9 2 0

add $t1, $t1, $s6 80004 0 9 22 9 0 32

lw $t0, 0($t1) 80008 35 9 8 0

bne $t0, $s5, Exit 80012 5 8 21 2

addi $s3, $s3, 1 80016 8 19 19 1

j Loop 80020 2 20000

Exit: … 80024

31
.. Et si le saut est encore plus loin

 Que se passe-t-il si la destination de la branche est plus

éloignée que ce qui peut être capturé en 16 bits?

 L’assembleur vient à la rescousse – il insère un saut

inconditionnel vers la branche cible et inverse la condition
beq $s0, $s1, far
devient
bne $s0, $s1, L2
j far
L2:

32
Résumé du mode d’adressage

33
L’organisation du MIPS vue jusqu’à maintenant

Processor
Memory
Register File
1…1100
src1 addr src1
5 32 data
src2 addr 32
5 registers
dst addr ($zero - $ra) read/write
5 src2
write data data addr
32 32 230
32 words
32 bits
branch offset
32 Add
read data
32 PC 32 Add 32 32
32
4 write data 0…1100
Fetch 32
PC = PC+4 32 0…1000
4 5 6 7 0…0100
32 ALU 0 1 2 3
Exec Decode 0…0000
32
32 bits word address
32
(binary)
byte address
(big Endian)

34
Compilation des instructions d’une boucle

 Code C:
while (save[i] == k) i +=
1;
 i dans $s3, k dans $s5, adresse
de save dans $s6
 Code compilé (manuellement) en
MIPS :
Loop: sll $t1, $s3, 2 add $t1, $zero, $s6
add $t1, $t1, $s6 lw $t0, 0($t1)
lw $t0, 0($t1) j test
bne $t0, $s5, Exit Loop: addi $t1, $t1, 4
addi $s3, $s3, 1 lw $t0, 0($t1)
j Loop Test: beq $t0, $s5, Loop
Exit: …

35
Autres instructions pour les sauts
 En plus de beq, bne, il y a autres types de sauts
 L’instruction slt (set less then) :
slt $t0, $s0, $s1 # if $s0 < $s1 then
# $t0 = 1 else
# $t0 = 0
 Format de l’instruction (format R):

 Il y a aussi
slti $t0, $s0, 25 # if $s0 < 25 then $t0=1 ...

sltu $t0, $s0, $s1 # if $s0 < $s1 then $t0=1 ...
sltiu $t0, $s0, 25 # if $s0 < 25 then $t0=1 ...

36
Pseudo-instructions pour les sauts
 On peut utiliser slt, beq, bne, et la valeur $zero pour créer
d’autres conditions
 less than blt $s1, $s2, Label

slt $at, $s1, $s2 #$at set to 1 if

bne $at, $zero, Label #$s1 < $s2

 less than or equal to ble $s1, $s2, Label

 greater than bgt $s1, $s2, Label
 great than or equal to bge $s1, $s2, Label

 blt, ble, bgt et bge sont des pseudo-instructions. Elles sont

reconnues par l’assembleur
 C'est pourquoi le registre ($at) est réservé pour l'assembleur.

37
Instructions pour l’accès aux procédures
 Instruction d’appel d’une procédure :

jal ProcedureAddress #jump and link

 Sauvegarde PC+4 dans le registre $ra pour avoir un lien à la
prochaine instruction lors du retour de la procédure
 Format machine (format J):
0x03 26 bit address

 La procédure retourne avec l’instruction

jr $ra #return
 Format machine (format R):
0 31 0x08
38
3 étapes dans l’exécution de la procédure

1. La routine principale (l’appelant) place les paramètres dans $a0 - $a3

pour que la procédure appelée accède à ces paramètres et va avoir le
contrôle après (jal dest)

2. La procédure appelée réserve les ressources nécessaires, exécute la

tâche demandée et puis retourne la valeur du résultat dans:$v0 - $v1

3. La procédure appelée retourne le contrôle à l’appelant (jr $ra)

Règles:

- La procédure appelée doit sauvegarder les registres $s0-$s7 si besoin

39
Exemple de Procédure
 Code C: ProcEx:
int ProcEx (int g, int h, addi $sp, $sp, -4
int i,int j)
{ int f; sw $s0, 0($sp)
f = (g + h) - (i + j);
return f;
} add $t0, $a0, $a1
 Arguments g, …, j dans add $t1, $a2, $a3
$a0, …, $a3
 f dans $s0 sub $s0, $t0, $t1
 Résultat dans $v0 add $v0, $s0, $zero
lw $s0, 0(sp)
addi $sp, $sp, 4
jr $ra

40
Métrique de la performance

41
Besoin de métrique de la performance

 Perspective d'achat
• étant donné une collection de machines, qui a
 La meilleure performance ?
 Le moindre coût ?
 Le meilleur rapport qualité/prix ?
 Perspective de conception
• face aux options de conception, qui a
 La meilleure amélioration de la performance ?
 Le moindre coût ?
 Le meilleur rapport qualité/prix ?
 Les deux exigent
• Une métrique pour l'évaluation et pour la comparaison
 L’objectif est de comprendre les facteurs de
l'architecture contribuant à la performance globale du
système et l'importance relative de ces facteurs
42
Quelques définitions

 La performance relative: “ x est N fois plus rapide que y”

 Si on s'intéresse avant tout à la latence,

 Si on s'intéresse avant tout au débit

43
Métrique de la performance du processeur

 Cycles d’horloge CPU /programme =

 Temps d’exécution =

Ninstr : nombre d’instructions exécutées (Instruction Count )

CPI : cycles par instruction (cycles per instruction)

Tcycle (=1/f): le temps de cycle de l’horloge (clock cycle time)

44
CPI
 Différents types d'instructions nécessitent différents nombres de
cycles

CPIi est le CPI pour le type d'instruction i

ICi est le nombre d'instructions de type i (Instruction Counti )

 Calcul du CPI moyen global

 CPIi est obtenu à partir de la fiche technique du processeur, et les

fréquences d'instructions obtenues par profilage de code

• Profilage de code : exécution d'un outil de mesure logiciel en arrière-

plan, qui compte les instructions par type, lors de l'exécution d'un
programme

45
Exemple 1: Comparaison de performance de deux machines
Supposons que nous ayons deux implémentations de la même
architecture de jeu d'instructions (ISA). Pour un programme,
La machine A a un temps de cycle d'horloge de 250 ps et un CPI de 2,0
La machine B a un temps de cycle d'horloge de 500 ps et un CPI de 1,2
Quelle machine est plus rapide pour ce programme, et de combien ?

 Chaque ordinateur exécute le même nombre d'instructions.

 On prend I commele nombre d’instructions.
 Cycles d'horloge CPU pour la machine A = I * 2
 Cycles d'horloge CPU pour la machine B = I * 1.2
 Temps CPU pour A = cycles d’horloge CPU * temps de cycle d’horloge = 500 * I ps
 Temps CPU pour B = cycles d’horloge CPU * temps de cycle d’horloge = 600 * I ps
 L’ordinateur A est plus rapide
 Performance CPU de A / Performance CPU de B = 1.2

46
Exemple 2: Calcul du CPI

Étant donné cette machine, le CPI est la somme de (CPIi × Frequencyi)

Le CPI moyen est de 0,5 + 0,4 + 0,4 + 0,2 = 1,5
Quelle fraction du temps est consacrée aux transferts de données ?
0.6/1.5 = 0,4
Quelle fraction du temps est consacrée pour les traitement arithmétique et
logique ?
0.5/1.5 = 0,33
Quelle fraction du temps est consacrée pour les sauts ?
0.4/1.5 = 0,27

Pour améliorer les performances, investir les ressources là où l’exécution

consomme plus de temps.
47
Considérations sur la performance CPU

Remarque: les paramètres de l’équation sont interdépendants et donc on

est confronté à chercher des compromis pour réduire le temps d’exécution

48
Benchmarks
• Un benchmark est un programme utilisé pour évaluer
la performance. Il existe des suites standards de
benchmark qui permettent de comparer les
performances de différentes machines informatiques.

Suite sandard de benchmark

Groupes utilisateurs
Experts académiques

TPC
EEMBC
Organisation pour benchmark SPEC
...

Fabriquants

49