Evaluation de la consommation en énergie des programmes

Transcription

N° d’ordre : ……………………………………
UNIVERSITE MOHAMMED BOUDIAF-M’SILA
FACULTE DE TECHNOLOGIE
DEPARTEMENT D’ELECTRONIQUE
MEMOIRE
Présenté pour obtenir le diplôme de
MAGISTER
EN ELECTRONIQUE
Par
BENDIB AHMED
Option : Commande des systèmes électro-énergétiques
SUJET
Evaluation de la consommation en énergie des
programmes implantés dans les systèmes
embarqués à base de microprocesseurs DSPs
Soutenu publiquement le : 15/12/2014 Devant le jury composé de :
Pr. CHIKOUCHE Djamel
Prof. Univ M’sila
Président
Pr. BOUAMAR Mohamed
Prof. Univ M’sila
Rapporteur
Dr. HOCINI Abdeslam
MCA Univ M’sila Examinateur
Dr. KHEDROUCHE Djamel
MCA Univ M’sila Examinateur
Promotion 2013/2014
REMERCIEMENTS
Je tiens à remercier premièrement mon encadreur, Monsieur le Pr. BOUAMAR
Mohamed, Professeur à l’université de M’sila pour avoir accepté de m'encadrer et de me
suivre tout au long de la réalisation de ce mémoire, pour son caractère de noblesse
incomparable, pour sa générosité et sa grande patience dont il a su faire preuve malgré ses
charges académiques et professionnelles. Je pourrai cordialement lui exprimer mes profonds
remerciements pour son soutien et sa présence dans les moments les plus pénibles. Qu’il
trouve ici l’expression de ma gratitude pour la confiance qu’il m’a faite.
Je remercie Monsieur le Pr. CHICOUCHE Djamel, Professeur à l’université de M’sila
pour l’honneur qu’il me fait en présidant ce jury, et par son esprit scientifique de haut niveau,
pour m’avoir orienté vers le plus approprié.
J’adresse également mes très sincères remerciements à l’ensemble des membres pour
l’honneur qu’ils m’ont fait pour avoir accepter de faire partie de ce jury en acceptant
d’examiner et d’évaluer ce travail. J’exprime mes vifs respects au Dr. HOCINI Abdeslam,
Maître de conférences (A) à l’université de M’sila et au Dr. KHEDROUCHE Djamel, Maître
de conférences (A) à l’université de M’sila. Soyez assurés messieurs les membres du jury de
ma profonde reconnaissance de l’attention que vous avez portée à ce mémoire et pour le
temps que vous avez consacré à son évaluation.
Finalement, je remercie tous mes amis, particulièrement KHERBACHI Abdelhammid
ainsi que toutes les personnes qui ont contribué de près ou de loin à ce modeste travail.
Résumé :
Les processeurs de traitement numérique du signal (DSPs), essentiellement à virgule fixe, ont
acquis depuis quelques années un intérêt particulier dans les applications embarquées. Un domaine où
la consommation d'énergie des dispositifs conçus doit être maîtrisée et minimisée. Leur utilisation est
courante dans différents domaines, spécialement dans l’industrie, la commande de processus, le
multimédia, les techniques spatiales, les techniques de navigation, ainsi que dans les nouvelles
technologies de l'information et de la communication.
L’objectif recherché dans le cadre de ce mémoire, est l’étude, l’évaluation et l’optimisation des
performances de programmes implantés dans les DSPs, en vue de minimiser leur consommation en
énergie. L’optimisation de l’énergie, contrainte majeure des systèmes embarqués, est à montrer à
travers une application en assembleur basée sur le calcul FFT dans un processeur DSP à virgule fixe.
Mots clés : Applications embarqués, Consommation d’énergie, Processeurs DSPs, DSP à virgule fixe,
Assembleur, Optimisation d’énergie.
: ‫ﻣﻠﺨﺺ‬
.‫ﻣﻌﺎﻟﺠ ﺎت اﻹﺷ ﺎرة اﻟﺮﻗﻤﯿ ﺔ وﺧﺎﺻ ﺔ ذات اﻟﻔﺎﺻ ﻠﺔ اﻟﺜﺎﺑﺘ ﺔ ﻟﻘﯿ ﺖ ﻣﻨ ﺬ ﺳ ﻨﻮات ﻗﻠﯿﻠ ﺔ اھﺘﻤﺎﻣ ﺎ ﺧﺎﺻ ﺎ ﻓ ﻲ اﻟﺘﻄﺒﯿﻘ ﺎت اﻟﻤﺪﻣﺠ ﺔ‬
،‫ اﺳ ﺘﺨﺪاﻣﮭﺎ ﺷ ﺎﺋﻊ ﻓ ﻲ ﻋ ﺪة ﻣﺠ ﺎﻻت‬.‫اﺣ ﺪ اﻟﻤﺠ ﺎﻻت ﺣﯿ ﺚ اﺳ ﺘﮭﻼك اﻷﺟﮭ ﺰة اﻟﻤﺼ ﻤﻤﺔ ﻟﻠﻄﺎﻗ ﺔ ﯾﺠ ﺐ أن ﯾﻜ ﻮن ﻣ ﺘﻘﻦ وﻣﻘﻠ ﻞ‬
‫ وﻛ ﺬﻟﻚ ﻓ ﻲ ﻣﺠ ﺎل‬،‫ ﺗﻘﻨﯿ ﺎت اﻟﻤﻼﺣ ﺔ‬،‫ اﻟﻮﺳ ﺎﺋﻂ اﻟﻤﺘﻌ ﺪدة‬،‫ اﻟﺘﻘﻨﯿ ﺎت اﻟﻔﻀ ﺎﺋﯿﺔ‬،‫ اﻟ ﺘﺤﻜﻢ ﻓ ﻲ اﻟﻌﻤﻠﯿ ﺎت‬،‫ﺧﺎﺻ ﺔ ﻓ ﻲ اﻟﺼ ﻨﺎﻋﺔ‬
.‫اﻟﺘﻜﻨﻮﻟﻮﺟﯿﺎت اﻟﺠﺪﯾﺪة ﻟﻠﻤﻌﻠﻮﻣﺎت و اﻻﺗﺼﺎﻻت‬
‫ ﻟﻠﺗﻘﻠﯾ ل ﻣ ن‬،DSPs ‫ ﺗﻘ ﺪﯾﺮ وﺗﺤﺴ ﯿﻦ أداء اﻟﺒ ﺮاﻣﺞ اﻟﻤﻀ ﻤﻨﺔ ﻓ ﻲ اﻟﻤﻌﺎﻟﺠ ﺎت‬،‫اﻟﮭ ﺪف ﻣ ﻦ ھ ﺬه اﻟﻤ ﺬﻛﺮة ھ ﻮ دراﺳ ﺔ‬
‫ و ﺳﻨﻌﺮﺿ ﮫ ﻣ ﻦ ﺧ ﻼل ﺗﻄﺒﯿ ﻖ ﻓ ﻲ ﻟﻐ ﺔ اﻟﺘﺠﻤﯿ ﻊ‬،‫ ﻋ ﺎﺋﻖ رﺋﯿﺴ ﻲ ﻓ ﻲ اﻷﻧﻈﻤ ﺔ اﻟﻤﺪﻣﺠ ﺔ‬،‫ اﻟﺘﺤﺴ ﯿﻦ ﻓ ﻲ اﻟﻄﺎﻗ ﺔ‬.‫اﺳ ﺘﮭﻼﻛﮭﺎ ﻟﻠﻄﺎﻗ ﺔ‬
.‫ ذو ﻓﺎﺻﻠﺔ ﺛﺎﺑﺘﺔ‬DSP ‫ ﻓﻲ ﻣﻌﺎﻟﺞ‬FFT ‫ﯾﻌﺘﻤﺪ ﻋﻠﻰ ﺣﺴﺎب‬
‫ ﺗﺤﺴ ﯿﻦ‬،‫ ﻟﻐ ﺔ اﻟﺘﺠﻤﯿ ﻊ‬،‫ ذو ﻓﺎﺻ ﻠﺔ ﺛﺎﺑﺘ ﺔ‬DSP ،DSPs ‫ ﻣﻌﺎﻟﺠ ﺎت‬،‫ اﺳ ﺘﮭﻼك اﻟﻄﺎﻗ ﺔ‬،‫ اﻟﺘﻄﺒﯿﻘ ﺎت اﻟﻤﺪﻣﺠ ﺔ‬: ‫ﻛﻠﻤ ﺎت ﻣﻔﺘﺎﺣﯿ ﺔ‬
.‫اﻟﻄﺎﻗﺔ‬
Abstract:
The digital signal processors (DSPs), essentially with fixed-point, have acquire a particular interest
in the last years in the embedded applications. A domain where the power consumption of the
conceived devices must be mastered and minimized. Their use is current in different domains,
especially in industry, the control of process, the multimedia, space techniques, navigation techniques,
as well as the new technologies of information and communication.
The objective being searched in the frame of this memoire is the study, the evaluation and the
optimization of the performances of programs implanted in the DSPs, in order to minimize their
consumption of energy. Energy optimization, the major constraint of embedded systems, is to be
shown by an application in the assembly language based on the calculation of FFT in a fixed-point
DSP processor.
Key words: Embedded systems, Energy consumption, DSP processors, Fixed point DSP, Assembly
language,
Energy
optimization
Table des matières
TABLE DES MATIERES
Introduction Générale
Introduction Générale .............................................................................................................................. 1
Chapitre I
Consommation d'énergie dans les systèmes embarqués
1. Introduction ...................................................................................................................................... 4
2. Les systèmes embarqués ................................................................................................................. 5
2.1. Introduction .............................................................................................................................. 5
2.2. Caractéristiques principales ...................................................................................................... 5
2.3. Architecture des systèmes embarqués ...................................................................................... 7
2.3.1. Les systèmes embarqués de première génération ............................................................. 7
2.3.2. Les systèmes embarqués de deuxième génération ........................................................... 8
2.3.3. Les systèmes embarqués de troisième génération ........................................................... 9
2.4. Utilisations des systèmes embarqués...................................................................................... 11
2.5. Contraintes des systèmes embarqués...................................................................................... 11
2.5.1. Temps réel et Activités .................................................................................................... 11
2.5.2. Consommation énergétique ............................................................................................. 12
2.5.3. Mémoire .......................................................................................................................... 12
2.5.4. Tolérance aux fautes........................................................................................................ 12
2.5.5. Hétérogénéité .................................................................................................................. 13
3. La consommation d’énergie dans les systèmes embarqués .......................................................... 13
3.1. La consommation dans les architectures électroniques .......................................................... 13
3.1.1. Consommation dans les circuits CMOS ......................................................................... 13
3.1.1.1. Consommation dynamique........................................................................................ 15
3.1.1.2. Consommation statique ............................................................................................. 16
3.2. Les techniques d’évaluation et d’optimisation de la consommation ...................................... 17
3.2.1. Évaluation et gestion de la consommation au niveau transistor ...................................... 17
3.2.1.1. Techniques et outils d’évaluation de la consommation au niveau transistor ............ 17
3.2.1.2. Méthodes de gestion de la consommation au niveau transistor ................................ 18
3.2.2. Évaluation et gestion de la consommation au niveau RTL .............................................. 19
Table des matières
3.2.3. Évaluation et gestion de la consommation au niveau système ......................................... 20
3.2.3.1. Techniques et outils d’évaluation de la consommation au niveau système .............. 21
3.2.3.2. Méthodes de gestion de la consommation au niveau système .................................. 24
4. Les Processeurs dans les systèmes embarqués............................................................................... 26
4.1. Architectures embarquées ..................................................................................................... 27
4.1.1. Les processeus DSPs ....................................................................................................... 27
4.1.2. Les circuits FPGAs.......................................................................................................... 28
4.1.3. Les circuits ASICs ........................................................................................................... 28
4.2. Estimation de la consommation de puissance de processeurs au niveau système .................. 29
4.2.1. Niveau fonctionnel ......................................................................................................... 29
4.2.2. Niveau instruction .......................................................................................................... 30
4.2.3. Hybride ........................................................................................................................... 31
5. Conclusion ..................................................................................................................................... 32
Chapitre II
Les Processeurs DSP à virgules fixe et flottante
1. Introduction .................................................................................................................................... 33
2. Généralités sur les processeurs DSPs ............................................................................................. 33
2.1. Introduction ............................................................................................................................ 33
2.2. Spécificités des DSPs ............................................................................................................. 35
2.2.1. Principale distinction entre un microprocesseur et un DSP ........................................... 35
2.2.1.1. L'opération MAC ...................................................................................................... 35
2.2.1.2. L'accès à la mémoire ................................................................................................. 36
2.5. Performances des DSPs ........................................................................................................ 36
2.5.1. Mesure de vitesse de calcul ............................................................................................. 37
2.5.2. Mesure du temps d’exécution (« Benchmark »).............................................................. 38
3. Critères de choix d’un processeur DSP .......................................................................................... 39
3.1. Arithmétique de calcul ........................................................................................................... 40
3.2. Dynamique des mots .............................................................................................................. 40
3.3. Vitesse de calcul ..................................................................................................................... 41
3.4. Organisation de la mémoire ................................................................................................... 41
3.5. Facilité de développement ...................................................................................................... 42
3.6. Appui multiprocesseur ........................................................................................................... 42
3.7. Consommation d’énergie ....................................................................................................... 43
Table des matières
3.8. Coût ........................................................................................................................................ 43
4. Exemples de processeurs DSPs ..................................................................................................... 44
4.1. Les DSPs à virgule flottante ................................................................................................... 44
4.1.1. Le processeur TMS320C67xx ........................................................................................ 45
4.1.2. Le processeur ADSP2116x ............................................................................................ 46
4.2. Les DSPs à virgule fixe .......................................................................................................... 48
5. Conclusion ..................................................................................................................................... 50
Chapitre III
Langage machine et consommation d’énergie
1. Introduction .................................................................................................................................... 51
2. Langages de programmation .......................................................................................................... 51
2.1. Introduction ............................................................................................................................ 51
2.2. Utilisation ............................................................................................................................... 52
2.3. Évolution des langages ........................................................................................................... 52
2.3.1. Langage machine............................................................................................................ 53
2.3.2. Langage d'assembleur .................................................................................................... 53
2.3.3. Langage de haut niveau .................................................................................................. 54
2.3.4. Langage de quatrième génération................................................................................... 54
2.4. Le langage C........................................................................................................................... 55
3. Langage assembleur et langage machine ....................................................................................... 56
3.1. Intérêts de programmation en assembleur .............................................................................. 57
3.2. Particularités de l'assembleur ................................................................................................. 57
3.3. Usage du langage assembleur................................................................................................. 58
3.4. Conditions d'utilisation du langage assembleur ..................................................................... 59
4. Performances d’application implantées sur processeur ................................................................. 59
4.1. Métriques d’évaluation des performances .............................................................................. 59
4.2. Estimation d’énergie au niveau instructions........................................................................... 60
4.2.1. Instruction sans transition............................................................................................... 60
4.2.2. Instruction avec transition unique .................................................................................. 61
4.2.3. Instruction avec transition .............................................................................................. 62
5. Performances des algorithmes implantés sur DSP ......................................................................... 62
6. Conclusion ..................................................................................................................................... 63
Table des matières
Chapitre IV
Application sur DSP à virgule fixe
1. Introduction .................................................................................................................................... 66
2. Exemple de test de performances…………..……………………………………………..……………..……..……….....66
3. Implementation .............................................................................................................................. 67
3.1. Mise en oeuvre de l’algorithme FFT radix-2 avec la fonction inversion des bits ..................68
3.2. Mise en oeure de l’algorithme FFT radix-2 sans la fonction inversion de bits ..................... 71
4. Simulation .................................................................................................................................... 72
3.4. Evaluation du temps d’éxecution ........................................................................................... 72
3.4. Evaluation énergétique ........................................................................................................... 74
5. Conclusion ..................................................................................................................................... 76
Conclusion Générale
Conclusion Générale ......................................................................................................................... 77
Liste des figures
LISTE DES FIGURES
Fig.1.1 : Présentation d’un système embarqué sous forme de couches................................................... 5
Fig.1.2 : Un système embarqué dans son environnement ....................................................................... 6
Fig.1.3 : Architecture embarquée de première génération ...................................................................... 7
Fig.1.4 : Architecture embarquée de deuxième génération ..................................................................... 8
Fig.1.5 : Architecture embarquée de troisième génération ................................................................... 10
Fig.1.6 : Un inverseur, fonction de base réalisée par des transistors CMOS ........................................ 14
Fig.1.7 : Courant de commutation dans un étage inverseur CMOS. ..................................................... 15
Fig.1.8 : Courant de court-circuit dans un étage inverseur CMOS ....................................................... 16
Fig.1.9 : Courant de fuite dans un étage inverseur CMOS.................................................................... 17
Fig.1.10 : Méthodes d’évaluation statistique et probabiliste ................................................................. 20
Fig.1.11 : Architecture d’une mémoire ................................................................................................. 21
Fig.1.12 : Positionnement relatif des architectures de traitement numérique de l’information en
fonction de leur performance et de leur flexibilité…………………………………. ........................... 26
Fig.2.1 : Chaîne complète typique d’un système de traitement numérique du signal .......................... 35
Fig.2.2 : Schéma fonctionnel du TMS320C67xx …. ............................................................................ 45
Fig.2.3 : Schéma fonctionnel de l’ADSP21160 .................................................................................... 46
Fig.2.4 : Constitution interne du DSP ADSP2181 ................................................................................ 50
Fig.3.1 : Temps d’exécution et consommation d’énergie des trois DSPs testés sur le benchmark FIR
(Bloc Données réelles)…………………………………………………………………………………64
Fig.3.2 : Temps d’exécution et consommation d’énergie des trois DSPs testés sur le benchmark FIR
(Bloc Données complexes)…………………………………………………………………………….65
Fig.4.1 : Temps d’exécution et consommation d’énergie des trois DSPs testés sur le benchmark FFTDIT (256 points complexes).…………………………………………………………………….....….67
Fig.4.2 : Schéma de transfert des coefficients FFT et des données vers le DSP...………............…….69
Fig.4.3 : Organigramme de calcul de l’algorithme FFT- DIT radix-2 .................................................. 70
Fig.4.4 : Schéma de transfert des coefficients FFT, des indices et des données vers le DSP
........... 71
Fig.4.5 : Réorganisation des données d’entrée par la technique proposée ............................................ 72
Fig.4.6 : Nombre de cycles consommés en fonction de N .................................................................... 74
Fig.4.7 : Consommation d’énergie de la FFT radix-2 avec et sans la fonction ‘bit reverse’
........... 75
Liste des tableaux
LISTE DES TABLEAUX
Tableau.2.1 : Définition des unités les plus courantes de mesure des performances des DSPs ............ 38
Tableau.3.1 : Une comparaison entre langages assembleur et langage C pour un DSP. ...................... 63
Tableau.3.2 : Performances des trois DSPs testés sur le benchmark FIR (Bloc Données réelles).
……………………..……………………………………………………………………..…………....63
Tableau.3.3 : Performances des trois DSPs testés sur le benchmark FIR (Bloc Données complexes).
………………………………………………………………………………........................................64
Tableau.4.1 : Performances des trois DSPs testés sur le benchmark FFT-DIT (256 points
complexes)………………………………………………………………………..……........................66
Tableau.4.2 : Indices des données d’entrée avec ordre naturel et mode bit reverse pour N=8..
............................................................................................................................................................... 71
Tableau.4.3 : Temps d’exécution de calcul FFT radix-2 avec la fonction «bit-reverse » ..................... 73
Tableau.4.4 : Temps d exécution de calcul FFT radix-2 sans fonction « bit reverse » ........................ 73
Tableau.4.5 : Energie consommée en fonction de N par l’ADSP2181(avce et sans ‘bit
reverse’)…………………………………………..……………………………………………………75
Notation
NOTATION
ABS: Anti-lock braking system
ADSL: Asymmetric Digital Subscriber Line
ALU: Arithmetic and Logic Unit
API: Application Programming Interface
ARM: Advanced Risc Machine
ASIC: Application Specific Integrated Circuit
BDT: Berkeley Design Technology
BS: Barrel Shifter
CAO : Conception Assistée par Ordinateur
CMOS : Complementary Metal-Oxide-Semiconducteur
CPU: Central Processing Unit
DAB: Direct Broadcast Audio
DAG: Data Address Generator
DFT: Discrete Fourier Transform
DIT: Decimation In Time
DM: Data Memory
DMA: Direct Memory Access
DSL: Digital Subscriber Line
DSP: Digital Signal Processor
DVD: Digital Video Disks
EDGE: Enhanced Data Rates for GSM Evolution
EEG : ElectroEncephaloGram
EMG : ElectroMyoGram
E/S: Entrée /Sortie
FFT: Fast Fourier Transform
FIFO: First In First Out
FIR: Finite Impulse Response
Notation
FLPA : Functional Level Power Analysis
FPGA: Field-Programmable Gate Arrays
GPS: Global Positioning System
GPU: Graphics Processing Units
GSM: Global System Mobile
HDSL: High Digital Subscriber Line
IHM: Interface Human Machine
ILPA : Instruction Level Power Analysis
IP: Internet Protocol
MAD: Multiply and Addition
MAC: Multiply and ACcumulate
MIMD: Multiple Instruction Multiple Data
MIPS: Millions Instructions per second
MIT: Massachusetts Institute of Technology
MPEG: Motion Picture Experts Group
MVP: Multimedia Video Processor
NoC: Network on Chip
OSI: Open Systems Interconnection
PDA: Personnal Digital Assistant
PC: Personal Computer
PID: Proportional Integral Derive
PM: Program Memory
RAM: Random Access Memory
RISC: Reduced Instruction Specific Circuit
ROM: Read Only Memory
PRML: Partial Response, Maximum Likehood
RTL: Register Transfer level
SIMD: Single Instruction Multiple Data
SIM : Subscriber Identity Module
Notation
SoC: System on Chip
SPEC95: Standard Performance Evaluation Corporation 95.
SRAM: Static Random Memory
TDSI: Traitement Du Signal et de l’Image
TI: Texas Instrument
TVHD: Télévision Haute Définition
UAL: Unité Arithmétique et Logique
UMTS: Universal Mobile Telecommunications System
VC: Video Controller
VHDL : Very high-scale integrated Hardware Description Language
VLIW: Very Large Instruction Word
WiFi: Wireless Fidelity
4G: 4th Generation
Introduction générale
INTRODUCTION GENERALE
Les évolutions technologiques rapides dans le domaine de la micro-électronique ont
permis de développer le secteur des systèmes embarqués. Plus de 10 milliards de processeurs
sont vendus chaque année dont 98% sont destinés au marché des systèmes embarqués [1]. Ce
marché représentait 92 Milliards de Dollars en 2008 avec une croissance annuelle de 5.6%
[2]. Pour le grand public, le nombre d’appareils électroniques utilisés dans la vie quotidienne
personnelle et professionnelle n’a cessé de s’accroître au cours de ces dernières années et les
services offerts sont toujours plus nombreux. Ces appareils sont de plus en plus connectés à
un réseau afin de pouvoir échanger de l’information.
Nombre de ces systèmes embarqués intègre des applications contenant des traitements
mathématiques de données. Ces applications sont issues, par exemple, des domaines du
traitement du signal et de l’image (TDSI: Traitement Du Signal et de l’Image) ou du
contrôle/commande. Elles sont présentes dans de nombreux secteurs comme les
télécommunications, les transports, l’aérospatial, la robotique, l’électronique médicale et
l’électronique grand public. Par exemple, les nouveaux systèmes de téléphonie mobile, tels
que les Smartphones, intègrent de très nombreuses fonctionnalités basées sur des applications
de TDSI pour la connectivité, l’interface avec l’utilisateur ou pour fournir de nouveaux
services. La connectivité est assurée selon différents standards tels que les systèmes de
communication cellulaire de seconde génération (GSM/EDGE: Global System Mobile/
Enhanced Data rates for GSM Evolution), de troisième génération (UMTS: Universal Mobile
Telecommunications System), ou encore de quatrième génération (4G: 4th Generation) ; les
systèmes d’accès aux réseaux locaux sans fil (WiFi: Wireless Fidelity) ou de communication
à courte distance (Bluetooth). De nombreuses interfaces avec l’utilisateur (écran, caméra,
micro, haut-parleurs) sont disponibles et ainsi, l’appareil possède des modules de
compression/décompression du son, de la parole, de l’image et de la vidéo selon différents
standards [3, 4].
En conséquence, les contraintes majeures des systèmes embarqués sont le coût et la
consommation d’énergie. Ces systèmes évoluant dans un contexte temps réel, les temps
d’exécution des applications doivent être minimisés ou au moins maîtrisés.
Avec une complexité accrue des architectures de ce type de systèmes, la consommation en
énergie des périphériques ainsi que celles des processeurs, est devenue une préoccupation
1
primordiale pour les concepteurs de circuits intégrés [5]. Les processeurs, en particulier,
indispensables et plus qu’essentiels aux systèmes embarqués, sont utilisés dans les
équipements électroniques tels que les caméras digitales et les téléphones mobiles, les
plateformes de jeu portables entre autres. La qualité de ces dispositifs ne se résume plus à la
performance de leurs fonctionnalités, mais aussi à la durée de vie de leurs batteries [6].
Les processeurs dédiés au traitement numérique du signal (DSP: Digital Signal Processor)
à virgule fixe sont largement utilisés dans les systèmes embarqués pour cause d’adaptation à
des contraintes d’intégration. La représentation en virgule fixe conduit souvent à des
architectures rapides, nécessitant une surface plus faible et consommant moins d’énergie par
rapport à celles basées sur la représentation en virgule flottante. Avec la représentation en
virgule fixe, la largeur des bus et des mémoires étant plus faible, le prix et la consommation
d’énergie sont moindres [7].
L’optimisation d’un algorithme de traitement du signal dans un processeur DSP exige non
seulement une connaissance approfondie de l’architecture du processeur en question, mais
aussi la maîtrise de sa programmation bas niveau (langage assembleur). Différentes méthodes
sont utilisées par les programmeurs afin d’optimiser les performances d’applications
implantées dans les systèmes embarqués à base de processeurs DSPs à virgule fixe [8, 9, 10].
L’objectif recherché dans le cadre de ce mémoire, est l’étude, l’évaluation et l’optimisation
des performances de programmes implantés dans les DSPs embarqués, en vue de minimiser
leur consommation en énergie. L’optimisation de celle-ci, contrainte majeure des systèmes
embarqués, est à montrer à travers une application en assembleur basée sur le calcul FFT dans
un processeur DSP à virgule fixe. Les programmes sont développés et exécutés sur simulateur
du système de développement de la famille ADSP218x de chez Analog Devices.
Le mémoire est structuré autour de quatre chapitres qui sont présentés comme suit :
Le premier chapitre concerne la description des systèmes embarqués ainsi que les
techniques d’évaluation de leur consommation en énergie. Des généralités, définitions et
caractéristiques fondamentales relatives au système et logiciel embarqué sont présentées, ainsi
que les techniques d’évaluation et optimisation de la consommation d’énergie des différents
composants le constituant.
Dans le deuxième chapitre nous donnons une présentation générale des processeurs DSPs à
virgules fixe et flottante. Une description des principes fondamentaux de ces processeurs est
2
effectuée. Les critères de choix des architectures de calcul, ainsi que des exemples de DSPs
appartenant aux différentes familles sont décrits.
Dans le chapitre trois, nous nous intéressons au langage assembleur et les méthodes
d’évaluation de la consommation d’énergie au niveau processeur. Nous présentons une
introduction générale des langages de programmation et certains détails sur les langages
assembleurs. Les métriques et outils d’évaluation des performances des algorithmes implantés
sur processeur ainsi que les techniques d’estimation d’énergie au bas niveau sont décrites.
Enfin, nous présentons quelques performances d’algorithmes implantés sur processeurs DSPs.
Le quatrième et dernier chapitre est consacré au développement et à l’implémentation de
l’algorithme FFT sur le processeur DSP à virgule fixe, l’ADSP2181. Le but est de proposer
une nouvelle implémentation de la technique de calcul minimisant ainsi l’usage de certains
circuits du processeur et donc optimisant sa consommation en énergie. Les performances en
matière de précision de calcul devraient être similaires à celles obtenues avec l’algorithme
non optimisé.
Une conclusion générale en fin de ce mémoire est prévue, elle retrace une synthèse du
travail effectué et souligne les perspectives envisagées.
3
Chapitre I
Consommation d’énergie dans les systèmes embarqués
CHAPITRE I
CONSOMMATION D'ENERGIE DANS LES SYSTEMES
EMBARQUES
1. INTRODUCTION
Les systèmes embarqués plus connus dans les secteurs de l’automobile, de l’aéronautique
et du militaire, touchent actuellement de nombreux autres domaines, par exemple les cartes à
puce, les systèmes mobiles communicants (tels que les téléphones mobiles, les agendas
électroniques, etc.), les capteurs intelligents, la santé et l'électronique grand public. Ils
apparaissent souvent comme des composants intégrés de systèmes complexes destinés à
effectuer des tâches précises au niveau du dispositif qu’ils contrôlent. La conception et le
développement d'un tel système diffèrent de ceux d'une application logicielle sur une
plateforme standard du fait qu’ils possèdent des caractéristiques et des besoins qui les
distinguent particulièrement des systèmes classiques. En effet, les systèmes embarqués sont
soumis à des contraintes techniques strictes à la fois de performance fonctionnelles mais
également temporelles, de consommation énergétique et de robustesse, qui pèsent sur eux du
fait de leur taille et de leurs ressources limitées. Ces contraintes imposées par les besoins du
système doivent être prises en compte dès les premières phases du cycle de développement
Le terme "embarqué" sous-entend une autonomie d’alimentation. Ces systèmes sont donc
censés être autonomes en énergie. Or, malgré les avancées importantes dans le domaine des
batteries, de nombreux systèmes restent très dépendants de l’énergie disponible et ont une
autonomie encore trop limitée au goût de leurs utilisateurs. Citons par exemple : les
téléphones portables, les PDAs (Personnal Digital Assistant), les ordinateurs portables, les
consoles, etc. Cependant, bien que n’étant pas embarqués et étant alimentés en électricité, les
gros systèmes comme les super calculateurs ont également leurs lots de problèmes liés à
l’énergie. En effet, leur consommation énergétique est très forte, ce qui provoque des pics de
puissance ainsi que des problèmes d’échauffement nécessitant la mise en place de systèmes de
refroidissement ou de climatisation, généralement coûteux et encombrants.
La consommation énergétique de ce type de systèmes est un problème sensible et sa
réduction est devenue une nécessité pour autoriser le déploiement de nouveaux produits. Les
4
Chapitre I
ressources processeurs peuvent sur ce plan avoir un impact considérable, tout particulièrement
pour des applications complexes (multimédia, traitement du signal, etc.).
Ce chapitre présente une description générale des systèmes et logiciels embarqués. Les
causes de dissipation d’énergie ainsi que les principales techniques utilisées pour évaluer et
réduire la consommation des composants, sont alors décrites.
2. LES SYSTEMES EMBARQUES
Le domaine des systèmes embarqués est en train de très rapidement devenir un domaine
technologique incontournable qui intervient dans notre vie quotidienne à tous les niveaux
(par exemple habitations, espaces personnels, hôpitaux, lieux de travail, voitures et transports
en général, centres industriels).
En reprenant la définition proposée par Wayne Wolf [11], on considérera comme
système embarqué tout dispositif programmable qui n’est pas un ordinateur dans le sens
proprement dit du terme et qui, compte tenu des caractéristiques de l’application, a une
conception appropriée à celles-ci. Ces systèmes sont composés de plusieurs couches, comme
l’illustre la figure 1.1. La couche la plus abstraite est la couche de l’application logicielle, elle
communique avec une couche logicielle de plus bas niveau qui représente le système
d’exploitation. Ensuite, vient le réseau de communication matériel, puis les composants
matériels.
Fig.1.1 : Présentation d’un système embarqué sous forme de couches.
2.1. Caractéristiques principales
Les systèmes embarqués ont pour but de permettre aux objets usuels de réagir à
l’environnement. Ils peuvent aussi apporter une interface avec l’utilisateur. La structure de
base de ces systèmes est donnée dans la figure 1.2 : l’environnement est mesuré par divers
5
Chapitre I
capteurs. L’information des capteurs est échantillonnée pour être traitée par le cœur du
système embarqué. Puis le résultat du traitement est converti en signaux qui gérèrent les
actions sur l’environnement (afficheurs d’informations pour l’utilisateur, actionneurs,
transmission d’information, etc.).
Fig.1.2 : Un système embarqué dans son environnement.
Dans la majorité des systèmes embarqués, il n’y a pas d’entrées/sorties standards. Il n’y a
pas aussi réellement un clavier standard (bouton poussoir, clavier matriciel,…), l’affichage est
limité ou n’existe pas du tout. L’interface IHM (Interface Human Machine) peut être simple
comme une diode (LED) qui clignote ou complexe comme un système de vision de nuit
temps réel. La capacité de mémoire de ce système est également limitée.
Un système embarqué est un système dans lequel le matériel et le logiciel sont intimement
liés : Le logiciel est enfoui, noyé dans le matériel, donc il n’est pas facile de les distinguer
clairement comme dans un environnement du système de type ordinateur PC (Personal
Computer).
Chaque système embarqué est un système numérique qui met en œuvre généralement un
processeur. Ce n’est pas un PC en général mais il utilise de plus en plus des architectures
similaires (x86) à basse consommation. Les systèmes embarqués utilisent des circuits
analogues ou des circuits numériques pour augmenter leur performance ou leur fiabilité. Le
processeur du système embarqué est de plus en plus rapide, puissant et bon marché grâce à la
loi empirique de Gordon Moore, cofondateur d’Intel qui affirme que « pour une surface de
silicium donnée, on double le nombre transistors intégrés tous les deux ans» [12].
Le logiciel d’un système embarqué exécute une
application pour réaliser une
fonctionnalité précise et n’exécute donc pas d’applications scientifiques ou grand public
traditionnelles.
6
Chapitre I
Aujourd’hui, les systèmes embarqués sont fortement communicants grâce aux puissances
de calcul offertes par les processeurs pour l’embarqué, et grâce aussi à l’explosion de l’usage
de la connectivité Intra et Internet.
2.2. Architecture des systèmes embarqués
Dans cette section nous présentons les architectures supportées par trois générations
d’outils de conception.
2.2.1. Les systèmes embarqués de première génération
a. Partie matérielle
Les premiers systèmes embarqués supportés par des outils tels que COSYMA et Vulcan
étaient très simples : ils étaient constitués d’un processeur qui contrôlait un nombre restreint
de CIAS (Circuits Intégrés à Applications Spécifiques) ou ASIC (Application Specific
Integrated Circuit) qui étaient appelés périphériques [13, 14]. Cette architecture est
représentée sur la figure 1.3. Les communications de cette architecture se situent au niveau du
bus du processeur et sont de type maître/esclave : le processeur est le maître et les
périphériques sont les esclaves.
Fig.1.3 : Architecture embarquée de première génération.
Les périphériques de ces architectures étaient essentiellement des capteurs et des
actionneurs (contrôleurs magnétiques, sorties, etc.). Le processeur est dédié au calcul et au
contrôle de l’ensemble du système.
Les microcontrôleurs assemblent sur une même puce le processeur et les périphériques.
b. Partie Logicielle
Ne devant pas exécuter de nombreuses opérations simultanées (le nombre de périphériques
et de fonctions étant restreint), les parties logicielles étaient constituées d’un seul programme.
7
Chapitre I
La réaction aux événements était effectuée par le biais de routines de traitement
d’interruptions.
Cette partie logicielle était décrite directement en langage d’assemblage ce qui permettait
d’obtenir un code efficace et de petite taille.
2.2.2. Les systèmes embarqués de deuxième génération
Les premiers systèmes embarqués ne pouvaient fournir que des fonctions simples ne
requérant que peu de puissance de calcul. Leur architecture ne peut pas supporter les
fonctionnalités requises pour les systèmes embarqués actuels à qui il est demandé non
seulement d’effectuer du contrôle, mais aussi des calculs complexes tels que ceux requis pour
le traitement numérique du signal. De nouveaux outils tels que N2C (dans ses nouvelles
versions) permettent de traiter des architectures plus complexes [15].
L’architecture des systèmes embarqués de deuxième génération est composée d’un
processeur central, de nombreux périphériques, et souvent de quelques processeurs annexes
contrôlés par le processeur central. Le processeur central est dédié au contrôle de l’ensemble
du système. Les processeurs annexes sont utilisés pour les calculs; il s’agit souvent de
processeurs spécialisés comme les DSPs. Une telle architecture est représentée dans la figure
1.4 où plusieurs bus de commutation peuvent être nécessaires : chaque processeur dispose de
son bus de communication.
Fig.1.4 : Architecture embarquée de deuxième génération.
b. Partie logicielle
La partie logicielle des systèmes embarqués de deuxième génération est répartie sur
plusieurs processeurs (le processeur principal et les processeurs annexes). Les systèmes
8
Chapitre I
actuels sont trop complexes pour pouvoir être gérés par un unique programme sur le
processeur principal. Il est donc nécessaire d’avoir une gestion multitâche sur ce processeur,
et un système d’exploitation est couramment employé dans ce but.
Le logiciel du processeur central est souvent décrit dans un langage de haut niveau tel que
le C. le logiciel des processeurs annexes est souvent trop spécifique pour être entièrement
écrit dans un langage de haut niveau, et l’utilisation des lagunages d’assemblage est
nécessaire.
2.2.3. Les systèmes embarqués de troisième génération
Les progrès de l’intégration permettant d’envisager des circuits pouvant contenir plusieurs
milliers de portes, il devient donc techniquement possible de fabriquer des systèmes
embarqués pouvant remplir toutes les fonctionnalités souhaitées [16].
Pour pouvoir supporter conjointement les besoins en puissance de calcul et de flexibilité,
ces architectures comprennent de plus en plus de processeurs, qui peuvent chacun se
comporter en maître : l’architecture couramment utilisée, basée sur un processeur central
contrôlant le reste du système, n’est donc plus suffisante.
Alors qu’auparavant le goulet d’étranglement était les ressources en calcul, de nos jours il
est situé plutôt au niveau des communications. Ce sont elles qui en définissent désormais
l’architecture, et non plus les ressources de calcul [17]. La figure 1.5 donne des exemples
d’architectures centrées sur les communications. Dans cette figure, tous les éléments
(processeur, ASIC ou mémoire), sont traités de la même manière. Le premier exemple est
basé sur des communications par bus : ce modèle de communications consomme peu de
surface, mais risque de devenir un goulet d’étranglement. Le deuxième est basé sur des
communications en barres croisées très performantes mais aussi très coûteuses en surface. Le
troisième exemple donne une solution intermédiaire, par réseau commuté. Enfin le dernier
exemple montre qu’il est possible de mixer plusieurs modèles de communication, et
d’apporter de la hiérarchie dans l’architecture.
9
Chapitre I
Fig.1.5 : Architecture embarquée de troisième génération.
Autour de ce modèle d’architecture centré sur les communications, se greffent les autres
modèles d’architectures : architecture des éléments de calcul et des mémoires. L’architecture
des éléments de calcul consiste à définir quels sont les éléments principaux et quels sont leurs
périphériques de manière à les grouper dans une architecture locale. L’architecture des
mémoires sert à définir quelles sont les mémoires locales à un groupe et quelles sont celles
qui seront partagées.
b. Partie logicielle
Les parties logicielles ont beaucoup gagné en importance dans les systèmes embarqués
[11]. Plusieurs systèmes d’exploitation sont parfois nécessaires pour les divers processeurs de
l’architecture. De plus, la complexité et la diversité des architectures possibles font qu’il
devient de plus en plus nécessaire d’abstraire les tâches logicielles des détails du matériel.
Toute cette complexité est donc reportée dans les systèmes d’exploitation, qui deviennent de
plus en plus complexes.
Cette complexité logicielle et matérielle entraîne de nombreuses alternatives. En
particulier, l’aspect multiprocesseur apporte des alternatives pour les systèmes d’exploitation :
il peut y avoir un seul système pour tous les processeurs (solution difficilement applicable
lorsque les processeurs sont hétérogènes), ou il peut y avoir un système par processeur
(solution qui peut être plus coûteuse).
10
Chapitre I
2.3. Utilisations des systèmes embarqués
Les systèmes embarqués existent depuis longtemps. L’Apollo Guidance Computer,
développé en 1961 au laboratoire d'instrumentation du MIT, est le premier système
embarqué [18]. Il
était utilisé en temps réel par les astronautes afin de recueillir et de
fournir des informations sur le vol, mais aussi pour effectuer des contrôles automatiques de
toutes les fonctions de navigation du vaisseau spatial.
De nos jours, on retrouve des systèmes embarqués « cachés » dans de nombreux
objets de la vie quotidienne : les téléphones portables, les lecteurs MP3, les
imprimantes, le GPS, le PDA, les appareils médicaux, les
robots, les systèmes de
transport, etc. Rien qu’une voiture contient à elle seule au moins 20 systèmes embarqués : les
systèmes de freinage, le contrôle du moteur, le contrôle des fenêtres, l’ABS (Anti-lock
Braking System), etc.
Les systèmes embarqués sont en forte croissance. Plus de 98% des puces produites
aujourd’hui, le sont pour être intégrées au sein de systèmes embarqués. Ces systèmes jouent
un rôle de plus en plus important dans de nombreux domaines d'applications. On citera par
exemple le domaine de la santé avec la conception des technologies innovantes pour
construire des systèmes de soin pour détecter des comportements anormaux, comme les
chutes, des comportements inattendus qui peuvent être liés à un problème de santé, l’aide à
l’autonomie des personnes dépendantes en raison de maladie ou de handicap, l’aide au
diagnostic ou à l’acte chirurgical. Dans le domaine de la domotique, on citera des systèmes
embarqués qui sont intégrés à des équipements afin d’apporter une surveillance intelligente
d’une maison, économiser l’énergie, contrôler le stock des aliments, etc.
2.4. Quelques contraintes des systèmes embarqués
2.4.1. Temps réel et Activités
Nous entendons souvent parler de temps réel dès qu’on parle de systèmes embarqués.
Le temps réel est un concept vague chacun a sa propre idée sur la question.
Nous pourrions le définir comme: Un système est dit temps réel lorsque l’information
après acquisition et traitement reste encore pertinente. Plus précisément, cela veut dire que
dans le cas d’une information arrivant de façon périodique (sous forme d’une interruption
périodique du système), les temps d’acquisition et de traitement doivent rester inférieurs à la
période de rafraîchissement de cette information.
11
Chapitre I
Pour cela, le noyau ou le système temps réel doit être :
-
Soit déterministe : les mêmes causes produisent les mêmes effets avec les mêmes temps
d’exécution.
-
Soit préemptif : la tâche de plus forte priorité prête à être exécutée, doit toujours avoir
accès au processeur.
Ces conditions-là sont des conditions nécessaires mais pas suffisantes pour dire qu’un
système embarqué est temps réel par définition.
Ces interactions contraignent les temps de réponse du système embarqué de manière plus
ou moins forte selon le domaine d’applications visé. On parle alors de système temps réel
dans le sens où le temps de livraison des résultats d’un calcul fait partie intégrante de la
spécification de ce dernier, au même titre que le résultat lui-même.
2.4.2. Consommation énergétique
Une grande majorité des systèmes embarqués (téléphones cellulaires, ordinateurs de poche,
...) sont confrontés au problème de l’autonomie. Aussi, afin d’étendre l’autonomie de
fonctionnement d’un système, deux approches complémentaires sont possibles :
-
Augmenter la capacité de stockage des batteries.
-
Réaliser un système embarqué à faible consommation énergétique.
Dans le cadre de cette dernière approche, plusieurs méthodes sont alors envisagées qui
touchent à la fois le domaine de l’électronique et du logiciel, la conception de composants
électroniques consommant le minimum d’énergie, l’optimisation du logiciel afin de diminuer
le coût énergétique de son exécution, et enfin la conception de stratégies logicielles exploitant
les fonctionnalités du matériel.
2.4.3. Mémoire
La mémoire est une ressource limitée dans un grand nombre de systèmes embarqués, et par
conséquent une bonne utilisation de la ressource mémoire est cruciale pour ces systèmes.
Une difficulté supplémentaire dans les systèmes embarqués est que la gestion de la
mémoire soit compatible avec les contraintes temps réel des applications.
2.4.4. Tolérance aux fautes
Certains systèmes embarqués doivent pouvoir remplir leurs fonctions malgré la présence
de fautes, qu’elles soient d’origine physique ou humaine. Les moyens pour la sûreté de
fonctionnement, et plus spécifiquement les méthodes de tolérance aux fautes, permettant au
système de remplir ses fonctions en dépit des fautes pouvant affecter ses composants.
12
Chapitre I
Les difficultés issues du contexte embarqué sont relatives aux contraintes de temps des
logiciels embarqués, ainsi qu’aux ressources limitées de l’architecture. Ceci contraint les
types de méthodes de tolérance aux fautes utilisables dans un contexte embarqué temps réel.
En particulier, dans les systèmes temps- réel, il est nécessaire d’intégrer les mécanismes de
tolérance aux fautes dans l’analyse d’ordonnancement du système.
2.4.5. Hétérogénéité
Les systèmes embarqués sont généralement composés de parties logicielle et matérielle; la
partie logicielle concerne l’application qui s’exécute sur un processeur alors que la partie
matérielle concerne plutôt un composant physique qui implémente une fonctionnalité
spécifique.
Cette hétérogénéité peut avoir plusieurs aspects comme: type de composants (CPU: Central
Processing Unit, mémoire, ASIC, etc. . .), protocole de communication utilisé (FIFO: First In
First Out, etc. ...), type de données échangées ou même la nature des composants
(électronique, mécanique, optique), des composants décrits dans différents langages, ce qui
ajoute un aspect d’hétérogénéité en plus.
3. LA CONSOMMATION D’ENERGIE DANS LES SYSTEMES EMBARQUES
Les progrès de la microélectronique rendant possible des densités d’intégration de plus en
plus élevées, les systèmes embarqués connaissent actuellement un essor et un développement
considérable. Cette croissance se heurte néanmoins à un facteur limitant la dissipation
d’énergie. Outre les problèmes de dissipation thermique devenus une contrainte en terme de
densité d’intégration, la consommation d’énergie devient un enjeu majeur dans le cadre des
applications portables (téléphonie, PDA, appareils photographiques numériques...) et doit être
prise en compte à chaque niveau de conception.
Le but de cette section est de présenter les causes de la dissipation d’énergie et de détailler
une palette des principales techniques utilisées pour évaluer et diminuer la consommation des
systèmes embarqués.
3.1. La consommation dans les architectures électroniques
3.1.1. Consommation dans les circuits CMOS
CMOS est une technologie de fabrication des circuits intégrés. Brevetée en 1967, la
technologie CMOS est aujourd’hui utilisée pour un grand nombre de composants
13
Chapitre I
électroniques numériques tels que les circuits logiques, les microprocesseurs et
microcontrôleurs, les mémoires mais aussi pour les composants analogiques, notamment les
capteurs photographiques et les convertisseurs de signaux (convertisseurs analogiquenumérique et inversement).
La consommation électrique est une contrainte majeure dans la plupart des composants et
en particulier pour les systèmes embarqués. Pour cette raison, la consommation des circuits
intégrés est une préoccupation de longue date.
Il existe deux types de transistor en fonction de leur fonctionnement sur l’alimentation
(Vdd) ou sur la masse (Vss), respectivement P et N. Ces deux transistors sont placés
symétriquement entre l’alimentation et la masse tel que présenté en Figure 1.6 ce qui constitue
la fonction de base réalisée par des transistors CMOS, un inverseur de signal. Ceci permet, en
fonction du niveau de tension appliqué sur la grille des transistors, d’avoir soit le transistor de
type N passant, soit le transistor de type P passant. Lorsque l’entrée est à l’état 1 (niveau
haut), le transistor N est passant et le transistor P est bloqué, alors la sortie est à l’état 0
(niveau bas). Le fonctionnement est inversé si l’entrée est à 0.
Fig.1.6 : Un inverseur, fonction de base réalisée par des transistors CMOS.
À partir de cette fonction de base, il est possible de réaliser des fonctions logiques telles
que des portes NAND (NON-ET) ou des bascules. La technologie CMOS est alors utilisée
dans la plupart des circuits intégrés, cependant, son fonctionnement produit des pertes de
courant. Ces pertes se traduisent par une consommation d’énergie et par un échauffement du
circuit. La consommation d’un inverseur CMOS (et de toute autre fonction) peut être
regroupée en deux familles. Il s’agit de la consommation dynamique et la consommation
statique. Les principes de base de la consommation dans les circuits CMOS sont exprimés par
la suite, la formulation détaillée ainsi que la plupart des concepts liés à la consommation sont
exposée dans le livre [19].
14
Chapitre I
3.1.1.1. Consommation dynamique
La structure CMOS, qui consiste à placer un (ou plusieurs) transistor(s) de type P entre
l’alimentation et la sortie (afin de pouvoir générer un signal à l’état 1) et un (ou plusieurs)
transistor(s) N entre la sortie et la masse (pour générer un signal à l’état 0), est une structure
qui peut provoquer une fuite de courant via ces transistors. Les grilles des transistors forment
une surface possédant des charges, celle-ci se comporte alors comme une capacité par rapport
aux autres éléments du transistor et du circuit intégré. La grille a donc besoin d’un courant de
charge pour passer au niveau haut. Ce courant est issu de l’alimentation de l’étage en amont
commandant le transistor. Puis lorsque cette grille doit passer au niveau bas, le courant de
décharge est envoyé vers la masse. Tous les deux changements d’un étage CMOS, la quantité
d’énergie emmagasinée par la capacité de la grille est perdue (Figure1.7). En plus de la
capacité de la grille, les capacités des connexions entre les étages se comportent de la même
manière que la capacité de grille ce qui augmente le courant de commutation.
Fig.1.7 : Courant de commutation dans un étage inverseur CMOS.
La consommation dynamique est alors donnée par l’équation1.1 où Vdd représente la
tension d’alimentation du circuit, F la fréquence des transitions, α le taux de transitions réelles
par rapport à la fréquence de base et C la totalité des capacités parasites.
Pdyn  Vdd2  F    C
(1.1)
Compte tenu de l’intervention de la tension d’alimentation au carré dans cette puissance
dynamique, il s’agit du premier paramètre sur lequel les concepteurs agissent pour diminuer la
consommation. Cependant, la baisse de la tension ralentit la commutation des transistors et
réduit la fréquence de fonctionnement.
15
Chapitre I
Fig.1.8: Courant de court-circuit dans un étage inverseur CMOS
De plus, lors d’un changement d’état, un transistor devient passant tandis que le transistor
complémentaire devient bloquant. Durant cette transition, les deux transistors sont passants
pendant un court laps de temps. Ils se comportent alors comme une résistance entre
l’alimentation et la masse pendant leur changement d’état, provoquant un courant de courtcircuit Icc, représenté en Figure1.8. La consommation de court-circuit est une équation
complexe dépendant de nombre de transistors Ntr et des paramètres liés à la technologie de
réalisation des transistors, notamment les tensions de seuils de commutation des transistors
(VthP etVthN) et le courant de court-circuit maximum IPeak . Une écriture simplifiée est donnée
par l’équation 1.2 et cette puissance s’ajoute à Pdyn.
Psc  Vdd  f ( I Peak , , F ,VthP ,VthN )  N tr
(1.2)
3.1.1.2. Consommation statique
Il existe cependant une consommation même lorsque le circuit n’effectue plus de
transitions, lorsque la fréquence est nulle ou lorsqu’il n’y a pas d’activité (α= 0). Lorsque les
transistors sont ouverts, leur résistance est très élevée, mais pas nulle. Il en résulte un courant
de fuite Ileak qui traverse les transistors complémentaires entre l’alimentation et la masse,
représenté en Figure 1.9. Cette consommation est directement liée au nombre de transistors
Ntr (surface du circuit) et à la tension d’alimentation Vdd, elle est donnée par l’équation 1.3.
Ps  Vdd  I leak  N tr
16
(1.3)
Chapitre I
Fig.1.9: Courant de fuite dans un étage inverseur CMOS.
3.2. Les techniques d’évaluation et d’optimisation de la consommation
Pour présenter ces méthodes de modélisation et de réduction de la consommation, nous
allons suivre une approche “bottom-up” en démarrant du niveau le plus bas (technologie
/transistor) jusqu’à arriver au niveau système. Nous verrons que les gains attendus par les
optimisations “haut niveau” sont dépendants des paramètres technologiques et architecturaux
du circuit et que la gestion de la consommation ne doit négliger aucune dimension
(technologique, architecturale, applicative) pour être efficace.
3.2.1. Évaluation et gestion de la consommation au niveau transistor
Pour pouvoir suivre la loi de Moore et intégrer deux fois plus de transistors tous les 3 ans,
de nombreuses recherches sont effectuées au niveau technologique. Ces recherches mènent à
la conception de nouveaux transistors pris en compte dans les “design kits” utilisés par les
outils de synthèse lors de la génération du lay-out circuit.
3.2.1.1. Techniques et outils d’évaluation
Pour évaluer la puissance dissipée par ces nouveaux transistors, les outils industriels
intègrent des modèles LSIM sous simulation SPICE [20, 21]. Ces modèles sont réalisés après
une caractérisation physique exhaustive du comportement des transistors. Ils sont donc très
précis et donnent une image réelle de la consommation des transistors en fonction de leurs
dimensions, de la tension d’alimentation et des substrats utilisés. La précision de ces modèles
implique évidemment de longs temps de simulation (1 à 2 jours de simulation pour un circuit
de 50KG). Pour pallier cela, des logiciels industriels comme NANOSIM utilisent des modèles
simplifiés et permettent d’analyser la consommation d’un petit circuit (<100000 portes) avec
une précision de 2-3% [22].
Les systèmes embarqués comportant plusieurs millions de transistors, ces logiciels de
simulations ne peuvent pas être utilisés pour évaluer leur consommation. Heureusement, des
17
Chapitre I
outils permettent d’évaluer la consommation à un plus haut niveau d’abstraction : ils seront
détaillés dans les sections suivantes.
3.2.1.2. Méthodes de gestion de la consommation
Pour permettre une réduction de la puissance dissipée par un transistor, il faut soit modifier
ses paramètres physiques (substrat, dimensions...), soit ses paramètres de fonctionnement
(tension d’alimentation, tension de polarisation du substrat...). Il est ainsi possible de réduire
les deux composantes de la puissance consommée : les puissances statique et dynamique.
a. Réduction de la puissance dynamique : L’équation 1.1 nous montre que la puissance
dynamique dépend de la capacité du circuit, de la fréquence de commutation et de la tension
d’alimentation.
La capacité équivalente C dépend entièrement des dimensions physiques du transistor
(longueur, largeur et substrat utilisé) et décroît avec les dimensions des transistors.
Pour diminuer plus avant la puissance dynamique dissipée, il faut agir sur la tension
d’alimentation V. Or, comme le montre l’équation 1.4, le temps nécessaire à la commutation
d’un transistor T dépend de la tension d’alimentation, de la tension de seuil (Vth) et de la
capacité équivalente de charge (C) [23].
Ainsi, toute diminution de V entraîne une augmentation du temps de commutation. Un
compromis devra donc être trouvé entre la tension d’alimentation et la fréquence de
fonctionnement. C’est ce qu’on appelle le voltage scaling.
T
CV
(V  Vth ) 2
(1.4)
Comme cet ajustement de tension doit être couplé à une diminution de fréquence, le
voltage scaling affecte les temps de calcul des architectures à base de transistors. La
problématique de gestion de la tension d’alimentation d’un circuit pourra donc être définie par
un compromis entre économie d’énergie et contraintes temporelles.
b. Réduction de la puissance statique : Comme nous le montre l’équation 1.4, le temps de
commutation d’un transistor dépend également de la tension de seuil Vth. Si V s’approche de
cette tension, le délai augmente considérablement. Pour permettre une grande plage
admissible de tension et donc une diminution plus importante de la puissance dynamique, la
tension de seuil Vth est réduite dans les nouvelles technologies.
18
Chapitre I
Cette diminution entraîne une croissance exponentielle du courant de sous seuil et donc de
la puissance statique dissipée. Pour pallier ces effets, les nouvelles technologies silicium
permettent d’influer sur les tensions de seuil, et ce même à substrat et dimensions fixées.
3.2.2. Évaluation et gestion de la consommation au niveau RTL
Si la consommation d’un circuit numérique peut être réduite par l’utilisation de nouveaux
transistors ou dispositifs technologiques, les outils CAO (Conception Assistée par Ordinateur)
permettent de gérer la consommation à un plus haut niveau d’abstraction. Cette section va
présenter plusieurs méthodes couramment utilisées pour estimer et réduire la consommation
au niveau logique/architecture.
L’évaluation de la puissance dissipée au niveau RTL (Register Transfer level) doit résulter
d’une modélisation ou d’une connaissance de l’activité du circuit considéré. Les outils
industriels proposent deux types d’approches : des méthodes statistiques et probabilistes et
des approches basées sur des simulations fonctionnelles.
a. Méthodes statistiques et probabilistes : Au lieu d’utiliser des simulations fonctionnelles
comme entrée des simulateurs logiques, ces techniques se proposent de calculer la puissance
moyenne dissipée par un circuit à l’aide de vecteurs de test générés automatiquement. La
figure 1.10 présente un synoptique de ces deux types d’approches.
- Les modélisations statistiques déterminent la puissance moyenne consommée par une
architecture à l’aide d’une génération de vecteurs de test représentatifs. Ces vecteurs de test
servent d’entrée à un simulateur logique classique qui calcule la puissance dissipée par
l’architecture vecteur par vecteur. Les résultats sont ensuite moyennés et on en tire une
information statistique de la puissance consommée.
- Les modélisations probabilistes sont basées sur des “modèles de transitions probabilistes”
extraits de vecteurs de test [24]. Ainsi à chaque type de signal (images, paroles etc. ..)
correspondra un modèle statistique défini permettant d’éviter la génération de vecteurs de
tests avant simulation. Ces modèles, donnés en entrée d’un analyseur logique contenant des
informations de consommation, permettront d’évaluer la puissance dissipée par un circuit en
se passant d’une analyse fonctionnelle exhaustive. Cette approche est utilisée dans des outils
de synthèse comme Build Gates (CADENCE) ou Sequence Design (Synopsys) [25].
19
Chapitre I
Vecteurs de test
représentatifs
Simulateur
Pmoy
Méthodes statistiques
Extraction de
propriétés
Analyseur
Pmoy
Méthodes probabiliste
Fig.1.10 : Méthodes d’évaluation statistique et probabiliste.
b. Méthodes basées sur les simulations fonctionnelles : Ces outils industriels s’appuient sur
une connaissance exacte de l’application se déroulant sur le circuit. Les outils comme
PRIMEPOWER ou POWERMILL lient les simulations portes avec les informations de
consommation contenues dans les librairies physiques fournies par les fondeurs [25].
Les fichiers représentant l’activité de chaque nœud logique sont extraits des simulations
comportementales et liés à des tables de consommation (contenant les valeurs de puissance
dissipée en fonction des transitions effectuées). Ces outils permettent d’évaluer la
consommation de circuits comportant jusqu’à 100K portes, avec une précision de 5 à 10%
(respectivement, simulations basées sur des circuits après et avant placement/routage).
Si ces logiciels permettent d’avoir une image précise du profil de consommation lors du
fonctionnement, ils nécessitent beaucoup de temps de simulation et de mémoire.
3.2.3. Évaluation et gestion de la consommation au niveau système
Les différentes techniques d’optimisation présentées précédemment sont pour la plupart
intégrées dans les logiciels de synthèse logique disponibles dans l’industrie. Si ces
optimisations permettent de réduire la consommation des SoCs (System on Chip) de 15 à
45%, une gestion à plus haut niveau de la consommation électrique permet des gains
d’énergie encore plus conséquents [26]. Il existe de très nombreuses solutions et approches
visant à diminuer la consommation dans les circuits. Nous allons ici présenter les
optimisations "système" les plus usitées, avec leurs applications et leurs limitations. Par
optimisation "système", nous entendons toutes les possibilités de réduction de consommation
offertes au concepteur qui considère l’architecture dans son ensemble et qui vise à en
optimiser la consommation lors de l’exécution d’une application.
Un SoC est constitué de trois éléments essentiels :
- Des ressources de calcul (processeurs, unités matérielles de calcul etc.) destinées à réaliser
les traitements nécessaires au déroulement de l’application.
20
Chapitre I
- Des ressources de mémorisation (RAMs : Random Access Memory, SRAM : Static
Random Access Memory etc.) permettant de stocker les données pendant le traitement.
- Des ressources de communication (bus, réseaux sur puce) assurant la communication entre
les différentes composantes du SoC.
3.2.3.1. Techniques et outils d’évaluation de la consommation
De nombreux modèles de processeurs, de mémoires et d’architectures de communication
existent. Nous allons présenter quelques modèles caractéristiques.
a. Modélisation de la consommation des mémoires : Une composante essentielle des
systèmes embarqués est la mémoire qui est nécessaire à tout programme et à toute application.
Vu l’importance prise par la surface silicium de la mémoire dans une architecture (+50% dans
les circuits de traitements vidéo/image), on se rend vite compte de son importance dans le
bilan de la puissance consommée. Comme il est impossible de décrire tous les modèles de
mémoire existants et les différentes hiérarchies de cache (il en existe de très nombreuses,
toutes adaptées à des applications particulières), nous allons dégager les principaux
paramètres de leur consommation.
Comme le montre la figure 1.11, un bloc de mémoire est en général constitué :
- des cellules mémoires elles-mêmes ;
- du décodeur d’adresse (sélection des lignes et de colonnes) ;
A(n-k)
Sélection de ligne
A(1)
Buffer d’adresses
- d’un amplificateur permettant la lecture et l’écriture des données.
Tableau de
cellules
mémoires
Amplificateur
Logique
de contrôle
Sélection de colonne
Buffer d’adresses
A(n-k+1)
A(n)
Fig.1.11 : Architecture d’une mémoire.
La majeure partie de la puissance consommée est dissipée par les cellules MoS de
mémorisation. Comme toutes les architectures numériques, la consommation de ces éléments
21
Chapitre I
est constituée d’une composante dynamique et d’une autre statique. La puissance dynamique
dissipée par une cellule de mémorisation (Pmd) est donnée par l’expression (1.5), avec k
représente la largeur de buffer d’adresses, Cli la capacité présente entre deux lignes mémoire
et Cic la capacité présente entre deux colonnes [27].
1
Pmd  2 k  (C li  C ic )V 2
2
(1.5)
Bien que cette composante dynamique fût prépondérante dans les technologies silicium
antérieures au 130nm, la part de consommation statique représente aujourd’hui près de 50%
de la consommation totale des mémoires [28].
La consommation totale des mémoires va donc principalement dépendre de ces paramètres :
- technologie silicium ;
- taille de la mémoire ;
- nombres d’accès mémoires N (∝ N.Pmd) ;
- architecture des colonnes et lignes, cache mémoire…
b. Architecture de communication sur puce : Par ressource de communication, nous
entendons essentiellement les bus et les réseaux sur puce (NoC : Network on Chip).
Bus de données La consommation d’un bus de données est due à trois composantes
principales :
- la capacité du bus en lui-même ;
- la puissance consommée dans les amplificateurs (nécessaire avant transmission et à la
réception des données sur un bus) ;
- la charge de données présente sur le bus.
Réseaux sur puce Les solutions d’interconnexion classiques comme les bus ne répondent
plus aux contraintes de performance imposées par la conception des SoCs complexes [29].
Les recherches s’orientent vers des communications basées sur des réseaux sur puce. Comme
des réseaux de communication classiques, ces réseaux font circuler des messages d’un
émetteur à un destinataire en utilisant une infrastructure composée de routeurs reliés entre eux
par des liens électriques (bus ou liaisons point à point). Donc pour modéliser la
consommation d’un NoC, il faut passer par la modélisation de tous ses composants.
Les NoCs constituant un domaine de recherche très actif, il existe plusieurs approches de
modélisation basée sur un simulateur générique de réseau ou qui modélise un réseau à l’aide
22
Chapitre I
d’une description VHDL (Very high-scale integrated Hardware Description Language)
[29, 30].
c. Modélisation de la consommation des processeurs : Le processeur constitue la ressource
principale de calcul et la principale source de dissipation d’énergie d’une architecture.
Pour modéliser la consommation d’un processeur complet, on peut se limiter à deux
paramètres importants [31, 32] :
- le coût énergétique de base ;
- le coût énergétique entre deux instructions (induit par le changement de chemin de
données et de contrôle).
Le coût de base représente l’énergie dissipée par une instruction du processeur. Ce coût
énergétique est indépendant des effets qu’il peut entraîner (défauts de caches, branchements).
Par contre, il doit prendre en compte l’influence des données utilisées par l’opérande de
l’instruction (une addition 32 bits consommera plus qu’une addition 8 bits...).
Cette dépendance aux données nous permet de construire un modèle pour chaque
instruction du processeur comprenant le meilleur et pire cas, ainsi qu’une estimation moyenne
de la consommation pour chaque instruction.
Par coût inter-instruction on entend tout ce qui ne concerne pas directement l’activité
propre d’un opérande. Sont principalement inclus dans cette catégorie, les surcoûts de
consommation engendrés par les branchements conditionnels et inconditionnels et l’énergie
dissipée en cas de défaut de cache. Pour extraire un modèle de ces coûts, on suit une
procédure analogue à la précédente, en exécutant un code particulier qui engendre l’effet à
mesurer.
Des méthodes de modélisation beaucoup moins exhaustives et coûteuses en temps ont été
réalisées à partir de l’observation du comportement de certains processeurs. On peut par
exemple considérer l’outil " Joule Track " [33] développé par l’équipe µAMPS du MIT. Cet
outil, disponible sur Internet, cible les processeurs Strong ARM SA-1100 et Hitachi SH4 et
fournit une estimation de la puissance consommée [23].
Pour modéliser le comportement de ces processeurs, ces travaux se basent sur l’hypothèse
(déduite de simulations) que l’influence des séquences d’instruction sur la consommation est
faible par rapport aux variations de tension d’alimentation et de fréquence d’utilisation. Ils ont
ainsi déduit une loi du premier ordre correspondant à une estimation de l’énergie consommée
par une séquence d’instruction :
23
Chapitre I
Etot  V  I (V , f )  (t )
(1.6)
Avec V, la tension d’alimentation, I le courant correspondant à une fréquence et à une tension
d’utilisation (donnée constructeur) et ∆(t) le temps d’exécution du programme.
Si cette approximation décrit correctement le comportement énergétique de processeurs
“génériques” comme l’ARM (Advanced Risc Machine), où les instructions ont sensiblement
la même consommation, elle ne convient pas pour les processeurs flots de données utilisant
des modules de calculs fortement hétérogènes (DSPs par exemple).
3.2.3.2. Méthodes de gestion de la consommation
Dans cette section nous allons exposer les principales techniques de gestion de la
consommation appliquées à chaque classe de composants présents dans les SoCs.
a. Optimisation de la consommation des mémoires : Il existe de nombreuses méthodes
permettant l’optimisation de la consommation des unités de mémoires. On peut les classer en
deux groupes :
- Les méthodes qui modifient l’architecture des unités de mémorisation (hiérarchies de
caches, architecture low power...) en fonction de l’application avant synthèse logique.
- Les techniques, qui pour une architecture de mémoire donnée, optimisent le code de
l’application pour diminuer les accès mémoires.
Les modifications et la définition d’architectures mémoire “basse consommation” sont
réalisées pour des applications connues a priori. Le choix de ces architectures est en général
guidé par des estimations en vitesse et en surface réalisées à l’aide de modèles analytiques.
On peut citer les travaux sur le choix des architectures de caches, ou pour les mémoires
SRAMs qui proposent toutes deux des architectures basse consommation adaptées à ces types
de mémoire fortement contraints en temps d’accès dans [34, 35]. Ces techniques
correspondent toutes à des applications spécifiques et ne peuvent être généralisées.
La modification du code des applications est une technique applicable à toutes les
architectures mémoires. Comme démontré précédemment, chaque accès mémoire est
consommateur d’énergie ; or dans les applications courantes des systèmes embarqués actuels,
comme le traitement d’image ou de vidéo, les fichiers de données sont de taille très
importante et les nombres d’accès mémoire sont nombreux. Réduire le nombre de ces accès
entraîne donc un gain conséquent d’énergie.
24
Chapitre I
Pour diminuer ce nombre d’accès, plusieurs approches s’orientent vers la modification des
boucles logicielles (très souvent présentes dans les algorithmes de filtrage et de traitement
d’image). On peut citer les travaux du L3I ou du LESTER qui modifient les boucles ou les
structures de données des programmes afin de limiter la mémoire nécessaire et le nombre
d’accès de données [36, 37 et 38].
b. Optimisation de la consommation des ressources de communication : Comme il a été
mentionné dans la section 3.2.3, chaque transfert de données sur un bus ou sur un réseau sur
puce consomme de l’énergie (10 à 40% de l’énergie totale dissipée [23]). Si des
transformations de codes améliorant la localité des données (clustering, etc.) où la régularité
des algorithmes permet de réduire les transferts mémoires-processeurs, des économies
supplémentaires d’énergie peuvent être réalisées au niveau du bus ou du réseau lui-même.
Réduction de la consommation dans les bus de données Pour diminuer la consommation
dynamique d’un bus, de nouveaux dispositifs permettent d’en réduire la tension
d’alimentation [39]. Ce “voltage scaling” sur bus doit évidemment être réalisé en fonction de
la charge de données transitant sur celui-ci.
Réduction de la consommation dans les NoCs : la réduction de la puissance dissipée par les
réseaux sur puce doit concerner chaque niveau de la pile réseau (modèle OSI [40]).
c. Optimisation de la consommation des processeurs : la gestion de la consommation des
processeurs embarqués est un problème bien connu et longuement étudié par toutes les
communautés de recherche se préoccupant des thématiques “basse consommation”.
Deux méthodes sont couramment employées :
- La gestion dynamique de puissance (Dynamic Power Management) qui consiste à
allumer/éteindre des éléments du processeur ou à gérer les modes de consommation d’une
architecture en fonction de l’activité.
- L’ajustement dynamique de tension (Dynamic Voltage Scaling) qui revient à ajuster les
couples tension/fréquence en fonction de l’exécution des tâches.
Au niveau processeur, l’utilisation de ces deux méthodes consiste à déterminer
algorithmiquement les modes de fonctionnement ou de tension qui minimisent la puissance
dissipée, tout en respectant les contraintes de performance de l’application (contraintes temps
réels).
25
Chapitre I
4. LES PROCESSEURS DANS LES SYSTEMES EMBARQUES
La grande majorité des conceptions de systèmes embarqués commencent par un système
basé processeur, en utilisant un microcontrôleur ou un microprocesseur comme élément
central pour prévoir et traiter les tâches élémentaires de contrôle et de surveillance,
communiquer avec des interfaces utilisateur, et superviser tous les autres aspects de la
conception. Pour les systèmes embarqués traditionnels, cette architecture fournissait une
puissance de traitement suffisante pour réaliser toutes les boucles de contrôle et enregistrer
des données. Pour des systèmes plus complexes qui intègrent des tâches avancées de contrôle
et de traitement de signaux, des composants de traitement supplémentaires comme des
FPGAs (Field Programmable Gate Arrays), des DSPs et des GPU (Graphics Processing
Units) afin d’atteindre un traitement de données à très haute vitesse, sont utilisés.
Fig.1.12 : Positionnement relatif des architectures de traitement numérique de l’information en fonction de
leur performance et de leur flexibilité [41].
La figure 1.12 illustre le positionnement relatif des architectures de traitement numérique
de l’information en fonction de leur performance et de leur flexibilité. Ainsi, leur espace de
conception s’étend des processeurs programmables (Von Neumann, DSPs), flexibles mais
relativement performants, jusqu’aux circuits spécifiques (ASICs), plus performants mais peu
flexibles, en passant par les solutions reconfigurables. Mentionnons également l’existence des
processeurs graphiques (GPU), massivement parallèles, à la puissance de calcul prodigieuse, à
la programmabilité croissante fondatrice du concept GPU mais à la consommation excessive
excluant leur utilisation dans le secteur de l’électronique embarquée.
26
Chapitre I
4.1. Architectures embarquées
4.1.1. Les processeurs DSPs
Le DSP est un composant électronique programmable de type processeur. Il est utilisé
dans bon nombre de domaines d'application qui nécessitent l'utilisation de filtres numériques
ou adaptatifs, du calcul FFT dans l'instrumentation (analyse transitoire, spectrale), dans le
domaine médical (monitoring, échographie, imagerie médicale), dans les applications de
contrôle (asservissement, robotique), le multi média et l'imagerie, le militaire (radar, guidage
de missile), les télécommunications (modems radio, cryptage de données, répéteurs de ligne)
et le grand public (automobile, électroménager).
Son architecture est figée et comprend un ensemble d'éléments qui, suivant les modèles,
permettent d'effectuer des calculs sur des données codées en virgule fixe ou flottante. Le
calcul en virgule flottante permet une programmation plus souple et plus rapide, mais s'avère
plus coûteux en termes de consommation. Le calcul en virgule fixe nécessite une unité
arithmétique et logique plus simple, d'où une puissance de calcul relativement élevée pour un
prix d'achat du DSP plus bas. Les DSPs ont une mémoire programme et une mémoire donnée
séparées (architecture HARVARD), liées par un chemin de données (registres). Les registres
sont reliés à des unités fonctionnelles permettant d'effectuer des opérations arithmétiques
et/ou logiques : des comparaisons, des opérations de chargement et stockage de données.
Une architecture nommée VLIW (Very Large Instruction Word) permet de réaliser
plusieurs instructions en un seul cycle. En effet les DSPs fonctionnent presque tous en mode
« pipeline ». L'instruction traduit une opération qui va être décomposée en un ensemble de
sous-opérations à exécuter en parallèle par les différentes unités fonctionnelles. Par exemple :
une instruction est tout d'abord lue en mémoire programme, décodée puis exécutée. Donc
pour un ensemble d'instructions, chaque étape peut s'effectuer en parallèle sur des unités
différentes suivant leurs disponibilités. Ceci accélère l'exécution du programme
(proportionnelle au nombre d'étages du pipeline).
L'évolution technologique permet l'obtention de composants de plus en plus performants
en terme de puissance de calcul ce qui, pour le DSP, se traduit par un nombre d'instructions
par seconde dépassant le million (MIPS, Million Instructions Per Second) et ne cessant de
progresser. De même, la taille des données manipulées est passée de 16 à 32 bits pour des
résultats pouvant aller jusqu'à 64 bits. Tout ceci favorise son utilisation dans des applications
de traitement du signal nécessitant de fortes capacités de traitement.
27
Chapitre I
4.1.2. Les circuits FPGAs
Les FPGAs sont utilisés depuis plus de 30 ans comme lien numérique flexible entre les
différents composants présents sur la même carte d’un circuit imprimé. La logique
reconfigurable intrinsèque au FPGA reste idéale pour mettre en œuvre des machines d’état
complexes ainsi qu’une circuiterie numérique propre à l’application qui fonctionnent de façon
indépendante des cycles de l’horloge du processeur, avec une fiabilité et un déterminisme
supérieurs. D’année en année, les performances des FPGAs n’ont fait qu’augmenter tandis
que la puissance et les coûts chutaient. C’est pour cette raison que l’utilisation des FPGAs
dans les conceptions de mesure et de contrôle de systèmes embarqués a évolué de la simple
logique de liaison à des tâches de traitement de signaux, comme par exemple des filtres
numériques personnalisés, des FFTs et des algorithmes de contrôle PID ( Proportional
Integral Drive ). Les FPGAs dédiés au traitement, présentent un avantage important :
plusieurs algorithmes peuvent fonctionner en parallèle, contrairement à l’architecture
séquentielle d’un processeur.
Cependant, malgré toutes les performances et la souplesse qu’offrent les FPGAs, ils ne
sont pas prêts de remplacer les microcontrôleurs ni les microprocesseurs dans les conceptions
de systèmes embarqués. En comparaison, les processeurs restent plus économiques et
s’accompagnent d’un écosystème bien établi d’abstraction logicielle, dont des systèmes
d’exploitation, des drivers matériels standard ainsi que des bibliothèques consacrées au
traitement de signaux avec une arithmétique à virgule flottante simple. L’adoption de la
technologie FPGA résulte de systèmes très performants qui combinent à la fois des
processeurs et un circuit FPGA pour diviser et satisfaire des besoins complexes en matière de
traitement via des architectures à la fois séquentielles et parallèles. L’intégration de matériel
reprogrammable dans des conceptions, est le moyen le plus rapide d’évoluer sans avoir à
passer du temps ni dépenser de l’argent à concevoir à nouveau des cartes à circuits imprimés.
4.1.3. Les circuits ASICs
Un ASIC est un circuit électronique intégrant sur une même puce tous les éléments actifs
nécessaires à la réalisation d'une fonction ou d'un ensemble électronique. Il s'agit d'un circuit
intégré conçu exclusivement pour le projet ou l'application qui l'utilise. Grâce aux ASICs, les
concepteurs peuvent désormais regrouper dans un seul boîtier toutes les fonctions nécessaires
à leur application en occupant une surface comparable à celle d'un simple composant. Dans
un produit, le circuit intégré est un élément porteur d'avenir, fiable, performant et peu
encombrant, de plus il assure la confidentialité du savoir-faire. Grâce à l'ASIC, il est possible
28
Chapitre I
de compléter (ou remplacer) des fonctions mécaniques, pneumatiques, hydrauliques ou
électriques, abaissant les coûts de production. En particulier, il permet de concevoir les
circuits électroniques de liaison entre le monde physique : capteur (analogique), et l'unité de
traitement d'information et de commande (très souvent numérique). C'est l'élément sensible de
la chaîne où la compétence et la maîtrise des outils restent fondamentales.
4.2. Estimation de la consommation de puissance de processeurs
Les méthodologies d’estimation de puissance au niveau système ciblant spécifiquement
les processeurs embarqués peuvent être classées en trois catégories : l’analyse de puissance
au niveau fonctionnel (en anglais « Functional Level Power Analysis » abrégé par FLPA),
l’analyse de puissance au niveau instruction (en anglais « Instruction Level Power Analysis
» abrégé par ILPA) ainsi que les modèles hybrides.
4.2.1. Niveau fonctionnel
L’analyse de puissance au niveau fonctionnel a été introduite dans [42]. La modélisation
FLPA, divise le processeur en plusieurs blocs fonctionnels, par exemple l’unité d’extraction,
l’unité arithmétique logique, la banque de registre entre autres. L’objectif est d’identifier
les blocs qui ont un impact sur la consommation de puissance totale du processeur. Après
les avoir bien identifiés, chacun de ces derniers doit être décrit individuellement par une
expression arithmétique en fonction des paramètres algorithmiques et architecturaux. Les
paramètres algorithmiques sont spécifiques à l’algorithme exécuté, comme le taux de
« cache-miss » et de « cache-hit », tandis que les paramètres architecturaux sont choisis par
le concepteur notamment la fréquence d’opération du processeur ainsi comme la longueur des
mots. Ensuite, la consommation individuelle de chaque bloc doit être calculée pour plusieurs
combinaisons différentes de ces paramètres. Ces différentes combinaisons sont obtenues par
l’exécution de plusieurs séquences de code assembleur. Finalement, les données acquises
sont analysées afin d’obtenir l’expression arithmétique de chaque bloc fonctionnel.
Au cours des dernières années, la technique FLPA a été étendue et améliorée. Un aspect
qui différencie les travaux qui appliquent la FLPA, est la séparation appropriée de
l’architecture du processeur en blocs fonctionnels. Pour souligner un exemple réel, la
méthodologie FLPA est appliquée pour caractériser un DSP à architecture VLIW de Texas
Instruments, un processeur spécialisé en application multimédia en [43]. L’architecture de
ce
dernier
a
été divisée en
six blocs fonctionnels;
l’arbre
d’horloge,
la
cache
d’instruction, la cache de données, l’unité arithmétique logique, l’unité d’extraction et la
29
Chapitre I
mémoire interne. Également, la méthodologie FLPA est utilisée pour générer un modèle
d’énergie du « soft-processor » PowerPC 405 en [44]. Le résultat a été intégré dans un
modèle SystemC du processeur permettant l’estimation de puissance à partir d’une
simulation de haut niveau. Enfin, basé sur la méthodologie FLPA, Soft Explorer est un
outil d’analyse qui inclut une bibliothèque de modèles de puissance couvrant plusieurs
blocs fonctionnels d’un processeur [45]. Un profilage rapide du code est nécessaire pour
déterminer les paramètres d’entrée des modèles de puissance. Et, une estimation
relativement précise se fait dans un délai très court.
4.2.2. Niveau instruction
Le problème d’estimation de la consommation d’énergie au niveau instruction a
d’abord été étudié par Tiwari au cours des années 90 [46]. Il a introduit la méthodologie
ILPA. Celle-ci associe chaque instruction du processeur à un coût d’énergie fixe normalement
nommé le coût de base de l’instruction. Ce coût est dû au traitement de base nécessaire pour
exécuter l’instruction en question. Le coût de base d’une instruction peut varier en fonction de
différents opérandes et des différentes valeurs d’adresse. Bien que les techniques plus
appropriées peuvent donner la valeur exacte du coût de base pour n’importe quelle valeur
d’opérande ou d’adresse, en pratique cette variation est, seulement, un effet secondaire [46].
En général, le coût énergétique total d’un programme est la somme des coûts de base de
chaque instruction exécutée. Néanmoins, lors de l’exécution d’un programme, certains effets
inter-instructions se produisent et si seulement le coût de base est pris en considération, la
contribution de ces effets inter-instructions ne sera pas incluse dans l’énergie totale
consommée. Le coût inter-instructions est défini comme l’énergie dissipée lors de la transition
entre deux instructions différentes exécutées consécutivement par le processeur. Ces
transitions provoquent le changement de l’état de plusieurs ressources du processeur. Ce
qui implique une grande augmentation de l’énergie consommée. Utiliser uniquement le
coût de base des instructions, pour modéliser la consommation de puissance d’une séquence
d’instructions, tend à sous-estimer la consommation [47]. Ainsi, l’ajout du coût interinstructions pour chaque paire d’instructions consécutives mène à une estimation
d’énergie beaucoup plus précise. D’autres coûts inter-instructions, normalement moins
significatives sont aussi observés, notamment l’effet de « cache-miss » et l’effet de blocage du
pipeline [48].
Les méthodologies d’estimation d’énergie ILPA mettent l'accent sur les avantages de
l’utilisation de différents niveaux d’abstractions. Chaque niveau possède ses propres
30
Chapitre I
caractéristiques et ajoute l’information pertinente sur différentes étapes du processus
d’estimation de puissance. En outre, les modèles d’estimation basé sur l’instruction abstraient
tout ce qui concerne l’implémentation de bas niveau, réduit le nombre de paramètres et
facilite l’extraction de données requises. Toutefois, chaque modèle a ses propres
particularités. Dans la littérature, il est possible de trouver plusieurs modèles très détaillés
qui tiennent compte des diverses sources de consommation d’énergie des processeurs (les
effets inter-instructions). En même temps, d’autres modèles sont très simplistes et ignorent
des concepts considérés redondants.
Les coûts de base de l’instruction et les coûts inter-instructions sont idéalement obtenus à
travers un processus de caractérisation du processeur. En effet, ce processus permet de
profiler l’ensemble d’instruction du processeur. Ce dernier exécute chaque instruction ou
bien chaque paire d’instructions plusieurs fois pendant un certain laps de temps. Pour
chacune de ces exécutions la puissance consommée par le processeur doit être calculée,
ensuite les valeurs obtenues sont analysées et un modèle d’énergie peut enfin être généré.
Une diversité de travaux suit ce flot classique pour obtenir un modèle d’énergie basé sur
l’instruction. Ils se différencient principalement par la méthode employée pour simuler le
design, par la méthode utilisée pour mesurer la consommation d’énergie du processeur
ainsi que par les effets inter instructions analysés [5, 6, 49].
Afin d’augmenter le niveau de détails de la modélisation au niveau instruction en vue
d’obtenir une meilleure précision, une technique
modélisé l’effet des opérandes des
instructions sur la consommation d’énergie d’un processeur de la famille ARM7 en [50]. Un
modèle est encore plus minutieux et analyse l’effet des paramètres (opérande) ainsi que l’effet
du blocage de pipeline dans la consommation du même processeur présenté en [51].
Notamment, la grande problématique de la méthodologie ILPA, soulignée par plusieurs
travaux, est que la quantité de mesures lors du processus de caractérisation du processeur est
directement proportionnelle au nombre d’instructions de ce dernier [42, 52]. Ainsi l’analyse
de l’effet inter-instructions de toutes les paires d’instructions devient une tâche extrêmement
compliquée à être réalisée due au temps demandé.
4.2.3. Niveau hybride
La méthode hybride combine la méthodologie FLPA et la méthodologie ILPA. Cette
méthode sépare les instructions du processeur en plusieurs classes (modélisation ILPA)
et la consommation de puissance de chaque classe est décrite par l’activité de blocs
fonctionnels (modélisation FLPA) [53]. Actuellement, les processeurs extensibles sont
31
Chapitre I
très populaires dans l’industrie, ces processeurs sont un bon compromis entre haute
performance et haute flexibilité tout en gardant un temps de développement très court.
Les techniques d’estimation de consommation hybrides s’avèrent une bonne approche
pour l’estimation de puissance de cette gamme de processeurs. Le processeur extensible
Xtensa de Tensilica a été caractérisé à l’aide d’un macro-modèle linéaire hybride en [54].
Ce dernier est en effet la sommation
de deux fonctions linéaires. La première est une
fonction linéaire dépendante des paramètres au niveau instructions, celle-ci modélise les
instructions de base du processeur Xtensa ainsi que les effets secondaires que le matériel
personnalisé peut causer, déjà la deuxième est une fonction linéaire dépendante des
paramètres au niveau fonctionnel, celle-ci modélise spécifiquement la consommation du
matériel personnalisé.
5. CONCLUSION
Ce premier chapitre a servi d’introduction aux systèmes embarqués et la gestion de la
consommation énergétique au niveau des composants. Au début du chapitre, nous avons
présenté les caractéristiques, les différentes architectures et contraintes des systèmes
embarqués. Sont introduits aussi, les principes physiques mis en jeux dans la consommation
électrique des circuits intégrés et les méthodes d’évaluation et d’optimisation de l’énergie
consommée à chaque niveau de conception, en insistant particulièrement sur les composants
intégrés. Enfin, une étude sur les processeurs embarqués ainsi que les méthodes d’estimation
de leur consommation en énergie au niveau système sont présentées.
Le chapitre suivant est essentiellement consacré à la ressource processeur d’un système
embarqué, qui consomme dans la plupart des cas une partie non moins importante d’énergie.
Il s’agit des processeurs de traitement numérique du signal à virgule fixe (DSPs).
32
Chapitre II
Les processeurs DSP à virgules fixe et flottante
CHAPITRE II
LES PROCESSEURS DSP A VIRGULES FIXE ET FLOTTANTE
1. INTRODUCTION
Depuis maintenant plusieurs années, le traitement numérique de signal dans les systèmes
embarqués est devenu la technique qui suscite le plus d’intérêt de la part de chercheurs et
spécialistes. La technologie des processeurs utilisés dans ce domaine, communément désignés
par l’acronyme anglais DSP, connait jusqu’à nos jours de continuelles innovations.
Les contraintes de coût et de consommation propres aux systèmes embarqués requièrent
l’utilisation de l’arithmétique virgule fixe. La largeur des données codées en virgule fixe étant
plus faible que celle utilisée pour l’arithmétique virgule flottante, la consommation d’énergie
et le coût du circuit sont moindres. En général, les structures basées sur l’arithmétique virgule
flottante codent les données sur 32 bits alors que les données virgule fixe sont codées sur des
largeurs plus faibles. De nombreux DSPs travaillent avec des données codées sur 16 bits. De
plus, les opérateurs en virgule fixe sont moins complexes que ceux utilisant l’arithmétique
virgule flottante. Pour cette dernière, la partie matérielle doit permettre de gérer la mantisse et
l’exposant. En conséquence, l’arithmétique virgule fixe est privilégiée dans les systèmes
embarqués. Néanmoins, les temps de développement en virgule fixe sont plus importants car
les formats des différentes données doivent être définis. Ces formats doivent garantir
l’absence de débordement au sein de l’application.
Dans ce chapitre il sera question d’une présentation générale des microprocesseurs DSPs
puis d’une étude plus ou moins détaillée des deux principales familles auxquelles
appartiennent ces processeurs.
2. GENERALITE SUR LES PROCESSEURS DSPS
2.1. Introduction
L’utilisation de techniques numériques a nettement pris le pas sur les techniques
analogiques dans de nombreux domaines, parmi lesquels on peut citer pêle-mêle :
-
le traitement du signal classique (filtrage, transformées rapides, génération de
signaux...) ;
33
Chapitre II
-
les télécommunications (codage-décodage, modulation-démodulation, égalisation
adaptative, annulation d’écho, cryptage...) ;
-
le traitement de la parole (codage-compression, analyse, reconnaissance, synthèse...) et
des images (codage-compression, reconnaissance de formes...) ;
-
le radar (poursuite multimode, traitement antiréverbération, identification de cibles...);
-
les applications médicales : traitement de signaux EEG, EMG... imagerie biomédicale
dans les résonances magnétique nucléaire RMN...) ;
-
la commande (industrielle, avionique...), etc.
L’apparition des microprocesseurs standards, suivis des microcontrôleurs, puis des DSPs,
microprocesseurs dédiés au traitement du signal, a rapidement assuré l’avantage des solutions
programmées sur les solutions câblées. Ces techniques présentent de nombreuses
caractéristiques intéressantes parmi lesquelles:
-
une reproductibilité des traitements facilitant les tests ;
-
la réalisation de fonctions n’ayant pas, ou du moins très difficilement, d’équivalent
analogique ;
-
une facilité de modification des algorithmes et/ou des paramètres que celui-ci
nécessite ;
-
l’existence d’outils de simulation.
D’un point de vue économique, on peut être assuré d’une croissance importante du marché
des DSPs eu égard les équipements dans lesquels ils sont présents :
-
les téléphones mobiles sous forme de circuits spécialisés à cœur de DSP ;
-
les modems sous une forme similaire ;
-
les terminaux DSL (Digital Subscriber Line), ADSL (Asymmetric DSL), HDSL (High
DSL)... dans lesquels ils assurent l’égalisation, le brouillage, l’annulation d’écho, la
suppression de la télédiaphonie, etc.
-
la télévision haute définition (TVHD) (codage-décodage du son et de l’image) ;
-
la radiodiffusion numérique DAB (Direct Audio Broadcast) ;
-
les DVD (Digital Video Disks) pour le décodage de son Dolby AC-3 et le décodage
vidéo MPEG-2 (Motion Picture Experts Group -2) ;
-
le contrôle des moteurs à courant alternatif ;
-
le contrôle des disques durs : utilisation de techniques à maximum de vraisemblance
(PRML Partial Response, Maximum Likehood) pour augmenter la densité
d’enregistrement, etc.
34
Chapitre II
2.2. Spécificités des DSPs
Un DSP est un type particulier de microprocesseur. Il se caractérise par le fait qu'il intègre
un ensemble de fonctions spéciales. Ces fonctions sont destinées à le rendre particulièrement
performant dans le domaine du traitement numérique du signal.
Comme un microprocesseur classique, un DSP est mis en œuvre en lui associant des
mémoires (RAM, ROM: Read Only Memory) et des périphériques. Un DSP typique a plutôt
vocation à servir dans des systèmes de traitements autonomes. Il se présente donc
généralement sous la forme d'un microcontrôleur intégrant, selon les marques et les gammes
des constructeurs, des mémoires, des timers, des ports séries synchrones rapides, des
contrôleurs DMA (Direct Memory Access), et des divers ports d'E/S (Entrée/Sortie).
La chaîne complète typique d’un système de traitement numérique du signal est représentée
par la Figure 2.1.
Mémoire
Signal Original
Filtre
Passe Bas
Conversion
Analogique
Numérique
DSP
Conversion
Numérique
Analogique
Ports E/S
Filtre
Passe Bas
Signal Traité
Fig.2.1 : Chaîne complète typique d’un système de traitement numérique du signal.
Un DSP est différent à un microprocesseur par les deux spécifications suivantes :
2.2.1. L'opération MAC
Apres avoir été numérisé, le signal se présente sous la forme d'une suite de valeurs
numériques discrètes. Cette suite de valeurs (ou échantillons) est apte à être stockée et traitée
par un système informatique. Par nature, le traitement numérique du signal revient à effectuer
essentiellement des opérations arithmétiques de base, du type A = (B x C) + D, que l’on
appelle l’opération
MAC (Multiply and ACcumulate). Un microprocesseur classique
nécessite plusieurs cycles d'horloge pour effectuer un tel calcul.
La plupart des DSPs ont un jeu d'instructions spécialisé permettant de lire en mémoire une
donnée, effectuer une multiplication puis une addition, et enfin écrire le résultat en mémoire,
le tout en un seul cycle d'horloge. Ce type d'opération MAC est effectué en un seul cycle,
35
Chapitre II
mais il n’est pas satisfaisant si le cycle d'horloge est trop
lent. Le principal objectif
d'évolution des DSP, a toujours été d'améliorer le temps de calcul d'une opération MAC [55].
Outre le temps d'exécution d'une opération MAC, un autre problème se pose. L'opération
MAC étant une multiplication suivie d'une addition, un débordement de l'accumulateur est
toujours possible. Pour contourner ce problème, certains DSPs possèdent un accumulateur
adapté au MAC. Ces accumulateurs ont un format spécial incorporant des bits
supplémentaires (bits de garde) par rapport à la
taille des données à manipuler. Les
problèmes de débordement sont alors contournés, car un programme de traitement
correctement conçu ne devrait pas générer des suites d'opérations MAC telles qu’un résultat
excède la capacité élargie de l'accumulateur.
2.2.2. L'accès en mémoire
Une autre caractéristique intéressante des DSPs est leur capacité à réaliser plusieurs accès
mémoire en un seul cycle. Ceci permet à un DSP de chercher en mémoire une instruction et
ces données simultanément, pour réaliser une opération MAC. Le gain en temps est évident.
Toutefois, sur certains DSPs de base, ce type d'opérations simultanées est généralement limité
à des instructions spéciales [56]. Ces instructions utilisent un mode d'adressage restreint, c'est
à dire ne portant que sur la mémoire vive intégrée au DSP.
Les modes d'adressages des données sont un point particulier des DSPs. Un DSP peut
avoir plusieurs unités logiques de génération d'adresse, travaillant en parallèle avec la logique
du cœur du DSP. Une unité logique de génération d'adresses est paramétrée une seule fois via
des registres appropriés, elle génère alors toute seule, en parallèle avec l'exécution d'une
opération arithmétique, les adresses nécessaires à l'accès des données. Ceci permet non
seulement de réaliser les accès mémoires simultanés en un seul cycle, mais également
d'incrémenter automatiquement les adresses générées. Ce mode d'adressage particulier,
généralement appelé adressage indirect par registre avec post (ou pré) incrémentation, est très
utilisé pour effectuer des calculs répétitifs sur une série de données rangées séquentiellement
en mémoire.
2.3. Performances des DSPs
Plus que pour un microprocesseur classique, les performances d’un DSP conditionnent son
domaine d’application.
La plupart des DSPs sont particulièrement destinés à des applications « temps réel » et
spécialisées, c’est à dire des applications où le temps de traitement est bien sûr primordial,
36
Chapitre II
mais où la diversité des événements à traiter n’est pas notablement importante. De ce point de
vue, l’approche DSP s’apparente plus à une étude « électronique » visant à réaliser une ou des
fonctions de traitements de signal, que d’une approche informatique temps réel et/ou
multitâche traditionnelle.
Il existe cependant des applications où le DSP assure à la fois des f onctions de traitements
numériques du signal et les fonctions générales d’un microprocesseur au cœur d’un système
informatique classique.
Dans tous les cas, les performances du DSP sont critiques. Le concepteur d’un système à
base de DSP doit évaluer d’une part la « puissance » nécessaire pour réaliser les traitements
numériques voulus, et d’autre part les performances des DSPs disponibles pour réaliser son
application.
2.3.1. Vitesse de calcul
La méthode classique pour évaluer les performances d’un DSP est de se baser sur sa
vitesse d’exécution. Encore faut-il trouver une bonne définition de ce qu’est la vitesse
d’exécution, ce qui n’est pas forcement simple.
Cette méthode de base consiste donc à compter le nombre d’instructions effectuées par
seconde. Un obstacle apparait alors, car une instruction ne signifie pas forcément la même
chose d’une famille de DSP à l’autre. Le tableau 2.1 résume les principales définitions en
usage.
37
Chapitre II
Tableau.2.1 : Définition des unités les plus courantes de mesure des performances des DSPs.
Acronyme anglais
Définition
MFLOPS
Million Floating-Point Operations Per Second.
Mesure le nombre d’opérations à virgules flottantes (multiplications,
additions, soustractions, etc.) que le DSP à virgule flottante peut
réaliser en une seconde.
MOPS
Million Operations Per Second.
Mesure le nombre total d’opérations que le DSP peut effectuer en une
seconde. Par opérations, il faut comprendre non seulement le
traitement de données, mais également les accès DMA, les transferts
de données, les opérations d’E/S, etc. cette définition mesure donc les
performances globales d’un DSP plutôt que ses seules capacités de
calcul.
MIPS
Million Instructions Per Second
Mesure le nombre de codes machines (instructions) que le DSP peut
effectuer en une seconde. bien que cette mesure s’appuie à tous les
types de DSP. Le MFLOPS est préféré dans le cas d’un DSP à virgule
flottante.
MBPS
Mega-Bytes Per Second
Mesure la largeur de bande d’un bus particulier ou d’un dispositif
d’E/S, c'est-à-dire son taux de transfert.
Une autre méthode consiste à définir une fois pour toute une opération de référence comme
étant un MAC, puisqu’il s’agit d’une fonction commune à tous les DSPs. Il ne reste plus qu’à
compter le nombre de MAC par seconde.
Cependant cette définition n’apporte pas beaucoup d’informations sur les performances
des DSP modernes. En effet, un MAC est exécute en un seul cycle. Sachant que sur les DSP
récents, la plupart des instructions sont également exécutées en un cycle, cela revient donc à
mesurer les MIPS du DSP. Il faut également tenir compte du fait que certains DSPs en font
plus dans un seul MAC (nombre, format et taille des opérandes traités) que d’autres.
2.3.2. Mesure du temps d’exécution (« Benchmark »)
La vitesse de calcul pure d’un DSP n’est pas une indication universelle, les méthodes et les
résultats diffèrent d’un DSP à l’autre. De plus elle ne rend pas compte d'un certain nombre de
perfectionnement dont peuvent bénéficier tel ou tel DSP.
Certains DSPs proposent en effet des modes d’adressages plus performants que d’autres.
Ces modes sont spécialement adaptés à des algorithmes standards du traitement du signal
(exemple : le mode d’adressage dit « bits reversing » pour accélérer le calcul FFT : Fast
38
Chapitre II
Fourier Transform). Les instructions itératives sont également importantes en termes de
performance (rapidité des boucles logicielles) et ne devraient pas être ignorées.
Enfin, le temps d’accès à la mémoire est un autre paramètre incontournable. Certains
DSPs intègrent des blocs de mémoire vive rapide. Cette mémoire est placée dans l’espace
d’adressage du DSP au même titre que de la mémoire vive externe, ceci permet d’y ranger
données et programmes sans avoir à effectuer des transferts permanents de ou vers l’extérieur.
Les éventuels cycles d’attentes pouvant être nécessaires pour adresser une mémoire externe
lente sont ainsi évités.
Pour toutes ces raisons, la mesure des performances par benchmark complète
avantageusement la mesure de vitesse pure. Elle consiste à mesurer le temps que met le DSP
pour exécuter des programmes « standards » de traitements du signal. Encore faut-il définir ce
qu’est un programme standard de traitement du signal.
Le point faible des benchmarks réside dans cette définition des algorithmes standards.
Quel domaine d’application faut-il choisir ? Quels sont les algorithmes les plus représentatifs?
Il existe plusieurs systèmes de benchmarks se proposant de servir de référence. Ainsi, le BDT
(Berkeley Design Technology)
benchmark est couramment utilisé, un autre benchmark
fréquemment utilisé est le « Standard Performance Evaluation Corporation », ou SPEC95
(Standard Performance Evaluation Corporation 95), qui couvre plusieurs domaines tels que
les vocodeurs, l’asservissement en position des têtes de lectures des disques durs, les modems,
voire les applications multimédia sur PC.
Dans la pratique, un autre problème se pose : la qualité de l’implémentation des
algorithmes peut varier d’un système de développement à l’autre. Ainsi par exemple, à qualité
égale, un filtre numérique peut demander plus ou moins de ressources processeur en fonction
de telle ou telle implémentation. Cet aspect n’est pas pris en compte par les benchmarks.
La mesure des capacités d’un DSP par benchmark reste néanmoins intéressante, car elle
tend à mesurer la performance globale du système de traitement numérique (y compris les
capacités du programmeur !).
3. CRITERES DE CHOIX D’UN PROCESSEUR DSP
Les processeurs DSPs peuvent exécuter divers types de programmes, mais leur jeu
d'instructions ainsi que leur architecture ont été optimisés afin de traiter les signaux en temps
réel. Cependant, la réussite de l'implantation d'une application sur un DSP repose sur le choix
de celui-ci au niveau de l'architecture et du degré d'intégration. Actuellement les contraintes
39
Chapitre II
en coût pour les produits grand public et en consommation pour les systèmes embarqués sont
prises en compte dans l'élaboration des architectures de DSPs. Parmi les processeurs
disponibles, il est possible de choisir un DSP standard dédié à un domaine d'application ou un
cœur de DSP autour duquel il faut ajouter des fonctionnalités nécessitées par l'application.
En fait le choix d’un processeur DSP dépend fortement de l’application retenue. Un
processeur peut être performant pour quelques applications mais non pour d’autres. A cet
effet, on peut considérer en choisissant un processeur, un certain nombre de facteurs qui
changent d’un DSP à un autre.
3.1. Arithmétique de calcul
Une des caractéristiques les plus fondamentales d’un processeur est le type d’arithmétique
liée à son architecture. La plupart des DSPs utilisent l’arithmétique à virgule fixe, où les
nombres sont représentés comme des nombres entiers ou fractions dans une gamme fixe
(habituellement allant de -1.0 à +1.0). D’autres processeurs emploient l’arithmétique à virgule
flottante, où les valeurs sont représentées par une mantisse et un exposant tel que :
mantisse × 2exposant. La mantisse est généralement une fraction dans la gamme -1.0 à +1.0,
tandis que l’exposant est un nombre entier qui représente le nombre de places où la virgule
binaire (analogue à la virgule décimale dans un nombre de base 10) doit être décalée à gauche
ou à droite afin d’obtenir la valeur représentée. L’arithmétique à virgule flottante est un
mécanisme plus flexible et plus général comparativement à celle de la virgule fixe. Les
concepteurs de systèmes ont accès dans ce cas à une large plage des mots représentés
(dynamique des mots plus importante). En conséquence, il est généralement plus facile de
programmer les DSPs à virgule flottante que leurs homologues à virgule fixe. Cependant ils
sont plus chers et leur consommation d’énergie est plus élevée. L’avantage d’une utilisation
facile de ces processeurs flottants est dû au fait que dans beaucoup de cas le programmeur ne
doit pas être préoccupé par la gamme dynamique des données et leur précision. En revanche,
sur un processeur à virgule fixe, les programmeurs doivent impérativement et soigneusement
mesurer à de diverses étapes de leurs programmes, la précision numérique proportionnée avec
la gamme dynamique limitée imposée [57].
3.2. Dynamique des mots
Tous les DSPs à virgule flottante utilisent 32 bits pour coder les mots. Pour les DSPs à
virgule fixe, la dynamique est de 16/20/24 bits. La taille en bits d’une donnée a un impact
important sur le coût. Elle influe fortement sur les dimensions de la puce, le nombre de
broches requises, et la taille des blocs mémoires externes utilisés. Par conséquent, les
40
Chapitre II
concepteurs essayant de fabriquer des puces avec la plus petite taille possible de mot utilisé
que leur application peut tolérer. Quand le besoin est ressenti pour plus de précision, le
recours à une arithmétique à double précision est recommandé. A titre d’exemple, en donnant
un processeur à virgule fixe de 16 bits, le programmeur peut exécuter des opérations en
double précision d’arithmétique de 32 bits en enchainant une combinaison appropriée
d’instructions. Si la partie majeure d’une application peut être manipulée avec une
arithmétique de simple précision, et l’application à besoin de plus de précision, l’utilisation
sélective de l’arithmétique à double précision peut se comprendre. Si la partie majeure de
l’application exige plus de précision, un processeur avec une plus grande taille des mots de
données est susceptible d’être un meilleur choix [57].
3.3. Vitesse de calcul
Une autre mesure fondamentale du choix d’un processeur DSP pour une application
donnée ; la vitesse de calcul. Il y a différentes façons de mesurer la vitesse d’un processeur.
La plus fondamentale est la durée de cycle d’une instruction se résumant dans la qualité de
temps requise pour exécuter l’instruction la plus rapide sur le processeur. Réciproquement, la
durée de cycle divisée par un million et multipliée par le nombre d’instructions exécutées par
seconde ; est le taux maximal d’exécution de l’instruction du processeur dans les millions
d’instructions par seconde, ou MIPS. Un problème apparait quand on compare le temps
d’exécution des instructions utilisées. La qualité de travail accomplie par une instruction
change considérablement d’un DSP à un autre. Certains des plus nouveaux emploient les
architectures VLIW, dans lesquelles de multiples instructions sont issues et exécutées au
niveau d’un même cycle. Ces processeurs emploient typiquement des instructions très simples
effectuant beaucoup moins de travail que les instructions typiques des processeurs
conventionnels de DSPs. Une solution pas aussi évidente à ce type de problème, est de choisir
une opération comme unité de référence (au lieu d’une instruction) et de l’employer comme
mesure de base en comparant les processeurs. Supposons à titre d’exemple l’opération MAC
peut servir de mesure de base. Le temps d’exécution d’une telle opération fournit d’infimes
renseignements pour différencier entre deux DSPs en général [57]. Comme souligné
précédemment, la mesure de vitesse de calcul par « Benchmarks » demeure la meilleure
solution offerte.
3.4. Organisation de la mémoire
L’organisation des mémoires peut avoir un grand impact sur le fonctionnement des DSPs.
Comme cité précédemment, l’opération MAC comme d’autres opérations, sont fondamentales
41
Chapitre II
pour beaucoup d’algorithmes de traitement des signaux. L’exécution rapide d’une opération
MAC exige la recherche d’un mot d’instruction et de deux mots opérandes de la mémoire une
fois pendant chaque cycle d’instruction. La structure des DSPs répond bien à ces exigences.
D’abord parce que l’architecture Harvard des DSPs sépare naturellement les mémoires
programme et données dans le but d’un accès plus souple et plus rapide. L’utilisation de
mémoires à accès multiples (banque de données) pour permettre de multiples accès aux
données par cycle d’instruction existent bel et bien au niveau de ce type d’architecture. Aussi
la présence de mémoire cache ne peut être qu’indispensable, afin de permettre aux
instructions d’aller chercher les mots à son niveau au lieu de la mémoire proprement dite, et
ce pour éviter un accès supplémentaire à la mémoire qui peut être exploité pour aller chercher
d’autres données [57].
3.5. Appui multiprocesseur
Certaines applications de haut niveau nécessitant des calculs complexes ou un traitement
multicanaux, exigent souvent l’utilisation parallèle de plusieurs DSPs. Dans ce cas, la facilité
d’interconnexion des processeurs (en termes de temps de conception des circuits de
communication inter processeur), ainsi que le coût et performances d’intercommunication
peuvent être des facteurs importants. Cette caractéristique d’appui multiprocesseur convient
énormément pour des systèmes ouverts à d’éventuelles extensions ultérieures [57].
3.6. Facilité de développement
Le degré de facilité de développement de programmes dépend aussi de l’application en
question. Les ingénieurs et chercheurs auront besoin probablement d’outils qui rendent ce
développement aussi simple que possible. Pour cela, le choix d’un DSP dépend de ses outils
logiciels de développement, à savoir, l’assembleur, le linker, le simulateur, le débuggeur, le
compilateur, les bibliothèques de code et logiciels d’exploitation en temps réel. L’outil
matériel tel que la carte de développement, l’émulateur, et bien d’autres environnements de
plus haut niveau de génération de code, est aussi important pour le choix d’un DSP.
Typiquement les réalisateurs choisissent l’un ou l’autre langage d’assemblage, un langage de
haut niveau, comme le C, ADA, ou une combinaison de tous les deux. Cependant, une grande
partie de programmation des DSPs est encore faite en langage assembleur. Puisque les
applications ont des conditions de calcul voraces, les programmeurs ne peuvent pas souvent
utiliser des compilateurs qui génèrent du code assembleur s’exécutant lentement. Plutôt ils
peuvent être forcés d’optimiser le code assembleur pour abaisser le temps d’exécution et le
nombre d’instructions à des niveaux acceptables. Dans un but de facilité de développement,
42
Chapitre II
les utilisateurs de compilateurs de langage de haut niveau souvent préfèrent les compilateurs
travaillant sur DSP à virgule flottante que sur les DSPs à virgule fixe. Plusieurs raisons sont à
l’origine de ce choix : d’abord, la plupart des langages de haut niveau n’ont pas le soutien
intrinsèque de l’arithmétique flottante ; en second lieu, les processeurs à virgule flottante
tendent à comporter régulièrement plus d’instructions et sont donc moins restrictifs que les
processeurs à virgule fixe ; enfin et comme c’est mentionné auparavant, les processeurs à
virgule flottante soutiennent typiquement de plus grands espaces mémoires que les
processeurs à virgule fixe, donc capables de générer du code compilateur qui tend à être plus
important que le code assembleur. Pour ce type de DSP le code reste toujours moins optimisé
et ce, quel que soit le degré d’optimisation du programme réalisé. L’utilisation d’un DSP à
virgule fixe programmé en assembleur peut présenter par contre des performances meilleures
au détriment d’un temps de développement supérieur mais avec l’avantage d’une
consommation moindre en énergie [57].
3.7. Consommation d’énergie
Comme c’est mentionné dans le chapitre précédent, la consommation d’énergie est un
facteur pertinent et décisif pour les systèmes embarqués.
Certains DSPs permettent aux programmeurs de neutraliser les périphériques qui ne sont
pas en service. Indépendamment des dispositifs de gestion de la puissance, il est souvent
difficile pour les ingénieurs d’estimer la consommation des DSPs, car la puissance d’un DSP
peut changer d’un moment à l’autre selon les instructions qu’il exécute. Malheureusement, la
plupart des fournisseurs éditent seulement des valeurs « typique ou maximum » de
consommation d’énergie, sans indiquer en quoi ça consiste un programme ‘’typique’’. Une
exception faite par Texas Instruments qui fournit des notes d’application dans lesquelles la
consommation d’énergie est détaillée. Ce paramètre évoquant la consommation d’énergie est
indispensable pour l’évaluation d’applications embarquées ou d’applications nécessitant
l’exploitation de plusieurs prototypes utilisés à grande échelle [57].
3.8. Coût
Evidemment le coût du processeur est un souci majeur pour les produits fabriqués en série.
Pour les applications, les concepteurs essayant d’utiliser des DSPs à bas prix qui répondent
aux contraintes, quoique de tels dispositifs puissent être considérablement moins flexibles et
plus difficiles à programmer que les processeurs plus couteux. Les processeurs moins chers
tendent à avoir sensiblement peu de dispositifs, moins de mémoire sur puce, et donc moins de
performances que les autres processeurs encore plus couteux. Les DSPs à virgule fixe sont en
43
Chapitre II
général à moindre prix par rapport aux DSPs à virgule flottante. Par exemple le DSP à virgule
fixe C541 présente un prix 5 à 10 fois moins cher que le DSP à virgule flottante, le C6701
[57].
4. EXEMPLES DE PROCESSEURS DSPS
4.1. Processeurs DSPs à virgule flottante
Les performances de la microélectronique permettent d’intégrer actuellement de grandes
quantités de composants (>500 000), ce qui permet à de nombreux constructeurs de proposer
des processeurs DSPs travaillant sur des nombres représentés en virgule flottante 32 bits
(norme IEEE 754-1985). La rapidité est en même temps accrue avec des cycles d’instruction
d’une durée encore plus faible, et en moyenne 1 à 2 cycles par instruction. Le fonctionnement
en virgule flottante est la principale évolution de cette famille de DSPs, il autorise la
manipulation de nombres qui ont une plus grande dynamique avec en général, plus de
précision. Ceci facilitera la mise au point des programmes qui devaient jusqu'à présent se
contenter en général d’une représentation à 16 bits en virgule fixe. De même, certains
algorithmes, jusqu’ alors inutilisables en virgule fixe, pourront être implantés. D’une façon
générale, on constate une multiplication des bus internes (32bits) et des unités dédiées
(multiplieur flottant, UAL flottante : Unité Arithmétique et Logique, générateurs d’adresses
32 bits élaborés, contrôleur de DMA etc.), ce qui permet un haut niveau de parallélisme.
L’adressage qui se fait sur 32 bits, offre de plus grandes possibilités. On trouve d’ailleurs en
général 1 à 2 contrôleurs de DMA qui permettent des transferts ultra rapides de blocs de
données sans gêner le fonctionnement de l’unité de calcul. Les différentes améliorations
permettent à ces processeurs de supporter des langages de haut niveau comme le C. Il s’en
suit une réduction très importante du temps de développement. Auparavant, il fallait tester
l’algorithme choisi sur un ordinateur classique, simuler l’implantation pour le processeur
utilisé afin de déterminer le bon jeu de paramètres, puis écrire le programme (en assembleur),
le télécharger sur une carte cible ou un système de développement puis tester l’application.
Grâce à la représentation en virgule flottante et la possibilité de supporter un langage de haut
niveau, on conçoit facilement la simplification apportée surtout si on travaille dans un
environnement de type micro ordinateur PC pour lequel il existe de nombreuses cartes
construites autour de DSPs. Dans ce qui suit, on présente la description de quelques types de
processeurs flottants se trouvant sur le marché.
44
Chapitre II
4.1.1. Les processeurs TMS320C67xx
TMS320C67xx est la famille de dernière génération des DSPs à virgule flottante 32bits de
chez Texas instruments figure (2.2). Cette famille est dérivée de la famille C62x 16bits à
virgule fixe fonctionnant à 200MHZ et complètement compatible avec le code DSP C62. En
outre, la famille C67x soutient l’arithmétique flottante IEEE754 à 32 bits simple précision, et
64 bits double précision. Elle vise les applications grand public (audio), le graphisme 3D,
l’imagerie médicale, le radar, et la reconnaissance vocale. le TMS320C67x contient deux
chemins de données à virgule flottante, chaque chemin contient deux MACs, deux UALs, et
un additionneur/soustracteur pour la génération d’adresses. Les UALs supportent les
opérations sur les entiers et sur les flottants. Les multiplieurs effectuent des multiplications
16x16 bits et 32x32 bits sur les entiers, et sur les flottants de 32 et 64 bits.
Fig.2.2 : Schéma fonctionnel de l’architecture TMS320C67xx [58].
Le système de mémoire de TMS320C67xx dispose d’une structure Harvard modifiée. La
recherche des instructions se fait par un bus d’adresse de 32 bits, et un bus de données 32 bits.
Chaque chemin d’accès aux données utilise 32 bits d’adresse et 64 bits de données. Ensemble,
ces bus peuvent exécuter en un cycle, deux chargements de 64 bits et stockages de 32 bits
vers ou depuis la mémoire interne.
45
Chapitre II
Le C6701 contient en interne 64 Ko de mémoire programme, et 64 Ko de mémoire de
données. La mémoire programme peut être configurée comme une mémoire cache. Ce
processeur et le TMS320C6712, utilisent 2 x 4ko de mémoire cache niveau1, une pour les
données, et l’autre pour les programmes. Une autre mémoire de 64 ko niveau2, peut être
configurée comme une SRAM, une cache, ou comme une combinaison entre les deux. Le
TMS320C6713 a la même architecture mémoire comme le TMS320C6711 et le
TMS320C6712 sauf que la mémoire niveau 2 est de 256 ko. Les TMS320C67x supportent
les adressages : registre direct, registre indirect, et l’adressage immédiat. Ils supportent aussi
l’adressage modulo (8 registres peuvent utiliser ce type d’adressage). Cependant ces types de
DSPs ne supportent pas l’adressage « bit-reverse ». Les membres de la famille C67x incluent
une variété de périphériques : un port hôte, un contrôleur DMA multicanaux, une interface
audio numérique, un timer de 32 bits et un port série.
4.1.2. Les processeurs ADSP2116x
La famille ADSP2116x est la deuxième génération d’Analog Devices des processeurs à
virgule flottante 32 bits, figure (2.3). Ces DSPs visent particulièrement le domaine militaire,
audio, identification de la voix, le traitement d’images, ainsi que les applications de
téléphonie exigeant des systèmes à structure multiprocesseur. Le premier membre de la
famille ADSP -2116x, est l’ADSP-21160, qui dispose d’une vitesse de 100 MIPS, utilise 32
bits d’adresses et 48-bits pour les données.
Fig.2.3 : Schéma fonctionnel du processeur ADSP21160 [59].
46
Chapitre II
L’architecture ADSP2116x fournit trois types distincts d’unités de calcul : un multiplieuraccumulateur, un décaleur, et une UAL, qui effectuent des opérations arithmétiques et
logiques en un seul cycle d’instruction. Chacune des trois unités est présente dans les deux
chemins de données qui peuvent fonctionner en parallèle en utilisant des instructions SIMD
(Single Instruction Multiple Data). Au niveau de chaque chemin de données, le multiplieuraccumulateur, le décaleur, et l’UAL accèdent à un registre dossier contenant seize registres de
40-bits. Les unités de décalage effectuent la manipulation à bit unique, de plusieurs bits,
rotation, et opérations de décalage logique et/ou arithmétique. Les unités de multiplication
exécutent des multiplications sur des entiers, des flottants, et des nombres fractionnaires. Ces
dispositifs fournissant l’appui pour l’arithmétique en multi précision. En fonctionnant sur des
données en virgule flottante, les unités de multiplication exécutent des opérations de 32x32
→40 bits ou 40x40→ 40 bits. En fonctionnant sur des données à virgule fixe, les unités de
multiplication exécutent les multiplications 32x32→64 bits et chacun fournit une sous-unité
de l’accumulateur 80 bits (qui fournit 16 bits de garde). Les accumulateurs sont utilisés
seulement pour des opérations à virgule fixe ; l’UAL est employée pour effectuer
l’accumulation de résultats à virgule flottante. L’ADSP2116x soutient quatre types de
données à savoir : 40-bits, 32-bits IEEE,
16 bits en virgule flottante et 32 bits en virgule
fixe. Son système de mémoire subdivisé en deux blocs de 3M mots hors puce de
multiprocesseur (mémoire qui réside physiquement dans d’autres processeurs ADSP2116x),
et jusqu’à 4G mots de mémoire hors puce d’usage général. Les générateurs d’adresses, les bus
d’adresses, et les bus de données séparés, permettent aux deux blocs de mémoire sur puce,
d’être consultés par le processeur en un seul cycle d’instruction. En outre, l’ADSP2116x
inclue une mémoire d’instructions cache de 32-mots qui peut être employée pour améliorer la
dynamique (bande plus large) de mémoire. Les bus de données sont élargis à 64-bits pour
s’adapter à la largeur de bande supplémentaire requise par le chemin de données
additionnelles. En exécutant des instructions de cache, le processeur peut charger ou stocker
deux paires de mots de 32 bits par cycle d’instructions, ayant pour résultat une largeur de
bande de 400M mots/s de 32 bits pour une vitesse de 100MIPS.
Les périphériques dans l’ADSP2116x incluent un timer, 2 ports série, 6 ‘link ports’, un
contrôleur DMA de 14 canaux, 4 bornes de bit-I/O (Input/Output), et un port de hôte. Chacun
des périphériques à un canal d’accès direct en mémoire.
47
Chapitre II
4.2. Processeurs DSPs à virgule fixe
Les DSPs à virgule fixe moins chers et consommant moins d’énergie, sont en général plus
compliqués à programmer que les DSPs à virgule flottante. Toutefois, la précision des calculs
est un point critique des DSPs à virgule fixe, car le concepteur de programmes doit rester
vigilant à chaque étape de calcul. Il doit rechercher la plus grande dynamique possible (c.à.d.
exploiter au mieux la gamme des nombres disponibles), pour conserver une bonne précision
des calculs, tout en évitant autant que faire ce peut les débordements du ou des accumulateurs.
Les bits supplémentaires des accumulateurs (bits de garde) prévus à cet effet, permettent de
réduire cette contrainte.
Les programmeurs contournent les limites des DSPs à virgule fixe en déterminant à
l’avance, et avec soins, la précision et la dynamique nécessaire (par méthode analytique ou
avec des outils de simulation) pour réaliser leurs projets. Il est également possible d’effectuer
des opérations en virgule flottante dans un DSP à virgule fixe par le biais de routines
logicielles adéquates. Cette approche est néanmoins pénalisante en temps d’exécution, même
sur un DSP à virgule fixe très rapide.
En termes de rapidité, les DSPs à virgule fixe se placent généralement devant leurs
homologues à virgule flottante, ce qui constitue un critère de choix important.
En termes de coût, les DSPs à virgule fixe sont moins chers que les DSPs à virgule
flottante, ils sont les plus utilisés. On les trouve dans tous les produits de grande diffusion où
le coût est un facteur important. Il peut cependant exister des exceptions, certains DSPs à
virgule fixe se présentant comme des microcontrôleurs perfectionnés, sont plus chers qu’un
DSP à virgule flottante de base.
L’exemple qu’on va décrire dans ce qui suit appartient à la famille des DSPs à virgule fixe
de chez Analog Devices. Il s’agit de la famille des DSPs à architecture conventionnelle,
ADSP-21xx. Elle est à virgule fixe et utilise des données de 16 bits. Son évolution a été
rapide en fonction de la diversification des besoins de ses processeurs.
Le cœur des DSPs de cette famille (Core 21xx) est dédié spécifiquement aux calculs, il
contient les ensembles principaux suivants :
-
01 ALU permettant les calculs simples du processeur : addition, soustraction, opérations
logiques,
-
01 MAC permettant les calculs de multiplication et d’addition,
48
Chapitre II
-
01 BS (Barrel Shifter) permettant le décalage de bits sur 16 ou 32 bits en mode logique et
arithmétique,
-
02 DAGs (Data Address Generator), générateurs d’adresses de données, pointeurs,
indispensables pour la plupart des opérations,
-
01 mémoire cache [60].
A noter que le DSP doit pouvoir accéder de façon simultanée à la zone de programme et à la
zone de données. C'est pourquoi il faut deux générateurs d'adresses indépendants. DAG1
génère l'adresse pour la zone de données et DAG2 génère l'autre adresse pour la zone de
programme. Les deux zones mémoires sont physiquement séparées.
Pour notre cas et dans un but de conformité avec nos objectifs, nous avons choisi de
travailler délibérément sur l’un des DSPs les plus performants de la famille, à savoir,
l’ADSP2181.
L’ADSP2181 est un processeur appartenant à la famille ADSP-21xx. Il a une vitesse
d'horloge de 40 MIPS (25ns de temps de cycle) et fonctionne sous une tension d'alimentation
de 5Volts. Ce processeur comporte un noyau 21xx commun à tous les processeurs
ADSP218x. Ce qui les diffère les uns des autres sont les unités périphériques intégrées sur la
même puce. Certains ont une mémoire intégrée de plus grande capacité que d'autres, Certains
possèdent un port DMA. D'autres fonctionnent à une vitesse d'horloge plus rapide. Certains
fonctionnent sous une tension d'alimentation de 2,5Volts, alors que d'autres fonctionnent à
plus basse tension, soit 1,8 Volts.
Dans la figure 2.4 on montre la constitution du noyau de l’ADSP2181 et de ses unités
périphériques.
49
Chapitre II
Fig.2.4 : Constitution interne du DSP ADSP2181 [61].
A rappeler que ce type d’architecture est très bien adapté au calcul FFT. Il intègre la fonction
« bit reverse » lui permettant le désembrouillage des données en un temps record.
5. CONCLUSION
Ce chapitre a fait l’objet d’une présentation générale des processeurs DSPs à virgules fixe
et flottante. Une description des principes fondamentaux de ces processeurs a été évoquée.
Les critères de choix de ces architectures de calcul, ainsi que des exemples de DSPs
appartenant aux deux familles indiquées, ont été bien décrits. Conformément aux objectifs
dressés, le processeur ADSP2181 de chez Analog Devices a été retenu pour notre application.
Le chapitre suivant fera l’objet d’une description générale des langages machines ainsi
que les techniques d’évaluation des performances des algorithmes fonctionnant en code
assembleur.
50
Chapitre III
CHAPITRE III
LANGAGE MACHINE ET CONSOMMATION D’ENERGIE
1. INTRODUCTION
De nos jours, la consommation d’énergie électrique est une contrainte clé et une métrique
de performance essentielle lors du design des systèmes numériques embarqués. Le processeur
est une ressource principale de ces systèmes et consomme une partie importante de l’énergie
durant l’exécution d’une application.
Pour assurer l’existence d’un algorithme à la fois faisable pour le fonctionnement de
l’application et optimal pour la consommation énergétique, il suffit d’écrire ces algorithmes
dans un langage de programmation proche du langage machine, ce langage est l’assembleur.
Le langage assembleur est intimement lié au processeur et les programmes écrits avec ce
langage dépendent directement de la machine qui les exécute.
L’évaluation de la consommation en énergie des algorithmes est basée sur diverses
méthodes et outils. On montre que la somme des consommations individuelles des
instructions dans un programme donne la consommation totale; une évaluation préliminaire
de la dissipation d’énergie pouvant être considérée comme non moins importante par rapport
à la consommation globale dans un système embarqué.
Dans ce chapitre nous présentons une introduction sur les langages de programmation avec
particulièrement le langage assembleur. Ensuite, nous décrivons les outils et techniques
utilisés pour l’estimation de la consommation en énergie des algorithmes implantés dans les
processeurs embarqués. Enfin, nous donnons des exemples sur des processeurs DSP à virgule
fixe lors de l’exécution d’algorithmes en langages évolué et machine.
2. LANGAGES DE PROGRAMMATION
2.1. Introduction
En informatique, un langage de programmation est une notation conventionnelle destinée à
formuler des algorithmes et produire des programmes informatiques qui les appliquent. D'une
manière similaire à une langue naturelle, un langage de programmation est fait d'un alphabet,
un vocabulaire, des règles de grammaire, et des significations.
Les premiers langages de programmation ont été créés dans les années 1950. De nombreux
concepts de l'informatique ont été lancés par un langage, avant d'être améliorés et étendus
51
Chapitre III
dans les langages suivants. Pour la plupart du temps, la conception d'un langage de
programmation est fortement influencée par l'expérience acquise avec les langages précédents
[62].
Les langages de programmation permettent de décrire d'une part les structures des données
qui seront manipulées par l'appareil informatique, et d'autre part d'indiquer comment sont
effectuées les manipulations et selon quels algorithmes. Ils servent de moyens de
communication par lesquels le programmeur communique avec l'ordinateur, mais aussi avec
d'autres programmeurs; les programmes étant d'ordinaire écrits, lus, compris et modifiés par
une communauté. Un langage de programmation est mis en œuvre par un traducteur
automatique: compilateur ou interpréteur. Un compilateur est un programme informatique qui
transforme dans un premier temps un code source écrit dans un langage de programmation
donné en un code cible qui pourra être directement exécuté par un ordinateur, à savoir un
programme en langage machine ou en code intermédiaire, tandis que l'interpréteur réalise
cette traduction à la volée.
2.2. Utilisation
La facilité d'utilisation, la portabilité et la clarté sont des qualités appréciées des langages
de programmation. La facilité d'utilisation, qui dépend de la syntaxe, du vocabulaire et des
symboles, influence la lisibilité des programmes écrits dans ce langage et la durée
d'apprentissage. La portabilité permet à un programme écrit pour être exécuté par une
plateforme informatique donnée (un système d'exploitation) d'être transféré en vue d'être
exécuté sur une autre plateforme.
L'alignement sur les standards industriels, la possibilité d'utiliser des fonctionnalités écrites
dans un autre langage de programmation et l'exécution simultanée de plusieurs threads sont
des possibilités appréciées des langages de programmation [63].
2.3. Évolution des langages
Si tous les langages de programmation finissent par traduire leur code en langage
machine, il existe plusieurs niveaux de langage de programmation, qui peuvent être plus
simples à utiliser pour un programmeur. Plus un langage est de haut niveau, plus il faut
abstraction du matériel, alors qu’un langage de base est plus proche du matériel de
l’ordinateur. Ces différents niveaux peuvent être séparés en : langage machine et langage
52
Chapitre III
assembleur, qui sont des langages de bas niveau ; langage de haut niveau et langage de
quatrième génération.
2.3.1. Langage machine
Le langage machine, dit langage de première génération, est ce qui pourrait être considéré
comme le langage de programmation du plus bas niveau. Il est écrit en binaire, une suite de 0
et de 1, qui se regroupent en groupe de 8 pour former ce que l’on appelle des octets. C’est le
langage de programmation le plus simple à comprendre pour l’ordinateur, car chaque
processeur est muni d’une palette d’instructions en langage machine qui lui est propre, un
langage natif. Si un processeur A peut exécuter toutes les instructions d’un processeur B, le
processeur A est compatible avec le processeur B. Le contraire n’est pas forcément vrai, car le
processeur A peut posséder des instructions que le processeur B ne possède pas. Le langage
machine est donc le seul langage de programmation qui peut être directement « compris » par
l’ordinateur. Si c’est le seul qui peut être compris par l’ordinateur, pourquoi alors y a-t-il
d’autres niveaux de langages de programmation ? La réponse est simple, le langage machine
est un langage qui est très difficile à comprendre pour un programmeur et le débogage peut
être très fastidieux. C’est pourquoi il existe un langage de programmation tel que le langage
assembleur.
2.3.2. Langage assembleur
Le langage assembleur, dit langage de deuxième génération, est le langage de
programmation qui se rapproche le plus du langage machine. Il remplace la plupart des
instructions binaires du processeur par des mots clés, comme ‘MOV’. Ce langage facilite
grandement la programmation, car le programmeur n’a plus besoin de connaître toutes les
lignes de bits qui référent à une instruction du processeur par cœur. Par contre, parce que
chaque processeur possède un langage machine qui lui est propre, il doit aussi y avoir un
langage assembleur propre à chaque processeur. Parce qu’il est très proche du langage
machine, le langage assembleur peut être traduit en langage machine et être exécuté
rapidement par l’ordinateur. Par contre, pour la même raison qu’il peut être exécuté
rapidement, le langage assembleur reste un langage difficile à comprendre et à déboguer pour
un programmeur. Une bonne connaissance de l’architecture matérielle du processeur, est
souvent nécessaire pour maîtriser un tel langage de programmation.
53
Chapitre III
2.3.3. Langage de haut niveau
Le langage de haut niveau, dit langage de troisième génération, est un niveau de langage
de programmation qui se rapproche beaucoup plus d’un langage dit naturel (par exemple
l’anglais) que du langage machine. Le code d’un programme fait avec un langage de haut
niveau utilise des mots issus d’un langage plus familier pour l’être humain en faisant
abstraction des caractéristiques techniques du matériel. C’est l’équivalent du langage
assembleur, mais à un niveau d’abstraction beaucoup plus élevé. Cela rend le langage de haut
niveau beaucoup plus compréhensible et facile d’utilisation pour un programmeur. Par contre,
l’utilisation d’un langage de haut niveau comporte un certain défaut, car il faut traduire le
code du programme en langage machine avant de l’exécuter, ce qui rend le programme plus
lent à l’exécution et à la compilation. De plus, le langage de haut niveau ne comporte pas le
même problème que les langages machine et assembleur ; il n’est pas propre au processeur.
Un programme fait avec un langage de haut niveau peut donc facilement être fonctionnel sur
plusieurs ordinateurs. Par contre, certains programmes peuvent être uniques à un système
d’exploitation (Windows, OS, Linux, etc.). Pour être exécuté, un programme utilisant un
langage
de
haut
niveau
doit
être
compilé
ou
interprété.
Dans le cas où le programme est compilé, le code source du programme est traduit à son
équivalent en langage machine par un programme appelé compilateur. Lorsque la compilation
du programme est terminée, le code en langage machine résultant est sauvegardé séparément
et peut alors être exécuté indépendamment du code source en tout temps. A chaque
modification du code source, il faut alors recompiler le code pour faire une nouvelle version
exécutable du programme en langage machine. Le code machine résultant de cette
compilation est moins efficace (plus lent) que l’équivalent qui aurait été fait en langage
assembleur, mais il est beaucoup plus rapide et simple pour un programmeur de faire un
programme en langage de haut niveau qu’en langage assembleur ou en langage machine.
Il existe plusieurs langages de haut niveau utilisés dans divers domaines d’application, à
savoir : Basic, Fortran, Pascal, C, Delphi, C++, etc.
2.3.4. Langage de quatrième génération
Le langage de quatrième génération (L4G, ou 4GL : 4th Generation Langauge) est un
langage qui se rapproche encore plus du langage naturel que le langage de troisième
génération. Le langage de quatrième génération est un langage qui est conçu pour résoudre
54
Chapitre III
des problèmes spécifiques, contrairement au langage polyvalent de troisième génération. Le
langage de quatrième génération est non procédural et est plus simple à apprendre qu’un
langage de troisième génération. Ce niveau de langage permet au programmeur de
programmer une application spécifique à un sujet et de le faire avec une grande lisibilité et
très peu de code, avec le défaut d’être moins polyvalent et d’avoir moins de possibilités
d’optimisation. Le langage de quatrième génération est souvent utilisé pour accéder aux bases
de données et pour faire des requêtes concernant celles-ci. Parce que ce langage est dédié à un
domaine spécifique, les opérations spécifiques concernant ce domaine, sont déjà incluses dans
le lexique du langage, contrairement au langage de troisième génération où ces opérations
seraient incluses dans une bibliothèque de logiciel complémentaire.
2.4. Le langage C
C est un langage de programmation impératif et généraliste. Il propose un éventail de types
entiers et flottants conçus pour pouvoir correspondre directement aux types supportés par le
processeur. Il fait en outre un usage intensif des calculs d'adresse mémoire avec la notion de
pointeur. Il a une notion de type composé, mais ne propose aucune opération qui traite
directement des objets de plus haut niveau (fichier informatique, chaîne de caractères,
liste…). Ces types plus évolués doivent être traités en manipulant des pointeurs et des types
composés. De même, le langage ne propose pas en standard la gestion de la programmation
orientée objet, ni de système de gestion d'exceptions. Il existe des fonctions standards pour
gérer les entrées-sorties et les chaînes de caractères, mais contrairement à d'autres langages,
aucun opérateur spécifique pour améliorer l'ergonomie. Ceci rend aisé le remplacement des
fonctions standards par des fonctions spécifiquement conçues pour un programme donné.
Ces caractéristiques en font un langage privilégié quand on cherche à maîtriser les
ressources utilisées, le langage machine et les données binaires générées par les compilateurs
étant relativement prévisibles. Ce langage est donc extrêmement utilisé dans des domaines
comme la programmation embarquée sur microcontrôleurs, les calculs intensifs, l'écriture de
systèmes d'exploitation et les modules où la rapidité de traitement est importante. Il constitue
une bonne alternative au langage d'assemblage dans ces domaines, avec les avantages d'une
syntaxe plus expressive et de la portabilité du code source. Le langage C a été inventé pour
écrire le système d'exploitation UNIX, et reste utilisé pour la programmation système. Ainsi
le noyau de grands systèmes d'exploitation comme Windows et Linux sont développés en
grande partie en C.
55
Chapitre III
Les compilateurs C possèdent les taux d'expansion les plus faibles de tous les langages
évolués (rapport entre la quantité de code machine généré par le compilateur et la quantité de
code machine généré par l'assembleur et ce pour une même application). C’est pour cette
raison que le langage C est devenu l’outil incontournable dans tout développement. Il se
présente comme l’outil le plus proche de la machine par rapport aux autres langages, tout en
étant proche de l’opérateur.
En effet, partant d’un programme source écrit en assembleur, Celui-ci va convertir un
fichier source en un fichier exécutable contenant le code numérique binaire de chaque
instruction, et donc compréhensible par le microprocesseur. L'assembleur ne fait que traduire
le fichier source du langage humain vers le langage binaire. Une fois traduit en instructions
machine 16 bits, ce code deviendra un code binaire (0 et 1). Le compilateur, par contre
analyse un fichier source écrit en un langage dit évolué et transforme chaque instruction
propre à ce langage en une suite d'instructions machines. On peut dire qu’il convertit le fichier
source en programme assembleur, et ce n'est qu'ensuite qu'il génère le fichier exécutable
contenant les codes binaires. En fait, le compilateur effectue une étape de plus que
l'assembleur, c'est la transformation "fichier source écrit en langage évolué" vers "un fichier
source écrit en assembleur". C'est justement l'inconvénient du compilateur : la transformation
n'est pas toujours aussi bonne que celle que l’on aurait écrite directement en assembleur. Ceci
fait que les programmes assembleurs sont toujours plus performants que les programmes
écrits avec des langages évolués.
3. LANGAGE ASSEMBLEUR ET LANGAGE MACHINE
Le langage machine, ou code machine, est la suite de bits qui est interprétée par le
processeur d'un ordinateur exécutant un programme informatique. C'est le langage natif d'un
processeur, c'est-à-dire le seul qu'il puisse traiter. Il est composé d'instructions et de données à
traiter codées en binaire. Le processeur d'un ordinateur ne peut donc exécuter que les
instructions écrites en langage machine, qui est d’ailleurs propre à chaque famille de
processeurs. Etant donné sa forme complexe (suite de bits), un programmeur ne peut alors
développer ses programmes en utilisant un tel langage. Il est donc contraint d’utiliser des
langages qui puissent exprimer des instructions à base code autre que le binaire.
Les langages assembleurs permettent de développer des programmes en utilisant ce que
l’on appelle du code mnémonique (utilisation de symboles pour décrire les instructions d’un
programme). Ce code mnémonique permet de développer des programmes qui sont à la fois
56
Chapitre III
performants (proches du processeur) et compréhensibles par le programmeur, alors que
les programmes exécutables (binaires) sont totalement illisibles même pour un informaticien.
Cela veut dire qu'une erreur de codage peut tout à fait faire planter une machine. L'avantage
du langage assembleur, reste tout de même le fait de pouvoir gérer jusqu'au moindre octet de
mémoire et de toujours savoir quel code est exécuté par le microprocesseur à un instant
donné.
3.1. Intérêts de la programmation en assembleur
Etant donné qu’un langage assembleur est fortement lié au processeur, ceci permet de
développer des programmes performants. Un programme développé en assembleur est
exécuté bien plus rapidement que s’il avait été développé en langage évolué (en langages C ou
JAVA par exemple). Cet aspect de performance est très important pour tous les programmes
où le temps d’exécution est très important. En fait, étant donné que nous programmons
directement le processeur, nous pouvons nous même effectuer des optimisations sur notre
code, suivant les cas. Cette optimisation est impossible à obtenir avec un compilateur.
De plus, un programme développé en assembleur occupe aussi beaucoup moins d’espace en
mémoire que s’il avait été développé en langage évolué. D’ailleurs, certains programmes ou
fonctions ne peuvent être programmés qu’en assembleur : c’est le cas des commandes fines
de circuits, de périphériques, d’E/S, de drivers, de la programmation de cartes à puces, etc.
Comme c’est souligné auparavant, l’apprentissage de l’assembleur est une manière
d’apprendre le fonctionnement de la machine au niveau physique. L’usage d’un tel langage
conduit souvent à des programmes plus longs et plus fastidieux à écrire qu’en langage évolué,
plus difficile aussi à modifier et à corriger, surtout s’ils ne sont pas écrits correctement et avec
rigueur.
3.2. Particularités du langage assembleur
Chaque famille de processeurs utilise un jeu d'instructions différent. Ainsi, le langage
assembleur, représentation exacte du langage machine, est spécifique à chaque architecture de
processeur. De plus, plusieurs groupes de mnémoniques ou de syntaxes de langage
assembleur peuvent exister pour un seul ensemble d'instructions, créant ainsi des macroinstructions.
Parmi les jeux d'instructions existants, les fameux jeux spécialisés de processeurs DSPs.
Ceux-ci sont similaires aux jeux d'instructions RISC (Reduced Instruction Specific Circuit),
avec peu d'instructions, toutes spécialisées pour faire du traitement du signal. A titre
57
Chapitre III
d’exemple, des instructions permettant de faire répéter rapidement une suite d'instructions
(création de boucles), ou des instructions capables de traiter plusieurs données en parallèle.
3.3. Usage du langage assembleur
Des débats constructifs ont toujours porté sur l'utilité du langage assembleur. Dans
beaucoup de cas, des compilateurs-optimiseurs peuvent transformer du langage de haut
niveau en un code qui tourne aussi efficacement qu'un code assembleur écrit à la main par un
très bon programmeur, tout en restant beaucoup plus facile, rapide (et donc moins coûteux) à
écrire, à lire et à maintenir.
Les compilateurs ayant entre-temps fait d'énormes progrès, il est donc évident que
l'immense majorité des programmes soient maintenant écrits en langages de haut niveau pour
des raisons économiques. En effet, le surcoût de programmation l'emporte très largement sur
le gain résultant de l'amélioration espérée des performances.
Cependant, il reste quelques cas très spécifiques où l'utilisation de l'assembleur se justifie
encore :
-
quelques calculs complexes écrits directement en assembleur, en particulier sur des
machines massivement parallèles, seront plus rapides, les compilateurs n'étant pas
assez évolués pour tirer parti des spécificités de ces architectures ;
-
certaines routines (drivers) sont parfois plus simples à écrire en langage de bas
niveau ;
-
des tâches très dépendantes du système, exécutées dans l'espace mémoire du système
d'exploitation sont parfois difficiles, voire impossibles à écrire dans un langage de
haut niveau ;
-
des artifices de calcul exploités directement sous assembleur, pouvant contourner
l’usage de certains circuits électroniques du processeur.
Toutefois, l'évolution du matériel fait que les composants de ces systèmes deviennent de
plus en plus puissants à un coût et à une consommation électrique constante. Toutefois,
l'investissement dans une programmation « tout assembleur » beaucoup plus coûteuse en
heures de travail, devient alors un non-sens en termes d'efforts. Typiquement, la
programmation en assembleur est beaucoup plus longue, plus délicate (car le programmeur
doit prendre en compte tous les micro-détails du développement dont il s'abstient en langage
58
Chapitre III
évolué) et donc considérablement plus coûteuse que la programmation en langage de haut
niveau. Il ne faut donc la réserver qu'aux situations pour lesquelles on ne peut pas faire
autrement.
3.4. Conditions d'utilisation du langage assembleur
L'utilisation du langage assembleur se doit d'être justifiée par des arguments de poids, tant
l'investissement intellectuel requis pour sa parfaite connaissance est important. La conception
de logiciels, quel que soit le domaine de l'application envisagée, se traduit en particulier, lors
de la réalisation informatique du produit, par l'écriture d'algorithme.
La réalisation d'applications, que ce soit totalement ou le plus souvent partiellement, à
l'aide du langage assembleur, requiert des connaissances multiples et variées, ainsi que la
mise en œuvre d'un environnement logiciel, sans lequel tout développement de l'application
devient très vite impossible.
Les connaissances requises concernent en particulier les points suivants :
– maîtrise parfaite de la structure interne du microprocesseur,
– maîtrise et connaissance complète du fonctionnement du microprocesseur, et en particulier
de ses modes d'adressage,
– connaissance du jeu complet d'instructions lié au microprocesseur,
– connaissance de l'environnement hardware du microprocesseur, des fonctionnalités offertes
par le système d'exploitation ainsi que les logiciels de développement.
4. PERFORMANCES D’APPLICATIONS IMPLANTEES SUR PROCESSEUR
La consommation électrique représente un sujet de préoccupation majeur pour les
concepteurs de circuits. Pour réduire l’énergie dissipée dans une architecture donnée,
plusieurs voies s’offrent au concepteur, depuis le développement de transistors basseconsommation jusqu’à l’optimisation de l’application.
4.1. Métriques d’évaluation des performances
La performance est le critère de base pour la conception, la sélection et l’utilisation des
systèmes intégrés. Sans doute, les objectifs importants de conception, sont de fixer les
demandes de performance, de pouvoir comparer différentes alternatives et de choisir celui qui
respecte le mieux ces demandes. Il est naturel d’associer une phase d’évaluation des
performances à l’étape de conception pour choisir la réalisation optimale.
59
Chapitre III
Les principales métriques utilisées pour l’évaluation des performances des programmes
implantés sont :

le temps d’exécution, qui est le temps consacré à l’exécution d’un programme sur un
processeur particulier ;

l’énergie consommée par un processeur pendant l’exécution d’un programme ;

la capacité de mémoire utilisée par l’application.
4.2. Estimation d’énergie au niveau instruction
Au niveau système, des modèles déduits de mesures et d’un profilage en consommation
d’une séquence d’instructions existent pour les processeurs embarqués. Ces modèles sont
précis, permettent une qualification rapide des techniques systèmes de gestion de la
consommation, mais sont spécifiques à l’architecture du circuit considéré.
Chaque modèle utilise une méthodologie associant chaque instruction du processeur à un
coût d’énergie fixe normalement nommé le coût de base de l’instruction. Ce coût est dû au
traitement de base nécessaire pour exécuter l’instruction en question. Le coût de base d’une
instruction peut varier en fonction de différents opérandes et différentes valeurs d’adresse.
D’une manière générale, nous pouvons affirmer que l’énergie totale consommée par
un programme, est la somme de l’énergie consommée à chaque cycle.
ntotal
Etotal 
E
cycle
(t )
n 0
(3.1)
Toutefois, l’énergie consommée par cycle peut être définie de différentes manières. Ceci
nous amène à une diversité de techniques d’estimation.
4.2.1. Instruction sans transition
Cette technique d’estimation est très simple. L’énergie par cycle Ecycle est seulement basée
sur le coût de base de l’instruction CBi, ceci étant l’énergie consommée par le processeur lors
de l’exécution de l’instruction. Une addition linéaire du coût de base de chaque instruction
exécutée donne l’estimation de l’énergie consommée.
Ecycle  CBi
(3.2)
Ainsi,
ntotal
E total 
 CB (n)
i
n 0
60
(3.3)
Chapitre III
Cette technique a déjà été utilisée par plusieurs projets de recherches [5, 47], entre autres.
4.2.2. Instruction avec transition unique
Cette deuxième technique d’estimation décompose l’énergie par cycle en deux parties.
La première partie est le coût de base de l’instruction CBi. La deuxième partie est le coût de
transition, ou bien le coût inter-instructions CIi,j où i est l’instruction exécutée et j est
l’instruction qui la suit, ceci correspond à l’énergie consommée lors de la transition entre
deux instructions différentes exécutées consécutivement par le processeur. Bref, l’énergie
par cycle Ecycle est le coût de base de l’instruction CBi plus le coût inter-instructions CIi,j.
La grande difficulté d’une telle approche est la modélisation du coût inter-instructions.
Dû à la grande quantité d’instructions dans le jeu d’instruction d’un processeur, la quantité
de couples d’instructions
possibles
est
très
grande. Pour
un
processeur
avec
n
instructions, nous avons n2 coûts inter-instructions possibles. Ainsi, la technique, instruction
avec transition unique, fait l’approximation suivante :
j, CI i , j  CI i , NOP
(3.4)
Quelle que soit l’instruction j, le coût inter-instructions CIi,j sera arrondi par le coût
inter-instructions. Donc, pour un processeur avec n instructions dans son jeu d’instruction,
nous aurions seulement n coûts inter-instructions possibles, au lieu de n2. Par conséquent,
l’énergie par cycle Ecycle est le coût de base de l’instruction CBi, plus le coût inter-instructions
entre l’instruction i et j l’instruction NOP, CIi,NOP.
Etotal  CBi  CI i , NOP
(3.5)
Finalement,
n
E total   ntotal
CB i ( n )  CI i , NOP ( n )
0
(3.6)
Cette technique est aussi connue comme le modèle NOP [49]. En effet, cette approche se
base sur l’hypothèse que l’effet inter-instructions est principalement dû au changement des
instructions et non aux instructions qui y sont impliquées. Cette hypothèse nous mène vers
une modélisation de la consommation de puissance au niveau instruction qui ne dépend
pas de toutes les paires d’instructions du processeur. Les effets inter-instructions sont pris
en compte, sans toutefois trop augmenter la complexité du modèle.
61
Chapitre III
4.2.3. Instruction avec transition
La troisième et dernière technique d’estimation que nous allons présenter dans ce
travail est l’instruction avec transition. Cette dernière est très semblable à la technique
précédente. L’énergie par cycle est, encore une fois, décomposée en deux parties : la première
partie est le coût de base de l’instruction CBi, et la deuxième, est le coût interinstructions CIi,j. Toutefois, cette technique ne fait aucune approximation du coût interinstructions. Alors, l’énergie par cycle Ecycle est le coût de base de l’instruction plus le
coût inter-instructions.
E cycle  CBi  CI i , j
(3.7)
Ceci implique que,
n
E total   ntotal
CB i ( n )  CI i , j ( n )
0
(3.8)
Sans aucune approximation, tous les coûts de transition de l’ensemble des instructions du
processeur doivent être calculés. Ceci est une tâche très coûteuse en temps où il y a un très
grand risque d’erreurs, c’est pourquoi un processus de modélisation automatique s’avère
absolument indispensable [64].
5. PERFORMANCES DES ALGORITHMES IMPLANTES SUR DSPS
Architectures internes et jeux d'instructions sont souvent très différents d'une famille de
DSPs à une autre. La comparaison de valeurs d’évaluation de performances fournies par des
fabricants de DSPs est encore le plus souvent délicate. Aussi la méthode utilisée consiste à
programmer dans ces DSPs, un ensemble de fonctions tests utilisées dans les applications de
traitement numérique du signal, telles que FIR (Finite Impulse Responce), FFT, détection et
compression MPEG, distance euclidienne, connue des applications de traitements d'images et
systèmes de communication [65].
Bien que les DSPs puissent être programmés dans un langage de haut niveau tel que le C,
la programmation en assembleur s'impose logiquement pour obtenir un comparatif réel.
Comme les programmes traitant les signaux sont courts et qu'en assembleur le code est
optimisé, le résultat prend donc le minimum de place. De plus, les outils de développement
générant du code assembleur pour DSP à partir d'une modélisation data flow de l'application
(DSP Station de Mentor Graphics ou SPW de Cadence) ne permettent pas encore de fournir
un code optimisé [66].
62
Chapitre III
Le tableau 3.1 situe les principaux avantages et inconvénients de la programmation en
langage C et en langage assembleur dans les processeurs DSPs.
Tableau.3.1 : Comparaison entre programmation en assembleur et langage C sur DSPs.
AVANT
AGES
INCONVE
NIENTS
Assembleur
- Permet d’optimiser au
maximum un programme en
temps d’exécution
- Spécifique au processeur
- long et pénible à développer
- nécessite de disposer ou
d’écrire des sous programmes
ou macros pour travailler sur
des opérandes au delà de la
taille de base ou en virgule
flottante.
Langage C
- grande facilité et souplesse de programmation.
- très nombreux types d’opérandes (entiers, nombres en
virgules fixe, en virgule flottante, structures, tableaux, chaines
de caractères…)
- grand nombre de fonctions mathématiques disponibles.
- gestion très simple des interruptions.
- portabilité vers d’autres processeurs (mis à part les routines
travaillant sur les périphériques internes)
- malgré les performances des compilateurs pour
microprocesseurs actuels, le code n’est pas toujours optimisé
en vitesse de traitement.
- taille de code et temps d’exécution évidemment très
augmentés si on travaille systématiquement en virgule flottante
sur des microprocesseurs ne possédant pas d’unité
arithmétique virgule flottante, et le cas de la plupart d’entre
eux.
Nous présentons dans ce qui suit et à titre comparatif les performances en matière de
consommation d’énergie et de temps d’exécution, de certains DSPs à virgule fixe se trouvant
sur le marché lors de l’exécution d’un programme de test (benchmark) écrit en assembleur. Il
s’agit d’un algorithme permettant le traitement de données réelles par bloc d’un filtre à
réponse impulsionnelle finie (FIR filter).
Les données présentées dans le tableau 3.2 reflètent les résultats de benchmarks de la
société BDTI concernant trois processeurs DSPs à virgule fixe 16 bits des fabricants Texas
Instruments et Lucent Technologies [67]. Les DSPs utilisés lors de ce test sont comme suit :
1. Le TMS320UC5402 : un DSP de la famille TMS320C54x de Texas Instruments
fonctionnant à une fréquence de 80 MHz et une tension d’alimentation de 1.8V.
2. Le TMS320C6202 : un DSP plus performant appartenant à la famille TMS320C62xx
de Texas Instruments qui fonctionne à une fréquence de 250MHz et une tension
d’alimentation de 1.8V.
3. DSP16210 : un DSP de la famille DSP16xxx de Lucent Technologies qui fonctionne à
une fréquence de 120MHz (8.3ns) et une tension d’alimentation de 3.3V
Tableau.3.2 : Performances des trois DSPs testés sur le benchmark FIR (Bloc Données réelles).
Performance
DSPs
C5402
C6202
DSP16210
Nombre de cycles
Temps d’exécution
(µs)
8.55
1.33
6.01
684
334
719
63
Energie consommée
(W.µs)
0.89
3.40
1.92
Chapitre III
La figure 3.1 montre ces mêmes résultats sous forme graphique.
9
8
7
6
5
4
3
2
1
0
Temps d'éxecution (µs)
Enengie consommée(W.µs)
'320UC5402
'320C6202
DSP16210
Fig.3.1 : Temps d’exécution et consommation d’énergie des trois DSPs testés sur
le benchmark FIR (Bloc Données réelles).
D’après la figure 3.1, on voit plutôt une différence des performances entre les DSPs testés sur
le plan technologique et non pas sur le plan rapport entre consommation d’énergie et temps
d’exécution. Cet aspect devrait être vérifié dans ce qui suit.
Les données présentées maintenant dans le tableau 3.3 reflètent les résultats du benchmark
permettant le traitement de données complexes par bloc de la société BDTI avec les mêmes
DSPs utilisés auparavant [68].
Tableau 3.3 : Performances des trois DSPs testés sur le benchmark FIR (Bloc données complexes).
Performance
DSP
C5402
C6202
DSP16210
Nombre de cycles
Temps d’exécution (µs)
2922
1294
1721
36.52
5.18
14.35
La figure 3.2 affiche ces mêmes résultats sous forme graphique.
64
Energie consommée
(W.µs)
3.80
12.55
3.74
Chapitre III
40
35
30
25
20
15
10
5
0
'320UC5402
'320C6202
DSP16210
le benchmark FIR (Bloc Données complexes).
D’après la figure 3.2, on voit clairement que la différence de technologie sur le plan
performances entre les DSPs est encore maintenue. Sur le plan rapport entre consommation
d’énergie et temps d’exécution, cet aspect est clairement précisé et vérifié ; on peut remarquer
d’ailleurs que l’énergie et le temps d’exécution sont liés les deux à la fois et de façon
proportionnelle à la complexité du programme exécuté. Plus un programme, est complexe et
plus le temps d’exécution et l’énergie dissipée sont importants.
6. CONCLUSION
Ce chapitre a fait l’objet d’une présentation des langages de bas et haut niveau utilisés dans
la programmation des processeurs. Un accent particulier a été mis sur les langages assembleur
en tant qu’outil de développement pour microprocesseurs embarqués. Les méthodes et outils
d’évaluation des performances en matière de consommation d’énergie des programmes
implantés sur processeurs, ont été présentés. Des exemples de benchmarks testés sur DSPs à
virgule fixe dans un but d’évaluation d’énergie et de temps d’exécution, sont par conséquent
montrés.
Le chapitre suivant consacré à la simulation, est dédié à une application sur processeur DSP
à virgule fixe, en l’occurrence l’ADSP2181. L’aspect évaluation et optimisation d’énergie
dans un programme FFT s’exécutant sur ce processeur est attendu.
65
Chapitre IV
CHAPITRE IV
APPLICATION SUR DSP A VIRGULE FIXE
1. INTRODUCTION
Ce chapitre fait l’objet d’une étude en simulation portant sur l’évaluation des
performances en matière de temps d’exécution et de consommation d’énergie du processeur
DSP à virgule fixe, l’ADSP2181. L’application en assembleur, porte sur l’exécution avec et
sans fonction de « bit reverse » d’un algorithme FFT en base 2 à entrelacement temporel.
2. EXEMPLE DE TEST DE PERFORMANCE
Comme souligné auparavant, les DSPs à virgule fixe sont des processeurs rapides et
optimisés en termes de consommation d’énergie. Un autre programme benchmark de BDTI
est utilisé dans ce qui suit, pour illustrer encore une fois les performances des DSPs à virgule
fixe en matière de temps d’exécution et de consommation d’énergie dans le calcul des
algorithmes de type FFT- radix2. Faut-il rappeler que cet algorithme représente l’objet de
notre application dans ce travail, et ce afin d’optimiser son fonctionnement dans un but
d’économie d’énergie.
Dans ce qui suit, on montre les performances du benchmark montrant l’algorithme FFT à
entrelacement temporel (DIT) s’exécuter sur des DSPs à virgule fixe, à partir de 256 données
d’entrée complexes [68].
Tableau.4.1 : Performances des trois DSPs testés sur le benchmark FFT-DIT (256 points complexes).
Performance
DSP
C5402
C6202
DSP16210
Nombre de cycles
Temps d’exécution (µs)
13233
4225
8485
165.41
16.90
70.76
Energie e consommée
(W.µs)
17.22
41.91
19.81
La figure 4.1 montre ces mêmes résultats sous forme d’histogramme.
66
Chapitre IV
180
160
140
120
100
80
60
40
20
0
'320UC5402
'320C6202
DSP16210
le benchmark FFT-DIT (256 points complexes).
Il apparait clairement d’après les résultats affichés que la technologie a un rôle primordial en
matière des performances d’un DSP. Dans l’exécution de cet algorithme, le DSP de la famille
TMSC62xx parait le plus performant relativement à ses concurrents en matière de facteur
« temps d’exécution x énergie dissipée».
3. IMPLEMENTATION
L’implémentation d’algorithmes de traitement de signal en informatique ne se fait
malheureusement pas sur l’espace infini des réels ℝ, ce qui nécessiterait un temps de calcul
infini. En revanche, la théorie du traitement du signal numérique permet d’adapter par
exemple la transformée de Fourier sur un nombre fini d’échantillons donnant lieu à
l’algorithme de transformée de Fourier discrète (TFD).
Soit un signal numérique x(n) de N échantillons, la définition mathématique de sa
transformée de Fourier discrète est:
N 1
X ( k )  n 0 x ( n).e
 j 2
nk
N
,
k  0,1,  , N - 1
(4.1)
Et son inverse :
nk
j 2
1 N 1
x(n)  n 0 X (k ).e N ,
N
n  0,1,, N - 1
(4.2)
Avec : N est la longueur de la TFD.
Les algorithmes FFT calculent la TFD plus rapidement et plus efficacement et réduisent
significativement les tailles des puces où seront implémentés tels que les DSPs et les
FPGAs. L'exécution de ses algorithmes en technologie d'intégration à très grande échelle
67
Chapitre IV
représente un problème non trivial quand il s'agit de respecter les contraintes de
l'application en termes de consommation de puissance, coût d'implémentation et vitesse de
calcul.
Il existe, à ce jour, un grand nombre d’algorithmes FFT, nécessitant chacun d’entre eux le
respect d’hypothèses permettant d’exploiter les propriétés correspondantes et d’obtenir le
maximum de performances. Ainsi un algorithme peut être efficace dans une situation et
inutile dans d’autres. Il est donc indispensable de bien choisir son algorithme avant de se
lancer dans l’implémentation et l’optimisation de ce dernier.
L'algorithme FFT à base 2 (radix-2) est un algorithme possédant la structure papillon la
plus simple pour le calcul d’une TFD. En entrée de l’algorithme, l’ordre des données n’est pas
l’ordre naturel du signal, mais ce dernier est obtenu par «bit-reversing » de la position de
chaque échantillon. Pour le calcul, il est impératif par exemple dans le cas d’une FFT à
entrelacement temporel de réorganiser ces données d’entrée selon le code binaire réfléchi.
Cette tâche est souvent fastidieuse et consomme un temps de calcul relativement important au
détriment du calcul proprement dit de la FFT. Certains DSPs, en l’occurrence l’ADSP2181,
qui sont plus efficaces dans l’exécution de tels algorithmes, sont dotés de la fonction « bit
reverse » permettant de provoquer une inversion des bits d’adresses lors d’un simple transfert
des données ; ce qui allègera le calcul et permettra une exécution plus rapide.
Dans ce qui suit, nous allons nous intéresser à l’implémentation de l’algorithme FFT-DIT
radix-2 sur simulateur ADSP2181, le VISUAL DSP++. L’objectif de notre travail est
d’implémenter cet algorithme de deux manières différentes. La première, est celle du
fabricant, où le programme assembleur est extrait du manuel « Application Handbook » et qui
utilise la fonction « bit reverse » comme technique incontournable dans le désembrouillage
des données en entrée de la FFT. La seconde est une technique que nous proposons, utilisant
le même code fourni par le fabricant, sauf que celle-ci contourne l’usage de la fonction dite
« bit reverse ». Notre but est d’arriver au même résultat que celui fourni par le fabricant, mais
avec un temps d’exécution plus faible et une énergie encore plus faible. Une évaluation des
performances entre les deux techniques en matière de temps d’exécution et de consommation
d’énergie, est prévue à cet effet.
3.1. Mise en œuvre de l’algorithme FFT avec la fonction bit reverse
Comme nous l’avons souligné précédemment, l’ADSP2181 est un processeur à virgule fixe
qui dispose d’un format fixe (1.15). Les données et coefficients d’entrée d’un signal de N
68
Chapitre IV
échantillons sont générés et convertis en format virgule fixe par le simulateur MATLAB avant
tout transfert vers les mémoires externes du DSP (figure 4.2).
Génération des
données d’entrée et
des coefficients en
format fixe sur
MATLAB
Mémoire de
programme pour les
coefficients
Cœur DSP
‘Calcul de
FFT’
Mémoire de données
pour les données
d’entrée
Fig.4.2 : Schéma de transfert des coefficients FFT et des données vers le DSP.
Le programme assembleur FFT-DIT radix-2 avec fonction « bit-reverse » est composé des
trois parties suivantes :
a- Partie initialisation: qui fait la déclaration et l’initialisation des buffers de données et
des variables.
b- Partie « inversion des bits » : utilisée pour organiser les données d’entrée selon le code
binaire réfléchi.
c- Partie calcul FFT : qui effectue le calcul proprement dit de la FFT-DIT radix-2.
La figure 4.3 représente l’organigramme de déroulement d’un algorithme FFT radix-2 à
entrelacement temporel
69
Chapitre IV
Début
Initialisation
Les données
d’entée en mode
bit-reverse
Préparation de l’étage
Suivant (stage)
Préparation du groupe
Suivant
Préparation du papillon
Suivant
Calcul des termes du
papillon
Fin des papillons
Oui
Non
Fin des groupes
Oui
Non
Fin des étages
Oui
Non
Composantes spectrales
Re(i), Img(i)
Fin
Fig.4.3 : Organigramme de calcul de l’algorithme FFT-DIT radix2.
70
Chapitre IV
3.2. Mise en œuvre de l’algorithme FFT sans la fonction bit reverse
La technique que nous proposons basée essentiellement sur le contournement de l’usage de
la fonction « bit reverse », suggère qu’un vecteur d’indices inversés des données d’entrée soit
prédéfini en mémoire programme du DSP avant calcul FFT. Ces indices devront être préparés
sous PC au même titre que les coefficients FFT puis chargés dans la mémoire programme du
DSP avant lancement du calcul (figure 4.4).
Calcul des données
d’entrée, des coefficients
et des indices en mode
bit-reverse en format fixe
sur MATLAB
Mémoire de
programme pour les
coefficients et les
indices des entrées
Cœur DSP
‘Calcul de
FFT
modifiée’
Mémoire de données
pour les données
d’entrée
Fig.4.4: Schéma de transfert des coefficients FFT, des indices et des données vers le DSP.
Comme exemple, nous présentons dans le tableau 4.2 les indices des données d’entrée
dans l’ordre naturel et en mode bit-reverse pour N=8 échantillons.
Tableau.4.2 : Indices des données d’entrée avec ordre naturel et mode bit reverse pour N=8.
Les données
Les indices des entrées
Les indices des entrées
d’entrée
en mode naturel
en mode bit reverse
x(0)
0
0
x(1)
1
4
x(2)
2
2
x(3)
3
6
x(4)
4
1
x(5)
5
5
x(6)
6
3
x(7)
7
7
La réorganisation des données d’entrée selon le code binaire réfléchi utilisant la technique
proposée, est montrée dans la figure 4.5.
71
Chapitre IV
Indices des
entrées
pré-calculés
Mémoire de
programme
PM
Mémoire de
données DM
0
x(0)
x(1)
x(2)
x(3)
x(4)
x(5)
x(6)
x(7)
4
2
6
1
5
3
7
Les données
d’entrée après
réorganisation
Les
données
d’entrée
(ordre naturel)
x(0)
x(4)
x(2)
x(6)
x(1)
x(5)
x(3)
x(7)
Fig.4.5 : Réorganisation des données d’entrée par la technique proposée.
Une fois que la lecture des données d’entrée est effectuée selon les indices pré-calculés en
mémoire programme du DSP, le calcul FFT pourra être lancé et exécuté exactement de la
même manière comme réalisé dans l’algorithme utilisant la fonction « bit reverse ».
4. SIMULATION
4.1. Evaluation du temps d’exécution
Dans cette partie nous présentons les résultats de simulation obtenus à partir du simulateur
VISUAL DSP++ reflétant l’exécution de l’algorithme FFT par les deux techniques. Le
déroulement de l’algorithme s’effectue sur des longueurs d’échantillons N d’un signal
sinusoïdal variant de 8 à 2048.
Le tableau 4.3 affiche le nombre de cycles et le temps d’exécution correspondant pour
chacune des valeurs de N pour un calcul FFT avec fonction « bit reverse ».
72
Chapitre IV
Tableau.4.3 : Temps d’exécution de calcul FFT radix-2 avec fonction « bit-reverse ».
Longueur de la FFT (N)
Nombre de cycles
Temps d’exécution (ms)
8
216
0.0054
16
497
0.0124
64
2555
0.0638
128
5740
0.1435
256
12797
0.3199
512
28302
0.7075
1024
62111
1.5527
2048
135236
3.3809
Le tableau 4.4 affiche plutôt le nombre de cycles et le temps d’exécution correspondant
pour chacune des valeurs de N pour un calcul FFT sans fonction « bit reverse ».
Tableau.4.4 : Temps d’exécution de calcul FFT radix-2 sans fonction « bit-reverse ».
Longueur de la FFT (N)
Nombre de cycles
Temps d’exécution (ms)
8
204
0.0051
16
481
0.0120
64
2515
0.0628
128
5668
0.1417
256
12661
0.3165
512
28038
0.7009
1024
61591
1.5397
2048
134036
3.3509
D’après les résultats montrés dans les tableaux 4.3 et 4.4, on remarque que la technique
proposée qui contourne l’usage de la fonction « bit reverse » est relativement plus rapide que
celle qui utilise cette fonction d’inversion, soit 1200 cycles d’horloge de moins pour N=2048
échantillons.
La figure 4.6 montre un histogramme affichant le nombre de cycles consommés lors de
l’exécution de l’algorithme par les deux techniques, pour des longueurs N=512, 1024 et
2048.
73
Chapitre IV
160000
140000
120000
Nombre de cycles
(avec fonction bit
reverse)
100000
80000
Nombre de cycles (sans
fonction bit reverse)
60000
40000
20000
0
N=512
N=1024
N=2048
Fig.4.6 : Nombre de cycles consommés en fonction de N.
D’après l’histogramme de la figure 4.6, on voit clairement que la technique proposée
optimise mieux le temps de calcul, soit 264 cycles d’horloge de moins pour N= 512, 520
cycles pour N= 1024 et 1200 cycles pour N=2048. Cette réduction en nombre de cycles
d’horloge doit avoir un impact certain sur la consommation du DSP en énergie. Un
programme moins complexe, qui nécessite moins de cycles, consomme automatiquement
moins d’énergie. Ce constat a été vérifié dans le chapitre précédent et va être confirmé dans ce
qui suit.
4.2. Evaluation énergétique
Dans cette section, nous nous proposons pour les deux techniques étudiées d’estimer
l’énergie consommée par le DSP lors de l’exécution de l’algorithme FFT pour différentes
valeurs de N. En général, l’évaluation de la consommation énergétique d’un programme
conduit dans le cas le plus approximatif à supposer qu’elle est égale à la somme des énergies
consommées de façon indépendante par chacune des instructions composant le programme.
On considère dans ce cas de figure que l’énergie consommée par les différentes instructions
de l’ADSP2181 s’exécutant en un seul cycle d’horloge, est constante. Alors, l’énergie totale
consommée lors d’exécution d’un programme donné, est égale au produit de l’énergie
consommée lors d’un seul cycle d’horloge par le nombre de total de cycles.
A noter toutefois que l’évaluation de la consommation d’énergie pour un seul cycle
d’horloge est calculée sur la base du produit de la puissance du processeur avec le temps
d’exécution correspondant à un seul cycle d’horloge, soit 25ns pour l’ADSP2181. La
puissance de celui-ci tournant à 33 MHz et alimenté à 5 V est estimée à 109.5 mW, sachant
que la puissance fournie par le constructeur pour la famille ADSP218x pour 80 MHz à 2.5 V
est de 54 mW [69].
74
Chapitre IV
La consommation d’énergie en fonction de N, évaluée pour le processeur ADSP2181 dans
l’exécution des algorithmes FFTs avec et sans le « bit reverse », est représentée dans le
tableau 4.5.
Tableau.4 .5: Energie consommée en fonction de N par l’ADSP2181 (avec et sans ‘bit reverse’).
Energie consommée
Energie consommée
Longueur N
(avec fonction bit reverse)
(sans fonction bit reverse)
Gain d’énergie
FFT
E1
E2
E1 – E2
(W.µs)
(W.µs)
(W.µs)
8
0.59
0.56
0.03
16
1.36
1.31
0.05
64
6.98
6.88
0.10
128
15.71
15.52
0.19
256
35.03
34.66
0.37
512
77.47
76.75
0.72
1024
170.02
168.60
1.42
2048
369.39
366.12
3.27
La figure 4.7 montre un histogramme affichant la consommation d’énergie estimée de
l’ADSP2181 lors de l’exécution de l’algorithme FFT avec et sans « bit reverse » en fonction
des valeurs de N= 512, 1024 et 2048.
400
350
Enengie
consommée (avec
en W.µs
300
250
200
Enengie
consommée (sans
en W.µs
150
100
50
0
N=512
N=1024
N=204_
Fig.4.7 : Consommation d’énergie de la FFT avec et sans la fonction ‘bit reverse’.
D’après l’histogramme de la figure 4.7, on voit clairement que la technique proposée
(FFT sans fonction bit reverse) réduit plus la consommation en énergie, soit 1.42 W.s de
moins pour N=1024 et 3.27 W.s de moins pour N=2048. En plus de cette réduction, il faut
compter le manque à gagner sur le plan hardware en éliminant tout un circuit électronique de
l’architecture du processeur qui prend en charge cette fonction d’inversion. Dans ce cas précis
75
Chapitre IV
d’application, on remarque que l’optimisation du temps de calcul comme étant une
conséquence de la réduction de complexité de l’algorithme FFT, a conduit en plus à une
optimisation de l’architecture matérielle du processeur. Il faut dire dans ce cas là, qu’il n’y a
pas que la technologie qui peut réduire la consommation en énergie des systèmes embarqués,
mais les techniques de programmation peuvent aussi le faire dans certaines proportions.
5. CONCLUSION
Ce chapitre a fait l’objet d’une étude en simulation portant sur l’évaluation des
performances en matière de temps d’exécution et de consommation d’énergie du processeur
DSP à virgule fixe, l’ADSP2181. L’application en assembleur, a porté sur l’exécution avec et
sans fonction de « bit reverse » d’un algorithme FFT en base 2 à entrelacement temporel. Les
résultats obtenus ont permis de montrer que la technique proposée (FFT sans fonction « bit
reverse ») était la mieux optimisée en termes des performances aussi bien sur le plan temps
d’exécution que de consommation énergétique.
76
Conclusion générale
CONCLUSION GENERALE
Les évolutions technologiques des systèmes embarqués et la complexité croissante des
applications qui les accompagne posent des problèmes de conception qui nécessitent de
nouvelles approches. L’augmentation permanente des besoins en puissance de calcul et la
progression de la technologie repoussent toujours plus les limites de l’intégration des circuits
électroniques et la consommation devient dans ce cas un problème majeur. La dissipation, le
temps de fonctionnement, l’autonomie et les préoccupations environnementales sont autant de
contraintes qui nécessitent la maîtrise de l’efficacité énergétique et celle-ci ne se limite plus
désormais au seul domaine de l’embarqué.
En plus, l’implantation d’applications de traitement numérique du signal dans les systèmes
embarqués, requière l’utilisation de processeurs DSPs à virgule fixe pour satisfaire les
contraintes de coût, de performance et de consommation d’énergie.
La diminution de temps d’exécution des algorithmes de TNS donne une diminution de la
consommation en énergie des processeurs embarqués. Dans ce contexte, les travaux présentés
dans ce mémoire de Magister ont ciblé une étude des techniques d’évaluation et
d’optimisation des performances d’un l’algorithme d’analyse spectrale qui est l’algorithme
FFT. Cet algorithme a été implémenté sur un simulateur de DSP à virgule fixe de la famille
Analog Devices, en l’occurrence, VISUAL DSP++.
Le travail présenté dans ce mémoire a été structuré autour de quatre chapitres essentiels.
Le premier chapitre a servi d’introduction aux systèmes embarqués et la gestion de la
consommation énergétique au niveau des composants. Au début du chapitre, nous avons
présenté les caractéristiques, les différentes architectures et contraintes des systèmes
embarqués. Sont introduits aussi, les principes physiques mis en jeux dans la consommation
électrique des circuits intégrés et les méthodes d’évaluation et d’optimisation de l’énergie
consommée à chaque niveau de conception, en insistant particulièrement sur les composants
intégrés. Enfin, une étude sur les processeurs embarqués ainsi que les méthodes d’estimation
de leur consommation en énergie au niveau système. Le second chapitre a fait l’objet d’une
présentation générale des processeurs DSPs à virgules fixe et flottante. Une description des
principes fondamentaux de ces processeurs a été évoquée. Les critères de choix de ces
architectures de calcul, ainsi que des exemples de DSPs appartenant aux deux familles
indiquées, ont été bien décrits. Conformément aux objectifs dressés, le processeur ADSP2181
77
Conclusion générale
de chez Analog Devices a été retenu pour notre application. Le troisième chapitre a plutôt fait
l’objet d’une présentation des langages de bas et haut niveau utilisés dans la programmation
des processeurs. Un accent particulier a été mis sur les langages assembleur en tant qu’outil
de développement pour microprocesseurs embarqués. Les méthodes et outils d’évaluation des
performances en matière de consommation d’énergie des programmes implantés sur
processeurs, ont été présentés. Des exemples de benchmarks testés sur DSPs à virgule fixe
dans un but d’évaluation d’énergie et de temps d’exécution, sont par conséquent montrés. Le
dernier consistait en une étude en simulation portant sur l’évaluation des performances en
matière de temps d’exécution et de consommation d’énergie du processeur DSP à virgule
fixe, l’ADSP2181. L’application en assembleur, a porté sur l’exécution avec et sans fonction
de « bit reverse » d’un algorithme FFT en base 2 à entrelacement temporel. Les résultats
obtenus ont permis de montrer que la technique proposée (FFT sans fonction « bit reverse »)
était la mieux optimisée en termes des performances aussi bien sur le plan temps d’exécution
que de consommation énergétique.
Sur le plan temps d’exécution, on a vu clairement d’après les résultats obtenus que la
technique proposée (FFT sans fonction « bit reverse ») optimise mieux le temps de calcul, soit
264 cycles d’horloge de moins pour N= 512, 520 cycles pour N= 1024 et 1200 cycles pour
N=2048. Cette réduction en nombre de cycles d’horloge avait un impact direct sur la
consommation du DSP en énergie. On a bien constaté qu’un programme moins complexe, qui
nécessite moins de cycles, consommait moins d’énergie.
Sur le plan énergétique, on a bien vu que la technique proposée (FFT sans fonction bit
reverse) réduisait plus la consommation en énergie, soit 1.42 W.s de moins pour N=1024 et
3.27 W.s de moins pour N=2048. Cette réduction d’énergie étant réalisée sans l’apport de la
fonction « bit reverse », nous laisse imaginer l’élimination de tout un circuit électronique qui
est responsable de cette fonction d’inversion de l’architecture du processeur. En général, il
faut dire à cet effet, qu’il n’y a pas que la technologie qui peut réduire la consommation en
énergie des systèmes embarqués, mais les techniques de programmation peuvent aussi le faire
dans certaines proportions.
78
Références
REFERENCES
[1] S. Balacoo, C. Rommel and J. Weiner, " Searching for the Total Size of the Embedded
Software Engineering Market ", VDC Research Group, Inc, Natick, Massachusetts, USA, 022011.
[2] A. Joshi, "Embedded Systems : Technologies and Markets", Technical report, VDC
Research Group, Inc, Natick, Massachusetts, USA, 04-2009.
[3] D. Menard, " Contribution à la conception de systèmes en virgule fixe", Habilitation à
diriger des recherches, Université de Rennes 1, France, 11-2011.
[4] E. Grâce, "Hiérarchie mémoire reconfigurable faible consommation pour systèmes
enfouis", Thèse doctorat, Université de Rennes 1, France, 10-2010, pp. 9-10.
[5] O. Jingzhao and V. K. Prasanna, "Rapid energy estimation of computations on FPGA
based soft processors", in SOC Conference, 2004, Proceedings of IEEE Inc, 2004.
[6] M. Wendt, M. Grumer, C. Steger, R. Weiss, U. Neffe and A. Muhlberger, "Energy
Consumption Measurement Technique for Automatic Instruction Set Characterization of
Embedded Processors", in Instrumentation and Measurement Technology Conference,
2007, Proceedings of IEEE Inc, 05-2007, pp.1-3.
[7] D. Menard, " Métrologie de compilation d’algorithmes de traitement du signal pour les
processeur en virgule fixe sous contrainte de précision", Thèse doctorat, Université de Rennes
1, France, 12-2002.
[8] Y. Jiang, T. Zhou, Y. Tang and Y. Wang, " Twiddle-factor-based FFT algorithm with
reduced memory access ", International Parallel and Distributed Processing
Symposium/International Parallel Processing Symposium, USA, 2002, Vol.10, pp.1109.
[9] Y. Tang, Y. Wang, J. G. Chung, S. Song and M.Lim, " high-speed assembly FFT
implementation with memory reference reduction on DSP processors ", Electronics, Circuits
and Systems, ICECS 2004, Proceedings of the 11 th IEEE International Conference on , New
York, USA, 2004, pp.547-550.
[10] Y. Wang, Y. F. Tang, Y. Jiang, J. G. Chung, S. S. Song and M. S. Lim, "Novel Memory
Reference Reduction Methods for FFT Implementations on DSP Processors" , Signal
Processing, IEEE Transactions on , 05-2007, vol. 55, pp.2338-2349.
[11] W. Wolf, "Computers as Components Principles of Embedded Computing System
Design", Morgan Kaufman Publishers, Burlington, Massachusetts, USA, 2012, chapter 1.
[12] G. E. Moore, "Progress in digital integrated electronics ", In Electron Devices Meeting,
1975, vol. 21, pp. 11-13.
[13] B. P. Dave, G. Lakshminarayana and N. K. Jha, " COSYN: Hardware–Software CoSynthesis of Heterogeneous Distributed Embedded Systems ", IEEE transactions on very large
scale integration (VLSI) systems, 03-1999, Vol. 7, pp. 92-104.
79
Références
[14] C. B. Stunkel, D. G. Shea, B. Abali, M. M. Denneau, P. H. Hochschild, D. J. Joseph, B.
J. Nathanson, M. Tsao and P.R. Varker, "Architecture and implementation of Vulcan", In 8th
international parallel processing symposium, NY, USA, 04-1994, pp. 268-274.
[15] K. V. Rompaey, D. Verkest, I. Bolsens and H. De Man, "Coware- A Design Environment
for Heterogeneous Hardware/Software Systems", Design Automation for Embedded Systems,
Belgium, 1996.
[16] S. Yoo , J. Lee , K. Na , J. Jung , Y. Cho , K. Choi, " Fast Prototyping of an IS-95 CDMA
Cellular Phone: a Case Study", the 6th Conference of Asia Pacific Chip Design Languages,
YOKOHAMA, Japan, 04-1999.
[17] L. Gauthier, "Génération de système d’exploitation pour le ciblage de logiciel multitâche
sur des architectures multiprocesseurs hétérogènes dans le cadre des systèmes embarqués
spécifiques ", thèse Doctorat, Institut National Polytechnique de Grenoble, France, 12-2001.
[18] P. R. Kolhe, M. H. Tharkar, M. Dharskar, P P. Kolhe, "Impact of Embedded System in
Modern Life ", IPASJ International Journal of Computer Science, Dapoli, Maharashtra, India,
10-2014, Vol. 2, pp.37.
[19] A. P. Chandrakasan S. Sheng and R. W. Brodersen, "Low power CMOS digital design".
IEEE Journal of Solid-State Circuits, California, USA, 04-1992, Vol. 27, pp.473-483.
[20] O. Coudert, R. Haddad K. Keutzer, " What is the state of the art in commercial EDA
tools for low power ", Synopsys Inc, 700 East Middlefield Rd, Mountain View, California,
USA, 1997.
[21] R. P. Lopis and K. Goossens, "The petrol approach to high-level power estimation ", in
ISLPED ’98: Proceedings of the 1998 international symposium on Low power electronics and
design, California, USA, 1998.
[22] M. Ferretti, R. O. Ozdag, P. A. Beerel, " High Performance Asynchronous ASIC BackEnd Design Flow Using Single-Track Full-Buffer Standard Cells ", Proceedings of the 10th
International Symposium on Asynchronous Circuits and Systems, Los Angeles, California,
USA, 2004.
[23] S. K. Khouri and N. K. Jha, "Leakage power analysis and reduction during behavioral
synthesis", IEEE Transaction on VLSI Systems 2002, USA, 12-2002, Vol.10, pp.876-885.
[24] P. Landman and J. M. Rabaey, "Architectural power analysis: the dual bit type method",
in VLSI Systems, IEEE VLSI, USA, 1995, vol.3, pp.173-187.
[25] P. Grosse, "Gestion dynamique des tâches dans une architecture micro-électronique
intégrée à des fins de basse consommation", Thèse doctorat, Ecole Normale Supérieure de
Lyon, France, 2007.
[26] D. Chillet, "Basse consommation dans les systèmes embarqués", Ecole Thématique,
Roscoff, France, 04-2003.
[27] D. Liu and C. Svensson, "Power consumption estimation in CMOS VLSI chips", IEEE
journal of Solid State Circuits on, 06-1994, Vol.29, pp.663-670.
80
Références
[28] T. Soebroto, W. Yung and A. Chang, "Reducing the dynamic power and leakage power
of a high performance SoC", Cadence design systems, Inc, Chelmsford, Massachusetts, USA,
2006.
[29] R. Lemaire, "Conception et modélisation d’un système de contrôle d’applications de
télécommunication avec une architecture de réseau sur puce (NoC)", Thèse de doctorat de
l’INPG, Grenoble, France, 2006.pp. 35-38.
[30] D. Siguenza and J. Nurmi, "VHDL-based simulation environment for proteo NoC ",
Proceedings of the IEEE High Level Design validation and test Workshop, Lexington,
Massachusetts, USA, 2002.
[31] R. Sridhar and K. Schindler, "Instruction level power model and its application to
general purpose processors", Signals, Systems & Computers, 1997, Conference Record of the
Thirty-First Asilomar Conference, Pacific Grove, California, USA, 11-1997, Vol.1.
[32] T. Šimunić, L. Benini and G. D. Micheli, "Cycle accurate simulation of energy
consumption in embedded systems", DAC 1999, Proceedings of the 36th annual ACM/IEEE
Design Automation Conference, New Orleans, Louisiana, USA, 1999.
[33] S. Amit and A. Chandraksan, "Joule track a web based tool for software energy
profiling", DAC IEEE, IEEE Computer Society, New Orleans, Louisiana, USA, 2001.
[34] M. Kamble and K. Ghose, "Analytical energy dissipation models for low power caches",
Low Power Electronics and Design, 1997, Proceedings of International Symposium,
Monterey, California, USA, 08-1997.
[35] S. L. Coumeri and D. E. Thomas, "Memory modeling for system synthesis", Low Power
Electronics and Design, Proceedings of International Symposium, Monterey, California,
USA, 08-1998.
[36] A. Fraboulet, K. Godary and A. Mignotte, "Loop fusion for memory space optimization",
System Synthesis, 2001, Proceedings of The 14th International Symposium, Montreal,
Quebec, Canada, 10-2001.
[37] A. Fraboulet, G. Huard and A. Mignotte,"Loop alignment for memory acces
optimization", System Synthesis, 1999, Proceedings of 12th International Symposium, San
Jose, California, USA, 11-1999.
[38] S. Pignolo, E. Martin and N. Julien, E. Senn, B. Saget, "Optimisation de la
consommation d’énergie des applications de traitement du signal et de l’Image embarquées
sur DSP ", in JFFTC 2001, France, 2001.
[39] H. Zhang, V. George and J. M. Rabaey, "Low swing on chip signaling techniques:
Effectiveness and robustness", Very Large Scale Integration (VLSI) Systems, IEEE
Transactions, IEEE Educational Activities Department Piscataway, New Jersey, USA, 062000, Vol.8, 264-272.
[40] H. Zimmermann, "OSI reference model: the ISO model of architecture for open systems
interconnection", Communications, IEEE Transactions on, Norwood, Massachusetts, USA,
04-1980, Vol.28, pp. 425-432.
81
Références
[41] P. Lysagh and W. Rosenstiel, "New Algorithms, Architectures and Applications for
Reconfigurable Computing ", Springer Publishing Company, Inc, Netherlands, 2005.
[42] G. Qu, N.Kawabe, K. Usami and M. Potkonjak, "Function-level power estimation
methodology for microprocessors", Proceedings of the 37th Annual Design Automation
Conference, Los Angeles, California, USA, 2000.
[43] M. Ibrahim, M. Rupp and A. H. Fahmy, "Power estimation methodology for VLIW
Digital Signal Processors", Signals, Systems and Computers, 2008 42nd Asilomar
Conference on, Pacific Grove, California, USA, 26/29-10-2008, pp. 1840-1844.
[44] S. K. Rethinagiri, R. Ben Atitallah, S. Niar, E. Senn and J. Dekeyser, "Fast and accurate
hybrid power estimation methodology for embedded systems", Design and Architectures
for Signal and Image Processing (DASIP), 2011 Conference on, Tampere, Finland, 2/4-112011.
[45] J. Laurent, N. Julien, E. Senn and E. Martin, "Functional level power analysis: an
efficient approach for modeling the power consumption of complex processors",
Design, Automation and Test in Europe Conference and Exhibition, 2004. Proceedings,
26/20-02-2004, Vol.1, pp. 666-667.
[46] V. Tiwari, S. Malik, A. Wolfe and M. T. C. Lee, "Instruction level power analysis
and optimization of software", VLSI Design, 1996, Proceedings of Ninth International
Conference on, Bangalore, Karnataka, India, 3/6-01-1996, pp. 326-328.
[47] S. Nikolaidis and T. Laopoulos, "Instruction-level power consumption estimation
embedded processors low-power applications", Intelligent Data Acquisition and
Advanced Computing Systems: Technology and Applications, International Workshop on,
Crimea, Ukraine, 07-2001, pp. 139-142.
[48] V. Tiwari, S. Malik and A. Wolfe, "Power Analysis Of Embedded Software: A First Step
Towards Software Power Minimization", Very Large Scale Integration (VLSI) Systems,
IEEE Transactions on, 12-1994, pp. 437-445.
[49] B. Klass, D. E. Thomas, H. Schmit and D. E. Nagle, "Modeling Inter-Instruction Energy
Effects in a Digital Signal Processor", Power-Driven Micro-architecture Workshop,
conjunction with Intl. Symposium on Computer Architecture, Barcelona, Spain, 06-1998.
[50] S. Lee, A. Ermedahl, S. L. Min and N. Chang, "An Accurate Instruction-Level Energy
Consumption Model for Embedded RISC Processors", Proceedings of the ACM SIGPLAN
workshop on Languages, compilers and tools for embedded systems, Snow Bird, Utah,
USA, 2001.
[51] N. Kavvadias, P. Neofotistos, S. Nikolaidis, C. A. Kosmatopoulos and T. Laopoulos,
"Measurements analysis of the software-related power consumption in microprocessors",
Instrumentation and Measurement Technology Conference, 2003. IMTC '03, Proceedings of
the 20th IEEE, Vail, Colorado, USA, 08-2004, vol.2, pp. 981-986.
[52] M. Schneider, H. Blume, and T. G. Noll, "Power estimation on functional level for
programmable processors", Academic Journal, Advances in Radio Science, 05-2004, Vol.2,
pp.215-219.
82
Références
[53] P. Zipf, H. Hinkelmann, D. Lei, M. Glesner, H. Blume and T. G. Noll, "A Power
Estimation Model for an FPGA-Based Softcore Processor", Field Programmable Logic and
Applications, FPL 2007, International Conference on, Amsterdam, Nederland, 08-2007, pp.
171-176.
[54] F. Yunsi, S. Ravi, A. Raghunathan, and N. K. Jha, "A hybrid energy-estimation technique
for extensible processors", Computer-Aided Design of Integrated Circuits and Systems,
IEEE Transactions on, 05-2004, vol. 23, pp. 652-664.
[55] B. Bouchez, "Applications Audio Numériques des DSPs ", Publitronic, Paris, France, 122008.
[56] G. Baudoin et F. Virolieu, "Les DSPs, famille TMS320 C54x : Développement
d’applications", EEA technologie électronique, Dunod, Paris, France, 02-2000.
[57] BDTI, "Choosing a DSP processor", Berkeley Design Technology, Inc, California, USA,
1989.
[58] Texas Instrument, "TMS320C6711D floating-point digital signal processor ", TI, Inc,
SPRS292B, Dallas, USA, 06-2006. Vol.1.
[59] Analog Devices,"ADSP-21160 Preliminary Data Sheet ", Analog Devices, Inc, San Jose,
California, USA, 09-1999.
[60] M. Bouamar, "Le processeur de traitement de signal ADSP-2100 et son système de
dévelopement ", Rapport LAAS No: 89013, Toulouse, France, 01-1989.
[61] Analog Devices, "The ADSP-218x DSP Hardware Reference", Analog Devices, Inc, San
Jose, California, USA, 1999.
[62] D. A. Watt and W. Findlay, "Programming Language Design Concepts", John Wiley &
Sons, Chichester, England, 03-2004, pp. 1-10.
[63] I. T. L. Education Solutions Limited, "Introduction To Information Technology», Pearson
Education India, New Delhi, Delhi, India, 09-2005, pp.245-255.
[64] M. Wendt, M. Grumer, C. Steger, R. Weiss, U. Neffe, and A. Muehlberger, "Tool for
Automated Instruction Set Characterization for Software Power Estimation",
Instrumentation and Measurement, IEEE Transactions on, 01-2010, vol. 59, pp. 84-91.
[65] M. Stein, "Les modems pour la transmission de données", Collection technique et
scientifique des télécommunications, Paris, France, 1991, pp. 3-5.
[66] W. Thies, J. Lin and S. Amarasinghe, "Phased Computation Graphs in the Polyhedral
Model", Version 1 of MIT Laboratory for Computer Science, Cambridge, Massachusetts,
USA, 08-2002, pp.1-2.
[67] BDTI, "Choosing a Processor: Benchmark and Beyond ", Berkeley Design Technology,
Inc, California, USA, 11-2006.
[68] BDTI, "Independent DSP Benchmark Results for the Latest Processors", Berkeley
Design Technology, Inc, California, USA, 2000.
83
Références
[69] BDTI, "Speed per Milliwatt Radios for Fixed-Point Packaged Processors", Berkeley
Design Technology, Inc, California, USA, 11-2013.
84
ANNEXES
Annexe 1
Annexe 1 :
ARCHITECTURE DU PROCESSEUR ADSP2181 :
Le processeur ADSP-2181, est l'un des plus performants des DSPs à virgule fixe de la
famille 21xx. Il combine l’architecture de base ADSP2100 (trois unités de calcul, deux
générateurs d’adresse et un séquenceur de programme) avec deux ports série pour la
transmission des données. Un port DMA intégré de 16-bit et un timer programmable, 16k de
mémoire de données de 16 bits en mémoire vive (RAM) et 16k de mémoire de programme de
24 bits en RAM. Le bus d'adressage est en 14 bits. L’horloge interne fonctionne à 33MHz. La
technologie est du type C-MOS, avec une longueur du canal de 0.5µm. Son architecture est
conçue pour mener en parallèle de multiples opérations afin de favoriser le « pipe-lining ».
Fig. I.1 : Diagramme bloc fonctionnel des DSPs de la famille ADSP218x .
I. Les unités fonctionnelles
I.1. Les Unités de calcul
Les unités de calcul (computational units CU) des ADSP218x exécutent les opérations
arithmétiques des algorithmes de calcul. Les opérations liées à l’unité de calcul sont réalisées
en virgules fixe (fixed-point). Chaque opération s’exécute en un seul cycle d’horloge.
Annexe 1
Fig. I.2 : Diagramme bloc d’une unité de calcul.
Ces unités sont :
- L’unité Arithmétique et logique (ALU) : L’ALU sert aux additions et soustractions
en complément à deux sur les nombres signés et non-singés. Il sert aussi aux opérations
logiques AND, OR, XOR et NOT. Enfin, il sert à effectuer les divisions binaires, mais par
programmation sur plusieurs instructions.
Points saillants de l’ALU de l’ADSP2181 :
 2 registres de 1er opérande AX0 et AX1 (16 bits) ;
 2 registres de 2eme opérande AY0 et AY1 (16 bits) ;
 Peut reprendre le résultat de lui-même ou des autres unités de calcul dans le cycle
suivant par : AR, AF, MR0, MR1, MR2, SR0, SR1 (16 bits) ;
 Dresse 6 bits d’état : AZ, AN, AC, AV, AS, AQ (1 bit) ;
 Prévu pour les calculs en multiple précision.
-
L’unité de multiplication et d’accumulation (MAC) : Sert de faire des
multiplications-additions en un seul cycle d’horloge.
- L’unité de décalage (BS) : Le registre de décalage permet de décaler tous les 16 bits
d’un registre de 1 à 16 positions vers la droite ou la gauche. C’est pour cela que l’unité de
décalage a besoin d’un second registre pour recueillir les bits en sortis.
Annexe 1
I.2. Les générateurs d’adresses
Les deux générateurs d’adresses de l’ADSP2181 (DAG : Data Address Generator)
générant les adresses nécessaires pour le transfert par adressage indirect de données des
mémoires de données (DM) et de programme (PM) internes ou externes.
Fig. I.3 : diagramme bloc d’un générateur d’adresse d’un ADSP218x.
Les fonctions de générateurs d’adresses présentent les caractéristiques suivantes :
-
Générations d’adresses utilisées pour atteindre des positions mémoire par un pointeur.
-
Générations d’adresses par un pointeur auquel est ajouté une valeur signée
(incrémentation ou décrémentation) afin d’atteindre la position mémoire désirée.
-
Modification du pointeur d’adresses sans transferts de données depuis la mémoire de
données ou de programme.
-
Inversion de bits d’adresses sans transferts de données d’adresse avant d’atteindre la
position mémoire désirée.
I.1.3. Le séquenceur de programme
Le séquenceur de programme de l’ADSP2181 contrôle le déroulement du programme en
cours en déterminant l’adresse de la prochaine instruction à exécuter. Le déroulement d’un
programme est principalement linéaire grâce à une exécution séquentielle des instructions. Ce
déroulement peut être modifié par l’utilisation d’une structure non séquentielle comme les
boucles, les interruptions et sous-routines, etc.
Annexe 1
Fig. I.4 : Diagramme bloc du séquenceur de l’ADSP2181.
I.1.4. La mémoire et les bus
L’ADSP2181 comporte deux mémoires vives, soit la PM et la DM, toutes deux de type
SRAM de 16Kmots chacune. Ainsi ils mettent à disposition un port pour la mémoire externe.
Fig. I.5 : Architecture de mémoire de l’ADSP2181
Le processeur ADSP2181 possède cinq bus connectant la mémoire interne avec les autres
unités fonctionnelles :
-
Bus d’adresses de la mémoire de donnée (DMA, 14 bits) ;
-
Bus de données de la mémoire de donnée (DMD, 16 bits)
-
Bus d’adresses de la mémoire de programme (PMA, 14 bits) ;
-
Bus de données de la mémoire de programme (PMA, 24 bits) ;
Annexe 1
Un bus d’adresse (14bits) et un bus de données (24 bits) externes sont prolongés pour l’accès
au mémoire de programme ou de donnée.
I.1.5. Les ports sériels
L’ADSP2181 possède 2 ports sériels intégrés, SPORT0 et SPORT1. Ces ports sériels
peuvent effectuer une transmission numérique, via un seul canal, des bits les uns après les
autres.
La communication est effectuée entre un processeur et une unité périphérique externe.
Fig. I.6 : diagramme bloc d’un port sériel de l’ASP2181.
I.1.6. Le Timer
Le timer à fréquence programmable, permet la génération d’interruptions périodiques. Un
diviseur de 8 bits permet au timer de décrémenter un compteur de 16 bits sur toute la plage de
chaque cycle pour tous les 256 cycles. Une interruption est générée lorsque ce compteur est
décrémenté à zéro. Le compteur est automatiquement rechargé à partir d'un registre de 16 bits
après que l'interruption du timer est générée.
Annexe 1
Fig. I.7 : diagramme bloc du timer.
I.1.7. Les ports DMA
Le DMA est un circuit qui, de façon autonome et prioritaire par rapport à l’exécution du
processeur, transfère directement les octets de la mémoire ROM vers la mémoire vive PM de
l’ADSP2181. L’ADSP2181 comporte deux DMA :
IDMA ou Internal Direct Memory Access. Celui-ci permet à un autre processeur hôte
d’accéder de façon asynchrone et transparente à sa mémoire intégrée PM et DM avec un seul
cycle de retard par mot accédé.
BDMA ou Byte Direct Memory Access. Celui-ci permet d’accéder à la mémoire externe
de façon asynchrone avec son propre séquencement.
Fig. I.8 : Interface de Port Byte DMA des ADSP218x
Annexe 2
Annexe 2 :
JEU D’INSTRUCTIONS DE L’ADSP2181
La famille ADSP218x porte un seul jeu d’instructions unifié conçu pour une compatibilité
ascendante avec les dispositifs de plus grande intégration.
L’ensemble des instructions de la famille ADSP218x offre un transfert flexible de
données. Le langage d’assemblage utilise une syntaxe algébrique pour la lisibilité et la facilité
de codage. Un ensemble d’outils logiciels et matériels complémentaires soutient le
développement de programmes.
Les registres internes au cœur des DSPs de la famille ADSP218x sont pour la plupart des
registres de 16 bits, et chaque unité fonctionnelle possède ses propres registres.
Figure. II.1. Les registres de la famille ADSP218x.
II.1. Les instructions liées au transfert de données
Annexe 2
L’ADSP2181 possède des instructions de transfert de données entre les registres de
mémoire, les mémoires, les registres, les registres de I/O et les registres de contrôle. Les
opérations de transfert comprennent la lecture, l’écriture, le chargement et la mémorisation de
données d’un endroit à un autre.
Exemple :
Transfert d’une donnée de la mémoire de programme (PM) vers un registre
-
AX0= PM(I4, M4).
II.2. Les instructions de calcul
II.2.1. Unité arithmétique et logique
L’ALU exécute des opérations arithmétiques sur des données en virgule fixe de 16 bits et
des opérations logiques bit à bit. Les instructions propres de l’ALU sont :
-
Les additions et soustractions sur 16 bits à virgule fixe ;
-
Les additions et soustractions sur 16 bits avec retenue ;
-
Les opérations logiques AND, OR, XOR, NOT ;
-
Les fonctions ABS et PASS ;
-
Les divisions (primitives).
Exemple des instructions de l’ALU:
-
AR= AX0 + AY0 ;
-
AF=MR0 XOR AY1 ;
-
DIVS AX1, AY1; DIVQ AX1; … « division entre deux nombres signés ».
II.2.2. Multiplicateur et accumulateur
Le MAC exécute des opérations de multiplication et d’addition en un cycle d’horloge. Il
joue un rôle clef pour les applications de traitement de signal puisqu’il est conçu pour le
calcul polynômial.
La multiplication avec addition ou soustraction cumulative se fait à partir de nombres de
16 bits avec le résultat sur 40 bits. Les entrées sont des nombres entiers signés, non signés ou
des nombres fractionnaires. Les instructions disponibles permettent de réaliser les opérations
suivantes :
-
Multiplication simple ;
-
Multiplication avec addition cumulative de choix du type d’arrondi ;
-
Multiplication avec soustraction cumulative de choix du type d’arrondi ;
Annexe 2
-
Arrondi, limitation ou mise à zéro du résultat .
Le multiplicateur possède deux entrées X et Y. le résultat des opérations de MAC de
trouve soit dans les registres MR (MR2, MR1, MR0) ou SR (SR, SR1, SR0).
Exemple :
Multiplication avec addition de résultats au registre de cumul MR.
-
MR= MR+ MX1*MY1.
II.2.3. Décaleur à barillet (Barrel Shifter ou BS)
Le BS permet des décalages de bits pour des registres de 16 bits combinés sur un résultat
de 40 bits. Ces opérations de décalage peuvent réaliser les fonctions suivantes :
-
Décalage logique (LSHIFT) ;
-
Décalage arithmétique (ASHIFT) ;
-
Normalisation (NORM) ;
-
Recherche de l’exposant (EXP) ;
-
Recherche d’un exposant commun à un groupe de nombres (EXPADJ).
Ces décalages peuvent être combinés pour réaliser un contrôle de format numérique
comme par exemple une représentation en virgule flottante ou pour le calcul en multiprécision.
Exemple d’instructions de décalage
-
SR= ASHIFT SI BY -3 (LO);
-
SR= ASHIFT SI BY 6 (HI);
-
BS=EXPADJ AX1.
II.3. Les instructions des générateurs d’adresses :
Chaque générateur d’adresses possède 5 types de registres. Les instructions de ces registres
servent à calculer l’adresse de la position mémoire à atteindre.
-
Les Registres d’index I0 à I3 pour DAG1 et I4 à I7 pour DAG2 jouent le rôle de
pointeur de mémoire;
-
Les Registres de modification M0 à M3 pour DAG1 et M4 à M7 pour DAG2
contiennent la valeur de modification de avec laquelle sera modifié le registre d’index;
-
Les Registres de longueur L0 à L3 pour DAG1 et I4 à I7 pour DAG2 sont utilisés pour
définir la longueur des buffers circulaires;
Annexe 2
-
Registres de base B0 à B3 pour DAG1 et B4 à B7 pour DAG2 sont utilisés pour définir
les adresses de déduit des buffers circulaires;
-
Registres de page mémoire DMPG1 pour DAG1 et DMPG2 pour DAG2 contiennent le
8 bits de poids forts des adresses mémoire.
II.3.1. Mode d’adressage avec bits inversés
Le mode d’adressage avec bits inversés est fréquencement utilisé pour les algorithmes de
transformée de Fourier rapide FFT.
L’adressage en bits inversés est disponible sur DAG1 alors que, vu l’indépendance des
deux générateurs d’adresses, DAG2 reste en mode d’adressage conventionnel. L’activation de
l’adressage en bits inversés de DAG1 se fait en forçant à « 1 » le flag MSTAT nommé
(BIT_REV), par exemple par l’instruction directe ENB BIT_REV.
Exemple d’algorithme d’un adressage avec bits inversés sur 8 bits (N=8) :
I4=buffer_in;
I0=0x2000;
M4=1;
M0=0x0100;
L4=0;
L0=0;
CNTR=8;
ENA BIT_REV;
DO boucle UNTIL CE
AY1= DM(I4, M4);
/* Initialisation de buffer d’entrée */
/* Initialisation du registre d’index (sortie) */
/* Initialisation du registre de modification d’entrée */
/* Initialisation du registre de modification de sortie */
/* Buffer linéaire en entrée */
/* Buffer linéaire en sortie */
/* Initialisation du compteur de boucle */
/* Activation de mode «Bits inversés » */
/* boucle de 8 passages */
/* Transfert d’un élément de buffer d’entrée vers un registre */
DM(I0, M0)=AY1;
DIS BIT_REV;
/* Transfert du registre vers le buffer de sortie */
/* désactivation de mode «Bits inversés » */
boucle:
II.4. Les instructions de déroulement d’un programme
Une fois le programme chargé, il nous est important de savoir comment sont exécutées les
instructions. C’est la que rentre en jeu le séquenceur de programme. Le séquenceur est le
cœur du processeur, c’est lui qui pompe le flux des instructions pour que tout le système
fonctionne.
Exemple des instructions :
-
Instruction de saut (JUMP):
IF NOT CE JUMP top_loop;
-
Instruction d’appel de sous-programme (CALL) :
-
Instruction de boucle : DO end_loop UNTIL CE;
-
Instruction de retour d’un sous programme (RTS) : IF LE RTS ;
-
Instruction de retour d’une routine d’interruption (RTI) : IF MV RTI.
CALL fft_R2;
Annexe 2
II.5. Les instructions des opérations de type multifonction
Grâce à l’architecture Harvard du DSP, il est possible de réaliser plusieurs tâches en un
seul cycle d’horloge.
Exemple :
En un cycle d’horloge les opérations suivantes peuvent être réalisées :
-
Multiplication de deux opérandes et sommation avec le résultat de la multiplication
précédente;
-
Lecture de deux opérandes pour la multiplication suivante.
MR= MR+ MX0*MY0 (SS), MX0=DM(I0, M0), MY0=DM(I4, M4);

Evaluation de la consommation en énergie des programmes

Transcription

Documents pareils

plan de cours : gif-16116

Conception et Commande des Systèmes Electriques Embarqués.

La Mairie de Châlons-en-Champagne recrute Contrôleur de

Licence Professionnelle CCSEE

COMITÉ DIRECTEUR (*) Président Bernard AMIEL BUREAU

Syndicat DSP Tertiaire 65 rue de la Perverie 44324 NANTES

T70-10

PROCESSEUR PENTIUM 4

INGENIEURS SYSTEMES EMBARQUES Contexte