5.1.2 : Main générique

Écrivons le fichier main_function.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 : 



1

#include "randinit.h"


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 :

1

#include "PTensor.h"


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 evaluateFunctionComputation(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

	//Allocation of the tensors
	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

	//Initialisation of the tables
	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);
	//Stating the timer
	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.

1

}


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, evaluateFunctionComputation);


Ceci est la fin du main :

1

}


Le fichier main_function.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

/***************************************
	Auteur : Pierre Aubert
	Mail : pierre.aubert@lapp.in2p3.fr
	Licence : CeCILL-C
****************************************/
#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 evaluateFunctionComputation(size_t nbElement){
	//Allocation of the tensors
	PTensor<float> tensorX(AllocMode::ALIGNED, nbElement);
	PTensor<float> tensorOut(AllocMode::ALIGNED, nbElement);
	//Initialisation of the tables
	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);
	//Stating the timer
	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, evaluateFunctionComputation);
}


Vous pouvez le télécharger ici.