Jak obliczyć czas wykonania fragmentu kodu w C ++

Muszę obliczyć czas wykonania fragmentu kodu C ++ w sekundach. Musi działać na komputerach z systemem Windows lub Unix.

Używam kodu następującego kodu, aby to zrobić. (zaimportuj przed)

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

Jednak w przypadku małych danych wejściowych lub krótkich instrukcji, takich jak a = a + 1, otrzymuję wynik „0 sekund”. Myślę, że to musi być około 0,0000001 sekundy lub coś w tym rodzaju.

Pamiętam, że System.nanoTime()w Javie działa w tym przypadku całkiem nieźle. Jednak nie mogę uzyskać tej samej dokładnej funkcjonalności z clock()funkcji C ++.

Masz rozwiązanie?

Możesz użyć tej funkcji, którą napisałem. Wołasz GetTimeMs64()i zwraca liczbę milisekund, które upłynęły od epoki unixowej przy użyciu zegara systemowego - podobnie time(NULL), z wyjątkiem milisekund.

Działa zarówno w systemie Windows, jak i Linux; jest bezpieczny dla wątków.

Zauważ, że szczegółowość wynosi 15 ms w systemie Windows; w Linuksie jest to zależne od implementacji, ale zwykle również 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
}

Mam inny działający przykład, który używa mikrosekund (UNIX, POSIX itp.).

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

Oto plik, w którym to zakodowaliśmy:

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

Oto proste rozwiązanie w C ++ 11, które daje satysfakcjonującą rozdzielczość.

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

Lub na * nix, dla 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_;
};

Oto przykład użycia:

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

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

Gdy progress_timerwyjdzie poza zakres, wydrukuje czas, który upłynął od jego utworzenia.

AKTUALIZACJA : Oto wersja, która działa bez funkcji Boost (testowana na 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 udostępnia funkcję QueryPerformanceCounter (), a Unix - gettimeofday () Obie funkcje mogą mierzyć różnicę co najmniej 1 mikro-sekundy.

W niektórych programach, które napisałem, używałem do tego celu RDTS . RDTSC nie dotyczy czasu, ale liczby cykli od uruchomienia procesora. Musisz skalibrować go w swoim systemie, aby uzyskać wynik w ciągu sekundy, ale jest to naprawdę przydatne, gdy chcesz ocenić wydajność, nawet lepiej jest użyć liczby cykli bezpośrednio, bez próby zmiany ich z powrotem na sekundy.

(powyższy link prowadzi do strony francuskiej Wikipedii, ale zawiera próbki kodu C ++, angielska wersja jest tutaj )

Proponuję wykorzystać standardowe funkcje biblioteczne do uzyskania informacji o czasie z systemu.

Jeśli chcesz uzyskać lepszą rozdzielczość, wykonaj więcej iteracji wykonania. Zamiast uruchamiać program raz i pobierać próbki, uruchom go 1000 lub więcej razy.

Lepiej jest uruchomić wewnętrzną pętlę kilka razy z taktowaniem wydajności tylko raz i średnio, dzieląc powtórzenia pętli wewnętrznej, niż uruchamiać całość (pętla + synchronizacja wydajności) kilka razy i średnio. Zmniejszy to obciążenie związane z kodem czasowym wydajności w porównaniu z rzeczywistą sekcją profilowaną.

Zawiń wywołania timera dla odpowiedniego systemu. W systemie Windows QueryPerformanceCounter jest dość szybki i „bezpieczny” w użyciu.

Możesz użyć "rdtsc" również na każdym nowoczesnym komputerze PC X86, ale mogą wystąpić problemy na niektórych maszynach wielordzeniowych (skakanie rdzenia może zmienić licznik czasu) lub jeśli masz włączony jakiś rodzaj szybkości.

(rozwiązanie specyficzne dla systemu Windows) Obecnie (około 2017 r.) sposobem uzyskania dokładnych czasów w systemie Windows jest użycie „QueryPerformanceCounter”. Takie podejście ma tę zaletę, że daje bardzo dokładne wyniki i jest zalecane przez MS. Po prostu umieść kod blob w nowej aplikacji konsoli, aby uzyskać działający przykład. Istnieje tu długa dyskusja: Pozyskiwanie znaczników czasu w wysokiej rozdzielczości

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

Kompletnym niezawodnym rozwiązaniem planowania wątków, które powinno dawać dokładnie takie same czasy w każdym teście, jest skompilowanie programu, aby był niezależny od systemu operacyjnego i uruchomienie komputera w celu uruchomienia programu w środowisku wolnym od systemu operacyjnego. Jest to jednak w dużej mierze niepraktyczne i co najwyżej trudne.

Dobrym substytutem przejścia bez systemu operacyjnego jest po prostu ustawienie koligacji bieżącego wątku na 1 rdzeń i priorytet na najwyższy. Ta alternatywa powinna zapewnić wystarczająco spójne wyniki.

Powinieneś także wyłączyć optymalizacje, które kolidowałyby z debugowaniem, co w przypadku g ++ lub gcc oznacza dodanie -Ogdo wiersza poleceń , aby zapobiec optymalizacji testowanego kodu. -O0Flaga nie powinna być stosowana, ponieważ wprowadza dodatkowe niepotrzebne obciążenie, które zostaną uwzględnione w wynikach pomiaru czasu, a tym samym pochylanie się czasowe szybkości kodu.

Wręcz przeciwnie, zarówno zakładając, że używasz -Ofast(lub przynajmniej -O3) w końcowej kompilacji produkcyjnej, jak i ignorując kwestię eliminacji „martwego” kodu, -Ogprzeprowadza bardzo niewiele optymalizacji w porównaniu z -Ofast; w ten sposób -Ogmoże fałszywie przedstawić rzeczywistą prędkość kodu w produkcie końcowym.

Co więcej, wszystkie testy szybkości (do pewnego stopnia) krzywoprzysięstwa: w skompilowanym produkcie końcowym -Ofastkażdy fragment / sekcja / funkcja kodu nie jest izolowana; raczej każdy fragment kodu nieustannie przepływa do następnego, umożliwiając w ten sposób kompilatorowi potencjalne łączenie, scalanie i optymalizowanie razem fragmentów kodu z każdego miejsca.

W tym samym czasie, jeśli porównujesz fragment kodu, który jest intensywnie używany realloc(), fragment kodu może działać wolniej w produkcie produkcyjnym z wystarczająco dużą fragmentacją pamięci. Stąd wyrażenie „całość to więcej niż suma jej części” odnosi się do tej sytuacji, ponieważ kod w końcowej wersji produkcyjnej może działać zauważalnie szybciej lub wolniej niż pojedynczy fragment kodu, który szybko testujesz.

Częściowym rozwiązaniem, które może zmniejszyć niezgodność, jest użycie -Ofastdo testowania szybkości z dodatkiem asm volatile("" :: "r"(var))do zmiennych biorących udział w teście w celu zapobieżenia eliminacji martwego kodu / pętli.

Oto przykład testu porównawczego funkcji pierwiastka kwadratowego na komputerze z systemem Windows.

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

Również uznanie dla Mike'a Jarvisa za jego Timer.

Pamiętaj (jest to bardzo ważne), że jeśli zamierzasz uruchamiać większe fragmenty kodu, to naprawdę musisz zmniejszyć liczbę iteracji, aby zapobiec zawieszaniu się komputera.

W przypadkach, w których chcesz mierzyć ten sam odcinek kodu za każdym razem, gdy jest on wykonywany (np. W celu profilowania kodu, który Twoim zdaniem może stanowić wąskie gardło), oto wrapper (niewielka modyfikacja) funkcji Andreasa Boniniego, która jest przydatna:

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

po prostu prosta klasa, która porównuje blok kodu:

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 prawdopodobnie zapewni Ci taką dokładność, jakiej potrzebujesz. Nie jest wystarczająco dokładne, aby powiedzieć, ile czasu a = a+1;to zajmie, ale z jakiego powodu miałbyś mieć czas na coś, co zajmuje kilka nanosekund?

Utworzyłem lambdę, która wywołuje wywołanie funkcji N razy i zwraca średnią.

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

Możesz znaleźć nagłówek c ++ 11 tutaj .

Stworzyłem proste narzędzie do pomiaru wydajności bloków kodu, korzystając z funkcji high_resolution_clock biblioteki chrono: https://github.com/nfergu/codetimer .

Czasy można rejestrować dla różnych kluczy i można wyświetlić zbiorczy widok czasów dla każdego klawisza.

Sposób użycia jest następujący:

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

Możesz również przyjrzeć się [cxx-rtimers][1]witrynie GitHub, która udostępnia pewne procedury zawierające tylko nagłówki do zbierania statystyk dotyczących czasu wykonywania dowolnego bloku kodu, w którym można utworzyć zmienną lokalną. Te timery mają wersje, które używają std :: chrono w C ++ 11, timerów z biblioteki Boost lub standardowych funkcji timera POSIX. Te liczniki czasu będą zgłaszać średni, maksymalny i minimalny czas spędzony w funkcji, a także liczbę wywołań. Można ich używać w następujący sposób:

#include <rtimers/cxx11.hpp>

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

Tak to robię, mało kodu, łatwy do zrozumienia, pasuje do moich potrzeb:

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

Stosowanie:

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;