méta-programmation et chronomètre

**salseropom** · 03/08/2009, 11h42

Bonjour,

je développe des coeurs de calculs (résolution d'équations) et je suis donc très intéressé par la minimisation des temps de calculs. J'ai lu l'article de Laurent Gomila sur la méta-programmation (http://loulou.developpez.com/tutoriels/cpp/metaprog/). Cet article est très clair mais j'ai cependant quelques questions :

1) tout doit connu par le compilateur. Certes. Mais dans mon cas toutes mes inputs sont lues à partir de fichiers texte (les fichiers d'initialisation). Donc le prétraitement consiste à lire ces fichiers, le traitement à effectuer les calculs et le post traitements à la visualisation graphique des résultats. Mais donc, à la compilation, rien n'est connu par le compilateur car tout est lu à partir de fichiers texte. Comment appliquer la méta-programmation ? Car les exemples donnés par Laurent Gomila dans son article sont donnés pour comprendre ce qu'est la méta-programmation. Il est rare de calculer factorielle(4). En général on fait plutôt factorielle(n) où n est lu à partir d'un fichier texte (donc inconnu à la compilation)

2) dans son article, Laurent Gomila utilise des struct et des enum. Sur le site suivant http://fr.wikipedia.org/wiki/C_plus_plus il y a un exemple de méta-programmation :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
 
template< size_t N >
struct CalcCompileTime
{
    static size_t Fact = N * CalcCompileTime< N - 1 > ;
};
 
template<0>
struct CalcCompileTime<0>
{
    static size_t Fact = 1 ;
};

que vaut-il mieux utiliser : les enums ou les static ?

3) j'ai codé un exemple donné par Laurent Gomila (le cosinus). C'est plus lent que le "simple" cosinus de <cmath> (d'un facteur 10). Où se trouve mon erreur ? Les fichiers sont en pièce jointe

4) La méta-programmation étant plus rapide que la programmation "normale", j'en déduis donc qu'il vaut mieux utiliser des librairies de calculs comme Boost plutôt que lapack non ?

Merci pour vos réponses, et je vais continuer à étudier de près cette technique de programmation car elle m'a l'air très intéressante !

Code main.cpp :

Sélectionner tout - Visualiser dans une fenêtre à part

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
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
#include <cmath>
#include <iostream>
 
using namespace std;
 
double GetClock ( void );
 
#define ITERMAX 1000000
 
 
template <int I> inline double Factorielle()
{
    return I * Factorielle<I - 1>();
}
 
template <> inline double Factorielle<0>()
{
    return 1.0;
}
 
template <int N> inline double Puissance(double x)
{
    return x * Puissance<N - 1>(x);
}
 
template <> inline double Puissance<0>(double x)
{
    return 1.0;
}
 
// Ici aussi, N resprŽsente l'ordre de dŽveloppement
 
template <int N> inline double Cosinus(double x)
{
    return Cosinus<N - 1>(x) + (N % 2 ? -1 : 1) * Puissance<2 * N>(x) / Factorielle<2 * N>();
}
 
template <> inline double Cosinus<0>(double x)
{
    return 1.0;
}
 
int main(void)
{
  double x = 3.14159265358979;
  double sum = 0.;
  double start, end;
  double d;
 
  cout<<"version non metaprogrammation"<<endl;
 
  for(int i = 0 ; i < ITERMAX ; i++)
  {
	start = GetClock();
	d = cos(x);
	end = GetClock();
	sum += end - start;
  }
 
  cout<<"d = "<< d <<endl;
 
  cout<<"chrono = " << sum / ITERMAX << endl;
 
  cout<<"version metaprogrammation"<<endl;
 
  sum = 0.;
 
  for(int i = 0 ; i < ITERMAX ; i++)
  {
	start = GetClock();
	d = Cosinus<7>(x);
	end = GetClock();
	sum += end - start;
  }
 
  cout<<"d = "<< d <<endl;
 
  cout<<"chrono = " << sum / ITERMAX << endl;
 
  return 0;
}

Code chrono.cpp :

Sélectionner tout - Visualiser dans une fenêtre à part

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
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
/******************************************************************************
 *                                                                            *
 *                           Import Header Files                              *
 *                                                                            *
 ******************************************************************************/
 
#include<stdlib.h>
#include<stdio.h>
#include <time.h>
#include <sys/time.h>
#if defined LINUX || defined MAC
#define UNIX
#include <unistd.h>
#endif
 
#include<string.h>
#include <errno.h>
 
/******************************************************************************
 *                                                                            *
 *                             Private Macros                                 *
 *                                                                            *
 ******************************************************************************/
 
#define CLOCKERROR    \
do                    \
{                     \
  fprintf( stderr, "%s:%d : GetClock() failed (%s)\n",__FILE__,__LINE__,strerror( errno ));\
  exit(EXIT_FAILURE); \
}                     \
while(0)
 
/******************************************************************************
 *                                                                            *
 *                      Public Functions Implementation                       *
 *                                                                            *
 ******************************************************************************/
 
double GetClock ( void )
{
/*
  This function returns the time (like clock()), but it returns the absolute
  real time (whereas clock() returns the time compared to the program). It
  returns the time in seconde with a precision until the micro-seconde.
 
  It returns -1 if there was an error
  
  source : http://www.developpez.net/forums/showthread.php?t=324756
 
 */
 
  double d=-1. ;
#ifndef UNIX
#ifdef WINDOWS
  struct timeval tval ;
  struct timezone *tz=NULL ;
  timerclear(&tval);
 
  if ( gettimeofday(&tval, tz) ) CLOCKERROR;
 
  d = ((double)(tval.tv_usec)/1000000.0) ;
  d = (double) tval.tv_sec + d ;
#else /* neither WINDOWS nor UNIX are defined */
  struct timespec cur_time ;
 
  if (clock_gettime(CLOCK_REALTIME, &cur_time)) CLOCKERROR;
 
  d = ((double)(cur_time.tv_nsec)/1000.0) / 1000000.0 ;
  d = (double) cur_time.tv_sec + d ;
#endif /* end #ifdef WINDOWS */
#else  /* UNIX is defined */  
  struct timeval tval ;
  struct timezone *tz=NULL ;
  timerclear(&tval);
 
  if ( gettimeofday(&tval, tz) ) CLOCKERROR;
 
  d = ((double)(tval.tv_usec)/1000000.0) ;
  d = (double) tval.tv_sec + d ;
#endif /* end #ifndef UNIX */
 
  return d ;
}

**loufoque** · 03/08/2009, 14h22

Mais donc, à la compilation, rien n'est connu par le compilateur car tout est lu à partir de fichiers texte. Comment appliquer la méta-programmation ?

Tu ne peux pas. Comme tu l'as dit toi-même, pour faire de la méta-programmation il faut tout connaître à l'avance (à la compilation) et non seulement à l'exécution.

**AurelienTran** · 03/08/2009, 14h29

Envoyé par salseropom

3) j'ai codé un exemple donné par Laurent Gomila (le cosinus). C'est plus lent que le "simple" cosinus de <cmath> (d'un facteur 10). Où se trouve mon erreur ? Les fichiers sont en pièce jointe

Tu essaies de comparer deux fonctions identique qui n'ont peut etre pas le meme algorithm et donc pas forcement les memes performance. Le test que tu as realise montre juste la fonction cos de cmath est dix fois plus rapide que ton implementation. Ce n'est pas concluant.
Si tu veux voir la difference de performance il faut que tu implementes ton propre cosinus (sans template) utilisant le meme algorithm et la tu pourras juger de la performance gagner par ton template.

PS: desole pour le manque d'accent mais j'ai juste un clavier QWERTY...

**Alp** · 03/08/2009, 14h36

La méta-programmation, elle est terminée à la compilation. Et le compilo fait autre chose que tes calculs de factorielle ou cosinus à la compilation, tu ne peux pas comparer les temps. Ca sert surtout à calculer des valeurs à la compilation que tu aurais, avant, calculé à l'exécution bien que rien ne dépendait de l'exécution elle-même.

Si tu veux que ton programme calcule des choses lues dans des fichiers, il faudrait plutôt un méta-compilateur, qui irait remplacer des "balises" dans ton code par les valeurs qu'il irait lire dans les fichiers... Mais bon

Bref, la méta-programmation pour les calculs ça n'est pas si utilisé que ça. L'astuce c'est après d'utiliser des techniques comme les expressions templates, présentées également dans l'article de Laurent.

**salseropom** · 03/08/2009, 20h04

Re, merci pour vos éclaicissements. Je vais donc me pencher sur les bibliothèques sitées par Laurent Gomila : la MTL et boost::uBlas

Merci

**Davidbrcz** · 07/08/2009, 17h23

Plop all.

je me permet de upper un petit peu ce topic car je vais devoir faire des benchs sur le temps de compilation entre du code avec des surcharges "écrites en dur" et du code où les surcharges sont générées à l'aide de boost::pp (donc au moment de la compilation) et je n'ai pas la moinde idée pratique et réaliste pour le faire.

Car j'ai bien la technique suivante (en pseudo code)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
 
time_t t=time();
system("make");
std::cout<<time()-t<<" s"<<std::endl;

Mais est ce qu'il n'y a pas d'autres moyens, car c'est vraiment de la bidouille ce que je propose

.

Merci.

**Pragmateek** · 07/08/2009, 17h30

S'il est possible d'utiliser des scripts shell pour le benchmark utilise plutôt la commande Posix "time".

**Davidbrcz** · 07/08/2009, 17h53

Envoyé par seriousme

S'il est possible d'utiliser des scripts shell pour le benchmark utilise plutôt la commande Posix "time".

Et pourquoi tenter le shell plutôt que time ? Il y a des imprécisions dessus ?

**metagoto** · 07/08/2009, 18h09

Envoyé par Davidbrcz

Et pourquoi tenter le shell plutôt que time ? Il y a des imprécisions dessus ?

Je pense plutôt que seriousme te conseille de passer par le shell plutôt que par un programme C++ pour effectuer ces benchmarks.

**Pragmateek** · 07/08/2009, 18h11

Ca donne plus d'info qu'un simple "time".

Et de manière plus générale ce type d'opération, le benchmarking, est réalisée via des outils plus souples que C++, tels des langages de scripting shell ou mieux des langages dynamiques comme Python.
Il n'est en effet pas nécessaire de profiter des performances que peut offrir C++ par rapport aux autres langages en temps normal.
Cela offre des applications de benchmark plus "métiers", car non polluées par les détails techniques inutiles : les informations de typage statique notamment.

Après si le benchmark lui-même est soumis à de fortes contraintes de performances, utilise plutôt C++.

**Alp** · 07/08/2009, 18h33

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

time g++ [etc...]

permet de mesurer le temps exact que prend g++ pour compiler ton programme.

Tu ne peux pas passer par la métaprogr directement pour ça.

**loufoque** · 09/08/2009, 01h05

Si c'est pour voir ce que génèrent tes macros, fais simplement g++ -P -E

**Davidbrcz** · 09/08/2009, 04h24

J'utilise ces options pour vérifier que le code que j'écris va bien faire la même chose que le code de base.

Je souhaitais mesurer l'inffluence de l'utilisation de boost::pp sur le temps de compilation face à du code avec des surcharges en dur.

méta-programmation et chronomètre

C++

Discussions similaires

Partager

Partager