Table des matières

1 Généralités sur les processeurs 1

1.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1
1.2 Architecture de base des processeurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1
1.3 Etapes d’exécution d’une instruction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
1.4 Processeur VON Neumann : 8086 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
1.5 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13

2 Architecture interne du DSP TMS320C6416 14

2.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
2.2 Besoin pour le TNS : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
2.3 Représentation des nombres à virgule . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
2.4 Programmation des DSP de la famille C6000 de Texas Instruments . . . . . . . . . . . . . 16
2.4.1 Architecture interne du cœur du DSP TMS 320C6416 : . . . . . . . . . . . . . . . . 16
2.4.2 Les mémoires . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
2.4.3 Bus internes et Contrôleurs d’accès mémoire . . . . . . . . . . . . . . . . . . . . . . 19
2.5 Jeu d’instruction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
2.5.1 Opérations de transfert de données : . . . . . . . . . . . . . . . . . . . . . . . . . . 22
2.5.2 Opérations arithmétiques et logiques : . . . . . . . . . . . . . . . . . . . . . . . . . 23
2.5.3 Opérations arithmétiques et logiques : . . . . . . . . . . . . . . . . . . . . . . . . . 24
2.5.4 Opérations de sauts conditionnels : Les boucles . . . . . . . . . . . . . . . . . . . . 25
2.6 Module d’évaluation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
2.7 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26

3 Techniques d’optimisation assembleur 27

3.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
3.2 Etages d’exécution d’une instruction du DSP TMS320C6416 . . . . . . . . . . . . . . . . . 27
3.3 Parallélisme du DSP TMS320C6416 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
3.3.1 Implémentation série . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
3.3.2 Implémentation partiellement parallèle . . . . . . . . . . . . . . . . . . . . . . . . 30
3.4 Application : Le critère de comparaison SAD . . . . . . . . . . . . . . . . . . . . . . . . . 31
3.5 Techniques d’optimisation : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
3.5.1 Réduire les NOP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
3.5.2 Utilisation des instructions par paquet . . . . . . . . . . . . . . . . . . . . . . . . . 36
3.5.3 Equilibrer les instructions entre l’unité A et B . . . . . . . . . . . . . . . . . . . . 38

2
 3.5.4 Parallèlisme entre les itérations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
3.6 Standard assembly : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
3.7 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43
 LISTE DES ACRONYMES

ALE : Address Latch Enable

BHE : Bus High Enable
CCS : Code Composer Studio
CS : Chip Select
CPU : Central Processing Unit
DMA : Direct Memory Access
DSK : DSP Starter Kit
DSP : Digital signal processor
ENIAC : Electronic Numerical Integrator and Computer
ISRAM : Internal Static Random Access Memory
MB : MacroBlock
MIPS : Million Instruction Per Second
PC : Programm counter
SA : Standard Assembly
SAD : Sum of Absolute Difference
TI : Texas Instruments
TNS : Traitement Numérique du Signal
UAL : Unité Arithmétique et Logique
VLIW : Very Long Instruction Word

1
 Chapitre 1

Généralités sur les processeurs

1.1 Introduction
Dans les années 1945, John Von Neumann définit des processeurs qui se distinguent de leurs prédéces-
seurs par le fait qu’ils disposent d’un programme composé d’instructions qui doivent être placées dans une
mémoire. Chaque instruction définit une action à réaliser sur des données. Auparavant, le système n’exé-
cutait qu’un seul programme câblé ; chaque exécution d’un nouveau programme nécessitait de le recâbler.
L’ENIAC (Electronic Numerical Integrator and Computer), un des premiers systèmes électroniques achevé
en 1946, est l’exemple type de ce genre de machine. Il occupait une surface de 167 m2 et consommait 150
Kilowatt. Sur cette machine, une multiplication était réalisée en 0,001 seconde ; de nos jours, une telle
opération demande 30 nanosecondes.

Figure 1.1 – L’ENIAC : Premier système câblé

1.2 Architecture de base des processeurs

Un processeur est constitué de plusieurs éléments. Son schéma bloc basique est donné par la figure 1.1. Il
est principalement composé de :
Une unité de mémorisation : Elle est constituée de registres de données qui permettent la mémorisation
d’informations au sein du processeur. Ils sont caractérisés par leur temps d’accès très rapide.

1
 CHAPITRE 1. GÉNÉRALITÉS SUR LES PROCESSEURS

Une unité d’exécution : appelée aussi Unité Arithmétique et Logique (UAL), elle enclave un ensemble
de circuits arithmétiques et logiques qui permettent au processeur d’effectuer les opérations de calcul. Elle
renferme aussi un registre d’état qui effectue une mise à jour suite à l’exécution de chaque instruction.
Une unité de commande : Elle fait principalement appel à un séquenceur qui pilote le travail du
processeur. Ce dernier est épaulé par décodeur d’adresse, un registre d’instruction et un compteur ordinal
(Programm counter PC). Le PC pointe toujours sur l’adresse de la prochaine instruction à exécuter. Le
pilotage est cadencé au rythme du signal d’horloge qui définit les cycles du processeur.
Une unité de communication :C’est l’ensemble des bus de données, d’adresses et de contrôles qui
permettent à l’information de circuler entre les différents composants du processeur.

Figure 1.2 – Schéma bloc basique d’un processeur

Un processeur est un composant actif. Il est principalement caractérisé par son architecture, sa fréquence
de calcul (Hz) et sa capacité d’adressage C@ (Octet) donnée par :

C@ = 2A .D (1.1)

A étant le nombre de bits du bus d’adresse du processeur et D le nombre de bits du bus de données du
processeur.
La mémoire est un module connecté au processeur pour couvrir sa capacité d’adressage. Elle est répartie
en une zone mémoire programme qui renferme les code et une deuxième zone mémoire données qui renferme
les données. Elle peut être constituée d’un ou de plusieurs blocs. Elle est organisée sous forme d’un tableau
de mots représentant une information qui peut être soit une instruction soit une donnée. Chaque mot
mémoire est une information identifiable de façon unique car il est désigné par une adresse qui marque
son rang dans le tableau mémoire.
Une mémoire est principalement caractérisée par son temps d’accès et sa taille T donnée par :

Imen Werda Page 2/51

 CHAPITRE 1. GÉNÉRALITÉS SUR LES PROCESSEURS

T = 2AM .DM (1.2)

2AM étant le nombre de bits du bus d’adresse du boitier mémoire et DM le nombre de bits du bus de
données du boitier mémoire.
¯ qui doit être impérativement connectée à la masse pour
La mémoire est aussi caractérisée par sa pine CS
marquer l’état de marche du boitier.
Le microprocesseur qui dispose d’un seul bus d’adresse et un seul bus de donnée a une architecture Von
¯ du bus de contrôle va orienter le courant du bus
Newman, comme illustré par la figure 1.3. Le signal RW
de données : en mode de lecture (Read) ou en mode d’écriture (Write). Le bus d’adresse est par contre
orienté vers un seul sens : seul le processeur peut délivrer une adresse à la mémoire.
NB : La taille de la mémoire câblée au processeur ne peut pas dépasser sa capacité d’adressage. Pour
câbler plusieurs boitiers à un processeur on doit se fier à la cartographie mémoire qui constitue le cahier
de charge du système.

Figure 1.3 – Architecture Von Newman

A titre d’exemple, on va considérer un processeur 8 bits de capacité d’adressage 1Koct. Pour représenter
son câblage avec des boitiers mémoires organisés comme suit, on doit effectuer méthodiquement les étapes
suivantes :

1. Déterminer la cartographie mémoire : c’est le cahier de charge de notre problème.

Imen Werda Page 3/51

 CHAPITRE 1. GÉNÉRALITÉS SUR LES PROCESSEURS

2. Repérer les bits de sélection puis extraire la table de vérité du décodeur d’adresse.
3. Représentez clairement le câblage entre les deux boitiers mémoires et le processeur.

Solution :
1. La cartographie mémoire : Suite à l’extraction de la cartographie mémoire, donnée par la figure
1.4, le bit A9 est repéré comme étant le bit de sélection. Par conséquent, de (A0 à A8) seront les
bits d’adresses à connecter avec les bus d’adresses des deux boitiers mémoires. En effet, toutes les
combinaisons de (A0 à A8) se référant aux cases mémoires du boitier M1 seront aussi réutiliser pour
sélectionner les cases mémoires du boitier M2. La seule différence c’est la valeur du bit A9.

Figure 1.4 – La cartographie mémoire

2. Table de vérité du décodeur d’adresse : L’entrée du module décodeur d’adresse est le bit A9. Les
¯ et CS2.
sorties sont les bits de sélection des deux boitiers mémoires CS1 ¯ Pour générer la table de
vérité, voir tableau 1.1, on va extraire à partir de la cartographie mémoire, l’état des sorties pour les
différentes combinaisons que peut prendre l’entrée.

TABLEAU 1.1 – Table de vérité du décodeur d’adresse

A9 ¯
CS1 ¯
CS1
0 0 1
1 0 1

3. Le câblage entre le microprocesseur et les deux boitiers mémoire est donné par la figure 1.5 :

Imen Werda Page 4/51

 CHAPITRE 1. GÉNÉRALITÉS SUR LES PROCESSEURS

Figure 1.5 – Câblage entre le microprocesseur et les boitiers mémoire

1.3 Etapes d’exécution d’une instruction

Le processeur agit comme un automate. Il exécute en ordre les instructions l’une après l’autre. Une
instruction est une chaîne binaire qui comprend deux grandes parties : Le code opératoire et l’opérande.
Il y’a trois étapes à suivre pour exécuter une instruction :

- Recherche de l’instruction à traiter (Fetch) : Le registre compteur d’instruction PC contient l’adresse

de la prochaine instruction à exécuter. Il va l’envoyer sur le bus d’adresse via l’unité de commande
qui émet un ordre de lecture. Le contenu de la case mémoire sélectionnée sera transféré via le bus de
données vers le registre données. Ce dernier va à son tour la transférer vers le registre d’instruction
pour marquer la fin de cette étape.
- Décoder l’instruction (Decode) : Cette étape consiste à décoder l’instruction sur plusieurs mots. En
une première phase, le premier mot de l’instruction est identifié : c’est le code opératoire qui définit
l’opération. Il sera transféré par l’unité de commande vers l’unité de traitement. Une deuxième
phase sera activée si l’instruction nécessite une opérande. L’adresse cette dernière sera envoyée par
le décodeur de l’unité de commande sur le bus d’adresse pour sélectionner la case cible. L’opérande
sera récupérée via le bus de données et stockée dans un registre de donnée.
- L’exécution de l’instruction (Execute) : Cette étape consiste à exécuter l’instruction au niveau de
l’UAL. Puis, effectuer la mise à jour du registre d’état et incrémenter le PC.

Pour exécuter un code constitué de quatre instructions on procèdera de cette manière :

F1D1E1 F2D2E2 F3D3E3 F4D4E4

Par conséquent 12 cycles seront nécessaires pour exécuter ce code.

Imen Werda Page 5/51

 CHAPITRE 1. GÉNÉRALITÉS SUR LES PROCESSEURS

Si on procède d’une autre manière, comme représenté par le tableau ci-dessous, 6 cycles seulement seront
nécessaires ce qui permettra une optimisation de 50% en consommation en temps d’exécution. L’exécution
de cette manière, représentée par la figure 1.6 s’appelle pipeline.

Figure 1.6 – Exécution en pipeline de quatre instructions

L’instant t , où les trois étages du pipeline sont fonctionnelles (F D E), est appelé instant d’amorçage.
A partir de cet instant on démarre le rythme d’exécution d’une instruction par cycle.
Le rectangle bleu de la figure 1.6 marque le fonctionnement simultané de deux étages du pipeline :
D1 : Le registre PC va envoyer l’adresse de I1 (@I1) sur le bus d’adresse par l’intermédiaire de l’unité de
commande qui émet un ordre de lecture. Le contenu de la case mémoire sélectionnée renfermant le code
opératoire de l’instruction (Opc I1) sera transféré via le bus de données vers le registre d’instruction pour
marquer la fin de F1. Pour décoder l’instruction I1 ( D1), le code opératoire qui définit l’opération I1 sera
transféré par l’unité de commande vers l’unité de traitement. Si l’instruction I1 nécessite une opérande,
l’adresse cette dernière (@ Opd1) sera envoyée par le décodeur de l’unité de commande sur le bus d’adresse
pour sélectionner la case cible. La valeur de l’opérande sera récupérée via le bus de données (Val Opd1)
et stockée dans un registre de donnée.
F2 : Au même instant, le pipeline procède à la recherche de l’instruction I2 (F2) : le registre PC va envoyer
l’adresse de I2 ( @I2 ) sur le bus d’adresse par l’intermédiaire de l’unité de commande qui émet un ordre
de lecture. Le contenu de la case mémoire sélectionnée (Opc I2) sera transféré via le bus de données vers
le registre d’instruction pour marquer la fin de F2. On peut clairement constater, Sur la figure 7, le conflit
entre F2 et D1. En effet, à un instant donné, le bus d’adresse affrontera un conflit entre le transfert de @I2
pour la phase F2 et @Opd1 pour la phase D1. De même, un deuxième conflit se présentera sur le bus de
données entre le transfert du code opératoire de l’instruction I1 Opd2 pour la phase F2 et la valeur de
l’opérande I1Val Opd1 pour la phase D1. La limitation de l’architecture Von Newman est principalement
due à la limitation de ses bus.

Imen Werda Page 6/51

 CHAPITRE 1. GÉNÉRALITÉS SUR LES PROCESSEURS

Figure 1.7 – Conflit des phases d’exécution sur l’architecture Von Newman

Cette limitation a permis de donner naissance à une autre architecture dite : Harvard. Cette dernière
affiche une séparation physique entre les bus de données et d’adresse connectés à la mémoire programme
et ceux connectés à la mémoire données, comme le montre la figure 1.8 .

Figure 1.8 – Architecture Harvard

Avec l’architecture Harvard on peut effectuer la phase F2 simultanément avec la phase D1 comme l’illustre
la figure 1.9. C’est ainsi que l’architecture Harvard permet l’exécution des instructions d’un code en pipeline
entrainant une accélération des temps d’exécutions.

Imen Werda Page 7/51

 CHAPITRE 1. GÉNÉRALITÉS SUR LES PROCESSEURS

Figure 1.9 – Pipeline sur l’architecture Harvard

Exemple :
Chaque processeur a son propre jeu d’instruction. Dans cet exemple, on procède à l’exécution du code C1
du tableau 2 constitué de six instructions assembleur indépendantes d’un processeur particulier.

TABLEAU 1.2 – Code assembleur C1

Imen Werda Page 8/51

 CHAPITRE 1. GÉNÉRALITÉS SUR LES PROCESSEURS

Figure 1.10 – Exécution pipeline du code C1

’exécution pipeline du code C1, illustrée par la figure 1.10, montre qu’à l’instant t3, suite à l’exécution de
l’instruction I1 (E1), la valeur 2+3= 5 sera affectée au registre R3. Simultanément, on procède à l’étape
D2 qui consiste à décoder l’instruction « + » et à lire ses opérandes ( 5 + 4 ) et en même temps on
effectue on accomplit l’étape F3. Les trois étages du pipeline sont actifs donc l’amorçage du pipeline est
activé. Normalement, à partir de cet instant on a démarré le rythme d’exécution d’une instruction par
cycle. Arrivé à l’instant t4, E2 permet d’affecter au registre R6 la valeur 9 mais on ne peut pas effectuer
l’opération D3 simultanément car l’opérande R6 n’est pas encore prête à t4. Un cycle d’attente s’impose
(W) et le décodage sera décalé au cycle t5. Le bon fonctionnement du pipeline est altéré et le rythme
d’exécution d’une instruction par cycle est rompu. Cette défaillance est causée par la dépendance de
donnée ou d’adresse au niveau du code. Dans notre cas, en avançant l’instruction I4 (décrémentation du
conteur) avant l’instruction I3, on casse cette dépendance de données sans impacter le bon fonctionnement
du code. En arrivant à l’instant t8, l’exécution de l’instruction de branchement va recharger le registre
PC par l’adresse de l’instruction I1. Par conséquent, Au cycle t9 le pipeline sera altéré et on lancera le
F1 de l’instruction I1 au lieu d’exécuter l’instruction E6 dont la phase « fetch » F6 et « decode » D6 ont
été effectués. Ces derniers cycles seront considérés comme des cycles d’attentes. Quand le conteneur R8
sera nul, la condition du branchement ne sera plus valide, et l’opération E6 sera exécuter. Ce cas de figure
montre que les boucles altèrent gravement le bon fonctionnement du pipeline. Pour éviter ce problème, il
faut dérouler les boucles à très faible nombre d’itérations.
Pour résumer, on peut conclure que les problèmes peuvent causer le disfonctionnement du pipeline sont
principalement : la dépendance de données et d’adresse et les boucles répétitives.
NB : Toutes les étapes d’exécution d’une instruction : FETCH, DECODE et EXECUTE sont automati-
quement synchronisées par le séquenceur qui assure le bon déroulement des opérations. Le programmeur ne
peut pas intervenir, certes, mais il peut éviter les problèmes précédemment cités au niveau de la structure
de leurs codes

Imen Werda Page 9/51

 CHAPITRE 1. GÉNÉRALITÉS SUR LES PROCESSEURS

1.4 Processeur VON Neumann : 8086

Le microprocesseur Intel 8086 fait partie de la famille de processeurs x86. Ce processeur 16 bits a été
développé par Intel en 1978 pour traiter des données de 16 bits à la fois. Cela représentait une amélio-
ration significative par rapport aux processeurs 8 bits précédents (8085). Il prend en charge un ensemble
d’instructions de niveau machine étendu, ce qui lui permet d’effectuer une variété de tâches complexes. [1]

Figure 1.11 – Cycles de lecture et d’écriture du 8086

Les bus d’adresse et de données du 8086 sont multiplexés pour réduire la taille de son boitier. Qu’il s’agit
d’un cycle de lecture ou d’écriture, l’adresse sera envoyée en premier lieu sur de bus ADi pour sélectionner
la case mémoire en mode lecture ou en mode écriture. Ensuite, un transfert de données sera effectué sur le
bus ADi dans le sens de lecture ou l’écriture. Les opérations de lectures et d’écritures ne seront activées
que si la donnée est disponible sur le bus ADi , comme illustré par la figure 1.11 [1].
Avant de le câbler avec les boitiers mémoires il faut procéder au démultiplexage des signaux AD0 à AD15
et A16/S3 à A19/S6 en mémorisant l’adresse lorsque celle-ci est présente sur le bus A/D, à l’aide d’un
LATCH. Ce dernier se compose de 20 bascules D ayant pour entrées les 20 bits du bus de donnés-adresse
du 8086. Ces bascules sont cadencées par le signal ALE (Address Latch Enable ) du 8086, qui commande
la mémorisation de l’adresse générée par le microprocesseur : Si (ALE=1) c’est que l’adresse est disponible
sur le bus, sinon, elle sera mémorisée. Dans les deux cas de figure l’adresse sera récupérée à la sortie du
LATCH. Le bus de données sera directement connecté aux mémoires depuis les pins Adi du 8086 puisqu’il
ne serait sollicité que quand les actions de lecture ou d’écriture sont activées.[1]

Imen Werda Page 10/51

 CHAPITRE 1. GÉNÉRALITÉS SUR LES PROCESSEURS

Figure 1.12 – Interfaçage 8086 et mémoires

Normalement, avec 16 bits de données et 20 bits d’adresse, le 8086 peut adresser jusqu’à 2 Mo, mais en
examinant son câblage avec les mémoires on peut comprendre la limitation de capacité d’adressage à 1
Mo de mémoire seulement. En effet la figure 12 montre que les boitiers mémoires connectés au 8086 ont
un bus de données de 8 bits. Le boitier pair sera connecté aux 8 bits de poids faible du bus de données
du 8086 et le boitier impair sera connecté aux 8bits de poids fort de son bus de données. En plus la pine
¯ du premier boitier mémoire est activée par le bit d’adresse de poids faible du 8086 A0, et le deuxième
CS
¯
boitier mémoire est sélectionné par la pine BHEdu 8086. Ainsi, ces deux boitiers peuvent être sélectionnés
simultanément, pour manipuler des données sur 16 bits, ou séparément pour traiter des données sur 8 bits.
La division physique du bus de données du 8086 a causé la limitation de sa capacité d’adressage à 1Mo
au lieu de 2Mo pour assurer sa compatibilité avec son prédécesseur, le processeur 8085.[1]

Imen Werda Page 11/51

 CHAPITRE 1. GÉNÉRALITÉS SUR LES PROCESSEURS

Figure 1.13 – Architecture interne du 8086

La figure 1.13 détaille l’architecture interne du processeur 8086 qui possède quatre registres auxiliaires
pour manipuler les données (AX, BX, CX, DX), des registres d’index (SI, DI, SP, BP), un registre
d’état (indicateur), un registre IP et des registres de segment (CS, DS, SS, ES). Ces derniers assurent
la gestion de la mémoire par la méthode dite « segmentation ». [1]
L’espace mémoire adressable par le 8086 est divisé en des zones mémoires de 64 Ko appelées segments.
Un segment est défini par son adresse de départ qui doit être un multiple de 16 (les 4 bits de poids faible
sont nuls) ce qui permet de représenter l’adresse d’un segment avec seulement ses 16 bit de poids fort,
les 4 bits de poids faible étant implicitement à 0. Ainsi, une case mémoire est représentée par le 8086 au
moyen de deux quantités sur 16 bits :
- Segment : Les 16 bits de poids fort de l’adresse de début du segment.
- Offset : Les 16 bits représentants le déplacement dans ce segment.
Ainsi, la représentation (segment : offset) définie l’adresse logique utilisée lors de la programmation.
L’adresse sur 20 bits A0 - A19, envoyée réellement par le microprocesseur 8086 sur le bus d’adresse, est

Imen Werda Page 12/51

 CHAPITRE 1. GÉNÉRALITÉS SUR LES PROCESSEURS

appelée adresse physique. L’architecture x86 est célèbre pour sa compatibilité ascendante, ce qui signifie
que les processeurs plus récents sont capables d’exécuter des programmes écrits pour les versions précé-
dentes de l’architecture. Cette compatibilité a été maintenue tout au long de l’évolution des processeurs
x86 jusqu’au processeur Xeon 64 bits.[1]

1.5 Conclusion
L’évolution des processeurs a été marquée par des progrès constants au fil des décennies, caractérisés par
une augmentation de la puissance de calcul, une amélioration de l’efficacité énergétique, des avancées dans
la technologie de fabrication, et l’intégration de fonctionnalités toujours plus avancées. Dans le chapitre
suivant on étudiera en détail l’architecture interne du processeur de traitement de signal numérique le
TMS320C6416 de la famille C6000 de TI.

Imen Werda Page 13/51

 Chapitre 2

Architecture interne du DSP

TMS320C6416

2.1 Introduction
Au fil des années, les calculs numériques ont pris de l’ampleur par rapport aux calculs analogiques grâce
aux avantages qu’il offre tels que leur grande résistance aux bruits engendrés par les variations des tensions
d’alimentation, les variations de la température et les interférences électromagnétiques. En plus, le calcul
numérique affiche une indépendance par rapport aux tolérances de fabrication et assure un stockage des
données sans dégradation. Le calcul numérique offre aussi un contrôle absolu des données lors du traitement
avec une programmation haut niveau facile qui peut être effectuée en un temps de développement rapide.

2.2 Besoin pour le TNS :

Pour épauler cet énorme flux de calculs numérique, des Processeur de traitement Numérique du Signal
(Digital Signal Processor (DSP) ) ont vue le jour. En effet, ces types particuliers de microprocesseurs
intègrent un ensemble de fonctions spéciales destinées à les rendre particulièrement performants dans
le domaine du traitement numérique du signal (TNS). Un DSP se présente généralement sous la forme
d’un microcontrôleur intégrant, selon les marques et les gammes des constructeurs, une grande variété de
mémoires, des timers, des ports séries synchrones rapides, des contrôleurs d’Accès Directe à la Mémoire
(DMA) et des ports d’E/S divers. Les DSP par leur architecture adaptée au traitement numérique assurent
une augmentation du parallélisme. En effet, les cœurs des DSPs sont dotés d’unités de calcul en parallèle.
Les mémoires internes et externes ont des bus indépendants permettant des accès multiples pour assurer
des opérations de lecture et écriture de plusieurs données simultanément. En plus du jeu d’instructions
spécialisé, l’architecture interne des DSP permet l’exécution des instructions en pipeline ce qui permet le
découpage des phases d’exécution des instructions de façon à pouvoir les exécuter à des intervalles plus
rapprochés. Les processeurs DSP ont une architecture performante car ils doivent accomplir des tâches
en temps réel. Cette contrainte, illustrée par la figure 2.1, imposant un temps d’attente positif, dépend
complètement de l’application. Ainsi, une application est dite en temps réel si son temps d’attente est ≥
0.

14
 CHAPITRE 2. ARCHITECTURE INTERNE DU DSP TMS320C6416

Figure 2.1 – La contrainte temps réel

2.3 Représentation des nombres à virgule

Pour traiter des variables réelles, les limites de la machine vont entraîner des limites sur l’étendue et la
précision des valeurs. Il existe deux façons de coder les nombres à virgule : Le codage en virgule fixe ou
en virgule flottante. Dans un processeur à virgule fixe, illustré par la figure 2.2, il faut se préoccuper de
la plage dynamique des nombres, car le codage en virgule fixe consiste à garder un nombre fixe de chiffes
après la virgule.

Figure 2.2 – Représentation en virgule fixe

Les données sont représentées comme étant des nombres fractionnaires à virgule fixe, (exemple -1.0 à +1.0),
ou comme des entiers classiques. Cette représentation des nombres fractionnaires s’appuie sur la méthode
du «complément à deux». Elle permet facilement l’addition binaire de nombres positifs et négatifs.
Lors du codage des réels à virgule flottante, représenté par la figure 16, les données sont représentées
en utilisant une mantisse et un exposant. La représentation de ces nombres s’effectue selon la formule
suivante :

n = mantisse x 2exposant (2.1)

Généralement, la mantisse est un nombre fractionnaire (-1.0 à +1.0), et l’exposant est un entier indiquant
la place de la virgule en base 2.

Imen Werda Page 15/51

 CHAPITRE 2. ARCHITECTURE INTERNE DU DSP TMS320C6416

Figure 2.3 – Représentation en virgule flottante

2.4 Programmation des DSP de la famille C6000 de Texas Instruments

Il est relativement facile d’écrire un programme pour un DSP, grâce aux compilateurs C interfacés avec
le DSP. La façon d’écrire le programme C a une influence significative sur l’efficacité du code généré. Il
existe une phase d’adaptation du code C à un code DSP, permettant au compilateur de tirer le meilleur
parti de l’architecture de calcul. Code Composer Studio (CCS) : Le logiciel de pilotage de la carte DSP est
un logiciel très performant comportant un ensemble complet d’outils de développement d’applications sur
DSP. Il permet aussi d’augmenter et d’améliorer le processus de développement pour les programmeurs
qui cherchent à créer et tester en temps réel des applications de traitement de signal.. Comme illustré par
la figure 2.4, il met en disposition des outils pour configurer, construire, exécuter, suivre et analyser des
programmes.

Figure 2.4 – CCS : balayage des niveaux d’abstraction logiciel

2.4.1 Architecture interne du cœur du DSP TMS 320C6416 :

Les DSP de la famille C6000 adoptent la technologie VLIW « Very Long Instruction Word », utilise
des paquets ou des mots d’instructions de 256 bits autorisant le traitement parallèle de 8 instructions
élémentaires de 32 bits. Les DSP de la famille C6000 offrent des cœurs à deux chemins de données A et B
pour traiter des instructions de 256 bits et 8 sous-instructions de 32 bits. Chaque chemin contient 4 unités
de traitement :
- (.M) pour exécuter la multiplication.

Imen Werda Page 16/51

 CHAPITRE 2. ARCHITECTURE INTERNE DU DSP TMS320C6416

- (.L) pour exécuter les opérations logiques et arithmétiques.

- (.S) pour assurer les opérations de branchement et les manipulations binaires.
- (.D) pour assurer les opérations de chargement et stockage des données.
Pour épauler ces deux chemins de données, le DSP C6000 dispose d’une pile de 64 registres de 32 bits (A0
à A31) et (B0 à B31) ainsi que deux chemins croisés (1x et 2x) (cross path) pour faciliter la communication
entre les deux unités.

Figure 2.5 – Cœur du DSP TMS320C6416

Le DSP TMS320 C6416 avec sa fréquence de 720 MHz, peut exécuter jusqu’à 5760 MIPS. L’architecture
VelociTI.2 de ce DSP fournit huit unités d’exécution : deux multiplicateurs et six unités arithmétiques et
logiques (UAL). Ces unités fonctionnent en parallèle et peuvent effectuer jusqu’à huit instructions en un
seul cycle d’horloge. L’unité centrale de traitement du C64x (CPU), présentée dans Figure 2.5, se compose
de deux groupes de registres A et B à 32 bit, de huit unités fonctionnelles (L1, S1, M1, D1 et L2, S2, M2,
D2) et de deux chemins de données 1x et 2x. La mémoire interne du TMS320C6416 est de 1Moct. Elle est
configurable comme mémoire cache, ISRAM ou comme combinaison des deux [2].

2.4.2 Les mémoires

L’accès à une mémoire externe, ou des mémoires internes de grande taille, est coûteuse en termes de
temps et de consommation d’énergie. . Pour éviter ces temps d’accès, les DSP ont intégré des mémoires
caches pour diminuer le trafic mémoire externe / CPU. De plus une organisation Harvard est adoptée

Imen Werda Page 17/51

 CHAPITRE 2. ARCHITECTURE INTERNE DU DSP TMS320C6416

pour les mémoires permettant d’accéder simultanément à deux blocs distincts de mémoire, la mémoire
des programmes et celle des données. Les mémoires caches sont caractérisées par leurs petites tailles. Elles
sont réparties en mémoire cache instruction destiné à loger des parties du code à exécuter et la mémoire
cache données configurable par l’utilisateur.

Figure 2.6 – Répartitions de la mémoire cache L1

L1P : Le C6x contient une mémoire cache programme de taille 16Ko ayant un bus de données de 256 bits.
Donc, un paquet de fetch (PF) = 256 bits = 8*32 = 8 instructions.

- TAG (18 bits) : les 18 bits MSB de l’adresse sont stockés dans une mémoire tampon pour indiquer la
présence de la plage d’adresse désirée dans la cache ou non.
- Set Index (9 bits) : un set est une collection de ligne de trame. Dans un système d’adressage direct,
chaque set contient une seule ligne.
- Offset (5 bits) : l’offset dans une ligne permet l’adressage par octet dans un PF.
Exemple : A partir de l’adresse de l’instruction (0X80000250) on peut déterminer l’offset, le set et le tag.

Figure 2.7 – Décryptage de l’adresse d’une instruction

- L1D : Le C64x contient une mémoire cache de données de16 Ko. Il y’a 128 ensembles contenant
chacun 2 lignes cache. Chaque ligne est formée de 64 octets.

- TAG (19 bits) : il représente les MSB de l’adresse. Il sera stocké dans une mémoire tampon pour
indiquer la présence de la plage d’adresse désirée dans le cache ou non (miss / hit).
- Set Index (7 bits) : un ensemble est une collection de ligne de trame. Dans un système d’adressage
associatif par ensemble de deux blocs, chaque ensemble contient deux lignes.
- Group (4 bits) : sélectionne le mot dans un ensemble qui contient les données désirées.

Imen Werda Page 18/51

 CHAPITRE 2. ARCHITECTURE INTERNE DU DSP TMS320C6416

- Offset (2 bits) : détermine l’offset d’un mot dans l’adresse.

2.4.3 Bus internes et Contrôleurs d’accès mémoire

Figure 2.8 – Bus internes du TMS320C6416

Les bus internes illustrés à la Figure 2.8 comprennent : Un bus d’adresses 32 bits pour les mémoires
programmes et un bus 256 bits, pour les mémoires données, qui accommode Huit unités fonctionnelles
à 32 bits pouvant opérer en parallèle. Un bus d’adresse à 32 bits pour les accès DMA qui va permettre
d’effectuer le transfert de données en parallèle avec les calculs du CPU.

TABLEAU 2.1 – Les registres de paramètres DMA

Ce DSP est aussi doté d’un module de transfert DMA qui fonctionne simultanément avec le CPU puisqu’il
dispose de son propre bus de donnée et adresse. Pour réaliser un transfert DMA, on doit configurer un
des 64 canaux DMA disponibles. Chaque canal est contrôlé par un groupe de registres de paramètres
qui fixent : les options de transfert “OPT” décrits au Tableau 2.2, l’adresse source “SRC”, le compteur

Imen Werda Page 19/51

 CHAPITRE 2. ARCHITECTURE INTERNE DU DSP TMS320C6416

du transfert “CNT”, l’adresse de destination “DST”, l’indexe “IDX” et l’adresse de liaison dans le cas de
transfert répétitif “RLD” comme détaillé par le tableau 2.1 [3].

TABLEAU 2.2 – Registre des options du canal DMA

Bits du registre OPT Label Descritption

31 :29 PRI Niveau de priorité du transfert
28 :27 ESIZE Taille des éléments(32/16/8-bit)
26 2DS Dimension de la Source
25 :24 SUM Adresse Source
23 2DD Dimension de la Destinantion
22 :21 DUM Adress Destination
20 TCINT Interruption du transfert
19 :16 TCC Fin du transfert
1 LINK Lien
0 FS Synchronisation

Imen Werda Page 20/51

 CHAPITRE 2. ARCHITECTURE INTERNE DU DSP TMS320C6416

Figure 2.9 – Architecture globale du DSP TMS320C6416

2.5 Jeu d’instruction

La programmation de la plupart des processeurs DSP peut être effectuée en C ou en assembleur pour
exploiter le jeu d’instruction riche qu’offre le TMS320C6416 [4]. La difficulté qu’engendre la programmation
en assembleur par rapport à la programmation en C, est récompensée par l’efficacité d’optimisation en
nombre de cycles obtenue suite à l’exploitation maximale des ressources de la puce. En pratique, on
commence par le codage en langage C d’extension (.c) pour analyser le comportement et la fonctionnalité
d’un algorithme. Ensuite, avec le C6x on peut écrire le code en assembleur linéaire d’extension (.sa) ou en

Imen Werda Page 21/51

 CHAPITRE 2. ARCHITECTURE INTERNE DU DSP TMS320C6416

assembleur optimisé à la main d’extension (.asm). La figure 23 illustre les phases d’évolution d’un fichier
source en un fichier exécutable d’extension (.out).

Figure 2.10 – Evolution d’un fichier source jusqu’à l’exécution

2.5.1 Opérations de transfert de données :

Selon la limite de la donnée (type), l’une des instructions de chargement suivantes peut être utilisée : LDB
pour charger un octet (8 bits), LDH pour charger un demi-mot (16 bits), LDW pour charger un mot (32
bits) ou LDDW pour charger un double mot (64 bits). Les opérations de chargement et de stockage des
données sont effectuées par les unités .D (D1 et D2) car elles sont les seules unités capables d’interagir
avec la mémoire de données.
Il existe plusieurs façons d’effectuer le pré et post déplacement (incrémentation ou décrémentation) d’un
registre lorsqu’il est utilisé comme pointeur [4]. La position de ce dernier peut être modifiée avant ou
après son utilisation (* ++A0 et * A0 ++). De plus, une option de pré-décalage peut être effectuée sans
modification du pointeur (* + A0). Le déplacement offset du pointeur représenté entre parenthèses spécifie
le nombre d’octets. Tandis que si le déplacement est représenté entre deux crochets, il s’effectue selon le
type de données entre crochets spécifie le nombre d’éléments de données. Le registre pointeur et le registre
offset doivent appartenir à la même unité (A ou B) de l’UAL D mise en épreuve (D1 ou D2). Ces options
de décalage de pointeur sont répertoriées dans l’exemple suivant pour offset =2.
- LDB *A0++[2] entraine une incrémentation du pointeur de 2 octets (2x1oct) après le chargement
de 1oct.

Imen Werda Page 22/51

 CHAPITRE 2. ARCHITECTURE INTERNE DU DSP TMS320C6416

- LDH *A0++[2] entraine une incrémentation du pointeur de 4 octets (2x2octs) après le chargement
de 2octs.
- LDW *A0++[2] entraine une incrémentation du pointeur de 8 octets (2x4octs) après le chargement
de 4octs.
- LDDW *A0++[2] entraine une incrémentation du pointeur de 16 octets (2x8octs) après le chargement
de 8octs.
Si les données à traiter ne sont pas sur le même alignement, il faut utiliser LDNW ou LDNDW qui
peuvent lire une valeur de 32 bits, ou respectivement une valeur de 64 bits, à partir de n’importe quelle
limite d’octet. Ainsi, l’alignement sur une limite de 32 bits, ou respectivement de 64 bits, n’est pas requis.
Il est à noter que ce type de chargement de données ne tolère pas un deuxième accès à la mémoire en
parallèle même si l’autre UAL est disponible. L’autre unité .D peut être utilisée en parallèle, à condition
qu’elle ne fait pas appel un accès mémoire [4].

2.5.2 Opérations arithmétiques et logiques :

TABLEAU 2.3 – Instructions simples du TMS320C6416

.L Unit .M Unit .S Unit .D Unit

ABS MPY ADD SET ADD
ADD MPYU ADDK SHL ADDAB
ADDU MPYUS AND SHR ADDAH
AND MPYSU CLR SHRU ADDAW
CMPEQ MPYH EXT SSHL SUB
CMPGT MPYHU EXTU SUB SUBAB
CMPGTU MPYHUS MV SUBU SUBAH
CMPLT MPYHSU MVCT XOR SUBAW
CMPLTU MPYHL MVK ZERO ZERO
LMBD MPYHLU MVKH MV
MV MPYHULS MVKLH
NEG MPYHSLU NEG
NORM MPYLH NOT
NOT MPYLHU OR
OR MPYLUHS
SADD MPYLSHU
SAT SMPY
SSUB SMPYHL
SUB SMPYLH
SUBU
SMPYH
SUBC
XOR
ZERO

Imen Werda Page 23/51

 CHAPITRE 2. ARCHITECTURE INTERNE DU DSP TMS320C6416

Le tableau 2.3 résume les différentes opérations arithmétiques et logiques simples que peut effectuer le
TMS320C6416. Chaque opération peut s’exécuter sur des UALs spécifiques. Je vais juste attirer l’attention
sur l’opération de multiplication. Cette opération est typique pour chaque processeur. En multipliant NBits
xNBits le résultat sera stocké sur 2NBits. Donc généralement le processeur procède à la troncature de NBits
ou bien à la concaténation entre deux registres pour sauvegarder le résultat. Pour le TMS320C6416, il
procède à la troncature des opérandes [4] :
MPY(U/US/SU) : cette instruction assure le multiplication des 16lsb x 16lsb des opérandes. Donc seuls
les 16Bits de poids faible des deux opérandes sont concernés par l’opération de multiplication.
MPYH(U/US/SU) : cette instruction assure le multiplication des 16msb x 16msb des opérandes. Donc
seuls les 16Bits de poids fort des deux opérandes sont concernés par l’opération de multiplication.

2.5.3 Opérations arithmétiques et logiques :

TABLEAU 2.4 – Instructions par paquet du TMS320C6416

.L unit .M unit .S unit .D unit

ABS2 AVG2 SHFL ADD2 ADD2
ADD2 AVGU4 SMPY2 ADDKPC ADDAD
ADD4 BITC4 SSHVL ANDN SUB2
ANDN BITR SSHVR SUB2 ANDN
MAX2 DEAL XPND2 SWAP2
MAXU4 DOTP2 XPND4 UNPKHU4
MIN2 DOTPN2 UNPKLU4
MINU4 DOTPNRSU2
PACK2 DOTPNRUS2 CMPEQ2
PACKH2 DOTPRSU2 CMPEQ4
PACKH4 DOTPRUS2 CMPGT2
PACKHL2 DOTPSU4 CMPGTU4
PACKL4 DOTPUS4 CMPLT2
PACKLH2 DOTPU4 CMPLTU4
SHLMB GMPY4 PACK2
SHRMB MPY2 PACKH2
SUB2 MPYHI PACKHL2
SUB4 MPYIH PACKLH2
SUBABS4 MPYIHR SADDU4
SWAP2 MPYLI SADDSU2
SWAP4 MPYIL SADDUS2
UNPKHU4 MPYLIR SHLMB
UNPKLU4 MPYILR SHR2
MPYSU4 SHRMB
MPYUS4 SHRU2
MPYU4 SPACK2
MVD SPACKU4
ROTL

Imen Werda Page 24/51

 CHAPITRE 2. ARCHITECTURE INTERNE DU DSP TMS320C6416

Le tableau 2.4 résume les différentes opérations arithmétiques et logiques de type SIMD (Single instruction
multiple data) du jeu d’instruction du TMS320C6416. Ces instructions procèdent par paquet et peuvent
exécuter un groupe de sous instructions adaptées au TNS. Les instructions SUBABS4 et DOTPU4 dé-
taillées si dessous sont très utilisées pour les applications TSN pour calculer le critère de comparaison et
pour les opérations de filtrage. SUBABS4 [4] : cette fonction effectue quatre valeurs absolues de différences
en un seul cycle sur 8bits séparément.

Figure 2.11 – Mode de fonctionnement de l’instruction SUBABS4 du TMS320C6416

DOTPU4 [4] : cette fonction effectue la somme de quatre produits sur 8bits séparément, en un seul cycle.
Elle est très utilisée pour les opérations de filtrage ou pour reprendre des calculs sur des valeurs simples
après des instructions par paquet.

Figure 2.12 – Mode de fonctionnement de l’instruction DOTPU4 du TMS320C6416

2.5.4 Opérations de sauts conditionnels : Les boucles

Avec les processeurs C6000, il n’y a pas d’instructions dédiées à la répétition d’un bloc d’instructions.
La boucle est créée par l’instruction B[4]. On commence par initialiser un compteur de boucles. Puis on
incorpore une instruction pour le décrémenter. On personnalise ensuite l’étiquette vers laquelle on veut
brancher. Finalement, on intègre une instruction de branchement conditionnée par la valeur du compteur
de boucles. La condition peut être inversée en ajoutant le symbole d’exclamation " !".
NB : Toute instruction peut être conditionnelle.

Imen Werda Page 25/51

 CHAPITRE 2. ARCHITECTURE INTERNE DU DSP TMS320C6416

2.6 Module d’évaluation

Un module d’évaluation TMS320C6416 DSP Starter Kit (DSK) est très utile car ses caractéristiques
recouvrent celles de l’application du codeur vidéo H264 à développer. Le module est piloté à partir d’un
logiciel adéquat exécuté par un PC. La communication avec le module d’évaluation s’effectue au travers
d’une liaison série. Le programme à tester est téléchargé dans le module pour être exécuté par le DSP.
Comme le simulateur, le module d’évaluation permet de consulter la mémoire et les registres du DSP
à volonté. Il permet également de poser des points d’arrêts simples aux endroits stratégiques du code à
déboguer.

Figure 2.13 – Module d’évaluation TMS320C6416 DSP Starter Kit (DSK)

2.7 Conclusion
La programmation assembleur un DSP demeure une approche très intéressante. Etant donné que les per-
formances de traitement sont cruciales, l’assembleur est le seul langage qui permet d’utiliser toutes les
possibilités spécifiques du DSP. Dans le chapitre suivant on détaillera les principales techniques d’optimi-
sation assembleur.

Imen Werda Page 26/51

 Chapitre 3

Techniques d’optimisation assembleur

3.1 Introduction
L’optimisation en langage d’assembleur implique l’amélioration des performances d’un programme en
ajustant le code source assembleur pour qu’il s’exécute de manière plus efficace. Les techniques courantes
d’optimisation en langage d’assembleur seront exploitées dans ce chapitre. Il faut commencer par effectuer
l’ordonnancement des instructions en réorganisant le code pour réduire les retards dus aux dépendances
de données et améliorer le flux d’exécution. Il est aussi nécessaire de maximiser l’utilisation des registres
pour éviter l’accès à la mémoire. Pour une meilleure performance, il sera indispensable de préparer un bon
design qui permettra d’exploiter le parallélisme d’instructions par paquet.

3.2 Etages d’exécution d’une instruction du DSP TMS320C6416

L’architecture Veloci TI du DSP TMS320C6416 élaborée par TI est basée sur la structure VLIW dont le
paquet fetch renferme 4 instructions de 32 bits chacune.

Figure 3.1 – Technologie VLIW du DSPTMS320C6416

Comme tout processeur, 3 étages sont alloués à l’exécution des instructions : Fetch, Decode et execute. La
figure 3.2 illustre ces étages ainsi que le nombre de cycles nécessaire alloués.

27
 CHAPITRE 3. TECHNIQUES D’OPTIMISATION ASSEMBLEUR

Figure 3.2 – Etages d’exécution d’une instruction du DSPTMS320C6416

Le paquet fetch (PF), formé de 8 instructions, peut contenir 1 PE (si toutes les 8 instructions en //) ou
8 PE (pas d’inststructions en // ). Le LSB d’une instruction (p-bit) indique si la prochaine instruction
appartiennent au même PE (si 1) ou non (si 0). La phase Fetch du processus d’exécution d’une instruction
du DSP TMS320C6416, illustrée par la figure 3.3, nécessite quatre cycles :
PG : Génération de l’adresse par le CPU
PS : Transmission de l’adresse à la mémoire.
PW : Attente de l’accès à la mémoire.
PR : Réception et lecture du PF.

Figure 3.3 – PF d’une instruction du DSPTMS320C6416

La phase de décodage d’une instruction du DSPTMS320C6416, illustré par la figure , se déroule en deux
cycles :
DP : Répartition des instructions d’un PF sous formes de PE.
DC : Décodage des différentes PEs.

Figure 3.4 – Décodage d’une instruction du DSPTMS320C6416

Imen Werda Page 28/51

 CHAPITRE 3. TECHNIQUES D’OPTIMISATION ASSEMBLEUR

La figure 3.7 établit le fait qu’un étage d’exécution d’une instruction du TMS320C6416 peut nécessiter de
un à six cycles, en fonction de l’instruction à exécuter.

Figure 3.5 – Exécution des instructions du DSPTMS320C6416

La majorité des instructions s’exécutent en un seul cycle. Cependant quelques instructions dites longues
nécessitent plus de cycles :

- Les instructions de multiplication qui s’effectuent en deux phases (addition et décalage) nécessitent
deux cycles pour s’exécuter.
- D’autres instructions par paquet comme DOTPU4 nécessitent quatre cycles pour l’exécution.
- Les instructions de chargement et de stockage nécessitent un temps supplémentaire pour permettre
l’accès à la mémoire. Cinq cycles sont alloués pour la phase d’exécution de ces instructions.
- Les instructions de branchement vont entrainer une mise à jours de l’ordre d’exécution des instruc-
tions ce qui explique qu’ils nécessitent 6 cycles pour l’exécution.

3.3 Parallélisme du DSP TMS320C6416

Les DSP possèdent des instructions à usage général et des instructions arithmétiques intensives qui sont
particulièrement convenables pour le traitement du signal et les autres applications numériques intensives.
Pour concrétiser nos connaissances, on va voir à travers un exemple la manière dont le DSPTMS320C6416
exécute des instructions en // et pipelinées. Considérons les trois implémentations suivantes qui assurent
le même fonctionnement :

3.3.1 Implémentation série

Le code présenté ci-dessous assure une exécution en série des différentes instructions : On peut remarquer
que seule l’unité fonctionnelle A est sollicité. Le parallélisme n’est donc pas appliqué ce qui explique qu’il
a nécessité 19 cycles pour achever son exécution.

Imen Werda Page 29/51

 CHAPITRE 3. TECHNIQUES D’OPTIMISATION ASSEMBLEUR

Figure 3.6 – Exécution Série des instructions

3.3.2 Implémentation partiellement parallèle

Le code présenté ci-dessous assure une exécution en partiellement parallèle des différentes instructions :
On peut remarquer qu’en faisant intervenir l’unité fonctionnelle B, quelques exécutions parallèles ont été
instaurées. Le parallélisme n’est donc pas appliqué ce qui explique qu’il a nécessité 19 cycles pour achever
son exécution.

Figure 3.7 – Exécution partiellement parallèle des instructions

Imen Werda Page 30/51

 CHAPITRE 3. TECHNIQUES D’OPTIMISATION ASSEMBLEUR

3.4 Application : Le critère de comparaison SAD

Le SAD (Sum of Absolute Difference) [5] est le critère de comparaison le plus utilisé dans la littérature,
pour les applications vidéo. Contrairement au critère SSD (Sum of Squared Difference), ce dernier ne
considère pas le carré de la différence mais la valeur absolue de la différence entre les pixels correspondant
des deux blocs de dimension D. Ce critère a pour particularité de considérer toutes les différences de la
même manière alors que le critère SSD pénalise davantage les grandes erreurs. L’expression du SAD est
donnée par :
X X
SAD(Br , Bc ) = |Br (i, j) − Bc (i, j)| (3.1)
i=0.....D i=0.....D

Imen Werda Page 31/51

 CHAPITRE 3. TECHNIQUES D’OPTIMISATION ASSEMBLEUR

Figure 3.8 – Schéma descriptif de la fonction SAD

Comme illustré par la figure 3.8,l ’algorithme SAD calcule la somme de la valeur absolu de la différence
entre un bloc source, d’adresse de début SRS et de taille N×N pixels, et d’une région de taille NxN pixels
dans image de référence de résolution CIF (Common Intermediate Format) (352×288) pixels. L’adresse
de début de cette région de l’image référence est REF.
Le code de la fonction SAD en langage C sur une vidéo de résolution CIF, pour N= 2, est donné par :

Unsigned short SAD ( unsigned char *SRC, unsigned char *REF))

{
int i, j ;
unsigned short sad=0 ;
for(i = 0 ; i < N ; i++)
{
for(j = 0 ; j < width ; j++)
sad+= abs( SRC[j+352*i] - REF[j+N*i]) ;
}
return sad ;
}

Si on exécute le programme sur le C64, il consommera 85 Cycles/SAD. Le résultat n’est pas satisfaisant,
voyant de prés le code assembleur généré par le compilateur du CCS. L’affectation des paramètres d’appel
aux registres interne est illustrée si dessous :

Imen Werda Page 32/51

 CHAPITRE 3. TECHNIQUES D’OPTIMISATION ASSEMBLEUR

3.5 Techniques d’optimisation :

3.5.1 Réduire les NOP

La première technique d’optimisation consiste à réduire le nombre de NOP très pénalisant surtout dans
le cas d’une boucle. En réduisant le nombre de NOP on obtient un code qui s’exécute sur 58 cycles. Ce
qui n’est toujours pas satisfaisant surtout quand on passe au SAD 4 × 4 et plus.

Imen Werda Page 33/51

 CHAPITRE 3. TECHNIQUES D’OPTIMISATION ASSEMBLEUR

Imen Werda Page 34/51

 CHAPITRE 3. TECHNIQUES D’OPTIMISATION ASSEMBLEUR

E1 E2 E3 E4 E5 E6 Résultat
MVK A20=0
MVK A14=2
MVK A12=2
LDBU A0=0xF001
LDBU LDBU A2=0xE001
SUB LDBU LDBU A12=1
B L1 LDBU LDBU
NOP B L1 LDBU LDBU
NOP B L1 LDBU
SUB B L1 A4=a0-b0
ABS B L1 A4 = |a0 − b0|
ADD B L1 A20 = |a0 − b0|
LDBU A0=0xF002
LDBU LDBU A2=0xE002
SUB LDBU LDBU A12=0
B L1 LDBU LDBU
NOP B L1 LDBU LDBU
NOP B L1 LDBU
SUB B L1 A4=a1-b1
ABS B L1 A4 = |a1 − b1|
ADD B L1 A20 = |a0 − b0| + |a1 − b1|
SUB A14=1
B L2
ADD B L2 A0=0xF160
NOP B L2
NOP B L2
NOP B L2
NOP B L2
MVK A12=2
LDBU A0=0xF161
LDBU LDBU A2=0xE003
SUB LDBU LDBU A12=1
B L1 LDBU LDBU
NOP B L1 LDBU LDBU
NOP B L1 LDBU
SUB B L1 A4=a2-b2
ABS B L1 A4 = |a2 − b2|
ADD B L1 A20 = |a0 − b0| + |a1 − b1| + |a2 − b2|
LDBU A0=0xF162
LDBU LDBU A2=0xE004
SUB LDBU LDBU A12=0
B L1 LDBU LDBU
NOP B L1 LDBU LDBU
NOP B L1 LDBU
SUB B L1 A4=a3-b3
ABS B L1 A4 = |a3 − b3|
ADD B L1 A20=|a0-b0|+| a1-b1|+|a2-b2|+|a3-b3|
SUB A14=0
B L2
ADD B L2 A0=0xF2C0
NOP B L2
NOP B L2
NOP B L2
NOP B L2
Return A20

Imen Werda Page 35/51

 CHAPITRE 3. TECHNIQUES D’OPTIMISATION ASSEMBLEUR

3.5.2 Utilisation des instructions par paquet

La première technique d’optimisation appliqué à un SAD 4×4 permis une exécution sur plus de 100
cycles. Ce qui n’est toujours pas satisfaisant, on va donc épauler notre implémentation par l’utilisation des
instructions par paquet. En effet l’utilisation des instructions SIMD (Single Instruction, Multiple Data)
permet d’effectuer des opérations sur plusieurs données simultanément, améliorant ainsi les performances
sur les architectures qui les supportent.
Les instructions en question sont :
LDNW,LDW : pour faire le chargement de quatre pixels en une seule lecture.
SUBABS4 : pour faire quatre valeurs absolues de différences en une seule instruction.
DOTPU4 : pour faire la somme des quatre opérations précédemment calculées.

L’exécution pas à pas de ce code est donnée par le tableau suivant :

Imen Werda Page 36/51

 CHAPITRE 3. TECHNIQUES D’OPTIMISATION ASSEMBLEUR

E1 E2 E3 E4 E5 E6 Résultat
MVK A20=0
MVK A12=2
MVK L A11=0x01010101
MVK H A11=0x01010101
LDNW A0=0xF160
LDW LDNW A1=0xE004
NOP LDW LDNW
NOP LDW LDNW
NOP LDW LDNW 4|3|2|1
SUB LDW 3|2|1|0
B 1|1|1|1
SUBABS4
DOTPU4 B
NOP DOTPU4 B
NOP DOTPU4 B
NOP DOTPU4 B A5=4
ADD B A20=4
LDNW A0=0xF2C0
LDW LDNW A1=0xE008
NOP LDW LDNW
NOP LDW LDNW
NOP LDW LDNW 8|7|6|5
SUB LDW 7|6|5|4
B 1|1|1|1
SUBABS4
DOTPU4 B
NOP DOTPU4 B
NOP DOTPU4 B
NOP DOTPU4 B A5=4
ADD B A20=8
LDNW A0=0xF420
LDW LDNW A1=0xE00C
NOP LDW LDNW
NOP LDW LDNW
NOP LDW LDNW 12|11|10|9
SUB LDW 11|10|9|8
B 1|1|1|1
SUBABS4
DOTPU4 B
NOP DOTPU4 B
NOP DOTPU4 B
NOP DOTPU4 B A5=4
ADD B A20=12
LDNW A0=0xF580
LDW LDNW A1=0xE010
NOP LDW LDNW
NOP LDW LDNW
NOP LDW LDNW 16|15|14|13
SUB LDW 15|14|13|12
B 1|1|1|1
SUBABS4
DOTPU4 B
NOP DOTPU4 B
NOP DOTPU4 B
NOP DOTPU4 B A5=4
ADD B A20=16

Imen Werda Page 37/51

 CHAPITRE 3. TECHNIQUES D’OPTIMISATION ASSEMBLEUR

3.5.3 Equilibrer les instructions entre l’unité A et B

Les optimisations appliquées au SAD 4×4 on réduit de 50% la complexité de la fonction. Ce taux d’op-
timisation peut être réduit d’avantage en utilisant toutes les unités offertes par le processeur. En effet,
seules les UAL de l’unité A sont utilisés dans la version précédente. Pour ce fait il faut réaliser un autre
design en créant des pointeurs B0 et B1 pour pointer sur quatre autre pixels en parallèle. Deux designs
seront possibles : ABAB ou AABB.
Dans ce qui suit, on détaillera le design AABB :

Imen Werda Page 38/51

 CHAPITRE 3. TECHNIQUES D’OPTIMISATION ASSEMBLEUR

E1 E2 E3 E4 E5 E6 Résultat
MVK A20=0
MVK A12=2
MVKL A11=0xXXXX0101
MVKH A11=0x01010101
MV B11=0x01010101
ADD B0=0xF2C0
ADD B1=0xE008
LDNW A0=0xF160
LDNW LDNW B0=0xF420
LDW LDNW LDNW A0=0xE004
LDW B0=0xE00C
SUB LDW LDNW A12=1
LDW LDNW
NOP LDW LDNW LDNW A2= 4|3|2|1
LDW
NOP LDW LDNW B2= 12|11|10|9
LDW
NOP LDW A3= 3|2|1|0
LDW B3= 11|10|9|8
B
SUBAB S4 A4= 1|1|1|1
SUBABS4 B4= 1|1|1|1
DOTPU4 B
DOTPU4
NOP DOTPU4 B
DOTPU4
NOP DOTPU4 B
DOTPU4
NOP DOTPU4 B A5= 4
DOTPU4 B5= 4
ADD B A20= 4
ADD B20= 4
LDNW A0=0xF2C0
LDNW LDNW B0=0xF580
LDW LDNW LDNW A0=0xE008
LDW B0=0xE010
SUB LDW LDNW LDNW A12=0
LDW
NOP LDW LDNW LDNW A2= 8|7|6|5
LDW
NOP LDW LDNW B2= 16|15|14|13
LDW
NOP LDW A3= 7|6|5|4
LDW B3= 15|14|13|12
B
SUBAB S4 A4= 1|1|1|1
SUBABS4 B4= 1|1|1|1
DOTPU4 B
DOTPU4
NOP DOTPU4 B
DOTPU4
NOP DOTPU4 B
DOTPU4
NOP DOTPU4 B A5= 4
DOTPU4 B5= 4
ADD B A20= 8
ADD B20= 8
ADD A20= 16

Imen Werda Page 39/51

 CHAPITRE 3. TECHNIQUES D’OPTIMISATION ASSEMBLEUR

3.5.4 Parallèlisme entre les itérations

Les optimisations appliquées au SAD 4×4 ont permis de réduire la consommation de la fonction en nombre
de cycles jusqu’à 36 en modifiant etape4 en titre tu peux prendre à partir de cette phrase et le mettre
après le code assembleur , dans l’autre page. La limitation de ce design est la dépendance de données entre
les instructions. Cette limitation peut être détournée en profitant du parallélisme entre les différentes
itérations, comme détaillé par le design ce dessous :

En appliquant ce design , le code devient comme suit et consomme 16 cycles seulement

Imen Werda Page 40/51

 CHAPITRE 3. TECHNIQUES D’OPTIMISATION ASSEMBLEUR

3.6 Standard assembly :

Le calcul de la fonction du critère de comparaison SAD est trop sollicité, son mappage au cœur de
l’architecture du DSP TMS320C6416 permet d’optimiser le calcul du module de prédiction temporelle.
Cependant, le temps alloué à la programmation est aussi important. Pour équilibrer entre la performance
d’optimisation et le time to market, on peut utiliser l’implémentation standard assemby. Cette implémen-
tation permet de profiter du jeu d’instruction offert par le DSP ainsi que du parallélisme sans faire appel
aux registres du DSP. On peut utiliser le nom des variables en guise de registres. Deux pointeurs seront
appliqués sur le Bloc original : comme illustré par la Figure 3.9, A_src pointe sur la première ligne de
pixels de l’image source et B_src sur la deuxième ligne. En utilisant l’instruction LDW sur les deux unités
D.1 et D.2, nous effectuons le chargement de deux lignes de pixels d’un bloc 4x4. Le même chargement
sera appliqué pour le bloc 4x4 de l’image référence en utilisant l’instruction LDNW utilisé dans le cas des
adresses non linéaires. En effet, la mémoire étant organisée en groupes de quatre octets, les adresses qui ne
sont pas des multiples de quatre (les deux premiers bits sont nuls) sont dites non linéaires. Le traitement
sur les pixels sera effectué en utilisant les instructions par paquet SUBABS4 et DOTPU4 aussi avec des
additions simples, tout en équilibrant leur partitionnement entre les deux unités de calcul de l’UAL A et
B pour assurer un meilleur parallélisme. Consultez le document SPRU189F.pdf pour voir la syntaxe de la
fonction BDEC et intégrer la au code.

Figure 3.9 – Mappage de la fonction SAD 4x4 sur le TSM320C6416

Imen Werda Page 41/51

 CHAPITRE 3. TECHNIQUES D’OPTIMISATION ASSEMBLEUR

L’implementation de code .sa de la fonction SAD ayant comme variables d’entrées :Unsigned short SAD
(unsigned char *src, unsigned int srcPitch, unsigned char *ref, unsigned int refPitch, unsigned int height,
unsigned int width) est donnée par l’annexe. L’interprétation du son fichier SPI "Software pipeline in-
formation" du code (.sa), qui représente la distribution des instructions sur les UAL L, S, D et M des
deux unités A et B, montre que notre code est optimum. En effet, on constate un équilibre parfait de la
répartition des instructions entre les deux unités A et B. Le SPI montre que le kernel de la boucle s’exécute
sur trois cycles avec cinq itérations en parallèles.

Figure 3.10 – Software pipeline information du SAD 4x4

Le SPI résume convenablement le code hand assembly représenté par la figure 3.11. Une phase d’initiali-
sation « EPILOG » est nécessaire pour créer les pointeurs, les données et des variables initiales. On peut
constater qu’ils sont bien répartis sur les deux unitésA et B du DSP. Le « KERNEL » de la boucle prend
trois cycles et atteint le maximum de huit instructions exécutées en parallèle en un seul cycle. Finalement,
la continuité des itérations lancées par le KERNEL achèvent leurs exécutions à la phase « PROLOG ».

Imen Werda Page 42/51

 CHAPITRE 3. TECHNIQUES D’OPTIMISATION ASSEMBLEUR

Figure 3.11 – Version .asm du code SAD4x4

Pour finir, il faut s’assurer que le code et les données d’une boucle de manière à tirer parti de la hiérarchie
de la mémoire cache et à minimiser les accès à la mémoire principale, qui sont généralement plus lents.

3.7 Conclusion
Il est important de noter que l’optimisation en langage d’assembleur peut être complexe et dépend forte-
ment de l’architecture matérielle cible. De plus, dans de nombreux cas, les compilateurs modernes peuvent
effectuer des optimisations automatiques, rendant la programmation en assembleur direct moins néces-
saire dans de nombreux scénarios. Avant de plonger dans l’assembleur, il est généralement recommandé de
profiler et d’optimiser le code à un niveau plus élevé. Justement, l’assembleur linéaire peut offrir un bon
compromis entre l’efficacité du code et l’effort de codage.

Imen Werda Page 43/51

 Annexe
;***************************************************** *******************

Code SA for C64

;***************************************************** *******************

.global _sad_sa64_16x16
_sad_sa64_16x16: .cproc A_src, B_srcPitch, A_ref, B_refPitch, A_height, B_width
En définissant les variables d’entrée, la première sera automatiquement affiliée à un registre de l’Unité
A, la deuxième à un registre de l’Unité B et ainsi de suite. Il est donc préférable d’intégrer l’unité
affiliée au registre au niveau de son nom. Un maximum de Dix variables d’entrée est toléré.

.no_mdep
Pour définir les registres des variables autres que les variables d’entrée, on utilise( .reg)
.reg B_src, B_ref, A_srcPitch, A_refPitch
;A side registers
.reg A_srcPix7654:A_srcPix3210, A_refPix7654:A_refPix3210
.reg A_absDiff3210, A_absDiff7654
.reg A_sumOfAbs, A_srcOffset, A_refOffset
.reg A_packSumOfAbsDiff0, A_packSumOfAbsDiff1
.reg A_const1111
;B side registers
.reg B_srcPix7654:B_srcPix3210, B_refPix7654:B_refPix3210
.reg B_absDiff3210, B_absDiff7654
.reg B_sumOfAbs, B_srcOffset, B_refOffset
.reg B_packSumOfAbsDiff0, B_packSumOfAbsDiff1
.reg B_const1111
.reg loopCntX, loopCntY
****************************************************************************
SHR.1x B_srcPitch, 3, A_srcPitch
SHR.2 B_srcPitch, 3, B_srcPitch
MV.1x B_refPitch, A_refPitch
ADD.2x A_src, 8, B_src
ADD.2x A_ref, 8, B_ref
ZERO.1 A_sumOfAbs
ZERO.2 B_sumOfAbs
 MVKL.1 0x0101, A_const1111
MVKH.1 0x01010101, A_const1111
MV.2x A_const1111, B_const1111
SUB A_height, 2, loopCntY
loopY: .trip 16, 16, 16
LDDW.1 *A_src++[A_srcPitch], A_srcPix7654:A_srcPix3210
LDNDW.1 *A_ref++(A_refPitch), A_refPix7654:A_refPix3210
SUBABS4.1 A_srcPix3210, A_refPix3210, A_absDiff3210
SUBABS4.1 A_srcPix7654, A_refPix7654, A_absDiff7654
DOTPU4.1 A_absDiff3210, A_const1111, A_packSumOfAbsDiff0
DOTPU4.1 A_absDiff7654, A_const1111, A_packSumOfAbsDiff1
ADD.1 A_sumOfAbs, A_packSumOfAbsDiff0, A_sumOfAbs
ADD.1 A_sumOfAbs, A_packSumOfAbsDiff1, A_sumOfAbs
LDDW.2 *B_src++[B_srcPitch], B_srcPix7654:B_srcPix3210
LDNDW.2 *B_ref++(B_refPitch), B_refPix7654:B_refPix3210
SUBABS4.2 B_srcPix3210, B_refPix3210, B_absDiff3210
SUBABS4.2 B_srcPix7654, B_refPix7654, B_absDiff7654
DOTPU4.2 B_absDiff3210, B_const1111, B_packSumOfAbsDiff0
DOTPU4.2 B_absDiff7654, B_const1111, B_packSumOfAbsDiff1
ADD.2 B_sumOfAbs, B_packSumOfAbsDiff0, B_sumOfAbs
ADD.2 B_sumOfAbs, B_packSumOfAbsDiff1, B_sumOfAbs
BDEC loopY, loopCntY
ADD.1x A_sumOfAbs, B_sumOfAbs, A_sumOfAbs
.return A_sumOfAbs
.endproc
TD1 : Interface mémoire et microprocesseur

Exercice1 :
En examinant le câblage de la figure 1(a) et le contenu des cases mémoires adressées par le microprocesseur
figure 1, déterminez le contenu des boitiers mémoires M1 et M2 figure 1.

Figure 1 – Cablage

Exercice2 :
On considère le schéma suivant, représentant l’interconnexion d’un microprocesseur et de trois boîtiers
mémoires (on n’a pas représenté les lignes de lecture et d’écriture) :

46
 1. Indiquer la capacité de chacun des boîtiers mémoire.
2. Donner la taille de la mémoire totale adressable par ce microprocesseur.
3. Donner, pour chaque boîtier mémoire, la plage d’adresses qu’il occupe dans l’espace d’adressage du
microprocesseur.
4. On désire ajouter à ce schéma un quatrième boîtier d’une capacité de 8koct. Comment doit-on
connecter ce boîtier afin qu’il occupe la plage d’adresse E000h-FFFFh ?

Exercice3 :
Soit un microprocesseur 32bits de capacité d’adressage 2Goct, représenter son câblage avec des boitiers
mémoire organisés comme suit :

1. Donnez la cartographie mémoire.

2. Donnez la table de vérité du décodeur d’adresse.
3. DoReprésentez clairement le câblage entre les trois boitiers mémoires et le microprocesseur.
4. On désire ajouter à ce schéma un quatrième boîtier d’une capacité de 64Moct à partir de l’adresse
0B000000h. Qu’elle est l’adresse de fin de ce boitier.
 TD2 : Optimisation Assembleur

Exercice1 :
L’implémentation assembleur de la fonction SumAbsDiff sur le DSP TMS 320C6416 est donnée par :

[Initialisation]
Loop: LDW *A2++, A4
|| LDW *B2++, B4
LDW *A0++[A20], A3
|| LDW *B0++[B20], B3
SUB A14,1,A14
NOPX
[A14 ] B Loop
|| SUBABS4 A3, A4,A5
|| SUBABS4 B3, B4,B5
DOTPU4 A5,A11, A6
|| DOTPU4 B5,B11, B6
NOPY
ADD A6,A10,A10
|| ADD B6, B10,B10
ADD A10, B10, A10
. return A10

1. Déterminez la valeur de X , Y et de A10 finale (SAD).

2. Intégrez les instructions nécessaires à l’initialisation des registres A14, A20, B20, A0, A2, A10, B10,
A11 et B11 : [Initialisation]. 0 c’est la valeur du pixel noir et 1 c’est la valeur du pixel blanc.
3. Effectuez l’exécution pas à pas de ce code jusqu’à atteindre la valeur finale du SAD. NB : Il faut
tenir compte du saut en utilisant les adresses et les valeurs des pixels.
4. Proposez un code assembleur optimal pour cette fonction. (Hand assembly)

48
Exercice2 :

1. Integrez les instructions necessaires à l’initialisation des registres A12, B0, B2, A30, B30,A11, B11.
2. Incorporez les NOPs necessaires au bon fonctionnement du code. N’oubliez pas de placer l’instruction
de branchement avec sa conditionet fixer toutes les UALs utilisées.
3. Effectuez l’exécution pas à pas de ce code en tenant compte des adresses et des valeurs des pixels.
4. Proposez un code optimal du sad 8x8.
 Bibliographie

[1] D. J. Haggège, “Support de cours « microprocesseur » ; 4ème niveau génie electrique,” 2003.
[2] T. Instruments, “Tms320c6000 cpu and instruction set reference guide,” Document technique :
SPRU190D, Fevrier 2001.
[3] T. Instruments, “Writing dsp/bios device drivers for block i/o,” Document technique : SPRA802A,
Fevrier 2003.
[4] T. Instruments, “Tms320c6000 cpu and instruction set reference guide,” Document technique :
SPRU189F, October 2000.
[5] W. J. Vassiliadis S, Hakkennes E .A and P. G.G, “The sum absolute difference motion estimation
acceleator,” 1998.

51