Fonction de benchmark : empêcher les optimisations null-statement
Bonjour.
Je cherche à créer une fonction de benchmark qui exécute en boucle une fonction passée en paramètre et retourne la durée d'exécution. Le problème c'est que si je ne fais qu'exécuter la fonction dans la boucle, en -O3, les compilateurs détectent que la fonction n'est pas utilisée pour quelque chose d'utile, et l'appel est carrément enlevé, si bien que le temps d'exécution est nul.
J'ai bidouillé la chose suivante avec un volatile et ça a l'air de fonctionner. Cependant, j'ai un peu du mal à savoir si les qualifiers des arguments sont les meilleurs que je puisse choisir. Je veux être certain que je mesure bien le temps d'exécution de ma fonction et que 95% du temps n'est pas pris par des copies inutiles à cause de la manière dont sont passés les arguments.
Bref, voilà mon code de base, que modifieriez vous dedans pour améliorer sa qualité ?
Code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
| #include <iostream>
#include <chrono>
#include <cmath>
template <class Clock = std::chrono::high_resolution_clock, class Counter, class Function, class... Args>
inline double benchmark(const Counter& counter, Function&& f, Args&&... args)
{
volatile decltype(f(args...)) temporary = decltype(f(args...))();
const typename Clock::time_point marker = Clock::now();
for (Counter i = Counter(); i < counter; ++i) {
temporary = f(args...);
}
return std::chrono::duration<double>(Clock::now()-marker).count();
}
int main(int argc, char* argv[])
{
std::cout<<benchmark(1000000000, [](double x){return std::sin(x);}, 3.)<<"\n";
return 0;
} |
Merci beaucoup ;)
