CHAPITRE 4

Programmation DSP BLACKFIN

Présentation du jeu d’instruction

Voir le PDF Jeu d’instructions

 Les modes arithmétiques
 Introduction
 Le jeu d’instruction BLACKFIN offre des instructions arithmétiques et des modes de calcul

 Ces instructions ont la syntaxe suivante (voir le jeu d’instruction):

◼ Instruction-arithmétique (opt_mode)

 (opt_mode) permet de choisir un mode arithmétique à utiliser, exemple:

◼ (S) : active le mode saturation
◼ (NS) : active le mode sans saturation
◼ (T) : active le mode troncation
◼ Si aucun mode n’est actif, le mode arithmétique par défaut est utilisé
 Les modes arithmétiques
 Transferts Ax → Dreg
 Mode par défaut: Transfert 32bits avec saturation 32bits

 Transferts Ax → Dreg_lo ou Dreg_hi

 Mode par défaut: Q signé + Transfert Ax.H + Saturation 16bits + Arrondi 16bits
 (FU) Fraction unsigned: Q non signé + Transfert Ax.H + Saturation 16bits + Arrondi 16bits
 (T) Troncation : Q signé + Transfert Ax.H + Troncation Ax.L
 (IS) Integer Signed: Entier signé + Transfert Ax.L + Saturation 16bits
 (IU) Integer Unsigned : Entier non signé + Transfert Ax.L + Saturation 16bits
◼ R2.L = A0;
◼ R2.L = A0 (T);
 Les modes arithmétiques
 Addition/soustraction 32bits

 Par défaut ou (NS): Sans saturation 32bits

◼ R5 = R2 + R1 ; // Addition sans saturation et #b de l’instruction 16bits
◼ R5 = R2 + R1(NS) ; // Addition sans saturation et #b de l’instruction 32bits

 (S): Saturation 32bits

◼ R5 = R2 + R1(S) ; // Addition avec saturation 32bits et #b de l’instruction 32bits
 Les modes arithmétiques
 Addition/soustraction 16bits
 Par défaut: Sans saturation
◼ R5.L = R2.L+ R3.H (NS) ; // Addition/Soustraction sans saturation 16bits
◼ R5 = R2 +|- R1 ; // Addition/Soustraction sans saturation 16bits (sans ajout de NS)

 (S): Saturation 16bits

◼ R5.L = R2.L+ R3.H (S) ; // Addition avec saturation 16bits
◼ R5 = R2 +|+ R1 (S) ; // Addition avec saturation 16bits
 Les modes arithmétiques
 Multiplications et MAC

Option Description
Par défaut Opérandes fractionnaires signés + décalage du bit signe

(TFU) Opérandes fractionnaires non-signés + Troncation

(T) Opérandes fractionnaires signés + Troncation

(IS) Opérandes entiers signés

(IU) Opérandes entiers non-signés

 Instructions parallèles
 Parallélisme
 L’architecture du cœur DSP BLACKFIN offre les BUS mémoire L1 suivants :
◼ DA0/LD0 32bits
◼ DA1/LD1 32bits
◼ SD 32bits
◼ IAB 32bits
◼ IDB 64bits
 Instructions parallèles
 Parallélisme
 BUS IDB permet un fetch d’un mot 64bits de 1 à 3 instructions parallèle (||)

 Cela permet un fetch de plusieurs instructions en parallèle (1 cycle d’horloge):

◼ 1 x instruction arithmétique sur MAC0/1 (ou ALU0/1) en même temps
◼ 2 x transferts 32 bits ( 2 lecture ou 1 lecture et 1 écriture)
◼ 2 x mises à jour pointeurs
◼ 2 x mises à jour boucles matérielles
 Instructions parallèles
 Syntaxe en ||
 Le DSP BLACKFIN permet de faire un fetch 64bits sous plusieurs arrangements:

Instruction ALU/MAC 32-bit Instruction 16bits Instruction 16bits

◼ Slot 1 : Instruction ALU/MAC 32bits ou un MNOP (Multiple NOP)

◼ Slot 2 : Instruction Load/Store 16bits ou un NOP
◼ Slot 3 : Instruction Load/Store 16bits ou un NOP

Les NOP/MNOP sont insérés automatiquement via l’assembleur

 Instructions parallèles
 Instructions possibles sur le slot 1
 Les instructions ALU/MAC 32-bit qui occupent le slot 1 :
◼ Addition/soustraction 16bits et 32bits

◼ Addition/soustraction avec saturation

◼ Multiplication/MAC

◼ Transferts Ax  → Dreg

◼ Transferts Dreg_hi_lo

◼ Auto-incrément/décrément Ax
 Instructions parallèles
 Instructions possibles sur le slot 2 et le slot 3

 Les instructions 16bits suivantes occupent le slot 2 et slot 3:

◼ Lecture/Ecriture via pointeur Preg

◼ Lecture/Ecriture via pointeur Ireg
 Instructions parallèles
 Exemples
 2 accés mémoires en paralléle

◼ MNOP || R1 = [I0++] || R3 = [I1++] ; // 2 lectures mémoire en méme temps

Les MNOP sont insérés automatiquement via l’assembleur

 Addition 16bits + incrément Ireg + lecture mémoire via Ireg

◼ R2 = R2 +|+ R4, R4 = R2 -|- R4 || I0 += M0 || R1 = [I0] ;

 Instructions parallèles
 Exemples

 2 x MAC + tranfert Dreg_lo_hi + 1 load via Preg + 1 load via Ireg

◼ R3.H=(A1+=R0.L*R1.H), R3.L=(A0+=R0.L*R1.L) || R0=[P0++] || R1=[I0] ;

 2 x MAC + tranfert Ax + 1 load via Ireg + 1 store via Ireg

◼ A1=R2.L*R1.L, A0=R2.H*R1.H || R2.H=W[I2++] || [I3++]=R3;

 Limitations du jeu d’instruction
 Transferts Ax vers Dreg ou Dreg_lo_hi
 L’accumulateur A0 doit être utilisé avec des registres paires Dreg_even ou Dreg_lo
 L’accumulateur A1 doit être utilisé avec des registres impaires Dreg_odd ou Dreg_hi

◼ Exemples:
R3 = A1; // R impaire
R5.L = A0
R2 = (A0 += R0.L*R1.L);
R5.H = (A1 += R1.L*R2.L);
 Limitations du jeu d’instruction
 2x MAC vers 2x Dreg
 Les registres destination doivent êtres des paires proches:
◼ R1/R0 ou R3 et R2 …. etc…

 Exemples:

R3 = (A1 += R0.H*R1.L) , R2=(A0 += R0.L*R1.L);

R5 = (A1 += R1.H*R2.L) , R4=(A0 += R1.L*R2.L);
Flot de développement
 Flot de développement
 Compilation et assemblage
 Flot de développement
 Exemple assemblage en ASM
 Flot de développement
 Exemple compilation en C
 Flot de développement
 Exemple compilation en C sous différentes sections
 Interface ASM-C/C++
 Interface C/C++/ASM

 Le DSP Blackfin peut être programmé en ASM ou en C/C++.

 Pour atteindre un rendement maximum en terme de performances, il est possible d’utiliser

un mix de fonctions C/C++ et de routines ASM à travers des interfaces prédéfinis.

 Ces interfaces peuvent être définies comme un:

◼ Programme C/C++ qui appel une fonction ASM
◼ Programme ASM qui appel une fonction C/C++
◼ Programme ASM qui associe des variables C/C++ comme symboles ASM
◼ Programme C/C++ qui utilise de l’assembleur in-line (instructions assembleurs en C)
 Interface ASM-C/C++
 Convention ASM → C
 Appel d’une variable/fonction ASM en C :
C ASM
.global _asm_func;
extern void asm_func(….); …………
_asm_func:
extern int asm_var; .global _asm_func;

◼ L’appel d’une fonction/variable ASM en C exige que:

◼ Son nom en ASM doit étre précédé d’un tiret
◼ Déclarées comme globales en ASM et comme externes en C
 Interface ASM-C/C++
 Convention C → ASM
 Appel d’une variable/fonction ASM en C :
C ASM
void c_func(….); .extern _c_func;
int c_var ; // variable globale .extern _asm_func;

◼ L’appel d’une fonction/variable C en ASM exige que:

◼ Son nom en ASM doit étre précédé d’un tiret
◼ Déclarées comme globales en C et comme externes en ASM
 Interface ASM-C/C++
 Appel d’une routine ASM en C
 Soit une fonction:
_MafonctionASM (Arg1, Arg2, …. );

 Passage des arguments C → fonction ASM:

◼ Arg1 → R0
◼ Arg2 → R1
◼ Arg3 → R2
◼ Arg4 et plus: sur le stack ([FP+20], [FP+24], [FP+28] ….etc….)

◼ Valeur de retour 32bits sur R0

◼ Valeur de retour 64bits sur R1:R0
 Interface ASM-C/C++
 Appel d’une routine ASM en C

 Une fonction ASM appelée en C ne peut utiliser librement les registres DSP

 Ces registres sont donc classés en registres:

◼ Compilateurs
◼ Préservés
◼ Indépendants
 Interface ASM-C/C++
 Appel d’une routine ASM en C

 Registres compilateur

◼ Ce sont les registres L0-L3 et les pointeurs de pile SP et FP

◼ Ces registres sont réservés à un usage exclusive par le compilateur C/C++

◼ A chaque appel ou retour d’une fonction ASM:

◼ SP et FP doivent être remis à leurs valeurs initiales avant retour d’une fonction ASM
◼ L0-L3 doivent être remis à 0 en cas d’utilisation par la fonction ASM
 Interface ASM-C/C++
 Appel d’une routine ASM en C

 Registres préservés

◼ Ce sont les registres R4-R7 et P3-P5

◼ A chaque appel fonction ASM, il faudra sauvegarder leurs valeurs
◼ A chaque retour fonction ASM, il faudra restaurer leurs valeurs
 Interface ASM-C/C++
 Appel d’une routine ASM en C

 Registres indépendants

◼ Ce sont les registres:

◼ R0-R3
◼ Accumulateurs
◼ ASTAT
◼ P0-P2
◼ Registres DAG sauf les Lreg
◼ Registres des boucles matérielles

◼ Ces registres peuvent être utilisés par une fonction ASM appelée en C sans aucune restriction
particulière
 Interface ASM-C/C++
 Assembleur in-line

 Un programme C peut utiliser la syntaxe assembleur sans faire appel à une interface ASM-
C en utilisant directement une construction asm( )

◼ asm(“R0 = W[P0];”);
◼ asm(“BITSET(R0,7);”);
◼ asm(“SSYNC;”);

 L’utilisation d’instructions ASM est également possible via des fonctions C précompilées:
◼ Exemple routine assembleur MAC ASM en C :
add_fr1x32 (acc , mult_fr1x32 (in[i] , coeff[i] ) ) ;
 Optimisation du code
 Densité du code vs Performances
 Il existe plusieurs façons d’utiliser les instructions en || afin d’optimiser son code
Exemple d’optimisation de la densité du code:
◼ R6=(A0+=R3.H*R2.H); // 32-bits
I2 -=M0 ; // 16-bits
◼ #Cycles: 2 cycles Taille du code: 6 octets

Exemple d’optimisation de la vitesse d’exécution:

◼ R6=(A0+=R3.H*R2.H) (FU) || I2 -=M0
◼ #Cycles: 1 cycle Taille du code: 8 octets
 Optimisation du code
 Optimisation en C
 Afin d’optimiser son code C il faut tous d’abord bien mettre au point son code C en suivant
les recommandations suivantes:

◼ Mettre les tableaux dans deux sections différentes en mémoire

◼ Eviter d’utiliser des variables globales comme condition dans une boucle
◼ Eviter les boucles avec un pas différent de 1
◼ Eviter d’inclure des instructions de conditions dans une boucle
◼ Utiliser les fonctions assembleurs compilés en C le plus possible
 Optimisation du code
 Optimisation en C
 Après avoir suivis ces recommandations, le code C est prêt à être optimisé par la CLI du
compilateur ou par l’ajout de directives pragmas spécifiques pour chaque section du code:

◼ #pragma optimize_for_space
…………………………….
…………………….
◼ #pragma optimize_for_space
…………………………………
……………………………….
 Optimisation du code
 Optimisation en ASM
 L’utilisation de l’assembleur est plus efficace que la programmation en C pour les fonctions
critiques dans le code. Cela offre au programmeur plus de contrôle sur le DSP

 L’optimisation ASM suit donc les recommandations suivantes:

◼ Eviter les boucles software
◼ Utiliser les deux unités MAC en même temps
◼ Fetch des instructions en parallèle au maximum
◼ Utiliser des sections différentes pour les tableaux de données
◼ Utiliser le pipeline en software
◼ Eviter les différents stalls qui peuvent avoir lieu