Как рассчитать разницу во времени в C ++

Question

Как лучше всего рассчитать разницу во времени в C ++? Я измеряю скорость выполнения программы, поэтому меня интересуют миллисекунды. Еще лучше, секунды. Миллисекунды.

Принятый ответ работает, но должен включать ctime или time.h, как отмечено в комментариях.

Answer 1

См. std::clock() функция.

const clock_t begin_time = clock();
// do something
std::cout << float( clock () - begin_time ) /  CLOCKS_PER_SEC;

Если вы хотите рассчитать время выполнения для себя (не для пользователя), лучше сделать это в тактах (не секундах).

EDIT:
ответственные файлы заголовков - <ctime> или <time.h>

Answer 2

если вы используете c ++ 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_;
};

Или для c ++ 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;
}

Answer 3

Я бы серьезно подумал об использовании 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';

Answer 4

Я добавил этот ответ, чтобы уточнить, что принятый ответ показывает процессорное время, которое может не соответствовать требуемому времени. Потому что в соответствии с ссылкой , есть процессорное время и время настенных часов . Время настенных часов - это время, которое показывает фактическое истекшее время независимо от любых других условий, таких как загрузка процессора другими процессами. Например, я использовал несколько процессоров для выполнения определенной задачи, и время ЦП было высоким 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 elaspedTimeMs = std::chrono::duration<double, std::milli>(t_end-t_start).count();

Answer 5

boost 1.46.0 и выше включает в себя библиотеку Chrono :

класс thread_clock обеспечивает доступ к реальным настенным часам потока, т.е. реальное время процессора в вызывающем потоке. Нить относительная текущее время можно узнать, вызвав 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";

Answer 6

В 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;

}

Answer 7

Вы также можете использовать clock_gettime . Этот метод может быть использован для измерения:

1. Системные часы реального времени
2. Системные монотонные часы
3. Процессорное время процессора
4. На процесс. Поток CPU time

Код выглядит следующим образом:

#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";
}

`

Answer 8

на всякий случай, если вы работаете в Unix, вы можете использовать time для получения времени выполнения:

$ g++ myprog.cpp -o myprog
$ time ./myprog

Answer 9

Еще одно замечание: если вы работаете в Windows и вам действительно нужна точность, вы можете использовать QueryPerformanceCounter . Это дает вам время (потенциально) нано секунд.

Answer 10

Для меня самый простой способ это:

#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.

Наслаждайся любимым подходом.