Mida fácilmente el tiempo transcurrido

Estoy intentando utilizar time() para medir varios puntos de mi programa.

Lo que no entiendo es por qué los valores del antes y el después son los mismos. Entiendo que esta no es la mejor manera de perfilar mi programa, solo quiero ver cuánto tiempo lleva algo.

printf("**MyProgram::before time= %ld\n", time(NULL));

doSomthing();
doSomthingLong();

printf("**MyProgram::after time= %ld\n", time(NULL));

Yo he tratado:

struct timeval diff, startTV, endTV;

gettimeofday(&startTV, NULL); 

doSomething();
doSomethingLong();

gettimeofday(&endTV, NULL); 

timersub(&endTV, &startTV, &diff);

printf("**time taken = %ld %ld\n", diff.tv_sec, diff.tv_usec);

¿ Cómo leo un resultado de **time taken = 0 26339? ¿Eso significa 26.339 nanosegundos = 26,3 ms?

¿Qué pasa **time taken = 4 45025? ¿Eso significa 4 segundos y 25 ms?

May 11 '10 13:05 hap497

0-delta

Utilice una función delta para calcular las diferencias horarias:

auto start = std::chrono::steady_clock::now();
std::cout << "Elapsed(ms)=" << since(start).count() << std::endl;

sinceacepta cualquier punto de tiempo y produce cualquier duración (milisegundos es el valor predeterminado). Se define como:

template <
    class result_t   = std::chrono::milliseconds,
    class clock_t    = std::chrono::steady_clock,
    class duration_t = std::chrono::milliseconds
>
auto since(std::chrono::time_point<clock_t, duration_t> const& start)
{
    return std::chrono::duration_cast<result_t>(clock_t::now() - start);
}

Demo

1 - Temporizador

Utilice un temporizador basado en std::chrono:

Timer clock; // Timer<milliseconds, steady_clock>

clock.tick();
/* code you want to measure */
clock.tock();

cout << "Run time = " << clock.duration().count() << " ms\n";

Demo

TimerSe define como:

template <class DT = std::chrono::milliseconds,
          class ClockT = std::chrono::steady_clock>
class Timer
{
    using timep_t = typename ClockT::time_point;
    timep_t _start = ClockT::now(), _end = {};

public:
    void tick() { 
        _end = timep_t{}; 
        _start = ClockT::now(); 
    }
    
    void tock() { _end = ClockT::now(); }
    
    template <class T = DT> 
    auto duration() const { 
        gsl_Expects(_end != timep_t{} && "toc before reporting"); 
        return std::chrono::duration_cast<T>(_end - _start); 
    }
};

Como señaló Howard Hinnantchrono , usamos una duración para permanecer en el sistema de tipos y realizar operaciones como promediar o comparar (por ejemplo, aquí esto significa usar std::chrono::milliseconds). Cuando simplemente hacemos IO, usamos los count()ticks o de una duración (por ejemplo, aquí el número de milisegundos).

2 - Instrumentación

Cualquier invocable (función, objeto de función, lambda, etc.) se puede instrumentar para la evaluación comparativa. Digamos que tiene una función Finvocable con argumentos arg1,arg2, esta técnica da como resultado:

cout << "F runtime=" << measure<>::duration(F, arg1, arg2).count() << "ms";

Demo

measureSe define como:

template <class TimeT  = std::chrono::milliseconds,
          class ClockT = std::chrono::steady_clock>
struct measure
{
    template<class F, class ...Args>
    static auto duration(F&& func, Args&&... args)
    {
        auto start = ClockT::now();
        std::invoke(std::forward<F>(func), std::forward<Args>(args)...);
        return std::chrono::duration_cast<TimeT>(ClockT::now()-start);
    }
};

Como se menciona en (1), usar la duración sin .count()es más útil para los clientes que desean posprocesar una serie de duraciones antes de la E/S, por ejemplo, promedio:

auto avg = (measure<>::duration(func) + measure<>::duration(func)) / 2;
std::cout << "Average run time " << avg.count() << " ms\n";

^{+ Esta es la razón por la que se reenvía la llamada a la función.}

^{+El código completo se puede encontrar aquí}

^{+Mi intento de construir un marco de evaluación comparativa basado en crono se registra aquí}

^{+ Demostración antigua}

Feb 24 '2014 18:02 Nikos Athanasiou

#include <ctime>

void f() {
  using namespace std;
  clock_t begin = clock();

  code_to_time();

  clock_t end = clock();
  double elapsed_secs = double(end - begin) / CLOCKS_PER_SEC;
}

La time()función sólo tiene una precisión de un segundo, pero hay CLOCKS_PER_SEC"relojes" de un segundo. Esta es una medición fácil y portátil, aunque está demasiado simplificada.

May 11 '2010 06:05

Como puedo ver en tu pregunta, parece que quieres saber el tiempo transcurrido después de la ejecución de algún fragmento de código. Supongo que te sentirías cómodo si vieras los resultados en segundos. Si es así, intente utilizar difftime()la función como se muestra a continuación. Espero que esto resuelva tu problema.

#include <time.h>
#include <stdio.h>

time_t start,end;
time (&start);
.
.
.
<your code>
.
.
.
time (&end);
double dif = difftime (end,start);
printf ("Elasped time is %.2lf seconds.", dif );

May 11 '2010 07:05 Akaanthan Ccoder