Technique or utility to minimize Java "warm-up" time?
I am supporting a Java messaging application that requires low latency (< 300 microseconds processing each message). However, our profiling shows that the Sun Java Virtual Machine runs slowly at first, and speeds up after the first 5,000 messages or so. The first 5,000 messages have latency of 1-4 milliseconds. After about the first 5,000, subsequent messages have ~250 microseconds latency, with occasional outliers.
It's generally understood that this is typical behavior for a Java application. However, from a business standpoint it's not acceptable to tell the customer that they have to wait for the JVM to "warm-up" before they see the performance they demand. The application needs to be "warmed-up" before the first customer message is processed
The JVM is Sun 1.6.0 update 4.
Ideas for overcoming this issue:
- JVM settings, such as -XX:CompileThreshold=
- Add a component to "warm-up" the application on startup, for example by sending "fake messages" through the application.
- Statically load application and JDK classes upon application startup, so that classes aren't loaded from JARs while processing customer messages.
- Some utility or Java agent that accomplishes either or both of the above two ideas, so that I don't have to re-invent the wheel.
NOTE: Obviously for this solution I'm looking at all factors, including chip arch, disk type and configuration and OS settings. However, for this question I want to focus on what can be done to optimize the Java application and minimize "warm up" time.
Answer
"Warm-up" in Java is generally about two things:
(1): Lazy class loading: This can be work around by force it to load.
The easy way to do that is to send a fake message. You should be sure that the fake message will trigger all access to classes. For exmaple, if you send an empty message but your progrom will check if the message is empty and avoid doing certain things, then this will not work.
Another way to do it is to force class initialization by accessing that class when you program starts.
(2): The realtime optimization: At run time, Java VM will optimize some part of the code. This is the major reason why there is a warm-up time at all.
To ease this, you can sent bunch of fake (but look real) messages so that the optimization can finish before your user use it.
Another that you can help to ease this is to support inline such as using private and final as much as you can. the reason is that, the VM does not need to look up the inheritance table to see what method to actually be called.
Hope this helps.