Discussion :

[SpaceToto]

Dans l'article sur la métaprog on un exemple un peu cryptique :

Code :

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
 
template<bool Condition> struct Test {};
 
template<> struct Test<true>
{
    static void Do()
    {
        DoSomething();
    }
};
 
template<> struct Test<false>
{
    static void Do()
    {
        DoSomethingElse();
    }
};

Je me demande si le code suivant est lui aussi de la méta programmation :

Code :

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

1
2
3
4
5
6
7
8
 
template<bool cond> void choixMeta()
{
	if(cond) 
        	DoSomething();
	else 
        	DoSomethingElse();
}

Je constate un gain de performance mais moins fort que le code de l'article, fichier de test :

Code :

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
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
#include <iostream>
#include <windows.h>
 
using namespace std;
 
int maVarGlobale=0;
 
#define CODE  \
	if(cond) \
		maVarGlobale=1; \
	else \
		maVarGlobale=0;
 
 
void choixClassique(bool cond)
{
	CODE
}
 
template<bool cond> void choixMeta()
{
	CODE
}
 
template<bool Condition> struct choixMeta2 {};
template<> struct choixMeta2<true>
{
    static void Do()
    {
        maVarGlobale=1;
    }
};
 
template<> struct choixMeta2<false>
{
    static void Do()
    {
        maVarGlobale=0;
    }
};
 
 
class CPrecisionTimer
{
LARGE_INTEGER lFreq, lStart;
double duration;
 
public:
CPrecisionTimer()
{
QueryPerformanceFrequency(&lFreq);
}
 
inline void Start()
{
QueryPerformanceCounter(&lStart);
}
 
inline double Stop()
{
// Return duration in seconds...
LARGE_INTEGER lEnd;
QueryPerformanceCounter(&lEnd);
duration=(double(lEnd.QuadPart - lStart.QuadPart) / lFreq.QuadPart);
return duration;
}
 
inline double Duration()
{
	return duration;
}
 
};
 
void main()
{
	int nb=100000000;
 
    CPrecisionTimer timer;
	bool cond;
 
	timer.Start();    
	for(int i=0;i<nb;++i)
	{
		choixClassique(true);
		choixClassique(true);
		choixClassique(true);
		choixClassique(true);
		choixClassique(true);
		choixClassique(false);
		choixClassique(false);
		choixClassique(false);
		choixClassique(false);
		choixClassique(false);
	}
	timer.Stop();   
	cout<<"Duree de choix classique="<<timer.Duration()<<endl;
 
 
 
	timer.Start(); 
	for(int i=0;i<nb;++i)
	{
		choixMeta<true>();
		choixMeta<true>();
		choixMeta<true>();
		choixMeta<true>();
		choixMeta<true>();
		choixMeta<false>();
		choixMeta<false>();
		choixMeta<false>();
		choixMeta<false>();
		choixMeta<false>();
	}
	timer.Stop();   
	cout<<"Duree de choix meta="<<timer.Duration()<<endl;
 
 
 
	timer.Start(); 
	for(int i=0;i<nb;++i)
	{
		choixMeta2<true>::Do();
		choixMeta2<true>::Do();
		choixMeta2<true>::Do();
		choixMeta2<true>::Do();
		choixMeta2<true>::Do();
 
		choixMeta2<false>::Do();
		choixMeta2<false>::Do();
		choixMeta2<false>::Do();
		choixMeta2<false>::Do();
		choixMeta2<false>::Do();
	}
	timer.Stop();   
	cout<<"Duree de choix meta2="<<timer.Duration()<<endl;
 
	system("pause");
 
}

J'ai dupliqué les appels pour voir un peu plus l'impact de l'astuce sur les temps d'execution, plutôt que de compter le temps passer à faire les boucles.

Sur mon pc j'obtiens

Duree de choix classique=31.6242
Duree de choix meta=29.7122
Duree de choix meta2=28.9344

Donc : le bout de code que je présente est-il bien de la méta prog (je pense) ?
De la méta prog "classieuse"? (je ne pense pas au vu des perfs)

Est-ce que l'exemple de l'article arriverait tout simplement à tellement métaprogrammer, qu'il évite l'appel de fonction ?

[Laurent Gomila]

Ton test n'a rien de meta-programmé, car la condition est évaluée à l'exécution. En outre, les deux parties du if seront compilées. Avec l'exemple du tutoriel, seul le code vérifiant la condition est compilé.

Au mieux ton compilateur optimisera le code car il connait déjà le résultat du test, mais c'est tout.

[Alp]

Il suffit de comprendre que le if que tu utilises est utilisé à l'exécution. Alors que les structures dans le tutoriel de Laurent sont toutes déterminées à la compilation. Tout est pré-calculé et on sait déjà quelle fonction va être appelée lorsque l'on instancie Test<true> ou Test<false>.
J'ai d'ailleurs écrit un tutoriel sur les classes de traits et de politiques (qui sont des éléments clés pour l'utilisation avancée des templates) : http://alp.developpez.com/tutoriels/traitspolicies/

[SpaceToto]

OK, dommage, c'était quand même plus "normal" comme écriture.

Je comptais me servir de ça comme une sorte d'alternative entre les ifdef et les paramètres que je fournit à mes classes pour éviter de faire certains traitements.Par exemple les sorties de debug.

Ce n'est pas pour ça que je voulais m'en servir, mais pour des traitements très répétés dans un programme qui a des contraintes de temps d'exécution.

[Luc Hermitte]

Cet aspect de la meta prog se rapproche plus du prolog que d'un langage impératif.
Tu vas devoir changer ta façon de percevoir les choses.

PS: des fois les macros, c'est bien aussi.

[Garulfo]

OK, dommage, c'était quand même plus "normal" comme écriture.

Non pas vraiment.
Personnellement le premier me semble plus normal.

Comme quoi la normalité n'est pas normalisée

[Alp]

Faut que tu gardes à l'esprit que la métaprogrammation ne s'utilise pas dans les mêmes situations que dans la programmation "habituelle". En métaprogrammation, on manipule des types par exemple (listes de types, cf le tuto de Laurent, par exemple).

[loufoque]

Un bon optimisateur qui fait de la const propagation devrait aussi effectuer tes if à la compilation.