faster equivalent of gettimeofday

by

POSIX Clocks

I wrote a benchmark for POSIX clock sources:

  • time (s) => 3 cycles
  • ftime (ms) => 54 cycles
  • gettimeofday (us) => 42 cycles
  • clock_gettime (ns) => 9 cycles (CLOCK_MONOTONIC_COARSE)
  • clock_gettime (ns) => 9 cycles (CLOCK_REALTIME_COARSE)
  • clock_gettime (ns) => 42 cycles (CLOCK_MONOTONIC)
  • clock_gettime (ns) => 42 cycles (CLOCK_REALTIME)
  • clock_gettime (ns) => 173 cycles (CLOCK_MONOTONIC_RAW)
  • clock_gettime (ns) => 179 cycles (CLOCK_BOOTTIME)
  • clock_gettime (ns) => 349 cycles (CLOCK_THREAD_CPUTIME_ID)
  • clock_gettime (ns) => 370 cycles (CLOCK_PROCESS_CPUTIME_ID)
  • rdtsc (cycles) => 24 cycles

These numbers are from an Intel Core i7-4771 CPU @ 3.50GHz on Linux 4.0. These measurements were taken using the TSC register and running each clock method thousands of times and taking the minimum cost value.

You’ll want to test on the machines you intend to run on though as how these are implemented varies from hardware and kernel version. The code can be found here. It relies on the TSC register for cycle counting, which is in the same repo (tsc.h).

TSC

Access the TSC (processor time-stamp counter) is the most accurate and cheapest way to time things. Generally, this is what the kernel is using itself. It’s also quite straight-forward on modern Intel chips as the TSC is synchronized across cores and unaffected by frequency scaling. So it provides a simple, global time source. You can see an example of using it here with a walkthrough of the assembly code here.

The main issue with this (other than portability) is that there doesn’t seem to be a good way to go from cycles to nanoseconds. The Intel docs as far as I can find state that the TSC runs at a fixed frequency, but that this frequency may differ from the processors stated frequency. Intel doesn’t appear to provide a reliable way to figure out the TSC frequency. The Linux kernel appears to solve this by testing how many TSC cycles occur between two hardware timers (see here).

Memcached

Memcached bothers to do the cache method. It may simply be to make sure the performance is more predictable across platforms, or scale better with multiple cores. It may also no be a worthwhile optimization.

More Related Contents:

  1. Optimize this C Code [closed]
  2. Improve INSERT-per-second performance of SQLite
  3. What is the fastest/most efficient way to find the highest set bit (msb) in an integer in C?
  4. Why does the order of the loops affect performance when iterating over a 2D array?
  5. C loop optimization help for final assignment (with compiler optimization disabled)
  6. Is there a performance difference between i++ and ++i in C?
  7. Are compilers allowed to eliminate infinite loops?
  8. Rounding up to next power of 2
  9. Disable all optimization options in GCC
  10. How to prevent GCC from optimizing out a busy wait loop?
  11. clock_gettime alternative in Mac OS X
  12. What is the instruction that gives branchless FP min and max on x86?
  13. What’s missing/sub-optimal in this memcpy implementation?
  14. What is the fastest way to convert float to int on x86
  15. Why doesn’t GCC optimize structs?
  16. Fastest Implementation of the Natural Exponential Function Using SSE
  17. Compute fast log base 2 ceiling
  18. Why is memcmp so much faster than a for loop check?
  19. How to optimize these loops (with compiler optimization disabled)?
  20. How to determine if memory is aligned?
  21. C for loop indexing: is forward-indexing faster in new CPUs?
  22. Are constant C expressions evaluated at compile time or at runtime?
  23. Count each bit-position separately over many 64-bit bitmasks, with AVX but not AVX2
  24. Very fast memcpy for image processing?
  25. Faster approach to checking for an all-zero buffer in C?
  26. What’s the proper implementation for hardware emulation?
  27. Produce loops without cmp instruction in GCC
  28. How can I optimize these loops (with compiler optimization disabled)?
  29. Query on -ffunction-section & -fdata-sections options of gcc
  30. Efficient 4×4 matrix multiplication (C vs assembly)

Leave a Comment