Какой лучший способ рассчитать разницу во времени на С++? Я определяю скорость выполнения программы, поэтому меня интересуют миллисекунды. Еще лучше, секунды .milliseconds..
Принятый ответ работает, но ему нужно включить ctime или time.h, как указано в комментариях.
См. std::clock().
const clock_t begin_time = clock();
// do something
std::cout << float( clock () - begin_time ) / CLOCKS_PER_SEC;
Если вы хотите вычислить время выполнения для себя (не для пользователя), лучше сделать это в тактах (не секунды).
EDIT:
ответственные файлы заголовков - <ctime> или <time.h>
если вы используете С++ 11, вот простая оболочка (см. gist):
#include <iostream>
#include <chrono>
class Timer
{
public:
Timer() : beg_(clock_::now()) {}
void reset() { beg_ = clock_::now(); }
double elapsed() const {
return std::chrono::duration_cast<second_>
(clock_::now() - beg_).count(); }
private:
typedef std::chrono::high_resolution_clock clock_;
typedef std::chrono::duration<double, std::ratio<1> > second_;
std::chrono::time_point<clock_> beg_;
};
Или для С++ 03 на * nix:
#include <iostream>
#include <ctime>
class Timer
{
public:
Timer() { clock_gettime(CLOCK_REALTIME, &beg_); }
double elapsed() {
clock_gettime(CLOCK_REALTIME, &end_);
return end_.tv_sec - beg_.tv_sec +
(end_.tv_nsec - beg_.tv_nsec) / 1000000000.;
}
void reset() { clock_gettime(CLOCK_REALTIME, &beg_); }
private:
timespec beg_, end_;
};
Пример использования:
int main()
{
Timer tmr;
double t = tmr.elapsed();
std::cout << t << std::endl;
tmr.reset();
t = tmr.elapsed();
std::cout << t << std::endl;
return 0;
}
Я бы серьезно подумал об использовании Boost, особенно boost:: posix_time:: ptime и boost:: posix_time:: time_duration (в http://www.boost.org/doc/libs/1_38_0/doc/html/date_time/posix_time.html).
Это кросс-платформенный, простой в использовании и по моему опыту обеспечивает наивысший уровень разрешения времени, предоставляемого операционной системой. Возможно, это тоже очень важно; он предоставляет некоторые очень хорошие операторы ввода-вывода.
Чтобы использовать его для вычисления разницы в выполнении программы (до микросекунды, возможно, переполнения), она будет выглядеть примерно так: [браузер написан, а не проверен]:
ptime time_start(microsec_clock::local_time());
//... execution goes here ...
ptime time_end(microsec_clock::local_time());
time_duration duration(time_end - time_start);
cout << duration << '\n';
Я добавил этот ответ, чтобы уточнить, что в принятом ответе указано время процессора, которое может не соответствовать требуемому времени. Поскольку согласно ссылке, есть время процессора и время настенных часов. Время настенных часов - это время, которое показывает фактическое истекшее время независимо от любых других условий, таких как загрузка процессора другими процессами. Например, я использовал несколько процессоров для выполнения определенной задачи, и время ЦП было высоким 18 с., где фактически потребовалось 2 с. в реальном времени настенных часов.
Чтобы узнать фактическое время,
#include <chrono>
auto t_start = std::chrono::high_resolution_clock::now();
// the work...
auto t_end = std::chrono::high_resolution_clock::now();
double elapsed_time_ms = std::chrono::duration<double, std::milli>(t_end-t_start).count();
boost 1.46.0 и выше включает библиотеку Chrono:
класс thread_clock обеспечивает доступ к реальным потоковым часам, т.е. реальные часы CPU-времени вызывающего потока. Относительный поток текущее время можно получить, вызвав thread_clock:: now()
#include <boost/chrono/thread_clock.hpp>
{
...
using namespace boost::chrono;
thread_clock::time_point start = thread_clock::now();
...
thread_clock::time_point stop = thread_clock::now();
std::cout << "duration: " << duration_cast<milliseconds>(stop - start).count() << " ms\n";
В Windows: используйте GetTickCount
//GetTickCount defintition
#include <windows.h>
int main()
{
DWORD dw1 = GetTickCount();
//Do something
DWORD dw2 = GetTickCount();
cout<<"Time difference is "<<(dw2-dw1)<<" milliSeconds"<<endl;
}
Вы также можете использовать clock_gettime. Этот метод может быть использован для измерения:
Код выглядит следующим образом:
#include < time.h >
#include <iostream>
int main(){
timespec ts_beg, ts_end;
clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &ts_beg);
clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &ts_end);
std::cout << (ts_end.tv_sec - ts_beg.tv_sec) + (ts_end.tv_nsec - ts_beg.tv_nsec) / 1e9 << " sec";
}
"
на всякий случай, если вы находитесь в Unix, вы можете использовать time для получения времени выполнения:
$ g++ myprog.cpp -o myprog
$ time ./myprog
Просто обратите внимание: если вы работаете в Windows, и вам действительно нужна точность, вы можете использовать QueryPerformanceCounter. Это дает вам время (возможно) nano секунд.
Получить системное время в миллисекундах в начале и снова в конце и вычесть.
Чтобы получить число миллисекунд с 1970 года в POSIX, вы должны написать:
struct timeval tv;
gettimeofday(&tv, NULL);
return ((((unsigned long long)tv.tv_sec) * 1000) +
(((unsigned long long)tv.tv_usec) / 1000));
Чтобы получить число миллисекунд с 1601 года в Windows, вы должны написать:
SYSTEMTIME systime;
FILETIME filetime;
GetSystemTime(&systime);
if (!SystemTimeToFileTime(&systime, &filetime))
return 0;
unsigned long long ns_since_1601;
ULARGE_INTEGER* ptr = (ULARGE_INTEGER*)&ns_since_1601;
// copy the result into the ULARGE_INTEGER; this is actually
// copying the result into the ns_since_1601 unsigned long long.
ptr->u.LowPart = filetime.dwLowDateTime;
ptr->u.HighPart = filetime.dwHighDateTime;
// Compute the number of milliseconds since 1601; we have to
// divide by 10,000, since the current value is the number of 100ns
// intervals since 1601, not ms.
return (ns_since_1601 / 10000);
Если вы решили нормализовать ответ Windows, чтобы он также возвращал количество миллисекунд с 1970 года, вам придется настроить свой ответ на 11644473600000 миллисекунд. Но это не обязательно, если все, о чем вы заботитесь, это прошедшее время.
Для меня самый простой способ:
#include <boost/timer.hpp>
boost::timer t;
double duration;
t.restart();
/* DO SOMETHING HERE... */
duration = t.elapsed();
t.restart();
/* DO OTHER STUFF HERE... */
duration = t.elapsed();
используя этот фрагмент кода, вам не нужно классифицировать end - start.
Наслаждайтесь любимым подходом.
Если вы используете:
tstart = clock();
// ...do something...
tend = clock();
Для получения времени в секундах вам понадобится следующее:
time = (tend - tstart) / (double) CLOCKS_PER_SEC;
Это, похоже, отлично работает для Mac Mac 10.7:
#include <time.h>
time_t start = time(NULL);
//Do your work
time_t end = time(NULL);
std::cout<<"Execution Time: "<< (double)(end-start)<<" Seconds"<<std::endl;