Discussion :

[Kaluza]

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 :

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
#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

[koala01]

Salut,

Il y a quelques mois, j'ai proposé cette solution pour être en mesure de mesurer le temps d'exécution de différentes fonctions.

Elle est écrite en C++11, ce qui implique qu'il faille un disposer d'un compilateur *relativement* récent (support des variadic templates, de <chrono> et de std::function requit) et présente l'avantage de ne pas être excessivement intrusive parce qu'elle s'utilise sur n'importe quelle fonction, mais l'inconvénient de ne te permettre la mesure que des fonctions que tu lui indiques explicitement.

L'idéal est donc, sans doute, de l'utiliser dans un projet séparé de ton projet original

[Arzar]

Bref, voilà mon code de base, que modifieriez vous dedans pour améliorer sa qualité ?

Bonjour,
Je pense qu'il manque un std::forward lors de l'appel à f :

Code :

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

temporary = f(std::forward<Arg>(args)...);

Mais sinon le coup du volatile m'a l'air d'être une bonne solution pour empêcher l'optimiseur de tout enlever en effet.

[Kaluza]

Vu que ça parle de std::forward, je vais en profiter pour demander à quoi sert cette métafonction car je n'ai jamais compris ce qu'elle faisait exactement dans le détail (et j'ai besoin d'en comprendre les mécanismes pour savoir l'utiliser). En général quand je repasse des arguments à une fonction, ces arguments sont passés en tant qu'universal references (au sens de Scott Meyers). Pourquoi cela ne suffirait-il pas ?

Genre :

template <class T> void f1(const T& x);
template <class T> void f2(T x);
template <class T> void f3(T& x);

template <class F, class T> void apply(F&& f, T&& x)

Quel avantage pour chaque cas f1, f2 et f3 d'utiliser std::forward dans la fonction apply ?

Merci beaucoup

[Flob90]

@Kaluza: Au sein de ta fonction apply, quelque soit la "valeur" des arguments template (ie que ce soit des T& ou T&& après détermination), les arguments de ta fonction sont des lvalue. std::forward permet de la retransformer en rvalue si c'en est une (T&&) ou de la laisser en lvalue sinon (T&). C'est l'outil qui permet d'achever le perfect forwarding.