Łatwo mierz upływ czasu

Próbuję użyć time () do pomiaru różnych punktów mojego programu.

Nie rozumiem, dlaczego wartości przed i po są takie same? Rozumiem, że to nie jest najlepszy sposób na profilowanie mojego programu, chcę tylko zobaczyć, jak długo coś potrwa.

printf("**MyProgram::before time= %ld\n", time(NULL));

doSomthing();
doSomthingLong();

printf("**MyProgram::after time= %ld\n", time(NULL));

Próbowałem:

struct timeval diff, startTV, endTV;

gettimeofday(&startTV, NULL); 

doSomething();
doSomethingLong();

gettimeofday(&endTV, NULL); 

timersub(&endTV, &startTV, &diff);

printf("**time taken = %ld %ld\n", diff.tv_sec, diff.tv_usec);

Jak odczytać wynik **time taken = 0 26339? Czy to oznacza 26 339 nanosekund = 26,3 milisekundy?

A co **time taken = 4 45025to znaczy 4 sekundy i 25 ms?

//***C++11 Style:***
#include <chrono>

std::chrono::steady_clock::time_point begin = std::chrono::steady_clock::now();
std::chrono::steady_clock::time_point end = std::chrono::steady_clock::now();

std::cout << "Time difference = " << std::chrono::duration_cast<std::chrono::microseconds>(end - begin).count() << "[µs]" << std::endl;
std::cout << "Time difference = " << std::chrono::duration_cast<std::chrono::nanoseconds> (end - begin).count() << "[ns]" << std::endl;

#include <ctime>

void f() {
  using namespace std;
  clock_t begin = clock();

  code_to_time();

  clock_t end = clock();
  double elapsed_secs = double(end - begin) / CLOCKS_PER_SEC;
}

time()Funkcja jest dokładna tylko w ciągu sekundy, ale istnieje CLOCKS_PER_SEC„zegary” w ciągu sekundy. Jest to łatwy, przenośny pomiar, nawet jeśli jest zbyt uproszczony.

Możesz wyodrębnić mechanizm pomiaru czasu i mierzyć czas działania każdej z wywołań przy minimalnym dodatkowym kodzie , po prostu przez wywołanie przez strukturę timera. Dodatkowo w czasie kompilacji można sparametryzować rodzaj taktowania (milisekundy, nanosekundy itp.).

^{Dzięki recenzji Lokiego Astari i sugestii zastosowania szablonów variadic. To dlatego przekazywane wywołanie funkcji.}

#include <iostream>
#include <chrono>

template<typename TimeT = std::chrono::milliseconds>
struct measure
{
    template<typename F, typename ...Args>
    static typename TimeT::rep execution(F&& func, Args&&... args)
    {
        auto start = std::chrono::steady_clock::now();
        std::forward<decltype(func)>(func)(std::forward<Args>(args)...);
        auto duration = std::chrono::duration_cast< TimeT> 
                            (std::chrono::steady_clock::now() - start);
        return duration.count();
    }
};

int main() {
    std::cout << measure<>::execution(functor(dummy)) << std::endl;
}

Demo

Według komentarza Howarda Hinnanta najlepiej nie uciekać z systemu chronografu, dopóki nie będziemy musieli. Tak więc powyższa klasa może dać użytkownikowi wybór do countręcznego wywołania poprzez dostarczenie dodatkowej metody statycznej (pokazanej w C ++ 14)

template<typename F, typename ...Args>
static auto duration(F&& func, Args&&... args)
{
    auto start = std::chrono::steady_clock::now();
    std::forward<decltype(func)>(func)(std::forward<Args>(args)...);
    return std::chrono::duration_cast<TimeT>(std::chrono::steady_clock::now()-start);
} 

// call .count() manually later when needed (eg IO)
auto avg = (measure<>::duration(func) + measure<>::duration(func)) / 2.0;

i przydadzą się najbardziej tym klientom

„chcę przetworzyć kilka okresów przed wejściem / wyjściem (np. średnio)”

Pełny kod można znaleźć tutaj . Moja próba zbudowania narzędzia do analizy porównawczej opartej na chrono została tutaj odnotowana .

Jeśli C ++ 17 std::invoke jest dostępny, wywołanie wywoływanego w executionmożna wykonać w następujący sposób:

invoke(forward<decltype(func)>(func), forward<Args>(args)...);

aby zapewnić kallaby, które są wskaźnikami do funkcji składowych.

Jak widzę z twojego pytania, wygląda na to, że chcesz znać upływ czasu po wykonaniu jakiegoś fragmentu kodu. Myślę, że wygodnie byłoby zobaczyć wyniki w sekundach. Jeśli tak, spróbuj użyć difftime()funkcji pokazanej poniżej. Mam nadzieję, że to rozwiąże twój problem.

#include <time.h>
#include <stdio.h>

time_t start,end;
time (&start);
.
.
.
<your code>
.
.
.
time (&end);
double dif = difftime (end,start);
printf ("Elasped time is %.2lf seconds.", dif );

Tylko Windows: (Tag Linux został dodany po opublikowaniu tej odpowiedzi)

Za pomocą GetTickCount () można uzyskać liczbę milisekund, które upłynęły od uruchomienia systemu.

long int before = GetTickCount();

// Perform time-consuming operation

long int after = GetTickCount();

time(NULL)zwraca liczbę sekund, które upłynęły od 01.01.1970 o 00:00 ( Epoka ). Różnica między tymi dwiema wartościami to liczba sekund, które zajęło przetwarzanie.

int t0 = time(NULL);
doSomthing();
doSomthingLong();
int t1 = time(NULL);

printf ("time = %d secs\n", t1 - t0);

Możesz uzyskać lepsze wyniki getttimeofday(), które zwracają bieżący czas w sekundach, podobnie jak time()w mikrosekundach.

funkcja czasu (NULL) zwróci liczbę sekund, które upłynęły od 01.01.1970 o 00:00. A ponieważ ta funkcja jest wywoływana w innym czasie w twoim programie, zawsze będzie różna w C ++

struct profiler
{
    std::string name;
    std::chrono::high_resolution_clock::time_point p;
    profiler(std::string const &n) :
        name(n), p(std::chrono::high_resolution_clock::now()) { }
    ~profiler()
    {
        using dura = std::chrono::duration<double>;
        auto d = std::chrono::high_resolution_clock::now() - p;
        std::cout << name << ": "
            << std::chrono::duration_cast<dura>(d).count()
            << std::endl;
    }
};

#define PROFILE_BLOCK(pbn) profiler _pfinstance(pbn)

Użycie jest poniżej:

{
    PROFILE_BLOCK("Some time");
    // your code or function
}

Jest to podobne do zakresu RAII

UWAGA, to nie jest moje, ale myślałem, że ma to znaczenie

#include<time.h> // for clock
#include<math.h> // for fmod
#include<cstdlib> //for system
#include <stdio.h> //for delay

using namespace std;

int main()
{


   clock_t t1,t2;

   t1=clock(); // first time capture

   // Now your time spanning loop or code goes here
   // i am first trying to display time elapsed every time loop runs

   int ddays=0; // d prefix is just to say that this variable will be used for display
   int dhh=0;
   int dmm=0;
   int dss=0;

   int loopcount = 1000 ; // just for demo your loop will be different of course

   for(float count=1;count<loopcount;count++)
   {

     t2=clock(); // we get the time now

     float difference= (((float)t2)-((float)t1)); // gives the time elapsed since t1 in milliseconds

    // now get the time elapsed in seconds

    float seconds = difference/1000; // float value of seconds
    if (seconds<(60*60*24)) // a day is not over
    {
        dss = fmod(seconds,60); // the remainder is seconds to be displayed
        float minutes= seconds/60;  // the total minutes in float
        dmm= fmod(minutes,60);  // the remainder are minutes to be displayed
        float hours= minutes/60; // the total hours in float
        dhh= hours;  // the hours to be displayed
        ddays=0;
    }
    else // we have reached the counting of days
    {
        float days = seconds/(24*60*60);
        ddays = (int)(days);
        float minutes= seconds/60;  // the total minutes in float
        dmm= fmod(minutes,60);  // the rmainder are minutes to be displayed
        float hours= minutes/60; // the total hours in float
        dhh= fmod (hours,24);  // the hours to be displayed

    }

    cout<<"Count Is : "<<count<<"Time Elapsed : "<<ddays<<" Days "<<dhh<<" hrs "<<dmm<<" mins "<<dss<<" secs";


    // the actual working code here,I have just put a delay function
    delay(1000);
    system("cls");

 } // end for loop

}// end of main 

Wartości wydrukowane przez drugi program to sekundy i mikrosekundy.

0 26339 = 0.026'339 s =   26339 µs
4 45025 = 4.045'025 s = 4045025 µs

#include <ctime>
#include <cstdio>
#include <iostream>
#include <chrono>
#include <sys/time.h>
using namespace std;
using namespace std::chrono;

void f1()
{
  high_resolution_clock::time_point t1 = high_resolution_clock::now();
  high_resolution_clock::time_point t2 = high_resolution_clock::now();
  double dif = duration_cast<nanoseconds>( t2 - t1 ).count();
  printf ("Elasped time is %lf nanoseconds.\n", dif );
}

void f2()
{
  timespec ts1,ts2;
  clock_gettime(CLOCK_REALTIME, &ts1);
  clock_gettime(CLOCK_REALTIME, &ts2);
  double dif = double( ts2.tv_nsec - ts1.tv_nsec );
  printf ("Elasped time is %lf nanoseconds.\n", dif );
}

void f3()
{
  struct timeval t1,t0;
  gettimeofday(&t0, 0);
  gettimeofday(&t1, 0);
  double dif = double( (t1.tv_usec-t0.tv_usec)*1000);
  printf ("Elasped time is %lf nanoseconds.\n", dif );
}
void f4()
{
  high_resolution_clock::time_point t1 , t2;
  double diff = 0;
  t1 = high_resolution_clock::now() ;
  for(int i = 1; i <= 10 ; i++)
  {
    t2 = high_resolution_clock::now() ;
    diff+= duration_cast<nanoseconds>( t2 - t1 ).count();
    t1 = t2;
  }
  printf ("high_resolution_clock:: Elasped time is %lf nanoseconds.\n", diff/10 );
}

void f5()
{
  timespec ts1,ts2;
  double diff = 0;
  clock_gettime(CLOCK_REALTIME, &ts1);
  for(int i = 1; i <= 10 ; i++)
  {
    clock_gettime(CLOCK_REALTIME, &ts2);
    diff+= double( ts2.tv_nsec - ts1.tv_nsec );
    ts1 = ts2;
  }
  printf ("clock_gettime:: Elasped time is %lf nanoseconds.\n", diff/10 );
}

void f6()
{
  struct timeval t1,t2;
  double diff = 0;
  gettimeofday(&t1, 0);
  for(int i = 1; i <= 10 ; i++)
  {
    gettimeofday(&t2, 0);
    diff+= double( (t2.tv_usec-t1.tv_usec)*1000);
    t1 = t2;
  }
  printf ("gettimeofday:: Elasped time is %lf nanoseconds.\n", diff/10 );
}

int main()
{
  //  f1();
  //  f2();
  //  f3();
  f6();
  f4();
  f5();
  return 0;
}

C ++ std :: chrono ma wyraźną zaletę bycia wieloplatformowym. Jednak wprowadza również znaczny narzut w porównaniu do POSIX clock_gettime (). Na moim Linux-ie wszystkie std::chrono::xxx_clock::now()smaki działają mniej więcej tak samo:

std::chrono::system_clock::now()
std::chrono::steady_clock::now()
std::chrono::high_resolution_clock::now()

Chociaż POSIX clock_gettime(CLOCK_MONOTONIC, &time)powinien być taki sam jaksteady_clock::now() ale jest ponad x3 razy szybszy!

Oto mój test na kompletność.

#include <stdio.h>
#include <chrono>
#include <ctime>

void print_timediff(const char* prefix, const struct timespec& start, const 
struct timespec& end)
{
    double milliseconds = end.tv_nsec >= start.tv_nsec
                        ? (end.tv_nsec - start.tv_nsec) / 1e6 + (end.tv_sec - start.tv_sec) * 1e3
                        : (start.tv_nsec - end.tv_nsec) / 1e6 + (end.tv_sec - start.tv_sec - 1) * 1e3;
    printf("%s: %lf milliseconds\n", prefix, milliseconds);
}

int main()
{
    int i, n = 1000000;
    struct timespec start, end;

    // Test stopwatch
    clock_gettime(CLOCK_MONOTONIC, &start);
    for (i = 0; i < n; ++i) {
        struct timespec dummy;
        clock_gettime(CLOCK_MONOTONIC, &dummy);
    }
    clock_gettime(CLOCK_MONOTONIC, &end);
    print_timediff("clock_gettime", start, end);

    // Test chrono system_clock
    clock_gettime(CLOCK_MONOTONIC, &start);
    for (i = 0; i < n; ++i)
        auto dummy = std::chrono::system_clock::now();
    clock_gettime(CLOCK_MONOTONIC, &end);
    print_timediff("chrono::system_clock::now", start, end);

    // Test chrono steady_clock
    clock_gettime(CLOCK_MONOTONIC, &start);
    for (i = 0; i < n; ++i)
        auto dummy = std::chrono::steady_clock::now();
    clock_gettime(CLOCK_MONOTONIC, &end);
    print_timediff("chrono::steady_clock::now", start, end);

    // Test chrono high_resolution_clock
    clock_gettime(CLOCK_MONOTONIC, &start);
    for (i = 0; i < n; ++i)
        auto dummy = std::chrono::high_resolution_clock::now();
    clock_gettime(CLOCK_MONOTONIC, &end);
    print_timediff("chrono::high_resolution_clock::now", start, end);

    return 0;
}

Oto wynik, który otrzymuję po kompilacji z gcc7.2 -O3:

clock_gettime: 24.484926 milliseconds
chrono::system_clock::now: 85.142108 milliseconds
chrono::steady_clock::now: 87.295347 milliseconds
chrono::high_resolution_clock::now: 84.437838 milliseconds

time(NULL)Wywołanie funkcji zwróci liczbę sekund, które upłynęły od EPOC: 1 stycznia 1970. Może co masz na myśli zrobić, to wziąć różnicę między dwoma znacznikami:

size_t start = time(NULL);
doSomthing();
doSomthingLong();

printf ("**MyProgram::time elapsed= %lds\n", time(NULL) - start);

Jak już zauważyli inni, funkcja time () w standardowej bibliotece C nie ma rozdzielczości lepszej niż jedna sekunda. Jedyną w pełni przenośną funkcją C, która może zapewnić lepszą rozdzielczość, wydaje się być clock (), ale raczej mierzy czas procesora niż czas zegara ściennego. Jeśli ktoś chce ograniczyć się do platform POSIX (np. Linux), to funkcja clock_gettime () jest dobrym wyborem.

Od wersji C ++ 11 istnieją znacznie lepsze możliwości pomiaru czasu które oferują lepszą rozdzielczość w formie, która powinna być bardzo przenośna w różnych kompilatorach i systemach operacyjnych. Podobnie biblioteka boost :: datetime zapewnia dobre klasy czasowe wysokiej rozdzielczości, które powinny być wysoce przenośne.

Jednym z wyzwań przy korzystaniu z któregokolwiek z tych urządzeń jest opóźnienie czasowe wprowadzone przez zapytanie zegara systemowego. Od eksperymentowania z clock_gettime (), boost :: datetime i std :: chrono, to opóźnienie może być łatwo kwestią mikrosekund. Tak więc, mierząc czas trwania dowolnej części kodu, musisz pozwolić, aby wystąpił błąd pomiaru mniej więcej tego rozmiaru, lub spróbuj w jakiś sposób poprawić ten błąd zerowy. Najlepiej byłoby zebrać wiele pomiarów czasu zajętych przez funkcję i obliczyć średni lub maksymalny / minimalny czas potrzebny na wiele przebiegów.

Aby pomóc w rozwiązaniu wszystkich problemów związanych z przenośnością i gromadzeniem statystyk, opracowałem bibliotekę cxx-rtimers dostępną na Github, która stara się zapewnić prosty interfejs API dla bloków czasowych kodu C ++, obliczania zerowych błędów i raportowania statystyk z wielu osadzonych timerów w twoim kodzie. Jeśli masz kompilator C ++ 11, po prostu #include <rtimers/cxx11.hpp>i użyj czegoś takiego:

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

Po wyjściu z programu otrzymasz podsumowanie statystyk czasowych zapisanych do std :: cerr, takich jak:

Timer(expensiveFunc): <t> = 6.65289us, std = 3.91685us, 3.842us <= t <= 63.257us (n=731)

który pokazuje średni czas, jego odchylenie standardowe, górną i dolną granicę oraz liczbę wywołań tej funkcji.

Jeśli chcesz korzystać z funkcji czasowych specyficznych dla Linuksa, możesz #include <rtimers/posix.hpp>, lub jeśli masz biblioteki Boost, ale starszy kompilator C ++, możesz #include <rtimers/boost.hpp>. Istnieją również wersje tych klas timerów, które mogą gromadzić statystyczne informacje o taktowaniu z wielu wątków. Istnieją również metody, które pozwalają oszacować błąd zerowy związany z dwoma bezpośrednio kolejnymi zapytaniami zegara systemowego.

Funkcja ta wewnętrznie uzyskuje dostęp do zegara systemowego, dlatego zwraca inne wartości za każdym razem, gdy go wywołujesz. Ogólnie w przypadku języków niefunkcjonalnych w funkcjach może występować wiele efektów ubocznych i ukrytych funkcji, których nie można zobaczyć, patrząc tylko na nazwę funkcji i argumenty.

Z tego, co widać, tv_sec przechowuje sekundy, które upłynęły, a tv_usec przechowuje mikrosekundy, które upłynęły osobno. I nie są nawzajem konwersjami. Dlatego należy je zmienić na odpowiednią jednostkę i dodać, aby uzyskać całkowity czas, który upłynął.

struct timeval startTV, endTV;

gettimeofday(&startTV, NULL); 

doSomething();
doSomethingLong();

gettimeofday(&endTV, NULL); 

printf("**time taken in microseconds = %ld\n",
    (endTV.tv_sec * 1e6 + endTV.tv_usec - (startTV.tv_sec * 1e6 + startTV.tv_usec))
    );

W Linuksie clock_gettime () jest jednym z dobrych wyborów. Musisz połączyć bibliotekę czasu rzeczywistego (-lrt).

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <time.h>

#define BILLION  1000000000L;

int main( int argc, char **argv )
  {
    struct timespec start, stop;
    double accum;

    if( clock_gettime( CLOCK_REALTIME, &start) == -1 ) {
      perror( "clock gettime" );
      exit( EXIT_FAILURE );
    }

    system( argv[1] );

    if( clock_gettime( CLOCK_REALTIME, &stop) == -1 ) {
      perror( "clock gettime" );
      exit( EXIT_FAILURE );
    }

    accum = ( stop.tv_sec - start.tv_sec )
          + ( stop.tv_nsec - start.tv_nsec )
            / BILLION;
    printf( "%lf\n", accum );
    return( EXIT_SUCCESS );
  }

Musiałem zmierzyć czas wykonywania poszczególnych funkcji w bibliotece. Nie chciałem kończyć każdego wywołania każdej funkcji funkcją pomiaru czasu, ponieważ jest brzydka i pogłębia stos wywołań. Nie chciałem również umieszczać kodu czasowego na górze i na dole każdej funkcji, ponieważ robi to bałagan, gdy funkcja może wyjść wcześniej lub na przykład zgłasza wyjątki. Skończyło się na zrobieniu timera, który używa własnego czasu życia do mierzenia czasu.

W ten sposób mogę zmierzyć czas ściany bloku kodu, po prostu tworząc instancję jednego z tych obiektów na początku danego bloku kodu (naprawdę funkcja lub dowolny zakres), a następnie pozwalając destruktorowi instancji na pomiar czasu, który upłynął od konstrukcja, gdy instancja wykracza poza zakres. Możesz znaleźć pełny przykład tutaj, ale struktura jest niezwykle prosta:

template <typename clock_t = std::chrono::steady_clock>
struct scoped_timer {
  using duration_t = typename clock_t::duration;
  const std::function<void(const duration_t&)> callback;
  const std::chrono::time_point<clock_t> start;

  scoped_timer(const std::function<void(const duration_t&)>& finished_callback) :
      callback(finished_callback), start(clock_t::now()) { }
  scoped_timer(std::function<void(const duration_t&)>&& finished_callback) :
      callback(finished_callback), start(clock_t::now()) { }
  ~scoped_timer() { callback(clock_t::now() - start); }
};

Struktura oddzwoni na dostarczony funktor, gdy wyjdzie poza zakres, abyś mógł zrobić coś z informacjami o taktowaniu (wydrukować lub zapisać lub cokolwiek innego). Jeśli trzeba zrobić coś jeszcze bardziej skomplikowane można nawet korzystać std::bindz std::placeholdersdo callback funkcje z większą liczbą argumentów.

Oto szybki przykład użycia:

void test(bool should_throw) {
  scoped_timer<> t([](const scoped_timer<>::duration_t& elapsed) {
    auto e = std::chrono::duration_cast<std::chrono::duration<double, std::milli>>(elapsed).count();
    std::cout << "took " << e << "ms" << std::endl;
  });

  std::this_thread::sleep_for(std::chrono::seconds(1));

  if (should_throw)
    throw nullptr;

  std::this_thread::sleep_for(std::chrono::seconds(1));
}

Jeśli chcesz być bardziej rozmyślny, możesz również użyć newi deletejawnie uruchomić i zatrzymać stoper bez polegania na określaniu zakresu, aby zrobić to za Ciebie.

Są one takie same, ponieważ funkcja doSomething zachodzi szybciej niż ziarnistość timera. Próbować:

printf ("**MyProgram::before time= %ld\n", time(NULL));

for(i = 0; i < 1000; ++i) {
    doSomthing();
    doSomthingLong();
}

printf ("**MyProgram::after time= %ld\n", time(NULL));

Obie wartości są takie same, ponieważ twoja długa procedura nie trwa tak długo - krócej niż sekundę. Możesz spróbować po prostu dodać długą pętlę (dla (int i = 0; i <100000000; i ++);) na końcu funkcji, aby upewnić się, że to jest problem, a następnie możemy przejść od tego ...

Jeśli powyższe okaże się prawdą, musisz znaleźć inną funkcję systemową (rozumiem, że pracujesz na Linuksie, więc nie mogę ci pomóc z nazwą funkcji), aby dokładniej zmierzyć czas. Jestem pewien, że w Linuksie jest funkcja podobna do GetTickCount (), wystarczy ją znaleźć.

Zwykle używam następujących:

#include <chrono>
#include <type_traits>

using perf_clock = std::conditional<
    std::chrono::high_resolution_clock::is_steady,
    std::chrono::high_resolution_clock,
    std::chrono::steady_clock
>::type;

using floating_seconds = std::chrono::duration<double>;

template<class F, class... Args>
floating_seconds run_test(Func&& func, Args&&... args)
{
   const auto t0 = perf_clock::now();
   std::forward<Func>(func)(std::forward<Args>(args)...);
   return floating_seconds(perf_clock::now() - t0);
} 

Jest to to samo, co proponowane przez @ nikos-athanasiou, z tym wyjątkiem, że unikam używania niestałego zegara i używam zmiennej liczby sekund jako czasu trwania.

W odpowiedzi na trzy szczegółowe pytania OP .

„Nie rozumiem, dlaczego wartości przed i po są takie same? ”

Pierwsze pytanie i próbki kodu pokazuje, że time()ma rozdzielczość 1 sekundę, więc odpowiedź musi być tak, że dwie funkcje wykonywane w mniej niż 1 sekundę. Ale od czasu do czasu poinformuje (najwyraźniej nielogicznie) o 1 sekundzie, jeśli dwa znaki timera przekraczają jedną sekundę.

W następnym przykładzie użyto gettimeofday()wypełnienia tej struktury

struct timeval {
    time_t      tv_sec;     /* seconds */
    suseconds_t tv_usec;    /* microseconds */
};

a drugie pytanie brzmi : „Jak odczytać wynik **time taken = 0 26339? Czy to oznacza 26 339 nanosekund = 26,3 ms?”

Moja druga odpowiedź to czas zajęty to 0 sekund i 26339 mikrosekund, czyli 0,026339 sekund, co dowodzi, że pierwszy przykład działa w czasie krótszym niż 1 sekunda.

Trzecie pytanie pyta: „A co **time taken = 4 45025, to znaczy, 4 sekundy i 25 ms?”

Moja trzecia odpowiedź to 4 sekundy i 45025 mikrosekund, czyli 4,045025 sekund, co pokazuje, że OP zmienił zadania wykonywane przez dwie funkcje, które wcześniej mierzył.

#include <ctime>
#include <functional>

using namespace std;

void f() {
  clock_t begin = clock();

  // ...code to measure time...

  clock_t end = clock();

  function<double(double, double)> convtime = [](clock_t begin, clock_t end)
  {
     return double(end - begin) / CLOCKS_PER_SEC;
  };

  printf("Elapsed time: %.2g sec\n", convtime(begin, end));

}

Podobny przykład do tego tutaj dostępnego, tylko z dodatkową funkcją konwersji + wydruku.

Utworzyłem klasę do automatycznego pomiaru upływu czasu. Sprawdź kod (c ++ 11) w tym linku: https://github.com/sonnt174/Common/blob/master/time_measure.h

Przykład użycia klasy TimeMeasure:

void test_time_measure(std::vector<int> arr) {
  TimeMeasure<chrono::microseconds> time_mea;  // create time measure obj
  std::sort(begin(arr), end(arr));
}

Matlab przyprawiony!

ticuruchamia stoper w celu pomiaru wydajności. Funkcja rejestruje czas wewnętrzny przy wykonywaniu polecenia tic. Wyświetlaj upływający czas za pomocą tocfunkcji.

#include <iostream>
#include <ctime>
#include <thread>
using namespace std;

clock_t START_TIMER;

clock_t tic()
{
    return START_TIMER = clock();
}

void toc(clock_t start = START_TIMER)
{
    cout
        << "Elapsed time: "
        << (clock() - start) / (double)CLOCKS_PER_SEC << "s"
        << endl;
}

int main()
{
    tic();
    this_thread::sleep_for(2s);
    toc();

    return 0;
}

Możesz użyć biblioteki SFML , która jest prostą i szybką biblioteką multimedialną. Zawiera wiele użytecznych i dobrze zdefiniowanych klas, takich jak Zegar, Gniazdo, Dźwięk, Grafika itp. Jest tak łatwy w użyciu i wysoce zalecany.

To jest przykład tego pytania.

sf::Clock clock;
...
Time time1 = clock.getElapsedTime();
...
Time time2 = clock.restart();