Optimisation 2
Directives de compilation
20
Directives de compilation : Pragma
• Les pargmas sont des directives qui fournissent des renseignements au
compilateur sur la manière de générer le code exécutable.
• Avec les pragmas, le code exécutable sera différent de celui généré par défaut.
Section 6.9 de optimizing compiler - spru187v.pdf
21
Pragma : liste
•
•
•
•
•
•
•
•
•
•
•
•
•
CHECK_MISRA (See Section 6.9.1)
CLINK (See Section 6.9.2)
CODE_SECTION (See Section 6.9.3)
DATA_ALIGN (See Section 6.9.4)
DATA_MEM_BANK (See Section 6.9.5)
DATA_SECTION (See Section 6.9.6)
diag_suppress, diag_remark, diag_warning,
diag_error, and diag_default 6.9.7)
FUNC_ALWAYS_INLINE (See Section 6.9.8)
FUNC_CANNOT_INLINE (See Section 6.9.9)
FUNC_EXT_CALLED (See Section 6.9.10)
FUNC_INTERRUPT_THRESHOLD ( 6.9.11)
FUNC_IS_PURE (See Section 6.9.12)
FUNC_IS_SYSTEM (See Section 6.9.13)
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
FUNC_NEVER_RETURNS (See Section 6.9.14)
FUNC_NO_GLOBAL_ASG (See Section 6.9.15)
FUNC_NO_IND_ASG (See Section 6.9.16)
FUNCTION_OPTIONS (See Section 6.9.17)
INTERRUPT (See Section 6.9.18)
LOCATION (EABI only; see Section 6.9.19)
MUST_ITERATE (See Section 6.9.20)
NMI_INTERRUPT (See Section 6.9.21)
NO_HOOKS (See Section 6.9.22)
PACK (See Section 6.9.23)
PROB_ITERATE (See Section 6.9.24)
RESET_MISRA (See Section 6.9.25)
RETAIN (See Section 6.9.26)
SET_CODE_SECTION (See Section 6.9.27)
SET_DATA_SECTION (See Section 6.9.27)
STRUCT_ALIGN (See Section 6.9.28)
22
UNROLL (See Section 6.9.29)
pragma DATA_SECTION
#pragma DATA_SECTION (Variable , Section)
Cette pragma positionne une variable dans une section déterminée de la mémoire
spécifiée dans le fichier de commande .cmd (l’editeur de lien).
Les variables sont déclarées dans un fichier .c ou un fichier .h
short Tab_A[N];
#pragma DATA_SECTION(Tab_A,".mysection")
.mysection doit être spécifié dans le fichier de commande .cmd dans une partie
mémoire de votre choix
23
pragma DATA_SECTION
• Fichier *.cmd :
MEMORY
{
L2SRAM : o = 0x00800000 , l = 0x00080000
MSMCSRAM : o = 0x0C000000, l = 0x00400000
DDR3 : o = 0x80000000, l = 0x20000000
}
SECTIONS
{
.text > L2SRAM
.data > L2SRAM
.cinit > L2SRAM
.const > L2SRAM
... les autres sections
.mysection > MSMCSRAM
}
24
Pragmas et boucles
• Les performances d’une boucle peuvent être optimisées en utilisant
différentes directives pragma.
• Les deux pragmas les plus efficaces utilisées pour passer des
informations sur le déroulement d’une boucle sont :
• MUST_ITERATE et
• UNROLL.
25
Déroulage manuelle d’une boucle
(manual loop unroll)
for (i=0; i<n; i+=2)
{
output[i] = input1[i] + input2[i];
output[i+1] = input1[i+1] + input2[i+1];
}
26
#pragma UNROLL
• Permet de fusionner plusieurs itérations d’une boucle dans une seule, elle
améliore la performance mais augmente la taille du code générée.
• Elle est positonnée juste avant la boucle
#pragma UNROLL(4)
for (i=0; i < count; i++) //count = 256
{
sum = sum + m[i] * n[i];
}
• Specifying #pragma UNROLL(1) asks that the loop not be unrolled. Automatic
loop unrolling also is not performed in this case.
27
#pragma MUST_ITERATE (lower_bound, upper_bound, factor)
peut spécifier une plage pour le nombre d’itérations ainsi qu'un facteur du nombre
d’itérations .
Elle fournit au compilateur des informations sur les itérations :
• lower_bound : définit les itérations totales minimales possibles de la
boucle,
• upper_bound : définit les itérations totales maximales possibles de la
boucle,
• factor : indique au compilateur que l'itération totale est toujours un
multiple entier de ce nombre.
L'un des trois paramètres peut être omis s'il est inconnu, mais si l'une des valeurs
est connue, il est recommandé de fournir cette information au compilateur.
Elle est positionnée juste avant une boucle.
Exemple : #pragma MUST_ITERATE(10, , 2)
28
#pragma MUST_ITERATE (lower_bound, upper_bound, factor)
#pragma MUST_ITERATE(8, 48, 8);
for(i = 0; i < trip_count; i++) { ...
Cet exemple indique au compilateur que la boucle s'exécute entre 8
et 48 fois et que la variable trip_count est un multiple de 8 (8, 16,
24, 32, 40, 48). L'argument factor permet au compilateur de
dérouler la boucle.
29
MUST_ITERATE
• Si le mécanisme qui détermine la sortie de la boucle est complexe, le
compilateur peut ne pas être en mesure de déterminer les propriétés
de la boucle. Dans ce cas, on doit indiquer au compilateur les
propriétés de la boucle en utilisant le pragma MUST_ITERATE.
#pragma MUST_ITERATE(8, 8)
for(i2 = ipos[2]; i2 < 40; i2 +=5)
{
}
...
30
#paragma DATA_ALIGN
DATA_ALIGN aligns symbol declared to an alignment boundary.
The alignment boundary is the maximum of the symbol's default
alignment value. It will cause the symbol to be located at an
address that satisfies the specified alignment requirement :
For example :
#pragma DATA_ALIGN(mybyte, 2)
char mybyte;
will locate mybyte at an even address.
#pragma DATA_ALIGN(mybuffer, 8)
int mybuffer[256];
will locate mybuffer at an address that is evenly divisible by 8
31
Intrinsic : nassert()
• void _nassert (int src); : c’est une fonction intrinsèque.
Elle ne génère pas de code, elle dit au compilateur que
l’expression fournie en argument est vraie
_nassert((int) m % 8 == 0);
_nassert((int) n % 8 == 0);
#pragma MUST_ITERATE(256,1000 ,4)
#pragma UNROLL(4)
Cet'exemple e indique qu'un pointeur y
for (i=0; i < count; i++)
est aligné sur une limite de 8 octets. Cela
{
peut être utilisé pour indiquer au
sum = sum + m[i] * n[i];
compilateur que les instructions SIMD
}
telles que LDDW et STDW doivent être
return(sum);
exécutées.
32
Restrict keyword
dotp_c(short *restrict a, short *b, int count) {
int i;
int sum = 0;
for (i=0; i < count; i++) {
sum = sum + a[i] * b[i]; }
return (sum); }
The restrict keyword tell the compiler that a and b never point to the
same object
33
