Cours

This page is read only. You can view the source, but not change it. Ask your administrator if you think this is wrong.
====== Partie 2 :Mesuré le temps passé par une fonction ======

[[in204:tds:sujets:td9|TD9]]

===== Références=====

[[https://en.cppreference.com/w/cpp/chrono/high_resolution_clock|std::chrono::high_resolution_clock]]


====== Partie n°1 ======

Nous souhaitons mesurer le temps de calcul d'une fonction. Pour ce faire, nous souhaitons créer une fonction :
- qui va prendre en argument la fonction que nous souhaitons exécuter,
- les arguments que nous devons passer à cette fonction,
- qui va lancer un chronomètre,
- qui va lancer la fonction
- qui va récupérer le résultat de la fonction,
- qui va estimer le temps passé par le temps de la fonction,
- qui va retourner à la fois le  résultat de la fonction mais aussi le temps passé par la fonction.

===== Question n°1 =====

Pour simplifier la conception, écrivez dans un premier la fonction qui appelle la fonction factorielle qui suit:
et qui va exécuter cette fonction

<code cpp>
int factorial(int n)
{
    return n <= 1 ? 1 : (n * factorial(n - 1));
}
</code>

La fonction aura le squelette suivant:
<code>
int estimate_time(int n)
{
    // Code pour lancer le chronomètre
    int result = factorial(n);
    // Code pour calculer le temps écoulé et affiché celui-ci.
    return result;
}
</code>

===== Question n°2 =====

Transformer la fonction précédente <code>estimate_time</code> pour qu'elle prenne en argument une fonction arbitraire à un argument et un résultat. 

Il faudra penser à utiliser un modèle (template) de fonctions.

<hidden Correction>

Il suffit de modifier la fonction antérieure comme un fonction qui prend deux paramètres de types:
  - le type correspondant à la fonction,
  - le type correspondant au paramètre de la fonction.

Et le tour est joué. Ceci donne le code suivant :

<code cpp>
template<class Function, class T>
std::pair<std::chrono::high_resolution_clock::duration, long double> estimate_function_time(Function function, T argument)
{
	auto starting_time = std::chrono::high_resolution_clock::now();
	auto result = function(argument);
	auto elasped_time = std::chrono::high_resolution_clock::now() - starting_time;
	return std::make_pair(elasped_time, result);
}
</code>

</hidden>


===== Question n°3 =====

Nous souhaitons désormais pouvoir prendre une fonction pouvant prendre plusieurs arguments comme la fonction puissance.

<code cpp>
template<class T1, T2> 
T1 power(T2 x, int y)
{
   T1 result = (T1)1.0
   while(y-- > 0)
       result  = result * (T1)x;
   return result;
}
</code>

Modifier le code de la fonction pour pouvoir prendre une telle fonction comme paramètre.

Estimer le temps nécesaire pour calculer par exemple : 1.02 ^ 10000000.


==== Question n°5 ====

Créer une fonction nouvelle qui va appeller la fonction <code>estimate_time</code> pour calculer <code>x</code> fois le temps et retourné le temps moyen pour effectuer un "run" de la fonction.

Exécuter cette fonction pour les fonctions <code>power</code> et <code>factorial</code> précédemment définie.

==== Question n°4 ====

Que faut-il faire ajouter pour dire au compilateur que la fonction <code>factorial</code> ou que la fonction <code>power</code> peut-être exécutée au moment de l'exécution ?

Effectuer la modification.

Calculer le temps pris désormais par ces fonctions.
Cours

User Tools

Site Tools

Page Tools
