Mesurer le temps d’exécution d’une fonction en C ++

Je veux savoir combien de temps une certaine fonction prend dans mon programme C ++ pour exécuter sous Linux . Ensuite, je veux faire une comparaison de vitesse. J’ai vu plusieurs fonctions temporelles mais j’ai fini par recevoir ceci de boost. Chrono:

process_user_cpu_clock, captures user-CPU time spent by the current process 

Maintenant, je ne sais pas si j’utilise la fonction ci-dessus, aurai-je le seul temps passé sur cette fonction?

Deuxièmement, je n’ai trouvé aucun exemple d’utilisation de la fonction ci-dessus. Quelqu’un peut-il m’aider s’il vous plaît comment utiliser la fonction ci-dessus?

PS: En ce moment, j’utilise std::chrono::system_clock::now() pour obtenir le temps en secondes, mais cela me donne des résultats différents à cause de la charge différente du processeur à chaque fois.

    C’est une méthode très facile à utiliser en C ++ 11. Vous devez utiliser std::chrono::high_resolution_clock de l’en-tête .

    Utilisez-le comme ça:

     #include  #include  using namespace std; using namespace std::chrono; void function() { long long number = 0; for( long long i = 0; i != 2000000; ++i ) { number += 5; } } int main() { high_resolution_clock::time_point t1 = high_resolution_clock::now(); function(); high_resolution_clock::time_point t2 = high_resolution_clock::now(); auto duration = duration_cast( t2 - t1 ).count(); cout < < duration; return 0; } 

    Cela mesurera la durée de la fonction.

    REMARQUE: Il n’est pas obligatoire d’obtenir toujours le même résultat car le processeur de votre ordinateur peut être plus ou moins utilisé par d’autres processus exécutés sur votre ordinateur. Comme vous résoudrez un exercice de mathématiques, votre esprit peut être plus ou moins concentré, de sorte que vous le résolvez à des moments différents. Dans l'esprit humain, nous pouvons nous souvenir de la solution d'un problème mathématique, même si pour un ordinateur, le même processus sera toujours quelque chose de nouveau. Comme je l'ai dit, il n'est pas nécessaire d'obtenir toujours le même résultat!

    Voici une fonction qui mesurera le temps d’exécution de toute fonction passée en argument:

     #include  #include  typedef std::chrono::high_resolution_clock::time_point TimeVar; #define duration(a) std::chrono::duration_cast(a).count() #define timeNow() std::chrono::high_resolution_clock::now() template double funcTime(F func, Args&&... args){ TimeVar t1=timeNow(); func(std::forward(args)...); return duration(timeNow()-t1); } 

    Exemple d’utilisation:

     #include  #include  typedef std::ssortingng Ssortingng; //first test function doing something int countCharInSsortingng(Ssortingng s, char delim){ int count=0; Ssortingng::size_type pos = s.find_first_of(delim); while ((pos = s.find_first_of(delim, pos)) != Ssortingng::npos){ count++;pos++; } return count; } //second test function doing the same thing in different way int countWithAlgorithm(Ssortingng s, char delim){ return std::count(s.begin(),s.end(),delim); } int main(){ std::cout< <"norm: "< 

    Sortie:

     norm: 15555 algo: 2976 

    programme simple pour trouver le temps d’exécution d’une fonction.

     #include  #include  // time_t #include  void function() { for(long int i=0;i<1000000000;i++) { // do nothing } } int main() { time_t begin,end; // time_t is a datatype to store time values. time (&begin); // note time before execution function(); time (&end); // note time after execution double difference = difftime (end,begin); printf ("time taken for function() %.2lf seconds.\n", difference ); return 0; } 

    Voici un excellent modèle de classe d’en-tête uniquement pour mesurer le temps écoulé d’une fonction ou d’un bloc de code:

     #ifndef EXECUTION_TIMER_H #define EXECUTION_TIMER_H template class ExecutionTimer { public: using Clock = std::conditional_t; private: const Clock::time_point mStart = Clock::now(); public: ExecutionTimer() = default; ~ExecutionTimer() { const auto end = Clock::now(); std::ossortingngstream strStream; strStream < < "Destructor Elapsed: " << std::chrono::duration_cast( end - mStart ).count() < < std::endl; std::cout << strStream.str() << std::endl; } inline void stop() { const auto end = Clock::now(); std::ostringstream strStream; strStream << "Stop Elapsed: " << std::chrono::duration_cast(end - mStart).count() < < std::endl; std::cout << strStream.str() << std::endl; } }; // ExecutionTimer #endif // EXECUTION_TIMER_H 

    Voici quelques utilisations:

     int main() { { // empty scope to display ExecutionTimer's destructor's message // displayed in milliseconds ExecutionTimer timer; // function or code block here timer.stop(); } { // same as above ExecutionTimer timer; // code block here... timer.stop(); } { // same as above ExecutionTimer timer; // code block here... timer.stop(); } { // same as above ExecutionTimer timer; // code block here... timer.stop(); } return 0; } 

    Étant donné que la classe est un modèle, nous pouvons spécifier très facilement comment nous voulons que notre temps soit mesuré et affiché. Ceci est un modèle de classe utilitaire très pratique pour effectuer des tests de banc et est très facile à utiliser.

    Un moyen facile pour les anciens C ++ ou C:

     #include  

    La précision du temps en secondes est de 1.0/CLOCKS_PER_SEC