Вычислить время для выполнения функции

Question

Мне нужно рассчитать время выполнения функции.

В настоящее время я использую time.h

В начале функции:

time_t tbegin,tend; 
double texec=0.000; 
time(&tbegin); 

Перед возвращением:

time(&tend); 
texec = difftime(tend,tbegin); 

Он работает нормально, но дать мне результат в texec как целое число.

Как я могу выполнить время выполнения в миллисекундах?

Answer 1

Большинство простых программ имеют время вычисления в миллисекундах. Итак, я полагаю, вы найдете это полезным.

#include <time.h> 
    #include <stdio.h> 
    int main() 
    { 
     clock_t start = clock(); 
      // Execuatable code 
     clock_t stop = clock(); 
     double elapsed = (double)(stop - start) * 1000.0/CLOCKS_PER_SEC; 
     printf("Time elapsed in ms: %f", elapsed); 
    } 

Если вы хотите, чтобы вычислить время выполнения всей программы, и вы на системе Unix, запустите программу с помощью команды времени, как это время ./a.out

Answer 2

Вы можете создать функцию, как этот source:

typedef unsigned long long timestamp_t; 

static timestamp_t 
timestampinmilliseconf() 
{ 
    struct timeval now; 
    gettimeofday (&now, NULL); 
    return now.tv_usec + (timestamp_t)now.tv_sec * 1000000; 
} 

Затем вы можете использовать это, чтобы получить разницу во времени.

timestamp_t time1 = get_timestamp(); 
// Your function 
timestamp_t time2 = get_timestamp(); 

Для окон вы можете использовать эту функцию:

#ifdef WIN32 
#include <Windows.h> 
#else 
#include <sys/time.h> 
#include <ctime> 
#endif 

typedef long long int64; typedef unsigned long long uint64; 

/* Returns the amount of milliseconds elapsed since the UNIX epoch. Works on both 
* windows and linux. */ 

int64 GetTimeMs64() 
{ 
#ifdef WIN32 
/* Windows */ 
FILETIME ft; 
LARGE_INTEGER li; 

/* Get the amount of 100 nano seconds intervals elapsed since January 1, 1601 (UTC) and copy it 
    * to a LARGE_INTEGER structure. */ 
GetSystemTimeAsFileTime(&ft); 
li.LowPart = ft.dwLowDateTime; 
li.HighPart = ft.dwHighDateTime; 

uint64 ret = li.QuadPart; 
ret -= 116444736000000000LL; /* Convert from file time to UNIX epoch time. */ 
ret /= 10000; /* From 100 nano seconds (10^-7) to 1 millisecond (10^-3) intervals */ 

return ret; 
#else 
/* Linux */ 
struct timeval tv; 

gettimeofday(&tv, NULL); 

uint64 ret = tv.tv_usec; 
/* Convert from micro seconds (10^-6) to milliseconds (10^-3) */ 
ret /= 1000; 

/* Adds the seconds (10^0) after converting them to milliseconds (10^-3) */ 
ret += (tv.tv_sec * 1000); 

return ret; 
#endif 
} 

Source

Answer 3

Вы можете использовать лямбда с auto параметров в C++ 14, чтобы время ваши другие функции. Вы можете передать параметры временной функции на ваш лямбда. Я хотел бы сделать это следующим образом:

// Timing in C++14 with auto lambda parameters 

#include <iostream> 
#include <chrono> 

// need C++14 for auto lambda parameters 
auto timing = [](auto && F, auto && ... params) 
{ 
    auto start = std::chrono::steady_clock::now(); 
    std::forward<decltype(F)>(F) 
    (std::forward<decltype(params)>(params)...); // execute the function 
    return std::chrono::duration_cast<std::chrono::milliseconds>(
       std::chrono::steady_clock::now() - start).count(); 
}; 

void f(std::size_t numsteps) // we'll measure how long this function runs 
{ 
    // need volatile, otherwise the compiler optimizes the loop 
    for (volatile std::size_t i = 0; i < numsteps; ++i); 
} 

int main() 
{ 
    auto taken = timing(f, 500'000'000); // measure the time taken to run f() 
    std::cout << "Took " << taken << " milliseconds" << std::endl; 

    taken = timing(f, 100'000'000); // measure again 
    std::cout << "Took " << taken << " milliseconds" << std::endl; 
} 

Преимущество заключается в том, что вы можете передать любой вызываемый объект в timing лямбда. Если вы не можете использовать параметры лямбда C++ 14 auto, тогда вам нужно написать шаблонный функтор, чтобы «имитировать» лямбда.

Но если вы хотите сохранить его простым, вы можете просто сделать:

auto start = std::chrono::steady_clock::now(); 
your_function_call_here(); 
auto end = std::chrono::steady_clock::now(); 
auto taken = std::chrono::duration_cast<std::chrono::milliseconds>(end - start).count(); 
std::cout << taken << " milliseconds"; 

Если вы знаете, что вы не собираетесь изменять системное время во время бега, вы можете использовать вместо std::chrono::high_resolution_clock, который может быть более точным. std::chrono::steady_clock, однако, не чувствителен к изменениям системного времени во время прогона.

Answer 4

в заголовке <chrono> есть класс std::chrono::high_resolution_clock
, который делает то, что вы хотите. это немного связано с использованием;

#include <chrono> 
using namespace std; 
using namespace chrono; 

auto t1 = high_resolution_clock::now(); 
// do calculation here 
auto t2 = high_resolution_clock::now(); 
auto diff = duration_cast<duration<double>>(t2 - t1); 
// now elapsed time, in seconds, as a double can be found in diff.count() 
long ms = (long)(1000*diff.count());