Measuring execution time of a function in C

Question

I want to find out how much time a certain function takes in my C   program to execute on Linux  Afterwards  I want to make a speed comparison   I saw several time function but ended up with this from boost  Chrono   process user cpu clock  captures user-CPU time spent by the current process   Now  I am not clear if I use the above function  will I get the only time which CPU spent on that function    Secondly  I could not find any example of using the above function  Can any one please help me how to use the above function   P S  Right now   I am using std  chrono  system clock  now   to get time in seconds but this gives me different results due to different CPU load every time

User · Answer

In Scott Meyers book I found an example of universal generic lambda expression that can be used to measure function execution time. (C++14)

auto timeFuncInvocation = 
    [](auto&& func, auto&&... params) {
        // get time before function invocation
        const auto& start = std::chrono::high_resolution_clock::now();
        // function invocation using perfect forwarding
        std::forward<decltype(func)>(func)(std::forward<decltype(params)>(params)...);
        // get time after function invocation
        const auto& stop = std::chrono::high_resolution_clock::now();
        return stop - start;
     };

The problem is that you are measure only one execution so the results can be very differ. To get a reliable result you should measure a large number of execution. According to Andrei Alexandrescu lecture at code::dive 2015 conference - Writing Fast Code I:

Measured time: tm = t + tq + tn + to

where:

tm - measured (observed) time

t - the actual time of interest

tq - time added by quantization noise

tn - time added by various sources of noise

to - overhead time (measuring, looping, calling functions)

According to what he said later in the lecture, you should take a minimum of this large number of execution as your result. I encourage you to look at the lecture in which he explains why.

Also there is a very good library from google - https://github.com/google/benchmark. This library is very simple to use and powerful. You can checkout some lectures of Chandler Carruth on youtube where he is using this library in practice. For example CppCon 2017: Chandler Carruth “Going Nowhere Faster”;

Example usage:

#include <iostream>
#include <chrono>
#include <vector>
auto timeFuncInvocation = 
    [](auto&& func, auto&&... params) {
        // get time before function invocation
        const auto& start = high_resolution_clock::now();
        // function invocation using perfect forwarding
        for(auto i = 0; i < 100000/*largeNumber*/; ++i) {
            std::forward<decltype(func)>(func)(std::forward<decltype(params)>(params)...);
        }
        // get time after function invocation
        const auto& stop = high_resolution_clock::now();
        return (stop - start)/100000/*largeNumber*/;
     };

void f(std::vector<int>& vec) {
    vec.push_back(1);
}

void f2(std::vector<int>& vec) {
    vec.emplace_back(1);
}
int main()
{
    std::vector<int> vec;
    std::vector<int> vec2;
    std::cout << timeFuncInvocation(f, vec).count() << std::endl;
    std::cout << timeFuncInvocation(f2, vec2).count() << std::endl;
    std::vector<int> vec3;
    vec3.reserve(100000);
    std::vector<int> vec4;
    vec4.reserve(100000);
    std::cout << timeFuncInvocation(f, vec3).count() << std::endl;
    std::cout << timeFuncInvocation(f2, vec4).count() << std::endl;
    return 0;
}

EDIT: Ofcourse you always need to remember that your compiler can optimize something out or not. Tools like perf can be useful in such cases.

User · Answer

Here is an excellent header only class template to measure the elapsed time of a function or any code block    ifndef EXECUTION TIMER H  define EXECUTION TIMER H  template lt class Resolution   std  chrono  milliseconds gt  class ExecutionTimer   public      using Clock   std  conditional t lt std  chrono  high resolution clock  is steady                                       std  chrono  high resolution clock                                       std  chrono  steady clock gt   private      const Clock  time point mStart   Clock  now     public      ExecutionTimer     default       ExecutionTimer             const auto end   Clock  now            std  ostringstream strStream          strStream  lt  lt   Destructor Elapsed                       lt  lt  std  chrono  duration cast lt Resolution gt   end - mStart   count                      lt  lt  std  endl          std  cout  lt  lt  strStream str    lt  lt  std  endl                 inline void stop             const auto end   Clock  now            std  ostringstream strStream          strStream  lt  lt   Stop Elapsed                       lt  lt  std  chrono  duration cast lt Resolution gt  end - mStart  count                      lt  lt  std  endl          std  cout  lt  lt  strStream str    lt  lt  std  endl               ExecutionTimer   endif    EXECUTION TIMER H   Here are some uses of it   int main              empty scope to display ExecutionTimer s destructor s message             displayed in milliseconds          ExecutionTimer lt std  chrono  milliseconds gt  timer               function or code block here           timer stop                      same as above         ExecutionTimer lt std  chrono  microseconds gt  timer              code block here             timer stop                     same as above        ExecutionTimer lt std  chrono  nanoseconds gt  timer             code block here            timer stop                      same as above        ExecutionTimer lt std  chrono  seconds gt  timer             code block here            timer stop                              return 0      Since the class is a template we can specify  real easily in how we want our time to be measured  amp  displayed  This is a very handy utility class template for doing bench marking and is very easy to use

User · Answer

include  lt iostream gt   include  lt chrono gt   void function            code here     int main         auto t1   std  chrono  high resolution clock  now        function        auto t2   std  chrono  high resolution clock  now         auto duration   std  chrono  duration cast lt std  chrono  microseconds gt   t2 - t1   count         std  cout  lt  lt  duration lt  lt  quot  n quot       return 0     This Worked for me   Note  The high resolution clock is not implemented consistently across different standard library implementations  and its use should be avoided  It is often just an alias for std  chrono  steady clock or std  chrono  system clock  but which one it is depends on the library or configuration  When it is a system clock  it is not monotonic  e g   the time can go backwards   For example  for gcc s libstdc   it is system clock  for MSVC it is steady clock  and for clang s libc   it depends on configuration  Generally one should just use std  chrono  steady clock or std  chrono  system clock directly instead of std  chrono  high resolution clock  use steady clock for duration measurements  and system clock for wall-clock time

User · Answer

Easy way for older C    or C    include  lt time h gt     includes clock t and CLOCKS PER SEC  int main          clock t start  end       start   clock              code to measure        end   clock         double duration sec   double end-start  CLOCKS PER SEC      return 0      Timing precision in seconds is 1 0 CLOCKS PER SEC

User · Answer

It is a very easy-to-use method in C  11  You have to use std  chrono  high resolution clock from  lt chrono gt  header   Use it like so    include  lt iostream gt   include  lt chrono gt   void function         long long number   0       for  long long i   0  i    2000000    i                number    5           int main         auto t1   std  chrono  high resolution clock  now        function        auto t2   std  chrono  high resolution clock  now         auto duration   std  chrono  duration cast lt std  chrono  microseconds gt   t2 - t1   count         std  cout  lt  lt  duration      return 0      This will measure the duration of the function   NOTE  You will not always get the same timing for a function  This is because the CPU of your machine can be less or more used by other processes running on your computer  just as your mind can be more or less concentrated when you solve a math exercise  In the human mind  we can remember the solution of a math problem  but for a computer the same process will always be something new  thus  as I said  you will not always get the same result

User · Answer

simple program to find a function execution time taken    include  lt iostream gt   include  lt ctime gt     time t  include  lt cstdio gt   void function          for long int i 0 i lt 1000000000 i                      do nothing           int main      time t begin end     time t is a datatype to store time values   time   amp begin      note time before execution function    time   amp end      note time after execution  double difference   difftime  end begin   printf   time taken for function     2lf seconds  n   difference     return 0

User · Answer

I recommend using steady clock which is guarunteed to be monotonic  unlike high resolution clock    include  lt iostream gt   include  lt chrono gt   using namespace std   unsigned int stopwatch         static auto start time   chrono  steady clock  now         auto end time   chrono  steady clock  now        auto delta      chrono  duration cast lt chrono  microseconds gt  end time - start time        start time   end time       return delta count       int main       stopwatch      Start stopwatch   std  cout  lt  lt   Hello World  n     cout  lt  lt  stopwatch    lt  lt  endl    Time to execute last line   for  int i 0  i lt 1000000  i          string s    ASDFAD     cout  lt  lt  stopwatch    lt  lt  endl    Time to execute for loop     Output   Hello World  62 163514

User · Answer

Here s a function that will measure the execution time of any function passed as argument    include  lt chrono gt   include  lt utility gt   typedef std  chrono  high resolution clock  time point TimeVar    define duration a  std  chrono  duration cast lt std  chrono  nanoseconds gt  a  count    define timeNow   std  chrono  high resolution clock  now    template lt typename F  typename    Args gt  double funcTime F func  Args amp  amp     args       TimeVar t1 timeNow        func std  forward lt Args gt  args           return duration timeNow  -t1       Example usage    include  lt iostream gt   include  lt algorithm gt   typedef std  string String     first test function doing something int countCharInString String s  char delim       int count 0      String  size type pos   s find first of delim       while   pos   s find first of delim  pos      String  npos           count   pos              return count       second test function doing the same thing in different way int countWithAlgorithm String s  char delim       return std  count s begin   s end   delim       int main        std  cout lt  lt  norm    lt  lt funcTime countCharInString  precision 10       lt  lt   n       std  cout lt  lt  algo    lt  lt funcTime countWithAlgorithm  precision 10            return 0      Output   norm  15555 algo  2976

User · Answer

If you want to safe time and lines of code you can make measuring the function execution time a one line macro   a  Implement a time measuring class as already suggested above   here is my implementation for android    class MeasureExecutionTime  private      const std  chrono  steady clock  time point begin      const std  string caller  public      MeasureExecutionTime const std  string amp  caller  caller caller  begin std  chrono  steady clock  now           MeasureExecutionTime            const auto duration std  chrono  steady clock  now  -begin          LOGD  ExecutionTime   lt  lt  For   lt  lt caller lt  lt   is   lt  lt std  chrono  duration cast lt std  chrono  milliseconds gt  duration  count   lt  lt  ms              b  Add a convenient macro that uses the current function name as TAG  using a macro here is important  else   FUNCTION   will evaluate to MeasureExecutionTime instead of the function you wanto to measure   ifndef MEASURE FUNCTION EXECUTION TIME  define MEASURE FUNCTION EXECUTION TIME const MeasureExecutionTime measureExecutionTime   FUNCTION      endif   c  Write your macro at the begin of the function you want to measure  Example    void DecodeMJPEGtoANativeWindowBuffer uvc frame t  frame mjpeg const ANativeWindow Buffer amp  nativeWindowBuffer           MEASURE FUNCTION EXECUTION TIME            Do some time-critical stuff      Which will result int the following output   ExecutionTime  For DecodeMJPEGtoANativeWindowBuffer is 54ms   Note that this  as all other suggested solutions  will measure the time between when your function was called and when it returned  not neccesarily the time your CPU was executing the function  However  if you don t give the scheduler any change to suspend your running code by calling sleep   or similar there is no difference between

User · Answer

Since none of the provided answers are very accurate or give reproducable results I decided to add a link to my code that has sub-nanosecond precision and scientific statistics   Note that this will only work to measure code that takes a  very  short time to run  aka  a few clock cycles to a few thousand   if they run so long that they are likely to be interrupted by some -heh- interrupt  then it is clearly not possible to give a reproducable and accurate result  the consequence of which is that the measurement never finishes  namely  it continues to measure until it is statistically 99 9  sure it has the right answer which never happens on a machine that has other processes running when the code takes too long   https   github com CarloWood cwds blob master benchmark h L40

User · Answer

It is a very easy to use method in C  11     We can use std  chrono  high resolution clock from  header   We can write a method to print the method execution time in a much readable form       For example  to find the all the prime numbers between 1 and 100 million  it takes approximately 1 minute and 40 seconds   So the execution time get printed as   Execution Time  1 Minutes  40 Seconds  715 MicroSeconds  715000 NanoSeconds   The code is here    include  lt iostream gt   include  lt chrono gt   using namespace std  using namespace std  chrono   typedef high resolution clock Clock  typedef Clock  time point ClockTime   void findPrime long n  string file   void printExecutionTime ClockTime start time  ClockTime end time    int main         long n   long 1E 8       N   100 million      ClockTime start time   Clock  now            Write all the prime numbers from 1 to N to the file  prime txt      findPrime n   C   prime txt          ClockTime end time   Clock  now         printExecutionTime start time  end time      void printExecutionTime ClockTime start time  ClockTime end time        auto execution time ns   duration cast lt nanoseconds gt  end time - start time  count        auto execution time ms   duration cast lt microseconds gt  end time - start time  count        auto execution time sec   duration cast lt seconds gt  end time - start time  count        auto execution time min   duration cast lt minutes gt  end time - start time  count        auto execution time hour   duration cast lt hours gt  end time - start time  count         cout  lt  lt    nExecution Time         if execution time hour  gt  0      cout  lt  lt      lt  lt  execution time hour  lt  lt    Hours         if execution time min  gt  0      cout  lt  lt      lt  lt  execution time min   60  lt  lt    Minutes         if execution time sec  gt  0      cout  lt  lt      lt  lt  execution time sec   60  lt  lt    Seconds         if execution time ms  gt  0      cout  lt  lt      lt  lt  execution time ms   long 1E 3   lt  lt    MicroSeconds         if execution time ns  gt  0      cout  lt  lt      lt  lt  execution time ns   long 1E 6   lt  lt    NanoSeconds

User · Answer

You can have a simple class which can be used for this kind of measurements   class duration printer   public      duration printer       start std  chrono  high resolution clock  now            duration printer             using namespace std  chrono          high resolution clock  time point end   high resolution clock  now            duration lt double gt  dur   duration cast lt duration lt double gt  gt  end -   start           std  cout  lt  lt  dur count    lt  lt    seconds   lt  lt  std  endl        private      std  chrono  high resolution clock  time point   start       The only thing is needed to do is to create an object in your function at the beginning of that function  void veryLongExecutingFunction         duration calculator dc      for int i   0  i  lt  100000    i  std  cout  lt  lt   Hello world   lt  lt  std  endl     int main         veryLongExecutingFunction        return 0      and that s it  The class can be modified to fit your requirements

[c++] Measuring execution time of a function in C++

Examples related to c++

Examples related to optimization

Examples related to profiling