Cours SETREX6

Références CPU RISC 16 bits
introduction au MSP 430

● Architecture
■ Documents du cours http://www.setre.info/ introduction au MSP 430
● Architecture R0/PC Program counter
● Périphériques
● Chaîne de développement
■ The mspgcc toolchain: ● Périphériques
● Chaîne de développement R1/SP Stack Pointer
http://mspgcc.sourceforge.net/
■ 28 Instructions sur 16 bits R2/SR/CG1 Status Reg
SETRE: Systèmes Embarqués Temps Réel Processeurs embarqués
Outils GNU pour la compilation ■ Notamment la doc mspgcc (download puis documentation)
Processeurs embarqués
Outils GNU pour la compilation

■ 64 Ko de mémoire adressable R3/CG2 Constant Gen
Un compilateur pour ■ Doc du MSP430 (MSP430x14x family) Un compilateur pour

■ Périphériques mappés en R4 General Purpose
MAB Memory Address Bus

l’embarqué: GCC l’embarqué: GCC R5 General Purpose
mémoire
MDB Memory Data Bus

Tanguy Risset, Antoine Fraboulet ■ Compilation:
.....
Pile d’exécution Pile d’exécution
■ 16 registres 16 bits (r0-r16)
tanguy.risset@insa-lyon.fr ■ David Patterson , John Hennessy Computer Organization ◆ r0: PC (Program counter)
R14 General Purpose
R15 General Purpose
Lab CITI, INSA de Lyon and Design: the hardware software interface ◆ r1: SP (Stack pointeur)
Morgan-Kaufmann, 1998. ◆ r2: SR (status register) Z
dest src
C
■ Wayne Wolf Computers as Components: Principles of ◆ r3: constante 0 V
N
16 bit ALU
Embedded Computing System Design. Un survey assez

complet de toutes les technologies utilisées
R3: Status Register
■ Liens sur le site du cours système embarqués (Master 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0
Recherche): Reserved V SCG1 SCG1

OS− CPU
GIE N Z GC
COFF OFF
http://citi.insa-lyon.fr/~trisset/cours/MasterWeb/
- p. 1/207 - p. 3/207 - p. 5/207
Plan du cours 1 (3H) Architecture du MSP Periphérique intégrés
introduction au MSP 430 ■ architecture du MSP430 introduction au MSP 430

● Architecture
● Architecture
■ timers
Processeurs embarqués ● Périphériques Flash ● Périphériques
■ Rappel d’architecture (processeurs embarqués) ● Chaîne de développement ROM
RAM Peripheral Peripheral
■ contrôleur LCD
Outils GNU pour la compilation Clock Bus 8 bits 8 bits
Un compilateur pour
■ Outils de développement: Compilation et assembleur Processeurs embarqués Ctrl Processeurs embarqués ■ mutliplieur cablé
l’embarqué: GCC Outils GNU pour la compilation Outils GNU pour la compilation ■ contrôleur de bus
Pile d’exécution 16 Adress 8
Un compilateur pour Un compilateur pour
l’embarqué: GCC
RISC−CPU l’embarqué: GCC ■ convertisseur analogique numérique, comparateur
16 bit
JTAG
Pile d’exécution
16
Pile d’exécution ■ ports séries
Data Bus 8
Conv
Watchdog Peripheral Peripheral Peripheral

Timer 8 bits 8 bits
16 bits
- p. 2/207 - p. 4/207 - p. 6/207

Périphérique mappé en mémoire Mapping mémoire Chaîne de développement

● Architecture
■ l’écriture à une certaine adresse est interprétée comme une introduction au MSP 430
● Architecture
■ Interrupt Vector Table: indique les adresses des fonctions de introduction au MSP 430
● Architecture simulation sans périphérique simulation avec périphérique
● Périphériques
communication avec le périphérique. ● Périphériques
gestion des interruption ● Périphériques
Prog.c
■ Exemple : le multiplieur matériel Processeurs embarqués
■ Lors du Boot, le MSP va lire l’adresse 0xFFFE: handler du Processeurs embarqués
Prog.c
◆ Accessible par des registres mappés entre les adresses reset.

Outils GNU pour la compilation Outils GNU pour la compilation Outils GNU pour la compilation
0xFFFF
Un compilateur pour
0x0130 et 0x013F Un compilateur pour Interrupt Vector Table Word/Byte Un compilateur pour
TCP
l’embarqué: GCC
◆ Écriture à l’adresse 0x130, positionne le premier l’embarqué: GCC ■ Sur le MSP430F449: 0xFFE0
l’embarqué: GCC
msp430−gcc msp430−gdb−insight msp430−gcc msp430−gdb−insight
wsim
Pile d’exécution
opérande (unsigned mult) Pile d’exécution ◆ 0x0 à 0x1FF: 0xFFDF Pile d’exécution
Word/Byte
◆ Écriture à l’adresse 0x138, positionne le deuxième périphériques FLASH/ROM
◆ 0x200 à B=0x9FF: RAM debug avec périphériques

opérande et lance le calcul A 1111111111111
0000000000000
0000000000000
1111111111111 Prog.elf
debug
Prog.elf
(2Ko), Données et pile 0000000000000

1111111111111
◆ Le résultat est à l’adresse 0x013A, sur 32 bits 0000000000000
1111111111111
0000000000000
1111111111111
0000000000000
1111111111111
d’exécution 0000000000000
1111111111111
0000000000000
1111111111111
■ Les autres périphériques sont aussi accessibles par des ◆ 0xC00 à 0xFFF: Boot
B 0000000000000
1111111111111
registres mappé en mémoire: les SFR (Special Function RAM Word/Byte
mem. 0x200
Registers), en C: ◆ 0x1000 à 0x10FF: byte
0x1FF
16 bit peripheral Modules
Word
◆ écriture vers le périphérique: SFR = valeur
◆ lecture des registres du périphérique: variable = SFR
info. mem. 0x100
0xFF 6 bit peripheral Modules
◆ A=0x1100 à 0xFFFF: Byte
0x10
ROM (60 Ko): code. 0xF
Special Function Register Byte
0x0
- p. 7/207 - p. 9/207 - p. 11/207
Exemple: multiplieur cablé Chaîne de développement Chaîne de développement

● Architecture int main(void) { introduction au MSP 430
● Architecture
■ Plusieurs configurations introduction au MSP 430
● Architecture
exécution sur la carte
● Périphériques
int i; ● Périphériques ◆ Programmation directe du micro-contrôleur ● Périphériques
Prog.c
● Chaîne de développement ● Chaîne de développement ● Chaîne de développement
int *p,*res; ◆ Simulation avec msp430-gdb-insight (sans les

Processeurs embarqués Processeurs embarqués Processeurs embarqués
int main(void) { périphériques) TCP

Board
int i; __asm__("mov #304, R4"); ◆ Simulation avec msp430-gdb-insight et wsim

Un compilateur pour Un compilateur pour Un compilateur pour msp430−gcc msp430−gdb−insight
l’embarqué: GCC l’embarqué: GCC l’embarqué: GCC
int *p,*res; __asm__("mov #2, @R4"); PC
Pile d’exécution
// p=0x130; Pile d’exécution Pile d’exécution
p=0x130; // *p=2; MSP430 exécution

programme GDB Liaison JTAG Prog.elf
gdb−proxy
*p=2; __asm__("mov #312, R4"); + Insight
p=0x138; __asm__("mov #5, @R4"); GCC
+ port
*p=5; //p=0x138; make parallèle
res=0x13A; //*p=5;
i=*res; __asm__("mov #314, R4");
__asm__("mov @R4, R5");
nop(); //res=0x13A;
i=*res;
}
nop();
- p. 8/207 - p. 10/207 - p. 12/207
}
Contradiction ? Variété des processeurs embarqués
introduction au MSP 430 introduction au MSP 430 ■ Alors d’ou vient la position d’Intel (16% du marché des introduction au MSP 430
● Processeurs embarqués
semi-conducteurs) ? Processeurs embarqués
● Éconnomie
● ISA
● Éconnomie
● ISA
■ processeurs: 2% du silicium, 30% des revenus ● Éconnomie
● ISA
● Pipeline ● Pipeline ● Pipeline
● Classification
● Charactéristiques Processeurs embarqués ● Classification
● Charactéristiques
● Classification
Un compilateur pour Un compilateur pour Un compilateur pour

Pile d’exécution Pile d’exécution Pile d’exécution
■ Les applications sont plus variées que pour les ordinateurs

■ Beaucoup de processeurs embarqués sont des processeurs
de bureau qui n’ont pas percés (MIPS, 68K, SPARC, ARM,
PowerPC)
- p. 13/207 - p. 15/207 - p. 17/207
Part de marché Et au sein des processeurs Architecture "Von Neuman" ou "Princeton"
introduction au MSP 430 ■ Quel est le le microprocesseur le plus vendu ? introduction au MSP 430 ■ 3 milliards de processeurs 8 bits vendus par an (8051, 6805 introduction au MSP 430 ■ La mémoire contient les données et les instructions
Processeurs embarqués ◆ Réponse classique: "Le Pentium: 92% du marché" Processeurs embarqués
etc.) Processeurs embarqués
● Processeurs embarqués ● Processeurs embarqués ● Processeurs embarqués
■ L’unité centrale (CPU) charge les instructions depuis la
● Éconnomie
● ISA
■ Faux!...... ● Éconnomie
● ISA
■ 32 bits (Pentium, Athlon, mais aussi PowerPC, 68000, MIPS, ● Éconnomie
● ISA
mémoire.
● Pipeline ◆ En fait les Pentium ne représentent que 2% des ● Pipeline
ARM etc.) ● Pipeline
● Classification ● Classification ● Classification
■ Un ensemble de registres aide le CPU:
● Charactéristiques microprocesseurs vendus dans le monde. ● Charactéristiques
■ La plupart (98%) sont embarqués (3 fois plus d’ARM vendus ● Charactéristiques
◆ Compteur d’instructions (Program counter: PC),
Outils GNU pour la compilation Outils GNU pour la compilation
que de Pentium) Outils GNU pour la compilation
◆ Registre d’instruction (Instruction register: IR)
◆ Pointeur de pile (stack pointer: SP)

◆ Registres à usage général (Accumulateur: A)
Memory Proc
- p. 14/207 - p. 16/207 - p. 18/207

Architecture Harvard CISC: Complex Instruction Set Computer RISC: Reduced Instruction Set Computer
introduction au MSP 430 ■ Données et instructions dans des mémoires séparées introduction au MSP 430 ■ Une instruction peut designer plusieurs opérations introduction au MSP 430 ■ Petites instructions simples, toutes de même taille, ayant
■ Autorise deux accès simultanés à la mémoire. Processeurs embarqués
élémentaires. Processeurs embarqués
toutes (presque) le même temps d’exécution
● Éconnomie ● Éconnomie Ex: un load, une opération arithmétique et un store, ● Éconnomie
■ Pas d’instruction complexe
● ISA ■ Utilisé pour la plupart des DSP ● ISA ● ISA
● Pipeline
◆ meilleure bande passante
● Pipeline Ex: calculer une interpolation linéaire de plusieurs ● Pipeline
■ Accélération en pipelinant l’exécution (entre 3 et 7 étages de
◆ Performances plus prédictibles ● Charactéristiques valeurs en mémoire. ● Charactéristiques
pipeline pour une instruction) ⇒ augmentation de la vitesse
Outils GNU pour la compilation Outils GNU pour la compilation ■ Accélération par des mécanismes matériels complexes Outils GNU pour la compilation
d’horloge
Un compilateur pour
Instruction Proc Un compilateur pour Un compilateur pour
l’embarqué: GCC l’embarqué: GCC
■ Grandes variations de taille et de temps d’exécution pour les l’embarqué: GCC ■ Code plus simple à générer, mais moins compact
Memory
instructions
■ Tous les microprocesseurs modernes utilisent ce paradigme:
Data
■ Résulte en un code compact mais complexe à générer. SPARC, MIPS, ARM, PowerPC, etc.
Memory ■ Vax, Motorola 68000, Intel x86/Pentium
- p. 19/207 - p. 21/207 - p. 23/207
Le jeu d’instruction Exemple: instructions de l’ISA du Pentium Exemple: instructions de l’ISA du MSP
introduction au MSP 430 ■ Le jeu d’instruction (Instruction Set Architecture: ISA) a une introduction au MSP 430 JE EIP + displacement
4 4 8
introduction au MSP 430 1 operand instruction
15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0
importance capitale Processeurs embarqués
JE Condition Displacement
0 0 0 1 0 0 opcode B/W Ad Dest reg.
● Éconnomie ◆ Il détermine les instructions élémentaires exécutées par le ● Éconnomie ● Éconnomie
● ISA ● ISA Call ● ISA
● Pipeline CPU. ● Pipeline 8 32 ● Pipeline
● Classification ● Classification ● Classification relative Jumps
● Charactéristiques ◆ C’est un équilibre entre la complexité matérielle du CPU ● Charactéristiques
CALL Offset
● Charactéristiques 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0
Outils GNU pour la compilation et la facilité d’exprimer les actions requises Outils GNU pour la compilation Mov $EBX, [EDI+displacement] Outils GNU pour la compilation
0 0 1 condition PC offset (10 bits)
Un compilateur pour ◆ On le représente de manière symbolique (ex: MSP, code Un compilateur pour
6 1 1 8 8
Un compilateur pour
l’embarqué: GCC l’embarqué: GCC MOV d w r−m postbyte Displacement l’embarqué: GCC
sur 16 bits): 2 operands instruction
mov r5,@r8 ; commentaire [R8]<-R5 Push ESI 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0
5 3
lab: ADD r4,r5 ; R5<-R5+R4 PUSH Reg opcode Dest reg. Ad B/W As Dest reg.
■ Deux classes de jeux d’instructions:

◆ CISC: Complex Instruction Set Computer
Add $EAX, Immediate Exemples:
4 3 1 32
■ PUSB.B R4
◆ RISC: Reduce Instruction Set Computer ADD Reg w Immediate
■ JNE -56
Test $EDX, Immediate
7 1 8 32 ■ ADD.W R4,R4
TEST w PostByte Immediate
- p. 20/207 - p. 22/207 - p. 24/207

Le CPU Le pipeline RISC: exemple du MIPS Exemple d’exécution sans pipeline
introduction au MSP 430 ■ L’unité de contrôle configure le chemin de donnée suivant introduction au MSP 430 ■ Physiquement, l’architecture du processeur est organisée en introduction au MSP 430 ■ Avant le début de l’exécution de l’instruction à l’adresse 100
l’instruction à exécuter. Processeurs embarqués
calculs combinatoires pour chaque étape de pipeline, Processeurs embarqués
Processor
● Éconnomie
■ L’exécution d’une instruction est décomposée en plusieurs ● Éconnomie séparés par des registres. ● Éconnomie
Datapath
● ISA ● ISA ● ISA
● Pipeline
● Classification
phases d’un cycle. ● Pipeline
● Classification
● Pipeline
● Classification Control unit
ALU
● Charactéristiques ● Charactéristiques ● Charactéristiques control/Status

Processor Datapath R0 Register File R1
PC IR
ALU
Control unit 100 R2 R3
control/Status
Register File
PC IR
Memory
100 la R0,500 500 10
Memory 104 add R1,R0,1
108 sw R1,500
- p. 25/207 - p. 27/207 - p. 29/207
Le pipeline RISC: exemple du MIPS Le pipeline RISC: exemple du MIPS cycle 1
introduction au MSP 430 ■ Le pipeline dépend de l’architecture, pour le MIPS: introduction au MSP 430 ■ Lorsque l’instruction suivante ne peut pas être exécutée tout introduction au MSP 430 ■ Chargement de l’instruction
Processeurs embarqués ◆ Instruction Fetch (IF, Fetch): Processeurs embarqués
de suite, cela crée une "bulle". Processeurs embarqués
charge l’instruction dans l’IR Processor Datapath
● Éconnomie
● ISA
● Éconnomie
● ISA
■ Par exemple une addition utilisant un registre qui vient d’être ● Éconnomie
● ISA
◆ Instruction Decode (ID, Decode):
● Pipeline
● Classification
● Pipeline
● Classification
chargé doit être retardé d’un cycle. ● Pipeline
● Classification
ALU
● Charactéristiques décode l’instruction et met en place le contrôle du chemin ● Charactéristiques ● Charactéristiques
Control unit
control/Status
Outils GNU pour la compilation de donnée Outils GNU pour la compilation Outils GNU pour la compilation R0 Register File R1
IR
Un compilateur pour ◆ Execute (Ex): exécute le calcul dans le chemin de Un compilateur pour Un compilateur pour
PC
l’embarqué: GCC l’embarqué: GCC l’embarqué: GCC 100 la R0,500 R2 R3
donnée.
◆ Memory access (Mem): accède la mémoire
◆ Write Back (WB): écrit dans le banc de registre
Memory
100 la R0,500 500 10
104 add R1,R0,1
108 sw R1,500
- p. 26/207 - p. 28/207 - p. 30/207

cycle 2 cycle 4 Bilan architecture pipelinée
introduction au MSP 430 ■ Décodage de l’instruction introduction au MSP 430 ■ Accès mémoire introduction au MSP 430 ■ Exécution non pipelinée:
Processeurs embarqués Processeurs embarqués Processeurs embarqués ◆ 5 cycles pour exécuter une instruction
Processor Processor
● Éconnomie Datapath ● Éconnomie
Datapath ● Éconnomie ◆ ⇒ 15 cycles pour 3 instructions.
● Pipeline ● Pipeline ALU ● Pipeline
ALU
● Classification ● Classification Control unit ● Classification
Control unit
● Charactéristiques ● Charactéristiques control/Status ● Charactéristiques
control/Status
R0 Register File R1 R0 Register File R1
IR PC IR
PC
l’embarqué: GCC 100 la R0,500 R2 R3 l’embarqué: GCC 100 la R0,500 R2 R3 l’embarqué: GCC
Memory Memory
500 100 la R0,500 500 10
100 la R0,500 10
104 add R1,R0,1 104 add R1,R0,1
108 sw R1,500 108 sw R1,500
- p. 31/207 - p. 33/207 - p. 35/207
cycle 3 cycle 5 Exemple d’exécution avec pipeline
introduction au MSP 430 ■ Exécution (rien pour load) introduction au MSP 430 ■ Write Back introduction au MSP 430 ■ Chargement de l’instruction load
● Processeurs embarqués ● Processeurs embarqués Processor ● Processeurs embarqués
● Éconnomie
Processor Datapath ● Éconnomie
Datapath ● Éconnomie
Processor Datapath
● Pipeline ● Pipeline ALU ● Pipeline
ALU ALU
● Classification ● Classification Control unit ● Classification
Control unit Control unit
● Charactéristiques ● Charactéristiques control/Status ● Charactéristiques
control/Status control/Status
R0 Register File R1 R0 Register File R1 R0 Register File R1
IR PC IR IR
PC 10 PC
l’embarqué: GCC 100 la R0,500 R2 R3 l’embarqué: GCC 100 la R0,500 R2 R3 l’embarqué: GCC 100 la R0,500 R2 R3
Memory Memory Memory

500 100 la R0,500 500 10 500
100 la R0,500 10 100 la R0,500 10
104 add R1,R0,1 104 add R1,R0,1 104 add R1,R0,1
108 sw R1,500 108 sw R1,500 108 sw R1,500
- p. 32/207 - p. 34/207 - p. 36/207

cycle 2 cycle 4 cycle 6
introduction au MSP 430 ■ Décodage de l’instruction load introduction au MSP 430 ■ Accès mémoire de l’instruction load introduction au MSP 430 ■ Write Back de rien
■ et Chargement de Rien (bulle car l’instruction suivante ● Processeurs embarqués
■ Exécution de rien ● Processeurs embarqués
■ Accès mémoire de l’instruction add (rien)
● Éconnomie
● ISA
retardée) ● Éconnomie
● ISA ■ Décodage de l’instruction add
● Éconnomie
● ISA ■ Exécution de l’instruction store (rien)
● Pipeline ● Pipeline ● Pipeline
● Classification
Processor
● Classification ■ Chargement de l’instruction store ● Classification
● Charactéristiques Datapath ● Charactéristiques ● Charactéristiques Processor Datapath
ALU Processor Datapath ALU
Un compilateur pour Control unit load Un compilateur pour Un compilateur pour add
add Control unit
l’embarqué: GCC control/Status l’embarqué: GCC l’embarqué: GCC
control/Status
ALU
R0 Register File R1 R0 Register File R1
Pile d’exécution Pile d’exécution Control unit Pile d’exécution
PC IR add IR
control/Status PC 10
R0 Register File R1
104 R2 R3 120 R2 R3
PC IR
108 sw R1,500 R2 R3
sw
Memory load Memory

100 la R0,500 500 10 500
100 la R0,500 10
104 add R1,R0,1 Memory 104 add R1,R0,1
100 la R0,500 500 10
108 sw R1,500 108 sw R1,500
104 add R1,R0,1
108 sw R1,500
- p. 37/207 - p. 39/207 - p. 41/207
cycle 3 cycle 5 cycle 7
introduction au MSP 430 ■ Exécution de l’instruction load (rien) introduction au MSP 430 ■ Write Back de l’instruction load introduction au MSP 430 ■ Write Back de l’instruction add
■ Décodage de rien ● Processeurs embarqués
■ Accès mémoire de rien ● Processeurs embarqués
■ Accès mémoire de l’instruction store (bypass)
● Éconnomie ● Éconnomie ● Éconnomie
● ISA ■ Chargement de l’instruction add ● ISA ■ Exécution de l’instruction add (bypass) ● ISA
● Pipeline ● Pipeline ● Pipeline Processor Datapath
● Classification ● Classification ■ Décodage de l’instruction store ● Classification
● Charactéristiques Processor Datapath
● Charactéristiques ● Charactéristiques
ALU
Control unit add
Processor Datapath control/Status
ALU
Un compilateur pour
Control unit Un compilateur pour sw Un compilateur pour R0 Register File R1
l’embarqué: GCC l’embarqué: GCC l’embarqué: GCC IR
control/Status ALU PC 11
10
Pile d’exécution
R0 Register File R1 Pile d’exécution Control unit Pile d’exécution
IR control/Status load 124 R2 R3
PC 10
R0 Register File R1
104 add R1,R0,1 R2 R3
PC IR
10
116 R2 R3 sw
Memory
100 la R0,500 500 11
Memory 104 add R1,R0,1
100 la R0,500 500 10
Memory 108 sw R1,500
104 add R1,R0,1
100 la R0,500 500 10
108 sw R1,500
104 add R1,R0,1
108 sw R1,500
- p. 38/207 - p. 40/207 - p. 42/207
Bilan architecture non pipelinée Parallélisme au sein du processeur Principe du Cache
introduction au MSP 430 ■ Exécution non pipelinée: introduction au MSP 430

Une autre approche possible: instructions SIMD. introduction au MSP 430 0
1
0
Processeurs embarqués ◆ 5 cycles pour exécuter une instruction Processeurs embarqués ■ Modification du data-path pour proposer des opérations Processeurs embarqués 2
● Processeurs embarqués ● Processeurs embarqués ● Processeurs embarqués 3
● Éconnomie ◆ ⇒ 15 cycles pour 3 instructions. ● Éconnomie parallèles sur 16 ou 8 bits ● Éconnomie 4
● ISA ● ISA ● ISA 5
● Pipeline
● Classification
■ Exécution pipelinée: ● Pipeline
● Classification
■ Exemple: Sun Visual Instruction Set, Intel Pentium MMX, ● Pipeline
● Classification
6
7
● Charactéristiques ◆ 5 cycles pour exécuter une instruction ● Charactéristiques Philips TriMedia ● Charactéristiques 0 8
1 9
Outils GNU pour la compilation ◆ 8 cycles pour 3 instructions. Outils GNU pour la compilation
■ Gains importants sur certains traitements mais très peu Outils GNU pour la compilation
1 cycle 2 10−20 cycles 10
Espace
Un compilateur pour ◆ ⇒ sans branchement, une instruction par cycle Un compilateur pour
utilisé en pratique (difficile à inférer par le compilateur) Un compilateur pour Processeur 0
1
0
1
0
13
04
1
0
1
0
1
0
1
0
1
11
mémoire
l’embarqué: GCC l’embarqué: GCC l’embarqué: GCC 0
1 05
1 0
1 01213
1 adressable
◆ Un branchement (conditionnel ou pas) interrompt le ◆ Librairies écrites en assembleur (programmes non
Pile d’exécution Pile d’exécution Pile d’exécution 6 14
pipeline car il faut attendre de décoder l’adresse de portables) 7 15

16
branchement pour charger l’instruction suivante ⇒ ◆ Fonction C représentant les instructions assembleurs 17
18
quelques cycles d’inactivité (pipeline stall) (compiler intrinsic) Cache de données (SRAM) 19
20
◆ Lors d’un branchement, certain ISA autorisent l’utilisation ◆ Exemple: instruction ifir8ii R1, R2, R3 du Trimedia: 21
de ces delai slots: une ou deux instructions après le 8 bits 8 bits 8 bits 8 bits 8 bits 8 bits 8 bits 8 bits 22
23 N−1
branchement sont exécutées, que le branchement soit
Mémoire principale (DRAM)
pris ou pas (comme si elles étaint écrites avant le * * * *
branchement). +
32 bits
- p. 43/207 - p. 45/207 - p. 47/207
Parallélisme au sein du processeur Mémoire Hiérarchie Mémoire

Indépendamment du pipeline, Deux paradigmes dominants: introduction au MSP 430 ■ Plusieurs technologies pour les mémoires: introduction au MSP 430
Processeurs embarqués ■ Super Scalaire Processeurs embarqués ◆ Mémoires statiques (SRAM): petites, rapides, Processeurs embarqués Processeur Processeur
● Processeurs embarqués ● Processeurs embarqués ● Processeurs embarqués /DSP /DSP
● Éconnomie ◆ Duplication des unités, ● Éconnomie consommatrices, peu denses (chères). ● Éconnomie
ASIC / ASIP
● ISA ● ISA ● ISA D: cache de données
● Pipeline ◆ Répartition au vol des instructions sur les unités ● Pipeline ◆ Mémoires dynamiques (DRAM): grandes, lentes, très ● Pipeline I: cache d’instructions
D I D I
● Charactéristiques disponibles (re-ordonnancement des instructions: out of ● Charactéristiques denses, transactions chères ● Charactéristiques
Outils GNU pour la compilation order execution) Outils GNU pour la compilation ■ De plus en plus de place On-Chip pour la mémoire (dans ce Outils GNU pour la compilation
◆ Exemple: le PowerPC 970 (4 ALU, 2 FPU) Mémoire cache

Un compilateur pour
l’embarqué: GCC
Un compilateur pour
l’embarqué: GCC
cas elles sont moins efficaces que les chips mémoire). Un compilateur pour
l’embarqué: GCC
de niveau 4
Cache
de niveau 3
Cache
de niveau 2
◆ Efficace mais complexifie l’unité de contrôle (problème
■ Ne pas oublier que le code aussi réside en mémoire Pile d’exécution
des interruptions)
■ Tous les systèmes ont des caches pour cacher les temps de SOC
■ Very Large Instruction Word (VLIW)
latence lors de l’accès à la mémoire, en général plusieurs
◆ Duplication des unités,
niveaux de caches: hiérarchie mémoire. Bus système externe
◆ L’ordonnancement des instructions est fixé à la
compilation (tout se passe comme si les instructions Bancs de mémoire DRAM
pouvait être regroupe sur 64 bits, 128 bits etc.) contrôleur

mémoire
◆ Inventé par Josh Fisher (Yale) à partir du trace scheduling
◆ Les processeurs VLIW sont tous basés sur les
architecures RISC, avec entre 4 et 8 unités.
◆ Exemple: TriMedia (Philips), Itanium IA64 (Intel).
- p. 44/207 - p. 46/207 - p. 48/207
Différents types de processeurs embarqués SPARC, 29000 et i960 Et les autres....
introduction au MSP 430 ■ Beaucoup de Processeurs à usage général ayant une ou introduction au MSP 430 ■ SPARC introduction au MSP 430 ■ Plus de 100 processeurs embarqués 32 bits sur le marché
deux générations Processeurs embarqués
◆ Un des premier RISC à avoir été embarqué (pratiquement Processeurs embarqués
■ Les constructeurs de FPGA proposent des soft-processeurs
● Éconnomie
■ 4, 8, 16 ou 32 bits (taille des mots) ● Éconnomie plus aujourd’hui) ● Éconnomie
pour configurer les FPGA: Nios (Altera), MicroBlaze (Xilinx)
● Pipeline ● Pipeline ◆ SPARC est une architecture brevetée (soft core, ● Pipeline
● Classification
■ RISC et CISC ● Classification ● Classification
■ Certain processeurs RISC (Crusoe de Transmetta) peuvent
● Charactéristiques ● Charactéristiques Intellectuel Property: IP), plusieurs compagnies fabriquent ● Charactéristiques
■ DSP: Digital Signal Processor exécuter du code CISC (Intel)
Outils GNU pour la compilation Outils GNU pour la compilation des SPARC Outils GNU pour la compilation
◆ Principe: recompilation du code à l’exécution (runtime
Un compilateur pour
■ ASIP: Application Specific Integrated Processor Un compilateur pour ■ 29000 (AMD) Un compilateur pour
l’embarqué: GCC l’embarqué: GCC l’embarqué: GCC compilation)
◆ Le 29000 a eu beaucoup de succès (imprimante laser ◆ Gain obtenus par un mécanisme de cache, d’optimisation
Apple) grâce à ces 192 registres poussée des portion de code répétées (boucle), et grâce
◆ AMD a arrêté la production car le développement des
au parallélisme de niveau instruction
outils coûtait trop cher. ◆ Réduction drastique de la consommation pour des
■ i960 (intel) performances équivalentes
◆ Le i960 a été le plus vendu des processeurs embarqués
au milieu des années 90 (router réseau et HP Laserjet).
- p. 49/207 - p. 51/207 - p. 53/207
68000, x86 MIPS, ARM, SuperH et PowerPC Micro-contrôleurs
introduction au MSP 430 ■ Famille des Motorola 68000 introduction au MSP 430 ■ MIPS (microprocessor without interlocked pipeline stages) introduction au MSP 430 ■ Utilisé pour le contrôle embarqué
Processeurs embarqués ◆ Un des plus vieux processeur embarqué (ex Sun, Mac) Processeurs embarqués ◆ Originellement pour les stations puissantes (SGI) Processeurs embarqués ◆ Censeur, contrôleurs simples
● Éconnomie ◆ Architecture CISC ● Éconnomie ◆ Puis, marché des consoles de jeux (Nitendo N64) ● Éconnomie ◆ Manipule des événements, quelques données mais en
● Pipeline ◆ ISA propre et les meilleurs outils de développement, ● Pipeline ◆ Famille très étendue: du plus gros (MIPS 20Kc, 64 bit) au ● Pipeline faible quantité
● Charactéristiques beaucoup d’utilisateurs ● Charactéristiques plus petit (SmartMIPS, 32 bit pour carte à puce) ● Charactéristiques ◆ Exemple: camescope, disque dur, appareil photo
Outils GNU pour la compilation ■ Famille des x86 Outils GNU pour la compilation ■ ARM (Advanced RISC Machines, ex Acorn) Outils GNU pour la compilation numérique, machine à laver, four à micro-onde
Un compilateur pour ◆ Démarre au 8086 (Intel) puis 80286, 386, 486, Pentium, et Un compilateur pour ◆ Un des 32 bits embarqués les plus populaires : Un compilateur pour ■ Quelques caractéristiques fréquentes
Pile d’exécution
Athlon (AMD) Pile d’exécution
téléphones portables Pile d’exécution
◆ Périphériques présents sur le circuit (timer, convertisseur
◆ En processeurs embarqués: 5 fois moins que MIPS, ARM ◆ Faible consommation analogique numérique, interface de communication),
ou 68000. ◆ Le successeur: StrongArm est commercialisé par Intel accessible directement grâce aux registres
◆ architecture CISC, compatible avec le code du 8086 sous le nom de XScale ◆ Programme et données intégrées au circuit
◆ compatibilité mais mauvaises performances ◆ Accès direct du programmeur à de nombreuses broches
■ SuperH (ou SH: Hitachi) Utilisé dans les stations Sega et les
PDA du circuit
◆ Instructions spécialisées pour les manipulation de bits.
■ PowerPC autant utilisé en embarqué qu’en ordinateur
■ Le MSP430 appartient à cette catégorie
- p. 50/207 - p. 52/207 - p. 54/207

DSP: Digital Signal Processing Quelques mécanismes matériels utiles Quelques mécanismes matériels utiles
introduction au MSP 430 ■ Utilisés pour les applications de traitement du signal introduction au MSP 430 ■ Manipulations au niveau bit: introduction au MSP 430 ■ Gestion spécifique du cache
Processeurs embarqués ◆ Grande quantités de données numérisées, souvent Processeurs embarqués ◆ Utilisé pour les algorithmes de cryptage mais surtout pour Processeurs embarqués ◆ Les caches améliorent les performances mais introduisent
● Éconnomie organisées en flux ● Éconnomie les pilotes de périphériques. ● Éconnomie du non-déterminisme.
● Pipeline ◆ Filtre numérique sur téléphone, TV numérique, ● Pipeline ◆ La plupart des périphériques indiquent leur état au ● Pipeline ◆ Les contraintes spécifiques des systèmes embarqués ont
● Charactéristiques synthétiseur de sons ● Charactéristiques processeur en mettant un certain bit à 1 dans un certain ● Charactéristiques entraîné des mécanismes particuliers pour les cache
Outils GNU pour la compilation ■ Relativement proche des GPP, mais quelques Outils GNU pour la compilation registre. Outils GNU pour la compilation
◆ On peut vouloir bloquer le cache (cache locking): forcer
◆ Un processeur standard doit rapatrier le mot de 32 bit, certaines données ou instruction à se charger et rester
Un compilateur pour
l’embarqué: GCC
caractéristiques en plus: Un compilateur pour
l’embarqué: GCC
Un compilateur pour
l’embarqué: GCC
◆ Bande passante élevée (deux bus) masquer et tester à 0 dans le cache (on parle aussi de mémoire scratch-pad
◆ Instructions dédiées pour les calculs de traitement du ◆ Les instructions BIC, BIT et BIS du MSP430 font des memory ou de software controlled cache).
signal: multiplication accumulation, manipulation au niveau bit dans la mémoire ◆ La plupart des caches utilisent une politique de
◆ Arithmétique spécifique (mode d’arrondi) Write-Back: une donnée modifiée dans le cache n’est pas
◆ Registres dédiés pour certains opérateurs. forcément immédiatement recopiée en memoire. Dans le
◆ Constructeurs: Texas Instrument, puis Analog Devices, cas de périphériques mappés en mémoire, il est
Motorola indispensable de recopier immédiatement (politique
write-through)
- p. 55/207 - p. 57/207 - p. 59/207
Quelques mécanismes matériels utiles Quelques mécanismes matériels utiles Quelques mots sur la consommation
introduction au MSP 430 ■ Densité de code: introduction au MSP 430 ■ Données non-alignés introduction au MSP 430 ■ Trois composantes de la consommation d’une porte logique
◆ La taille du code est importante pour les codes Processeurs embarqués
◆ De nombreux traitements manipulent des données de Processeurs embarqués
(inverseur)
● Éconnomie embarqués car elle influe sur la taille de la mémoire ● Éconnomie taille non-multiple de 32 (paquets TCP/IP, video streams, ● Éconnomie ◆ Consommation dynamique : Pdyn = C.V 2
CC
● Pipeline utilisée ● Pipeline clés d’encryption, 20 bits, 56 bits) ● Pipeline (C capacité de la porte)
● Charactéristiques ◆ Un programme C compilé pour SPARC prendra deux fois ● Charactéristiques ◆ Les processeurs RISC savent uniquement transférer des ● Charactéristiques
◆ Consommation statique : Pstatic = VCC .Ileak
Outils GNU pour la compilation plus de place en mémoire que le même programme Outils GNU pour la compilation mots (32 bits) alignés (calés sur une adresse multiple de Outils GNU pour la compilation (VCC : tension d’alimentation, Ileak intensité des
Un compilateur pour compilé pour le 68030. Un compilateur pour 32 bits). Un compilateur pour courants de fuite)
◆ Consommation de court-circuit Pcs = K.τ.(VCC − 2VT h )3 .
◆ En général les code RISC sont deux fois moins dense que ◆ La plupart des architectures CISC (68k, x86) peuvent faire
les codes CISC (ex: instruction TBLS du 68300: table des chargements non alignés (K:constante technologique ; VT h :tension seuil ;
lookup and interpolate) τ :temps de montée descente du signal)
◆ Les options de compilation doivent être utilisées avec ■ Aujourd’hui (2004) Pdyn ≫ Pstatic ≫ Pcs
précaution. ■ Demain (2007) Pdyn ≈ Pstatic ≫ Pcs
◆ Le code est quelquefois stocké compressé et
decompressé au vol par du matériel spécifique.
- p. 56/207 - p. 58/207 - p. 60/207

Consommation d’un circuit CMOS Réduction dynamique de la consommation
introduction au MSP 430 ■ Généralisation naïve en prenant en compte une activité introduction au MSP 430 ■ Gestion dynamique de la fréquence d’horloge introduction au MSP 430
moyenne α (nombre moyen de portes commutant) Processeurs embarqués
■ Exemple: processeur Crusoe (Transmetta) Processeurs embarqués
◆ Consommation dynamique : Pdyn = C.V 2 .α.f Outils GNU pour la compilation

● Éconnomie
● ISA
CC
● Éconnomie
● ISA
Suppression de l’horloge sur un bloc (Dynamic clock ● Outils GNU pour la
● Pipeline (f : fréquence du circuit) ● Pipeline
gating) compilation
● Classification
● Charactéristiques ◆ Consommation statique : Pstatic = VCC .Ileak .N.kdesign
● Classification
■ Gestion dynamique de l’alimentation (pas encore réalisé)
● GNU
● Compilation Outils GNU pour la compilation
Outils GNU pour la compilation (N: nombre de portes, kdesign constante dépendant Outils GNU pour la compilation
Un compilateur pour
l’embarqué: GCC
Un compilateur pour du design) Un compilateur pour

Pile d’exécution
Pile d’exécution
■ Cette modélisation est très imprécise pour un circuit dont le Pile d’exécution
comportement n’est pas stationnaire (ex: processeur)
- p. 61/207 - p. 63/207 - p. 65/207
Réduction statique de la consommation Low Power Mode pour le MSP430 Le projet GNU
introduction au MSP 430 ■ Le facteur le plus important est la tension d’alimentation introduction au MSP 430 ■ Différent mode pour réduire la consommation introduction au MSP 430 ■ Le projet GNU, initié par Richard Stallman en 1984, vise à
(VCC ) d’abord 3.3 V puis 2.5 V. Les versions récentes de Processeurs embarqués
◆ LPM0: le CPU est arrété Processeurs embarqués
créer un système d’exploitation complet qui réponde aux
● Éconnomie Xscale (strong ARM, Intel) et les puces smartCard ● Éconnomie ◆ LPM1, LPM2: l’horloge rapide (MCLK) est aussi arrétée Outils GNU pour la compilation
● Outils GNU pour la
principes du logiciel libre
● ISA ● ISA
● Pipeline fonctionnent a 0.65 V ● Pipeline ◆ LPM3 le générateur d’horloge est arrété compilation
● GNU
■ Licence GPL (GNU General Public License) ou LGPL (GNU
● Classification ● Classification
◆ LPM4 : l’oscillateur du crystal est arrété
● Charactéristiques ■ On peut différencier les tensions en fonction du bloc du chip: ● Charactéristiques
● Compilation
Lesser General Public License)
Outils GNU pour la compilation 1.5 V pour le processeur, 3.3 pour l’interface du bus et les Outils GNU pour la compilation ■ Le temps de reprise est d’autant plus long que la veille est Un compilateur pour
l’embarqué: GCC ■ Philosophie unix: programmes modulaires assemblés en un
Un compilateur pour
l’embarqué: GCC
pattes d’entrée/sortie (ex: Strong ARM de Digital) Un compilateur pour
l’embarqué: GCC
profonde. Pile d’exécution système complexe:
Pile d’exécution
■ Plus la technologie est intégrée, moins elle consomme Pile d’exécution
◆ Portabilité
(capacité diminuée). ◆ Standard Posix
◆ Performances
■ Fréquence d’horloge peu élevée compensée par le
parallélisme ■ Prise en main plus difficile que les outils commerciaux.
■ Complexité réduite des différents composants (moins de ■ Modèle économique de plus en plus suivi par les industriels.
registres, architectures RISC)
- p. 62/207 - p. 64/207 - p. 66/207

principaux outils de développement GNU Détail de la partie “compilation” Compilation: Le middle-end
introduction au MSP 430 ■ Le compilateur gcc est la pièce maîtresse du projet GNU. introduction au MSP 430 ■ le processus de compilation est divisé en trois phases: introduction au MSP 430 ■ Certaines phases d’optimisations sont ajoutées, elles
Compilateur C, C++ et Objective-C de très grande qualité, Processeurs embarqués Processeurs embarqués
peuvent être très calculatoires
ses performances dépassent souvent celles des meilleurs Outils GNU pour la compilation
Front−End Middle−End Back−End
■ Quelques exemples de transformation indépendantes de la
compilation compilateurs commerciaux. compilation compilation
machine:
Ordonnancement
● GNU ● GNU ● GNU
Alloc. Reg.
Scanning
Selection
● Compilation
■ Autres compilateurs g77, gnat, gpc,. . . ● Compilation ● Compilation
◆ Élimination d’expressions redondantes
Parsing
C.S.A
Opt1
Opt2
Opt3
l’embarqué: GCC ■ emacs éditeur de texte multifonction qui peut faire aussi l’embarqué: GCC l’embarqué: GCC ◆ Élimination de code mort
Pile d’exécution office d’environnement intégré de programmation (IDE) Pile d’exécution Pile d’exécution ◆ Propagation de constantes
■ make permet d’automatiser l’ordonnancement des Infrastructure

■ Attention, les optimisation peuvent nuire à la compréhension
différentes étapes de compilation Table des symbols, Arbres de syntaxe abstraite, Graphes, ensembles, IR, ...
de l’assembleur (utiliser l’options -O0 avec gcc)
■ gdb est un débogueur pour les langages C, C++ et Fortran. Compilateur
ddd apporte une interface graphique au-dessus de gdb.

■ automake, autoconf permette de produire facilement des
programmes portables.
■ Tous ces programmes sont disponibles sur tous les type de
systèmes. Pour windows, c’est à travers l’environnement
cygwin
- p. 67/207 - p. 69/207 - p. 71/207
A Data cache optimisations
Compilation: Le flot général Compilation: Le front-end B

Procedure integration
Tail−recursion optimisation
Scalar replacement of agregates
Sparse conditional constant propagation
Interprocedural constant propagation
Procedure specialization and cloning
Sparse conditional constant propagation
introduction au MSP 430 ■ Le flot complet de compilation est le suivant: introduction au MSP 430 ■ Le front-end d’un compilateur pour code embarqué utilise les introduction au MSP 430 Global value numbering
Local and global copy propagation
Constant folding
Algebraic simplifications
Processeurs embarqués Processeurs embarqués
mêmes techniques que les compilateurs traditionnels (on Processeurs embarqués Sparse conditional constant propagation
Dead code elimination
peut vouloir inclure des partie d’assembleur directement) Outils GNU pour la compilation
C Local and global common subexpression elimination Partial redundancy elimination
compilation
● GNU
compilation
● GNU
■ Parsing LR(1): Le parseur est généré à partir de la compilation
● GNU Loop invariant code motion
● Compilation ● Compilation
grammaire du langage. ● Compilation

l’embarqué: GCC l’embarqué: GCC ■ Flex et bison: outils GNU l’embarqué: GCC
Code hoisting
Induction−variable strength reduction
Linear function test replacement
Pile d’exécution Pile d’exécution Pile d’exécution Induction−variable removal
Unnecessary bound checking elimination
Control−flow optimisations
■ La programmation d’un système embarqué nécessite In−line expansion

Leaf routine optimization
souvent d’écrire explicitement des parties en assembleur Shrink wrapping

Machine idioms
Tail merging
(pilotes de périphériques et d’accélérateurs matériels). Branch optimization and conditionnal moves
D Software−pipelining, loop unrolling, variable expansion
register renaming and hierachical reduction
Basic block and branch scheduling 1
Register allocation by graph coloring
Basic block and branch scheduling 2
Intraprocedural I−cache optimization
Instruction prefretching
Data prefretching
Branch prediction
Interprocedural register allocation

E Aggregation of global references
- p. 68/207 - p. 70/207 Interprocedural I−cache optimisation - p. 72/207
Compilation: Le back-end compilateur, éditeur de liens, binutils GCC
introduction au MSP 430 ■ La phase de génération de code est dédiée à l’architecture introduction au MSP 430 introduction au MSP 430 ■ La commande gcc lance plusieurs programmes suivant les
cible. Les techniques de compilation reciblable sont utilisées Processeurs embarqués Processeurs embarqués
options
pour des familles d’architectures. Outils GNU pour la compilation Outils GNU pour la compilation ◆ Le pré-processeur cpp
Un compilateur pour Un compilateur pour ◆ Le compilateur cc1
compilation
● GNU
■ Les étapes les plus importantes sont l’embarqué: GCC l’embarqué: GCC
● Compilation
◆ Sélection de code
● GCC ● GCC ◆ L’assembleur gas
● gcc ● gcc
Un compilateur pour
◆ Allocation de registre ● gdb ● gdb ◆ L’éditeur de liens ld
l’embarqué: GCC ● Pile d’exécution ● Pile d’exécution
◆ Ordonnancement d’instructions
■ gcc: ftp://ftp.gnu.org/gnu/gcc/gcc-3.3.tar.gz ■ gcc -v permet de visualiser les différents programmes
■ Assembleur, éditeur appelés par gcc
de lien et utilitaire de manipulation de binaire (objdump, etc..)
ftp://ftp.gnu.org/gnu/binutils/binutils-2.9.1.tar.gz
■ Run-time library (printf, malloc, etc.): newlib (ou
glibc) ftp://ftp.gnu.org/gnu/glibc/
- p. 73/207 - p. 75/207 - p. 77/207
Un compilateur pour l’embarqué: GCC Installation de GCC pour MSP430 Le pré-processeur: cpp ou gcc -E
introduction au MSP 430 ■ GCC: Gnu C Compiler ou Gnu Compiler Collection introduction au MSP 430 ■ tar zxf gcc-3.3.tar.gz introduction au MSP 430 ■ cpp0 pour msp430-gcc
■ http://gcc.gnu.org/ ■ tar zxf binutils-2.9.1.tar.gz ■ msp430-gcc -mmcu=msp430x449 -E ex1.c -o ex1.i
■ Outil développé par la communauté mondiale, ■ cd binutils-2.9.1 ■ Les tâches du préprocesseur sont :
l’embarqué: GCC développement rapide. l’embarqué: GCC configure l’embarqué: GCC ◆ élimination des commentaires,
● GCC ● GCC ● GCC
-target=msp430 ◆ l’inclusion de fichier source,
● gcc
● gdb
■ De plus en plus utilisé pour le calcul embarqué car il est ● gcc
● gdb
● gcc
● gdb
make all install ◆ la substitution de texte,
● Pile d’exécution
reciblable. ● Pile d’exécution ● Pile d’exécution
Pile d’exécution Pile d’exécution ■ Même chose pour gcc (L’exécutable est nommé Pile d’exécution ◆ la définition de macros,
■ Exemple d’utilisation
msp430-gcc) ◆ la compilation conditionnelle.
◆ Créer un compilateur pour le MSP430 sur votre Pentium
◆ Insérer une routine d’interruption dans votre programme ■ Voir le fichier configure.sub pour les plate-formes cibles ■ Exemple:
◆ Répartir les différentes sections de votre code dans possibles #define MAX(a, b) ((a) > (b) ? (a) : (b))
différentes mémoires. ■ On peut aussi compiler gcc sur une machine pour l’utiliser ex1.c ...
sur une autre machine (ou il produira du code pour une f=MAX(3,b);
troisième machine): GCC est un Cross-compiler
#define MAX(a, b) ((a) > (b) ? (a) : (b))
ex1.i ...
f=((3) > (b) ? (3) : (b));
- p. 74/207 - p. 76/207 - p. 78/207
Le compilateur cc1 ou gcc -S Assembleur produit par mspgcc -S Éditeur de liens: ld
.text
.p2align 1,0
introduction au MSP 430 ■ Génère du code assembleur introduction au MSP 430 .global main introduction au MSP 430 ■ Produit l’exécutable (a.out par défaut) à partir des codes
■ msp430-gcc -O0 -mmcu=msp430x449 -S main.c -o
Processeurs embarqués .type main,@function Processeurs embarqués
objets des programmes et des librairies utilisées.
main.S main: ■ Il y a deux manières d’utiliser les librairies dans un
l’embarqué: GCC ■ Exemple : l’embarqué: GCC /* prologue: frame size = 2 */ l’embarqué: GCC programme
.L__FrameSize_main=0x2 ◆ Librairies dynamiques ou partagées (shared, option par
● gcc void main() ● gcc ● gcc
● gdb
{ int i;
● gdb
● Pile d’exécution .L__FrameOffset_main=0x6
● gdb
défaut): le code de la librairie n’est pas inclus dans
Pile d’exécution Pile d’exécution mov #(__stack-2), r1 Pile d’exécution
l’exécutable, le système charge dynamiquement le code
i=0;
mov r1,r4 de la librairie en mémoire lors de l’appel du programme.
On n’a besoin que d’une version de la librairie en mémoire
while (1) /* prologue end (size=3) */
même si plusieurs programmes utilisent la même librairie.
{ mov #llo(0), @r4
La librairie doit donc être installée sur la machine, avant
i++; .L2: d’exécuter le code.
nop(); add #llo(1), @r4 ◆ Librairies statiques (static): le code de la librairie est
} nop inclus dans l’exécutable. Le fichier exécutable est plus

} jmp .L2 gros mais on peut l’exécuter sur une machine sur laquelle
/* epilogue: frame size=2 */ la librairie n’est pas installée.
add #2, r1 ■ Les OS simples ne proposent pas de librairies dynamiques.
- p. 79/207
br #__stop_progExec__ - p. 81/207 - p. 83/207
/* epilogue end (size=3) */
Assembleur correspondant (vu par gdb-insight) Assembleur as ou gas Manipuler les fichiers binaires

while (1) introduction au MSP 430 ■ Transforme un fichier assembleur en un code objet introduction au MSP 430
Quelques commandes utiles:
{ i++;
(représentation binaire du code assembleur) Processeurs embarqués ■ nm
nop();
■ L’options -c de gcc permet de combiner compilation et Outils GNU pour la compilation
permet de connaître les symboles (en particulier les
assemblage:
Un compilateur pour
fonctions) utilisés dans un fichier objet ou exécutable:
l’embarqué: GCC } l’embarqué: GCC l’embarqué: GCC
● GCC
● gcc
● GCC
● gcc msp430-gcc -c -mmcu=msp430x449 main.c -o ● GCC
● gcc
trisset@hom\$ msp430-nm fib.elf | grep main
● gdb
mov #2558, SP ; initialisation de la pile ● gdb ● gdb 000040c8 T main
● Pile d’exécution ● Pile d’exécution
main.o ● Pile d’exécution
mov r1, r4 ; r4 contient SP ■ objdump permet d’analyser un fichier binaire. Par exemple
mov #0, 0(r4) ; initialisation de i pour avoir la correspondance entre la représentation binaire
inc 0(r4) ; i++ et le code assembleur:
nop ; nop(); trisset@hom$ msp430-objdump -f fib.elf
jmp $-6 ; saut inconditionnel (PC-6): fib.elf: file format elf32-msp430
incd SP ; architecture: msp:43, flags 0x00000112:
br #0x1158 ; EXEC_P, HAS_SYMS, D_PAGED
start address 0x00001100
- p. 80/207 - p. 82/207 - p. 84/207

Options utiles de gcc gdb: GNU symbolic debugger Exemple de session gdb
introduction au MSP 430 ■ -c :pas d’édition de liens introduction au MSP 430 ■ gdb est un debugger symbolique, c’est-à-dire un utilitaire introduction au MSP 430 ■ Lorsque l’on lance gdb avec la commande gdb exgdb.c,
■ -o file: renomme le fichier de sortie file au lieu de
Unix permettant de contrôler le déroulement de programmes Processeurs embarqués
gdb a chargé l’exécutable, il attend alors une commande
a.out Outils GNU pour la compilation
C. Outils GNU pour la compilation gdb, comme par exemple run (pour exécuter le
■ gdb permet (entre autres) de mettre des points d’arrêt dans
Un compilateur pour
programme), break (pour mettre un point d’arret dans le
l’embarqué: GCC ■ -g : insère les informations nécessaires à l’utilisation d’un l’embarqué: GCC l’embarqué: GCC
● GCC ● GCC
un programme, de visualiser l’état de ses variables, de ● GCC programme), step (pour avancer d’une instruction dans le
● gcc déboggeur (gbd, ddd). ● gcc ● gcc
● gdb ● gdb
calculer des expressions, d’appeler interactivement des ● gdb programme), etc.
● Pile d’exécution ■ -Wall : fait le maximum de vérifications statiques possibles ● Pile d’exécution ● Pile d’exécution

fonctions, etc. Pile d’exécution
■ Les points d’arrêt peuvent se positionner au début des
■ -Oval :(val est un entier compris entre 0 et 4), effectue des fonctions (break main, par exemple), ou à une certaine
■ xxgdb, ddd et insight sont des interfaces graphiques qui
optimisations de niveau val ligne (break 6, par exemple), ou lorsqu’une variable
facilitent l’utilisation de gdb sous X-Window.
■ -Ipath : recherche les fichiers d’en-tête dans le répertoire change de valeur (watch i, par exemple).
■ gdb ne nécessite aucun système de fenêtrage, il peut
path avant de les rechercher dans les répertoires standards
s’exécuter sur un simple terminal shell (mode console).
(/usr/include, /usr/local/include).
■ Il est indispensable de comprendre le fonctionnement en
■ -Lpath : recherche les librairies dans le répertoire path
mode de gdb pour pouvoir utiliser insight.
avant de les rechercher dans les répertoires standards
(/usr/lib, /usr/local/lib).
■ -Dflag=val : équivalent à écrire la directive
#define flag val dans le code
- p. 85/207 - p. 87/207 - p. 89/207
Attention aux optimisation: -01 Exemple de session gdb Exemple de session gdb
#include <stdio.h> ■ Suite de la session:
(gdb) break main
int main() Breakpoint 1 at 0x8048424: file exgdb.c, line 6.
introduction au MSP 430 ■ Assembleur du main (while(1) {i++; nop()}) avec introduction au MSP 430 introduction au MSP 430
{int i,*p; (gdb) run

l’option -O1 msp430-gcc -O1 -mmcu=msp430x449 -S Processeurs embarqués Processeurs embarqués
Starting program: /home/trisset/cours/2005/AGP/cours_tr

main.c -o main.S Outils GNU pour la compilation Outils GNU pour la compilation
Un compilateur pour while (1) Un compilateur pour i=1; Un compilateur pour

p=(int *)malloc(sizeof(int));
l’embarqué: GCC
Breakpoint 1, main () at exgdb.c:6
● GCC
{ i++; ● GCC ● GCC
● gcc
● gdb
● gcc
● gdb *p=2;
● gcc
● gdb
6 i=1;
nop();
● Pile d’exécution ● Pile d’exécution
*p+=i;
● Pile d’exécution (gdb)
}
fprintf(stdout,"i=%d, p=%X, *p=%d\n",i,p,*p); Pile d’exécution
gdb a lancé l’exécutable et arrêté l’exécution à la ligne 6 du
mov #2558, SP free(p); fichier (à la première ligne de la fonction main), le code de
nop return(0); cette ligne apparaît à l”écran.
jmp $2 } ■ On peut avancer d’un pas dans le programme:
br #0x114C ■ compilation avec -g: (gdb) step
shell$ gcc -g exgdb.c -o exgdb 7 p=(int *)malloc(sizeof(int));
■ lancement de gdb: shell$ gdb exgdb (gdb)
GNU gdb 6.3-debian ■ On peut afficher la valeur de i;
(gbd)
(gdb) print i
$1 = 1
- p. 86/207 - p. 88/207 (gdb) - p. 90/207
Exemple de session gdb gdb commandes abrégées insight: haut de la fenêtre
■ Affichage permanent de variables: display
(gdb) display i
introduction au MSP 430 1: i = 1 introduction au MSP 430 ■ On peut taper la première lettres des commandes: introduction au MSP 430
Processeurs embarqués (gdb) Processeurs embarqués Processeurs embarqués

■ r est équivalent à run
■ Affichage de pointeurs (comme une variable): Outils GNU pour la compilation
■ b main est équivalent à break main

l’embarqué: GCC (gdb) display p l’embarqué: GCC
■ p var est équivalent à print var l’embarqué: GCC
● gcc 2: p = (int *) 0xb8000540 ● gcc ● gcc
● gdb
(gdb) ● gdb ■ d var est équivalent à display var ● gdb
● Pile d’exécution ● Pile d’exécution ● Pile d’exécution
■ s est équivalent à step
Pile d’exécution ■ Affichage d’objet pointés par les pointeurs : Pile d’exécution Pile d’exécution
■ n est équivalent à next

(gdb) display *p
3: *p = -1208053760 ■ c est équivalent à continue
(gdb) ■ La commande run peut prendre des arguments, le
programme est alors exécuté avec les arguments donnés
(gdb) step
8 *p=2;
■ la commande info permet d’afficher des informations sur
3: *p = 0 l’état du programme dans le débugger. Par exemple info b
2: p = (int *) 0x804a008 liste les points d’arrêt.
1: i = 1 ■ La commande help est l’aide en ligne de gdb
(gdb)
- p. 91/207 - p. 93/207 - p. 95/207
Exemple de session gdb insight insight: source et assembleur

(gdb) step
9 *p+=i;
introduction au MSP 430 3: *p = 2 introduction au MSP 430 ■ insight est une interface graphique pour gdb. introduction au MSP 430
Processeurs embarqués 2: p = (int *) 0x804a008 Processeurs embarqués Processeurs embarqués

■ Après avoir compilé un programme avec msp430-gcc -g,
Outils GNU pour la compilation 1: i = 1 Outils GNU pour la compilation Outils GNU pour la compilation
on tape:
Un compilateur pour
l’embarqué: GCC
(gdb) step Un compilateur pour
l’embarqué: GCC msp430-gdb-insight nomduprog
Un compilateur pour
l’embarqué: GCC
● GCC
● gcc
10 fprintf(stdout,"i=%d, p=%X, *p=%d\n",i,p,*p); ● GCC
● gcc Par exemple: ● GCC
● gcc
● gdb
3: *p = 3 ● gdb
msp430-gdb-insight fib.elf ● gdb
2: p = (int *) 0x804a008 ■ Le débuggage peut se faire dans insight (mode
1: i = 1 simulateur) ou avec une plateforme externe (connection
(gdb) next TCP).
i=1, p=804A008, *p=3
11 free(p);
3: *p = 3
2: p = (int *) 0x804a008
1: i = 1
(gdb) cont
Continuing.
Program exited normally. - p. 92/207 - p. 94/207 - p. 96/207
(gdb)
insight: fenètre des registres du MSP insight: état de la mémoire du MSP Outils de GCC
introduction au MSP 430 introduction au MSP 430 introduction au MSP 430

Utilisation de GCC pour le développement de code embarqué

● gcc ● gcc ● gcc
● gdb ● gdb ● gdb
- p. 97/207 - p. 99/207 - p. 101/207
insight: connexion au programme Liens à connaître Assembleur dans le code C
introduction au MSP 430 introduction au MSP 430 ■ make, documentation introduction au MSP 430 ■ On peut include directement des instructions assembleur
http://www.gnu.org/software/make/manual/make.html Processeurs embarqués
dans le code C avec la fonction __asm__
Outils GNU pour la compilation Outils GNU pour la compilation
■ gcc home page: http://gcc.gnu.org/ Outils GNU pour la compilation
int main(void) {
int i;
l’embarqué: GCC l’embarqué: GCC ■ gdb documentation l’embarqué: GCC
int *p,*res;
● gcc ● gcc http://www.gnu.org/software/gdb/documentation/, ● gcc
● gdb ● gdb ● gdb
__asm__("mov #304, R4"); // p=0x130;
__asm__("mov #2, @R4"); // *p=2;
__asm__("mov #312, R4"); //p=0x138;
__asm__("mov #5, @R4"); //*p=5;
__asm__("mov #314, R4");
__asm__("mov @R4, R5"); //Res=mem(0x13A);
nop();
}
■ Permet d’écrire des pilotes de périphériques, de contrôler la
gestion des interruptions sans système d’expoitation
- p. 98/207 - p. 100/207 - p. 102/207
Assembleur dans le code C Gestionnaire d’interruption Le LD script
introduction au MSP 430 ■ On peut aussi mettre explicitement des variables dans des introduction au MSP 430 ■ Beaucoup de périphériques dédiés /* code C de gestion de l’interruption */
introduction au MSP 430 ■ L’éditeur de liens assemble les différents fichiers objets
void isr_C( void ) {
registres sans connaître l’allocation de registres faite par le Processeurs embarqués
communiquent avec le processeur /* ISR: interupt service routine
résultant de la compilation séparée des différents fichiers.
processeur Outils GNU pour la compilation
par des interruptions faire quelque chose en C */
...
■ C’est là que sont résolus les appels à des fonctions entre
Un compilateur pour Un compilateur pour ◆ Problèmes (adresse mémoire Un compilateur pour
l’embarqué: GCC ■ Exemple: utilisation de la fonction fsinx du 68881: l’embarqué: GCC
}
l’embarqué: GCC fichiers ou à des fonctions de bibliothèques non fournies par
● GCC
● gcc __asm__("fsinx %1,%0" : "=f" (result) : "f" (angle)); ● GCC
● gcc
invalide), erreur de transmission /* code assembleur utilisé
● GCC
● gcc l’utilisateur
● gdb ● gdb sur le bus dans le code source */ ● gdb
● Pile d’exécution ■ %0 et %1 représentent le résultat et l’opérande de la ● Pile d’exécution __asm__(" ● Pile d’exécution ■ C’est aussi là que sont agencées les différentes sections
◆ Fin de tache pour un accélérateur .global _isr
Pile d’exécution fonction qui vont correspondre aux variables result et Pile d’exécution _isr: Pile d’exécution mémoire dans l’espace d’adressage final.
matériel
angle du programme C /* Sauvegarde des registres
◆ Détection de données pour un * choisis
■ "f" est une directive indiquant à gcc qu’il doit utiliser des senseurs
*/
push r0
registres flottants push r1
■ GCC ne peut pas généralement pas ...
/* appel du gestionnaire */
directement compiler un jsr _isr_C
gestionnaire d’interruption (retour /* restauration des registre
* et retour
par rte: return from exception) */
...
■ on peut contourner ce problème en pop r1
pop r0
encapsulant la procédure de gestion rte
de l’interruption ");
- p. 103/207 - p. 105/207 - p. 107/207
Contrôler les section du programme Gestionnaire d’interruption pour MSP430 Exemple de LD script (MIPS)
introduction au MSP 430 ■ Le code assembleur contient différentes sections. Par introduction au MSP 430 ■ Le compilateur msp430-gcc dispose de facilité pour cela introduction au MSP 430 /* Une list de fichier à inclure (les autres sont
spécifiés par la ligne de commande */
exemple avec GCC Processeurs embarqués
■ Le mot cles interrupt (CODE_INTERRUPT) permet de Processeurs embarqués
INPUT(libc.a libg.a libgcc.a libc.a libgcc.a)
Outils GNU pour la compilation ◆ La section .text contient les instructions du programme Outils GNU pour la compilation Outils GNU pour la compilation
déclarer une fonction comme handler d’interruption et de /* Specification du format de sortie
Un compilateur pour ◆ La section .data contient des données statiques etc. Un compilateur pour Un compilateur pour
l’embarqué: GCC l’embarqué: GCC faire les traitement supplémentaires par rapport à un appel l’embarqué: GCC
■ Spécification de fichier de
(binaire :bin}, Intel Hex:
ihex, debug coff-\$target */
● gcc
■ Le concepteur de logiciel embarqué veut souvent contrôler ● gcc de fonction normal (ici essentiellement sauvegarde du SP ● gcc
librairie
OUTPUT_FORMAT("coff-sh")
● gdb
explicitement la répartition des variables globales dans les ● gdb
sur la pile). ● gdb
sections (à la compilation): pour distinguer les variables des

■ Spécification du format de /* list of our memory sections */
Pile d’exécution Pile d’exécution ■ Le compilateur dispose aussi d’un certain nombre de macro Pile d’exécution
sortie MEMORY {
constantes par exemple. pour désigner les ports, les diverses paramètres du MSP, vect : ORIGIN = 0x00000000, LENGTH = 1k
■ Il peut vouloir aussi contrôler la répartition des sections dans elles sont dans le répertoire /include/msp430, là ou les
■ 5 sections nommées rom : ORIGIN = 0x00000400, LENGTH = 127k
reset: ORIGIN = 0xBFC00000, LENGTH = 0x00000400
ram : ORIGIN = 0x400000, LENGTH = 128k
les composants matériels (à l’édition de lien et au outils mspgcc ont étés installé. En particulier cache : ORIGIN = 0xfffff000, LENGTH = 4k
chargement du programme) ◆ iomacro.h }
◆ msp430x44x.h
■ Utilisation de la directive __attibute__
◆ msp430/basic_timer.h
const int put_this_in_rom
◆ ...
__attribute__((section("myconst" )));
const int put_this_in_flash
__attribute__((section("myflash" )));
- p. 104/207 - p. 106/207 - p. 108/207

Exemple de LD script (suite) Pile d’exécution Appel de procédure: état de la pile

■ Description du placement /* uninitialized data */
introduction au MSP 430 ■ Le mécanisme de transfert de contrôle entre les procédures introduction au MSP 430
avant l’appel après l’appel
de chaque section en SECTIONS {
.bss : Processeurs embarqués
est implémenté grâce à la pile d’exécution. Processeurs embarqués
Outils GNU pour la compilation /* the interrupt Outils GNU pour la compilation
■ Le programmeur à cette vision de la mémoire virtuelle: Outils GNU pour la compilation SP
Un compilateur pour
mémoire vector table */
{
__bss_start = . ; Un compilateur pour Un compilateur pour
.vect :
l’embarqué: GCC
● GCC
■ Création d’un symbole au {
*(.bss)
*(COMMON)
__vect_start = .; Code static Tas Memoire libre Pile AR procédure

● gcc
● gdb
début de la section (ex: *(.vect);
__bss_end = . ; Pile d’exécution
● Pile
Pile d’exécution
● Pile
} > ram
● Pile d’exécution __text_start) et à la fin __vect_end = .; appelée
} > vect
Pile d’exécution (__text_end ) /* initialized data */ SP ARP
.init : AT (__text_end)
/* code and constants */
{
■ Placement des parties du .text :
__data_start = .; ⇒
{
code préfixé par la directive __text_start = .;
*(.data)
AR procédure AR procédure
__data_end = .;
.text dans la section rom *(.text) } > ram 0 100000
appelante appelante
*(.strings) (petites adresses) (grandes adresses)
de la mémoire. __text_end = .;
/* application stack */
ARP
} > rom
■ Éventuellement insertion de .stack :
{
■ Le tas (heap) est utilisé pour l’allocation dynamique.
.reset : {
code spécifiquement écrit ./libhandler.a(.reset)
__stack_start = .; ■ La pile (stack) est utilisée pour la gestion des contextes des
*(.stack)
directement dans la } > reset
__stack_end = .; procédures (variable locales, etc.)
} > ram
mémoire (.reset) }
- p. 109/207 - p. 111/207 - p. 113/207
Enregistrement d’activation Contenu de l’AR
introduction au MSP 430 introduction au MSP 430 ■ Appel d’une procédure: empilement de l’enregistrement introduction au MSP 430

d’activation (AR pour activation record). Processeurs embarqués
SP
Variables locales
■ L’AR permet de mettre en place le contexte de la procédure.
■ Cet AR contient Adresse de retour
Pile d’exécution
● GCC
AR procédure
● gcc Pile d’exécution ◆ L’espace pour les variables locales déclarées dans la Pile d’exécution
appelée ARP appelant
● gdb ● Pile ● Pile
● Pile d’exécution procédure ARP Résultat
Pile d’exécution ◆ Des informations pour la restauration du contexte de la Sauvegarde des registres
procédure appelante:
■ Pointeur sur l’ AR de la procédure appelante ( ARP ou FP
AR procédure Parametres
appelante
pour frame pointeur).
■ Adresse de l’instruction de retour (instruction suivant
l’appel de la procédure appelante).

■ Éventuellement sauvegarde de l’état des registres au
moment de l’appel.
- p. 110/207 - p. 112/207 - p. 114/207

Retour de procédure: état de la pile Exemple: arbre d’appel Code assembleur fibonnacci (-O0)
push r11 ;sauvegarde des registres caller-save r11 sur la pile
push r5 ; (cloberred): R4-R11
procedure main();
push r4 ;
var y...
mov r1, r5 ;
avant le retour après le retour
procedure mere() Pile ( lors du 2eme appel de fils): introduction au MSP 430
add #8, r5 ;R5 pointe dans la pile

Processeurs embarqués Processeurs embarqués var z: ... Processeurs embarqués
sub #4, SP ;reserve deux nouveaux entiers dans la pile
procedure f ils();
Outils GNU pour la compilation SP Outils GNU pour la compilation
Arbre Outils GNU pour la compilation
mov r1, r4 ;R4 pointe vers le somme de pile
begin { f ils()}
Un compilateur pour
l’embarqué: GCC
Un compilateur pour
l’embarqué: GCC ... d’appel: SP Un compilateur pour
l’embarqué: GCC
mov r15, 0(r4) ;mise en place de l’argument i en var. locale
cmp #2, 0(r4) ;comparaison de i à 2
Pile d’exécution AR procédure Pile d’exécution
end; { f ils()} AR procédure Pile d’exécution
jge $+8 ;branchement si i>=2 (instr mov @R4, R5)
● Pile ● Pile procedure employeur(); fils ● Pile
appelée var y.... Lien statique mov #1, 2(r4) ;sinon mise en place du resultat (SP+2)
main ARP (SL: static link)
SP jmp $+26 ;saut à mov 2(r4), r15
ARP begin { employeur()}
mov @r4, r15 ;Si i>2 R15 <- i
x:=... ARP appelant AR procédure
mere add #-1, r15 ;R15 <- i-1
⇒ f ils(); (dynamic link) employeur Lien statique
(SL: static link) call #4826 ;call fib
AR procédure AR procédure end;
fils mov r15, r11 ;resultat dans r15 -> R11 <- fib(i-1)
begin { mere()}
appelante appelante ARP appelant mov @r4, r15 ;R15 <- i
z:=1; employeur (dynamic link) AR procédure
ARP decd r15 ;R15 <- i-2
f ils(); mere
call #4826 ;call fib
employeur();
fils add r15, r11 ;R11 <- fib(i-1) + fib(i-2)
end;
mov r11, 2(r4) ;mise en place du resultat dans (SP+2)
begin { main()}
mov 2(r4), r15 ;mise en place du resultat dans R15
mere();
add #4, SP ;on libère les deux entier
...
pop r4 ;restauration R4
end;
pop r5 ;restauration R5
pop r11 ;restauration r11
- p. 115/207 - p. 117/207 - p. 119/207
ret ;retour au code appelant
Lien statique et Lien dynamique Exemple: fibonnacci sur MSP Code assembleur fibonnacci (options -O2)
0x1258 <fib>: push r11 ;
0x125a <fib+2>: push r10 ;
0x125c <fib+4>: mov r15, r10 ;
introduction au MSP 430 ■ Considérons une procédure employeur qui appelle une introduction au MSP 430 int fib (int i) introduction au MSP 430 0x125e <fib+6>: cmp #2, r15 ;subst r3 with As==10
0x1260 <fib+8>: jl $+24 ;abs dst addr 0x1278
procédure fils. Processeurs embarqués { Processeurs embarqués
0x1262 <fib+10>: add #-1, r10 ;subst r3 with As==11
■ Dans l’AR de fils, l’ARP appelant pointe sur l’AR de Outils GNU pour la compilation if (i<=1) return(1); Outils GNU pour la compilation
0x1264 <fib+12>: mov r10, r15 ;
Un compilateur pour
l’embarqué: GCC employeur.
Un compilateur pour
l’embarqué: GCC
else return(fib(i-1)+fib(i-2)); Un compilateur pour
l’embarqué: GCC
0x1266 <fib+14>: call #4696 ;#0x1258
} 0x126a <fib+18>: mov r15, r11 ;
Pile d’exécution
● Pile
■ Ce pointeur l’ARP est quelquefois appelé le lien dynamique, il Pile d’exécution
● Pile
Pile d’exécution
● Pile
0x126c <fib+20>: add #-1, r10 ;subst r3 with As==11
pointe sur l’environnement de la procédure appelante (ici 0x126e <fib+22>: mov r10, r15 ;
0x1270 <fib+24>: call #4696 ;#0x1258
employeur).
0x1274 <fib+28>: add r11, r15 ;
■ Considérons maintenant la procédure mère dans laquelle 0x1276 <fib+30>: jmp $+4 ;abs dst addr 0x127a
fils à été déclarée. 0x1278 <fib+32>: mov #1, r15 ;subst r3 with As==01
0x127a <fib+34>: pop r10 ;
■ Dans certains langages comme Pascal, la procédure fils 0x127c <fib+36>: pop r11 ;
peut accéder aux variables de mère 0x127e <fib+38>: ret
■ Pour cela on a besoin d’un lien statique qui est un pointeur
sur l’environnement de la procédure ou l’on a été déclaré.
- p. 116/207 - p. 118/207 - p. 120/207

Cours SETREX6

Hochgeladen von

Dokumentinformationen

Originaltitel

Copyright

Verfügbare Formate

Dieses Dokument teilen

Dokument teilen oder einbetten

Freigabeoptionen

Stufen Sie dieses Dokument als nützlich ein?

Sind diese Inhalte unangemessen?

Copyright:

Verfügbare Formate

Cours SETREX6

Hochgeladen von

Copyright:

Verfügbare Formate

Références CPU RISC 16 bits

introduction au MSP 430

SETRE: Systèmes Embarqués Temps Réel Processeurs embarqués

Outils GNU pour la compilation

Un compilateur pour ■ Doc du MSP430 (MSP430x14x family) Un compilateur pour

MAB Memory Address Bus

MDB Memory Data Bus

R15 General Purpose

Embedded Computing System Design. Un survey assez

Recherche): Reserved V SCG1 SCG1

- p. 1/207 - p. 3/207 - p. 5/207

Plan du cours 1 (3H) Architecture du MSP Periphérique intégrés

introduction au MSP 430 ■ architecture du MSP430 introduction au MSP 430

Watchdog Peripheral Peripheral Peripheral

- p. 2/207 - p. 4/207 - p. 6/207

introduction au MSP 430

◆ Accessible par des registres mappés entre les adresses reset.

◆ Écriture à l’adresse 0x138, positionne le deuxième périphériques FLASH/ROM

◆ 0x200 à B=0x9FF: RAM debug avec périphériques

(2Ko), Données et pile 0000000000000

Exemple: multiplieur cablé Chaîne de développement Chaîne de développement

introduction au MSP 430

int *p,*res; ◆ Simulation avec msp430-gdb-insight (sans les

int main(void) { périphériques) TCP

int i; __asm__("mov #304, R4"); ◆ Simulation avec msp430-gdb-insight et wsim

p=0x130; // *p=2; MSP430 exécution

Un compilateur pour Un compilateur pour Un compilateur pour

Pile d’exécution Pile d’exécution Pile d’exécution

■ Les applications sont plus variées que pour les ordinateurs

- p. 13/207 - p. 15/207 - p. 17/207

Part de marché Et au sein des processeurs Architecture "Von Neuman" ou "Princeton"

Pile d’exécution Pile d’exécution Pile d’exécution

- p. 14/207 - p. 16/207 - p. 18/207

- p. 19/207 - p. 21/207 - p. 23/207

■ Deux classes de jeux d’instructions:

- p. 20/207 - p. 22/207 - p. 24/207

● Charactéristiques ● Charactéristiques ● Charactéristiques control/Status

- p. 25/207 - p. 27/207 - p. 29/207

Le pipeline RISC: exemple du MIPS Le pipeline RISC: exemple du MIPS cycle 1

- p. 26/207 - p. 28/207 - p. 30/207

Pile d’exécution Pile d’exécution Pile d’exécution

108 sw R1,500 108 sw R1,500

- p. 31/207 - p. 33/207 - p. 35/207

cycle 3 cycle 5 Exemple d’exécution avec pipeline

Memory Memory Memory

108 sw R1,500 108 sw R1,500 108 sw R1,500

- p. 32/207 - p. 34/207 - p. 36/207

Memory load Memory

cycle 3 cycle 5 cycle 7

introduction au MSP 430 ■ Exécution non pipelinée: introduction au MSP 430

pipeline car il faut attendre de décoder l’adresse de portables) 7 15

- p. 43/207 - p. 45/207 - p. 47/207

Parallélisme au sein du processeur Mémoire Hiérarchie Mémoire

introduction au MSP 430

◆ Exemple: le PowerPC 970 (4 ALU, 2 FPU) Mémoire cache

pouvait être regroupe sur 64 bits, 128 bits etc.) contrôleur

- p. 49/207 - p. 51/207 - p. 53/207

68000, x86 MIPS, ARM, SuperH et PowerPC Micro-contrôleurs

- p. 50/207 - p. 52/207 - p. 54/207

- p. 55/207 - p. 57/207 - p. 59/207

- p. 56/207 - p. 58/207 - p. 60/207

◆ Consommation dynamique : Pdyn = C.V 2 .α.f Outils GNU pour la compilation

Un compilateur pour du design) Un compilateur pour

int p,res; ◆ Simulation avec msp430-gdb-insight (sans les

int i; asm("mov #304, R4"); ◆ Simulation avec msp430-gdb-insight et wsim