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 s'exécuter sous Linux . Ensuite, je veux faire une comparaison de vitesse. J'ai vu plusieurs fonctions de temps mais j'ai fini avec cela de boost. Chrono:

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

Maintenant, je ne suis pas clair si j'utilise la fonction ci-dessus, vais-je obtenir le seul temps que le processeur a 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 à 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 en raison de la charge CPU différente à chaque fois.

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

Utilisez-le comme ceci:

#include <iostream>
#include <chrono>

void function()
{
    long long number = 0;

    for( long long i = 0; i != 2000000; ++i )
    {
       number += 5;
    }
}

int main()
{
    auto t1 = std::chrono::high_resolution_clock::now();
    function();
    auto t2 = std::chrono::high_resolution_clock::now();

    auto duration = std::chrono::duration_cast<std::chrono::microseconds>( t2 - t1 ).count();

    std::cout << duration;
    return 0;
}

Cela mesurera la durée de la fonction.

REMARQUE: vous n'obtiendrez pas toujours le même timing pour une fonction. En effet, le processeur de votre machine peut être moins ou plus utilisé par d'autres processus exécutés sur votre ordinateur, tout comme votre esprit peut être plus ou moins concentré lorsque vous résolvez un exercice de mathématiques. Dans l'esprit humain, nous pouvons nous souvenir de la solution d'un problème mathématique, mais pour un ordinateur, le même processus sera toujours quelque chose de nouveau; ainsi, comme je l'ai dit, vous n'obtiendrez pas toujours le même résultat!

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

#include <chrono>
#include <utility>

typedef std::chrono::high_resolution_clock::time_point TimeVar;

#define duration(a) std::chrono::duration_cast<std::chrono::nanoseconds>(a).count()
#define timeNow() std::chrono::high_resolution_clock::now()

template<typename F, typename... Args>
double funcTime(F func, Args&&... args){
    TimeVar t1=timeNow();
    func(std::forward<Args>(args)...);
    return duration(timeNow()-t1);
}

Exemple d'utilisation:

#include <iostream>
#include <algorithm>

typedef std::string String;

//first test function doing something
int countCharInString(String s, char delim){
    int count=0;
    String::size_type pos = s.find_first_of(delim);
    while ((pos = s.find_first_of(delim, pos)) != String::npos){
        count++;pos++;
    }
    return count;
}

//second test function doing the same thing in different way
int countWithAlgorithm(String s, char delim){
    return std::count(s.begin(),s.end(),delim);
}


int main(){
    std::cout<<"norm: "<<funcTime(countCharInString,"precision=10",'=')<<"\n";
    std::cout<<"algo: "<<funcTime(countWithAlgorithm,"precision=10",'=');
    return 0;
}

Production:

norm: 15555
algo: 2976

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

#include <iostream>
#include <ctime> // time_t
#include <cstdio>

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

Dans le livre de Scott Meyers, j'ai trouvé un exemple d'expression lambda générique universelle qui peut être utilisée pour mesurer le temps d'exécution d'une fonction. (C ++ 14)

auto timeFuncInvocation = 
    [](auto&& func, auto&&... params) {
        // get time before function invocation
        const auto& start = std::chrono::high_resolution_clock::now();
        // function invocation using perfect forwarding
        std::forward<decltype(func)>(func)(std::forward<decltype(params)>(params)...);
        // get time after function invocation
        const auto& stop = std::chrono::high_resolution_clock::now();
        return stop - start;
     };

Le problème est que vous ne mesurez qu'une seule exécution, les résultats peuvent donc être très différents. Pour obtenir un résultat fiable, vous devez mesurer un grand nombre d'exécutions. D'après la conférence d'Andrei Alexandrescu à la conférence code :: dive 2015 - Writing Fast Code I:

Temps mesuré: tm = t + tq + tn + to

où:

tm - temps mesuré (observé)

t - le temps réel d'intérêt

tq - temps ajouté par le bruit de quantification

tn - temps ajouté par diverses sources de bruit

to - temps de surcharge (mesure, bouclage, fonctions d'appel)

D'après ce qu'il a dit plus tard dans la conférence, vous devriez prendre un minimum de ce grand nombre d'exécutions comme résultat. Je vous encourage à regarder la conférence dans laquelle il explique pourquoi.

Il existe également une très bonne bibliothèque de google - https://github.com/google/benchmark . Cette bibliothèque est très simple à utiliser et puissante. Vous pouvez consulter quelques conférences de Chandler Carruth sur youtube où il utilise cette bibliothèque dans la pratique. Par exemple CppCon 2017: Chandler Carruth «Going Nowhere Faster»;

Exemple d'utilisation:

#include <iostream>
#include <chrono>
#include <vector>
auto timeFuncInvocation = 
    [](auto&& func, auto&&... params) {
        // get time before function invocation
        const auto& start = high_resolution_clock::now();
        // function invocation using perfect forwarding
        for(auto i = 0; i < 100000/*largeNumber*/; ++i) {
            std::forward<decltype(func)>(func)(std::forward<decltype(params)>(params)...);
        }
        // get time after function invocation
        const auto& stop = high_resolution_clock::now();
        return (stop - start)/100000/*largeNumber*/;
     };

void f(std::vector<int>& vec) {
    vec.push_back(1);
}

void f2(std::vector<int>& vec) {
    vec.emplace_back(1);
}
int main()
{
    std::vector<int> vec;
    std::vector<int> vec2;
    std::cout << timeFuncInvocation(f, vec).count() << std::endl;
    std::cout << timeFuncInvocation(f2, vec2).count() << std::endl;
    std::vector<int> vec3;
    vec3.reserve(100000);
    std::vector<int> vec4;
    vec4.reserve(100000);
    std::cout << timeFuncInvocation(f, vec3).count() << std::endl;
    std::cout << timeFuncInvocation(f2, vec4).count() << std::endl;
    return 0;
}

EDIT: Bien sûr, vous devez toujours vous rappeler que votre compilateur peut optimiser quelque chose ou non. Des outils comme perf peuvent être utiles dans de tels cas.

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

#include <time.h> // includes clock_t and CLOCKS_PER_SEC

int main() {

    clock_t start, end;

    start = clock();
    // ...code to measure...
    end = clock();

    double duration_sec = double(end-start)/CLOCKS_PER_SEC;
    return 0;
}

La précision du chronométrage en secondes est 1.0/CLOCKS_PER_SEC

• C'est une méthode très simple à utiliser en C ++ 11.
• Nous pouvons utiliser std :: chrono :: high_resolution_clock depuis l'en-tête
• Nous pouvons écrire une méthode pour afficher le temps d'exécution de la méthode sous une forme très lisible.

Par exemple, pour trouver tous les nombres premiers entre 1 et 100 millions, cela prend environ 1 minute et 40 secondes. Ainsi, le temps d'exécution est imprimé comme suit:

Execution Time: 1 Minutes, 40 Seconds, 715 MicroSeconds, 715000 NanoSeconds

Le code est ici:

#include <iostream>
#include <chrono>

using namespace std;
using namespace std::chrono;

typedef high_resolution_clock Clock;
typedef Clock::time_point ClockTime;

void findPrime(long n, string file);
void printExecutionTime(ClockTime start_time, ClockTime end_time);

int main()
{
    long n = long(1E+8);  // N = 100 million

    ClockTime start_time = Clock::now();

    // Write all the prime numbers from 1 to N to the file "prime.txt"
    findPrime(n, "C:\\prime.txt"); 

    ClockTime end_time = Clock::now();

    printExecutionTime(start_time, end_time);
}

void printExecutionTime(ClockTime start_time, ClockTime end_time)
{
    auto execution_time_ns = duration_cast<nanoseconds>(end_time - start_time).count();
    auto execution_time_ms = duration_cast<microseconds>(end_time - start_time).count();
    auto execution_time_sec = duration_cast<seconds>(end_time - start_time).count();
    auto execution_time_min = duration_cast<minutes>(end_time - start_time).count();
    auto execution_time_hour = duration_cast<hours>(end_time - start_time).count();

    cout << "\nExecution Time: ";
    if(execution_time_hour > 0)
    cout << "" << execution_time_hour << " Hours, ";
    if(execution_time_min > 0)
    cout << "" << execution_time_min % 60 << " Minutes, ";
    if(execution_time_sec > 0)
    cout << "" << execution_time_sec % 60 << " Seconds, ";
    if(execution_time_ms > 0)
    cout << "" << execution_time_ms % long(1E+3) << " MicroSeconds, ";
    if(execution_time_ns > 0)
    cout << "" << execution_time_ns % long(1E+6) << " NanoSeconds, ";
}

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

#ifndef EXECUTION_TIMER_H
#define EXECUTION_TIMER_H

template<class Resolution = std::chrono::milliseconds>
class ExecutionTimer {
public:
    using Clock = std::conditional_t<std::chrono::high_resolution_clock::is_steady,
                                     std::chrono::high_resolution_clock,
                                     std::chrono::steady_clock>;
private:
    const Clock::time_point mStart = Clock::now();

public:
    ExecutionTimer() = default;
    ~ExecutionTimer() {
        const auto end = Clock::now();
        std::ostringstream strStream;
        strStream << "Destructor Elapsed: "
                  << std::chrono::duration_cast<Resolution>( 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<Resolution>(end - mStart).count()
                  << std::endl;
        std::cout << strStream.str() << std::endl;
    }

}; // ExecutionTimer

#endif // EXECUTION_TIMER_H

En voici quelques utilisations:

int main() {
    { // empty scope to display ExecutionTimer's destructor's message
         // displayed in milliseconds
         ExecutionTimer<std::chrono::milliseconds> timer;

         // function or code block here

         timer.stop();

    } 

    { // same as above
        ExecutionTimer<std::chrono::microseconds> timer;

        // code block here...

        timer.stop();
    }

    {  // same as above
       ExecutionTimer<std::chrono::nanoseconds> timer;

       // code block here...

       timer.stop();

    }

    {  // same as above
       ExecutionTimer<std::chrono::seconds> timer;

       // code block here...

       timer.stop();

    }              

    return 0;
}

Puisque la classe est un modèle, nous pouvons spécifier très facilement la façon dont nous voulons que notre temps soit mesuré et affiché. Il s'agit d'un modèle de classe d'utilité très pratique pour faire du benchmarking et est très facile à utiliser.

Je recommande d'utiliser steady_clockce qui est garanti pour être monotone, contrairement high_resolution_clock.

#include <iostream>
#include <chrono>

using namespace std;

unsigned int stopwatch()
{
    static auto start_time = chrono::steady_clock::now();

    auto end_time = chrono::steady_clock::now();
    auto delta    = chrono::duration_cast<chrono::microseconds>(end_time - start_time);

    start_time = end_time;

    return delta.count();
}

int main() {
  stopwatch(); //Start stopwatch
  std::cout << "Hello World!\n";
  cout << stopwatch() << endl; //Time to execute last line
  for (int i=0; i<1000000; i++)
      string s = "ASDFAD";
  cout << stopwatch() << endl; //Time to execute for loop
}

Production:

Hello World!
62
163514

Vous pouvez avoir une classe simple qui peut être utilisée pour ce type de mesures.

class duration_printer {
public:
    duration_printer() : __start(std::chrono::high_resolution_clock::now()) {}
    ~duration_printer() {
        using namespace std::chrono;
        high_resolution_clock::time_point end = high_resolution_clock::now();
        duration<double> dur = duration_cast<duration<double>>(end - __start);
        std::cout << dur.count() << " seconds" << std::endl;
    }
private:
    std::chrono::high_resolution_clock::time_point __start;
};

La seule chose à faire est de créer un objet dans votre fonction au début de cette fonction

void veryLongExecutingFunction() {
    duration_calculator dc;
    for(int i = 0; i < 100000; ++i) std::cout << "Hello world" << std::endl;
}

int main() {
    veryLongExecutingFunction();
    return 0;
}

et c'est tout. La classe peut être modifiée pour répondre à vos besoins.

Comme aucune des réponses fournies n'est très précise ou ne donne des résultats reproductibles, j'ai décidé d'ajouter un lien vers mon code qui a une précision inférieure à la nanoseconde et des statistiques scientifiques.

Notez que cela ne fonctionnera que pour mesurer le code qui prend un temps (très) court à s'exécuter (alias, quelques cycles d'horloge à quelques milliers): s'ils fonctionnent si longtemps qu'ils sont susceptibles d'être interrompus par une interruption -heh- , alors il n'est clairement pas possible de donner un résultat reproductible et précis; la conséquence est que la mesure ne se termine jamais: à savoir, il continue à mesurer jusqu'à ce qu'il soit statistiquement sûr à 99,9% d'avoir la bonne réponse, ce qui ne se produit jamais sur une machine qui a d'autres processus en cours d'exécution lorsque le code prend trop de temps.

https://github.com/CarloWood/cwds/blob/master/benchmark.h#L40

Si vous voulez sécuriser le temps et les lignes de code, vous pouvez faire de la mesure du temps d'exécution de la fonction une macro d'une ligne:

a) Implémentez une classe de mesure du temps comme déjà suggéré ci-dessus (voici mon implémentation pour Android):

class MeasureExecutionTime{
private:
    const std::chrono::steady_clock::time_point begin;
    const std::string caller;
public:
    MeasureExecutionTime(const std::string& caller):caller(caller),begin(std::chrono::steady_clock::now()){}
    ~MeasureExecutionTime(){
        const auto duration=std::chrono::steady_clock::now()-begin;
        LOGD("ExecutionTime")<<"For "<<caller<<" is "<<std::chrono::duration_cast<std::chrono::milliseconds>(duration).count()<<"ms";
    }
};

b) Ajoutez une macro pratique qui utilise le nom de la fonction actuelle comme TAG (l'utilisation d'une macro ici est importante, sinon __FUNCTION__évaluera à la MeasureExecutionTimeplace de la fonction que vous voulez mesurer

#ifndef MEASURE_FUNCTION_EXECUTION_TIME
#define MEASURE_FUNCTION_EXECUTION_TIME const MeasureExecutionTime measureExecutionTime(__FUNCTION__);
#endif

c) Écrivez votre macro au début de la fonction que vous souhaitez mesurer. Exemple:

 void DecodeMJPEGtoANativeWindowBuffer(uvc_frame_t* frame_mjpeg,const ANativeWindow_Buffer& nativeWindowBuffer){
        MEASURE_FUNCTION_EXECUTION_TIME
        // Do some time-critical stuff 
}

Ce qui aboutira à la sortie suivante:

ExecutionTime: For DecodeMJPEGtoANativeWindowBuffer is 54ms

Notez que ceci (comme toutes les autres solutions suggérées) mesurera le temps entre le moment où votre fonction a été appelée et son retour, pas nécessairement le moment où votre CPU exécutait la fonction. Cependant, si vous ne donnez aucune modification au planificateur pour suspendre votre code en cours d'exécution en appelant sleep () ou similaire, il n'y a aucune différence entre les deux.