millisecond precision timing of functions in C - crossplatform

Question

Is there a way to get milliseconds precision, accurate (at least within a few ms) times in C using a cross-platform approach?

on a POSIX system I can use sys/time.h, but that is not cross-platform.

the stdlib time() function only gives second level precision

you can always check the current time in a loop.... can you provide more information including why and what did you try? — No Idea For Name, Jul 14 '13 at 12:07
Can you just run the subroutine 1000 times in a loop, measure the time in seconds, and then divide by 1000. BTW, a millisecond is a *long* time in a processor. — Mike Dunlavey, Jul 14 '13 at 15:34
This was for timing algorithms that might run in the ~50ms to 10 seconds range — talloaktrees, Jul 15 '13 at 13:33

score 4 · Accepted Answer · edited May 23 '17 at 12:06

I haven't found a cross-platform solution to measuring time in C, per se. However, what I do is use almost identical functions for Unix and Windows. I created this gist because I always have to re-look this up every time. In short:

Unix

#include <time.h>

long diff_micro(struct timespec *start, struct timespec *end)
{
    /* us */
    return ((end->tv_sec * (1000000)) + (end->tv_nsec / 1000)) -
        ((start->tv_sec * 1000000) + (start->tv_nsec / 1000));
}

long diff_milli(struct timespec *start, struct timespec *end)
{
    /* ms */
    return ((end->tv_sec * 1000) + (end->tv_nsec / 1000000)) -
        ((start->tv_sec * 1000) + (start->tv_nsec / 1000000));
}

int main(int argc, char **argv)
{
    struct timespec start, end;

    clock_gettime(CLOCK_MONOTONIC, &start);

    // Activity to be timed
    sleep(1000);

    clock_gettime(CLOCK_MONOTONIC, &end);

    printf("%ld us\n", diff_micro(&start, &end));
    printf("%ld ms\n", diff_milli(&start, &end));

    return 0;
}

source for Unix solution

Win32

#include <Windows.h>

long diff_micro(LARGE_INTEGER *start, LARGE_INTEGER *end)
{
    LARGE_INTEGER Frequency, elapsed;

    QueryPerformanceFrequency(&Frequency); 
    elapsed.QuadPart = end->QuadPart - start->QuadPart;

    elapsed.QuadPart *= 1000000;
    elapsed.QuadPart /= Frequency.QuadPart;

    return elapsed.QuadPart;
}

long diff_milli(LARGE_INTEGER *start, LARGE_INTEGER *end)
{
    LARGE_INTEGER Frequency, elapsed;

    QueryPerformanceFrequency(&Frequency); 
    elapsed.QuadPart = end->QuadPart - start->QuadPart;

    elapsed.QuadPart *= 1000;
    elapsed.QuadPart /= Frequency.QuadPart;

    return elapsed.QuadPart;
}

int main(int argc, char **argv)
{
    LARGE_INTEGER StartingTime, EndingTime;

    QueryPerformanceCounter(&StartingTime);

    // Activity to be timed
    Sleep(1000);

    QueryPerformanceCounter(&EndingTime);

    printf("%ld us\n", diff_micro(&StartingTime, &EndingTime));
    printf("%ld ms\n", diff_milli(&StartingTime, &EndingTime));

    return 0;
}

source used for Win32 solution

score 0 · Answer 2 · edited May 23 '17 at 11:58

0

You can try something like this:-

#include <time.h>
clock_t uptime = clock() / (CLOCKS_PER_SEC / 1000);

See this Link

edited May 23 '17 at 11:58

Community

1
1

answered Jul 14 '13 at 12:42

Vivek Sadh

4,230
3
32
49

`clock` gives the CPU time, not real time. It stops on blocking, and goes faster if multi-threaded. – RnMss Oct 09 '13 at 05:31

Dmitry Negoda · Answer 3 · 2017-07-19T16:01:19.110

0

The best way is using std::chrono

#include <chrono>

...

auto begin = std::chrono::high_resolution_clock::now();

...

auto end = std::chrono::high_resolution_clock::now();
elapsedTime = std::chrono::duration_cast<std::chrono::milliseconds>(end - begin).count();

edited Jul 19 '17 at 16:01

answered Jul 19 '17 at 15:53

Dmitry Negoda

2,894
2
18
15

millisecond precision timing of functions in C - crossplatform

3 Answers3

Unix

Win32