Question

I am trying to measure the complexity of an algorithm using a timer to measure the execution time, whilst changing the size of the input array.

The code I have at the moment is rather simple:

public void start() {
    start = System.nanoTime();
}

public long stop() {
    long time = System.nanoTime() - start;
    start = 0;
    return time;
}

It appears to work fine, up until the size of the array becomes very large, and what I expect to be an O(n) complexity algorithm turns out appearing to be O(n^2). I believe that this is due to the threading on the CPU, with other processes cutting in for more time during the runs with larger values for n.

Basically, I want to measure how much time my process has been running for, rather than how long it has been since I invoked the algorithm. Is there an easy way to do this in Java?

Answer 1

Measuring execution time is a really interesting, but also complicated topic. To do it right in Java, you have to know a little bit about how the JVM works. Here is a good article from developerWorks about benchmarking and measuring. Read it, it will help you a lot.

The author also provides a small framework for doing benchmarks. You can use this framework. It will give you exaclty what you needs – the CPU consuming time, instead of just two time stamps from before and after. The framework will also handle the JVM warm-up and will keep track of just-in-time-compilings.

You can also use a performance monitor like this one for Eclipse. The problem by such a performance monitor is, that it doesn’t perform a benchmark. It just tracks the time, memory and such things, that your application currently uses. But that’s not a real measurement – it’s just a snapshot at a specific time.