Jak używać clock () w C ++

127

Jak mogę zadzwonić clock()w C++?

Na przykład chcę sprawdzić, ile czasu zajmuje wyszukiwanie liniowe, aby znaleźć dany element w tablicy.

dato datuashvili
źródło
1
Pamiętaj, że zegar ścienny nie zawsze jest dobrym sposobem na mierzenie mikroznaków. Aby uzyskać spójne wyniki, musisz obejść problem skalowania częstotliwości procesora (w tym turbo Intel lub odpowiednik AMD, co pozwala na zwiększenie zegara procesora, gdy pozwalają na to ograniczenia termiczne / mocy). Profilowanie za pomocą liczników wydajności może zapewnić pomiary w rdzeniowych cyklach zegara (a także szczegółowe informacje o tym, czy wąskim gardłem są chybienia w pamięci podręcznej w porównaniu z przepustowością instrukcji i opóźnieniem, patrząc na liczniki inne niż tylko cykle). W systemie Linuxperf stat -d ./a.out
Peter Cordes,

Odpowiedzi:

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
źródło
5
Z tego, co widzę tutaj cplusplus.com/reference/ctime/clock , nie musisz używać notacji "std ::". Po prostu użyj "clock ()"
gromit190
4
@Birger: We wszystkich projektach, nad którymi pracowałem, styl kodu wymaga std :: przed każdym std :: call.
Cz. Thielemann
2
Czy to zwraca odpowiedź w kilka sekund?
Arnav Borborah
1
@ArnavBorborah Tak, to prawda.
QuantumHoneybees
1
@ Th.Thielemann oba clock()i clock_tpochodzą z nagłówka biblioteki C Standard Library time.h, a zatem nie potrzebują używania stdprzedrostków przestrzeni nazw po włączeniu ich bibliotek. <ctime>otacza tę wartość i funkcję z stdprzestrzenią nazw, ale nie jest to wymagane. Sprawdź tutaj szczegóły implementacji: en.cppreference.com/w/cpp/header/ctime
kayleeFrye_onDeck
70

Alternatywnym rozwiązaniem, które jest przenośne i zapewnia większą precyzję, dostępne od C ++ 11, jest użycie std::chrono.

Oto przykład:

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

Uruchomienie tego na ideone.com dało mi:

Delta t2-t1: 282 nanoseconds
Martin G.
źródło
11
Jeśli sugerujesz użycie C ++ 11, równie dobrze możesz pisać using Clock=std::chrono::high_resolution_clock;. Zobacz alias typu .
JHBonarius
std::chrono::high_resolution_clocknie jest monotoniczny we wszystkich implementacjach biblioteki standardowej. Z cppreference - Generalnie należy po prostu użyć std :: chrono :: steady_clock lub std :: chrono :: system_clock bezpośrednio zamiast std :: chrono :: high_resolution_clock: użyj steady_clock do pomiaru czasu trwania i system_clock do zegara ściennego.
Kristianmitk
30

clock()zwraca liczbę tyknięć zegara od momentu uruchomienia programu. Istnieje powiązana stała, CLOCKS_PER_SECktóra mówi, ile tyknięć zegara występuje w ciągu jednej sekundy. W ten sposób możesz przetestować dowolną operację, taką jak ta:

clock_t startTime = clock();
doSomeOperation();
clock_t endTime = clock();
clock_t clockTicksTaken = endTime - startTime;
double timeInSeconds = clockTicksTaken / (double) CLOCKS_PER_SEC;
Shirik
źródło
6
timeInSecondszawsze 0.000000po mnie przychodzi . Jak mam to naprawić?
Noufal
3
@noufal Może spędzony czas jest tak krótki, że pojawia się jako 0. Możesz spróbować użyć a, long doubleaby uzyskać większą precyzję.
Gerard
prawdopodobnie rozdzielczość twojego zegara nie jest wystarczająco wysoka, więc czas nie upłynął.
Marco Freudenberger
4

Przynajmniej w systemie Windows jedynym praktycznie dokładnym mechanizmem pomiarowym jest QueryPerformanceCounter (QPC). std :: Chrono jest realizowany przy użyciu go (od VS2015, jeśli używasz tego), ale to nie dokładne w tym samym stopniu, jak przy użyciu QueryPerformanceCounter bezpośrednio. W szczególności twierdzenie, że raportowanie o ziarnistości 1 nanosekundy jest absolutnie niepoprawne. Tak więc, jeśli mierzysz coś, co zajmuje bardzo mało czasu (a Twój przypadek może być takim przypadkiem), powinieneś użyć QPC lub odpowiednika dla swojego systemu operacyjnego. Natknąłem się na to podczas pomiaru opóźnienia pamięci podręcznej i zanotowałem kilka uwag, które mogą okazać się przydatne, tutaj; https://github.com/jarlostensen/notesandcomments/blob/master/stdchronovsqcp.md

SonarJetLens
źródło
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
źródło
Nie dodaje to do już odpowiedzi na pytanie. Sen po cl = clock () - cl nie jest potrzebne. A cout drukuje sekundy, a nie tyknięcia na sekundę. cl przechowuje tyknięcia zegara.
Dr Yunke
0

Prawdopodobnie możesz być zainteresowany takim timerem: H: M: S. Msec.

kod w systemie Linux:

#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
źródło
Możesz chcieć sprawdzić pierwszy warunek ... 10 ms = 1 sekunda?
Dr Yunke
2
Spowoduje to nagromadzenie względnego błędu w czasie, ponieważ nie uwzględniasz czasu potrzebnego na wydrukowanie i usleepnie zawsze wróci po dokładnie takiej kwocie, o jaką prosisz. Czasami będzie dłużej. Powinieneś sprawdzić aktualny czas na początku, a następnie sprawdzić aktualny czas i odjąć, aby uzyskać bezwzględny czas od rozpoczęcia każdej pętli.
Peter Cordes
0

możesz zmierzyć, jak długo działa Twój program. Następujące funkcje pomagają mierzyć czas procesora od początku programu:

  • C ++ (double) clock () / CLOCKS PER SEC z dołączonym ctime.
  • python time.clock () zwraca wartość zmiennoprzecinkową w sekundach.
  • Java System.nanoTime () zwraca wartość długą w nanosekundach.

moja referencja : Przybornik algorytmów tydzień 1 część kursu ze specjalności struktur danych i algorytmów Uniwersytetu Kalifornijskiego w San Diego i National Research University Higher School of Economics

więc możesz dodać tę linię kodu po algorytmie

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

Oczekiwany wynik: wyjście reprezentujące liczbę plików clock ticks per second

Muhamed Youssry
źródło
1
Pytanie dotyczy tylko języka c ++. Więc miło jest odnosić się do innych języków programowania / skryptów, ale jest to poza tematem.
dboy