Cómo usar clock () en C ++

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.

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

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

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;

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

#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"

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

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