C ++ получает время в миллисекундах в Linux - часы () не работают должным образом

Question

В Windows clock() возвращает время в миллисекундах, но в этом окне Linux, над которым я работаю, оно округляется до ближайшей 1000, поэтому точность равна только «второму» уровню, а не уровню миллисекунд .

Я нашел решение с помощью Qt, используя класс QTime, создающий экземпляр объекта и вызывающий start() для него, затем вызывающий elapsed(), чтобы получить количество прошедших миллисекунд.

Мне повезло, потому что я с самого начала работаю с Qt, но я бы хотел решение, которое не зависит от сторонних библиотек,

Нет ли стандартного способа сделать это?

UPDATE

Пожалуйста, не рекомендуем Boost ..

Если Boost и Qt могут это сделать, конечно, это не волшебство, должно быть что-то стандартное, что они используют!

Answer 1

#include <sys/time.h>
#include <stdio.h>
#include <unistd.h>
int main()
{
    struct timeval start, end;

    long mtime, seconds, useconds;    

    gettimeofday(&start, NULL);
    usleep(2000);
    gettimeofday(&end, NULL);

    seconds  = end.tv_sec  - start.tv_sec;
    useconds = end.tv_usec - start.tv_usec;

    mtime = ((seconds) * 1000 + useconds/1000.0) + 0.5;

    printf("Elapsed time: %ld milliseconds\n", mtime);

    return 0;
}

Answer 2

Обратите внимание, что clock не не измеряет время настенных часов. Это означает, что если ваша программа занимает 5 секунд, clock не обязательно будет измерять 5 секунд, но может потребовать больше (ваша программа может запустить несколько потоков и, следовательно, может потреблять больше ЦП, чем в реальном времени) или меньше. Он измеряет приближение процессорное время используется. Чтобы увидеть разницу, рассмотрите этот код

#include <iostream>
#include <ctime>
#include <unistd.h>

int main() {
    std::clock_t a = std::clock();
    sleep(5); // sleep 5s
    std::clock_t b = std::clock();

    std::cout << "difference: " << (b - a) << std::endl;
    return 0;
}

выводит на мою систему

$ difference: 0

Потому что все, что мы делали, это спали и не использовали процессорное время! Однако, используя gettimeofday, мы получаем то, что хотим (?)

#include <iostream>
#include <ctime>
#include <unistd.h>
#include <sys/time.h>

int main() {
    timeval a;
    timeval b;

    gettimeofday(&a, 0);
    sleep(5); // sleep 5s
    gettimeofday(&b, 0);

    std::cout << "difference: " << (b.tv_sec - a.tv_sec) << std::endl;
    return 0;
}

Выходы в моей системе

$ difference: 5

Если вам нужна большая точность, но вы хотите получить процессорное время , тогда вы можете рассмотреть возможность использования функции getrusage.

Answer 3

Вы можете использовать gettimeofday в начале и в конце вашего метода, а затем различать две структуры возврата. Вы получите структуру, подобную следующей:

struct timeval {
  time_t tv_sec;
  suseconds_t tv_usec;
}

Answer 4

Я также рекомендую инструменты, предлагаемые Boost. Либо упомянутый Boost Timer, либо взломайте что-нибудь из Boost.DateTime, либо есть новая предлагаемая библиотека в песочнице - Boost.Chrono : эта последняя будет заменой для Timer и будет содержать:

• Утилиты времени стандартной библиотеки C ++ 0x, в том числе:
  • Шаблон класса duration
  • Шаблон класса time_point
  • Часы:
    • system_clock
    • monotonic_clock
    • high_resolution_clock
• Шаблон класса timer, с typedefs:
  • system_timer
  • monotonic_timer
  • high_resolution_timer
• Часы и таймеры процесса:
  • process_clock, фиксируя реальное, пользовательское и системное время.
  • process_timer, фиксируя истекшее реальное, пользовательское и системное время.
  • run_timer, удобная отчетность | process_timer | Результаты.
• Рациональная арифметика времени компиляции стандартной библиотеки C ++ 0x.

Вот источник из списка функций

Answer 5

Я написал Timer класс, основанный на ответе CTT . Может использоваться следующим образом:

Timer timer = Timer();
timer.start();
/* perform task */
double duration = timer.stop();
timer.printTime(duration);

Вот его реализация:

#include <stdio.h>
#include <stdlib.h>
#include <sys/time.h>
using namespace std;

class Timer {
private:

    timeval startTime;

public:

    void start(){
        gettimeofday(&startTime, NULL);
    }

    double stop(){
        timeval endTime;
        long seconds, useconds;
        double duration;

        gettimeofday(&endTime, NULL);

        seconds  = endTime.tv_sec  - startTime.tv_sec;
        useconds = endTime.tv_usec - startTime.tv_usec;

        duration = seconds + useconds/1000000.0;

        return duration;
    }

    static void printTime(double duration){
        printf("%5.6f seconds\n", duration);
    }
};

Answer 6

Если вам не нужен код для переноса на старые устройства, вы можете использовать clock_gettime (), который даст вам время в наносекундах (если ваш процессор поддерживает это разрешение). Это POSIX, но с 2001 года.

Answer 7

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

(Помните, что вам нужно связать с -lrt в Linux).

Answer 8

С C ++ 11 и std::chrono::high_resolution_clock вы можете сделать это:

#include <iostream>
#include <chrono>
#include <thread>
typedef std::chrono::high_resolution_clock Clock;

int main()
{
    std::chrono::milliseconds three_milliseconds{3};

    auto t1 = Clock::now();
    std::this_thread::sleep_for(three_milliseconds);
    auto t2 = Clock::now();

    std::cout << "Delta t2-t1: " 
              << std::chrono::duration_cast<std::chrono::milliseconds>(t2 - t1).count()
              << " milliseconds" << std::endl;
}

Выход:

Delta t2-t1: 3 milliseconds

Ссылка на демо: http://cpp.sh/2zdtu

Answer 9

clock () не возвращает миллисекунды или секунды в Linux. Обычно clock () возвращает микросекунды в системе Linux. Правильный способ интерпретации значения, возвращаемого функцией clock (), - это разделить его на CLOCKS_PER_SEC, чтобы выяснить, сколько времени прошло.

Answer 10

gettimeofday - проблема в том, что могут иметь более низкие значения, если вы меняете аппаратные часы (например, с NTP) Boost - недоступно для этого проекта clock () - обычно возвращает 4-байтовое целое число, что означает, что оно имеет малую емкость, и через некоторое время возвращает отрицательные числа.

Я предпочитаю создавать свой собственный класс и обновлять его каждые 10 миллисекунд, поэтому этот способ более гибкий, и я даже могу улучшить его, чтобы иметь подписчиков.

class MyAlarm {
static int64_t tiempo;
static bool running;
public:
static int64_t getTime() {return tiempo;};
static void callback( int sig){
    if(running){
        tiempo+=10L;
    }
}
static void run(){ running = true;}
};

int64_t MyAlarm::tiempo = 0L;
bool MyAlarm::running = false;

чтобы обновить его, я использую setitimer:

int main(){
struct sigaction sa; 
struct itimerval timer; 

MyAlarm::run();
memset (&sa, 0, sizeof (sa)); 
sa.sa_handler = &MyAlarm::callback; 

sigaction (SIGALRM, &sa, NULL); 


timer.it_value.tv_sec = 0; 
timer.it_value.tv_usec = 10000; 



timer.it_interval.tv_sec = 0; 
timer.it_interval.tv_usec = 10000; 


setitimer (ITIMER_REAL, &timer, NULL); 
.....

Посмотрите на setitimer, ITIMER_VIRTUAL и ITIMER_REAL.

Не используйте функции будильника или ualarm, у вас будет низкая точность, когда ваш процесс получит тяжелую работу.