Einfaches Messen der verstrichenen Zeit

Question

Ich versuche zu verwenden Zeit() um verschiedene Punkte meines Programms zu messen.

Was ich nicht verstehe, ist, warum die Werte vorher und nachher gleich sind? Mir ist klar, dass dies nicht der beste Weg ist, um ein Profil meines Programms zu erstellen, ich möchte nur sehen, wie lange etwas dauert.

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

doSomthing();
doSomthingLong();

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

Ich habe es versucht:

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

Wie lese ich ein Ergebnis von **time taken = 0 26339 ? Bedeutet das 26.339 Nanosekunden = 26,3 msec?

Was ist mit **time taken = 4 45025 Bedeutet das 4 Sekunden und 25 msec?

Answer 1

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

Answer 2

0 - Delta

Verwenden Sie eine Deltafunktion zur Berechnung von Zeitdifferenzen:

auto start = std::chrono::steady_clock::now();
std::cout << "Elapsed(ms)=" << since(start).count() << std::endl;

since akzeptiert einen beliebigen Zeitpunkt und erzeugt eine beliebige Dauer (Standard ist Millisekunden). Sie ist definiert als:

template <
    class result_t   = std::chrono::milliseconds,
    class clock_t    = std::chrono::steady_clock,
    class duration_t = std::chrono::milliseconds
>
auto since(std::chrono::time_point<clock_t, duration_t> const& start)
{
    return std::chrono::duration_cast<result_t>(clock_t::now() - start);
}

Demo

1 - Zeitschaltuhr

Verwenden Sie einen Timer, der auf std::chrono :

Timer clock; // Timer<milliseconds, steady_clock>

clock.tick();
/* code you want to measure */
clock.tock();

cout << "Run time = " << clock.duration().count() << " ms\n";

Demo

Timer ist definiert als:

template <class DT = std::chrono::milliseconds,
          class ClockT = std::chrono::steady_clock>
class Timer
{
    using timep_t = typename ClockT::time_point;
    timep_t _start = ClockT::now(), _end = {};

public:
    void tick() { 
        _end = timep_t{}; 
        _start = ClockT::now(); 
    }

    void tock() { _end = ClockT::now(); }

    template <class T = DT> 
    auto duration() const { 
        gsl_Expects(_end != timep_t{} && "toc before reporting"); 
        return std::chrono::duration_cast<T>(_end - _start); 
    }
};

Als Howard Hinnant darauf hingewiesen, verwenden wir eine Dauer für den Verbleib in der chrono Typsystem und führen Operationen wie Mittelwertbildung oder Vergleiche durch (hier bedeutet dies z. B. die Verwendung von std::chrono::milliseconds ). Wenn wir nur IO machen, verwenden wir die count() oder Ticks einer Dauer (z. B. hier Anzahl der Millisekunden).

2 - Instrumentierung

Jede aufrufbare Funktion (Funktion, Funktionsobjekt, Lambda usw.) kann für das Benchmarking instrumentiert werden. Angenommen, Sie haben eine Funktion F aufrufbar mit Argumenten arg1,arg2 führt diese Technik zu:

cout << "F runtime=" << measure<>::duration(F, arg1, arg2).count() << "ms";

<strong>Demo</strong>

measure ist definiert als:

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

Wie in (1) erwähnt, ist die Verwendung der Dauer ohne .count() ist vor allem für Clients nützlich, die eine Reihe von Dauern vor der E/A nachbearbeiten wollen, z. B. für den Durchschnitt:

auto avg = (measure<>::duration(func) + measure<>::duration(func)) / 2;
std::cout << "Average run time " << avg.count() << " ms\n";

---

+ Diese ist der Grund für den weitergeleiteten Funktionsaufruf.

+Der vollständige Code ist zu finden unter aquí

+Mein Versuch, eine Benchmarking-Rahmen basierend auf Chrono wird aufgezeichnet aquí

+Alt démo

Answer 3

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

En time() Funktion ist nur auf eine Sekunde genau, aber es gibt CLOCKS_PER_SEC "Uhren" innerhalb einer Sekunde. Dies ist eine einfache, übertragbare Messung, auch wenn sie stark vereinfacht ist.

Answer 4

Wie ich aus Ihrer Frage ersehen kann, möchten Sie wohl die verstrichene Zeit nach der Ausführung eines bestimmten Codes wissen. Ich vermute, dass Sie gerne die Ergebnisse in Sekunden sehen würden. Wenn ja, versuchen Sie es mit difftime() Funktion wie unten dargestellt. Ich hoffe, damit ist Ihr Problem gelöst.

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

Answer 5

Nur für Windows: (Der Linux-Tag wurde hinzugefügt, nachdem ich diese Antwort veröffentlicht hatte)

Sie können verwenden GetTickCount() um die Anzahl der Millisekunden zu ermitteln, die seit dem Start des Systems verstrichen sind.

long int before = GetTickCount();

// Perform time-consuming operation

long int after = GetTickCount();