Chapitre 4

Implémentation d'algorithmes sur DSP

1
Prof. M. Bouziani
 Architecture du DSP C6x
2

Architecture interne du DSP C6713

Fréquence Horloge :
 300 MHz=2400 MIPS
 1800 MFLOPS
Mémoire interne cache :
 264 Ko
Mémoire externe :
 1 Go
 Mémoire du DSP C6x
3

 Espace Mémoire :
 Un espace adressable de 232bits=4 Go : 0x0000 0000  0xFFFF FFFF

 Espace mémoire interne allant de 0x0000 0000  0x0003 FFFF (256 Ko)
• Espace mémoire cache interne L2

 Espace mémoire mixte allant de 0x0004 0000  0x7FFF FFFF (256 Ko)
• Espace registres périphériques+plusieurs espaces réservés
• Registres Timers, ports McBSP, HPI, GPIO, etc…
GPIO : General Purpose I/O : E/S à usage général
 Mémoire du DSP C6x
4

 Espace Mémoire :
 Espace mémoire externe : 0x8000 0000  0xBFFF FFFF (1Go)
• Espace mémoire externe (EMIF) répartie en 4 Blocks de 256 Mo
• Blocks0 ; CE0, CE1, CE2 et CE3

 Espace mémoire réservée : 0xC000 0000  0xFFFF FFFF (1 Go)

 Exemple :
Cartographie mémoire du DSP TMS320C6713
 Cartographie mémoire du DSP C6713
5
 Cartographie mémoire du DSP C6713
6
 CPU du DSP C6713
7
Les composants du chemin de données pour la
CPU TMS320C67x sont :
 2 piles de registres à usage général (A et B)
 8 unités fonctionnelles (.L1, .L2, .S1, .S2, .M1,
.M2, .D1 et .D2)
 Deux chemins de chargement de données à
partir de la mémoire (LD1 et LD2)
 Deux chemins de stockage de données en
mémoire (ST1 et ST2)
 Deux chemins d'adresses de données (DA1 et
DA2)
 Deux chemins de données de piles de registre
(1X et 2X)
 CPU du DSP C6713
8 Registres à usage général
 Chaque pile contient 16 registres de 32 bits (A0 – A15 pour
la pile A et B0 – B15 pour la pile B) Piles de Registres
Registres A Registres B
 Les registres à usage général peuvent être utilisés pour de
données, des pointeurs d'adresse de données ou des A1:A0 B1:B0
registres de conditions. A3:A2 B3:B2
 Les registres sont utilisés deux à deux pour les données A5:A4 B5:B4
allant de 32, 40 à 64 bits (Virgule flottante double précision) A7:A6 B7:B6
A9:A8 B9:B8
A11:A10 B11:B10
A13:A12 B13:B12
A15:A14 B15:B14
 CPU du DSP C6713
9 Chemins croisés 1X et 2X
 CPU du DSP C6713
10 Chemins croisés T1 et T2
 CPU du DSP C6713
11 Registres de Contrôle
 CPU du DSP C6713
12 Registres de Contrôle

Exemple : MVC .S2 PCE1, B0

 CPU du DSP C6713
13 Registres de Contrôle
 CPU du DSP C6713
14 Registres de Contrôle
 CPU du DSP C6713
15 Registres de Contrôle
 CPU du DSP C6713
16 Registres de Contrôle
 CPU du DSP C6713
17 Timers
 CPU du DSP C6713
18 Port Parallèle HPI
 CPU du DSP C6713
19 Port Parallèle HPI
 CPU du DSP C6713
20 Les Unités Fonctionnelles
Unité Fonctionnelle Opérations à Virgule fixe
Unité L (.L1 et .L2) o Arithmétique 32/40 bits,
o Opérations de comparaison,
o Opérations logiques 32 bits,
o Comptage 32 et 40 bits
Unité S (.S1 et .S2) o Opérations arithmétiques 32 bits,
o Décalages 32/40 bits,
o Opérations logiques 32 bits,
o Génération constante
o Branchements
Unité M (.M1 et .M2) o Opérations de multiplication 16 × 16 bits
o Opérations de multiplication 32 × 32 bits
Unité D (.D1 et .D2) o Génération d'adresse 32 bits linéaire et
circulaire,
o Charge et stocke avec un décalage
constant de 5 bits,
o Chargement et stockage des données
avec un offset de 5 bits (15 bits sur
l’unité .D2),
o Opérations arithmétiques 32 bits
Opérations à Virgule flottante
o Opérations arithmétiques,
o DP → SP, INT → DP, INT → SP,
o Opérations de conversion
o Comparaison,
o Valeur réciproque/absolue/racine carrée,
o Opérations de conversion SP → DP SP et DP,
o Addition/soustraction en SP et DP (src2 -
src1)
o Opérations de multiplication à virgule
flottante,
o Opérations de multiplication à précision
mixte
o Chargement et stockage des données
avec un offset de 5 bits
 CPU du DSP C6713
21 Chemins de données croisés entre registres
Chaque unité fonctionnelle lit et écrit directement dans la pile de registres
figurant dans son propre chemin de données. Autrement dit, les unités .L1,
.S1, .D1 et .M1 écrivent dans la pile de registres A et les unités .L2, .S2, .D2 et
.M2 écrivent dans la pile de registres B.
Les registres d’une pile sont connectées aux unités fonctionnelles de la pile
de registres du côté opposé via les chemins croisés 1X et 2X. Ces chemins
de croisement permettent aux unités fonctionnelles d'un chemin de
données d'accéder à un opérande de 32 bits à partir de la pile de registres
du côté opposé. Le chemin de croisement 1X permet aux unités
fonctionnelles du chemin de données A de lire leur source à partir de la pile
de registres B, et le chemin de croisement 2X permet aux unités
fonctionnelles du chemin de données B de lire leur source à partir de la pile
de registre A.
 CPU du DSP C6713
22 Chemins de mémoire : Lecture/Ecriture
Deux chemins de 32 bits pour charger les données de la mémoire vers la
pile de registres :
 LD1 pour la pile de registres A,
 LD2 pour la pile de registres B,
N.B :
 L'instruction LDDW permet de charger simultanément deux valeurs 32 bits dans la pile registres A et
deux valeurs 32 bits dans la pile B. En effet, pour le côté A, LD1a est le chemin de chargement pour
les 32 LSB et LD1b est le chemin de chargement pour le 32 MSB. Pour le côté B, LD2a est le chemin
de chargement pour les 32 LSB et LD2b est le chemin de chargement pour les 32 MSB.
 Il existe également deux chemins 32 bits, ST1 et ST2, pour stocker les valeurs des registres dans la
mémoire à partir de chaque pile de registres.
 CPU du DSP C6713
23 Mode d’adressage
Les modes d'adressage déterminent comment on peut
accéder a la mémoire (c-à-d comment on peut avoir
accès aux données). Il y a deux types pour l'architecture
C6713 :
 Adressage indirect ou linéaire : tous les registres
peuvent l'utiliser.
 Adressage Circulaire. ( le plus utilisé) avec les registres
de A4-A7 (utilisés par l'unite .D1) et B4-B7 (utilisés par
l'unité .D2).
 Adressage Indirect
24
 *R le registre R contient l'adresse de la mémoire où la donnée est
stockée.
 *R++(d) le registre R contient l'adresse de la mémoire (localisation).
Apres avoir utilise l'adresse mémoire , R sera incrémenté (modifié), de
telle façon à ce que l'adresse courante sera déplacée (incrémentée)
par la valeur de déplacement d : si d=1 (default), la nouvelle adresse est
R+1, ou bien R sera incrémenté directement vers la l'adresse suivante de
la mémoire.
 *++R(d) l'adresse est pré-incrémentée ou bien décalée par "d", de telle
façon à ce que l'adresse courante est R+d.
 *+R(d) l'adresse est pré-incrémentée par "d", de telle façon à ce que
l'adresse courante est R+d (même pour le cas précédent). Cependant,
dans ce cas, R il s'agit de pré-incrémentation de R sans modification
(pas de modification ou mise à jour de R).
 Adressage Circulaire
25

 Ce type d'adressage , appelé aussi adressage modulo est utilisé pour créer
des mémoires buffer circulaires. Crée en hardware, très utilisé par plusieurs
algorithmes de DSP.(filtrage numérique ou pour les algorithmes de
corrélation).
 Le DSP C6x possède un circuit (hardware) spécifique pour utiliser
l'adressage circulaire.
 Adressage Circulaire
26

 Cela implique qu'on a besoin d'avoir les 8 échantillons d'entrée les plus
récents (x[n], x[n-1], x[n-2], …, x[n-7])pour produire un échantillon en sortie;
ces 8 échantillons doivent être stockés en mémoire et mis à jour chaque fois
qu'un nouvel échantillon est acquis. C'est la le principe de l'adressage
circulaire (ou adressage modulo)

L'adressage modulo : à gauche l‘état du buffer à l'instant n à droite à

l'instant n+1 (après un nouveau échantillon)
 Jeux d'instruction TMS320 C6x, Assembleure
27
Le format du code assembleur est représenté comme suit :
Label  [condition ] Instruction .Unit Operandes ; commentaire
 Label : (optionnel) ; représente une adresse ou localisation dans la mémoire,
qui contient une instruction ou une donnée. (lettre ou (_) suivie d'une lettre).
  : si l'instruction est en train de s'exécuter en parallèle par rapport à
l'instruction précédente.
 [ ] : ce champs est optionnel, pour que l'instruction associée soit
conditionnelle : 5 registres conditionnels sont utilisés A1, A2, B0, B1 et B2.
Toutes les instructions de C6X peuvent être conditionnels avec les registres
A1,A2,B0,B1 et B2 en déterminant quand le registre conditionnel est égale à
zero.
 Exemple : [A2] : Exécution de l'instruction associée si A20
[!A2] : Exécution de l'instruction associée si A2=0
 Jeux d'instruction TMS320 C6x, Assembleure
28

 Le champs Instruction peut être soit :

Mnémonique : Instruction actuelle utilisée (en exécution)
Directive Assembleur : commande assembleur : .word valeur : qui
réserve 32 bits dans la mémoire et le remplie par la valeur utilisée.
 Le champs .Unit : une parmi les 8 unités du CPU (optionnel),
 Addition, Soustraction, Multiplication
29

ADD .L1 A3,A7,A7 ; A3+A7 --> A7

SUB .S1 A1,1,A1 ; A1= A1 - 1;
MPY .M2 A7,B7,B6 ; multiplication de 16 LSB de A7*B7 -->B6
|| MPYH .M1 A7,B7,A6 ; multiplication de 16 MSB de A7*B7 --> A6.
 Load/Store
30

LDH .D2 *B2++, B7 ; load(B2)  B7 , Incrémenter B2

|| LDH .D1 *A2++, A7 ; load(A2)  A7, Incrémenter A2
o Charger dans B7 (demi-mot) (16 bits) dont l'adresse dans la mémoire est
donnée/pointée par B2. Ensuite, le registre B2 est incrémenté vers la
prochaine adresse de la mémoire (vers le haut).
o En parallèle, (par le mode d'adressage indirect) load dans A7 le contenu de
la mémoire dont l'adresse est donnée par A2. Ensuite l'adresse de registre A2
est incrémentée vers la prochaine adresse de la mémoire (vers le haut).

o Remarque : L'instruction LDW charge le mot complet 32 bits en utilisant les

deux chemins A et B.
 Branch / Move
31

Loop MVKL .S1 x,A4 ; move 16LSBs of x adress --> A4

MVKH .S1 x,A4 ; move 16MSBs of x adress --> A4
. (;" x " contient maintenant adresse complète de
;32 bits)
.
.
SUB .S1 A1,1,A1 ; decrement A1 (le registre A1
;est utilise comme compteur de la boucle, apres sa
;decrementation avec SUB, on passe a le tester)
[A1] B .S2 Loop ; branch to Loop if A1 # 0
NOP 5 ; five no-operation instructions.
STW .D1 A3,*A7 ; sauvegarde (store) A3 dans (A7)
 Load/Store
32

LDH .D2 *B2++,B7 ; load (B2)--> B7, incremente B2

|| LDH .D1 *A2++,A7 ; load (A2)--> A7, incremente A2
; charge dans B7 le demi-mot (16 bits) dont l'adresse est
specifiée/pointée par B2.
Apres, le registre B2 est incrémenté (post incrémenté) pour
pointer vers l'adresse de mémoire juste supérieure.
En parallèle, autre instruction de mode d'adressage indirecte
charge (load) dans A7 le contenu de la mémoire dont l'adresse est
spécifiée par A2, après A2 est incrémente pour pointer vers
l'adresse de mémoire juste supérieure.
 Branch / Move
33

Remarque :
 L'instruction LDW charge le mot complet (32 bits), dans ce cas
deux chemins " .D1 et .D2 " doivent être utiliser pour charger les
données de la mémoire vers les registres.
 L'instruction LDWW charge deux double-mots (32 bits
simultanément en utilisant des registres dans les deux coté A et B.
 L'instruction LDW stocke le mot de 32 bits A1 dans la mémoire
dont l'adresse est spécifiée par A4 décalé de 20 mots de 32 bits
(80 octets). L'adresse de registre A4 est préincrémentée avec un
décalage (offset), mais elle n'est pas modifiée (++ est utilisé si A4
sera modifié).
 Load/Store
34

Remarque :
 L'instruction LDW charge le mot complet (32 bits), dans ce cas
deux chemins " .D1 et .D2 " doivent être utiliser pour charger les
données de la mémoire vers les registres.
 L'instruction LDWW charge deux double-mots (32 bits
simultanément en utilisant des registres dans les deux coté A et B.
 L'instruction LDW stocke le mot de 32 bits A1 dans la mémoire
dont l'adresse est spécifiée par A4 décalé de 20 mots de 32 bits
(80 octets). L'adresse de registre A4 est préincrémentée avec un
décalage (offset), mais elle n'est pas modifiée (++ est utilisé si A4
sera modifié).
 Commandes Spéciales
35

 Autre que le jeu d'instructions du processeur, il y a des

commandes spéciales à l'assembleur qui commandent
l'assembleur d'effectuer différentes tâches lors du
montage du code.
 Assembly code instructions sont soient des directives ou
des mnémoniques.
Exemple d'une directive : .sect "name" : crée une section
de l'information (donnée ou code)
 Commandes Spéciales
36

 La directive .set directive définit le nom du symbole.

Exemple : count .set 40 ,
l'assembleur remplace count par la valeur 40.
 La directive .ref est utilisée pour déclarer les noms des
symboles définies dans un autre fichier (similaire à extern
dans le langage C)
 La directive .space réserve l'espace mémoire avec la
taille déterminée en octets.
Exemple : buffer .space 128
 Commandes Spéciales
37

.short : pour initialiser un entier de 16 bits.

.int : pour initialiser un entier de 32 bits (aussi .word ou
.long), le compilateur traite la valeur de donnée de type
long comme une valeur de 40 bits, l'assembleur C6x le
considère comme 32 bits.
.float : pour initialiser une constante de 32 bits simple
précision selon la norme IEEE.
.double : pour initialiser une constante de 64 bits double
précision selon la norme IEEE.
 CPU du DSP C6713
38 Paquets Fetch/Execution
Paquet Fetch FP/Paquet Execution EP :
 Un FP a une taille de 256 bits (8 Instruction de 32bits chacune),
 Les instructions du FP peuvent être exécutées en parallèle () ou en série,
 Les instructions exécutées en parallèle () constituent un paquet d’exécution (Execution
Paquet EP),
 Un FP peut avoir :
 1 EP au minimum
 8 EP au maximum

 Chaque instruction dans un FP doit utiliser une unité fonctionnelle différente,

 CPU du DSP C6713
39 Paquets Fetch/Execution
Exemple 1 :
 Ce FP contient 3 EP,
 Les instructions dans un EP exploitent des UF différentes
 CPU du DSP C6713
40 Paquets Fetch/Execution
Paquet Fetch FP/Paquet Execution EP :
 Le bit LSB d’une instruction appelé BIT P () permet de trouver le
nombre de EP dans un FP,
 Si P=1 : L’instruction suivante appartient au même EP,
 Si P=0: L’instruction suivante appartient à un autre EP

 Le BIT P de la dernière instruction du FP est toujours =0.

 CPU du DSP C6713
41 Paquets Fetch/Execution
Paquet Fetch FP/Paquet Execution EP :
 Le bit LSB d’une instruction appelé BIT P () permet de trouver le nombre de EP dans un FP,
 CPU du DSP C6713
42 Paquets Fetch/Execution
Paquet Fetch FP/Paquet Execution EP :
 Le bit LSB d’une instruction appelé BIT P () permet de trouver le nombre de EP dans un FP,
 CPU du DSP C6713
43 Paquets Fetch/Execution
Exemple 2 :
 CPU du DSP C6713
44 Paquets Fetch/Execution
Exemple 3 : Instructions utilisant une même unité fonctionnelle

ADD .S1 A0, A1, A2 ; .S1 est utilisée par les deux instructions
|| SHR .S1 A3, 15, A4 ; ... en même temps, EP non valide

Exemple 4 : Instructions utilisant des UF différents

ADD .L1 A0, A1, A2 ; Les deux instructions utilsent des UF

|| SHR .S1 A3, 15, A4 ; ... différentes, EP valide

N.B : Deux instructions utilisant la même unité fonctionnelle ne

peuvent écrire leurs résultats pendant le même cycle
d'instructions.
 Architecture Pipeline
45
 Dans un CPU l’exécution d’une instructions passe par trois étapes
:
 F: Fetch (recherche et chargement de l’instruction)
 D: Décodage
 E : Exécution
 En fonction du CPU, ces étapes peuvent être effectuées :
 En Série,
 En Parallèle
 L’exécution des instructions en parallèle à une architecture
appelée PIPELINE
 Architecture Pipeline
46
 Dans un CPU l’exécution d’une instructions passe par trois étapes :
 Architecture Pipeline
47 Fetch : répartie en 4 phases
 PG: Program address generate
 PS: Program address send
 PW: Program access ready wait
 PR: Program fetch packet receive
 Architecture Pipeline
48
Décode : les deux phases du décodage
 DP: Instruction dispatch : répartition des instructions vers les unités fonctionnelles
 DC: Instruction decode : Décodage des instructions avant exécution

Dans la phase DP du pipeline, les Fetch paquets sont répartis en

paquets d'exécution (EP). Les paquets d'exécution se
composent d'une instruction ou de deux à huit instructions
parallèles. Pendant la phase DP, les instructions d'un paquet
d'exécution sont affectées aux unités fonctionnelles appropriées.
Dans la phase DC, les registres source, les registres de destination
et les chemins associés sont décodés pour l'exécution des
instructions dans les unités fonctionnelles.
 Architecture Pipeline
49 Décode : les deux phases du décodage
 DP: Instruction dispatch : répartition des instructions vers les unités fonctionnelles
 DC: Instruction decode : Décodage des instructions avant exécution

NOP : aucune instruction n’est dispatchée.

 Architecture Pipeline
50
Execute : Réparti en 10 phases (E1-E10)
 La partie Execute du pipeline est subdivisée en dix phases (E1-E10).
 Différents types d'instructions nécessitent différents nombres de ces phases pour
terminer leur exécution.
 Architecture Pipeline
51
Résumé

Pendant le cycle 7 : les instructions de FPn atteignent E1, les instructions du paquet
d'exécution de FPn+1 sont en cours de décodage. FPn+2 est en répartition tandis que les
FPn+3, n+4, n+5 et n+6 sont chacun dans l'une des quatre phases de recherche de
programme.
 Architecture Pipeline ||
||
LDDW .D1 *A0−−[4],B5:B4 ;
ADDSP .L1 A9,A10,A12
SUBSP .L2X B12,A2,B12
E1 Phase

52 Exemple Execute Packet 

||
||
MPYSP .M1X A6,B13,A11
MPYSP .M2 B5,B13,B11
|| ABSSP .S1 A12,A15
LDDW .D1 *A0++[5],A7:A6 ; DC Phase
|| ADDSP .L1 A12,A11,A12
|| ADDSP .L2 B10,B11,B12
|| MPYSP .M1X A4,B6,A9
|| MPYSP .M2X A7,B6,B9
|| CMPLTSP .S1 A15,A8,A1
|| ABSSP .S2 B12,B15
LOOP:
[!B2] LDDW .D1 *A0++[2],A5:A4 ; DP and PS Phases
||[B2] ZERO .D2 B0
|| SUBSP .L1 A12,A2,A12
|| ADDSP .L2 B9,B12,B12
|| MPYSP .M1X A5,B7,A10
|| MPYSP .M2 B4,B7,B10
||[B0] B .S1 LOOP
||[!B1] CMPLTSP .S2 B15,B8,B1
[!B2] LDDW .D1 *A0−−[4],B5:B4 ; PR and PG Phases
||[B0] SUB .D2 B0,2,B0
|| ADDSP .L1 A9,A10,A12
|| SUBSP .L2X B12,A2,B12
|| MPYSP .M1X A6,B13,A11
|| MPYSP .M2 B5,B13,B11
|| ABSSP .S1 A12,A15
||[A1] MVK .S2 1,B2
[!B2] LDDW .D1 *A0++[5],A7:A6 ; PW Phase
|| [B1] MV .D2 B1,B2
|| ADDSP .L1 A12,A11,A12
|| ADDSP .L2 B10,B11,B12
|| MPYSP .M1X A4,B6,A9
||[!A1] CMPLTSP .S1 A15,A8,A1
|| ABSSP .S2 B12,B1
 Architecture Pipeline
53 Phases de l’étage Exécution
 Architecture Pipeline
54 Phases de l’étage Exécution
 Architecture Pipeline
55 Phases de l’étage Exécution
56 Traitement du signal
Un filtre numérique est un système de traitement
numérique qui agit sur un signal numérique d'entrée
x[n] et produit un autre signal numérique à sa sortie
y[n].
57 Traitement du signal

Dans de nombreux algorithmes DSP, les opérations Somme

des produits ou Multiplier-Accumuler (MAC) sont très
courantes.
Pour une mise en œuvre efficace du fonctionnement
MAC, les processeurs C67x disposent de deux unités de
multiplication .M1 et .M2 et chacune d‘elles peut effectuer
une multiplication de 32 bits à chaque cycle d'horloge.
Par exemple, si nous voulons calculer le produit scalaire de
deux vecteurs de longueur 40 a[n] et x[n], nous devons
calculer:
58 Traitement du signal
y
Quand a[n] et x[n] sont stockés en mémoire, à partir de n=1, nous
devons calculer a[n] x[n] et l'ajouter à y (y est initialement 0) et
répéter ceci jusqu'à n=N. Dans l'assemblage C67x, cette opération
MAC peut être écrite comme suit:
MPY .M a,x,prod
ADD .L y,prod,y
Ici, a, x, prod et y sont des nombres stockés en mémoire et
l'instruction MPY multiplie deux nombres a et x ensemble, en utilisant
l’unité fonctionnelle .M1, et stocke le résultat dans prod. L'instruction
ADD ajoute deux nombres y et prod ensemble, en utilisant l’unité
fonctionnelle .L1, en stockant le résultat vers y.
 Traitement du signal
59 Produit scalaire en virgule fixe en utilisant LDW
 Traitement du signal
60 Produit scalaire en virgule fixe en utilisant LDW
 Traitement du signal
61 Filtre FIR en C
void fir(short x[], short h[], short y[]) sum0 += x3 * h3;
{ sum1 += x4 * h3;
int i, j, sum0, sum1; x5 = x[j+i+5];
short h4 = h[i+4];
x0,x1,x2,x3,x4,x5,x6,x7,h0,h1,h2,h3,h4,h5,h6,h7; sum0 += x4 * h4;
for (j = 0; j < 100; j+=2) { sum1 += x5 * h4;
sum0 = 0; x6 = x[j+i+6];
sum1 = 0; h5 = h[i+5];
x0 = x[j]; sum0 += x5 * h5;
for (i = 0; i < 32; i+=8){ sum1 += x6 * h5;
x1 = x[j+i+1]; x7 = x[j+i+7];
h0 = h[i]; h6 = h[i+6];
sum0 += x0 * h0; sum0 += x6 * h6;
sum1 += x1 * h0; sum1 += x7 * h6;
x2 = x[j+i+2]; x0 = x[j+i+8];
h1 = h[i+1]; h7 = h[i+7];
sum0 += x1 * h1; sum0 += x7 * h7;
sum1 += x2 * h1; sum1 += x0 * h7;
x3 = x[j+i+3]; }
h2 = h[i+2]; y[j] = sum0 >> 15;
sum0 += x2 * h2; y[j+1] = sum1 >> 15;
sum1 += x3 * h2; }
x4 = x[j+i+4]; }
h3 = h[i+3];
 Traitement du signal
62 Filtre FIR en Assembleur
MV .L1X B4,A0 ; point to h[0] & h[1]
|| ADD .D2 B4,4,B2 ; point to h[2] & h[3]
|| MV .L2X A4,B1 ; point to x[j] & x[j+1]
|| ADD .D1 A4,4,A4 ; point to x[j+2] & x[j+3]
|| MVK .S2 200,B0 ; set lp ctr ((32/8)*(100/2))
LDW .D1 *A4++[2],B9 ; x[j+i+2] & x[j+i+3]
|| LDW .D2 *B1++[2],A10 ; x[j+i+0] & x[j+i+1]
|| MVK .S1 4,A1 ; set pointer reset lp cntr
LDW .D2 *B2++[2],B7 ; h[i+2] & h[i+3]
|| LDW .D1 *A0++[2],A8 ; h[i+0] & h[i+1]
|| MVK .S1 60,A3 ; used to reset x ptr (16*4–4)
|| MVK .S2 60,B14 ; used to reset x ptr (16*4–4)
LDW .D2 *B1++[2],A11 ; x[j+i+4] & x[j+i+5]
|| LDW .D1 *A4++[2],B10 ; x[j+i+6] & x[j+i+7]
||[A1] SUB .L1 A1,1,A1 ; dec pointer reset lp cntr
|| MVK .S1 64,A5 ; used to reset h ptr (16*4)
|| MVK .S2 64,B5 ; used to reset h ptr (16*4)
|| ADD .L2X A6,2,B6 ; point to y[j+1]
LDW .D1 *A0++[2],A9 ; h[i+4] & h[i+5]
|| LDW .D2 *B2++[2],B8 ; h[i+6] & h[i+7]
||[!A1] SUB .S1 A4,A3,A4 ; reset x ptr
[!A1] SUB .S2 B1,B14,B1 ; reset x ptr
||[!A1] SUB .S1 A0,A5,A0 ; reset h ptr
|| LDH .D2 *B1,A8 ; x[j+i+8]
ADD .S2X A10,0,B8 ; move to other reg file
|| MVK .S1 5,A2 ; set store lp cntr
MPYLH .M2X A8,B8,B4 ; p10 = h[i+0]*x[j+i+1]
||[!A1] SUB .S2 B2,B5,B2 ; reset h ptr
|| MPYHL .M1X A8,B9,A14 ; p11 = h[i+1]*x[j+i+2]
MPY .M1 A8,A10,A7 ; p00 = h[i+0]*x[j+i+0]
|| MPYLH .M2 B7,B9,B13 ; p12 = h[i+2]*x[j+i+3]
||[A2] SUB .S1 A2,1,A2 ; dec store lp cntr
|| ZERO .L2 B11 ; zero out initial accumulator
[!A2] SHR .S2 B11,15,B11 ; (Bsum1 >> 15)
|| MPY .M2 B7,B9,B9 ; p02 = h[i+2]*x[j+i+2]
|| MPYH .M1 A8,A10,A10 ; p01 = h[i+1]*x[j+i+1]
||[A2] ADD .L2 B4,B11,B4 ; sum1(p10) = p10 + sum1
|| LDW .D1 *A4++[2],B9 ;* x[j+i+2] & x[j+i+3]
|| LDW .D2 *B1++[2],A10 ;* x[j+i+0] & x[j+i+1]
|| ZERO .L1 A10 ; zero out initial accumulato
 Traitement du signal
63 Filtre FIR en Assembleur
LOOP:
[!A2] SHR .S1 A10,15,A12 ; (Asum0 >> 15)
||[B0] SUB .S2 B0,1,B0 ; dec outer lp cntr
|| MPYH .M2 B7,B9,B13 ; p03 = h[i+3]*x[j+i+3]
||[A2] ADD .L1 A7,A10,A7 ; sum0(p00) = p00 + sum0
|| MPYHL .M1X B7,A11,A10 ; p13 = h[i+3]*x[j+i+4]
|| ADD .L2X A14,B4,B7 ; sum1 += p11
|| LDW .D2 *B2++[2],B7 ;* h[i+2] & h[i+3]
|| LDW .D1 *A0++[2],A8 ;* h[i+0] & h[i+1]
ADD .L1 A10,A7,A13 ; sum0 += p01
|| MPYHL .M2X A9,B10,B12 ; p15 = h[i+5]*x[j+i+6]
|| MPYLH .M1 A9,A11,A10 ; p14 = h[i+4]*x[j+i+5]
|| ADD .L2 B13,B7,B7 ; sum1 += p12
|| LDW .D2 *B1++[2],A11 ;* x[j+i+4] & x[j+i+5]
|| LDW .D1 *A4++[2],B10 ;* x[j+i+6] & x[j+i+7]
||[A1] SUB .S1 A1,1,A1 ;* dec pointer reset lp cntr
[B0] B .S2 LOOP ; Branch outer loop
|| MPY .M1 A9,A11,A11 ; p04 = h[i+4]*x[j+i+4]
|| ADD .L1X B9,A13,A13 ; sum0 += p02
|| MPYLH .M2 B8,B10,B13 ; p16 = h[i+6]*x[j+i+7]
|| ADD .L2X A10,B7,B7 ; sum1 += p13
|| LDW .D1 *A0++[2],A9 ;* h[i+4] & h[i+5]
|| LDW .D2 *B2++[2],B8 ;* h[i+6] & h[i+7]
||[!A1] SUB .S1 A4,A3,A4 ;* reset x ptr
MPY .M2 B8,B10,B11 ; p06 = h[i+6]*x[j+i+6]
|| MPYH .M1 A9,A11,A11 ; p05 = h[i+5]*x[j+i+5]
|| ADD .L1X B13,A13,A9 ; sum0 += p03
|| ADD .L2X A10,B7,B7 ; sum1 += p14
||[!A1] SUB .S2 B1,B14,B1 ;* reset x ptr
||[!A1] SUB .S1 A0,A5,A0 ;* reset h ptr
|| LDH .D2 *B1,A8 ;* x[j+i+8]
[!A2] MVK .S1 4,A2 ; reset store lp cntr
|| MPYH .M2 B8,B10,B13 ; p07 = h[i+7]*x[j+i+7]
|| ADD .L1 A11,A9,A9 ; sum0 += p04
|| MPYHL .M1X B8,A8,A9 ; p17 = h[i+7]*x[j+i+8]
|| ADD .S2 B12,B7,B10 ; sum1 += p15
 Traitement du signal
64 Filtre FIR en Assembleur
||[!A2] STH .D2 B11,*B6++[2] ; y[j+1] = (Bsum1 >> 15) || LDW .D1 *A4++[2],B9 ;** x[j+i+2] & x[j+i+3]
||[!A2] STH .D1 A12,*A6++[2] ; y[j] = (Asum0 >> 15) || LDW .D2 *B1++[2],A10 ;** x[j+i+0] & x[j+i+1]
|| ADD .L2X A10,0,B8 ;* move to other reg file ;Branch occurs here
ADD .L1 A11,A9,A12 ; sum0 += p05 [!A2] SHR .S1 A10,15,A12 ; (Asum0 >> 15)
|| ADD .L2 B13,B10,B8 ; sum1 += p16 [!A2] STH .D2 B11,*B6++[2] ; y[j+1] = (Bsum1 >> 15)
|| MPYLH .M2X A8,B8,B4 ;* p10 = h[i+0]*x[j+i+1] ||[!A2] STH .D1 A12,*A6++[2] ; y[j] = (Asum0 >> 15)
||[!A1] MVK .S1 4,A1 ;* reset pointer reset lp cntr
||[!A1] SUB .S2 B2,B5,B2 ;* reset h ptr
|| MPYHL .M1X A8,B9,A14 ;* p11 = h[i+1]*x[j+i+2]
ADD .L1X B11,A12,A12 ; sum0 += p06
|| MPY .M1 A8,A10,A7 ;* p00 = h[i+0]*x[j+i+0]
|| MPYLH .M2 B7,B9,B13 ;* p12 = h[i+2]*x[j+i+3]
||[A2] SUB .S1 A2,1,A2 ;* dec store lp cntr
ADD .L1X B13,A12,A10 ; sum0 += p07
||[!A2] SHR .S2 B11,15,B11 ;* (Bsum1 >> 15)
|| MPY .M2 B7,B9,B9 ;* p02 = h[i+2]*x[j+i+2]
|| MPYH .M1 A8,A10,A10 ;* p01 = h[i+1]*x[j+i+1]
||[A2] ADD .L2 B4,B11,B4 ;* sum1(p10) = p10 + sum1