Appel à la bonne version d'une fonction template

Bonjour à toutes et à tous ! :D
J'ai un petit souci technique, désolé du titre très peu évocateur, j'ai aucune idée du nom du problème que je rencontre !

Je cherche à comparer les temps d'exécution de différentes stratégies de simulation via des classes de politiques.
Mais je ne sais pas comment appeler la bonne version template de la fonction à évaluer, parce que je ne lui ai pas encore donné ses arguments ! J'imagine que c'est assez classique comme problème mais je ne sais pas trop où/quoi chercher, et ça fait une petite heure que je me tords le neurone ;)

Voyez plutôt :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

template<typename F, typename... Args> double execution_time(F func, Args&&... args){ auto t1 = std::chrono::high_resolution_clock::now(); func(std::forward<Args>(args)...); return std::chrono::duration_cast<std::chrono::nanoseconds>(std::chrono::high_resolution_clock::now() - t1).count(); }   //! \remark Merger est une classe de politique donnant la stratégie de simulation template<class Merger, typename Generator, typename... Args> void repeat_WF(unsigned int n, unsigned int k, Generator& gen, Args&&... args){ for(unsigned int i = 0; i < n; ++i){ std::vector<int> v(k); auto model = model::make_discrete_time_wright_fisher<Merger>(v.begin(), v.end(), std::forward<Args>(args)... ); model(gen); } }

---

Le code suivant compile et tourne, mais la dernière ligne commentée ne marche évidemment pas. La version bourrine serait peut-être de préciser tous les arguments template avec l'argument de fonction, mais c'est super moche non ? Il y a moyen de faire autrement ? J'hésite à bricoler une fonction qui instantie une lambda...

Code:

---

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

int main(){   using namespace coalescence; using BigInt = boost::multiprecision::cpp_int; using BigFloat = boost::multiprecision::cpp_dec_float_50; using SMM1_type = SimultaneousMultipleMerge<on_the_fly>; using SMM2_type = SimultaneousMultipleMerge<in_memoized_distribution<BigInt, BigFloat>>; using time_type = int; std::mt19937 gen;   unsigned int k = 20; unsigned int N = 100; unsigned int g = 10; time_type t0 = 0;   auto coal_event = std::plus<int>(); auto init_parent = [](time_type t){return 0;};   // ça c'est juste pour montrer qu'au moins on arrive à simuler selon différentes politiques/stratégies repeat_WF<BinaryMerge>(10, k, gen, N, g, t0, coal_event, init_parent); repeat_WF<SMM1_type>(10, k, gen, N, g, t0, coal_event, init_parent); repeat_WF<SMM2_type>(10, k, gen, N, g, t0, coal_event, init_parent);   //std::cout << execution_time(repeat_WF<BinaryMerge>, 10, k, gen, N, g, t0, coal_event, init_parent) << std::endl; // ne marche pas, snif !   return 0; }

---

Merci d'avance ! :)
Bien à vous,

Salut,

En attendant une potentielle meilleure réponse, voici une solution pas générique, mais simple :

Code:

---

1 2 3 4

template<class Merger, typename Generator, typename... Args> double execution_time_repeat_WF(unsigned int n, unsigned int k, Generator& gen, Args&&... args) { return execution_time(repeat_WF<Merger, Generator, Args...>, n, k, gen, std::forward<Args>(args)...); }

---

Exemple d'appel :

Code:

---

execution_time_repeat_WF<BinaryMerge>(10, k, gen, N, g, t0, coal_event, init_parent)

---

Un foncteur

Code:

---

1 2 3 4 5 6 7 8 9 10 11

template<class Merger> struct repeat_WF_fn { template<typename Generator, typename... Args> void operator()(unsigned int n, unsigned int k, Generator& gen, Args&&... args) const { /*...*/ } };   // http://en.cppreference.com/w/cpp/language/variable_template template<class Merger> constexpr auto repeat_WF = repeat_WF_fn<Merger>{};

---

Solution alternative : une macro :

Code:

---

1 2 3 4 5 6

#define EXECUTION_TIME(expr) \ ([&] {\ auto EXECUTION_TIME_t1 = std::chrono::high_resolution_clock::now();\ static_cast<void>(expr);\ return std::chrono::duration_cast<std::chrono::nanoseconds>(std::chrono::high_resolution_clock::now() - EXECUTION_TIME_t1).count();\ }())

---

Exemple d'appel :

Code:

---

EXECUTION_TIME(repeat_WF<BinaryMerge>(10, k, gen, N, g, t0, coal_event, init_parent))

---

Personnellement, je préfère la solution de jo_link_noir. Ma solution avec une macro, ce serait plutôt si le code de repeat_WF ne pouvait pas être changé.

Edit 2017-04-27-14h18 : t1 renommé en EXECUTION_TIME_t1 pour éviter de potentielles collisions de nom.

Merci à tous pour vos réponses ! :bravo:

Citation:

---

Envoyé par jo_link_noir

Un foncteur

Code:

---

1 2 3 4 5 6 7 8 9 10 11

template<class Merger> struct repeat_WF_fn { template<typename Generator, typename... Args> void operator()(unsigned int n, unsigned int k, Generator& gen, Args&&... args) const { /*...*/ } };   // http://en.cppreference.com/w/cpp/language/variable_template template<class Merger> constexpr auto repeat_WF = repeat_WF_fn<Merger>{};

---

---

Ok, donc on instantie le foncteur avec la police adaptée, et le reste de l'instantiation est repoussé à l'opérateur parenthèse. Logique. Sauf que je comprends mal l'utilisation de la variable template... :? Je crois avoir compris l'exemple classique des variables template avec PI, mais dans notre contexte je vois moins bien.

La variable template permet d'alléger un peu l’écriture. Pour utiliser repeat_WF_fn, il faut faire repeat_WF_fn<P>{}(params...). La paire d'accolade sert à instancier le foncteur et les parenthèses appel la fonction membre.
Avec la variable template repeat_WF<P>, cela crée une instance de repeat_WF_fn (cf: repeat_WF_fn<P>{}. Il n'y a donc plus besoin des accolades.

repeat_WF<P> = repeat_WF_fn<P>{}.
repeat_WF<P>(params...) = repeat_WF_fn<P>{}(params...).

Cela donne la fausse impression d'utiliser une fonction ^^.

Ooooooh mais c'est super joli ! :D
Merci encore à vous deux ! ;)