Medición del tiempo de ejecución de una función en C ++

Quiero saber cuánto tiempo tarda una determinada función en ejecutar mi programa C ++ en Linux . Después, quiero hacer una comparación de velocidad. Vi varias funciones de tiempo pero terminé con esto desde boost. Crono:

process_user_cpu_clock, captures user-CPU time spent by the current process

Ahora, no estoy claro si uso la función anterior, ¿tendré el único tiempo que la CPU pasó en esa función?

En segundo lugar, no pude encontrar ningún ejemplo de uso de la función anterior. ¿Alguien puede ayudarme a usar la función anterior?

PD: En este momento, estoy usando std::chrono::system_clock::now()para obtener el tiempo en segundos, pero esto me da resultados diferentes debido a la carga de CPU diferente cada vez.

Es un método muy fácil de usar en C ++ 11. Tienes que usar std::chrono::high_resolution_clockdesde el <chrono>encabezado.

Úselo así:

#include <iostream>
#include <chrono>

void function()
{
    long long number = 0;

    for( long long i = 0; i != 2000000; ++i )
    {
       number += 5;
    }
}

int main()
{
    auto t1 = std::chrono::high_resolution_clock::now();
    function();
    auto t2 = std::chrono::high_resolution_clock::now();

    auto duration = std::chrono::duration_cast<std::chrono::microseconds>( t2 - t1 ).count();

    std::cout << duration;
    return 0;
}

Esto medirá la duración de la función.

NOTA: No siempre obtendrá el mismo tiempo para una función. Esto se debe a que la CPU de su máquina puede ser menos o más utilizada por otros procesos que se ejecutan en su computadora, así como su mente puede estar más o menos concentrada cuando resuelve un ejercicio matemático. En la mente humana, podemos recordar la solución de un problema matemático, pero para una computadora el mismo proceso siempre será algo nuevo; así, como dije, ¡no siempre obtendrás el mismo resultado!

Aquí hay una función que medirá el tiempo de ejecución de cualquier función pasada como argumento:

#include <chrono>
#include <utility>

typedef std::chrono::high_resolution_clock::time_point TimeVar;

#define duration(a) std::chrono::duration_cast<std::chrono::nanoseconds>(a).count()
#define timeNow() std::chrono::high_resolution_clock::now()

template<typename F, typename... Args>
double funcTime(F func, Args&&... args){
    TimeVar t1=timeNow();
    func(std::forward<Args>(args)...);
    return duration(timeNow()-t1);
}

Ejemplo de uso:

#include <iostream>
#include <algorithm>

typedef std::string String;

//first test function doing something
int countCharInString(String s, char delim){
    int count=0;
    String::size_type pos = s.find_first_of(delim);
    while ((pos = s.find_first_of(delim, pos)) != String::npos){
        count++;pos++;
    }
    return count;
}

//second test function doing the same thing in different way
int countWithAlgorithm(String s, char delim){
    return std::count(s.begin(),s.end(),delim);
}


int main(){
    std::cout<<"norm: "<<funcTime(countCharInString,"precision=10",'=')<<"\n";
    std::cout<<"algo: "<<funcTime(countWithAlgorithm,"precision=10",'=');
    return 0;
}

Salida:

norm: 15555
algo: 2976

programa simple para encontrar el tiempo de ejecución de una función.

#include <iostream>
#include <ctime> // time_t
#include <cstdio>

void function()
{
     for(long int i=0;i<1000000000;i++)
     {
        // do nothing
     }
}

int main()
{

time_t begin,end; // time_t is a datatype to store time values.

time (&begin); // note time before execution
function();
time (&end); // note time after execution

double difference = difftime (end,begin);
printf ("time taken for function() %.2lf seconds.\n", difference );

return 0;
}

En el libro de Scott Meyers encontré un ejemplo de expresión lambda genérica universal que se puede usar para medir el tiempo de ejecución de funciones. (C ++ 14)

auto timeFuncInvocation = 
    [](auto&& func, auto&&... params) {
        // get time before function invocation
        const auto& start = std::chrono::high_resolution_clock::now();
        // function invocation using perfect forwarding
        std::forward<decltype(func)>(func)(std::forward<decltype(params)>(params)...);
        // get time after function invocation
        const auto& stop = std::chrono::high_resolution_clock::now();
        return stop - start;
     };

El problema es que solo mide una ejecución, por lo que los resultados pueden ser muy diferentes. Para obtener un resultado confiable, debe medir un gran número de ejecuciones. Según la conferencia de Andrei Alexandrescu en la conferencia code :: dive 2015 - Writing Fast Code I:

Tiempo medido: tm = t + tq + tn + to

dónde:

tm - tiempo medido (observado)

t - el tiempo real de interés

tq: tiempo agregado por el ruido de cuantización

tn - tiempo agregado por varias fuentes de ruido

a - tiempo de sobrecarga (medición, bucle, funciones de llamada)

De acuerdo con lo que dijo más adelante en la conferencia, debe tomar un mínimo de esta gran cantidad de ejecución como resultado. Os animo a mirar la conferencia en la que explica por qué.

También hay una muy buena biblioteca de google: https://github.com/google/benchmark . Esta biblioteca es muy simple de usar y poderosa. Puede consultar algunas conferencias de Chandler Carruth en YouTube donde está usando esta biblioteca en la práctica. Por ejemplo, CppCon 2017: Chandler Carruth "Going Nowhere Faster";

Ejemplo de uso:

#include <iostream>
#include <chrono>
#include <vector>
auto timeFuncInvocation = 
    [](auto&& func, auto&&... params) {
        // get time before function invocation
        const auto& start = high_resolution_clock::now();
        // function invocation using perfect forwarding
        for(auto i = 0; i < 100000/*largeNumber*/; ++i) {
            std::forward<decltype(func)>(func)(std::forward<decltype(params)>(params)...);
        }
        // get time after function invocation
        const auto& stop = high_resolution_clock::now();
        return (stop - start)/100000/*largeNumber*/;
     };

void f(std::vector<int>& vec) {
    vec.push_back(1);
}

void f2(std::vector<int>& vec) {
    vec.emplace_back(1);
}
int main()
{
    std::vector<int> vec;
    std::vector<int> vec2;
    std::cout << timeFuncInvocation(f, vec).count() << std::endl;
    std::cout << timeFuncInvocation(f2, vec2).count() << std::endl;
    std::vector<int> vec3;
    vec3.reserve(100000);
    std::vector<int> vec4;
    vec4.reserve(100000);
    std::cout << timeFuncInvocation(f, vec3).count() << std::endl;
    std::cout << timeFuncInvocation(f2, vec4).count() << std::endl;
    return 0;
}

EDITAR: Por supuesto, siempre debe recordar que su compilador puede optimizar algo o no. Herramientas como perf pueden ser útiles en tales casos.

Manera fácil para C ++ o C anteriores:

#include <time.h> // includes clock_t and CLOCKS_PER_SEC

int main() {

    clock_t start, end;

    start = clock();
    // ...code to measure...
    end = clock();

    double duration_sec = double(end-start)/CLOCKS_PER_SEC;
    return 0;
}

La precisión del tiempo en segundos es 1.0/CLOCKS_PER_SEC

• Es un método muy fácil de usar en C ++ 11.
• Podemos usar std :: chrono :: high_resolution_clock desde el encabezado
• Podemos escribir un método para imprimir el tiempo de ejecución del método en una forma muy legible.

Por ejemplo, para encontrar todos los números primos entre 1 y 100 millones, se tarda aproximadamente 1 minuto y 40 segundos. Entonces el tiempo de ejecución se imprime como:

Execution Time: 1 Minutes, 40 Seconds, 715 MicroSeconds, 715000 NanoSeconds

El código está aquí:

#include <iostream>
#include <chrono>

using namespace std;
using namespace std::chrono;

typedef high_resolution_clock Clock;
typedef Clock::time_point ClockTime;

void findPrime(long n, string file);
void printExecutionTime(ClockTime start_time, ClockTime end_time);

int main()
{
    long n = long(1E+8);  // N = 100 million

    ClockTime start_time = Clock::now();

    // Write all the prime numbers from 1 to N to the file "prime.txt"
    findPrime(n, "C:\\prime.txt"); 

    ClockTime end_time = Clock::now();

    printExecutionTime(start_time, end_time);
}

void printExecutionTime(ClockTime start_time, ClockTime end_time)
{
    auto execution_time_ns = duration_cast<nanoseconds>(end_time - start_time).count();
    auto execution_time_ms = duration_cast<microseconds>(end_time - start_time).count();
    auto execution_time_sec = duration_cast<seconds>(end_time - start_time).count();
    auto execution_time_min = duration_cast<minutes>(end_time - start_time).count();
    auto execution_time_hour = duration_cast<hours>(end_time - start_time).count();

    cout << "\nExecution Time: ";
    if(execution_time_hour > 0)
    cout << "" << execution_time_hour << " Hours, ";
    if(execution_time_min > 0)
    cout << "" << execution_time_min % 60 << " Minutes, ";
    if(execution_time_sec > 0)
    cout << "" << execution_time_sec % 60 << " Seconds, ";
    if(execution_time_ms > 0)
    cout << "" << execution_time_ms % long(1E+3) << " MicroSeconds, ";
    if(execution_time_ns > 0)
    cout << "" << execution_time_ns % long(1E+6) << " NanoSeconds, ";
}

Aquí hay una excelente plantilla de clase de solo encabezado para medir el tiempo transcurrido de una función o cualquier bloque de código:

#ifndef EXECUTION_TIMER_H
#define EXECUTION_TIMER_H

template<class Resolution = std::chrono::milliseconds>
class ExecutionTimer {
public:
    using Clock = std::conditional_t<std::chrono::high_resolution_clock::is_steady,
                                     std::chrono::high_resolution_clock,
                                     std::chrono::steady_clock>;
private:
    const Clock::time_point mStart = Clock::now();

public:
    ExecutionTimer() = default;
    ~ExecutionTimer() {
        const auto end = Clock::now();
        std::ostringstream strStream;
        strStream << "Destructor Elapsed: "
                  << std::chrono::duration_cast<Resolution>( end - mStart ).count()
                  << std::endl;
        std::cout << strStream.str() << std::endl;
    }    

    inline void stop() {
        const auto end = Clock::now();
        std::ostringstream strStream;
        strStream << "Stop Elapsed: "
                  << std::chrono::duration_cast<Resolution>(end - mStart).count()
                  << std::endl;
        std::cout << strStream.str() << std::endl;
    }

}; // ExecutionTimer

#endif // EXECUTION_TIMER_H

Aquí hay algunos usos:

int main() {
    { // empty scope to display ExecutionTimer's destructor's message
         // displayed in milliseconds
         ExecutionTimer<std::chrono::milliseconds> timer;

         // function or code block here

         timer.stop();

    } 

    { // same as above
        ExecutionTimer<std::chrono::microseconds> timer;

        // code block here...

        timer.stop();
    }

    {  // same as above
       ExecutionTimer<std::chrono::nanoseconds> timer;

       // code block here...

       timer.stop();

    }

    {  // same as above
       ExecutionTimer<std::chrono::seconds> timer;

       // code block here...

       timer.stop();

    }              

    return 0;
}

Como la clase es una plantilla, podemos especificar fácilmente cómo queremos medir y mostrar nuestro tiempo. Esta es una plantilla de clase de utilidad muy útil para hacer marcas de banco y es muy fácil de usar.

Recomiendo usar el steady_clockque es voluntario para ser monótono, a diferencia high_resolution_clock.

#include <iostream>
#include <chrono>

using namespace std;

unsigned int stopwatch()
{
    static auto start_time = chrono::steady_clock::now();

    auto end_time = chrono::steady_clock::now();
    auto delta    = chrono::duration_cast<chrono::microseconds>(end_time - start_time);

    start_time = end_time;

    return delta.count();
}

int main() {
  stopwatch(); //Start stopwatch
  std::cout << "Hello World!\n";
  cout << stopwatch() << endl; //Time to execute last line
  for (int i=0; i<1000000; i++)
      string s = "ASDFAD";
  cout << stopwatch() << endl; //Time to execute for loop
}

Salida:

Hello World!
62
163514

Puede tener una clase simple que se puede utilizar para este tipo de mediciones.

class duration_printer {
public:
    duration_printer() : __start(std::chrono::high_resolution_clock::now()) {}
    ~duration_printer() {
        using namespace std::chrono;
        high_resolution_clock::time_point end = high_resolution_clock::now();
        duration<double> dur = duration_cast<duration<double>>(end - __start);
        std::cout << dur.count() << " seconds" << std::endl;
    }
private:
    std::chrono::high_resolution_clock::time_point __start;
};

Lo único que debe hacer es crear un objeto en su función al comienzo de esa función

void veryLongExecutingFunction() {
    duration_calculator dc;
    for(int i = 0; i < 100000; ++i) std::cout << "Hello world" << std::endl;
}

int main() {
    veryLongExecutingFunction();
    return 0;
}

y eso es. La clase se puede modificar para adaptarse a sus requisitos.

Como ninguna de las respuestas proporcionadas son muy precisas o dan resultados reproducibles, decidí agregar un enlace a mi código que tenga precisión y estadísticas científicas por debajo de los nanosegundos.

Tenga en cuenta que esto solo funcionará para medir el código que tarda (muy) poco tiempo en ejecutarse (es decir, unos pocos ciclos de reloj hasta unos pocos miles): si se ejecutan tanto tiempo que es probable que sean interrumpidos por alguna interrupción -heh- , entonces claramente no es posible dar un resultado reproducible y preciso; La consecuencia es que la medición nunca termina: es decir, continúa midiendo hasta que estadísticamente está 99.9% seguro de que tiene la respuesta correcta que nunca sucede en una máquina que tiene otros procesos en ejecución cuando el código tarda demasiado.

https://github.com/CarloWood/cwds/blob/master/benchmark.h#L40

Si desea ahorrar tiempo y líneas de código, puede hacer que la medición del tiempo de ejecución de la función sea una macro de una línea:

a) Implemente una clase de medición de tiempo como ya se sugirió anteriormente (aquí está mi implementación para Android):

class MeasureExecutionTime{
private:
    const std::chrono::steady_clock::time_point begin;
    const std::string caller;
public:
    MeasureExecutionTime(const std::string& caller):caller(caller),begin(std::chrono::steady_clock::now()){}
    ~MeasureExecutionTime(){
        const auto duration=std::chrono::steady_clock::now()-begin;
        LOGD("ExecutionTime")<<"For "<<caller<<" is "<<std::chrono::duration_cast<std::chrono::milliseconds>(duration).count()<<"ms";
    }
};

b) Agregue una macro conveniente que use el nombre de la función actual como TAG (usar una macro aquí es importante, de lo contrario __FUNCTION__evaluará en MeasureExecutionTimelugar de la función que desea medir

#ifndef MEASURE_FUNCTION_EXECUTION_TIME
#define MEASURE_FUNCTION_EXECUTION_TIME const MeasureExecutionTime measureExecutionTime(__FUNCTION__);
#endif

c) Escriba su macro al comienzo de la función que desea medir. Ejemplo:

 void DecodeMJPEGtoANativeWindowBuffer(uvc_frame_t* frame_mjpeg,const ANativeWindow_Buffer& nativeWindowBuffer){
        MEASURE_FUNCTION_EXECUTION_TIME
        // Do some time-critical stuff 
}

Lo que dará como resultado la siguiente salida:

ExecutionTime: For DecodeMJPEGtoANativeWindowBuffer is 54ms

Tenga en cuenta que esto (como todas las otras soluciones sugeridas) medirá el tiempo entre el momento en que se llamó a su función y cuando regresó, no necesariamente el momento en que su CPU estaba ejecutando la función. Sin embargo, si no le da al programador ningún cambio para suspender su código de ejecución llamando a sleep () o similar, no hay diferencia entre ellos.