genaue Zeitmessung

Ich verwende time.h in C++, um das Timing einer Funktion zu messen.

clock_t t = clock();
someFunction();
printf("\nTime taken: %.4fs\n", (float)(clock() - t)/CLOCKS_PER_SEC);

Ich bekomme jedoch immer die Zeit als 0,0000. clock() und t haben, wenn sie separat gedruckt werden, den gleichen Wert. Ich würde gerne wissen, ob es eine Möglichkeit gibt, die Zeit in C++ genau zu messen (vielleicht in der Größenordnung von Nanosekunden). Ich verwende VS2010.

C++11 führte die Chrono-APIkönnen Sie verwenden, um Nanosekunden zu erhalten:

auto begin = std::chrono::high_resolution_clock::now();

// code to benchmark

auto end = std::chrono::high_resolution_clock::now();
std::cout << std::chrono::duration_cast<std::chrono::nanoseconds>(end-begin).count() << "ns" << std::endl;

Für einen relevanteren Wert ist es gut, die Funktion mehrmals auszuführen und den Durchschnitt zu berechnen:

auto begin = std::chrono::high_resolution_clock::now();
uint32_t iterations = 10000;
for(uint32_t i = 0; i < iterations; ++i)
{
    // code to benchmark
}
auto end = std::chrono::high_resolution_clock::now();
auto duration = std::chrono::duration_cast<std::chrono::nanoseconds>(end-begin).count();
std::cout << duration << "ns total, average : " << duration / iterations << "ns." << std::endl;

Aber denken Sie daran for Schleife und Zuweisung begin und end var verbraucht auch etwas CPU-Zeit.

Ich benutze meistens die QueryPerformanceCounter Funktion.

Beispiel:

LARGE_INTEGER frequency;        // ticks per second
LARGE_INTEGER t1, t2;           // ticks
double elapsedTime;

// get ticks per second
QueryPerformanceFrequency(&frequency);

// start timer
QueryPerformanceCounter(&t1);

// do something
...

// stop timer
QueryPerformanceCounter(&t2);

// compute and print the elapsed time in millisec
elapsedTime = (t2.QuadPart - t1.QuadPart) * 1000.0 / frequency.QuadPart;

Aus dem folgenden Text, dem ich vollkommen zustimme, wird zitiert Optimierung von Software in C++ (gute Lektüre für jeden C++ Programmierer) –

Die Zeitmessungen können eine sehr hohe Auflösung erfordern, wenn die Zeitintervalle kurz sind. Unter Windows können Sie die
GetTickCount oder
QueryPerformanceCounter Funktionen für Millisekundenauflösung. Eine viel höhere Auflösung kann mit dem Zeitstempelzähler in der CPU erreicht werden, der mit der CPU-Taktfrequenz zählt.

Es besteht das Problem, dass “die Taktfrequenz dynamisch variieren kann und dass die Messungen aufgrund von Interrupts und Task-Wechseln instabil sind”.

In C oder C++ mache ich normalerweise wie unten. Wenn es immer noch fehlschlägt, können Sie die Verwendung von rtdsc-Funktionen in Betracht ziehen

      struct timeval time;
      gettimeofday(&time, NULL); // Start Time

      long totalTime = (time.tv_sec * 1000) + (time.tv_usec / 1000);

          //........ call your functions here

        gettimeofday(&time, NULL);  //END-TIME

        totalTime = (((time.tv_sec * 1000) + (time.tv_usec / 1000)) - totalTime);