11/10/2021

Chapitre III Architecture des DSPs

Plan

Généralités sur les DSP

Architecture du TMS320C6x

1
 11/10/2021

Généralités sur les DSP

Définition d’un DSP

DSP = Digital Signal Processor

Processeur de traitement Numérique du Signal

Un DSP est un type particulier de processeur.

Comporte un ensemble de fonctions spéciales destinées à le rendre
particulièrement performant dans le domaine du traitement numérique du
signal (TNS).
Intègre, selon les marques et les gammes des constructeurs, des
mémoires, des timers, des ports série synchrones rapides, des contrôleurs
DMA, des ports d’E/S divers.

2
 11/10/2021

Solutions matérielles pour le TNS

ASIC ASIP DSP GPP

Matériel dédié Matériel générique

Complexité dans le logiciel

Performance pour une application spécifique Flexibilité

Temps réel Consommation d’énergie

Temps de développement

Exemple : DSK C6416

3
 11/10/2021

Applications des DSP

Communications Image / vidéo

Filaire (DSL, cable) Compression/Codage
Sans fil (cellulaires, télévision Composition
numérique, radio numérique) Traitement
Modem
Cryptage
Militaire
Audio Imagerie : radar, sonar…
Mixage et édition Cryptographie
Effets Guidage de missiles
Suppression de bruit Navigation
Annuleur d’echo

Applications des DSP

Biomédical Automatisation
Equipements de monitoring Commande de machines
Signaux biophysiques Contrôle de moteurs
ElectroEncéphaloGramme (EEG) Robots
ElectroCardioGramme (ECG)
Radiographie

Instrumentation Electronique Automobile

Analyseurs de spectre
Générations de fonctions
Analyseurs de régimes
transitoires
Contrôle du moteur
Assistance au freinage
Aide à la navigation
Commandes vocales

4
 11/10/2021

Exemple : EVM DM646

Digital Motor Control

10

10

5
 11/10/2021

Digital Motor Control

11

11

Caractéristiques des DSP

Chemin de données organisé pour traitement du signal

Jeu d’instructions spécialisé

Plusieurs bancs mémoire et plusieurs bus

Modes d’adressage spécialisés

Périphériques spéciaux pour le traitement du signal

Augmentation du parallélisme

12

12

6
 11/10/2021

Caractéristiques des DSP

Augmentation du parallélisme

Calculs
Unités de calcul en parallèle.

Mémoire à accès multiples

Lecture/Écriture de plusieurs données simultanément.

Pipeline
Découpage des instructions de façon à les exécuter à intervalles plus
rapprochés.
13

13

Pipeline
t1 t2 t3 t4 t5 t6 t7 t8 t9
Fetch F1 F2 F3
Decode D1 D2 D3
Execute E1 E2 E3

Exécution sans pipeline

t1 t2 t3 t4 t5 t6 t7 t8 t9
Fetch F1 F2 F3 F4 F5 F6 … … …
Decode D1 D2 D3 D4 D5 D6 … …
Execute E1 E2 E3 E4 E5 E6 …

Exécution avec pipeline

14

14

7
 11/10/2021

Architecture de DSP TMS320C6x

15

15

Spécificités des DSP

Algorithme classique de TNS : Filtre RIF

N 1
y (n)   a (i ) x(n  i )
i 0

Pour chaque cellule a(i) x(n-i) :

Recherche de l’instruction
3 accès en
Recherche du coefficients a(i)
mémoire
Recherche de la donnée x(n-i)

2 accès à l’unité
Multiplication a(i) x(n-i)
de calcul Accumulation a(i+1) x(n-i+1) + a(i) x(n-i)
16

16

8
 11/10/2021

Spécificités des DSP

Objectifs :

Augmenter les accès mémoire simultanés

Réduire le temps des accès mémoire

Réduire le temps des calculs

Instruction MAC
(multiplication-accumulation)
en 1 seul cycle d’instruction

17

17

Évolution des DSP

Comment accélérer les programmes ?

PARALLELISME
Solutions courantes :
SIMD (DSP16xxx,ADSP-2116x, …)
Superscalaire (LSI401Z, ZSP164, …)
VLIW (TMS320 C6x)
DSP améliorés :
DSP multicores
DSP hybrides

18

18

9
 11/10/2021

VLIW : TMS320C6x
VLIW :Very Long Instruction Word
Data path
Deux unités de traitement (1 C62
et 2)

Control
Interrupt
Instruction Fetch Control
Instruction de 32 bits Instruction Dispatch Registers
Instruction Decode Emulation

Unités logique .L :
Arithmétique et comparaisons Data Path 1 Data Path 2
Unité de décalage .S : Register File A Register File B
ALU et Décalage
A15-A0 B15-B0
Unités de multiplication .M :
Multiplication
Unités de données .D : L1 S1 M1 D1 D2 M2 S2 L2
Mouvement de données
de/vers la mémoire

19

19

Unités fonctionnelles

Deux chemins de données : A et B

Chaque chemin contient 4 unités de traitement :
.M : Multiplication
.L : Opération logique et arithmétique
.S : Branchement et manipulation binaire
.D : Chargement et stockage des données
64 registres de 32 bits (A0 à A31) et (B0 à B31)
2 chemins croisés (1x et 2x) (cross path)

Chemin de données A Chemin de données B

Registre A0 à A31 Registre B0 à B31

.L1 .S1 .M1 .D1 .L2 .S2 .M2 .D2

Chemin croisé

20

20

10
 11/10/2021

Contrôleurs d’accès mémoire

DMA (Direct Memory Access) : Contrôleur du transfert des données
entre les plages d’adresse de la mémoire sans l’interférence du CPU. Formé
par 4 canaux programmables et un cinquième auxiliaire. Entre (L1P,L1D) et L2.

EDMA (Enhanced DMA) : Même chose que le DMA mais avec 16 canaux
programmable et une RAM pour la mémorisation de plusieurs configurations
pour des transferts projeté. Entre L2 et la mémoire externe.

HPI (Host Port Interface) : Interface parallèle du processeur host

permettant l’accès direct à l’espace mémoire du CPU pour échanger le
contenu des registres d’état.

EMIF (External Memory InterFace) : Remplace le HPI. Il permet l’échange

asynchrone d’information entre non seulement le CPU et le Processeur host
mais aussi avec l’extérieur à travers les ports d’E/S .

21

21

Mémoire cache de programme (L1P)

Bus de données : 256 bits
Bus d’adresses : 32 bits

Registres de
Extraction du programme (Fetch) contrôle
Répartition des instructions (Dispatch) Contrôleur
de logique
DMA / EMIF Décodage des instructions Testeur
Émulateur
Chemin de données A Chemin de données B Interrupteur
.L1 .S1 .M1 .D1 .L2 .S2 .M2 .D2

Registre A0 à A31 Registre B0 à B31

- Horloge
Mémoire cache de données (L1D) - Ports séries
- Autre
Bus de données : 64 bits périphériques
Bus d’adresses : 32 bits ..Etc

22

22

11
 11/10/2021

Paquet de Fetch et d’Exécution

Basée sur la structure VLIW (Very Long Instruction Word)

Instruction : 4 octets = 32 bits
PE : Paquet Exécutable : groupe d’instructions exécutables en //
pendant un seul cycle.
PF : Paquet Fetch formé de 8 instructions.

1PF peut contenir 1 PE (si toutes les 8 instructions en //)

ou 8 PE (pas d’instructions en // ).
Le LSB d’une instruction (p-bit) indique si la prochaine
instruction appartient au même PE (si 1) ou non (si 0).

23

23

Paquet de Fetch et d’Exécution

Exemple 1 :
Instruction A
Instruction B
Un PF avec 3 PEs le LSB (p-bit) de chaque inst :
Instruction C
Instruction D 31 0 31 0 31 0 31 0 31 0 31 0 31 0 31 0

Instruction E 1 0 1 1 0 1 1 0
Instruction F A B C D E F G H
Instruction G
Instruction H

24

24

12
 11/10/2021

Paquet de Fetch et d’Exécution

Exemple 2 :

25

25

Paquet de Fetch et d’Exécution

Exemple 3 :

Exemple 4 :

26

26

13
 11/10/2021

Pipeline

PG PS PW PR DP DC E1 E2 E3 E4 E5 E6

Fetch Decode Execute

Étapes d’extraction du Programme

(fetch, PF)

PG PS PR
PW
Génération Transmission de Réception et lecture
Attente accès
d’adresse l’adresse du PF
mémoire
Dans le CPU (à la mémoire) (au CPU)

27

27

Pipeline
Étape du décodage
d’instruction (D)

DP
DC
Répartition des instructions
Décodage des PEs
d’un PF sous forme de PE

Étape d’exécution
Jusqu’à 6 cycles et tout (E)
dépend de l’instruction !!

E1 E5
courtes inst (ADD, E2 E3; E4 Chargement E6
SUB, AND, OR, Instruction MPY Slots de des valeurs Branchement
XOR, etc…) retard dans un registre

Etage réservée pour les instructions longues

28

28

14
 11/10/2021

Pipeline
Considérons les 3 exemples suivants :

6 cycles Série Parallèle partielle Parallèle totale

1 cycle B .S1 B .S1 B .S1

MVK .S1 || MVK .S2 || MVK .S2
ADD .L1 ADD .L1 || ADD .L1
2 cycles ADD .L1 || ADD .L2 || ADD .L2
MPY .M1 || MPY .M1 || MPY .M1
5 cycles MPY .M1 MPY .M1 || MPY .M2
LDW .D1 || LDW .D1 || LDW
LDB .D1 || LDB .D2 .D1
|| LDB .D2

29

29

Pipeline
1er exemple : Exécution en série

Cycle = 1
B .S1
MVK .S1 Program Fetch Decode Execute Done
ADD .L1 PG PS PW PR DP DC E1 E2 E3 E4 E5 E6 
B
ADD .L1 MVK
MPY .M1 ADD
ADD
MPY .M1 MPY
LDW .D1 MPY
LDW
LDB .D1 LDB

30

30

15
 11/10/2021

Pipeline

Cycle = 2
B .S1
Program Fetch Decode Execute Done
MVK .S1
PG PS PW PR DP DC E1 E2 E3 E4 E5 E6 
ADD .L1
B
ADD .L1 MVK
ADD
MPY .M1 ADD
FP2
MPY .M1 MPY
MPY
LDW .D1 LDW
LDB
LDB .D1

31

31

Pipeline

Cycle = 3
B .S1
Program Fetch Decode Execute Done
MVK .S1
PG PS PW PR DP DC E1 E2 E3 E4 E5 E6 
ADD .L1
B
ADD .L1 MVK
MPY .M1 ADD
FP3 FP2 ADD
MPY .M1 MPY
MPY
LDW .D1 LDW
LDB .D1 LDB

32

32

16
 11/10/2021

Pipeline

Cycle = 4
B .S1
MVK .S1 Program Fetch Decode Execute Done
ADD .L1 PG PS PW PR DP DC E1 E2 E3 E4 E5 E6 
B
ADD .L1 MVK
MPY .M1 ADD
ADD
MPY .M1 MPY
LDW .D1 MPY
LDW
LDB .D1 LDB

33

33

Pipeline
Un seul PE par cycle entre dans le pipeline en arrivant à l’étape DC (Decode) :

B .S1 Cycle = 5
MVK .S1
PF Decode Execute Done
ADD .L1
PF DP DC E1 E2 E3 E4 E5 E6 
ADD .L1
MPY .M1 B
MVK
MPY .M1 ADD
PF2
LDW .D1 ADD
MPY
LDB .D1 MPY
LDW
LDB

34

34

17
 11/10/2021

Pipeline

Cycle = 6 PF Decode Execute Done

PF DP DC E1 E2 E3 E4 E5 E6 

B + + + + +
MVK +
ADD
PF2 ADD
MPY
MPY
LDW
LDB

35

35

Pipeline

Cycle = 7 PF Decode Execute Done

PF DP DC E1 E2 E3 E4 E5 E6 

B + + + +
MVK +
ADD
PF2 ADD
MPY
MPY
LDW
LDB

36

36

18
 11/10/2021

Pipeline

Cycle = 8 PF Decode Execute Done

PF DP DC E1 E2 E3 E4 E5 E6 

B + + + +
MVK
ADD
PF2 ADD
MPY
MPY
LDW
LDB

37

37

Pipeline

Cycle = 9 PF Decode Execute Done

PF DP DC E1 E2 E3 E4 E5 E6 

B + + +
MVK
ADD
PF2 ADD
MPY
MPY
LDW
LDB

38

38

19
 11/10/2021

Pipeline
2ème exemple : Exécution en parallèle partielle

B .S1 Cycle = 5
|| MVK .S2 PF Decode Execute Done
PF DP DC E1 E2 E3 E4 E5 E6 
ADD .L1
B
|| ADD .L2 MVK
|| MPY .M1 ADD
ADD
MPY
MPY .M1
MPY
|| LDW .D1 LDW
|| LDB .D2 LDB

39

39

Pipeline

B .S1 Cycle = 6
|| MVK .S2 PF Decode Execute Done
PF DP DC E1 E2 E3 E4 E5 E6 
ADD .L1
B + + + + + +
|| ADD .L2 MVK +
|| MPY .M1 ADD
ADD
MPY
MPY .M1
MPY
|| LDW .D1 LDW
|| LDB .D2 LDB

40

40

20
 11/10/2021

Pipeline

PF Decode Execute Done

Cycle = 7
PF DP DC E1 E2 E3 E4 E5 E6 
B + + + + +
MVK

ADD
ADD
MPY

MPY
LDW
LDB

41

41

Pipeline

PF Decode Execute Done

Cycle = 8
PF DP DC E1 E2 E3 E4 E5 E6 
B + + + +
MVK

ADD
ADD
MPY

MPY
LDW
LDB

42

42

21
 11/10/2021

Pipeline

PF Decode Execute Done

Cycle = 9
PF DP DC E1 E2 E3 E4 E5 E6 
B + + +
MVK

ADD
ADD
MPY

MPY
LDW
LDB

43

43

Pipeline

PF Decode Execute Done

Cycle = 10
PF DP DC E1 E2 E3 E4 E5 E6 
B + +
MVK

ADD
ADD
MPY
MPY
LDW
LDB

44

44

22
 11/10/2021

Pipeline
3ème exemple : Exécution en parallèle totale

Cycle = 5
B .S1 PF Execute Done
Decode
|| MVK .S2
PF DP DC E1 E2 E3 E4 E5 E6 
|| ADD .L1
|| ADD .L2 B
MVK
|| MPY .M1 ADD
ADD
|| MPY .M2 MPY
|| LDW .D1 MPY
LDW
|| LDB .D2 LDB

45

45

Pipeline

PF Decode Execute Done

Cycle = 6
PF DP DC E1 E2 E3 E4 E5 E6 

B
MVK
ADD
ADD
MPY
MPY
LDW
LDB

46

46

23
 11/10/2021

Pipeline

PF Decode Execute Done

Cycle = 7
PF DP DC E1 E2 E3 E4 E5 E6 

B + + + + +
MVK
ADD
ADD
MPY +
MPY +
LDW + + + +
LDB + + + +

47

47

Pipeline

PF Decode Execute Done

Cycle = 8
PF DP DC E1 E2 E3 E4 E5 E6 

B + + + +
MVK
ADD
ADD
MPY
MPY
LDW + + +
LDB + + +

48

48

24
 11/10/2021

Pipeline

PF Decode Execute Done

Cycle = 9
PF DP DC E1 E2 E3 E4 E5 E6 

B + + +
MVK
ADD
ADD
MPY
MPY
LDW + +
LDB + +

49

49

Mémoire interne
Program
Cache
(L1P)

Internal
Core RAM or
Cache
EMIF
(L2)

Data
Cache
(L1D)

L1
Level 2
Level 3

50

50

25
 11/10/2021

Mémoire interne
CPU cherche
une donnée

Non Non Copier la donnée

La donnée La donnée
de la mémoire
dans L1 ? dans L2 ?
externe vers L2

Oui Oui

Envoyer la
Copier la donnée
donnée vers
de L2 vers L1
Core

51

51

Mémoire cache L1

L1P DSP L1D

(16ko) C64 (16ko)

L1P : Le C6x contient une mémoire cache programme de 32 bits de bus

d’adresses et de 256 bits (bus de données).
Noté que : 1 PF = 8 instructions = 8 * 32 bits = 256 bits

L1D : Le C64x contient une mémoire cache de données de 64 bits (bus

de données) et de 32 bits (bus d’adresses).
Remarque : Le C62x et le C67x contiennent 32 bits de bus de données.

52

52

26
 11/10/2021

Jeu d’instructions
Arithmétique
1 ADD(U) Addition entière 32/40 bits signée (non signée)
ADD2 2 additions entières 16 bits
ADD4 4 additions entières 8 bits
SUB(U) Soustraction entière 32/40 bits signée (non signée)
SUB2 2 soustractions entières 16 bits
SUB4 4 soustractions entières 8 bits

Nb de cycles
d’exécution

53

53

La somme de deux vecteurs a et b, le résultat dans c

Les contenu des cases de a b et c sont des entiers
Les entiers de a et b ne dépassent pas 100

#include<stdio.h>
Void main()
{
int a[5]={10,100,30,20,100};
int b[5]={10,100,30,20,100};
int c[5],i;
For(i=0;i<5;i++)
C[i]=a[i]+b[i];
}

54

54

27
 11/10/2021

#include<stdio.h>
Void main()
{
Unsigned char a[5]={11,53,88,100,0};
Unsigned char b[5]={11,53,88,100,0};
Unsigned char c[5],i;
For(i=0;i<5;i++)
C[i]=a[i]+b[i];
}

00 110 0 0000
C 0

0000 1000 0000 0000

0 8 0 0

55

55

Jeu d’instructions
Arithmétique
1 ADD(U) Addition entière 32/40 bits signée (non signée)
ADD2 2 additions entières 16 bits
ADD4 4 additions entières 8 bits
SUB(U) Soustraction entière 32/40 bits signée (non signée)
SUB2 2 soustractions entières 16 bits
SUB4 4 soustractions entières 8 bits

Nb de cycles
d’exécution

56

56

28
 11/10/2021

Jeu d’instructions
Multiplication entières
2 MPY 16 LSB signés x 16 LSB signés => 32 bits
MPYH 16 MSB signés x 16 MSB signés => 32 bits
MPYLH 16 LSB signés x 16 MSB signés => 32 bits
MPYHL 16 MSB signés x 16 LSB signés => 32 bits
4 MPYU4 4 Multiplication 8bits par 8 bits, non signé
MPYSU4 4 Multiplication 8bits signé par 8 bits non signé
MPYUS4 4 Multiplication 8bits non signé par 8 bits signé

Nb de cycles
d’exécution

57

57

Jeu d’instructions
Multiplication entières
2 MPY 16 LSB signés x 16 LSB signés => 32 bits
MPYH 16 MSB signés x 16 MSB signés => 32 bits
MPYLH 16 LSB signés x 16 MSB signés => 32 bits
MPYHL 16 MSB signés x 16 LSB signés => 32 bits
4 MPYU4 4 Multiplication 8bits par 8 bits, non signé
MPYSU4 4 Multiplication 8bits signé par 8 bits non signé
MPYUS4 4 Multiplication 8bits non signé par 8 bits signé

Nb de cycles
d’exécution

58

58

29
 11/10/2021

Jeu d’instructions
Accès mémoire
5 LD(B/H/W/DW)(U) Chargement (octet, demi mot, mot,2 mots) signé (non signé)
1 ST(B/H/W/DW)(U) Stockage (octet, demi mot, mot, 2 mots) signé (non signé)
Affectation
1 MV Transfère d’un registre vers un autre registre
1 MVK Transfère une constante 16 bits LSB signée vers un registre
1 MVKH Transfère une constante 16 bits MSB signée vers le MSB
d’un registre
Décalage
1 SHL Décalage gauche 32/40 bits
SHR2 Décalage droit 16 bits signé
SSHL Décalage gauche 32/40 bits avec saturation
SHLMB Décalage gauche et arrangement en octet
SHRMB Décalage droit et arrangement en octet
Branchement
6 B Branchement conditionnel

Nb de cycles
d’exécution
59

59

Jeu d’instructions et unités

.L .M .S .D
ABS MPY ADD2 ADD(U)
ABS2 MPYSU4 AND ADD2
ADD(U) MPYUS4 B AND
ADD2 MPYU4 MVK LDB
ADD4 …… MVKH LDDW
AND OR MVK
MVK SHL OR
OR SHLMB STH
SHLMB SHR2 STDW
SHRMB SHRMB SUB(U)
SUB(U) SUB2 SUB2
SUB2 XOR XOR
SUB4 …… …...
XOR
……

60

60

30
 11/10/2021

Modes d’adressages
Il existe deux différents modes d’adressages :
- Mode linéaire
- Mode circulaire
L’adressage le plus utilisé est le mode linéaire indirect.
Supposant que R est un registre d’adresse :
*R : Le registre R pointe sur une adresse mémoire.
*R++(d) : Le registre R contient une adresse mémoire en plus il y aura une post-
incrémentation c.à.d après une lecture R va s’auto incrémenter par une valeur (d)
qui est 1 par défaut.
*++R(d) : Même chose que le cas précédent mais maintenant une pré-
incrémentation.
*+R(d) : L’adresse est pré-incrémentée de tel sorte que l’adresse actuelle est R+d.
Par contre, R ne va pas être modifier.

61

61

Mode d’adressage circulaire

Utiliser pour créer un tampon circulaire très utilisé dans le TNS : algorithmes de
filtrage, corrélation ..etc.
Il existe deux tampons circulaire indépendants BK0 et BK1 et 8 registres pointeurs : A4-
A7 et B4-B7.
Initialiser le registre du mode d’adressage : AMR pour activer le mode d’adressage
circulaire désiré en spécifiant le mode du registre pointeur et la taille du tampon utilisé.

62

62

31
 11/10/2021

Mode d’adressage circulaire

Exemple : Un filtre RIF à N coefficients

y(n) = a0*x(n) + a1*x(n-1) + a2*x(n-2) + ... + aN-1*x(n-N-1)

Nous constatons la présence implicite des éléments suivants :

Une table de N coefficients : a0 à aN-1.
Une table de N échantillons : x(n) à x(n-N-1)
Pour chaque échantillon résultat y(n) courant, la nécessitée d’effectuer
N opérations MAC.
Une structure itérative, l’échantillon d’entrée x(n) courant devenant
l’échantillon précédant à chaque calcul du nouvel échantillon de sortie y(n).

63

63

Mode d’adressage circulaire

Implémentation de ce filtre sur un DSP TMS320C30 :

64

64

32
 11/10/2021

Mode d’adressage circulaire

Registre AMR :
31 26 25 21 20 16

réservé BK1 BK0

15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0

Mode B7 Mode B6 Mode B5 Mode B4 Mode A7 Mode A6 Mode A5 Mode A4

Mode Description Exemple :

00 Adressage linéaire par défaut Si on désire avoir un tampon
01 Adressage circulaire utilisant BK0 circulaire de 128 octets dans
10
BK1 pointé par le registre B5,
Adressage circulaire utilisant BK1
AMR doit être initialisé à :
11 Réservé
0x00C00800

BK0 et BK1 : N taille du tampon qui sera 2N+1.

65

65

Mode d’adressage circulaire

Registre AMR :
Exemple :
MVK .S2 0x0004, AMR ;LSB 16 bits dans AMR.
MVKH .S2 0x00050000, AMR ;MSB 16 bits dans AMR

0x0004 = (00 00 00 00 00 00 01 00)b dans 16 LSBs de l’AMR :

mode 01
registre A5 utilisant BK0
0x0005 = (000000 00000 00101)b dans 16 MSBs de l’AMR :
N=5
BK0 de taille 2N+1 = 64 octet

66

66

33
 11/10/2021

Syntaxe des instructions

Add / Soustraction / Multiplication :
; A3 + A7  A8
ADD .L1 A3, A7, A8
Si le résultat est stocké dans B8, on choisie l’unité .L2
SUB .S1 A1, 1, A2
; A1 – 1  A2

2 instructions en parallèle :
MPY .M2 A7, B7, B6 ; LSB(A7) * LSB(B7)  B6
|| MPYH .M2 A7, B7, A6 ; MSB(A7) * MSB(B7)  A6

M1

Le choix de l’unité de traitement (1 ou 2) dépend de la destination.

67

67

Syntaxe des instructions

Load / Store :
LDH .D2 *B2++, B7 ; Charger (B2)  B7, Incrémenter B2
LDH .D1 *A2++, A7 ; Charger (A2)  A7, Incrémenter A2
LDH : chargement de 16 bits (H: half word).
LDW : chargement de 32 bits (W: word).

STW .D1 A1, *+A4[20] ; Store A1  (A4) offset par 20

stocké 32 bits de A1 dans une mémoire dont l’adresse est spécifiée par
A4 décalé par 20 mots (32 bits) c.à.d. 80 octets.
Noté que le continu de A4 ne va pas changer après le stockage puisque
une seule + est utilisée.

68

68

34
 11/10/2021

Syntaxe des instructions

Branchement / Move :
MVK .S1 0x20, A1; Move 16 LSBs de 0x20  A1
Move 16 LSBs de 0x10  A4
Loop: MVK .S1 0x10, A4 ;
MVKH .S1 0x15, A4 ; Move 16 de 0x15  16 MSBs A4
…
…
SUB .S1 A1, 1, A1; Décrémenter A1
[A1] B .S2 Loop ; Branchement à Loop si A1≠0
NOP 5; 5 instructions de No-operation
STW .D1 A3, *A7 ; Stocker A3 dans (A7)

69

69

Contraintes
Contrainte chemin croisé :
Le code suivant est valide :
ADD .L1x A1, B1, A0
|| MPY .M2x A2, B2, B3

Le code suivant n’est pas valide :

ADD .L1x A1, B1, A0
|| MPY .M1x A2, B2, B3

M2x

70

70

35
 11/10/2021

Instructions spéciales du C64x

Le jeu d’instruction du C64x offre quelques instructions

fonctionnant avec des données emballées qui peuvent être utilisées
par exemple dans l’algorithme SAD.

Exemples :

PACK2
SUBABS4
DOTP2 / DOTPN2 / DOTPU4
SHRMB
AVGU4

71

71

Instructions spéciales du C64x

SUBABS4 src1, src2, dst : Valeur absolue de la différence 8bits - 8bits

31 24 23 16 15 8 7 0
src1
a_3 a_2 a_1 a_0

SUBABS4
31 24 23 16 15 8 7 0
src2
b_3 b_2 b_1 b_0

31 24 23 16 15 8 7 0
dst
ABS(a_3-b_3) ABS(a_2-b_2) ABS(a_1-b_1) ABS(a_0-b_0)

72

72

36
 11/10/2021

Instructions spéciales du C64x

PACK2 src1, src2, dst : groupement de deux registres 16 bits

31 16 15 0
src1
a_hi a_lo
PACK2
31 16 15 0
src2
b_hi b_lo

31 16 15 0
dst
a_lo b_lo

73

73

Instructions spéciales du C64x

DOTP2 src1, src2, dst : Produit scalaire 16 bits -16 bits

31 16 15 0
src1
a_hi a_lo
DOTP2
31 16 15 0
src2
b_hi b_lo

0
31
dst
(a_hi*b_hi) + (a_lo*b_lo)

74

74

37
 11/10/2021

Instructions spéciales du C64x

DOTPN2 src1, src2, dst : Différence des produits 16 bits-16 bits

31 16 15 0
src1
a_hi a_lo
DOTPN2
31 16 15 0
src2
b_hi b_lo

0
31
dst
(a_hi*b_hi) - (a_lo*b_lo)

75

75

Instructions spéciales du C64x

DOTPU4 src1, src2, dst : Produit scalaires 8 bits – 8 bits

31 24 23 16 15 8 7 0
src1
a_3 a_2 a_1 a_0
DOTPU4
31 24 23 16 15 8 7 0
src2
b_3 b_2 b_1 b_0

0
31
dst
(a_3*b_3) + (a_2*b_2) + (a_1*b_1) + (a_0*b_0)

76

76

38
 11/10/2021

Instructions spéciales du C64x

SHRMB src1, src2, dst : Décalage et concaténation

31 24 23 16 15 8 7 0
src1
a_3 a_2 a_1 a_0
SHRMB
31 24 23 16 15 8 7 0
src2
b_3 b_2 b_1 b_0

31 24 23 16 15 8 7 0
dst
a_0 b_3 b_2 b_1

77

77

Instructions spéciales du C64x

AVGU4 src1, src2, dst : Moyenne 8 bits – 8 bits

31 24 23 16 15 8 7 0
src1
a_3 a_2 a_1 a_0

AVGU4
31 24 23 16 15 8 7 0
src2
b_3 b_2 b_1 b_0

31 24 23 16 15 8 7 0
dst
(a_3+b_3+1)>>1 (a_2+b_2+1)>>1 (a_1+b_1+1)>>1 (a_0+b_0+1)>>1

78

78

39
 11/10/2021

FIN Chapitre III

79

79

40