Cómo usar clock () en C ++


127

Como llamar clock()en C++?

Por ejemplo, quiero probar cuánto tiempo lleva una búsqueda lineal para encontrar un elemento dado en una matriz.


1
Tenga en cuenta que el tiempo del reloj de pared no siempre es una buena forma de cronometrar microbenchmarks. Para obtener resultados consistentes, debe evitar el escalado de frecuencia de la CPU (incluido Intel turbo o el equivalente de AMD, que permite que su CPU aumente el reloj cuando lo permiten los límites térmicos / de potencia). La creación de perfiles con contadores de rendimiento puede proporcionarle mediciones en ciclos de reloj principales (y también detalles sobre si un cuello de botella es errores de caché vs. rendimiento de la instrucción vs. latencia, al observar contadores que no sean solo ciclos). En Linux,perf stat -d ./a.out
Peter Cordes

Respuestas:


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

55
Por lo que puedo ver aquí cplusplus.com/reference/ctime/clock , no necesita usar la notación "std ::". Simplemente use "clock ()"
gromit190

44
@Birger: En todo el proyecto en el que trabajé, el estilo del código requiere std :: antes de cada llamada std ::.
Th. Thielemann el

2
¿Esto devuelve la respuesta en segundos?
Arnav Borborah

1
@ArnavBorborah Sí, lo hace.
QuantumHoneybees

1
@ Th.Thielemann clock()y clock_tson del encabezado de la Biblioteca estándar de C time.hy, por lo tanto, no necesitan el uso de stdprefijos de espacio de nombres después de la inclusión de sus bibliotecas. <ctime>envuelve ese valor y funciona con el stdespacio de nombres, pero no es obligatorio usarlo. Verifique aquí los detalles de implementación: en.cppreference.com/w/cpp/header/ctime
kayleeFrye_onDeck

70

Es utilizar una solución alternativa, que es portátil y con mayor precisión, disponible desde C ++ 11 std::chrono.

Aquí hay un ejemplo:

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

Ejecutar esto en ideone.com me dio:

Delta t2-t1: 282 nanoseconds

11
Si está sugiriendo usar C ++ 11, también podría escribir using Clock=std::chrono::high_resolution_clock;. Ver tipo alias .
JHBonarius

std::chrono::high_resolution_clockno es monótono en todas las implementaciones de std lib. De la cppreference: en general, uno debería usar std :: chrono :: steady_clock o std :: chrono :: system_clock directamente en lugar de std :: chrono :: high_resolution_clock: use steady_clock para las mediciones de duración y system_clock para el tiempo del reloj de pared.
Kristianmitk

30

clock()devuelve el número de tics de reloj desde que comenzó su programa. Hay una constante relacionada CLOCKS_PER_SEC, que le dice cuántos tics de reloj ocurren en un segundo. Por lo tanto, puede probar cualquier operación como esta:

clock_t startTime = clock();
doSomeOperation();
clock_t endTime = clock();
clock_t clockTicksTaken = endTime - startTime;
double timeInSeconds = clockTicksTaken / (double) CLOCKS_PER_SEC;

66
timeInSecondssiempre viene 0.000000por mí ¿Cómo lo arreglaría?
noufal

3
@noufal Tal vez el tiempo empleado es tan corto que aparece como 0. Puede intentar usar a long doublepara obtener más precisión.
Gerard

probablemente la resolución de su reloj no sea lo suficientemente alta, por lo que no pasó tiempo.
Marco Freudenberger

4

Al menos en Windows, el único mecanismo de medición prácticamente preciso es QueryPerformanceCounter (QPC). std :: crono se implementa utilizando (desde VS2015, que si se utiliza), pero es que no precisa en el mismo grado como el uso de QueryPerformanceCounter directamente. En particular, se afirma que informar a una granularidad de 1 nanosegundo no es del todo correcto. Entonces, si está midiendo algo que lleva una cantidad de tiempo muy corta (y su caso podría ser tal), entonces debe usar QPC, o el equivalente para su sistema operativo. Me topé con esto al medir las latencias de caché, y anoté algunas notas que pueden ser útiles aquí; https://github.com/jarlostensen/notesandcomments/blob/master/stdchronovsqcp.md


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"

Esto no se suma a la pregunta ya respondida. Dormir después de cl = reloj (): no se necesita cl. Y la impresión imprime segundos, no marcas por segundo. cl almacena las garrapatas del reloj.
Dr. Yunke

0

Probablemente te interese un temporizador como este: H: M: S. Ms.

el código en el sistema operativo 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";
}

Es posible que desee verificar la primera condición ... 10 mseg = 1 seg.
Dr. Yunke

2
Esto acumulará un error relativo en el tiempo porque no incluye el tiempo que lleva imprimir, y usleepno siempre regresará después de la cantidad exacta que solicita. A veces será más largo. Debe verificar la hora actual al comienzo, luego verificar la hora actual y restar para obtener el tiempo absoluto desde que comenzó cada vez a través del ciclo.
Peter Cordes

0

Puedes medir cuánto tiempo funciona tu programa. Las siguientes funciones ayudan a medir el tiempo de CPU desde el inicio del programa:

  • C ++ (doble) clock () / CLOCKS PER SEC con ctime incluido.
  • python time.clock () devuelve el valor de coma flotante en segundos.
  • Java System.nanoTime () devuelve un valor largo en nanosegundos.

mi referencia : Algorithms toolbox week 1 course parte de estructuras de datos y especialización de algoritmos por la University of California San Diego y la National Research University Higher School of Economics

para que pueda agregar esta línea de código después de su algoritmo

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

Salida esperada: la salida que representa el número de clock ticks per second


1
La pregunta es preguntar solo por c ++. Por lo tanto, es bueno que haga referencia a otros lenguajes / scripts de programación, pero está fuera de tema.
Dboy
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.