Java performance issues

I'm in the process of benchmarking an app i've written. I ran my app through the benchmark 10 times in a loop (to get 10 results instead of only 1). Each time, the first iteration seems to take some 50 - 100 milliseconds longer than rest of the iterations.

Is this related to the JIT compiler and is there anyt开发者_如何学JAVAhing one could do to "reset" the state so that you would get the initial "lag" included with all iterations?

To benchmark a long running application you should allow an initialization (1st pass), thats because classes have to be loaded, code has to be generated, in web-apps JSP compile to servlets etc. JIT of course plays its role also. Sometimes a pass could take longer if garbage collection occurs.

It is probably caused by the JIT kicking in, however you probably want to ignore the initial lag anyway. At least most benchmarks try to, because it heavily distorts the statistics.

You can't "uncompile" code that has been compiled but you can turn compiling off completely by using the -Xint command line switch.

The first pass will probably always be slower because of the JIT. I'd even expect to see differences when more runs are made because of possible incremental compilation or better branch prediction.

For benchmarking, follow the recommondations given in the other answers (except I wouldn't turn off the JIT because you'd have your app running with JIT in a production environment).

In any case use a profiler such as JVisualVM (included in JDK).

Is this related to the JIT compiler

Probably yes, though there are other potential sources of "lag":

• Bootstrapping the JVM and creation of the initial classloader.
• Reading and loading the application's classes, and the library classes that are used.
• Initializing the classes.
• JIT compilation.
• Heap warmup effects; e.g. the overheads of having a heap that is initially too small. (This can result on the GC running more often than normal ... until the heap reaches a size that matches the application's peak working set size.)
• Virtual memory warmup effects; e.g. the OS overheads incurred when the JVM grows the process address space and physical pages are allocated.

... and is there anything one could do to "reset" the state so that you would get the initial "lag" included with all iterations?

There is nothing you can do, apart from starting the JVM over again.

However, there are things that you can do to remove some of these sources of "lag"; e.g. turning of JIT compilation, using a large initial heap size, and running on an otherwise idle machine.

Also, the link that @Joachim contributed above is worth a thorough read.

There are certain structures you might have in your code, such as singletons which are initialized only once and consume system resources. If you're using a database connection pool for example, this might be the case. Moreover it is the time needed by Java classes to be initialized. For these reasons, I think you should discard that first value and keep only the rest.