poner - temporizador en c++

Algoritmo de tiempo: reloj() vs tiempo() en C++

Question

Para cronometrar un algoritmo (aproximadamente en ms), cuál de estos dos enfoques es mejor:

clock_t start = clock();
algorithm();
clock_t end = clock();
double time = (double) (end-start) / CLOCKS_PER_SEC * 1000.0;

O,

time_t start = time(0);
algorithm();
time_t end = time(0);
double time = difftime(end, start) * 1000.0;

Además, de alguna discusión en el canal de C ++ en Freenode, sé que el reloj tiene una resolución muy mala, por lo que el tiempo será cero para un algoritmo (relativamente) rápido. Pero, ¿cuál tiene mejor tiempo de resolución () o reloj ()? ¿O es lo mismo?

Answer 1

¿Qué hay de gettimeofday? Cuando se llama, actualiza dos estructuras, con información de tiempo. Normalmente, la estructura de la mano izquierda es suficiente, lo que llevará tiempo desde la Época, 01-01-1970 00:00:00 (UTC). Se puede usar de la siguiente manera:

#include <time.h>

struct timeval start;
double mtime, seconds, useconds;
gettimeofday(&start, NULL); //left hand struct is usually enough
seconds  = start.tv_sec; //time in seconds
useconds = start.tv_usec; //time in microseconds

Answer 2

Depende de lo que desee: el time mide el tiempo real mientras que el clock mide el tiempo de procesamiento que toma el proceso actual. Si su proceso duerme durante un período de tiempo apreciable, o si el sistema está ocupado con otros procesos, los dos serán muy diferentes.

http://en.cppreference.com/w/cpp/chrono/c/clock

Answer 3

La estructura time_t probablemente sea un entero, lo que significa que tendrá una resolución de segundo.

La primera pieza de código: solo contará el tiempo que la CPU estaba haciendo algo, por lo tanto, cuando duermas (), no contará nada. Puede anularse contando el tiempo que duerme (), pero probablemente comenzará a desplazarse después de un tiempo.

La segunda pieza: solo resolución de segundos, no tan buena si necesita lecturas de tiempo por debajo del segundo.

Para lecturas de tiempo con la mejor resolución que puede obtener, debe hacer algo como esto:

double getUnixTime(void)
{
    struct timespec tv;

    if(clock_gettime(CLOCK_REALTIME, &tv) != 0) return 0;

    return (tv.tv_sec + (tv.tv_nsec / 1000000000.0));
}

double start_time = getUnixTime();
double stop_time, difference;

doYourStuff();

stop_time = getUnixTime();
difference = stop_time - start_time;

En la mayoría de los sistemas, su resolución se reducirá a algunos microsegundos, pero puede variar con diferentes CPU, y probablemente incluso con las principales versiones del kernel.

Answer 4

<chrono> es el mejor. Visual Studio 2013 proporciona esta característica. Personalmente, he probado todos los métodos mencionados anteriormente. Recomiendo encarecidamente que use la biblioteca <chrono> . Puede rastrear el tiempo de pared y al mismo tiempo tener una buena resolución (mucho menos de un segundo).

Answer 5

<chrono> sería una mejor biblioteca si estás usando C ++ 11.

#include <iostream>
#include <chrono>
#include <thread>

void f()
{
    std::this_thread::sleep_for(std::chrono::seconds(1));
}

int main()
{
    auto t1 = std::chrono::high_resolution_clock::now();
    f();
    auto t2 = std::chrono::high_resolution_clock::now();
    std::cout << "f() took "
              << std::chrono::duration_cast<std::chrono::milliseconds>(t2-t1).count()
              << " milliseconds/n";
}

Ejemplo tomado de here .