If you're using C++11, you can use the header's functionality:

#include

#include

using namespace std::chrono;

int main()

{

  const auto begin = high_resolution_clock::now(); // or use steady_clock if high_resolution_clock::is_steady is false

  std::cout

@Ruben Van Boxem With chrono I get system time with great precision, although it's still System time. To make a conclusion I have to run the code multiple times to minimize the statistical error. I am looking for an accurate, system-load independant way to measure time

Dimitris - are you looking for a 'real-time clock'?  For Linux (on Intel) you have http://linux.die.net/man/4/rtc, but it isn't portable.  Each OS vendor should provide a way to get to the rtc - if they support one.

Thank you very much for the answers. I understand that there is not an "absolute" metric on how I measure execution time. The way that seems to fit my needs is the aggregation, which Kamran Idrees adresses.

I will look all other ways to settle in one of them.

Any additional information is appreciated!

There are many ways of measuring time with different overhead and accuracy. Not all methods are available on every platform or situation. Performance measurement infrastructures used in high-performance computing usually have a whole set of functions. As they are specifically concerned to minimize overhead and maximize accuracy, they choose the best candidate for the given platform.

If you want a detailed view on the time spent in specific functions of your code, you could use those tools directly.

If you just want a simple timer, the license of most of these tools would allow you to extract the relevant parts and build your own small (private) timer lib, but always check for yourself in the specific case.

I added a link to HPCToolkit, which I would recommend for C++ at this point.

http://hpctoolkit.org/software.html

Most of the time system time is preferable to CPU time -- especially in the context of parallel software. If some threads have already finished and don't use up CPU time anymore, system time gives a more natural measure how long the computation took. In order to get good results with system time you will need a computer that is mostly running only your software you want to benchmark. There might be still an operating system and a few background tasks running, but no graphical interface or any other application software. This will give you the best possible testing environment and then using system time is the right choice.

Dimitris >> "I am looking for an accurate, system-load independant way to measure time" In this case you need a hard real time system. Forget about Windows, it is not a hard real time system.

If you use Linux or any *nix flavor and your program is POSIX compatible, you can run it on VxWorks and there you get exactly what you need.

Perhaps you may want to look into profiling tools.

Profiling is the idea of compiling your code with some specific flags (like gcc -pg), then run your code as normal and get detailed statistics of how much processing time it takes for each function of your code. It is a very neat way to benchmark your entire code. The link below points to a simple and straightforward tutorial for Linux systems.

http://www.network-theory.co.uk/docs/gccintro/gccintro_80.html

Thank you all for the answers. I understood the problem and how to cope with it. I run my code in a local linux machine, Intel x64 architecture, with no graphical interface and  till now, for my needs, the most accurate method is by using rusage functionality, from which I extract system and user time. This gives me an overall image of what and how it runs.

By the way, my software makes use of openMP libraries to parallelize some blocks of code. So, system time in an "empty" (by means of loading) system makes sense in my case.

Since you are using OpenMP you should note that it also includes a function for timing. There is omp_get_wtime() which will give you the a portable way of measuring time with a high precision.  You can get the timers precision with omp_get_wtick(). Again, this is not CPU time!

Thanks Simon, I didn't know that! It is useful in my project

Consider modifying the Linux kernel's supervisor to up the priority of your one task, beyond what nice -20 provides.  Increase the kernel's parameters, or decrease, according, to change how often the supervisor looks for other processes to give a time slice too.  Or enforce the supervisor to stop looking for other processes until your process returns.  Most supervisors will insist they at least get time slices, but you can delay that for several seconds, or enough time to allow your process to 'finish'.  Machine lock up may be common, until you master changing the supervisor code or parameters.  Tune down hard drive access, even spin it down, to let your process run without any peripheral issues.  I have another two dozen tweaks.  A real time kernel might do better and easier to set up.

Use a profiler yet?  There may be one that provides a CPU time 'estimate' that is more accurate than other methods (other than the one I mention).

You did not post why you need CPU time, so the extreme method above, and the easier profiler software approach, might not be applicable.

These methods are only applicable on the platform release level you run on. I will not get into hardware tweaks, motherboard jumpers, server hardware, and such, as you have not posted the application you are measuring, and it does matter.

Hmm - I'm an OS guy so take what I say about developer tools with a small amount of salt ;-)  Since you replied to Kamran's comment, I'm going to intuit that you are running on an INTEL*64 based HW product.  

So assuming that, what you are asking is pretty standard and something that many of our customers also need to do and something we do a great deal internally ourselves for our own needs.  So much so, we at Intel, have included extensive profiling support in the HW as Kamran described one of them, and we  try to bring out support for in the developer tools products, as well as some specific FOSS projects that we might be a part.

That said, the tools can be found in Intel's Parallel Studio product and in particular vtune and inspector (which are included in the suite ) - which I think may do what you want out of the box as it were {you can get a 30 day trial of same: at https://software.intel.com/en-us/intel-parallel-studio-xe/try-buy and if you are a qualifying student using Linux, you can get it for free at: https://registrationcenter.intel.com/RegCenter/StuForm.aspx?ProductID=1822&pass=yes).

There is also lots of help over in the SW support forum if you have specific questions about the HW and the tools:  https://software.intel.com/en-us/forums

Best wishes