Discussion :

[Seabirds]

Bonjour à toutes et à tous !
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 :

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

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

[Pyramidev]

Salut,

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

Code :

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

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 :

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

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

[jo_link_noir]

Un foncteur

Code :

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

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>{};

[Pyramidev]

Solution alternative : une macro :

Code :

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

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 :

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

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.

[Seabirds]

Merci à tous pour vos réponses !

Un foncteur

Code :

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

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.

[jo_link_noir]

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 ^^.

[Seabirds]

Ooooooh mais c'est super joli !
Merci encore à vous deux !