How to clock_gettime within clock_getime? - c++

Question

Lets say I want to measure the total time of a particular function. Now this function calls other functions (f1 and f2). So I want to calculate total time of f1 and f2.
What I was expecting was f total time = f1 total time + f2 total time
void f(){
struct timespec total_start, total_end;
struct timespec f1_start, f1_end;
struct timespec f2_start, f2_end;
clock_gettime(CLOCK_MONOTONIC, &total_start);
clock_gettime(CLOCK_MONOTONIC, &f1_start);
f1();
clock_gettime(CLOCK_MONOTONIC, &f1_end);
clock_gettime(CLOCK_MONOTONIC, &f2_start);
f2();
clock_gettime(CLOCK_MONOTONIC, &f2_end);
clock_gettime(CLOCK_MONOTONIC, &total_end);
f_total_time = (total_end.tv_sec - total_start.tv_sec) + (total_end.tv_nsec - total_start.tv_nsec)/1e9 ;
f1_total_time = (f1_end.tv_sec - f1_start.tv_sec) + (f1_end.tv_nsec - f1_start.tv_nsec)/1e9 ;
f2_total_time = (f2_end.tv_sec - f2_start.tv_sec) + (f2_end.tv_nsec - f2_start.tv_nsec)/1e9 ;
}
My question is, Is this a correct way to measure time of functions inside function.
Problem : The problem I am facing is total time of f1 and f2 does not add up to total time of f. ie f total time != f1 total time + f2 total time what actually happens is f total time > f1 total time + f2 total time
Am I doing something wrong?

Answer 1

Answer -
Yes. IMHO it appears to be a valid duration measurement technique
of a function within a function.
The Posix clock_gettime() reports sec/nanoseconds from a fixed
time, so each access is independent of any other.
From "man clock_gettime" :
All implementations support the system-wide real-time clock,
which is identified by CLOCK_REALTIME. Its time represents
seconds and nanoseconds since the Epoch. When its time is
changed, timers for a relative interval are unaffected, but
timers for an absolute point in time are affected.
I see nothing wrong with your approach.
Perhaps you need to know more about the relative duration of your
code vs duration of the clock read mechanisms you are using.
On my Ubuntu 15.10, on an older Dell, using g++ 5.2.1, the Posix
call
clock_gettime(CLOCK_REALTIME, ...)
uses > 1,500 ns (avg over 3 seconds) (i.e. ~1.5 us)
To achieve some measure of repeatability, the duration you are
trying to measure (f1() and f2() and f1()+f2()) must be more than
this, probably by a factor of 10.
Your system will be different (than mine), so you must test it to
know how long these clock reads take.
There is also the interesting idea of knowing how fast
CLOCK_REALTIME increments. Even though the API indicates
nanoseconds, it might not be that fast.
An alternative I use is std::time(nullptr) with a cost of ~5 ns (on my system), 3 orders of magnitude less. FYI: ::time(0) measures the same.
A loop controlled by this API return simply kicks out at the end
of a second, when the value returned has changed from previous
values. I usually accumulate 3 seconds of loops (i.e. a fixed
test time) and compute the average event duration.
Example measurement output:
751.1412070 M 'std::time(nullptr) duration' invocations in 3.999,788 sec (3999788 us)
187.7952549 M 'std::time(nullptr) duration' events per second
5.324948176 n seconds per 'std::time(nullptr) duration' event
If using this clock access, you can simply subtract 5.3 ns (on my
system) from each invocation when calculating the seconds per event for
your functions.
Note: Any Posix API is an interface to a system provided
function, not the function itself.
Being part of an API is not conclusive evidence about the
functions implementation ... which may be in any language,
even assy for peak performance.

Answer 2

To chronometer a C++ application, note initial time in a variable, and a declare a duration (seconds) :
#include "time.h"
clock_t t (clock ());
size_t duration (0);
during execution, duration is updated this way :
duration = (clock() - t)/CLOCKS_PER_SEC;