TD5 : Exécution conditionnelle des instructions

Université Paris Sud
Master d’Informatique (M1)
D. Etiemble
2004-2005
TD5 : Exécution conditionnelle des instructions
On examine dans ce TD des jeux d'instructions où l'exécution de toutes les instructions sont
conditionnelles.
Soit le jeu d'instructions ARM dont les instructions essentielles sont données en annexe. Toutes
les instructions sont à exécution conditionnelle, en fonction du contenu du registre code
condition : INSTcond, où INST est l'instruction, et cond est la condition (GT, GE, EQ; NE, LT,
LE…).
Dans l'implantation XScale (Intel), les mauvaises prédictions de branchement coûtent 4 cycles.
La prédiction statique est NP pour les branchements avant et P pour les branchements arrière.
Exercice 1 : si… alors… sinon
Q 1 : Donner les versions ARM avec et sans branchements pour l'exécution du code, avec le
nombre de cycles correspondants
int x[N], xmin, xmax;
int i;
xmin=x[0];
xmax=xmin;
for (i=1; i<10, i++)
{
if x[i] <xmin
xmin= x[i];
if xmax < x[i]
xmax=x[i];
}
Q 2 : Donner les versions ARM avec et sans branchements avec le nombre de cycles
correspondants
int a, b, c, d, e, f
if (a==0) { a++, b++, c++, d++, e++}
else (a--, b--, c--, d--, e--}
Q 3 : Etablir la formule qui compare les temps d'exécution des versions avec et sans
branchement pour l'expression
if (cond) {if_bloc}
else {else_bloc}
où
N1B est le nombre de cycles pour exécuter {if_bloc} en utilisant des branchements
N2B est le nombre de cycles pour exécuter {else_bloc} en utilisant des branchements
P1 est le pourcentage d'exécution du {if_bloc}
P2 est le pourcentage de mauvaise prédiction de branchement
N1C est le nombre de cycles pour exécuter {if_bloc} en utilisant les instructions
conditionnelles en supposant la condition vraie
N2C est le nombre de cycles pour exécuter {else_bloc} en utilisant les instructions
conditionnelles en supposant la condition fausse
1
Université Paris Sud
Master d’Informatique (M1)
D. Etiemble
2004-2005
Exercice 2 : expressions complexes
Q4 : Donner le code ARM pour les fonctions suivantes
a) int foo (int a, int b) {
if (a!=0 && b!=0)
return 0;
else return 1;
}
b) int foo (int a, int b) {
if (a!=0 || b!=0)
return 0;
else return 1;
}
Q5 : Donner le code ARM, puis le code IA-64 pour le programme suivant :
int T[N], a=0, b=0, c=0, d=0, i;
for (i=0; i<N; i++=)
{
if (T[i] <5)
a++;
if ((T[i] >=5)&& (T[i] <10))
b++;
if ((T[i] >=10)&& (T[i] <15))
c++;
if (T[i] >=15)
d++;
}
r1 pointe sur T[0]
r2 contient N
Instructions ARM (extrait)
Format des instructions arithmétiques et logiques
31-28
Cond
00
I
24-21
20
19-16
15-12
11-0
Code Op
S
n
d
Opérande 2
Rs est le registre source (s est le numéro)
Rd est le registre destination (d est le numéro)
Lorsque I =0, opérande 2 est obtenu comme suit
Opérande 2 = rotation à droite de 2 n positions [immédiat non signé sur 8 bits]
Où les 12 bits sont interprétés comme suit
11-8
7-0
2
Université Paris Sud
Master d’Informatique (M1)
D. Etiemble
2004-2005
Rotation (2 x n)
Immédiat
Lorsque I=1, opérande 2 est obtenu comme suit
Opérande 2 = décalage [Rm]
Où les 12 bits sont interprétés comme suit
11-4
3-0
Décalage (nb de bits)
m (numéro de registre)
Les instructions ARM sont définies à la fois pour les formats RR et RI : Opérande 2 = immédiat
ou Rm
Instructions arithmétiques
Instructions arithmétiques
ADD, SUB
ADC, SUBC
Instructions arithmétiques
RSB, RSC
Instructions logiques
Instructions de transfert
AND, ORR, EOR
MOV, MVN
Rd ← Rs op opérande 2
Rd ← Rs + opérande 2 + retenue
Rd ← Rs - opérande 2 + retenue -1
Rd ← opérande 2 - Rs
Rd ← opérande 2 - Rs + retenue -1
Rd ← Rs op opérande 2
Rd ← opérande 2
Rd ← complément de opérande 2
Les instructions mémoire sont les suivantes
Instruction
LDR
LDRB
STR
STRB
Signification
Chargement mot
Chargement octet
Rangement mot
Rangement octet
Action
Rd ← Mem32(AE)
Rd ← Mem8 (AE)
Mem32(AE) ← Rd
Mem8 (AE) ← Rd
Les modes d’adressage avec la syntaxe assembleur et leur effet sont résumés dans la table cidessous.
Mode
Déplacement 12 bits,
Pré-indexé
Déplacement 12 bits,
Pré-indexé avec mise à jour
Déplacement 12 bits,
Post-indexé
Déplacement dans Rm
Préindexé
Déplacement dans Rm
Préindexé avec mise à jour
Assembleur
[Rn, #deplacement]
Action
Adresse = Rn + déplacement
[Rn, #deplacement] !
Déplacement dans Rm
Postindexé
Relatif
[Rn], ± Rm, décalage
Adresse = Rn + déplacement
Rn ← Adresse
Adresse = Rn
Rn ← Rn + déplacement
Adresse = Rn + décalage
(Rm)
Adresse = Rn + décalage
(Rm)
Rn ← Adresse
Adresse = Rn
Rn ← Rn + décalage (Rm)
Adresse = CP + déplacement
[Rn], #deplacement
[Rn, ± Rm, décalage]
[Rn, ± Rm, décalage] !
Instructions de comparaison et branchement
3
Université Paris Sud
Master d’Informatique (M1)
CMP , TST
Instructions arithmétiques
avec suffixe S : ADDS, SUBS,
etc
Bcond (LT, LE, GT, GE, EQ,
NE…)
BL
BLcond
D. Etiemble
2004-2005
CMP Rs1, Rs2
TST Rs1, Rs2
SUBS Rd, Rs1, Rs2
Rs1-Rs2 → RCC
Rs1 and Rs2 → RCC
Rd ← Rs1 – Rs2
Positionne Rcc
Bcond, déplacement
Si cond, alors
CP ← NCP +déplacement
R14 ← NCP
CP ← NCP + déplacement
Si cond, alors { R14 ← NCP
CP ← NCP +déplacement}
BL déplacement
BLcond déplacement
Instructions IA-64 : extraits
Chargement compteur de boucle
Branchement boucle
mv lc=valeur
Br.cloop L1 ;
Chargement mémoire
ld rd=[rs], déplacement
Comparaison
(pc) cmp.cond. pi,pj=rs,imm
Br.cloop L1 ; ;
4
lc ←valeur
lc ←lc-1. Branchement si
lc≠0
Rd ←Mem (rs + depl)
Rs ←rs + déplacement
positionne les prédicats