Mida el tiempo de ejecución con alta precisión en C/C++

Posted on by Rudeus Greyrat

Tiempo de ejecución: el tiempo de ejecución o tiempo de CPU de una tarea dada se define como el tiempo que el sistema dedica a ejecutar esa tarea; de otra manera, puede decir el tiempo durante el cual se ejecuta un programa.
Hay varias formas de medir el tiempo de ejecución de un programa, en este artículo discutiré 5 formas diferentes de
medir el tiempo de ejecución de un programa.

  1. Uso time()de la función en C y C++ .

    time() : la función time() devuelve el tiempo desde la Época (1 de enero de 1970) en segundos.
    Archivo de encabezado: “time.h”
    Prototipo / Sintaxis: time_t time(time_t *tloc);
    Valor devuelto: en caso de éxito, se devuelve el valor del tiempo en segundos desde la Época, en caso de error, se devuelve -1.

    Debajo del programa para demostrar cómo medir el tiempo de ejecución usando time()la función.

    #include <bits/stdc++.h>
    using namespace std;
      
    // A sample function whose time taken to
    // be measured
    void fun()
    {
        for (int i=0; i<10; i++)
        {
        }
    }
      
    int main()
    {
        /* Time function returns the time since the 
            Epoch(jan 1 1970). Returned time is in seconds. */
        time_t start, end;
      
        /* You can call it like this : start = time(NULL);
         in both the way start contain total time in seconds 
         since the Epoch. */
        time(&start);
      
        // unsync the I/O of C and C++.
        ios_base::sync_with_stdio(false);
      
        fun();
      
        // Recording end time.
        time(&end);
      
        // Calculating total time taken by the program.
        double time_taken = double(end - start);
        cout << "Time taken by program is : " << fixed
             << time_taken << setprecision(5);
        cout << " sec " << endl;
        return 0;
    }
    Producción:

    Time taken by program is : 0.000000 sec
  2. Uso clock()de la función en C y C++.

    clock() : clock() devuelve el número de tics de reloj transcurridos desde que se inició el programa.
    Archivo de encabezado: “time.h”
    Prototipo / Sintaxis: clock_t clock(void);
    Valor devuelto: en caso de éxito, el valor devuelto es el tiempo de CPU utilizado hasta ahora como clock_t; Para obtener el número de segundos utilizados, se divide por CLOCKS_PER_SEC.on se devuelve el error -1.

    Debajo del programa para demostrar cómo medir el tiempo de ejecución usando clock()la función. También puede ver esto

    #include <bits/stdc++.h>
    using namespace std;
      
    // A sample function whose time taken to
    // be measured
    void fun()
    {
        for (int i=0; i<10; i++)
        {
        }
    }
      
    int main()
    {
        /* clock_t clock(void) returns the number of clock ticks
           elapsed since the program was launched.To get the number 
           of seconds used by the CPU, you will need to divide by 
           CLOCKS_PER_SEC.where CLOCKS_PER_SEC is 1000000 on typical
           32 bit system.  */
        clock_t start, end;
      
        /* Recording the starting clock tick.*/
        start = clock();
      
        fun();
      
        // Recording the end clock tick.
        end = clock();
      
        // Calculating total time taken by the program.
        double time_taken = double(end - start) / double(CLOCKS_PER_SEC);
        cout << "Time taken by program is : " << fixed 
             << time_taken << setprecision(5);
        cout << " sec " << endl;
        return 0;
    }
    Producción:

    Time taken by program is : 0.000001 sec
  3. usando gettimeofday()la función en C y C++.

    gettimeofday() : la función gettimeofday() puede obtener la hora y la zona horaria.
    Archivo de encabezado: «sys/time.h».
    Prototipo / Sintaxis: int gettimeofday(struct timeval *tv, struct timezone *tz);
    El argumento tv es una estructura timeval y proporciona el número de segundos y microsegundos desde la
    Época.
    estructura timeval {
    time_t tv_sec; // segundos
    susegundos_t tv_usec; // microsegundos
    };
    Valor devuelto: devuelve 0 para el éxito o -1 para el fracaso.

    Debajo del programa para demostrar cómo medir el tiempo de ejecución usando gettimeofday()la función.

    #include <bits/stdc++.h>
    #include <sys/time.h>
    using namespace std;
      
    // A sample function whose time taken to
    // be measured
    void fun()
    {
        for (int i=0; i<10; i++)
        {
        }
    }
      
    int main()
    {
        /* The function gettimeofday() can get the time as
           well as timezone. 
           int gettimeofday(struct timeval *tv, struct timezone *tz);
          The tv argument is a struct timeval and gives the
          number of seconds and micro seconds since the Epoch.
          struct timeval {
                   time_t      tv_sec;     // seconds 
                   suseconds_t tv_usec;    // microseconds
               };    */
        struct timeval start, end;
      
        // start timer.
        gettimeofday(&start, NULL);
      
        // unsync the I/O of C and C++.
        ios_base::sync_with_stdio(false);
      
        fun();
      
        // stop timer.
        gettimeofday(&end, NULL);
      
        // Calculating total time taken by the program.
        double time_taken;
      
        time_taken = (end.tv_sec - start.tv_sec) * 1e6;
        time_taken = (time_taken + (end.tv_usec - 
                                  start.tv_usec)) * 1e-6;
      
        cout << "Time taken by program is : " << fixed
             << time_taken << setprecision(6);
        cout << " sec" << endl;
        return 0;
    }
    Producción:

    Time taken by program is : 0.000029 sec
  4. Uso clock_gettime()de la función en C y C++.

    clock_gettime() : La función clock_gettime() obtiene la hora actual del reloj especificado por clock_id y la coloca en el búfer al que apunta tp.
    Archivo de encabezado: «time.h».
    Prototipo / Sintaxis: int clock_gettime( clockid_t clock_id, struct timespec *tp );
    El parámetro tp apunta a una estructura que contiene al menos los siguientes miembros:

    struct timespec {
    time_t tv_sec; //segundos
    de duración tv_nsec; // nanosegundos
    };

    Valor devuelto: devuelve 0 para el éxito o -1 para el fracaso.
    clock_id : id del reloj = CLOCK_REALTIME,
    CLOCK_PROCESS_CPUTIME_ID, CLOCK_MONOTONIC … etc.
    CLOCK_REALTIME : reloj que mide el tiempo real (es decir, reloj de pared).
    CLOCK_PROCESS_CPUTIME_ID: Temporizador por proceso de alta resolución de la CPU.
    CLOCK_MONOTONIC: temporizador de alta resolución que no se ve afectado por los cambios de fecha del sistema (por ejemplo, demonios NTP).

    Debajo del programa para demostrar cómo medir el tiempo de ejecución usando clock_gettime()la función.

    #include <bits/stdc++.h>
    #include <sys/time.h>
    using namespace std;
      
    // A sample function whose time taken to
    // be measured
    void fun()
    {
        for (int i=0; i<10; i++)
        {
        }
    }
      
    int main()
    {
        /* int clock_gettime( clockid_t clock_id, struct 
         timespec *tp ); The clock_gettime() function gets
         the current time of the clock specified by clock_id, 
         and puts it into the buffer  pointed to by tp.tp 
         parameter points to a structure containing 
         atleast the following members:    
         struct timespec {
                   time_t   tv_sec;        // seconds 
                   long     tv_nsec;       // nanoseconds
               };
        clock id = CLOCK_REALTIME, CLOCK_PROCESS_CPUTIME_ID, 
                   CLOCK_MONOTONIC ...etc
        CLOCK_REALTIME : clock  that  measures real (i.e., wall-clock) time.
        CLOCK_PROCESS_CPUTIME_ID : High-resolution per-process timer 
                                   from the CPU.
        CLOCK_MONOTONIC : High resolution timer that is unaffected
                          by system date changes (e.g. NTP daemons).  */
        struct timespec start, end;
      
        // start timer.
        // clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &start);
        // clock_gettime(CLOCK_REALTIME, &start);
        clock_gettime(CLOCK_MONOTONIC, &start);
      
        // unsync the I/O of C and C++.
        ios_base::sync_with_stdio(false);
      
        fun();
      
        // stop timer.
        // clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &end);
        // clock_gettime(CLOCK_REALTIME, &end);
        clock_gettime(CLOCK_MONOTONIC, &end);
      
        // Calculating total time taken by the program.
        double time_taken;
        time_taken = (end.tv_sec - start.tv_sec) * 1e9;
        time_taken = (time_taken + (end.tv_nsec - start.tv_nsec)) * 1e-9;
      
        cout << "Time taken by program is : " << fixed
             << time_taken << setprecision(9);
        cout << " sec" << endl;
        return 0;
    }
    Producción:

    Time taken by program is : 0.000028 sec
  5. Uso chrono::high_resolution_clocken C++.

    crono: la biblioteca Chrono se utiliza para gestionar la fecha y la hora. Esta biblioteca fue diseñada para lidiar con el hecho de que los temporizadores y los relojes pueden ser diferentes en diferentes sistemas y, por lo tanto, para mejorar con el tiempo en términos de precisión. este encabezado no se define directamente bajo el espacio de nombres std (como la mayoría de la biblioteca estándar) sino bajo el espacio de nombres std::chrono.

    Debajo del programa para demostrar cómo medir el tiempo de ejecución usando high_resolution_clockla función. Para obtener información detallada sobre la biblioteca crono, consulte este y este

    #include <bits/stdc++.h>
    #include <chrono>
    using namespace std;
      
      
    // A sample function whose time taken to
    // be measured
    void fun()
    {
        for (int i=0; i<10; i++)
        {
        }
    }
      
    int main()
    {
        auto start = chrono::high_resolution_clock::now();
      
        // unsync the I/O of C and C++.
        ios_base::sync_with_stdio(false);
      
        fun();
      
        auto end = chrono::high_resolution_clock::now();
      
        // Calculating total time taken by the program.
        double time_taken = 
          chrono::duration_cast<chrono::nanoseconds>(end - start).count();
      
        time_taken *= 1e-9;
      
        cout << "Time taken by program is : " << fixed 
             << time_taken << setprecision(9);
        cout << " sec" << endl;
        return 0;
    }
    Producción:

    Time taken by program is : 0.000024 sec

Publicación traducida automáticamente

Artículo escrito por vivek kumar 9 y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *