Verwendung von clock () in C ++

127

Wie rufe ich clock()an C++?

Ich möchte beispielsweise testen, wie viel Zeit eine lineare Suche benötigt, um ein bestimmtes Element in einem Array zu finden.

dato datuashvili
quelle
1
Beachten Sie, dass die Wanduhrzeit nicht immer ein guter Weg ist, um Mikrobenchmarks zu messen. Um konsistente Ergebnisse zu erzielen, müssen Sie die CPU-Frequenzskalierung umgehen (einschließlich Intel Turbo oder des AMD-Äquivalents, mit dem Ihre CPU höher taktet, wenn die thermischen / Leistungsgrenzen dies zulassen). Durch die Profilerstellung mit Leistungsindikatoren können Sie Messungen in Kerntaktzyklen durchführen (und auch Details darüber, ob ein Engpass Cache-Fehlschläge im Vergleich zum Befehlsdurchsatz im Vergleich zur Latenz sind, indem Sie andere Zähler als nur Zyklen betrachten). Unter Linuxperf stat -d ./a.out
Peter Cordes

Antworten:

207
#include <iostream>
#include <cstdio>
#include <ctime>

int main() {
    std::clock_t start;
    double duration;

    start = std::clock();

    /* Your algorithm here */

    duration = ( std::clock() - start ) / (double) CLOCKS_PER_SEC;

    std::cout<<"printf: "<< duration <<'\n';
}
Dolph
quelle
5
Nach dem , was ich hier unter cplusplus.com/reference/ctime/clock sehen kann , müssen Sie die Notation "std ::" nicht verwenden. Verwenden Sie einfach "clock ()"
gromit190
4
@Birger: In allen Projekten, an denen ich gearbeitet habe, erfordert der Codestil std :: vor jedem std :: -Aufruf.
Th. Thielemann
2
Gibt dies die Antwort in Sekunden zurück?
Arnav Borborah
1
@ArnavBorborah Ja, das tut es.
QuantumHoneybees
1
@ Th.Thielemann beide clock()und clock_tstammen aus dem Header der C Standard Library von time.hund benötigen daher stdnach der Aufnahme ihrer Bibliotheken keine Namespace-Präfixe. <ctime>Umschließt diesen Wert und diese Funktion mit dem stdNamespace, muss jedoch nicht verwendet werden. Überprüfen Sie hier für Implementierungsdetails: en.cppreference.com/w/cpp/header/ctime
kayleeFrye_onDeck
70

Eine alternative Lösung, die portabel und präziser ist und seit C ++ 11 verfügbar ist, ist die Verwendung std::chrono.

Hier ist ein Beispiel:

#include <iostream>
#include <chrono>
typedef std::chrono::high_resolution_clock Clock;

int main()
{
    auto t1 = Clock::now();
    auto t2 = Clock::now();
    std::cout << "Delta t2-t1: " 
              << std::chrono::duration_cast<std::chrono::nanoseconds>(t2 - t1).count()
              << " nanoseconds" << std::endl;
}

Das auf ideone.com auszuführen gab mir:

Delta t2-t1: 282 nanoseconds
Martin G.
quelle
11
Wenn Sie C ++ 11 verwenden möchten, können Sie auch schreiben using Clock=std::chrono::high_resolution_clock;. Siehe Typalias .
JHBonarius
std::chrono::high_resolution_clockist nicht bei allen Standard-Lib-Implementierungen monoton. Aus der Referenz - Im Allgemeinen sollte man nur std :: chrono :: stetige Uhr oder std :: chrono :: system_clock direkt anstelle von std :: chrono :: high_resolution_clock verwenden: benutze stetige Uhr für Dauermessungen und system_clock für die Wanduhrzeit.
Kristianmitk
30

clock()Gibt die Anzahl der Uhr-Ticks seit dem Start Ihres Programms zurück. Es gibt eine verwandte Konstante, CLOCKS_PER_SECdie angibt, wie viele Taktstriche in einer Sekunde auftreten. So können Sie jede Operation wie folgt testen:

clock_t startTime = clock();
doSomeOperation();
clock_t endTime = clock();
clock_t clockTicksTaken = endTime - startTime;
double timeInSeconds = clockTicksTaken / (double) CLOCKS_PER_SEC;
Shirik
quelle
6
timeInSecondskommt immer 0.000000für mich. Wie würde ich das beheben?
Noufal
3
@noufal Vielleicht ist die aufgewendete Zeit so kurz, dass sie als 0 angezeigt wird. Sie könnten versuchen, eine long doublezu verwenden, um mehr Präzision zu erzielen .
Gerard
Wahrscheinlich ist Ihre Taktauflösung nicht hoch genug, sodass keine Zeit verstrichen ist.
Marco Freudenberger
4

Zumindest unter Windows ist QueryPerformanceCounter (QPC) der einzige praktisch genaue Messmechanismus. std :: chrono wird damit implementiert (seit VS2015, wenn Sie das verwenden), aber es ist nicht in demselben Maße genau wie die direkte Verwendung von QueryPerformanceCounter. Insbesondere ist die Behauptung, bei 1 Nanosekunde Granularität zu melden, absolut nicht korrekt. Wenn Sie also etwas messen, das nur sehr kurze Zeit in Anspruch nimmt (und Ihr Fall könnte ein solcher Fall sein), sollten Sie QPC oder das Äquivalent für Ihr Betriebssystem verwenden. Ich bin beim Messen der Cache-Latenzen darauf gestoßen und habe einige Notizen notiert, die Sie hier möglicherweise nützlich finden. https://github.com/jarlostensen/notesandcomments/blob/master/stdchronovsqcp.md

SonarJetLens
quelle
0
#include <iostream>
#include <ctime>
#include <cstdlib> //_sleep()  --- just a function that waits a certain amount of milliseconds

using namespace std;

int main()
{

    clock_t cl;     //initializing a clock type

    cl = clock();   //starting time of clock

    _sleep(5167);   //insert code here

    cl = clock() - cl;  //end point of clock

    _sleep(1000);   //testing to see if it actually stops at the end point

    cout << cl/(double)CLOCKS_PER_SEC << endl;  //prints the determined ticks per second (seconds passed)


    return 0;
}

//outputs "5.17"
Garrett
quelle
Dies ergänzt nicht die bereits beantwortete Frage. Schlaf nach cl = clock () - cl wird nicht benötigt. Und der Cout druckt Sekunden, nicht Ticks pro Sekunde. cl speichert die Uhrzecken.
Dr. Yunke
0

Wahrscheinlich interessieren Sie sich für einen Timer wie diesen: H: M: S. Msec.

der Code in Linux OS:

#include <iostream>
#include <unistd.h>

using namespace std;
void newline(); 

int main() {

int msec = 0;
int sec = 0;
int min = 0;
int hr = 0;


//cout << "Press any key to start:";
//char start = _gtech();

for (;;)
{
        newline();
                if(msec == 1000)
                {
                        ++sec;
                        msec = 0;
                }
                if(sec == 60)
                {
                        ++min;
                        sec = 0; 
                }
                if(min == 60)
                {
                        ++hr;
                        min = 0;
                }
        cout << hr << " : " << min << " : " << sec << " . " << msec << endl;
        ++msec;
        usleep(100000); 

}

    return 0;
}

void newline()
{
        cout << "\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n";
}
Färid Alijani
quelle
Vielleicht möchten Sie die erste Bedingung überprüfen ... 10 ms = 1 s?
Dr. Yunke
2
Dies führt zu relativen Fehlern in der Zeit, da Sie nicht die Zeit angeben, die zum Drucken benötigt wird, und usleepnicht immer nach genau dem Betrag zurückkehren, den Sie angefordert haben. Manchmal wird es länger dauern. Sie sollten die aktuelle Zeit zu Beginn überprüfen, dann die aktuelle Zeit überprüfen und subtrahieren, um die absolute Zeit zu erhalten, seit Sie jedes Mal durch die Schleife gestartet sind.
Peter Cordes
0

Sie können messen, wie lange Ihr Programm funktioniert. Die folgenden Funktionen helfen beim Messen der CPU-Zeit seit dem Start des Programms:

  • C ++ (Doppel) clock () / CLOCKS PER SEC mit ctime enthalten.
  • python time.clock () gibt den Gleitkommawert in Sekunden zurück.
  • Java System.nanoTime () gibt einen langen Wert in Nanosekunden zurück.

meine Referenz : Algorithmus Toolbox Woche 1 Kurs Teil der Spezialisierung auf Datenstrukturen und Algorithmen durch die University of California in San Diego und die Higher School of Economics der National Research University

Sie können diese Codezeile also nach Ihrem Algorithmus hinzufügen

cout << (double)clock() / CLOCKS_PER_SEC ;

Erwartete Ausgabe: Die Ausgabe, die die Anzahl von darstellt clock ticks per second

Muhamed Youssry
quelle
1
Die Frage ist nur für c ++ gestellt. Es ist schön, dass Sie auf andere Programmiersprachen / Skripte verweisen, aber es ist nicht zum Thema.
Dboy