Vous êtes sur la page 1sur 12

Chapitre 5 :

Pipeline matériel

1er Exemple :
Somme des produits
Exemple 1 : Fonction permettant de calculer la somme
de produits 39
Y = ∑a
i=0
i bi

void somme_produit (unsigned char a[40], unsigned char b[40])


{
int i;
int y=0;
for( i=0 ; i < 40 ; i++)
y = y + (a[i] * b[i]);
}

Chapitre 5 Cours DSP 2

1
1er Exemple
Code C Code Assembleur
MVK .S 40, A2
void somme_produit(unsigned char a[40],
unsigned char b[40]) loop: LDH .D *A5++, A0
{ LDH .D *A6++, A1
int x;
int y=0; MPY .M A0, A1, A3
ADD .L A4, A3, A4
for(x=0 ; x < 40 ; x++ )
y = y + (a[x] * b[x]);
SUB .L A2, 1, A2
} [A2] B .S loop
Incrémenter le
pointeur après
chaque chargement STH .D A4, *A7

Chapitre 5 Cours DSP 3

1er Exemple
MVK .S 40, A2
Paquet Fetch : contient 8 instructions de loop: LDH .D *A5++, A0
32 bits chacune. LDH .D *A6++, A1

MPY .M A0, A1, A3


ADD .L A4, A3, A4
SUB .L A2, 1, A2

Comment effectué ce code le pipeline du [A2] B .S loop


C64x :
STH .D A4, *A7
Cycle = 1

Program Fetch Decode Execute Done


PG PS PW PR DP DC E1 E2 E3 E4 E5 E6
MVK
LDH
LDH
MPY
ADD
SUB
B
STH

Chapitre 5 Cours DSP 4

2
1er Exemple
Cycle = 4

Program Fetch Decode Execute Done


PG PS PW PR DP DC E1 E2 E3 E4 E5 E6
MVK
LDH
LDH
FP4 FP3 FP2 MPY
ADD
SUB
B
STH

Cycle = 5
PF Decode Execute Done
PF DP DC E1 E2 E3 E4 E5 E6 √
MVK
LDH
LDH
MPY
ADD
SUB
B
STH

Chapitre 5 Cours DSP 5

1er Exemple
Cycle = 6
PF Decode Execute Done
PF DP DC E1 E2 E3 E4 E5 E6 √
MVK
LDH
LDH
MPY
ADD
SUB
B
STH

Cycle = 7
PF Decode Execute Done
PF DP DC E1 E2 E3 E4 E5 E6 √
MVK
LDH
LDH
MPY
ADD
SUB
B
STH

Chapitre 5 Cours DSP 6

3
1er Exemple
Cycle = 8
PF Decode Execute Done
PF DP DC E1 E2 E3 E4 E5 E6 √
MVK
LDH
LDH
MPY
ADD
SUB
B
STH

Cycle = 9
PF Decode Execute Done
PF DP DC E1 E2 E3 E4 E5 E6 √
MVK
LDH
LDH
MPY
ADD
SUB
B
STH

Chapitre 5 Cours DSP 7

1er Exemple
Cycle = 10
PF Decode Execute Done
PF DP DC E1 E2 E3 E4 E5 E6 √
MVK
LDH
LDH
MPY
ADD
SUB
B
STH

Cycle = 11
PF Decode Execute Done
PF DP DC E1 E2 E3 E4 E5 E6 √
MVK
LDH
LDH
MPY
ADD
SUB
B
STH

Chapitre 5 Cours DSP 8

4
1er Exemple
Cycle = 12
MVK .S 40, A2
PF Decode Execute Done
loop: LDH .D *A5++, A0
PF DP DC E1 E2 E3 E4 E5 E6 √
LDH .D *A6++, A1
MVK
LDH
LDH
MPY .M A0, A1, A3
FP2 MPY ADD .L A4, A3, A4
ADD SUB .L A2, 1, A2
SUB
B [A2] B .S loop
STH
STH .D A4, *A7

Les instructions ADD et MPY s’achèvent au même


cycles alors que les 2 loads ne sont pas accomplies.

Ce code ne fonctionne pas.

Chapitre 5 Cours DSP 9

1er Exemple
Code assembleur simple :
MVK.S1 40, A2 ; Initialiser le compteur de la boucle
MVK.S1 0, A4 ; Initialiser l’accumulateur à 0
loop LDH .D1 *A5++, A0 ; Charger a[i]
LDH .D1 *A6++, A1 ; Charger b[i]

MPY.M1 A0, A1, A3 ; Multiplier a[i] et b[i]

ADD .L1 A4, A3, A4 ; Accumuler la somme a[i] x b[i]


SUB .L1 A2, 1, A2 ; Décrémenter le compteur de la boucle
[A2] B .S1 loop ; Branchement à loop

STH .D1 A4, *A7 ; Stocker la valeur finale

Chapitre 5 Cours DSP 10

5
1er Exemple
Code assembleur simple avec NOP :
MVK.S1 40, A2 ; Initialiser le compteur de la boucle
MVK.S1 0, A4 ; Initialiser l’accumulateur à 0
loop LDH .D1 *A5++, A0 ; Charger a[i]
LDH .D1 *A6++, A1 ; Charger b[i]
NOP 4 ; Attendre fin du chargement
MPY.M1 A0, A1, A3 ; Multiplier a[i] et b[i]
NOP ; Attendre la multiplication
ADD .L1 A4, A3, A4 ; Accumuler la somme a[i] x b[i]
SUB .L1 A2, 1, A2 ; Décrémenter le compteur de la boucle
[A2] B .S1 loop ; Branchement à loop
NOP 5 ; Attendre la fin de la boucle
STH .D1 A4, *A7 ; Stocker la valeur finale

Chapitre 5 Cours DSP 11

D1

1er Exemple
MVK.S1 40, A2
1ére méthode MVK.S1 0, A4 2ème méthode
5 loop LDH .D1 *A5++, A0 1
1 LDH .D1 *A6++, A1 1
0 NOP 4 4
2 MPY.M1 A0, A1, A3 1
0 NOP 1
1 ADD .L1 A4, A3, A4 1
1 SUB .L1 A2, 1, A2 1
6 [A2] B .S1 loop 1
0 NOP 5 5
16 cycles = STH .D1 A4, *A7 = 16 cycles

Nb cycles exécution = (Nb cycles Boucle x 40) + 1 (MVK) + 1(MVK) + 1 (STH)


= (16 x 40) + 1 + 1 + 1
= 643
Chapitre 5 Cours DSP 12

6
Techniques d’optimisation
A fin d’optimiser un code, il faut :

1. Utiliser les instructions en parallèles

2. Supprimer les NOP

3. Utiliser un chargement par mot (LDW) ou double


mots (LDDW)

4. Supprimer la boucle (SUB, B) : loop unrolling

Chapitre 5 Cours DSP 13

1ére étape : Utiliser les instructions en parallèles


Cycle
.D1 .D2 .M1 .M2 .L1 .L2 .S1 .S2 NOP
1 ldh
2 ldh
3 nop
4 nop
5 nop
6 nop
7 mpy
8 nop
9 add
10 sub
11 b
12 Nombre de cycles de nop
13 la boucle = nop
14 nop
15 16 x 40 = 640 nop
16 nop
Chapitre 5 Cours DSP 14

7
1ére étape : Utiliser les instructions en parallèles
Cycle
.D1 .D2 .M1 .M2 .L1 .L2 .S1 .S2 NOP
1 ldh ldh
2 nop
3 nop
4 nop
5 nop
6 mpy
7 nop
8 add
9 loop LDH .D1 *A5++, A0 sub
10 ||LDH .D2 *B6++, B1 b
11 NOP 4 nop
12 MPY .M1x A0, B1, A3 nop
NOP Nombre de cycles de
13 nop
14
ADD .L1 A4, A3, A4 la boucle = nop
SUB .L1 A2, 1, A2
15 [A2] B .S1 loop 15 x 40 = 600 cycles nop
16
Chapitre 5 Cours DSP 15

2éme étape : Supprimer les NOP

loop LDH .D1 *A5++, A0 loop LDH .D1 *A5++, A0


|| LDH .D2 *B6++, B1 || LDH .D2 *B6++, B1
NOP SUB .L1 A2, 1, A2
NOP [A2] B .S1 loop
NOP NOP
NOP NOP
MPY .M1x A0, B1, A3 MPY .M1x A0, B1, A3
NOP NOP
ADD .L1 A4, A3, A4 ADD .L1 A4, A3, A4
SUB .L1 A2, 1, A2 STH
[A2] B .S1 loop
NOP 5
STH

Chapitre 5 Cours DSP 16

8
2éme étape : Supprimer les NOP
Cycle
.D1 .D2 .M1 .M2 .L1 .L2 .S1 .S2 NOP
1 ldh ldh
2 sub
3 b
4 nop
5 nop
6 mpy
7 nop
8 add
9
loop LDH .D1 *A5++, A0
10
||LDH .D2 *B6++, B1
11
SUB .L1 A2, 1, A2
12 [A2] B .S1 loop Nombre de cycles de
13 NOP 2 la boucle =
14 MPY .M1x A0, B1, A3
15 NOP 8 x 40 = 320 cycles
16 ADD .L1 A4, A3, A4
Chapitre 5 Cours DSP 17

3éme étape : Chargement par mot ou double mots


loop LDH .D1 *A5++, A0 ; A0 = a[0] 40 fois
|| LDH .D2 *B6++, B1 ; B1 = b[0]
SUB .L1 A2, 1, A2
20 fois
[A2] B .S1 loop
loop LDW .D1 *A5++, A0 ; A0 = a[0] et a[1]
NOP 2
|| LDW .D2 *B6++, B1 ; B1 = b[0] et b[1]
MPY .M1x A0, B1, A3
SUB .L1 A2, 1, A2
NOP
[A2] B .S1 loop
ADD .L1 A4, A3, A4
NOP 2
MPY .M1x A0, B1, A3 ; A3 = a[0] x b[0]
|| MPYH .M2x A0, B1, B5 ; B5 = a[1] x b[1]
NOP
ADD .L1 A4, A3, A4
|| ADD .L2 B4, B5, B4
; A4 = a[0] x b[0] + a[2] x b[2] + a[4] x b[4] + K
; B4 = a[1] x b[1] + a[3] x b[3] + a[5] x b[5] + K
Chapitre 5 Cours DSP 18

9
3éme étape : Chargement par mot ou double mots
En utilisant un chargement par mot (32 bits), on va
utiliser les instructions MPY et MPYH :

MPY : Multiplication Loop: ; nb itération = 20


16 LSB x 16 LSB LDW .D1 *A5++, A0
|| LDW .D2 *B6++, B1
MPYH : Multiplication SUB .L1 A2, 1, A2
16 MSB x 16 MSB [A2] B .S1 loop
NOP 2
On fait la somme des MPY .M1x A0, B1, A3
deux multiplications || MPYH .M2x A0, B1, B5
Nombre de cycles de NOP
la boucle = ADD .L1 A4, A3, A4
|| ADD .L2 B4, B5, B4
8 x 20 = 160 cycles
Chapitre 5 Cours DSP 19

4éme étape : loop unrolling


LDH .D1 *A5++, A0 ; iteration 1
SUB et B prennent || LDH .D2 *B6++, B1
NOP 4
au minimum 2 cycles MPY.M1x A0, B1, A3
en plus par itération : NOP
ADD.L1 A4, A3, A4
LDH .D1 *A5++, A0 ; iteration 2
|| LDH .D2 *B6++, B1
loop LDH .D1 *A5++, A0 NOP 4
LDH .D1 *A6++, A1 MPY.M1x A0, B1, A3
SUB .L1 A2, 1, A2 NOP
ADD.L1 A4, A3, A4
[A2] B .S1 loop
:
NOP 2 :
MPY .M1 A0, A1, A3 LDH .D1 *A5++, A0 ; iteration 40
NOP || LDH .D2 *B6++, B1
NOP 4
ADD .L1 A4, A3, A4 MPY.M1x A0, B1, A3
NOP
ADD.L1 A4, A3, A4

Chapitre 5 Cours DSP 20

10
2ème Exemple : SAD
Un deuxième exemple qui consiste à déterminer la fonction SAD (Sum of
Absolute Difference) qui est très utilisée en traitement d’image et vidéo :

int sad ( unsigned char a[40], unsigned char b[40] )


{
int x;
int sum=0;
for(x=0; x < 40; x++)
sum = sum + abs(a[x] - b[x]);
return sum;
}

Chapitre 5 Cours DSP 21

3ème Exemple : Interpolation

void interpolation ( char a[40] , short b[39] )

int x;

for(x=0 ; x < 39 ; x++)

b[x] = ( a[x] + a[x+1] + 1 ) / 2 ;

Chapitre 5 Cours DSP 22

11
FIN
Chapitre 5

Chapitre 5 Cours DSP 23

12

Vous aimerez peut-être aussi