Professional Documents
Culture Documents
Contacts:
x@unige.ch
1
Plan du cours
Systmes informatiques et programmation
en assembleur
lments des systmes informatiques
Etude du jeu dinstruction dun
microcontrleur (ARM7TDMI)
Programmation dune gameboy advance
2
Evaluation
Un examen oral la fin de lanne
Ou
Deux contrles continus au cours de lanne, si le premier contrle
continu est rendu, la moyenne des deux compte comme la note de
lexamen oral
1. Le processeur
2. La mmoire
3. Les priphriques
5
Les bus
6
Les bus
Les interrupteurs sont raliss avec des transistors. Un exemple de
sortie est (dpend de la technologie, CMOS, bipolaire, ) :
U[V]
Logique
de
contrle
0
Processeur 1
Bus . Suite de
Priphrique . Bits
mmoire 1
1 (binary digits)
8
Les bus
Linformation transfre par les bus est de type binaire, cest--dire une
suite de bits. Tous les traitements internes sont bass sur le traitement
de ces suites de bits.
Les suites de bits codent linformation
Linformation est traite (fonctions) avec des circuits logiques, portes
et, ou, nand,
9
Les bus
On peut rsumer les diffrentes fonctionnalits des bus
10
schmatiquement
processeur mmoire
Bus de donnes
Bus dadresse
Bus de contrle
Priphrique #1
11
Les bus
Il existe beaucoup de standard diffrents qui dfinissent des bus.
12
Processeur
Le processeur est le composant dun ordinateur qui excute les
programmes, cest--dire
Excute des instructions, lensemble des instructions (machine)
excutables constitue le jeu dinstruction du processeur.
Effectue des oprations sur les donnes, par exemple des
oprations arithmtiques (addition,), des oprations sur les
adresses pour retrouver les donnes en mmoire (pour permettre la
gestion des tableaux de donnes, des pointeurs,), des
comparaisons.
13
Processeur
Historiquement on distinguait les processeurs et les
microprocesseurs, ce dernier faisant rfrences aux processeurs
implants sur un unique circuit intgr (chip). Actuellement, ces termes
sont utiliss sans distinctions.
14
Processeurs structure
Les lments principaux dun processeur sont:
Lunit dexcution
Lunit de commande (control unit)
Lunit de gestion des bus (entres-sorties)
Des registres usage gnral
15
Lunit dexcution
Est compose principalement de:
Lunit arithmtique et logique (ALU Arithmetic and logic unit)
Effectue les oprations arithmtique (addition, soustraction,..)
Effectue les test (galit, plus grand,)
Effectue les oprations logique (et, ou, )
Ou encore
Lunit de calcul en virgule flottante (FPU Floating point unit)
Effectue les calculs complexes non pris en charge par lALU.
Cette unit peut-tre externe au processeur
16
Lunit de commande
Un squenceur ou bloc logique de commande synchronise
lexcution des instructions, gre les signaux de commande.
17
Lunit de gestion des bus
Des registres pour les instructions courantes
Un registre dinstruction qui contient linstruction excuter
Un registre dadresse qui est connect au bus dadresse externe
et qui permet la slection dun priphrique externe (mmoire)
Un registre de donne qui est connect au bus de donnes
externe et permet le transfert de donne entre le processeur et les
circuits externes
18
Les registres
Les registres constituent une petite zone mmoire (de lordre dune
dizaine de mots). Ils sont internes aux processeurs, gnralement
utiliss par lunit dexcution comme oprande source et destination
des instructions.
Leur accs est trs rapide, beaucoup plus rapide quun accs en
mmoire externe et cest la raison pour laquelle on prfre les utiliser
comme oprande plutt que des mots qui se trouvent en mmoire
externe.
19
Schmatiquement B
u
s
A[31:0], bus adresse externe
d
e
Registre dadresse Dcodeur c
dinstruction o
PC n
Logique t
Registres r
de contrle
Usage gnral
PC (program counter) l
Registre dtat e
e
x
t
e
Registre dinstruction r
ALU n
Lecture/criture des donnes e
22
Systmes embarqus
Un domaine dapplication important des microcontrleur est le domaine
de systmes embarqus.
Systmes de freinage dans les vhicules
Les tlphones portables
Les assistants personnels
Systmes de mesure
Camras numriques
Connexion Internet sans fils
Ces systmes sont souvent des systmes Temps Rel, cest--dire
des systmes pour lesquels les contraintes temporelles sont
importantes.
1. Les donnes sont traites immdiatement et non en diffr
2. Le temps de rponse du systme une sollicitation doit tre fix
(au moins born) et dterministe
23
Systmes embarqus
On peux caractriser ces systmes par les contraintes quil doit
satisfaire. En gnral, la puissance de calcul nest pas le critre le plus
important dun tel systme. Des critres classiques sont
24
La mmoire - notation
La mmoire est un dispositif qui permet denregistrer, de conserver et
de restituer des informations codes en binaire.
0 1 2 3 4 5 6 7 8 9 A B C D E F
0000 0001 0010 0011 0100 0101 0110 0111 1000 1001 1010 1011 1100 1101 1110 1111
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
27
La mmoire
Les informations sont repres par des adresses
0x03 0xFC
0x06 0x10
28
La mmoire
Organise par halfword: Un halfword = 2bytes = 16 bits
0x00 0xBC3A
0x02 0x1A2C
0x04 0x332D
Les adresses 0x4ADD
0x06
Sont toujours paires
0x08 0x0000
0x0A 0x0000
0x0C 0xFFFF
29
La mmoire
Organise par mots de 32 bits (word)
0x00 0xBC3AAA31
0x04 0x1A2CCFFF
0x08 0x332D4321
Les adresses
Sont toujours divisibles 0x0C 0x4ADD3320
Par 4 0x10 0x00000000
0x14 0x0000FFFF
0x18 0xFFFFFFFF
30
La mmoire
Les adresses des halfword doivent tre divisible par 2
Les adresses des mots de 32 bits (word) doivent tre divisible par 4
31
La mmoire
Big-endian (big end first): Les bytes sont ordonns en mmoire tel que les
bytes les plus significatifs possdent les adresses les plus petites
0x0C 4A 3B 2C 1D
0x10
little-endian (little end first): Les bytes sont ordonns en mmoire tel que les
bytes les moins significatifs possdent les adresses les plus petites
0x0D 0x0E 0x0F
0x0C 1D 2C 3B 4A
0x10
32
La mmoire
processeur
Un mot mmoire
c
d a o 1 bit
o d m
n r m
n e a
n
s
d
e s e
s e s
s
e
l
e
Active la mmoire c
t
i
o
n
33
Les diffrents types de mmoire
On peux classer les diffrents types de mmoire par la capacit de
stockage quils permettent. Les mmoires la capacit la plus limit
sont aussi celles qui sont accessibles le plus rapidement.
34
Temps daccs ordre de
grandeur
1. Les registres internes, laccs le plus rapide, la capacit la
plus faible
2. La mmoire cache, 6-35 ns pour lire/crire un mot (150-30
MHz)
3. La mmoire centrale, 35-120 ns
4. Disque durs, 10-20 ms
La mmoire cache est gnralement une mmoire qui est plus rapide
que la mmoire centrale (capacit plus faible car plus chre) et est
utilise pour dupliquer les informations souvent accdes (en mmoire
centrale) pour diminuer les temps daccs.
35
Les mmoires vives
Appeles aussi mmoire RAM (Random Access Memory) ce sont les
mmoires que lon peux accder en lecture et en criture.
36
Les mmoires vives
Statiques, SRAM Static Random Access Memory
6-15 ns, permettent de conserver linformation sans
Alimentation, chre souvent la mmoire cache (faible capacit)
Les mmoires
vives DRAM, Dynamic Random Access Memory
60 70ns
Dynamiques SDRAM, Synchronous DRAM
37
Les mmoires mortes
Appeles aussi ROM (Read Only memory), elles ont lavantage de
conserver linformation mme lorsque le circuit nest plus aliment.
39
Les priphriques
Le systme processeur + mmoire est le systme fonctionnel
minimum. Pour pouvoir accder lextrieur on utilise les
priphriques.
40
Les priphriques
En gnral les priphriques possdent des registres que lon accde
de la mme manire quon accde la mmoire. En crivant les valeurs
adquates dans ces registres on active/dsactive le priphrique.
processeur
Ce registre possde une
0xFFFF0000
adresse, on crit un mot
de 32 bits cette adresse
le contenu du registre
est recopi sur un port
externe
41
Les priphriques
Gnralement les priphriques sont directement pilots par le
processeur (do le nom de driver ou pilote pour le logiciel qui contrle
un priphrique).
Par exemple, pour imprimer un fichier le processeur doit transfrer les
donnes en mmoire centrale puis de la mmoire centrale
limprimante en utilisant les bus externes.
Certains priphriques sont capables de prendre en charge ces
transferts de donnes de la mmoire centrale vers un priphrique qui
va seffectuer en parallle lexcution du programme par le
processeur. Ces priphriques sont identifis sous le nom de DMA,
Direct Access memory.
42
Priphrique
Les units dchanges
Par Units dchanges, on dsigne les priphriques dentre/sortie qui
permettent donc dchanger de linformation entre les composants
internes du systmes informatique et lextrieur.
Bus de contrle
read
write
Bus de donnes 8 bits
signaux de
slection imprimante
slection
des circuits
Mmoire Mmoire unit
S1 ROM S2 RAM S3 dchange
Bus dadresses
A0
A1
A2
.
. 43
.
A10
Espace dadressage
Sur le schma prcdent:
le bus de donne est partag par tous les lments extrieurs
(mmoire et priphrique) pour permettre le transfert de donnes
depuis le processeur vers tous les circuits.
44
Espace dadressage
On utilise trois signaux S1, S2, S3 qui sont gnrs par lunit de
slection pour dsigner le circuit parmi les trois qui doit prendre en
compte le transfert. Cest--dire le circuit qui est destin les donnes
ou qui doit fournir les donnes.
45
Espace dadressage
On considre par exemple un processeur qui dispose de 16 lignes
dadresses
0x0000
0x0000
0x0001 Priphrique #1
0x000A
Les registres
0x0000
Priphrique #2
0x001F
0xFFFD
0xFFFE
0xFFFF
Lors de la conception du systme
on assigne une adresse aux registres
des priphriques dans lespace adress
Adressable par le processeur 46
par le processeur
Exemple
Memory Map
General Internal Memory
0000:0000-0000:3FFF BIOS - System ROM (16 KBytes)
0000:4000-01FF:FFFF Not used
0200:0000-0203:FFFF WRAM - On-board Work RAM (256 KBytes) 2 Wait
0204:0000-02FF:FFFF Not used
0300:0000-0300:7FFF WRAM - In-chip Work RAM (32 KBytes)
0300:8000-03FF:FFFF Not used
0400:0000-0400:03FE I/O Registers
0400:0400-04FF:FFFF Not used
Internal Display Memory
0500:0000-0500:03FF BG/OBJ Palette RAM (1 Kbyte)
0500:0400-05FF:FFFF Not used
0600:0000-0617:FFFF VRAM - Video RAM (96 KBytes)
0618:0000-06FF:FFFF Not used
0700:0000-0700:03FF OAM - OBJ Attributes (1 Kbyte)
0700:0400-07FF:FFFF Not used
47
Exemple
External Memory (Game Pak)
0800:0000-09FF:FFFF Game Pak ROM/FlashROM (max 32MB) - Wait State 0
0A00:0000-0BFF:FFFF Game Pak ROM/FlashROM (max 32MB) - Wait State 1
0C00:0000-0DFF:FFFF Game Pak ROM/FlashROM (max 32MB) - Wait State 2
0E00:0000-0E00:FFFF Game Pak SRAM (max 64 KBytes) - 8bit Bus width
0E01:0000-0FFF:FFFF Not used
Unused Memory Area
1000:0000-FFFF:FFFF Not used (upper 4bits of address bus unused)
48
Cycle de lecture B
u
Ladresse prsente sur le bus s
est ladresse dune instruction A[31:0], bus adresse externe
d
e
Registre dadresse Dcodeur c
dinstruction o
PC n
Logique t
Registres r
de contrle
Usage gnral
PC (program counter) l
Registre dtat e
e
x
t
e
Registre dinstruction r
ALU Lecture/criture des donnes n
e
Dans un Ladresse
registre processeur slection mmoire
0xDD30003F S1 0xDD30003F 0x0000FF04
50
Cycle de lecture
on peux dcomposer un cycle de lecture
1. Le processeur dpose ladresse sur le bus dadresse
2. En utilisant ladresse ou un signal ddi le circuit mmoire est
slectionn, ce qui lui indique quil doit prendre en charge le transfert
(bus de contrle)
3. Le circuit mmoire dpose sur le bus de donne la donne qui se
trouve ladresse
4. Le processeur saisit la donne et libre les bus pour le prochain
transfert
La donne peut tre une information telle que la valeur dune variable,
un pointeur, etc. mais aussi la prochaine instruction excuter.
51
Cycle dcriture
Dans un Ladresse
registre processeur mmoire
0xDD30003F 0xDD30003F 0x0000FF04
52
Cycle dcriture
on peux dcomposer un cycle dcriture
53
Un priphrique classique
UART (port srie)
UART : Universal Asynchronous Receiver Transmitter
INTR
Emission
Transmission Donnes transmises
54
dcalage
(srie)
UART
Registre de rception: contient le dernier caractre reu
Le registre de validation des interruptions: permet dindiquer si lon
fonctionne en mode interruption ou pas
Le registre qui indique le statut (ltat) de la ligne : libre, occupe
Le registre didentification de linterruption: contient un numro
dinterruption qui est fourni au processeur pour spcifier
linterruption traiter (la routine excuter)
Le registre diviseur: permet de dfinir la vitesse de transmission
Le registre de contrle du modem
Le registre de statut du modem: positionn par le modem, permet
au processeur de connatre ltat du priphrique
Le registre dmission: contient le prochain caractre mettre
55
Traitement dune interruptions
Le traitement des interruptions dpend du processeur, on prsente ici
un exemple inspir du processeur Motorola 68000. Toujours utilis
dans certaine microcontrleur 68376, 68332
56
Interruptions
Le signal INTR est activ par lUART pour indiquer au processeur
quune interruption (matriel) doit tre traite. Par exemple, la
rception dun caractre.
INTR
processeur
UART
57
Traitement dune interruption
Excution des instruction
Routine
PC Interruption
Plus prioritaire
Routine dinterruption
Niveau y>x
Programme
Principale
Niveau x
58
Table dinterruption CPU32 (68000)
Numro du vecteur Adresse Description
47 Instruction TRAP
60
IACK = Interrupt Acknowledge
Daisy Chain
Pour un mme niveau de priorit, les circuits sont ordonns selon leur
position dans la chane. Les circuits qui reoivent le signal IACK du
processeur peuvent dcider
61
Interruptions
Les sources des interruptions peuvent tre soit matriels soit
logicielles
Les interruptions matriels sont asynchrones et permettent une
rponse rapide du systme un vnement
Les interruptions logicielles sont synchrones et permettent par
exemple de changer la priorit dexcution du processus. Ce qui est
utile pour excuter certaines oprations en mode superviseur (OS).
Les programme utilisateurs nayant pas la priorit suffisante pour les
excuter
Une alternative au Daisy Chain est la scrutation, le processeur
testant tous les registres dtats des priphriques pour trouver celui
qui initi linterruption
Une alternative au systme dinterruption est la scrutation (polling)
ou le processeur passe son temps tester si un vnement eu
lieu.
Le systme dinterruption du 68000 est vectoris
62
Masquage des interruptions
Dans certaines situations il est important de masquer les interruptions,
cest--dire dempcher leur prise en compte par le processeur.
Un programme en mmoire
63
Masquage des interruptions
Pour les processeurs du type 68000 on a la possibilit dutiliser les
diffrents niveaux de priorits pour masquer les interruptions. Le
niveau 7 est non masquable. On peut se placer en niveau 7 pour
masquer toutes les interruptions
Section critique
64
CTI
Un programme dexemple
#include <signal.h>
#include <stdio.h>
#include <unistd.h>
void handler(int signum) // la routine est appelle priodiquement toutes les secondes
{
printf ("%d,%d\n", memory.a, memory.b);
alarm (1);
}
65
Les interruptions ARM7TDMI
Les processeurs de la famille ARM nutilisent pas un systme dinterruptions
vectoris. Le systme permet dutiliser 7 interruptions diffrentes.
66
Les interruptions ARM7TDMI
A ladresse correspondant une interruption se trouve une instruction.
Lorsquune interruption est leve, les processeur suspend lexcution
en cours, charge linstruction qui se trouve ladresse correspondante
et lexcute. Gnralement, la table dinterruption contient une
instruction de branchement qui permet dexcuter une routine.
67
Les interruptions ARM7TDMI
Software interrupt : le processeur excut une instruction SWI, par
exemple pour effectuer un appel une routine du systme
dexploitation.
68
Le Microcontrolleur
ARM7TDMI
69
Nomenclature des processeur
ARM
ARM{x}{y}{z}{T}{D}{M}{I}{E}{J}{F}{-S}
x: famille 1,2,3,,7,8,9
y: gestionnaire de mmoire/unit de protection
z: cache
T: jeu dinstructions Thumb
D: debbugger hardware JTAG
M: multiplicateur rapide
I: macrocell ICE embarqu (debug)
E: jeu dinstructions avanc
J: jeu dinstruction Jazelle (acclaration byte-code Java)
F: unit virgule flottante
S: version synthetisable
70
Architecture ARM
http://www.arm.com
71
RISC
Dans un processeur RISCles instructions doivent sexcuter en un
seul cycle dhorloge qui doit tre haute frquence. La complexit
des instructions est donc limite ( par exemple les modes
dadressages). La complexit dun algorithme est donc assure par
lensemble des instructions et les performances du compilateurs sont
dterminantes
Instructions: Reduced Intstructions Set Computer, le compilateur doit
raliser des oprations simples (typ. pas de divisions). Le temps
dexcution des instructions est similaire (1 cycle). Pour un processeur
CISC certaines instructions peuvent durer plusieurs cycles dhorloges.
Pipelines: Les instructions ayant toutes le mme format il est possible
de fractionner leur excution en sous-tapes dexcution (lire
linstruction, dcodage, excution).
Registres: Grand nombre de registres usage gnral (pas de
registres ddis). Les registres peuvent contenir des donnes ou des
adresses indiffremment.
72
RISC
Registres (suites): les registres sont utiliss par les instructions comme
paramtres dentres/sorties. Dans certains processeurs RISC, certaines
instructions peuvent sexcuter seulement avec certains registres pour
amliorer les performances.
Architecture Load/Store: Les instructions sexcutent uniquement sur des
donnes contenues dans les registres. Les transferts entre mmoire
externe et registres seffectuent par des instructions spcifiques (Load et
Store) . Les processeurs CISC permettent par exemple la multiplication de
donnes en mmoire externes et le placent rsultat en mmoire externe (3
accs mmoire)
74
ARM-RISC ou CISC
Les instructions ne sexcutent pas toutes en un seul cycle
dhorloge. Par exemple, les instructions load/store peuvent
transfrer plusieurs registres des adresses squentielles
(augmentation de la densit de code, accs squentiels sont
gnralement plus rapides)
Un registre dcalage barrel register permet deffectuer un
prcalcul sur un registre avant quil soit utilis par une instruction
(dcalage)
Un jeu dinstruction cod sur 16 bits (augmentation de la densit
dintgration ~30%)
Les instructions peuvent tre conditionnelles, ce qui rduit
lutilisation des instructions de branchement
Certaines instructions sont spcialises, comme les instructions
DSP
75
Exemple darchitecture
Dcodage et paramtrisation des mmoires par programme
ROM
SRAM
FLASHROM
Cur Controlleur
Programmable, mmoire
ARM DRAM
quel priphrique
priorit, Controlleur
Bus externe
Controlleur AHB etxerne
Dinterruption
76
Software
Application
Systme dexploitation
77
Software
Code dinitialisation: Le premier programme excut par le systme,
ralise linitialisation du systme (controlleur dadresse, etc) pour
quil soit fonctionnel.
Le systme dexploitation est gnralement rduit pour les systmes
embarqus (pas de mmoire de masse, structures de fichiers, etc.).
Gnralement, se rduit un ordonnanceur de tches qui
fonctionne par interruption ou scrutation (event or pool driven
system).
Les pilotes, lments logiciels qui simplifie lexploitation des
priphriques
78
Code dinitialisation
(boot code)
On considre trois phases diffrentes
Initialisation du matriel: par exemple les plan dadressages. Par dfaut,
un plan dadressage est dfini pour le processeur mais il peut-tre
modifi
Diagnostique: test les priphriques et ressources
Dmarrage (booting): par exemple charger et passer la main au
systme dexploitation, activer une application, Le programme qui doit
tre excut peut tre sauvegard en mmoire sous forme
compresse, le code doit donc tre dcompress et plac en mmoire
externe.
Systmes dexploitations
RTO (Real Time Operating system) Un systme qui garanti les temps
de rponse aux vnements (<x microsec.)
Platform OS, prend en charge la gestion des priphriques, mmoire
disque dur, sans contraintes temps-rels (Linux, Windows)
79
Flot des donnes
Data bus (donne/programme)
dcodeur dinstruction
extension du signe
write read Rd
rsultat
registres r0-r15
Rn Rm
A B
Acc
registre dadresse
incrmenteur
80
Bus dadresse A,B,rsultat : bus internes
ARM
Le schma reprsente une implmentation de Von Neumann de
larchitecture ARM (un seul bus de donnes pour les
instructions/donnes). Il existe des implmentations de Harvard.
Larchitecture est de type load/store (typique des RISC). Cest--dire
que les instructions sexcutent uniquement sur les registres et les
accs externes sont seulement pour transfrer des donnes
vers/depuis les registres.
Les donnes sont sur 32 bits, les entiers peuvent tre signs.
Lorsquune donne sur 8 ou 16 bits est transfres vers les
registres sur 32 bits et en tendant le signe.
Les instruction load/store utilisent lALU pour gnrer une adresse
qui est maintenue dan le registre dadresse et sur le bus dadresse
externe. Rm
Le registre peut tre modifi avec le registre dcalage avant
dtre utilis par lALU
81
Les registres
Les registres accessibles dpendent du mode de fonctionnement du processeur.
Mode Utilisateur (user mode): les registres sont 32 bits, les registres rx sont
r0
usage gnral (general purpose). Les registres r13,r14 et r15
r1 sont gnralement utiliss comme pointeur de pile (sp=stack
r2
pointer), adresse de retour de sous-routine (lr=link register) et
r3
r4
de compteur de programme (pc=program counter) pointe sur
r5 ladresse de la prochaine instruction charger. Les registres
r6 r13 et r14 peuvent tre utiliss comme registres gnraux mais
r7
cet usage peut-tre en conflit avec un ventuel OS. Les
r8
r9
registres r0-r13 sont orthogonaux cest--dire que toutes les
r10 instructions qui sexcutent sur r0 peuvent sexcuter sur les
r11 autres registres. Certaines instructions utilisent r14 et r15
r12
particulirement
r13 sp
r14 lr
r15 pc
cpsr
-
registres dtats (un registre et sa copie) 82
Registre cpsr
Current Program Status Register
31 30 29 28 24 7 6 5 4 0
N Z C V J I F T Mode
cpsr
- spsr_fiq spsr_irq spsr_svc spsr_undef spsr_abt
85
saved program status register
Les registres - modes
lorsque lon change de mode de fonctionnement les registres affects
par lexcution des instructions peuvent changer.
Par exemple, en mode fast Interrupt request, les instructions qui
modifient les registres r8 - r14 modifient rellement les registres r8_fiq -
r14_fiq.
86
Excution des instruction Les registres - modes
PC
mode fast
interrupt request
Mode utilisateur
la routine peut modifier les registres r8-r14
sans se soucier de restaurer
les valeurs a la fin du traitement. Les autres
registres doivent tre sauvegards puis 87
restaurer.
Notion de contexte
Le contexte dexcution dune tche ou dune application est
constitu des registres utiliss par la tche pour raliser sa fonction.
Pour le processeur ARM, il sagit des registre r0-r15 et des registres
dtats.
Pour traiter une interruption, excuter une routine, ou changer
dutilisateur (systme partag ou multitche) il faut commuter (changer)
le contexte, cest--dire
cpsr
- spsr_irq sauvegarde du registre dtat du mode utilisateur
89
Changement de mode
Les sources des changements de modes peuvent tre
logicielles
matrielles
90
Modes rsum
Mode Abbrviation Privilgi Mode[4:0]
abort abt oui 10111
91
Etat du processeur et jeu
dinstructions
Le processeur peut se trouver dans trois tats diffrents: ARM,
Thumb, Jazelle. Les changements dtats sont provoqus par
lexcution dinstructions particulires
92
comparaison
ARM Thumb
#instructions 58 30
93
Retour sur le cpsr
31 30 29 28 27 24 7 6 5 4 0
N Z C V Q J I F T Mode
F,T: masque dinterruption pour les fast interrupt request et interrupt request
95
Saturation
Par exemple:
Arithmtique non sature
0x7fffffff + 1 = 0x 80000000 (rsultat ngatif)
Arithmtique sature
0x7fffffff + 1 = 0x7fffffff
96
Pipeline
Lexcution dune instruction se dcompose en
1. transfrer linstruction de la mmoire dans le registre ddi au
dcodage es instructions
2. dcodage de linstruction
3. excution de linstruction
le pipeline de lARM7
97
Pipeline
Exemple: on a trois instruction ADD, SUB, CMP qui se suivent
ADD
SUB ADD
temps
98
Pipeline
la longueur du pipeline dtermine les caractristiques de
lexcutions
une instruction est excute uniquement aprs quelle ait pass tout les
tages du pipeline. A linitialisation le pipeline doit se remplir avant la
premire excution, a cela correspond un temps de latence. (idem
lorsquil y a rupture de squence avec une instruction de branchement)
Il se peut quil y ait des dpendances entre les donnes lintrieur du
pipeline. Un tage du pipeline est bloqu car il doit connatre le rsultat
dune instruction elle aussi dans le pipeline. Le compilateur est
responsable de limiter de telles dpendances .
Les curs ARM9 et ARM10 utilisent des pipelines de 5 et 6 tages
respectivement
99
Pipeline - pc
Le registre pc contient ladresse de la prochaine instruction transfrer
de la mmoire vers le processeur. Si linstruction en cours dexcution
se trouvait ladresse n, le pc pointe sur ladresse n + 8 ( mode thumb
cest + 4).
100
Exceptions - interruptions
Lorsquune interruption ou une exception est leve le processeur
suspend lexcution du programme courant et excute linstruction
situe ladresse correspondante dans la table des vecteurs
dinterruptions.
Reset: adresse du code dinitialisation aprs mise sous tension du
processeur
Undefined instruction: le processeur est incapable de dcoder une
instruction
Prefetch abort: le processeur nest pas autoris transfrer une
instruction ladresse dsire
Data abort: idem prefetch abort except que laccs mmoire est
pour une donne
Interrupt request: interruption matrielle externe
Fast interrupt request: idem interrupt request mais temps de rponse
plus court
101
Exceptions - interruptions
Exception/interruption mnmonique adresse adresse2
103
Autres lments
Gestionnaire de mmoire
une unit de protection de la mmoire MPU (memory protection
unit)
dtermine un nombre limit de zone mmoire (parmi les 4Gb
adressables) et des permissions pour les accs
pour les systmes qui ncessitent la mmoire protges mais na
pas de plan dadressage compliqu
une unit de gestion de la mmoire MMU (memory managment
unit)
permet dimplmenter la mmoire virtuelle (table de traduction
dadresses) ainsi que les permissions daccs
pour les applications multitches
il est possible de travailler sans MPU ni MMU pour les systmes
particulirement simples
104
Autres lments
Gnralement une unit de calcul en virgule flottante FPU (Floating
Point Unit) nest pas intgre. Les lments matriels qui sont
utilisables pour acclrer les calculs en virgule flottante sont
FPA Floating Point Accelerator
VFP Vector Floating Point Accelerator
105
les instructions ARM
Nous ne considrons que le jeu dinstruction ARM cod sur 32 bits. Les
caractristiques gnrales sont:
excution conditionnelle
instructions comprenant deux oprandes sources et une
oprande destination
opration de dcalage sur une oprande source (barrel register)
saut de programme (relatif) de + ou 32 Mbytes
31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1
106
Exemple ADD
31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1
107
exemple ADD
ADD R1,R1,#1 R1=R1+1
ADDNE R2,R3,R4 si Z=0 R2=R3+R4 sinon NOP
108
pr-processing des donnes
Data bus (donne/programme)
dcodeur dinstruction
extension du signe
write read Rd
rsultat
registres r0-r15
Rn Rm
A B
Acc
registre dadresse
incrmenteur
109
Bus dadresse A,B,rsultat : bus internes
Les conditions
cond drapeau test
mnmonique signification
[31:28] (cpsr)
0000 EQ gal Z=1
0001 NE pas gal Z=0
0010 CS/HS retenue/plus grand ou gal (non sign) C=1
0011 CC/LO pas de retenue/plus petit (strict et non sign) C=0
0100 MI minus/ngatif N=1
0101 PL plus/positif ou nul N=0
0110 VS overflow/ dpassement de capacit V=1
0111 VC no overflow/pas de dpassement de capacit V=0
1000 HI plus grand non sign C=1 et Z=0
1001 LS plus petit ou gal non sign C=0 ou Z=1
1010 GE plus grand ou gal sign N=V
1011 LT plus petit sign N != V
1100 GT plus grand sign Z=0 et (N=V)
1101 LE plus petit ou gal sign Z=1 ou (N!=V)
110
1110 AL pas de condition toujours
Les conditions
EQ = equal GT = greater that
NE = not equal LE = less or equal
CS = carry set (=1) AL = always
CC =carry clear (=0)
MI = minus
PL = plus
VS = V set (=1)
VC = V clear (=0)
HI = higher
LS = lower or same
GE = greater or equal
LT = less than
111
Exemples
ADDNE R1,R2,R3 R1=R2+R3 si Z=0
ADDVS R8,R9,R10 R8=R9+R10 si V=1
ADDAL R4,R5,R6 R4=R5+R6 toujours
ADD R2,R5,R8 R2=R5+R8 toujours par dfaut
Ce mcanisme permet dviter les branchements conditionnels
BNE suite
ADD R1,R2,R3 = ADDNE R1,R2,R3
suite
112
Les drapeaux
les conditions portent sur des drapeaux (V=1, C=0, etc) qui sexprime
sous la forme overflow/dpassement de capacit sign, etc Le code
gnral est:
113
Les drapeaux
<NoUnsignedOverflow>: 1-<UnsignedOverflow>
114
Les instructions de manipulation
des donnes
manipulation des donnes entre registres.
dplacement (MOVE)
instructions arithmtiques
instructions logiques
instructions de comparaison
instruction multiplication
le registre dcalage (barrel shifter) est gnralement disponible
Mise jour du registre cpsr (S=Statut)
Dplacement/MOVE
syntaxe: <instruction>{<cond>}{S} Rd, N
oprande source
115
Exemple
MOV Rd = N
MOVN Rd = ~ N
Plus prcisement,
valeur_immdiate = imm_8 ROR 2*imm_4
117
Mise jour du cpsr
Si linstruction le spcifie (MOVS, par exemple) le registre dtat cpsr
est mis jour en fonction de la valeur du registre de destination
(rsultat).
N = <negative> (bit 31)
Z = <zero>
V nest pas modifi
118
Registre dcalage
Rn Rm
registre dcalage
pre-processing
ALU
119
Registre dcalage
constante ou valeur immdiate
nombre de
mnmonique description dcalage rsultat
dcalage
(unsigned)x>>
LSR dcalage logique droite xLSRy #1-32 ou Rs
y
dcalage arithmtique
ASR xASRy (signed)x>>y #1-32 ou Rs
droite
((unsigned)x>>
ROR dcalage droite xRORy #1-31 ou Rs
y) | (x<<(32-y))
(c flag << 31) |
RRX dcalage droite tendu xRRX y ((unsigned)x>> ----
1) 120
Registre dcalage
31 0
C 0 LSL
31 0
0 0 LSR
31 0
0 ASR
C ROR
31 0
C RRX
122
2me oprande source
<instruction>{<cond>}{S} Rd, N
N syntaxe
valeur immdiate #valeur
registre Rm
dcalage logique gauche immdiate Rm, LSL #val_imm
dcalage logique gauche registre Rm, LSL Rs
dcalage logique droite immdiate Rm, LSR #val_imm
dcalage logique droite registre Rm, LSR Rs
dcalage arithmtique droite immdiate Rm, ASR #val_imm
dcalage arithmtique droite registre Rm, ASR Rs
rotation droite immdiate Rm, ROR #val_imm
rotation droite registre Rm, ROR Rs
Rotation droite avec extension Rm, RRX 123
Exemple
MOVS r0,r1, LSL #1
r0 0x00000000 r0 0x00000008
r1 0x80000004 r1 0x80000004
124
Instructions arithmtiques
Syntaxe: <instruction>{<cond>}{S} Rd, Rn, N
2me oprande
instruction 1re oprande
excution conditionnelle
registre destination
125
Instructions arithmtiques
ADC adition 2 oprandes* + retenue Rd = Rn + N + C
r0 0x00000000 r0 0xffffff89
r1 0x00000077 r1 0x00000077
complment 2
les bits C=<UnsignedOverflow>, V=<SignedOverflow>, N=<Negative> et Z
= <Zero> sont positionns
127
Exemple
Programmation de boucles:
MOV r1, N
loop
; le corps de la boucle r1 = N, N-1, , 1
SUBS r1, r1, #1
BGT loop
128
Exemple
Programmation de boucles 2:
SUBS r1, N, #1
loop
; le corps de la boucle i = N-1 , N-2, , 0
SUBS r1, r1, #1 #2, #3, pour modifier le pas
BGE loop
r1 = r2 + 8 * r3
r1 = r2 + r3/16 (sign)
130
Exemples
4. ADD r1,r2,r3, LSL r4
r1 = r2 + 2^r4 * r3
131
Instructions logiques
Les instructions logique effectue des oprations bit--bit (bitwise)
* de 32-bits
les bits Z et N du cpsr sont mis--jour
132
Exemples
ORR r0, r1, r2
r0 0x00000000 r0 0x12345678
r1 0x02040608 r1 0x02040608
r2 0x10305070 r2 0x10305070
0x00400000
BIC r0, r0, #1<<22
r0 0xffff0000 r0 0xffbf0000
135
Instructions de multiplication
On a deux classes, les multiplications et les multiplications longues (le
rsultat est sur 64 bits). Le rsultat est plac dans un registre ou une
pair de registres
MUL Multiplication Rd = Rm * Rs
136
Instructions de multiplication
Multiplications longues
syntaxe: <instruction>{<cond>}{S} RdLo, RdHi, Rm, Rs
137
exemple
MUL r0, r1, r2 r0 = r1 * r2
r0 0x00000000 r0 0x00000004
r1 0x00000002 r1 0x00000002
r2 0x00000002 r2 0x00000002
r0 0x00000000 r0 0xe0000004
r1 0x00000000 r1 0x00000001
r2 0xf0000002 r2 0xf0000002
r3 0x00000002 r3 0x00000002
138
Remarque sur les multiplications
le temps ncessaire lexcution dune multiplication dpend de
1. limplmentation du processeur = certaine ralisations sont plus
optimum que dautres
2. la valeur du registre Rs, on dtermine
1. M=1 pour -2^11 <= Rs < 2^11
2. M=2 pour -2^23 <= Rs < 2^23
3. M=3 pour les autres valeurs de Rs
le nombre de cycle pour excuter linstruction est M pour les
instructions MUL/MLA, 4 pour MULS/MLAS, 1+M xMULL/xMLAL et
5 pour xMULLS/xMLALS
139
Remarque sur les multiplications
Pour un processeur 68000 la diffrence de temps dexcution entre
une addition et une multiplication est un facteur 8-9
140
Instructions de branchement
les instructions de branchement permettent de modifier le droulement du
programme (initialement squentiel) pour effectuer des tests ou des appels de
sous-routines.
B branch pc = label
pc = label
BL branch + link
lr = adresse de la prochaine instruction aprs BL
pc = label, T=1
BLX branch exchange +l ink pc = Rm & 0xfffffffe, T= Rm & 1 141
lr = adresse de la prochaine instruction aprs BLX
Instructions de branchement
Le bit T dsigne le bit T du cpsr qui indique que le processeur est dans
ltat Thumb, les instructions BX et BLX permettent donc de changer
ltat du processeur.
142
Instructions de branchement
exemple:
B forward
ADD r1, r2, #4
ADD r0, r6, #2
ADD r3, r7, 34
forward
SUB r1, r2, #4
143
Instructions de branchement
exemple:
backward
ADD r1, r2, #4
SUB r1, r2, #4
ADD r4, r6, r7
B backward boucle infinie
144
instructions de branchements
exemple: appel une sous-routine
BL sousroutine
CMP r1, #5
MOVEQ r1, #0
.
.
.
.
sousroutine
<code de la sous-routine>
MOV pc, lr move le contenu du registre lr dans le pc
145
Instructions load- Store
les instructions Load et Store permettent le transfert de donnes entre
les registres et la mmoire externes (priphriques,).
146
transfert registre simple
Single-register transfer
147
STRB sauve un byte depuis un registre Rd => mem8[adresse]
transfert registre simple
148
modes dadressages
Le processeur ARM permet daccder la mmoire selon diffrents
modes (modes dadressages). Chacun de ces modes utilise une des
mthodes suivantes pour lindexage
pr indexe avec mise jour
pr index
post index
pr index avec
mem[base + offset] base + offset LDR r0, [r1, #4]!
mise jour
150
modes dadressages
adressage1 et mthode dindexage (suite):
pr index avec registre d
offset et registre dcalage [Rn, +- Rm, shift #shift_imm]!
et mise jour:
151
modes dadressages
Les modes dadressages prsents sur les deux derniers transparents
sont disponibles pour des instructions load/store de mot de 32 bits ou
de byte non sign
le mot immdiat (par exemple offset immdiat) indique que les calculs
utilise un offset de 12 bits encod dans linstruction (par daccs
mmoire supplmentaire)
152
modes dadressages
mode dadressage 2:
pr index avec offset immdiat: [Rn, #+-offset_8]
100014
r1 0x00000000
100010
r2 0x00100014
1000C 0x9876C4A1
r3 0x00000008
10008
10004
0x00100014-0x8 = 0x0010000C
mmoire
r1 0x9876C4A1
r2 0x0010000C
r3 0x00000008
154
exemple
LDR r1, [r2], r3, LSL #3
adresse valeur
100010
r1 0x00000000 10000C
r2 0x00100000 100008
r3 0x00000001 100004
100000 0x9876C4A1
0x1 LSL #3 = 0x8 mmoire
r1 0x9876C4A1
r2 0x00100008
r3 0x00000001
155
exemple
lors dun chargement dun byte non sign les 24 bits de poids fort sont
mis 0
LDRB r1, [r2, #2]
adresse valeur
r1 0xxxxxxxxx 100008
r2 0x00100004 100004 0x9876C4A1
100000
r1 0x000000C4
r2 0x00100004
156
exemple
Mot non-align: lorsque ladresse nest pas multiple de 4, le mot entier
est transfr dans le registre, mais le byte dsign par ladresse
devient le byte de poids fort
LDR r1, [r2, #2]
adresse valeur
100008
r1 0x00000000
100004 0x9876C4A1
r2 0x00100004
100000
mmoire
r1 0xC4A19876
r2 0x00100004
157
exemple
Mot non align: lorsquun mot est stock en mmoire une adresse
non divisible par 4, les deux derniers bits de ladresse sont mis zro
et le mot stock cette adresse
STR r1,[r2,#0]
adresse valeur
r1 0x12345678 100008
r2 0x00100007 100004 0x12345678
100000
158
exemples
pr index avec mise jour
LDR r0, [r1, #0x4]! r0=mem32[r1+0x4] r1 += 0x4
LDR r0, [r1, r2, LSR#0x4]! r0=mem32[r1+(r2 LSR 0x4) r1 += (r2 LSR 0x4)
pr index
LDR r0,[r1,#0x4] r0=mem32[r1+0x4] r1 pas mis jour
LDR r0,[r1,r2] r0=mem32[r1+r2] r1 pas mis jour
LDR r0,[r1, -r2,LSR #0x4] r0=mem32[r1-(r2 LSR 0x4)] r1 pas mis jour
159
exemples
post index
LDR r0, [r1], #0x4 r0=mem32[r1] r1 += 0x4
160
transferts de multiples registres
Une seule instructions peut transfrer le contenu de plusieurs registres
vers/depuis la mmoire. Le transfert dbute depuis une adresse de
base contenue dans un registre Rn.
161
transferts de multiples registres
syntaxe: <LDM | STM>{<cond>}<mode adressage> Rn{!}, <registres>{^}
multiple
mode
description adresse dbut adresse fin Rn!
adressage
IA Incrmente aprs Rn Rn+4*n-4 Rn+4*N
IB incrmente avant Rn + 4 Rn+4*N Rn+4*N
DA dcrmente aprs Rn-4*N+4 Rn Rn-4*N
DB dcrmente avant Rn-4*N Rn-4 Rn-4*N
162
exemple
LDMIA r0!, {r1-r3}
0x80020 0x00000005
163
exemple
r0 0x8001c
r1 0x00000001
r2 0x00000002
r3 0x00000003
0x80020 0x00000005
r0 0x8001c 0x00000004
0x80018 0x00000003
0x80014 0x00000002
0x80010 0x00000001
164
exemple
LDMIB r0!, {r1-r3}
0x80020 0x00000005
165
exemple
r0 0x8001c
r1 0x00000002
r2 0x00000003
r3 0x00000004
0x80020 0x00000005
r0 0x8001c 0x00000004
0x80018 0x00000003
0x80014 0x00000002
0x80010 0x00000001
166
exemple
les instructions STM<cond> et LDM<cond> doivent tre utiliss par
paires pour lire/crire les mmes registres, par exemple lors dune
sauvegarde sur la pile
STMIA LDMDB
STMIB LDMDA
STMDA LDMIB
STMDB LDMIA
167
exemple
r0 0x00090000
r1 0x00000009
r2 0x00000008 avant
r3 0x00000007
0x0009010
STMIB r0!, {r1,r2,r3}
0x000900c 0x00000007
MOV r1, #1
0x0009008 0x00000008
MOV r2, #2
0x0009004 0x00000009
MOV r3, #3
0x0009000
r0 0x0009000c
r1 0x00000001
r2 0x00000002
aprs
r3 0x00000003
168
exemple
r0 0x0009000c
r1 0x00000001
avant
r2 0x00000002
r3 0x00000003
0x0009010
LDMDA r0!, {r1,r2,r3}
0x000900c 0x00000007
0x0009008 0x00000008
0x0009004 0x00000009
r0 0x00090000 0x0009000
r1 0x00000009
r2 0x00000008
aprs
r3 0x00000007
169
exemple
copie dune zone mmoire vers une autre zone
; le registre r9 pointe sur le dbut de la zone source
; le registre r10 pointe sur le dbut de la zone destination
; le registre r11 pointe sur la fin de la zone source
; les transferts sont effectus par blocs de 32 bytes
loop
; charger un bloc de 32 bytes depuis la mmoire
LDMIA r9!, {r0-r7}
; transfrer le bloc vers la mmoire
STMIA r10!, {r0-r7}
; a-t-on termin?
CMP r9, r11
BNE loop
170
exemple
destination
r10
r11
source
r9
171
la pile
0x1000c
0x10008 3
0x10004 2
pile ascendante A
0x10000 1
0x0fffc
0x0fff8
0x0fff4
0x1000c
0x10008
0x10004
pile descendante D
0x10000 1
0x0fffc 2
0x0fff8 3
0x0fff4 172
la pile
On parle de pile pleine F (full stack) si le pointeur de pile (sp) pointe sur
le dernier lment qui a t empil
selon les options choisies pour dfinir la pile (A, D, F, E) les instructions
pop et push sont codes diffremment
173
oprations sur la pile
Mode
description pop =LDM push =STM
adressage
full
FA LDMFA LDMDA STMFA STMIB
Ascending
full
FD LDMFD LDMIA STMFD STMDB
descending
empty
EA LDMEA LDMDB STMEA STMIA
ascending
empty
ED LDMED LDMIB STMED STMDA
descending
174
exemple
r1 = 0x00000002
r4 = 0x00000003
sp = 0x00080014
STMFD sp!, {r1,r4}
avant aprs
175
exemple
r1=0x00000002
r4=0x00000003
sp=0x00080010
STMED sp!, {r1,r4}
avant aprs
176
attributs
les attributs respecter pour une pile sont
ladresse de base
le pointeur de pile
ladresse limite de la pile (stack limit)
pour une pile descendante, par exemple, le code suivant vrifie que la
pile reste dans la limite, sinon appel une routine _stack_overflow
SUB sp, sp, #size attention valeur immdiate sur 8 bits
CMP sp, r10 registre r10 stack limit sl
BLLO _stack_overflow
177
exemples - remarques
le signe ^ modifie le comportement des instructions. Le processeur ne
doit pas se trouver en mode utilisateur ou systme (par exemple lors
du traitement dune interruption).
Dans ce cas les registres qui apparaissent dans la liste sont les
registres en mode utilisateur. Si le pc est dans la liste, le spsr est copi
dans le cpsr
178
Instruction swap
Linstruction swap est une instruction du type load/store spcialise.
Elle permute le contenu dune position mmoire avec le contenu dun
registre. Linstruction est atomique, cest--dire que les cycles de
lecture et dcriture seffectuent pendant le mme cycle bus. Aucune
instruction peut modifier le registre ou la position mmoire avant la fin
de linstruction, le systme garde le contrle du bus.
tmp = mem32[Rn]
permute les mots dune position mmoire et
SWP mem32[Rn] = Rm
dun registre
Rd = tmp
tmp = mem8[Rn]
SWPB permutation dun byte mem8[Rn] = Rm
Rd = tmp 179
exemple
mem32[0x9000] = 0x12345678
r0 = 0x00000000
r1 = 0x11112222
r2 = 0x00009000
mem32[0x9000] = 0x11112222
r0 = 0x12345678
r1 = 0x11112222
r2 = 0x00009000
180
exemple
Linstruction swap permet dimplmenter un mcanisme de smaphore
pour grer laccs une ressource partage.
algorithme:
ladresse smaphore contient #1 si la ressource est dj utilise et ne peut
pas tre accde.
Si la ressource peut tre accde ladresse smaphore contient une autre
valeur.
Une tche doit donc tester la valeur contenue ladresse smaphore et
rserver laccs la ressource si elle est disponible.
Le test et la modification de la valeur doit seffectuer de manire atomique
cest--dire sans quaucune tche puisse accder la valeur pendant la
lecture et lcriture de la valeur (situation idem celle discute avec les
interruptions)
181
exemple
1er processus 2me processus
lecture de la valeur
valeur = 0x0 ok ressource
accessible commutation de tche
lecture de la valeur
valeur = 0x0 ok ressource
accessible
criture 0x1 ladresse
smaphore pour rserver
la ressource (trop tard)
temps 182
exemple - smaphore
Le code correct pour implmenter un smaphore
spin
MOV r1, smaphore r1 contient ladresse
MOV r2, #1 valeur tester
SWP r3, r2, [r1] place #1 ladresse + r3
CMP r3, #1 est-ce que la ressource est ok
BEQ spin
183
Instruction dInterruption logicielle
Les interruptions logicielles sont un mcanisme utilis par exemple par
les applications pour faire des appels aux routines du systme
dexploitation.
184
exemple
cpsr = n z c V q i f t_user
pc = 0x00008000
lr = 0x003fffff; lr = r14
r0 = 0x12
SWI 0x123456
cpsr = n z c V q I f t_svc
spsr = n z c V q i f t_user
pc = 0x00000008
lr = 0x00008004 pas de sauvegarde ncessaire
r0 = 0x12 paramtre, le registre r0 nest pas
modifi
185
exemple - suite
les registres peuvent tre utiliss pour passer des paramtres la
routine dinterruption
31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1
187
Remarque sur lexcution
Lorsque le processeur excute linstruction
SWI SWI_number
Lexception correspondante (SWI) est leve et le processeur change la
valeur du pc par 0x8, la valeur correspondante dans la table
dinterruption. Il va donc excuter cette instruction qui est dans notre
cas une instruction
B SWI_handler.
Cette instruction ne modifie pas le link register (lr) et donc lr pointe sur
linstruction qui suit linstruction SWI.
188
instructions et cpsr
Le jeu dinstruction ARM met disposition deux instructions pour
contrler le registre cpsr. Il sagit dinstructions qui permettent de
sauver et restaurer le contenu du registre dtat. En mode utilisateur les
bits peuvent tre lus et seulement le champ flag peut tre modifi.
= psr
Syntaxe: MRS{<cond>} Rd, <cpsr | spsr>
MSR{<cond>} <cpsr | spsr>_<fields>, Rm
MSR{<cond>} <cpsr | spsr>_fields, #immediate
psr[field]189
=
MSR copie une valeur immdiate (partiellement) vers un psr
immdiate
exemple - cpsr
cpsr = n z c v q I F t_SVC
cpsr = n z c v q i F t_SVC
les diffrents champs sont
31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0
N Z C V I F T mode
190
instructions coprocesseur
les instructions coprocesseur tendent le jeu dinstruction du
processeur. Le coprocesseur peut fournir des ressources de calculs
supplmentaires ou contrler la mmoire du systme (mmoire cache
et gestionnaire de mmoire).
191
LDR Rd, #imm_32
Les instructions ARM sont codes sur 32 bits, il est donc impossible de
coder une valeur immdiate sur 32 bits charger dans un registre.
Lassembleur ARM propose nanmoins des pseudo-instructions.
LDR charge une valeur immdiate sur 32 bits Rd = constante sur 32 bits
LDR r0, =0xff devient MOV r0, #0xff valeur immdiate sur 8 bits
193
instructions conditionnelles
Lintrt des instructions conditionnelles est de rduire les instruction
de rupture de squence qui pnalisent le bon fonctionnement du
pipeline.
194
instructions conditionnelles
ce qui peut scrire en assembleur (r1 est a et r2 est b)
gcd
CMP r1, r2
BEQ complete
BLT lessthan
SUB r1, r1, r2
B gcd
lessthan
SUB r2, r2, r1
B gcd
complete
195
instructions conditionnelles
ou encore
gcd
CMP r1, r2
SUBGT r1, r1, r2
SUBLT r2, r2, r1
BNE gcd
196
Cache
Vitesse dun processeur ~ 1GHz, temps de cycle 1 nanosecondes
(=10^-9 secondes)
Mmoire
cache 0x
0xDD30003F
0xDD30003F
0x...
199
Cache
principe de fonctionnement
Les performances de lutilisation de la mmoire cache dpendent des
chance de succs (cache hit) et donc de lalgorithme de remplacement
des donnes en mmoire cache. Pour comprendre comment
seffectuent les accs en mmoire on effectue un grand nombre dtude
statistique sur des programmes choisi.
On observe:
1. Lorsquune instruction rfrence une adresse il est trs probable
que les prochains accs soit dans un voisinage de cette adresse.
Par exemple, accs un tableau, les instructions sont disposes
squentiellement en mmoire. Cest le principe de localit
spatiale.
2. Lorsque le processeur rfrence un mot donn, il est trs probable
que ce mot soit rfrenc dans les instants qui suivent. Cest le
principe de localit temporelle
201
Exemple Cache direct
On suppose quon dispose dune mmoire centrale dune capacit de
10000 mots, les adresses voluent donc de 0000 9999. On
dcompose ladresse en ltiquette, lindex et loffset. Par exemple,
ladresse 0215 est dcompos en :
02 = ltiquette Lindex Loffset
1 = lindex Ltiquette
5 = loffset 02 1 5
202
Lindex Mmoire centrale
Ltiquette Loffset
00 0 0
02 1 5
00 1 0
00 2 0
cl 00 3 0
0 0 01
1 1 02 A B C D E F G H I J
2 0 02
02 0 0
3 0 02 02 1 0 A B C D E F G H I J
4 0 00 02 2 0
02 3 0
5 0 99
6 0 03
7 0 00
8 0 99 99 9 0
9 0 04
adresses donnes
Rpertoire Mmoire cache 203
bit validit Comparateur
Cache direct
pseudo-code
204
Cache direct
exemple
En supposant que la mmoire cache est dans ltat indiqu sur le
prcdent transparent, on dsire accder successivement les
adresses:
0215 succs (cache hit) la donne est transfre depuis la mmoire
cache
0212 re-succs
0114 chec (cache miss) on modifie lentre de la mmoire cache qui
correspond lindex 1
0225 chec, cause du bit de validit (=0), chargement de la ligne
0116 succs
On observe que toutes les adresses du type 011x, 021x, 031x, etc
donnent lieu des collisions car elles utilisent le mme index.
205
Cache purement associative
Ces mmoires caches utilisent autant de comparateurs que de lignes
de cache, ce qui permet de supprimer lindex dans le rpertoire.
206
Ltiquette Loffset Mmoire centrale
0000
023 5
0010
0020
0030
0 001
1 003
2 022
0200
cl 3 0210
4 023 A B C D E F G H I J 0220
0230 A B C D E F G H I J
5
6
7 000
8 998 9990
9
adresses donnes
Rpertoire Mmoire cache 207
validit
Comparateurs
Mmoire cache associative
pseudo-code
si rpertoire contient ltiquette & bit de validit alors
transfrer la donne vers le processeur depuis la mmoire
cache
sinon
si rpertoire est plein alors
appliquer un algorithme pour choisir une ligne
modifier la valeur de la ligne choisie en mmoire cache
avec les donnes qui se trouvent en mmoire centrale
transfrer les donnes vers le processeur
sinon
choisir une ligne vide et transfrer les donnes
correspondantes depuis la mmoire centrale
transfrer les donnes vers le processeur
finsi
finsi 208
Mmoire cache associative
Ce type de mmoire est plus couteux que la mmoire cache directe,
principalement cause des comparateurs
209
Localisation des caches
On distingue trois niveau de mmoire cache
1. Un cache de petite capacit, trs rapide intgr au
processeur
capacit
vitesse
3. La mmoire centrale
210
cache de niveau 2
cache de niveau 1
Mmoire centrale
processeur cache de niveau 3
SRAM
instruction DRAM
donnes
211
Conclusion mmoire cache
Les mmoires caches permettent damliorer les performances dun
systme informatique en rduisant les temps daccs (lecture/criture)
en mmoire centrale
212
Retour sur les mmoires caches
Les systmes ARM propose des mmoires caches. On se propose de
passer en revue les diffrents systmes. On dtaillera aussi certains
mcanismes suggrs au dbut du cours.
213
Hirarchie
Processeur registres
Tightly coupled
memory (TCM) write buffer
cache L1
SRAM
DRAM
FLASH mmoire non volatile
Mmoire externe
214
Hirarchie
La mmoire TCM se trouve sur le chip.
216
Transferts
accs direct la mmoire Mmoire
Processeur centrale
lent
transferts
rapide block
Cache
lent
rapide Mmoire
Processeur
centrale
Write
buffer lent
217
Caches virtuels
Certains systmes disposent dun circuit MMU, Memory Management
Unit, qui soccupe de traduire les adresses (virtuelles) manipules par
le processeur en adresse physique. La mmoire cache peut-tre
place soit
218
Architecture de base
Larchitecture de cache de base propose pour les systmes ARM est un cache
accs direct.
cache line
Miss
31
Tag
Set
Index Cache Tag v d word3 word2 word1 word0
4
3
Data 219
Index
Architecture de base
Comme prcdemment, le Set Index (bits 4-11) pointe sur une entre
de la mmoire cache et le Tag (bits 12-31) est compar avec lentre
de la cache.
220
Fonctionnement
On a vu que les transferts entre la mmoire centrale et la mmoire
cache taient raliss par blocks, (4 mots de 32 bits).
221
Fonctionnement
Lorsquune ligne de la mmoire cache est valide et quon doit la
remplacer, les mmoires cache accs direct peuvent tre inefficace.
222
Fonctionnement
Avec les routines routineA() et routineB() qui se trouvent aux adresses
223
Mmoire associative
Pour palier ce problme, on utilise des mmoires caches accs indirect qui
stocke les entres Cache Tag dans une mmoire associative.
Une solution intermdiaire propose pour les systmes ARM, est de mettre
disposition quatre structures de mmoires cache pour chaque valeur de
lindice (Set Index). On divise le nombre dentre de la mmoire cache par 4,
mais on contourne le problme mentionn prcdemment. Cette solution limite
la complexit du circuit par rapport une mmoire cache associative.
31 10 9 4 3 1
224
Miss
31
v Cache
Cache TagCache Tag Tag
v d
d word3 v d word3
word3
word2 word1 word2
word2 word0 word1
word1 word0
Cache Tag
Cache Tag v d v d word3
word3 word2 word2
word1
4 Cache Tag v d word3 word2 word1 word0
3
Cache Tag
Cache Tag v d v d
word3 word3
word2 word2
word1
Cache Tag v d word3 word2
225
ARM940T - cache
Ce processeur dispose dune mmoire cache qui met en parallle 64
structure de mmoire cache. Chaque structure de mmoire cache
(way) dispose de 4 entres, lindice (SetI Index) est cod sur 2 bits, et
utilise une mmoire associative.
226
ARM940T - cache
31
227
Stratgie dcriture
Les stratgie dcriture des systmes de mmoire caches ARM sont
classiques:
Writethrough: Chaque criture dans la mmoire cache est reproduite
en mmoire centrale. La cohrence est assure en permanence.
228
Stratgie de remplacement des
lignes
Principalement deux stratgies:
Round-robin: La mmoire cache gre un pointeur qui est la prochaine
ligne remplacer. Le pointeur est incrment dune unit chaque
remplacement (modulo le nombre de ligne)
229
Stratgie dallocation des lignes
Pour lallocation des lignes, il y a aussi deux stratgies possibles:
230
ARM720T Writethough Random Read-miss
ARM740T Writethough Random Read-miss
ARM920T Writethough, writeback Random, Read-miss
round-robin
ARM940T Writethough, writeback Random Read-miss
ARM926EJS Writethough, writeback Random , Read-miss
round-robin
ARM946E Writethough, writeback Random , Read-miss
round-robin
ARM10202E Writethough, writeback Random , Read-miss
round-robin
ARM1026EJS Writethough, writeback Random , Read-miss
round-robin
Intel Writeback Round-robin Read-miss
StrongARM
Intel XScale Writethough, writeback Round-robin Read-miss,write-
miss
231
Fonctionnement par lexemple
Le cur ARM940T propose les deux stratgies de remplacement
alatoire et round-robin.
_asm {
timesloop:
MOV newstart, start
MOV setcount, numset
setloop:
LDR value, [newstart, #0]
ADD newstart, newstart, #0x40
SUBS setcount, setcount, #1
BNE setloop
SUBS times, times, #1
BNE timesloop
}
return value;
}
233
Rsultats
Avec numset = 64 et Round-Robin : 0.51 secondes
234
Programmation efficace en C
235
Introduction
La programmation bas-niveau des systmes ce fait en assembleur et
souvent en C. Programmer en C ncessite lutilisation dun compilateur
qui doit tirer parti de la structure particulire du processeur et de son
jeu dinstruction pour gnrer du code aussi adapt que possible, cest-
-dire:
236
Types de donnes en C
Comment le compilateur utilise les ressources du processeur pour
dfinir les types de donnes C en assembleur et quels types sont plus
avantageux que les autres.
237
Types de donnes en C
Type de donne C taille
238
Type de donnes en C
ATTENTION: les compilateurs C dfinissent habituellement le type
char comme une donne signe sur 8 bits alors que les compilateur
gcc utilise le type non sign pour les caractres.
Ceci car les premires version du proc. ARM ne pouvait pas manipuler
facilement les donnes 8 bits signe (portabilit du code.).
239
Instruction load/store
Pre-ARMv4 LDRB charge une valeur 8 bits non signe
241
Variables locales
Les instructions ARM portent gnralement sur des donnes 32 bits.
Les variables locales doivent de prfrence tre de type int ou long.
Les types char ou short doivent tre vits. Si on travail en utilisant une
arithmtique modulo 256 (255+1=0) alors ce sont les bons types a
utiliser.
242
Exemple 1
int checksum_v1(int *data)
{
char i; // hypothse fausse: un char occupe moins de place
//car les registres sont 32 bits ainsi que les entres de la pile
int sum=0;
243
Exemple 1
code assembleur (i est du type char)
checksum_v1
MOV r2, r0 ; r2 = data
MOV r0, #0 ; sum = 0
MOV r1, #0 ;i=0
checksum_loop
LDR r3, [r2, r1, LSL #2] ; r3 = data[i]
ADD r1, r1, #1 ; r1 = i + 1
AND r1, r1, #0xff ; i = (char) r1
CMP r1, #0x40 ; le paquet contient 64 mots
ADD r0, r3, r0 ; sum += r3
BCC checksum_loop ; if (i<64) loop
MOV pc, r14
244
Exemple 1
code assembleur (i est du type int)
checksum_v2
MOV r2, r0 ; r2 = data
MOV r0, #0 ; sum = 0
MOV r1, #0 ;i=0
checksum_loop
LDR r3, [r2, r1, LSL #2] ; r3 = data[i]
ADD r1, r1, #1 ; r1 = i + 1
CMP r1, #0x40 ; le paquet contient 64
mots
ADD r0, r3, r0 ; sum += r3
BCC checksum_loop ; if (i<64) loop
MOV pc, r14
245
Exemple 2
les donnes sont sur 16 bits
246
Exemple 2
code assembleur (les donnes a additionner sont sur 16 bits)
checksum_v3
MOV r2,r0 ; r2 = data
MOV r0,#0 ; sum = 0
MOV r1,#0 ;i=0
checksum_loop
ADD r3,r2,r1,LSL #1 ; r3 = &data[i]
LDRH r3,[r3,#0] ; r3=data[i] pas doffset autorise
ADD r1,r1,#1 ; i++
CMP r1,#0x40 ; compare i, 64
ADD r0,r3,r0 ; r0 = r0 + r3
MOV r0,r0, LSL #16
MOV r0,r0,ASR #16 ; sum = (short)r0 extension du signe
BCC checksum_loop
MOV pc,r14
247
Exemple 2
Linstruction LDRH ne permet pas tous les modes dadressages de
linstruction LDR (pr index, registre doffset et dcalage), la premire
instruction ADD calcule ladresse de la donne. (la solution consiste
incrmenter un pointeur sur le tableau, c.f. aprs)
Les donnes additionner sont du type short (16 bits signes) et les
additions de type 32 bits signes. Pour convertir 32 bits signs-> 16
bits signs le compilateur utilise deux instructions. Un premier dcalage
gauche (16 bits) pour enlever linformation contenue dans les bits de
poids fort du registre et un dcalage (16 bits) vers la droite pour
tendre le signe (en utilisant une variable de type int pour la somme
on supprime ces instructions, la conversion seffectue une seule fois
lorsque lon quitte la fonction)
248
Extension du signe
Les instructions
MOV r0,r0, LSL #16
MOV r0,r0,ASR #16
effectuent lextension du signe de la donne (signe) sur 16 bits aux 32 bits du
registre. En effet (exemple sur 8 bits), on considre une valeur -3 code sur 4
bits et tendue 8 bits.
-3 = -(0011) = 1101 la dernire galit utilise le complment deux
249
Finalement
short checksum_v4(short *data)
{
unsigned int i;
int sum = 0;
for(i=1; i<64; i++)
{
sum+=*(data++);
}
return (short) sum;
}
250
Finalement
checksum_v4
toujours mise jour de r0 (voir
MOV r2, #0
la diffrence avec pr index et !)
MOV r1, #0
checksum_loop
LDRSH r3,[r0],#2 ; post index immdiat r3=*(data++)
ADD r1,r1,#1 , i++
CMP r1,#0x40 ; i<64?
ADD r2,r3,r2 ; sum+=data[i]
BCC checksum_v4
MOV r0,r2, LSL #16
MOV r0,r0,ASR #16 ; r0 = (short)sum
MOV pc,r14 ; return
251
Variables locales Arguments de
fonctions
Convertir les variables locales de types char ou short en des variables
de type int augmente les performances et diminue la taille du code.
exemple:
short add_v1(short a, short b)
{
return a+(b>>1);
}
252
Arguments de fonctions
Les arguments a et b ainsi que la valeur de retour sont passs en
arguments la fonction en utilisant les registres (32 bits).
255
Type sign/non sign
faut-il choisir signed int ou unsigned int ?
Si le programme utilise des additions, soustractions et des
multiplications, il ny a pas de diffrences.
256
Type sign/non sign
average_v1
ADD r0,r0,r1 ; r0 = a + b
ADD r0,r0,r0,LSR #31 ; if (r0<0) r0++
MOV r0,r0,ASR #1 ; r0 = r0 >> 1
MOV pc,r14
On doit tester si r0<0 avant de dcaler droite (diviser par deux) car
lopration de dcalage droite ne correspond pas une division par
deux si le nombre est sign et ngatif.
En effet: -3 = 1101, -3>>1 = 1110 = -2 mais la division -3/2 doit donner
-1 (on divise en arrondissant vers 0 comme on le fait pour les nombres
positifs)
Si cest possible il faut prfrer les entiers non sign ds que les
divisions sont utilises
257
Rcapitulations
1. les variables locales qui se trouvent dans les registres doivent de
prfrences tre de type int (sign ou non).
2. pour les variables globales, les tableaux qui se trouvent en
mmoire il faut prfrer le type qui utilise le moins de place
possible. Les donnes doivent tre parcourues en modifiant un
pointeur sur la structure.
3. Utiliser des casts (int), (short) explicite dans les programmes
lorsque lon assigne une variable locale ou crit la valeur dune
variable locale en mmoire (cast troit explicite).
4. il faut viter de laisser le compilateur effectuer des changements
de types implicites. Utiliser des options de compilations pour
signaler le casts implicites.
5. Eviter dutiliser les types char et short pour les arguments de
fonctions et les valeurs de retour.
258
Les boucles
Boucles avec un nombre fixe ditrations:
retour sur le calcul de la somme de contrle
code C optimal
int check_sum(int *data)
{ unsigned int i;
int sum=0;
for(i=0; i<64; i++)
{
sum+=*(data++);
}
return sum;
}
259
Les boucles
compilation assembleur
checksum_v5
MOV r2,r0 ; r2=data
MOV r0,#0 ; sum=0
MOV r1,#0 ; i=0
checksum_v5_loop
LDR r3,[r2],#4 ; r3=*(data++)
ADD r1,r1,#1 ; i++
CMP r1,#0x40 ; compare i, 64
ADD r0,r3,r0 ; sum += r3
BCC checksum_v5_loop
MOV pc,r14 ; return sum
trois instructions pour implmenter la boucle 260
Les boucle en assembleur ARM
Deux instructions sont suffisantes pour implmenter une boucle:
1. Une soustraction pour dcrmenter le compteur de boucle avec
mise jour du registre cpsr (en particulier le bit C)
2. Une instruction conditionnelle de branchement
261
Exemple
code C
int checksum_v6(int *data)
{
i est non sign, alors la
unsigned int i; condition (i>0) est quivalente
int sum=0;
for(i=64; i!=0; i--)
{
sum+=*(data++);
}
return sum;
}
262
Exemple
code assembleur
checksum_v6
MOV r2,r0 ; r2=data
MOV r0,#0 ; sum = 0
MOV r1,#0x40 ; i = 64
checksum_loop
LDR r3,[r2],#4 ; r3 = *(data++)
SUBS r1,r1,#1 ; i-- + mise--jour cpsr
ADD r0,r3,r0 ; sum+=r3
BNE checksum_loop ; si (i!=0) boucle
MOV pc,r14 ; return sum
SUB r1,r1,#1 r1
CMP r1,#0
BGT loop branch si r1>0
264
Compteur sign/non sign
Le compilateur se mfie du cas ou i= 0x80000000
265
Boucles avec un nombre variable
ditrations
code C
int checksum_v7(int *data, unsigned int N)
{
int sum = 0; compteur non sign
for(; N!=0; N--)
{ le compteur est dcrment vers 0
sum +=*(data++); (2 instructions assembleur pour la boucle)
}
return sum; on incrmente le pointeur
}
266
Boucles avec un nombre variable
ditrations
code assembleur
checksum_v7
MOV r2,#0 ; sum = 0
CMP r1,#0 ; compare N, 0
BEQ checksum_v7_end
checksum_v7_loop
LDR r3,[r0],#4 ; r3 = *(data++)
SUBS r1,r1,#1 ; N- - + mise--jour de cpsr
ADD r2,r3,r2 ; sum += r3
BNE checksum_v7_loop
checksum_v7_end
MOV r0,r2 ; r0 = sum
MOV pc,r14
267
Boucle avec un nombre variable
ditrations
Le compilateur test que le compteur N est plus grand que 0 avant
deffectuer une premire boucle. Si le programmeur est certain que
cette valeur est >0 alors il faut utiliser une structure do-while
268
Boucle avec un nombre variable
ditrations
do-while, code assembleur:
checksum_v8
MOV r2,#0
checksum_v8_loop
LDR r3,[r0],#4 ; r3 = *(data ++) Xcycles
SUBS r1,r1,#1 ; N- - 1 cycle
ADD r2,r3,r2 ; sum += r3 1 cycle
BNE checksum_v8_loop ; if (N!=0) 3 cycles
MOV r0,r2 ; r0 = sum
MOV pc,r14 ; return
269
Technique de droulement des
boucles
Une boucle coute deux instructions une soustraction et un
branchement conditionnel.
270
Droulement des boucles
On suppose que le nombre de paquets N est un multiple de 4
int checksum_v9(int *data, unsigned int N)
{
int sum = 0;
do {
sum += *(data++);
sum += *(data++);
sum += *(data++);
sum += *(data++);
N -=4;
} while (N != 0);
}
271
Droulement des boucles
pour le code assembleur de checksum_v8 le traitement du corps de la
boucle sexcute en X + 5 cycles.
272
Droulement des boucles
seules les boucles qui sont frquemment utilises sont susceptibles
dtre droule, sinon on augmente la taille du code sans gain de
performance significatif
il faut considrer aussi la taille du corps de la boucle. Plus le corps
de la boucle est grand moins les pertes dues la gestion de la
boucle (4 cycles) sont importants et plus la duplication du code
augmente la taille totale du code. De plus, ca diminue les
performances de la mmoire cache. Gnralement, si drouler une
boucle augmente les performances de moins de 1%, la technique
nest plus efficace.
si le nombre total ditrations excuter nest pas un multiple
constant de 2, 4, etc. on peut drouler une partie du code et faire le
reste en ajoutant des instructions (sans boucles)
273
Droulement des boucles
code C
int checksum_v10(int *data, unsigned int N)
{
unsigned int i;
int sum = 0;
for (i=N/4; i!=0; i--)
{
sum+=*(data++); sum+=*(data++);
sum+=*(data++); sum+=*(data++);
}
for(i=N&3;i!=0;i--) // & oprateur et sur les bits, positionne tous les
sum+=*(data++); // bits 0 except le deux premiers
return sum;
}
274
Boucles - rsum
les compteurs doivent tre dcrments vers 0 pour viter que le
compilateur utilise un registre pour mmoriser le nombre ditrations
et effectuer la comparaison avec zro (gratuit)
les compteurs de boucles sont non signs, les conditions de
terminaisons (i!=0) et (i>0) sont quivalentes (il faut viter la
situation ou le compteur dmarre a 0x80000000 et passe a
0x7FFFFFFF)
utiliser un do-while de prfrence un for pour viter un test au
dbut de la boucle
drouler le boucles si cest efficace
prfrer les structures de donnes qui gnrent des tableaux
multiples de 2, 4, etc. et qui permettent le droulement des boucles
275
Allocation des registres
Le compilateur essaye dallouer un registre par variable locale dclare
(utilise) dans une fonction C. Si plusieurs variables ne sont pas
utilises simultanment, le compilateur utilise le mme registre pour
ces variables.
276
Convention
Le passage des paramtres en C utilise les conventions suivantes
concernant lusage des registres
277
Convention
r12: un scratch register , la fonction peut lutiliser sans ce soucier de
le restaurer.
278
Convention
Si le compilateur doit utiliser la pile, il le fait pour les variables le moins
frquemment utilises.
279
Appels de fonctions - arguments
ARM dfini un standard pour lappel des procdures: ARM Procedure
Call Standard (APCS), qui dfinit comment les arguments sont passs
aux fonctions et comment sont gres les valeurs de retour.
Les autres arguments entiers (pointeurs) sont placs sur la pile (full
descending) de manire croissante avec la mmoire
r3 argument 3
sp+12 argument 7
r2 argument 2
sp+8 argument 6
r1 argument 1
sp+4 argument5
sp argument 4 r0 argument 0 280
valeur retour
Appels de fonctions - arguments
Les arguments cods sur deux mots tel que les double ou long long
sont passs dans deux registres conscutifs et retourn dans r0, r1
281
Exemple
Une routine qui permet dinsrer des caractres dans une file dattente
(tampon circulaire).
0xyyyyyyyy data
0xyyyyyyyy
0xyyyyyyyy
N donnes
0xyyyyyyyy
0xyyyyyyyy
282
Exemple
occup occup occup occup libre libre libre libre
0xyyyyyyyy
0xyyyyyyyy data
0xyyyyyyyy
N donnes
0xyyyyyyyy
0xyyyyyyyy
283
Code C
char *queue_bytes_v1(char *Q_start, char *Q_end, char *Q_ptr, char *data,
unsigned int N)
{
do {
*(Q_ptr++)=*(data++);
if (Q_ptr==Q_end) Q_ptr=Q_start;
} while (--N)
return Q_ptr;
}
285
Utilisation dune structure
typedef struct {
char *Q_start, *Q_end, *Q_ptr;
} Queue;
287
utilisation dune structure-
code assembleur
queue_bytes_v2
STR r14, [r13, #-4] sauvegarde lr sur la pile
LDR r3, [r0, #8] r3 = queue->Q_ptr
LDR r14, [r0, #4] Q_end
queue_v2_loop
LDRB r12, [r1], #1 r12 = *(data++)
STRB r12, [r3], #1 *(Q_ptr++) = r12
CMP r3, r14 if (Q_ptr == Q_end)
LDREQ r3, [r0, #0] Q_ptr = queue->Q_start
SUBS r2, r2, #1 --N et mise a jour du cpsr
BNE queue_v2_loop if (N!=0) goto loop
STR r3, [r0, #8] queue->Q_ptr = r3
LDR pc, [r13], #4 return
288
Autres stratgies
Lorsquune fonction utilise peu de variables locales ou/et que le code
gnr par la fonction est petit le compilateur peut procder des
optimisations si le code de la fonction se trouve dans le mme
fichier que le code des fonctions appelantes
289
Exemple 2
une fonction uint_to_hex converti une entier 32 bits en une chane de
caractres de 8 caractres hexadcimaux.
290
Exemple 2 code assembleur
uint_to_hex
MOV r3, #8 ; i=8
uint_to_hex_loop
MOV r1, r1, ROR #28 ; rotation 4 bits gauche
AND r2, r1, #0xf ; r2 = in & 15
CMP r2, 0xa ; if (r2>=10)
ADDCS r2, r2, #0x41 ; r2 += A 10 non sign
ADDCC r2, r2, #0x30 ; r2 += 0 non sign
STRB r2, [r0], #1 ; *(out++)=r2
SUBS r3, r3, #1 ; i-- + mise--jour du cpsr
BNE uint_to_hex_loop ; if (i!=0) goto loop
MOV pc, r14 ; return
291
Exemple 2 code assembleur
Lappel la fonction nybble_to_hex t supprimer et la fonction
insrer dans le corps de la routine appelante (inline)
292
aliasing - pointeur
Le terme aliasing rfre la situation ou plusieurs pointeurs pointent
sur la mme adresse. Lorsque plusieurs pointeurs sont utiliss, le
compilateur doit toujours suspecter que la valeur pointe par un
pointeur t modifie mme si ce pointeur na pas t utilis.
exemple:
293
code assembleur
timer_v1
LDR r3, [r0,#0] ; r3 = *timer1
LDR r12, [r2,#0] ; r12 = *step
ADD r3, r3, r12 ; r3 += r12
STR r3, [r0, #0] ; *timer1 = r3
lcriture pu modifier
LDR r0, [r1, #0] ; r0 = *timer2 le contenu de [r2]
LDR r2, [r2,#0] ; r2 = *step aliasing possible
ADD r0, r0, r2 ; r0 += r2
STR r0, [r1, #0] ; *timer2 = r0
MOV pc, r14
294
structures
Linstruction LDR supplmentaire est un accs la mmoire externe,
viter. La solution consiste utiliser une variable locale
295
structures
ATTENTION, le code suivant gnre aussi une instruction supplmentaire,
mme si des structures sont utilises
296
Exemple 2
int checksum(void)
{ int *data; int N, sum=0;
data = get_next_packet(&N);
do {
sum += *(data++);
} while(--N);
}
le compilateur doit prendre en compte
que les deux pointeurs peuvent pointer
sur la mme donne (aliasing)
297
Exemple2 - assembleur
checksum
STMFD r13!, {r4, r14} sauvegarde r4, lr sur la pile
SUB r13, r13, #8 cre deux variables sur pile
ADD r0, r13, #4 r0 = &N pour appel proc.
MOV r4, #0 sum = 0
BL get_next_packet
checksum_loop
LDR r1, [r0], #4 r1 = *(data++)
ADD r4, r1, r4 sum += r1
LDR r1, [r13, #4] r1 = N depuis la pile!
SUBS r1, r1, #1 r1 et mise jour cpsr
STR r1, [r13, #4] N=r1 criture sur la pile !
BNE checksum_loop
MOV r0, r4 r0 = sum
ADD r13, r13, #8 supprime les variables sur pile
LDMFD r13!, {r4, pc} 298
exemple 2 - remarque
Le compilateur rserve de la place pour deux variables sur la pile et en
utilise une seule..
299
aliasing recommandations
Il faut utiliser des variables locales pour viter que le compilateur
considre des donnes identiques comme diffrentes
Il faut viter daccder une variable locale par son adresse pour viter
quelle se trouve sur la pile. Si cest ncessaire il faut dfinir une
nouvelle variable locale et copier la valeur utile.
300
Alignement
Lorganisation des structures composes peut avoir des consquences sur les
performances du code gnr par le compilateur.
Les donnes accdes par les instructions load/store doivent tre alignes.
Jusqu la version ARMv5TE, on a les restrictions
301
Alignement
Pour respecter ces contraintes, le compilateur ajoute des champs non utiliss
(pad) dans les structure de donnes composes.
Exemple:
struct {
+3 +2 +1 +0
char a;
int b; +0 pad pad pad a
302
Alignement
Pour optimiser loccupation de la mmoire on doit rordonner la dfinition de la
structure.
struct {
char a;
char c;
short d;
int b;
}
(little endian)
+3 +2 +1 +0
+0 d[15,8] d[7,0] c a
303
Alignement
Certain compilateur dispose doption pour rduire la taille des donnes en
mmoire en supprimant les bits de padding. Pour le compilateur armcc, cest le
mot cl _packed, qui ne produit pas toujours une organisation optimale
_packed struct{
char a; +3 +2 +1 +0
int b; +0 b[23,16] b[15,8] b[7,0] a
char c; +4 D[16,8] d[7,0] c b[31,24]
short d;
+8 libre libre libre libre
}
304
Champs de bits
En C on peut dfinir des boolens en utilisant un seul bit de donne en
mmoire.
typedef struct {
unsigned int StageA : 1;
unsigned int StageB : 1; 3 bits en mmoire
unsigned int StageC : 1;
} Stages_v1;
Stages_v1 exemple;
exemple.StageA = 1;
305
Champs de bits
Lordre des bits en mmoire change selon le compilateur.
Souvent le code gnr nest pas optimis.
Exemple:
void dostagesA(void);
void dostagesB(void);
void dostagesC(void);
306
Champs de bits
Void dostages_v1(Stages_v1 *stages) {
if (stages->StageA)
dostageA();
if (stages->StageB)
dostageB();
if (stages->StageC)
dostageC();
}
307
Champs de bits
dostages_v1
STMFD r13!,{r4,r14} La fonction dostageA peut modifier
MOV r4,r0 le champ de bits!
LDR r0,[r0,#0] ; r0 contient le champ de bits
TST r0,#1 ; calcule r0 & #1, test le premier bit
BLNE dostageA
LDR r0,[r4,#0] ; r0 contient le champ de bits
MOV r0,r0,LSL #30
CMP r0, #0
BLLT dostageB
LDR r0,[r4,#0] ; ncessaire
MOV r0,r0, LSL #29
CMP r0,#0
LDMLTFD r13!,{r4,r14} ; return
BLT dostageC
LDMFD r13!,{r4,pc}
309
Champs de bits
void dostages_v2(Stages_v2 *stages_v2) {
Stages_v2 stages = *stages_v2;
310
Champs de bits
dostages_v2
STMFD r13!,{r4,r14}
LDR r4,[r0,#0]
TST r4,#1
BLNE dostageA
TST r4,#2
BLNE dostageB
TST r4,#4
LDMNEFD r13!,{r4,r14}
BNE dostageC
LDMFD r13!,{r4,pc}
311
Champs de bits
En conclusion, pour manipuler des champs de bits il est prfrable
dutiliser des masques.
Exemple: stages |= STAGEA; (enable) stages &= ~STAGEB; (disable)
stages ^= STAGEc; (toggle)
312
Division
Le processeur ARM de dispose pas dinstruction pour le calcul des
divisions. Le temps dexcution des routines des librairies C standards
varie entre 20 et 100 cycles en fonction de limplmentation ou de la
taille des oprandes.
313
Tampon circulaire
Il est plus efficace dcrire
offset += increment;
if (offset >= buffer_size)
offset -= buffer_size;
314
Division signe/non signe
Les routines de division de nombres signs sont implmente en trois
tapes:
315
Division / reste
Les routines des librairies C retournent gnralement le rsultat de la
division et le reste. On utilise cette proprit pour calculer plus
efficacement.
Exemple:
typedef struct { int x; int y; } point;
316
Division / reste
Pour le calcul de p.x, on a voulu viter de calculer une division. En fait,
crire p.x=offset % bytes_per_line; est meilleur, car le calcul de la
premire division retourne aussi le reste.
getxy_v2
STMFD r13!, {r4,r14}
MOV r4, r0
MOV r0, r2
BL _rt_udiv valeurs de retour dans r0, r1
STR r0, [r4, #4]
STR r1, [r4, #0]
LDMFD r13!, {r4,pc}
317
Division / Multiplication
Si un programme effectue souvent la division par un mme
dnominateur, z, il devient efficace de calculer 1/z et de remplacer les
divisions par des multiplications.
Dans tous les cas, on prfre calculer avec des valeurs entires et on
vite les nombres en virgule flottante.
318
Division / Multiplication
Cette approche nous oblige a effectuer une division avec des entiers
sur 64 bits pour le calcul de s, ce qui est long.
Dautre part, si d=1, la valeur mmoriser est aussi sur 64 bits.
s = ( 232 1) =d = 23 2 e1 ; 0 < e1 1
En pratique, on utilise d
exact
Pour calculer la division, on utilise arrondis
q = (unsigned int)( ((unsigned long long)n * s) >> 32);
232
La division par introduit une erreur
q = n s2 32 e2 ; 0 e2 < 1
319
Division / Multiplication
Do: n
q= n e1 2 32 e2 ; 0 n e1 2 32 + e2 < 2
d
(n 2< q n)
On a donc lestimation d d
q = n =d; ou q = n =d 1
n =d 1
320
Division / Multiplication
Exemple: On doit diviser des valeurs entires non signes contenues
dans un tableau.
void scale( unsigned int *dest, unsigned int *src, unsigned int d,
unsigned int N) {
unsigned int s = 0xFFFFFFFFu / d;
do { unsigned int n, q, r;
n = *(src++);
q=(unsigned int)(((unsigned long long)n * s) >> 32);
r = n - q*d;
if (r>=d) q++;
*(dest++)=q;
} while (--N);
} 321
Remarques
La multiplication 64 bits est implmente en utilisant UMUL (maximum
4 cycles).
322
Division constante
Si dans un programme une division par une constante d apparait
souvent, on peut optimiser lexcution en cherchant une valeur de s qui
donne le bon rsultat. On cherche une approximation rationnelle
1 m
= s
d 2N + k
n =d = m n =2N + k ; 0 n < 2N
telle que
On a le rsultat suivant
si 2N + k ds 2N + k + 2k ; al or s n =d = n s
si 2N + k 2k ds < 2N + k ; al or s n =d = n s + s
0 n < 2N
323
Division constante
( n = ( n =d) d + r ; 0 r < d)
En effet,
n r ds 2N + k r 2N + k r+ 1
n s ( n =d) 2N + k = n s 2N + k = n + < 2N + k < 2N + k
d d d d
< 2N 0 : : : 2k
324
Division constante
ds 2N + k ( r + 1) 2N + k
( n + 1) s ( n =d) 2N + k = ( n + 1) +
d d
325
Division constante
2k < d 2k + 1
En pratique, on a N=32, on choisit k tel que et
2N + k + 2k
s = (2N + k + 2 ) =d =
k e; 0 e < 1
d
On a
2N + k + 2k
ds = d ed < 2N + k + 2k
d
2N + k + 2k
ds = d ed 2N + k + 2k d 2N + k + 2k 2k + 1
d | {z }
2k
326
Division constante
Avec ces choix de s et k, un des deux rsultats sapplique toujours.
On calcule donc ds et on implmente la multiplication selon
(
2N + k
ds
< 2N + k
327
Implmentation de la division
On suppose donns n et d et on cherche calculer q=n/d la division
entire et le reste r=n%d.
Supposons quon sache que le quotient q peut tre cod sur N bits.
Une implmentation de la division consiste calculer les N bits de q
successivement.
328
Implmentation de la division
do
{
N--; // on test le bit suivant
if ( (r>>N) >= d) { // si r >= d * (1<<N)
r -= (d<<N);
d += (1<<N);
} while(N);
return q;
}
n = c0 d + c1 2d + c2 4d + c4 8d + : : :
En fait, on dcompose
329
Implmentation de la division
Pour montrer que lalgorithme est correcte, on montre que lexpression
ci-dessous est un invariant dans la boucle
n= qd + r , 0 r < d2N
330
En assembleur
331
332
333
334
Newton-Raphson
Une autre technique qui permet de calculer la division est dutiliser la
mthode de Newton_Raphson.
Cette mthode
f ( x ) =permet
0 de calculer itrativement la racine dune
quation
xn
On suppose quon connait une approximation et on calcule une
meilleure approximation avec la formule
xn + 1 = xn f (xn )
f 0( x n )
335
Newton-Raphson
On2Ncherche
=d calculer n/d. On va calculer une approximation entire de
n =d = n 2N =d=2N
et on calculera
f (x ) = d 2N
La fonction xpossde lapproximation cherche pour
racine. Litration du schma de Newton-Raphson donne
xn + 1 = xn d 2N =x n = 2x n dx 2
n
2n x n 2 2N
336
Racines carres
La mthode de Newton-Raphson est trs gnrale et permet de
calculer toutes les fonctions classiques, racine carre, exponentielle,
sinus, cosinus, .
337
Racines carres
r > 2q
Remarquez que si alors q peut-tre incrment.
( q + 1) 2 = q2 + 2q + 1
Supposons que d soit un entier sur 32 bits. Le rsultat q est cod sur
16 bits et le reste r sur 17 bits.
r n ew 0
Donc, si on effectue la modification
r r 2n ( 2q + 2n )
q q + 2n
338
Racines carres
En C,
q et r contiennent le rsultat
339