Как измерить время Wallclock в C ++ вместо времени процессора?

Question

Я бы хотел измерить время, проведенное с помощью моего алгоритма на C ++. Многие статьи указывают на этот код.

clock_t begin_time, end_time;
begin_time = clock();
Algorithm();
end_time = clock();
cout << ((double)(end_time - begin_time)/CLOCKS_PER_SEC) << endl;

Но это измеряет только время процессора, затраченное моим алгоритмом. В другой статье указывался этот код.

double getUnixTime(void)
{
    struct timespec tv;

    if(clock_gettime(CLOCK_REALTIME, &tv) != 0) return 0;

    return (tv.tv_sec + (tv.tv_nsec / 1000000000.0));
}
double begin_time, end_time;
begin_time = getUnixTime();
Algorithm();
end_time = getUnixTime();
cout << (double) (end_time - begin_time) << endl;

Я думал, что это напечатает время на стене, затраченное моим алгоритмом. Но удивительно, время, напечатанное этим кодом, намного меньше, чем время процессора, напечатанное предыдущим кодом. Итак, я в замешательстве. Пожалуйста, предоставьте код для печати времени на стене.

Answer 1

Те времена, вероятно, из-за шума.Чтобы получить разумное измерение времени, попробуйте выполнить свой алгоритм много раз в цикле:

const int loops = 1000000;
double begin_time, end_time;
begin_time = getUnixTime();

for (int i = 0; i < loops; ++i)
    Algorithm();

end_time = getUnixTime();
cout << (double) (end_time - begin_time) / loops << endl;

Answer 2

Я получаю примерно столько же раз в однопоточной программе:

#include <time.h>
#include <stdio.h>
__attribute((noinline)) void nop(void){}
void loop(unsigned long Cnt) { for(unsigned long i=0; i<Cnt;i++) nop(); }
int main()
{
    clock_t t0,t1;
    struct timespec ts0,ts1;
    t0=clock();
    clock_gettime(CLOCK_REALTIME,&ts0);
    loop(1000000000);
    t1=clock();
    clock_gettime(CLOCK_REALTIME,&ts1);
    printf("clock-diff: %lu\n", (unsigned long)((t1 - t0)/CLOCKS_PER_SEC));
    printf("clock_gettime-diff: %lu\n", (unsigned long)((ts1.tv_sec - ts0.tv_sec)));
}
//prints 2 and 3 or 2 and 2 on my system

Но справочная страница clock s описывает только возвращение приближения .Нет никаких признаков того, что аппроксимация сравнима с тем, что возвращает clock_gettime.

Где я получаю радикально разные результаты, это когда я добавляю несколько потоков:

#include <time.h>
#include <stdio.h>
#include <pthread.h>
__attribute((noinline)) void nop(void){}
void loop(unsigned long Cnt) {
    for(unsigned long i=0; i<Cnt;i++) nop();
}
void *busy(void *A){ (void)A; for(;;) nop(); }
int main()
{
    pthread_t ptids[4]; 
    for(size_t i=0; i<sizeof(ptids)/sizeof(ptids[0]); i++)
        pthread_create(&ptids[i], 0, busy, 0);
    clock_t t0,t1;
    struct timespec ts0,ts1;
    t0=clock();
    clock_gettime(CLOCK_REALTIME,&ts0);
    loop(1000000000);
    t1=clock();
    clock_gettime(CLOCK_REALTIME,&ts1);
    printf("clock-diff: %lu\n", (unsigned long)((t1 - t0)/CLOCKS_PER_SEC));
    printf("clock_gettime-diff: %lu\n", (unsigned long)((ts1.tv_sec - ts0.tv_sec)));

}
//prints 18 and 4 on my 4-core linux system

Это потому, что и musl, и glibc onВ Linux для реализации clock() используется clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &ts), а нестандартные часы CLOCK_PROCESS_CPUTIME_ID описаны в справочной странице clock_gettime как время возврата для всех потоков процесса вместе.