¿Cómo puedo llamar a clock() en C++?

Por ejemplo, quiero poner a prueba cuánto tiempo una búsqueda lineal se lleva a buscar un determinado elemento de una matriz.

  • Tenga en cuenta que en la pared de la hora del reloj no es siempre una buena manera de tiempo microbenchmarks. Para obtener resultados consistentes, usted tiene que trabajar alrededor de la frecuencia de la CPU-escala (incluyendo Intel turbo o el equivalente de AMD, lo que permite que el reloj de CPU superior cuando térmica/límites de potencia permiten). Perfiles con los contadores de rendimiento puede dar mediciones en el núcleo de ciclos de reloj (y también los detalles acerca de si un cuello de botella es el caché pierde frente de la instrucción de rendimiento frente a la latencia, por mirar los contadores no sea sólo de los ciclos). En Linux, perf stat -d ./a.out

6 Comentarios

  1. 192
    #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';
    }
    • Por lo que puedo ver aquí cplusplus.com/reference/ctime/clock, usted no necesita utilizar el «std::» la notación. Sólo uso «clock()»
    • En todos los proyectos que he trabajado sin embargo, el estilo de código requiere std:: antes de cada std:: llame.
    • No esta de regreso la respuesta en cuestión de segundos?
    • Sí, lo es.
    • ambos clock() y clock_t son de la Biblioteca Estándar de C de la cabecera de time.h, y por lo tanto no necesitan el uso de std prefijos de espacio de nombres después de la inclusión de sus bibliotecas. <ctime> de envolturas que el valor y la función con el std espacio de nombres, pero no se requiere para su uso. Consulta aquí los detalles de la implementación: en.cppreference.com/w/cpp/header/ctime
    • Es clock() la función de afectados por la CPU del acelerador y otros fenómenos que podrían provocar que la velocidad de la CPU a la humedad.
    • Es allí una manera más eficiente? El cálculo para el cálculo de la duración de la toma 0.007 segundos, lo que es significativo. Hay alguna forma de que automáticamente hace esto?

  2. 64

    Una solución alternativa, que es portátil y con mayor precisión, disponible desde C++11, es el uso de std::chrono.

    Aquí está 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
    • Si usted está sugiriendo el uso de C++11, usted puede escribir using Clock=std::chrono::high_resolution_clock;. Consulte alias de tipo.
    • Totalmente de acuerdo con que
  3. 29

    clock() devuelve el número de impulsos de reloj desde que el programa comenzó. Hay una constante relacionados, CLOCKS_PER_SEC, que le indica el número de impulsos de reloj se producen en un segundo. Por lo tanto, usted puede probar cualquier operación como ésta:

    clock_t startTime = clock();
    doSomeOperation();
    clock_t endTime = clock();
    clock_t clockTicksTaken = endTime - startTime;
    double timeInSeconds = clockTicksTaken / (double) CLOCKS_PER_SEC;
    • timeInSeconds siempre viene 0.000000para mí. ¿Cómo puedo solucionarlo ?
    • Tal vez el tiempo es tan corto se muestra como 0. Usted podría tratar de usar un long double para obtener más precisión.
    • probablemente su reloj de resolución no es lo suficientemente alto, así que no hay tiempo transcurrido.
  4. 4

    En Windows, al menos, el sólo prácticamente medición precisa mecanismo es QueryPerformanceCounter (QPC). std::chrono es implementado usando (ya VS2015, si se usa), pero es no precisa en el mismo grado que el uso de QueryPerformanceCounter directamente. En particular, la reclamación de informe en 1 nanosegundo granularidad no es absolutamente correcto. Por lo tanto, si usted está midiendo algo que toma una cantidad de tiempo muy corto (y su caso podría ser un caso), entonces usted debe utilizar QPC, o el equivalente para su sistema operativo. Me ocurrió en contra de esto cuando la medición de la caché de las latencias, y me apunté algunas notas que te pueden ser de utilidad, aquí;
    https://github.com/jarlostensen/notesandcomments/blob/master/stdchronovsqcp.md

  5. 1
    #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 agrega a la ya respondió a la pregunta. El sueño después de la cl = clock() – cl no es necesario. Y la cout imprime segundos no ticks por segundo. cl tiendas de los impulsos de reloj.
  6. -1

    Probablemente usted podría estar interesado en el temporizador como este :
    H : M : S . Mseg.

    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 comprobar la primera condición … 10 milisegundos = 1 segundo?
    • Este se acumulará el error relativo en el tiempo, ya que no incluye el tiempo necesario para imprimir, y usleep no siempre regreso después de exactamente la cantidad que usted pide. A veces será más largo. Usted debe verificar la hora actual al inicio, a continuación, comprobar el tiempo actual y la resta para obtener el tiempo total desde que se inició cada vez a través del bucle.

Dejar respuesta

Please enter your comment!
Please enter your name here