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 Introduction générale 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 Introduction générale 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 Consommation d’énergie dans les systèmes embarqués 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 Consommation d’énergie dans les systèmes embarqués 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 Consommation d’énergie dans les systèmes embarqués 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 Consommation d’énergie dans les systèmes embarqués 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]. a. Partie matérielle 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 Consommation d’énergie dans les systèmes embarqués 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]. a. Partie matérielle 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 Consommation d’énergie dans les systèmes embarqués 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 Consommation d’énergie dans les systèmes embarqués 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 Consommation d’énergie dans les systèmes embarqués 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 Consommation d’énergie dans les systèmes embarqués 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 Consommation d’énergie dans les systèmes embarqués é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 Consommation d’énergie dans les systèmes embarqués 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 Consommation d’énergie dans les systèmes embarqués 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 Consommation d’énergie dans les systèmes embarqués 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 Consommation d’énergie dans les systèmes embarqués 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 Consommation d’énergie dans les systèmes embarqués 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 Consommation d’énergie dans les systèmes embarqués 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 Consommation d’énergie dans les systèmes embarqués - 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 Consommation d’énergie dans les systèmes embarqués 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 Consommation d’énergie dans les systèmes embarqués 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 Consommation d’énergie dans les systèmes embarqués 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 Consommation d’énergie dans les systèmes embarqués 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 Consommation d’énergie dans les systèmes embarqués 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 Consommation d’énergie dans les systèmes embarqués 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 Consommation d’énergie dans les systèmes embarqués 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 Consommation d’énergie dans les systèmes embarqués 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 Consommation d’énergie dans les systèmes embarqués 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 Consommation d’énergie dans les systèmes embarqués 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 Consommation d’énergie dans les systèmes embarqués 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 processeurs DSP à virgules fixe et flottante 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 Les processeurs DSP à virgules fixe et flottante 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 Les processeurs DSP à virgules fixe et flottante 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 Les processeurs DSP à virgules fixe et flottante 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 Les processeurs DSP à virgules fixe et flottante 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 Les processeurs DSP à virgules fixe et flottante 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 Les processeurs DSP à virgules fixe et flottante 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 Les processeurs DSP à virgules fixe et flottante 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 Les processeurs DSP à virgules fixe et flottante 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 processeurs DSP à virgules fixe et flottante 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 Les processeurs DSP à virgules fixe et flottante 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 Les processeurs DSP à virgules fixe et flottante 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 Les processeurs DSP à virgules fixe et flottante 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 Les processeurs DSP à virgules fixe et flottante 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 Les processeurs DSP à virgules fixe et flottante 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 - Les processeurs DSP à virgules fixe et flottante 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 Les processeurs DSP à virgules fixe et flottante 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 Langage machine et consommation d’énergie 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 Langage machine et consommation d’énergie 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 Langage machine et consommation d’énergie 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 Langage machine et consommation d’énergie 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 Langage machine et consommation d’énergie 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 Langage machine et consommation d’énergie 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 Langage machine et consommation d’énergie 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 Langage machine et consommation d’énergie 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 Langage machine et consommation d’énergie é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 Langage machine et consommation d’énergie 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 Langage machine et consommation d’énergie 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 Langage machine et consommation d’énergie 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 Langage machine et consommation d’énergie 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 Langage machine et consommation d’énergie 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 Langage machine et consommation d’énergie 40 35 30 25 20 Temps d'éxecution (µs) 15 Enengie consommée(W.µs) 10 5 0 '320UC5402 '320C6202 DSP16210 Fig.3.2 : Temps d’exécution et consommation d’énergie des trois DSPs testés sur 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 Application sur DSP à virgule fixe 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 Application sur DSP à virgule fixe 180 160 140 120 100 80 60 40 20 0 Temps d'éxecution (µs) Enengie consommée(W.µs) '320UC5402 '320C6202 DSP16210 Fig.4.1 : Temps d’exécution et consommation d’énergie des trois DSPs testés sur 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 Application sur DSP à virgule fixe 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 Application sur DSP à virgule fixe é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 Application sur DSP à virgule fixe 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 Application sur DSP à virgule fixe 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 Application sur DSP à virgule fixe 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 Application sur DSP à virgule fixe 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 Application sur DSP à virgule fixe 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 Application sur DSP à virgule fixe 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 fonction bit reverse) en W.µs 300 250 200 Enengie consommée (sans fonction bit reverse) 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 Application sur DSP à virgule fixe 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);