So berechnen Sie die Ausführungszeit eines Code-Snippets in C ++

Ich muss die Ausführungszeit eines C ++ - Code-Snippets in Sekunden berechnen. Es muss entweder auf Windows- oder Unix-Computern funktionieren.

Ich benutze Code den folgenden Code, um dies zu tun. (vorher importieren)

clock_t startTime = clock();
// some code here
// to compute its execution duration in runtime
cout << double( clock() - startTime ) / (double)CLOCKS_PER_SEC<< " seconds." << endl;

Bei kleinen Eingaben oder kurzen Anweisungen wie a = a + 1 erhalte ich jedoch das Ergebnis "0 Sekunden". Ich denke, es muss ungefähr 0,0000001 Sekunden oder so sein.

Ich erinnere mich, dass System.nanoTime()in Java in diesem Fall ziemlich gut funktioniert. Ich kann jedoch nicht genau die gleiche Funktionalität von der clock()Funktion von C ++ erhalten.

Hast du eine lösung

Sie können diese Funktion verwenden, die ich geschrieben habe. Sie rufen GetTimeMs64()an und es wird die Anzahl der Millisekunden zurückgegeben, die seit der Unix-Epoche mit der Systemuhr verstrichen sind - genau wie time(NULL)in Millisekunden.

Es funktioniert sowohl unter Windows als auch unter Linux. es ist threadsicher.

Beachten Sie, dass die Granularität unter Windows 15 ms beträgt. Unter Linux ist es implementierungsabhängig, aber normalerweise auch 15 ms.

#ifdef _WIN32
#include <Windows.h>
#else
#include <sys/time.h>
#include <ctime>
#endif

/* Remove if already defined */
typedef long long int64; typedef unsigned long long uint64;

/* Returns the amount of milliseconds elapsed since the UNIX epoch. Works on both
 * windows and linux. */

uint64 GetTimeMs64()
{
#ifdef _WIN32
 /* Windows */
 FILETIME ft;
 LARGE_INTEGER li;

 /* Get the amount of 100 nano seconds intervals elapsed since January 1, 1601 (UTC) and copy it
  * to a LARGE_INTEGER structure. */
 GetSystemTimeAsFileTime(&ft);
 li.LowPart = ft.dwLowDateTime;
 li.HighPart = ft.dwHighDateTime;

 uint64 ret = li.QuadPart;
 ret -= 116444736000000000LL; /* Convert from file time to UNIX epoch time. */
 ret /= 10000; /* From 100 nano seconds (10^-7) to 1 millisecond (10^-3) intervals */

 return ret;
#else
 /* Linux */
 struct timeval tv;

 gettimeofday(&tv, NULL);

 uint64 ret = tv.tv_usec;
 /* Convert from micro seconds (10^-6) to milliseconds (10^-3) */
 ret /= 1000;

 /* Adds the seconds (10^0) after converting them to milliseconds (10^-3) */
 ret += (tv.tv_sec * 1000);

 return ret;
#endif
}

Ich habe ein anderes Arbeitsbeispiel, das Mikrosekunden verwendet (UNIX, POSIX usw.).

    #include <sys/time.h>
    typedef unsigned long long timestamp_t;

    static timestamp_t
    get_timestamp ()
    {
      struct timeval now;
      gettimeofday (&now, NULL);
      return  now.tv_usec + (timestamp_t)now.tv_sec * 1000000;
    }

    ...
    timestamp_t t0 = get_timestamp();
    // Process
    timestamp_t t1 = get_timestamp();

    double secs = (t1 - t0) / 1000000.0L;

Hier ist die Datei, in der wir dies codiert haben:

https://github.com/arhuaco/junkcode/blob/master/emqbit-bench/bench.c

Hier ist eine einfache Lösung in C ++ 11, die Ihnen eine zufriedenstellende Auflösung bietet.

#include <iostream>
#include <chrono>

class Timer
{
public:
    Timer() : beg_(clock_::now()) {}
    void reset() { beg_ = clock_::now(); }
    double elapsed() const { 
        return std::chrono::duration_cast<second_>
            (clock_::now() - beg_).count(); }

private:
    typedef std::chrono::high_resolution_clock clock_;
    typedef std::chrono::duration<double, std::ratio<1> > second_;
    std::chrono::time_point<clock_> beg_;
};

Oder auf * nix für c ++ 03

#include <iostream>
#include <ctime>

class Timer
{
public:
    Timer() { clock_gettime(CLOCK_REALTIME, &beg_); }

    double elapsed() {
        clock_gettime(CLOCK_REALTIME, &end_);
        return end_.tv_sec - beg_.tv_sec +
            (end_.tv_nsec - beg_.tv_nsec) / 1000000000.;
    }

    void reset() { clock_gettime(CLOCK_REALTIME, &beg_); }

private:
    timespec beg_, end_;
};

Hier ist die Beispielverwendung:

int main()
{
    Timer tmr;
    double t = tmr.elapsed();
    std::cout << t << std::endl;

    tmr.reset();
    t = tmr.elapsed();
    std::cout << t << std::endl;

    return 0;
}

Von https://gist.github.com/gongzhitaao/7062087

#include <boost/progress.hpp>

using namespace boost;

int main (int argc, const char * argv[])
{
  progress_timer timer;

  // do stuff, preferably in a 100x loop to make it take longer.

  return 0;
}

Wenn progress_timerder Gültigkeitsbereich verlassen wird, wird die seit seiner Erstellung verstrichene Zeit ausgedruckt.

UPDATE : Hier ist eine Version, die ohne Boost funktioniert (getestet unter macOS / iOS):

#include <chrono>
#include <string>
#include <iostream>
#include <math.h>
#include <unistd.h>

class NLTimerScoped {
private:
    const std::chrono::steady_clock::time_point start;
    const std::string name;

public:
    NLTimerScoped( const std::string & name ) : name( name ), start( std::chrono::steady_clock::now() ) {
    }


    ~NLTimerScoped() {
        const auto end(std::chrono::steady_clock::now());
        const auto duration_ms = std::chrono::duration_cast<std::chrono::milliseconds>( end - start ).count();

        std::cout << name << " duration: " << duration_ms << "ms" << std::endl;
    }

};

int main(int argc, const char * argv[]) {

    {
        NLTimerScoped timer( "sin sum" );

        float a = 0.0f;

        for ( int i=0; i < 1000000; i++ ) {
            a += sin( (float) i / 100 );
        }

        std::cout << "sin sum = " << a << std::endl;
    }



    {
        NLTimerScoped timer( "sleep( 4 )" );

        sleep( 4 );
    }



    return 0;
}

Windows bietet die Funktion QueryPerformanceCounter () und Unix die Funktion gettimeofday (). Beide Funktionen können einen Unterschied von mindestens 1 Mikrosekunde messen.

In einigen Programmen, die ich geschrieben habe, habe ich RDTS für diesen Zweck verwendet. Bei RDTSC geht es nicht um die Zeit, sondern um die Anzahl der Zyklen ab dem Prozessorstart. Sie müssen es auf Ihrem System kalibrieren, um ein Ergebnis in Sekunden zu erhalten. Es ist jedoch sehr praktisch, wenn Sie die Leistung bewerten möchten. Es ist sogar noch besser, die Anzahl der Zyklen direkt zu verwenden, ohne zu versuchen, sie auf Sekunden zurückzusetzen.

(Der obige Link führt zu einer französischen Wikipedia-Seite, enthält jedoch C ++ - Codebeispiele. Die englische Version finden Sie hier. )

Ich schlage vor, die Standardbibliotheksfunktionen zu verwenden, um Zeitinformationen vom System zu erhalten.

Wenn Sie eine feinere Auflösung wünschen, führen Sie mehr Ausführungsiterationen durch. Anstatt das Programm einmal auszuführen und Beispiele zu erhalten, führen Sie es 1000 Mal oder öfter aus.

Es ist besser, die innere Schleife mehrmals mit dem Leistungszeitpunkt nur einmal und durchschnittlich durch Teilen der Wiederholungen der inneren Schleife auszuführen, als das Ganze (Schleife + Leistungszeitpunkt) mehrmals und durchschnittlich auszuführen. Dies reduziert den Overhead des Performance-Timing-Codes im Vergleich zu Ihrem tatsächlichen Profilabschnitt.

Wickeln Sie Ihre Timer-Anrufe für das entsprechende System ein. Für Windows ist QueryPerformanceCounter ziemlich schnell und "sicher" zu verwenden.

Sie können "rdtsc" auch auf jedem modernen X86-PC verwenden, aber auf einigen Multicore-Computern können Probleme auftreten (Core-Hopping kann den Timer ändern) oder wenn Sie einen Geschwindigkeitsschritt aktiviert haben.

(Windows-spezifische Lösung) Die aktuelle (ca. 2017) Möglichkeit, genaue Timings unter Windows zu erhalten, ist die Verwendung von "QueryPerformanceCounter". Dieser Ansatz hat den Vorteil, dass sehr genaue Ergebnisse erzielt werden, und wird von den MS empfohlen. Fügen Sie einfach den Code-Blob in eine neue Konsolen-App ein, um ein funktionierendes Beispiel zu erhalten. Hier gibt es eine lange Diskussion: Erfassen von hochauflösenden Zeitstempeln

#include <iostream>
#include <tchar.h>
#include <windows.h>

int main()
{
constexpr int MAX_ITER{ 10000 };
constexpr __int64 us_per_hour{ 3600000000ull }; // 3.6e+09
constexpr __int64 us_per_min{ 60000000ull };
constexpr __int64 us_per_sec{ 1000000ull };
constexpr __int64 us_per_ms{ 1000ull };

// easy to work with
__int64 startTick, endTick, ticksPerSecond, totalTicks = 0ull;

QueryPerformanceFrequency((LARGE_INTEGER *)&ticksPerSecond);

for (int iter = 0; iter < MAX_ITER; ++iter) {// start looping
    QueryPerformanceCounter((LARGE_INTEGER *)&startTick); // Get start tick
    // code to be timed
    std::cout << "cur_tick = " << iter << "\n";
    QueryPerformanceCounter((LARGE_INTEGER *)&endTick); // Get end tick
    totalTicks += endTick - startTick; // accumulate time taken
}

// convert to elapsed microseconds
__int64 totalMicroSeconds =  (totalTicks * 1000000ull)/ ticksPerSecond;

__int64 hours = totalMicroSeconds / us_per_hour;
totalMicroSeconds %= us_per_hour;
__int64 minutes = totalMicroSeconds / us_per_min;
totalMicroSeconds %= us_per_min;
__int64 seconds = totalMicroSeconds / us_per_sec;
totalMicroSeconds %= us_per_sec;
__int64 milliseconds = totalMicroSeconds / us_per_ms;
totalMicroSeconds %= us_per_ms;


std::cout << "Total time: " << hours << "h ";
std::cout << minutes << "m " << seconds << "s " << milliseconds << "ms ";
std::cout << totalMicroSeconds << "us\n";

return 0;
}

Eine vollständige Lösung für die Thread-Planung, die bei jedem Test genau die gleichen Zeiten liefern sollte, besteht darin, Ihr Programm so zu kompilieren, dass es vom Betriebssystem unabhängig ist, und Ihren Computer hochzufahren, um das Programm in einer betriebssystemfreien Umgebung auszuführen. Dies ist jedoch weitgehend unpraktisch und bestenfalls schwierig.

Ein guter Ersatz für die Betriebssystemfreiheit besteht darin, die Affinität des aktuellen Threads auf 1 Kern und die Priorität auf die höchste zu setzen. Diese Alternative sollte konsistent genug Ergebnisse liefern.

Außerdem sollten Sie Optimierungen deaktivieren, die das Debuggen beeinträchtigen würden, was für g ++ oder gcc das Hinzufügen -Ogzur Befehlszeile bedeutet , um zu verhindern, dass der getestete Code optimiert wird. Das -O0Flag sollte nicht verwendet werden, da es zusätzlichen unnötigen Overhead verursacht, der in den Timing-Ergebnissen enthalten wäre, wodurch die zeitgesteuerte Geschwindigkeit des Codes verzerrt wird.

Im Gegenteil, sowohl unter der Annahme, dass Sie den endgültigen Produktionsbuild verwenden -Ofast(oder zumindest verwenden -O3) als auch das Problem der "toten" Code-Eliminierung ignorieren, werden im -OgVergleich zu nur sehr wenige Optimierungen durchgeführt -Ofast. Dies -Ogkann die tatsächliche Geschwindigkeit des Codes im Endprodukt falsch darstellen.

Darüber hinaus sind alle Geschwindigkeitstests (bis zu einem gewissen Grad) gültig: In dem endgültigen Produktionsprodukt, mit dem kompiliert wurde -Ofast, ist nicht jedes Snippet / jeder Abschnitt / jede Funktion des Codes isoliert. Vielmehr fließt jedes Codeausschnitt kontinuierlich in das nächste, sodass der Compiler potenzielle Codeteile von überall her zusammenfügen, zusammenführen und optimieren kann.

Wenn Sie ein Code-Snippet vergleichen, das stark genutzt wird realloc(), wird das Code-Snippet in einem Produktionsprodukt mit ausreichend hoher Speicherfragmentierung möglicherweise langsamer ausgeführt. Daher gilt für diese Situation der Ausdruck "Das Ganze ist mehr als die Summe seiner Teile", da Code im endgültigen Produktionsbuild möglicherweise merklich schneller oder langsamer ausgeführt wird als das einzelne Snippet, das Sie auf Geschwindigkeit testen.

Eine Teillösung, die die Inkongruenz verringern kann, ist die Verwendung -Ofastfür Geschwindigkeitstests mit Hinzufügung asm volatile("" :: "r"(var))zu den am Test beteiligten Variablen, um die Beseitigung von totem Code / Schleife zu verhindern.

Hier ist ein Beispiel für das Benchmarking von Quadratwurzelfunktionen auf einem Windows-Computer.

// set USE_ASM_TO_PREVENT_ELIMINATION  to 0 to prevent `asm volatile("" :: "r"(var))`
// set USE_ASM_TO_PREVENT_ELIMINATION  to 1 to enforce `asm volatile("" :: "r"(var))`
#define USE_ASM_TO_PREVENT_ELIMINATION 1

#include <iostream>
#include <iomanip>
#include <cstdio>
#include <chrono>
#include <cmath>
#include <windows.h>
#include <intrin.h>
#pragma intrinsic(__rdtsc)
#include <cstdint>

class Timer {
public:
    Timer() : beg_(clock_::now()) {}
    void reset() { beg_ = clock_::now(); }
    double elapsed() const { 
        return std::chrono::duration_cast<second_>
            (clock_::now() - beg_).count(); }
private:
    typedef std::chrono::high_resolution_clock clock_;
    typedef std::chrono::duration<double, std::ratio<1> > second_;
    std::chrono::time_point<clock_> beg_;
};

unsigned int guess_sqrt32(register unsigned int n) {
    register unsigned int g = 0x8000;
    if(g*g > n) {
        g ^= 0x8000;
    }
    g |= 0x4000;
    if(g*g > n) {
        g ^= 0x4000;
    }
    g |= 0x2000;
    if(g*g > n) {
        g ^= 0x2000;
    }
    g |= 0x1000;
    if(g*g > n) {
        g ^= 0x1000;
    }
    g |= 0x0800;
    if(g*g > n) {
        g ^= 0x0800;
    }
    g |= 0x0400;
    if(g*g > n) {
        g ^= 0x0400;
    }
    g |= 0x0200;
    if(g*g > n) {
        g ^= 0x0200;
    }
    g |= 0x0100;
    if(g*g > n) {
        g ^= 0x0100;
    }
    g |= 0x0080;
    if(g*g > n) {
        g ^= 0x0080;
    }
    g |= 0x0040;
    if(g*g > n) {
        g ^= 0x0040;
    }
    g |= 0x0020;
    if(g*g > n) {
        g ^= 0x0020;
    }
    g |= 0x0010;
    if(g*g > n) {
        g ^= 0x0010;
    }
    g |= 0x0008;
    if(g*g > n) {
        g ^= 0x0008;
    }
    g |= 0x0004;
    if(g*g > n) {
        g ^= 0x0004;
    }
    g |= 0x0002;
    if(g*g > n) {
        g ^= 0x0002;
    }
    g |= 0x0001;
    if(g*g > n) {
        g ^= 0x0001;
    }
    return g;
}

unsigned int empty_function( unsigned int _input ) {
    return _input;
}

unsigned long long empty_ticks=0;
double empty_seconds=0;
Timer my_time;

template<unsigned int benchmark_repetitions>
void benchmark( char* function_name, auto (*function_to_do)( auto ) ) {
    register unsigned int i=benchmark_repetitions;
    register unsigned long long start=0;
    my_time.reset();
    start=__rdtsc();
    while ( i-- ) {
        auto result = (*function_to_do)( i << 7 );
        #if USE_ASM_TO_PREVENT_ELIMINATION == 1
            asm volatile("" :: "r"(
                // There is no data type in C++ that is smaller than a char, so it will
                //  not throw a segmentation fault error to reinterpret any arbitrary
                //  data type as a char. Although, the compiler might not like it.
                result
            ));
        #endif
    }
    if ( function_name == nullptr ) {
        empty_ticks = (__rdtsc()-start);
        empty_seconds = my_time.elapsed();
        std::cout<< "Empty:\n" << empty_ticks
              << " ticks\n" << benchmark_repetitions << " repetitions\n"
               << std::setprecision(15) << empty_seconds
                << " seconds\n\n";
    } else {
        std::cout<< function_name<<":\n" << (__rdtsc()-start-empty_ticks)
              << " ticks\n" << benchmark_repetitions << " repetitions\n"
               << std::setprecision(15) << (my_time.elapsed()-empty_seconds)
                << " seconds\n\n";
    }
}


int main( void ) {
    void* Cur_Thread=   GetCurrentThread();
    void* Cur_Process=  GetCurrentProcess();
    unsigned long long  Current_Affinity;
    unsigned long long  System_Affinity;
    unsigned long long furthest_affinity;
    unsigned long long nearest_affinity;

    if( ! SetThreadPriority(Cur_Thread,THREAD_PRIORITY_TIME_CRITICAL) ) {
        SetThreadPriority( Cur_Thread, THREAD_PRIORITY_HIGHEST );
    }
    if( ! SetPriorityClass(Cur_Process,REALTIME_PRIORITY_CLASS) ) {
        SetPriorityClass( Cur_Process, HIGH_PRIORITY_CLASS );
    }
    GetProcessAffinityMask( Cur_Process, &Current_Affinity, &System_Affinity );
    furthest_affinity = 0x8000000000000000ULL>>__builtin_clzll(Current_Affinity);
    nearest_affinity  = 0x0000000000000001ULL<<__builtin_ctzll(Current_Affinity);
    SetProcessAffinityMask( Cur_Process, furthest_affinity );
    SetThreadAffinityMask( Cur_Thread, furthest_affinity );

    const int repetitions=524288;

    benchmark<repetitions>( nullptr, empty_function );
    benchmark<repetitions>( "Standard Square Root", standard_sqrt );
    benchmark<repetitions>( "Original Guess Square Root", original_guess_sqrt32 );
    benchmark<repetitions>( "New Guess Square Root", new_guess_sqrt32 );


    SetThreadPriority( Cur_Thread, THREAD_PRIORITY_IDLE );
    SetPriorityClass( Cur_Process, IDLE_PRIORITY_CLASS );
    SetProcessAffinityMask( Cur_Process, nearest_affinity );
    SetThreadAffinityMask( Cur_Thread, nearest_affinity );
    for (;;) { getchar(); }

    return 0;
}

Dank auch an Mike Jarvis für seinen Timer.

Bitte beachten Sie (dies ist sehr wichtig), dass Sie die Anzahl der Iterationen verringern müssen, wenn Sie größere Codefragmente ausführen möchten, damit Ihr Computer nicht einfriert.

In Fällen, in denen Sie bei jeder Ausführung dieselbe Codestrecke zeitlich festlegen möchten (z. B. für die Profilerstellung von Code, von dem Sie glauben, dass er ein Engpass ist), finden Sie hier eine Zusammenfassung (eine geringfügige Änderung an) der Funktion von Andreas Bonini, die ich nützlich finde:

#ifdef _WIN32
#include <Windows.h>
#else
#include <sys/time.h>
#endif

/*
 *  A simple timer class to see how long a piece of code takes. 
 *  Usage:
 *
 *  {
 *      static Timer timer("name");
 *
 *      ...
 *
 *      timer.start()
 *      [ The code you want timed ]
 *      timer.stop()
 *
 *      ...
 *  }
 *
 *  At the end of execution, you will get output:
 *
 *  Time for name: XXX seconds
 */
class Timer
{
public:
    Timer(std::string name, bool start_running=false) : 
        _name(name), _accum(0), _running(false)
    {
        if (start_running) start();
    }

    ~Timer() { stop(); report(); }

    void start() {
        if (!_running) {
            _start_time = GetTimeMicroseconds();
            _running = true;
        }
    }
    void stop() {
        if (_running) {
            unsigned long long stop_time = GetTimeMicroseconds();
            _accum += stop_time - _start_time;
            _running = false;
        }
    }
    void report() { 
        std::cout<<"Time for "<<_name<<": " << _accum / 1.e6 << " seconds\n"; 
    }
private:
    // cf. http://stackoverflow.com/questions/1861294/how-to-calculate-execution-time-of-a-code-snippet-in-c
    unsigned long long GetTimeMicroseconds()
    {
#ifdef _WIN32
        /* Windows */
        FILETIME ft;
        LARGE_INTEGER li;

        /* Get the amount of 100 nano seconds intervals elapsed since January 1, 1601 (UTC) and copy it
         *   * to a LARGE_INTEGER structure. */
        GetSystemTimeAsFileTime(&ft);
        li.LowPart = ft.dwLowDateTime;
        li.HighPart = ft.dwHighDateTime;

        unsigned long long ret = li.QuadPart;
        ret -= 116444736000000000LL; /* Convert from file time to UNIX epoch time. */
        ret /= 10; /* From 100 nano seconds (10^-7) to 1 microsecond (10^-6) intervals */
#else
        /* Linux */
        struct timeval tv;

        gettimeofday(&tv, NULL);

        unsigned long long ret = tv.tv_usec;
        /* Adds the seconds (10^0) after converting them to microseconds (10^-6) */
        ret += (tv.tv_sec * 1000000);
#endif
        return ret;
    }
    std::string _name;
    long long _accum;
    unsigned long long _start_time;
    bool _running;
};

Nur eine einfache Klasse, die den Codeblock bewertet:

using namespace std::chrono;

class benchmark {
  public:
  time_point<high_resolution_clock>  t0, t1;
  unsigned int *d;
  benchmark(unsigned int *res) : d(res) { 
                 t0 = high_resolution_clock::now();
  }
  ~benchmark() { t1 = high_resolution_clock::now();
                  milliseconds dur = duration_cast<milliseconds>(t1 - t0);
                  *d = dur.count();
  }
};
// simple usage 
// unsigned int t;
// { // put the code in a block
//  benchmark bench(&t);
//  // ...
//  // code to benchmark
// }
// HERE the t contains time in milliseconds

// one way to use it can be :
#define BENCH(TITLE,CODEBLOCK) \
  unsigned int __time__##__LINE__ = 0;  \
  { benchmark bench(&__time__##__LINE__); \
      CODEBLOCK \
  } \
  printf("%s took %d ms\n",(TITLE),__time__##__LINE__);


int main(void) {
  BENCH("TITLE",{
    for(int n = 0; n < testcount; n++ )
      int a = n % 3;
  });
  return 0;
}

boost :: timer gibt Ihnen wahrscheinlich so viel Genauigkeit, wie Sie benötigen. Es ist bei weitem nicht genau genug, um Ihnen zu sagen, wie lange a = a+1;es dauern wird, aber aus welchem ​​Grund müssten Sie etwas zeitlich festlegen, das ein paar Nanosekunden dauert?

Ich habe ein Lambda erstellt, das Sie N-mal aufruft und Ihnen den Durchschnitt zurückgibt.

double c = BENCHMARK_CNT(25, fillVectorDeque(variable));

Den c ++ 11-Header finden Sie hier .

Ich habe ein einfaches Dienstprogramm zum Messen der Leistung von Codeblöcken mithilfe der hochauflösenden Uhr der Chronobibliothek erstellt: https://github.com/nfergu/codetimer .

Timings können für verschiedene Tasten aufgezeichnet werden, und eine aggregierte Ansicht der Timings für jede Taste kann angezeigt werden.

Die Verwendung ist wie folgt:

#include <chrono>
#include <iostream>
#include "codetimer.h"

int main () {
    auto start = std::chrono::high_resolution_clock::now();
    // some code here
    CodeTimer::record("mykey", start);
    CodeTimer::printStats();
    return 0;
}

Sie können sich auch den [cxx-rtimers][1]on GitHub ansehen , der einige Nur-Header-Routinen zum Sammeln von Statistiken zur Laufzeit eines Codeblocks bereitstellt, in dem Sie eine lokale Variable erstellen können. Diese Timer haben Versionen, die std :: chrono unter C ++ 11 verwenden, oder Timer aus der Boost-Bibliothek oder Standard-POSIX-Timerfunktionen. Diese Timer geben die durchschnittliche, maximale und minimale Dauer einer Funktion sowie die Häufigkeit an, mit der sie aufgerufen wird. Sie können wie folgt verwendet werden:

#include <rtimers/cxx11.hpp>

void expensiveFunction() {
    static rtimers::cxx11::DefaultTimer timer("expensive");
    auto scopedStartStop = timer.scopedStart();
    // Do something costly...
}

So mache ich das, nicht viel Code, leicht zu verstehen, passt zu meinen Bedürfnissen:

void bench(std::function<void()> fnBench, std::string name, size_t iterations)
{
    if (iterations == 0)
        return;
    if (fnBench == nullptr)
        return;
    std::chrono::high_resolution_clock::time_point start, end;
    if (iterations == 1)
    {
        start = std::chrono::high_resolution_clock::now();
        fnBench();
        end = std::chrono::high_resolution_clock::now();
    }
    else
    {
        start = std::chrono::high_resolution_clock::now();
        for (size_t i = 0; i < iterations; ++i)
            fnBench();
        end = std::chrono::high_resolution_clock::now();
    }
    printf
    (
        "bench(*, \"%s\", %u) = %4.6lfs\r\n",
        name.c_str(),
        iterations,
        std::chrono::duration_cast<std::chrono::duration<double>>(end - start).count()
    );
}

Verwendung:

bench
(
    []() -> void // function
    {
        // Put your code here
    },
    "the name of this", // name
    1000000 // iterations
);

#include <omp.h>

double start = omp_get_wtime();

// code 

double finish = omp_get_wtime();

double total_time = finish - start;