How to Calculate Execution Time of a Code Snippet in C

Question

I have to compute execution time of a C   code snippet in seconds  It must be working either on Windows or Unix machines   I use code the following code to do this   import  before   clock t startTime   clock       some code here    to compute its execution duration in runtime cout  lt  lt  double  clock   - startTime      double CLOCKS PER SEC lt  lt    seconds    lt  lt  endl    However for small inputs or short statements such as a   a   1  I get  0 seconds  result  I think it must be something like 0 0000001 seconds or something like that   I remember that System nanoTime   in Java works pretty well in this case  However I can t get same exact functionality from clock   function of C     Do you have a solution

User · Answer

Thats how i do it  not much code  easy to understand  fits my needs  void bench std  function lt void   gt  fnBench  std  string name  size t iterations        if  iterations    0          return      if  fnBench    nullptr          return      std  chrono  high resolution clock  time point start  end      if  iterations    1                start   std  chrono  high resolution clock  now            fnBench            end   std  chrono  high resolution clock  now              else               start   std  chrono  high resolution clock  now            for  size t i   0  i  lt  iterations    i              fnBench            end   std  chrono  high resolution clock  now              printf                quot bench      quot  s  quot    u     4 6lfs r n quot           name c str            iterations          std  chrono  duration cast lt std  chrono  duration lt double gt  gt  end - start  count             Usage  bench            - gt  void    function                  Put your code here             quot the name of this quot      name     1000000    iterations

User · Answer

include  lt omp h gt   double start   omp get wtime        code   double finish   omp get wtime     double total time   finish - start

User · Answer

windows specific solution  The current  circa 2017  way to get accurate timings under windows is to use  QueryPerformanceCounter   This approach has the benefit of giving very accurate results and  is recommended by MS  Just plop the code blob into a new console app to get a working sample  There is a lengthy discussion here  Acquiring High resolution time stamps   include  lt iostream gt   include  lt tchar h gt   include  lt windows h gt   int main     constexpr int MAX ITER  10000    constexpr   int64 us per hour  3600000000ull       3 6e 09 constexpr   int64 us per min  60000000ull    constexpr   int64 us per sec  1000000ull    constexpr   int64 us per ms  1000ull        easy to work with   int64 startTick  endTick  ticksPerSecond  totalTicks   0ull   QueryPerformanceFrequency  LARGE INTEGER    amp ticksPerSecond    for  int iter   0  iter  lt  MAX ITER    iter      start looping     QueryPerformanceCounter  LARGE INTEGER    amp startTick      Get start tick        code to be timed     std  cout  lt  lt   cur tick      lt  lt  iter  lt  lt    n       QueryPerformanceCounter  LARGE INTEGER    amp endTick      Get end tick     totalTicks    endTick - startTick     accumulate time taken       convert to elapsed microseconds   int64 totalMicroSeconds     totalTicks   1000000ull   ticksPerSecond     int64 hours   totalMicroSeconds   us per hour  totalMicroSeconds    us per hour    int64 minutes   totalMicroSeconds   us per min  totalMicroSeconds    us per min    int64 seconds   totalMicroSeconds   us per sec  totalMicroSeconds    us per sec    int64 milliseconds   totalMicroSeconds   us per ms  totalMicroSeconds    us per ms    std  cout  lt  lt   Total time     lt  lt  hours  lt  lt   h    std  cout  lt  lt  minutes  lt  lt   m    lt  lt  seconds  lt  lt   s    lt  lt  milliseconds  lt  lt   ms    std  cout  lt  lt  totalMicroSeconds  lt  lt   us n    return 0

User · Answer

You could also look at the  cxx-rtimers  1  on GitHub  which provide some header-only routines for gathering statistics on the run-time of any code-block where you can create a local variable  Those timers have versions that use std  chrono on C  11  or timers from the Boost library  or standard POSIX timer functions  These timers will report the average  maximum  amp  minimum duration spent within a function  as well as the number of times it is called  They can be used as simply as follows    include  lt rtimers cxx11 hpp gt   void expensiveFunction         static rtimers  cxx11  DefaultTimer timer  expensive        auto scopedStartStop   timer scopedStart           Do something costly

User · Answer

Windows provides QueryPerformanceCounter   function  and Unix has gettimeofday   Both functions can measure at least 1 micro-second difference

User · Answer

For cases where you want to time the same stretch of code every time it gets executed  e g  for profiling code that you think might be a bottleneck   here is a wrapper around  a slight modification to  Andreas Bonini s function that I find useful    ifdef  WIN32  include  lt Windows h gt   else  include  lt sys time h gt   endif         A simple timer class to see how long a piece of code takes       Usage                   static Timer timer  name                              timer start             The code you want timed           timer stop                               At the end of execution  you will get output         Time for name  XXX seconds     class Timer   public      Timer std  string name  bool start running false              name name    accum 0    running false                if  start running  start                Timer     stop    report           void start             if    running                 start time   GetTimeMicroseconds                 running   true                      void stop             if   running                unsigned long long stop time   GetTimeMicroseconds                 accum    stop time -  start time               running   false                      void report              std  cout lt  lt  Time for   lt  lt  name lt  lt       lt  lt   accum   1 e6  lt  lt    seconds n          private         cf  http   stackoverflow com questions 1861294 how-to-calculate-execution-time-of-a-code-snippet-in-c     unsigned long long GetTimeMicroseconds          ifdef  WIN32            Windows            FILETIME ft          LARGE INTEGER li              Get the amount of 100 nano seconds intervals elapsed since January 1  1601  UTC  and copy it                to a LARGE INTEGER structure             GetSystemTimeAsFileTime  amp ft           li LowPart   ft dwLowDateTime          li HighPart   ft dwHighDateTime           unsigned long long ret   li QuadPart          ret -  116444736000000000LL     Convert from file time to UNIX epoch time             ret    10     From 100 nano seconds  10 -7  to 1 microsecond  10 -6  intervals     else            Linux            struct timeval tv           gettimeofday  amp tv  NULL            unsigned long long ret   tv tv usec             Adds the seconds  10 0  after converting them to microseconds  10 -6             ret     tv tv sec   1000000    endif         return ret            std  string  name      long long  accum      unsigned long long  start time      bool  running

User · Answer

boost  timer will probably give you as much accuracy as you ll need  It s nowhere near accurate enough to tell you how long a   a 1  will take  but I what reason would you have to time something that takes a couple nanoseconds

User · Answer

I have another working example that uses microseconds  UNIX  POSIX  etc         include  lt sys time h gt      typedef unsigned long long timestamp t       static timestamp t     get timestamp                struct timeval now        gettimeofday   amp now  NULL         return  now tv usec    timestamp t now tv sec   1000000                     timestamp t t0   get timestamp           Process     timestamp t t1   get timestamp         double secs    t1 - t0    1000000 0L    Here s the file where we coded this   https   github com arhuaco junkcode blob master emqbit-bench bench c

User · Answer

It is better to run the inner loop several times with the performance timing only once and average by dividing inner loop repetitions than to run the whole thing  loop   performance timing  several times and average   This will reduce the overhead of the performance timing code vs your actual profiled section   Wrap your timer calls for the appropriate system   For Windows  QueryPerformanceCounter is pretty fast and  safe  to use   You can use  rdtsc  on any modern X86 PC as well but there may be issues on some multicore machines  core hopping may change timer  or if you have speed-step of some sort turned on

User · Answer

In some programs I wrote I used RDTS for such purpose  RDTSC is not about time but about number of cycles from processor start  You have to calibrate it on your system to get a result in second  but it s really handy when you want to evaluate performance  it s even better to use number of cycles directly without trying to change them back to seconds    link above is to a french wikipedia page  but it has C   code samples  english version is here

User · Answer

You can use this function I wrote  You call GetTimeMs64    and it returns the number of milliseconds elapsed since the unix epoch using the system clock - the just like time NULL   except in milliseconds   It works on both windows and linux  it is thread safe   Note that the granularity is 15 ms on windows  on linux it is implementation dependent  but it usually 15 ms as well    ifdef  WIN32  include  lt Windows h gt   else  include  lt sys time h gt   include  lt ctime gt   endif     Remove if already defined    typedef long long int64  typedef unsigned long long uint64      Returns the amount of milliseconds elapsed since the UNIX epoch  Works on both    windows and linux      uint64 GetTimeMs64      ifdef  WIN32     Windows     FILETIME ft   LARGE INTEGER li       Get the amount of 100 nano seconds intervals elapsed since January 1  1601  UTC  and copy it     to a LARGE INTEGER structure      GetSystemTimeAsFileTime  amp ft    li LowPart   ft dwLowDateTime   li HighPart   ft dwHighDateTime    uint64 ret   li QuadPart   ret -  116444736000000000LL     Convert from file time to UNIX epoch time      ret    10000     From 100 nano seconds  10 -7  to 1 millisecond  10 -3  intervals      return ret   else     Linux     struct timeval tv    gettimeofday  amp tv  NULL     uint64 ret   tv tv usec      Convert from micro seconds  10 -6  to milliseconds  10 -3      ret    1000       Adds the seconds  10 0  after converting them to milliseconds  10 -3      ret     tv tv sec   1000     return ret   endif

User · Answer

Here is a simple solution in C  11 which gives you satisfying resolution    include  lt iostream gt   include  lt chrono gt   class Timer   public      Timer     beg  clock   now           void reset     beg    clock   now          double elapsed   const            return std  chrono  duration cast lt second  gt               clock   now   - beg   count       private      typedef std  chrono  high resolution clock clock       typedef std  chrono  duration lt double  std  ratio lt 1 gt   gt  second       std  chrono  time point lt clock  gt  beg        Or on  nix  for c  03   include  lt iostream gt   include  lt ctime gt   class Timer   public      Timer     clock gettime CLOCK REALTIME   amp beg           double elapsed             clock gettime CLOCK REALTIME   amp end            return end  tv sec - beg  tv sec                end  tv nsec - beg  tv nsec    1000000000              void reset     clock gettime CLOCK REALTIME   amp beg       private      timespec beg   end        Here is the example usage   int main         Timer tmr      double t   tmr elapsed        std  cout  lt  lt  t  lt  lt  std  endl       tmr reset        t   tmr elapsed        std  cout  lt  lt  t  lt  lt  std  endl       return 0      From https   gist github com gongzhitaao 7062087

User · Answer

just a simple class that benchmark the codeblock    using namespace std  chrono   class benchmark     public    time point lt high resolution clock gt   t0  t1    unsigned int  d    benchmark unsigned int  res    d res                      t0   high resolution clock  now           benchmark     t1   high resolution clock  now                      milliseconds dur   duration cast lt milliseconds gt  t1 - t0                      d   dur count              simple usage     unsigned int t          put the code in a block     benchmark bench  amp t                     code to benchmark         HERE the t contains time in milliseconds     one way to use it can be    define BENCH TITLE CODEBLOCK      unsigned int   time      LINE     0         benchmark bench  amp   time      LINE             CODEBLOCK           printf   s took  d ms n   TITLE    time      LINE       int main void      BENCH  TITLE        for int n   0  n  lt  testcount  n           int a   n   3          return 0

User · Answer

include  lt boost progress hpp gt   using namespace boost   int main  int argc  const char   argv        progress timer timer        do stuff  preferably in a 100x loop to make it take longer     return 0      When progress timer goes out of scope it will print out the time elapsed since its creation   UPDATE  Here s a version that works without Boost  tested on macOS iOS     include  lt chrono gt   include  lt string gt   include  lt iostream gt   include  lt math h gt   include  lt unistd h gt   class NLTimerScoped   private      const std  chrono  steady clock  time point start      const std  string name   public      NLTimerScoped  const std  string  amp  name     name  name    start  std  chrono  steady clock  now                    NLTimerScoped             const auto end std  chrono  steady clock  now             const auto duration ms   std  chrono  duration cast lt std  chrono  milliseconds gt   end - start   count             std  cout  lt  lt  name  lt  lt    duration     lt  lt  duration ms  lt  lt   ms   lt  lt  std  endl             int main int argc  const char   argv                     NLTimerScoped timer   sin sum              float a   0 0f           for   int i 0  i  lt  1000000  i                   a    sin   float  i   100                       std  cout  lt  lt   sin sum      lt  lt  a  lt  lt  std  endl                         NLTimerScoped timer   sleep  4                sleep  4                 return 0

User · Answer

A complete unfailing solution to thread scheduling  which should yield exactly the same times per each test  is to compile your program to be OS independent and boot up your computer so as to run the program in an OS-free environment  Yet  this is largely impractical and would be difficult at best   A good substitute to going OS-free is just to set the affinity of the current thread to 1 core and the priority to the highest  This alternative should provide consistent-enough results   Also you should turn off optimizations which would interfere with debugging  which for g   or gcc means adding -Og to the command line  to prevent the code being tested from being optimized out  The -O0 flag should not be used because it introduces extra unneeded overhead which would be included in the timing results  thus skewing the timed speed of the code   On the contrary  both assuming that you use -Ofast  or  at the very least  -O3  on the final production build and ignoring the issue of  dead  code elimination  -Og performs very few optimizations compared to -Ofast  thus -Og can misrepresent the real speed of the code in the final product   Further  all speed tests  to some extent  perjure  in the final production product compiled with -Ofast  each snippet section function of code is not isolated  rather  each snippet of code continuously flows into the next  thus allowing the compiler to potential join  merge  and optimize together pieces of code from all over the place   At the same time  if you are benchmarking a snippet of code which makes heavy use of realloc    then the snippet of code might run slower in a production product with high enough memory fragmentation  Hence  the expression  the whole is more than the sum of its parts  applies to this situation because code in the final production build might run noticeably faster or slower than the individual snippet which you are speed testing   A partial solution that may lessen the incongruity is using -Ofast for speed testing WITH the addition of asm volatile        r  var   to the variables involved in the test for preventing dead code loop elimination   Here is an example of how to benchmark square root functions on a Windows computer      set USE ASM TO PREVENT ELIMINATION  to 0 to prevent  asm volatile        r  var       set USE ASM TO PREVENT ELIMINATION  to 1 to enforce  asm volatile        r  var     define USE ASM TO PREVENT ELIMINATION 1   include  lt iostream gt   include  lt iomanip gt   include  lt cstdio gt   include  lt chrono gt   include  lt cmath gt   include  lt windows h gt   include  lt intrin h gt   pragma intrinsic   rdtsc   include  lt cstdint gt   class Timer   public      Timer     beg  clock   now           void reset     beg    clock   now          double elapsed   const            return std  chrono  duration cast lt second  gt               clock   now   - beg   count      private      typedef std  chrono  high resolution clock clock       typedef std  chrono  duration lt double  std  ratio lt 1 gt   gt  second       std  chrono  time point lt clock  gt  beg       unsigned int guess sqrt32 register unsigned int n        register unsigned int g   0x8000      if g g  gt  n            g    0x8000            g    0x4000      if g g  gt  n            g    0x4000            g    0x2000      if g g  gt  n            g    0x2000            g    0x1000      if g g  gt  n            g    0x1000            g    0x0800      if g g  gt  n            g    0x0800            g    0x0400      if g g  gt  n            g    0x0400            g    0x0200      if g g  gt  n            g    0x0200            g    0x0100      if g g  gt  n            g    0x0100            g    0x0080      if g g  gt  n            g    0x0080            g    0x0040      if g g  gt  n            g    0x0040            g    0x0020      if g g  gt  n            g    0x0020            g    0x0010      if g g  gt  n            g    0x0010            g    0x0008      if g g  gt  n            g    0x0008            g    0x0004      if g g  gt  n            g    0x0004            g    0x0002      if g g  gt  n            g    0x0002            g    0x0001      if g g  gt  n            g    0x0001            return g     unsigned int empty function  unsigned int  input         return  input     unsigned long long empty ticks 0  double empty seconds 0  Timer my time   template lt unsigned int benchmark repetitions gt  void benchmark  char  function name  auto   function to do   auto           register unsigned int i benchmark repetitions      register unsigned long long start 0      my time reset        start   rdtsc        while   i--             auto result     function to do   i  lt  lt  7             if USE ASM TO PREVENT ELIMINATION    1             asm volatile        r                      There is no data type in C   that is smaller than a char  so it will                     not throw a segmentation fault error to reinterpret any arbitrary                     data type as a char  Although  the compiler might not like it                  result                          endif           if   function name    nullptr             empty ticks      rdtsc  -start           empty seconds   my time elapsed            std  cout lt  lt   Empty  n   lt  lt  empty ticks                lt  lt    ticks n   lt  lt  benchmark repetitions  lt  lt    repetitions n                  lt  lt  std  setprecision 15   lt  lt  empty seconds                  lt  lt    seconds n n         else           std  cout lt  lt  function name lt  lt    n   lt  lt     rdtsc  -start-empty ticks                 lt  lt    ticks n   lt  lt  benchmark repetitions  lt  lt    repetitions n                  lt  lt  std  setprecision 15   lt  lt   my time elapsed  -empty seconds                   lt  lt    seconds n n             int main  void         void  Cur Thread    GetCurrentThread        void  Cur Process   GetCurrentProcess        unsigned long long  Current Affinity      unsigned long long  System Affinity      unsigned long long furthest affinity      unsigned long long nearest affinity       if    SetThreadPriority Cur Thread THREAD PRIORITY TIME CRITICAL              SetThreadPriority  Cur Thread  THREAD PRIORITY HIGHEST              if    SetPriorityClass Cur Process REALTIME PRIORITY CLASS              SetPriorityClass  Cur Process  HIGH PRIORITY CLASS              GetProcessAffinityMask  Cur Process   amp Current Affinity   amp System Affinity        furthest affinity   0x8000000000000000ULL gt  gt   builtin clzll Current Affinity       nearest affinity    0x0000000000000001ULL lt  lt   builtin ctzll Current Affinity       SetProcessAffinityMask  Cur Process  furthest affinity        SetThreadAffinityMask  Cur Thread  furthest affinity         const int repetitions 524288       benchmark lt repetitions gt   nullptr  empty function        benchmark lt repetitions gt    Standard Square Root   standard sqrt        benchmark lt repetitions gt    Original Guess Square Root   original guess sqrt32        benchmark lt repetitions gt    New Guess Square Root   new guess sqrt32          SetThreadPriority  Cur Thread  THREAD PRIORITY IDLE        SetPriorityClass  Cur Process  IDLE PRIORITY CLASS        SetProcessAffinityMask  Cur Process  nearest affinity        SetThreadAffinityMask  Cur Thread  nearest affinity        for        getchar           return 0      Also  credit to Mike Jarvis for his Timer   Please note  this is very important  that if you are going to be running bigger code snippets  then you really must turn down the number of iterations to prevent your computer from freezing up

User · Answer

I suggest using the standard library functions for obtaining time information from the system    If you want finer resolution  perform more execution iterations   Instead of running the program once and obtaining samples  run it 1000 times or more

User · Answer

I created a simple utility for measuring performance of blocks of code  using the chrono library s high resolution clock  https   github com nfergu codetimer   Timings can be recorded against different keys  and an aggregated view of the timings for each key can be displayed   Usage is as follows    include  lt chrono gt   include  lt iostream gt   include  codetimer h   int main          auto start   std  chrono  high resolution clock  now           some code here     CodeTimer  record  mykey   start       CodeTimer  printStats        return 0

User · Answer

I created a lambda that calls you function call N times and returns you the average   double c   BENCHMARK CNT 25  fillVectorDeque variable      You can find the c  11 header here

[c++] How to Calculate Execution Time of a Code Snippet in C++

Examples related to c++

Examples related to benchmarking