c++ - fragmentos - codigo c# ejemplos

Buscando un fragmento de código de referencia(c++)

Question

Algunas rutinas de carga en mi programa tardan en completarse. Quiero un pequeño fragmento rápido para comprobar cuánto tardó en ejecutarse una función. Por pequeño me refiero a "preferiblemente sin bibliotecas de terceros".

¿Tal vez algo tan simple como tomar el tiempo del sistema?

start = current_system_time()
load_something()
delta = current_system_time()-start
log_debug("load took "+delta)

Editar: el sistema operativo objetivo en cuestión es Windows.

Answer 1

Esta es una manera rápida y sucia de sincronizar un bloque de código C / C ++. Necesita #include <sys/time.h> , que debería ser un encabezado estándar ...

struct timeval start, end;
gettimeofday(&start, NULL);
// benchmark code
gettimeofday(&end, NULL);
long long time =   (end.tv_sec * (unsigned int)1e6 +   end.tv_usec) - 
                 (start.tv_sec * (unsigned int)1e6 + start.tv_usec);

Esto debería dar una resolución de 1-2μs en los sistemas Linux modernos (¿qué SO estás usando?), Lo que significa que no es muy adecuado para aprender mucho para elementos que toman <10μs. Sin embargo, no pareces estar en esa situación.

Actualización: Basado en el sistema operativo especificado ... Implementación de Windows de gettimeofday ()

Answer 2

Su respuesta: sí

Advertencia: eso NO funcionará en códigos multihebra o en máquinas con múltiples núcleos; necesitará un reloj de pared robusto. Así que te recomiendo que uses el wallclock de omp. OMP está incluido con VC y GCC, y la mayoría de los compiladores, y es un estándar que no necesita preocuparse por desaparecer

#include <omp.h>

// Starting the time measurement
double start = omp_get_wtime();
// Computations to be measured
...
// Measuring the elapsed time
double end = omp_get_wtime();
// Time calculation (in seconds)

Answer 3

Tengo un encabezado benchmark.hpp en mi biblioteca sweet.hpp . Tiene dos herramientas de referencia. El primero es un simple manual start stop time taker

Bench b;
...
b.stop();
b.milli(); // returns an uint with passed millisec. Also has sec and micro sec

El otro es un poco más sofisticado. Usted escribe funciones o bloquea declaraciones como esta.

void myFunc() {
    BENCH(someName);
    ...
}

Y al final, llame a sweet::Benchmark::printResults(); tener el tiempo invertido y la cantidad de llamadas impresas.

Editar: agregué una función para que pueda llamarlo así.

double c = BENCHMARK_CNT(25, yourFunctionCallHere());

Answer 4

Uso una clase para esto, está diseñada para medir el tiempo necesario para ejecutar una función y escribirla en un archivo de texto uth-16le (necesito actualizar esto para usar una nueva clase que hice para esto ... pero nm).

Crea una nueva instancia en la parte superior de una función, por ejemplo, jProfiler (L "myFunction") y la limpieza al final de la función hará el resto, si quieres estar seguro aunque nuevo y eliminarlo tú mismo. Es un poco exagerado para una pequeña prueba, pero podría ayudar:

// start header

/* jProfiler class by Semi Essessi
 *
 * (class description goes here)
 *
 */

#ifndef __JPROFILER_H
#define __JPROFILER_H

#include <stdio.h>
#include <windows.h>

class jProfiler
{
private:
    wchar_t*        str;
    LARGE_INTEGER   start;
    LARGE_INTEGER   tps;
    LARGE_INTEGER   buf;

    static FILE*    f;
    static int      instCount;

    static void     Initialise();
    static void     Shutdown();
public:
    jProfiler(const wchar_t* msg);
    ~jProfiler();
};

#endif

// - end header

/* jProfiler class by Semi Essessi
 *
 * (class description goes here)
 *
 */

#include "jProfiler.h"

#include <windows.h>

FILE* jProfiler::f = 0;
int jProfiler::instCount = 0;

jProfiler::jProfiler(const wchar_t* msg)
{
    // constructor code for menuVar
    int i = (int)wcslen(msg)+1;
    str = new wchar_t[i];
    memcpy(str, msg, sizeof(wchar_t)*i);
    str[i-1] =  0;

    QueryPerformanceFrequency(&tps);
    QueryPerformanceCounter(&start);

    instCount++;
    Initialise();
}

jProfiler::~jProfiler()
{
    // destructor code for menuVar
    QueryPerformanceCounter(&buf);
    // work out change in time
    double dt=((float)buf.QuadPart - (float)start.QuadPart)/(float)tps.QuadPart;
    fwprintf(f, L"%s : %.20f/r/n", str, dt);

    if(str) delete[] str;
    instCount--;
    Shutdown();
}

void jProfiler::Initialise()
{
    if(!f)
    {
        f = _wfopen(L"profilerlog.txt", L"wb");
        unsigned short a = 0xFEFF;
        fwrite(&a, sizeof(unsigned short), 1, f);
    }
}

void jProfiler::Shutdown()
{
    if(instCount==0) if(f) fclose(f);
}

Answer 5

#if defined(_WIN32) || defined(__WIN32__) || defined(WIN32)

namespace win32 {
    #include <windows.h>
}

class timer
{
    win32::LARGE_INTEGER start_time_;
public:
    timer() { QueryPerformanceCounter( &start_time_ ); }
    void   restart() { QueryPerformanceCounter( &start_time_ ); }
    double elapsed() const
    {
        win32::LARGE_INTEGER end_time, frequency;
        QueryPerformanceCounter( &end_time );
        QueryPerformanceFrequency( &frequency );
        return double( end_time.QuadPart - start_time_.QuadPart )
            / frequency.QuadPart;
    }
};

#else

#include <ctime>

class timer
{
    clock_t _start_time;
public:
    timer() { _start_time = clock(); }
    void   restart() { _start_time = clock(); }
    double elapsed() const
    {
        return double(clock() - _start_time) / CLOCKS_PER_SEC;
    }
};

#endif

template< typename Func >
double measure_time( Func f )
{
    timer t;
    f();
    return t.elapsed();
}