4.1.2 : Main générique
Écrivons le fichier main_sqrt.cpp :
Comme ce
main est générique, nous devons ajouter tous les includes qui pouraient s'avérer nécessaires.
Le premier permet d'insérer aléatoirement des valeurs déterminées comme des NaN ou des nombres dénormalisés :
Ensuite, nous devons inclure la bibliothèque qui permet de faire simplement des tests de performances :
1
|
#include "micro_benchmark.h"
|
Enfin, nous devons inclure la bibliothèque qui permet de gérer des tableax alignés automatiquement car ce
main servira pour les tests de performance vectoriés et en fonctions intrisèques :
L'inclusion du
header de calcul doit quant à elle être flexible. Nous allons donc devoir passé la macro
INCLUDE_FUNCTION_NAME qui indiquera au compilateur quel
header utiliser :
1
|
#include INCLUDE_FUNCTION_NAME
|
La fonction qui évaluera les performances de notre calcul ne prend qu'un seule paramètre, le nombre d'éléments dans les tableaux :
1
2
3
4
|
///Get the number of nanoseconds per elements of the Hadamard product
/** @param nbElement : number of elements of the tables
*/
void evaluateSqrt(size_t nbElement){
|
Ensuite, nous allouons les tenseurs en prennant garde de les alignés pour qu'il soient utilisable par les calculs vectoriés et en fonctions intrisèques :
1
2
3
|
PTensor<float> tensorX(AllocMode::ALIGNED, nbElement);
PTensor<float> tensorOut(AllocMode::ALIGNED, nbElement);
|
Nous devons également initialiser nos tenseurs avec des valeurs raisonnable :
1
2
3
4
5
|
tensorOut.fill(0.0f);
for(size_t i(0lu); i < nbElement; ++i){
tensorX.setValue(i, (float)(i*32lu%17lu) + 42.0f);
}
|
Si ce
main est utilisé avec des valeurs exotique nous devons les prendre en compte.
Elles devront être définies par deux macros :
- RATIO_NB_NAN : qui donnera la proportion de nombres exotiques à initialiser dans les tenseurs
- VALUE_DEF : qui donnera la valeur à initialiser dans les tenseurs
Comme cette partie ne doit être activée que dans certains cas, nous devons l'activée que sous certaines conditions :
1
2
3
4
|
#if defined(RATIO_NB_NAN) && defined(VALUE_DEF)
size_t nbNan((size_t)(RATIO_NB_NAN*((double)nbElement)));
setValueInTable(tensorX.getData(), nbElement, nbNan, VALUE_DEF);
#endif
|
Enfin nous devons appeler le test de performance proprement dit, dans ce cas :
- le nom du test de performance, la macro KERNEL_STR_FUNCTION_NAME donnera le nom de la fonction entre guillemets
- fullNbElement : le nombre total d'éléments utilisés (utile si on traite des matrices)
- FUNCTION_NAME : la fonction à appeler qui sera une macro passée au compilateur
- enfin les parametres de la fonction que l'on a appelée (resultat, x, nombre d'éléments)
1
2
3
4
|
size_t fullNbElement(nbElement);
micro_benchmarkAutoNsPrint("evaluate " KERNEL_STR_FUNCTION_NAME, fullNbElement, FUNCTION_NAME,
tensorOut.getData(), tensorX.getData(), nbElement);
|
Cette fonction est maintenant terminée. Place à la fonction
main.
La définition de la fonction
main est classique :
1
|
int main(int argc, char** argv){
|
Nous devons changer le mode de calcul des nombres dénormalisés si besoin :
1
2
3
|
#ifdef DENORM_SET_TO_ZERO
_mm_setcsr(_mm_getcsr() | (_MM_DENORMALS_ZERO_ON));
#endif
|
Nous devons initialiser les aléatoires que si nous en avons besoin :
1
2
3
|
#if defined(RATIO_NB_NAN) && defined(VALUE_DEF)
initRandom();
#endif
|
Enfin, nous appellons la fonction qui permet de traiter plusieurs tailles de vecteurs différents, qui seront passés en paramètres du programme :
1
|
return micro_benchmarkParseArg(argc, argv, evaluateSqrt);
|
Ceci est la fin du
main :
Le fichier
main_sqrt.cpp complet :
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
|
#include "randinit.h"
#include "micro_benchmark.h"
#include "PTensor.h"
#include INCLUDE_FUNCTION_NAME
///Get the number of nanoseconds per elements of the Hadamard product
/** @param nbElement : number of elements of the tables
*/
void evaluateSqrt(size_t nbElement){
PTensor<float> tensorX(AllocMode::ALIGNED, nbElement);
PTensor<float> tensorOut(AllocMode::ALIGNED, nbElement);
tensorOut.fill(0.0f);
for(size_t i(0lu); i < nbElement; ++i){
tensorX.setValue(i, (float)(i*32lu%17lu) + 42.0f);
}
#if defined(RATIO_NB_NAN) && defined(VALUE_DEF)
size_t nbNan((size_t)(RATIO_NB_NAN*((double)nbElement)));
setValueInTable(tensorX.getData(), nbElement, nbNan, VALUE_DEF);
#endif
size_t fullNbElement(nbElement);
micro_benchmarkAutoNsPrint("evaluate " KERNEL_STR_FUNCTION_NAME, fullNbElement, FUNCTION_NAME,
tensorOut.getData(), tensorX.getData(), nbElement);
}
int main(int argc, char** argv){
#ifdef DENORM_SET_TO_ZERO
_mm_setcsr(_mm_getcsr() | (_MM_DENORMALS_ZERO_ON));
#endif
#if defined(RATIO_NB_NAN) && defined(VALUE_DEF)
initRandom();
#endif
return micro_benchmarkParseArg(argc, argv, evaluateSqrt);
}
|
Vous pouvez le télécharger
ici.