Measuring the time spent executing the code

Question

Let's say I have the following for loop that I want to time:

for(int i = 0; i < list.size() - 1; i++ ) {     
{
// call other methods, let's say call other 3-4 methods

}

So, if I want to measure how much time that for loop takes to run with an in built Java long time = System.nanoTime(); before and after the for loop, will it also measure the time spent inside the methods that I'm calling?

Or if I don't call other methods and just put all the code inside my for loop, it would take much more time than If I were just calling other methods?

Time spend into the loop depends on the time spend in the methods in it ... so what is the problem ? — AxelH, Nov 22 '16 at 07:11
Possible duplicate of [How do I write a correct micro-benchmark in Java?](http://stackoverflow.com/questions/504103/how-do-i-write-a-correct-micro-benchmark-in-java) — rkosegi, Nov 22 '16 at 07:19

score 1 · Answer 1 · edited May 23 '17 at 10:33

The timer just counts the difference between the time it starts and it ends. It has no knowledge of what happened between the start and the end. So it doesn't matter if you dump all your code inside the for loop, or call those methods directly instead of inlining them.

However this would not give you the time taken by each individual function. You may want to look at Java profilers to get results in a more systematic way.

score 0 · Answer 2 · edited May 23 '17 at 12:18

0

System.nanoTime() returns the current value of the running Java Virtual Machine's high-resolution time source, in nanoseconds.

From the Java's Documentation:

This method can only be used to measure elapsed time and is not related to any other notion of system or wall-clock time. The value returned represents nanoseconds since some fixed but arbitrary origin time (perhaps in the future, so values may be negative). The same origin is used by all invocations of this method in an instance of a Java virtual machine; other virtual machine instances are likely to use a different origin.

Calculating time by using System.nanoTime() values would calculate the full time taken to execute that loop. This would include the execution time of the methods inside the loop (if they are there).

However, if it happens that you start threads inside the loop which have their own execution time, the time elapsed from point 1 to point 2 would only be the time taken to start the threads, not their execution time.

I have found a good way to understand this thing. Just write a simple code:

long t1 = System.nanoTime();
long t2 = System.nanoTime();
System.out.println((t2 - t1) / 1000000);

Pull this in a debugger and see what happens when you don't apply any breakpoints.
Now apply a breakpoint at line #2 and wait for some time there before resuming the execution.

You could see the difference.

Reference Link

edited May 23 '17 at 12:18

Community

1
1

answered Nov 22 '16 at 07:11

Jay

1,089
12
29

Good point with the Threads ! But you can always wait for them to stop after you've run them all ;) – AxelH Nov 22 '16 at 07:12
@AxelH Just sharing what I have experienced/known ;) Would include that as well. – Jay Nov 22 '16 at 07:13
@AxelH sorry I didn't get what you said :/ – Jay Nov 22 '16 at 07:20
[This is what I meant](http://stackoverflow.com/questions/7939257/wait-until-all-threads-finish-their-work-in-java). Using a pool to manage the threads and wait for them to end. – AxelH Nov 22 '16 at 07:22
@AxelH Thanks. Do you think I can make my description more elaborate, so that future comers can find it useful? – Jay Nov 22 '16 at 07:24
Oh yeah, you have just explain (too much) what is `nanoTime` without simpy trying to said that this is the current time of the JVM in nanoSeconds. For his question, you don't really said much, add a simple example of how to calculate how long it take to iterate all Integer or something. – AxelH Nov 22 '16 at 07:29
@AxelH thanks :) For now, I would just wait for some +reps xD – Jay Nov 22 '16 at 07:33

score 0 · Answer 3 · answered Nov 22 '16 at 08:00

Here is a simple example of what I would use to do some basic and not precise test.

We first need some basic methods to start and print the time easily

public class Main {

    static long start;

    static void startTest(){
        start = System.nanoTime();
    }

    static void stopTest(){
        System.out.format("%012.6f ms\n",(System.nanoTime() - start)/1000000.0);
        start = -1;
    }
}

Single Thread

Lets run a test on an empty loop :

startTest();
for(int i = 0; i < Integer.MAX_VALUE; ++i){}
stopTest();

This will wait that the loop end before calling stopTest() and print the time it takes.

Multi-thread

With a different thread, you need to wait that they ends, this is simple and can be don't in multiple ways. Here is one :

startTest();
List<Callable<String>> list = new ArrayList();
for(int i=0;i<5;i++){
    list.add(new Callable() {
        public Object call() throws Exception {
            for(int i = 0; i < Integer.MAX_VALUE/5; ++i){}
            System.out.println("End of Thread");
            return null;
        }
    });
}
ExecutorService es = Executors.newCachedThreadPool();
try {

    es.invokeAll(list);
} catch (InterruptedException ex) {
    Logger.getLogger(Main.class.getName()).log(Level.SEVERE, null, ex);
} finally {
    stopTest();
    es.shutdown();
}

With this Executors, we can invoke all Callable at the same time an wait for them to end.

Measuring the time spent executing the code

3 Answers3

Single Thread

Multi-thread