Messung der Ausführungszeit einer Funktion in C ++

Ich möchte herausfinden, wie viel Zeit eine bestimmte Funktion in meinem C ++ - Programm benötigt, um unter Linux ausgeführt zu werden . Danach möchte ich einen Geschwindigkeitsvergleich machen. Ich habe mehrere Zeitfunktionen gesehen, aber am Ende hatte ich diese durch Boost. Chrono:

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

Jetzt ist mir nicht klar, ob ich die obige Funktion verwende. Bekomme ich die einzige Zeit, die die CPU für diese Funktion aufgewendet hat?

Zweitens konnte ich kein Beispiel für die Verwendung der obigen Funktion finden. Kann mir bitte jemand helfen, wie man die obige Funktion benutzt?

PS: Im Moment verwende ich std::chrono::system_clock::now(), um Zeit in Sekunden zu erhalten, aber dies führt zu unterschiedlichen Ergebnissen aufgrund der unterschiedlichen CPU-Auslastung jedes Mal.

Es ist eine sehr einfach zu verwendende Methode in C ++ 11. Sie müssen std::chrono::high_resolution_clockaus dem <chrono>Header verwenden.

Verwenden Sie es so:

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

Dadurch wird die Dauer der Funktion gemessen.

HINWEIS: Sie erhalten nicht immer das gleiche Timing für eine Funktion. Dies liegt daran, dass die CPU Ihres Computers weniger oder mehr von anderen auf Ihrem Computer ausgeführten Prozessen verwendet werden kann, genauso wie Ihr Geist mehr oder weniger konzentriert sein kann, wenn Sie eine mathematische Übung lösen. Im menschlichen Geist können wir uns an die Lösung eines mathematischen Problems erinnern, aber für einen Computer wird der gleiche Prozess immer etwas Neues sein; So erhalten Sie, wie gesagt, nicht immer das gleiche Ergebnis!

Hier ist eine Funktion, die die Ausführungszeit jeder als Argument übergebenen Funktion misst:

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

Anwendungsbeispiel:

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

Ausgabe:

norm: 15555
algo: 2976

einfaches Programm, um eine benötigte Funktionsausführungszeit zu finden.

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

In Scott Meyers Buch habe ich ein Beispiel für einen universellen generischen Lambda-Ausdruck gefunden, mit dem die Ausführungszeit von Funktionen gemessen werden kann. (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;
     };

Das Problem ist, dass Sie nur eine Ausführung messen, sodass die Ergebnisse sehr unterschiedlich sein können. Um ein zuverlässiges Ergebnis zu erhalten, sollten Sie eine große Anzahl von Ausführungen messen. Laut Andrei Alexandrescu Vortrag auf der Code :: Dive 2015 Konferenz - Schreiben von Fast Code I:

Gemessene Zeit: tm = t + tq + tn + bis

wo:

tm - gemessene (beobachtete) Zeit

t - der tatsächliche Zeitpunkt des Interesses

tq - Zeit, die durch Quantisierungsrauschen hinzugefügt wird

tn - Zeit, die durch verschiedene Geräuschquellen hinzugefügt wird

zu - Overhead-Zeit (Messen, Schleifen, Aufrufen von Funktionen)

Nach dem, was er später in der Vorlesung sagte, sollten Sie ein Minimum dieser großen Anzahl von Ausführungen als Ergebnis nehmen. Ich ermutige Sie, sich die Vorlesung anzusehen, in der er erklärt, warum.

Es gibt auch eine sehr gute Bibliothek von Google - https://github.com/google/benchmark . Diese Bibliothek ist sehr einfach zu bedienen und leistungsstark. Sie können einige Vorträge von Chandler Carruth auf Youtube lesen, wo er diese Bibliothek in der Praxis nutzt. Zum Beispiel CppCon 2017: Chandler Carruth „Going Nowhere Faster“;

Anwendungsbeispiel:

#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: Natürlich müssen Sie immer daran denken, dass Ihr Compiler etwas optimieren kann oder nicht. Werkzeuge wie perf können in solchen Fällen nützlich sein.

Einfacher Weg für älteres C ++ oder 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;
}

Timing-Präzision in Sekunden ist 1.0/CLOCKS_PER_SEC

• Es ist eine sehr einfach zu verwendende Methode in C ++ 11.
• Wir können std :: chrono :: high_resolution_clock aus dem Header verwenden
• Wir können eine Methode schreiben, um die Ausführungszeit der Methode in einer gut lesbaren Form zu drucken.

Zum Beispiel dauert es ungefähr 1 Minute und 40 Sekunden, um alle Primzahlen zwischen 1 und 100 Millionen zu finden. Die Ausführungszeit wird also wie folgt gedruckt:

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

Der Code ist hier:

#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, ";
}

Hier ist eine hervorragende Klassenvorlage nur für Header, um die verstrichene Zeit einer Funktion oder eines Codeblocks zu messen:

#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

Hier sind einige Verwendungen davon:

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

Da es sich bei der Klasse um eine Vorlage handelt, können wir ganz einfach festlegen, wie unsere Zeit gemessen und angezeigt werden soll. Dies ist eine sehr praktische Vorlage für Utility-Klassen zum Benchmarking und sehr einfach zu verwenden.

Ich empfehle die Verwendung, steady_clockdie im Gegensatz zu monoton garantiert ist 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
}

Ausgabe:

Hello World!
62
163514

Sie können eine einfache Klasse haben, die für diese Art von Messungen verwendet werden kann.

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

Sie müssen lediglich zu Beginn dieser Funktion ein Objekt in Ihrer Funktion erstellen

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

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

und das ist es. Die Klasse kann an Ihre Anforderungen angepasst werden.

Da keine der bereitgestellten Antworten sehr genau ist oder reproduzierbare Ergebnisse liefert, habe ich beschlossen, meinem Code einen Link hinzuzufügen, der eine Genauigkeit von weniger als einer Nanosekunde und wissenschaftliche Statistiken aufweist.

Beachten Sie, dass dies nur zum Messen von Code funktioniert, dessen Ausführung (sehr) kurze Zeit in Anspruch nimmt (auch bekannt als einige Taktzyklen bis zu einigen Tausend): Wenn sie so lange laufen, dass sie wahrscheinlich durch einen -heh- Interrupt unterbrochen werden dann ist es eindeutig nicht möglich, ein reproduzierbares und genaues Ergebnis zu liefern; Die Folge davon ist, dass die Messung niemals beendet wird: Sie misst weiter, bis statistisch zu 99,9% sicher ist, dass sie die richtige Antwort hat, was auf einem Computer, auf dem andere Prozesse ausgeführt werden, niemals geschieht, wenn der Code zu lange dauert.

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

Wenn Sie Zeit und Codezeilen sparen möchten, können Sie die Messung der Funktionsausführungszeit zu einem einzeiligen Makro machen:

a) Implementiere eine Zeitmessklasse wie oben bereits vorgeschlagen (hier ist meine Implementierung für 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) Fügen Sie ein praktisches Makro hinzu, das den aktuellen Funktionsnamen als TAG verwendet (die Verwendung eines Makros ist hier wichtig, andernfalls __FUNCTION__wird MeasureExecutionTimeanstelle der zu messenden Funktion ausgewertet

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

c) Schreiben Sie Ihr Makro am Anfang der Funktion, die Sie messen möchten. Beispiel:

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

Was zu folgender Ausgabe führt:

ExecutionTime: For DecodeMJPEGtoANativeWindowBuffer is 54ms

Beachten Sie, dass dies (wie alle anderen vorgeschlagenen Lösungen) die Zeit zwischen dem Aufruf Ihrer Funktion und der Rückgabe misst, nicht unbedingt die Zeit, zu der Ihre CPU die Funktion ausgeführt hat. Wenn Sie dem Scheduler jedoch keine Änderung zum Anhalten Ihres laufenden Codes durch Aufrufen von sleep () oder ähnlichem geben, gibt es keinen Unterschied zwischen.