We Keep Coding

Tools for checking spring performance and bottlenecks with example [closed]

Closed. This question does not meet Stack Overflow guidelines. It is not currently accepting answers.
This question appears to be off-topic because it lacks sufficient information to diagnose the problem. Describe your problem in more detail or include a minimal example in the question itself.
Closed 9 years ago.
Improve this question
i am new to all this performance improvement thing. Can anyone provide names of some good tools or techniques for checking the performance of the web application and finding the bottlenecks in the application both on server side and client side. If any one can provide link examples or tutorials to such tools or techniques it will be very helpful. Thanks in advance for your help.
Using VisualVM i got following result
please do let me know how to find the code in my application which is responsible for this.

Improving the performance of a web application involves couple of things.
Improving the application code involves :
Apply caching - E.g. JCS, EHCache
Compression of HTTP requests
Avoid Embedding of Javascripts
Balance the load - Horizontal/Vertical Scaling
Cookie size reduction
Use profiling tools like JProfiler, jProbe, JRockit, VisualVM
EDITED for the changed question :
Are you getting Out of memory Error ?
To find Memory related issue, Take snapshot at regular interval and look for possible leaks. Using the Deltas mode you can easily watch newly allocated and disposed objects over a specific period of time or while an action is executed which makes it really easy to identify a memory leak. Also, the memory data can be saved as a .nps snapshot which can later be compared to other memory snapshots using the Compare function. Once the memory leak is identified, you can investigate the leak further by using the built-in HeapWalker. The HeapWalker has been enhanced to support displaying retained sizes and provides a powerful OQL scripting engine.
Furthermore, you can use other tools for heap analysis like :
HAT, The Java Heap Analysis Tool
YourKit Java Profiler
Memory Analyzer project at Eclipse, contributed to them by SAP.
HeapWalker is a good option too.

Have you tried visualVM, its free and powerful tool to track the J2EE performance application, some of its features:
Provide a CPU profiling.
Provide all info about Threads.
Provide the JVM Heap and the memory states.
Provide Info about the GC activities.
Its come with the JDK package, so you don't have to install it, for more info check this

How the java heap allocation for eden and other generation affects the Garbage collection and Performance?

I want to know how different values set for the Xmx, Xms, Xmn and Xss Affects the Garbage collection and Performance?
On basis of what parameters we can decide the optimum values for these parameters?
What are the tools available for the monitoring and analyzing the same?

If you want a detailed description http://www.oracle.com/technetwork/java/javase/gc-tuning-6-140523.html#generation_sizing is one of the better resources to follow .
As far as the tools are concerned , apart from the default java tools like Hprof ,hat ,visualvm and Jconsole . Other commercial ones also exist like Appdynamics , yourkit , jprofiler , dynatrace ,newrelic ,etc .

Usually the best thing is to performance test you application under realistic load.
Generally speaking these parameters are reasonably optimal if you leave them alone. You should only set them if you know doing so improves performance. To know it improves performance you should have a load test which demonstrates that performance is better with that setting.
(Anything else is just guess work)

So first some helpful link :
GC tuning
Diagnosing a Garbage Collection problem
Monitoring
GC FAQ
For monitoring I'm used to Netbeans Profiler.
You can also set some VM option to print GC activity with (for example) :
-verbose:gc -XX:+PrintGCDetails -XX:+PrintGCApplicationConcurrentTime -XX:+PrintGCApplicationStoppedTime
or
-agentlib:hprof=heap=all
Finally you can monitor your app using MemoryMXBean.
There is a lot of other monitoring tools, choose yours!

Is G1GC still not officially production ready?

I wonder what the official status of the "garbage first" (G1) collector in the JDK 7 release is. I would like to use G1 as a low pause gc alternative to CMS, but only if I can really trust on its robustness.
Before JDK 7 was out, G1 was advertised as the shiny new gc going to replace the CMS collector and even to be the default gc in JDK 7. However, now with Oracle JDK 7u1, G1 is not the default gc on any machine I have tried.
Even though one does not need to specify -XX:+UnlockExperimentalVMOptions anymore when using -XX:+UseG1GC in JDK 7, it's a JVM feature that's officially completely undocumented:
Java 7 (JDK 7) garbage collection and documentation on G1
The only official document I could find that mentions G1 is seriously outdated and was written long before JDK 7 was out:
http://www.oracle.com/technetwork/java/javase/tech/g1-intro-jsp-135488.html
For example, the official "Java HotSpot VM Options" documentation ( http://www.oracle.com/technetwork/java/javase/tech/vmoptions-jsp-140102.html ) documents how to enable and tune the other collectors but does not even mention the existence of G1. As if it didn't exist!
This is quite confusing and I wonder what the real status of the G1 and what its future is. Is it really stable yet? Have the remaining issues (like leaks, spurious crashes and missing instrumentation support) been resolved? And if so, why does Oracle treat the G1GC as an undocumented (embarrassing?) secret? Is G1 perhaps a failed project that's now silently discontinued? Or do I need to pay for documentation and support? Or is it just still beta? Can someone enlighten me on what's going on here?

The place to ask this question is on the hotspot-gc-dev mailing list.
If you look through the archives you'll find that there is a lot of work being done. A lot of the mail appears to be commits and review requests/comments so they're busy working on it.
I haven't found any official news announcements, but that is how Oracle works. You might be able to ask on that mailing list how they think they're going, if you're happy with an unofficial and non-binding comment from one of the devs.
EDIT: #scravy sent an email to the mailing list, this is the response received:
I don't think there is a simple answer to this question, though
probably not. G1's initial focus was to provide reasonable pauses
for extremely large heaps. Which means today it might not be the
best choice for everyone. We think the technology has 'a lot of
legs' though, meaning that with adaptation, it can address many
different kinds of garbage collection demands. So one day, it
might effectively be the default collector, but it is too soon to
know for sure.
Considering that GC behavior changes can be very disruptive to
existing deployments, we are reluctant to make shifts like this
even in major releases without considerable advanced notice. So in current releases, if you
don't specify a collector, we attempt to make some simple
automated choices, but I doubt we'd make radical changes to that
behavior in the near term.
For the bigger question regarding is G1 supported, the current
answer is no. But keep in mind that the support commitment that
Oracle makes to its paid customers for supported products is
fairly significant, and there is much more to it than just meeting
the functionality and reliability requirements.
We continue to encourage everyone to test and evaluate G1, and of
course, deliver feedback to us, as we continue significant
development on G1.
-John
EDIT: According to this link on Oracle's site it looks like G1GC is now fully supported.

We are already using G1GC, from almost a year and half. Its doing great in our mission critical transaction processing system, and It proved to be a great support w.r.t high throughput, low pause, concurrency, multi-threading and optimized heavy memory management.
We are using following JVM settings:
-server -d64 -Xms512m -Xmx3072m -XX:+HeapDumpOnOutOfMemoryError -XX:+UseG1GC
-XX:+UnlockExperimentalVMOptions -XX:+AggressiveOpts -XX:+DoEscapeAnalysis
-XX:MaxGCPauseMillis=400 -XX:GCPauseIntervalMillis=8000
-XX:+UseCompressedOops -XX:NewRatio=50

According to this: http://www.oracle.com/technetwork/java/javase/tech/g1-intro-jsp-135488.html,
G1 development is now focused primarily on resolving any remaining
reliability issues and improving performance
Also,
In terms of GC pause times, G1 is sometimes better and sometimes worse
than CMS. Work is ongoing to make G1 consistently as good as, if not
better than, CMS.
So G1 is supposedly going to replace CMS when the official JDK SE 7 is out.

AFAIK, G1 is not secret -- it's open for experimental use long enough -- at least year or two. Every JavaOne comes with some lection about how good G1 will be :)
From unofficial sources: it's one of current focuses for java engeneers, to make G1 production ready at last. They just was not ready to open it for JDK 7. Just keep waiting :)

It looks like the page linked in the question has been updated:
The Garbage-First (G1) garbage collector is fully supported in Oracle
JDK 7 update 4 and later releases.
(Note, however, that for embedded platforms like ARM, it is not yet supported at all in 7u4.)

G1 GC is production ready since Java 7 update 4 version launch.
From oracle article (under The G1 Garbage Collector), you can find real use cases for G1 GC.
Applications running today with either the CMS or the ParallelOldGC garbage collector would benefit switching to G1 if the application has one or more of the following traits.
Full GC durations are too long or too frequent.
The rate of object allocation rate or promotion varies significantly.
Undesired long garbage collection or compaction pauses (longer than 0.5 to 1 second)
Have a look at related question for more details about G1GC and key parameters to be fine tuned:
Java 7 (JDK 7) garbage collection and documentation on G1
Regarding your other queries:
Is it really stable yet? Have the remaining issues (like leaks, spurious crashes and missing instrumentation support) been resolved? And if so, why does Oracle treat the G1GC as an undocumented (embarrassing?) secret? Is G1 perhaps a failed project that's now silently discontinued? Or do I need to pay for documentation and support? Or is it just still beta? Can someone enlighten me on what's going on here?
G1GC is stable.
I have not found any leaks in this algorithm.
Oracle did not keep it undocumented. You can find more info about G1GC here and here
G1 is not a failed project and G1GC is going to be default GC algorithm in newer versions of java (java 9)
You don't need to pay for support. It's not beta.

Open Source Java Profilers [closed]

Closed. This question is opinion-based. It is not currently accepting answers.
Want to improve this question? Update the question so it can be answered with facts and citations by editing this post.
Closed 2 years ago.
Improve this question
What can you guys recommend to use with Java?
Only requirement is it should be open source, or has not too expensive academic licence .

The VisualVM which comes with jdk6 has a basic profiler inside it.
VisualVM is provided with the jdk, so if you have the jdk6 installed, you likely have it installed as well.
https://visualvm.github.io/

you've got a list here (listing them below, in-case link gets broken)
JMemProf
JMP
DrMem
JTreeProfiler
NetBeans Profiler
JAMon API
JBoss Profiler
MessAdmin
InfraRED
TomcatProbe
Java Interactive Profiler (JIP)
Profiler4j
Stopwatch
JMeasurement
DJProf
TIJmp
Allmon
Appspy
EurekaJ
japex
OKTECH Profiler
Perf4j

Ah. Netbeans Profiler, developer.com's "Product of the Year" winner, in 2009.

Java has a basic built in profiler called HProf. I find it useful to compare the results it provides with results from more fully features profilers.

The open-source tool jvmtop does include a basic console profiler.
Example output:
JvmTop 0.7.0 alpha - 15:16:34, amd64, 8 cpus, Linux 2.6.32-27, load avg 0.41
http://code.google.com/p/jvmtop
Profiling PID 24015: org.apache.catalina.startup.Bootstrap
36.16% ( 57.57s) hudson.model.AbstractBuild.calcChangeSet()
30.36% ( 48.33s) hudson.scm.SubversionChangeLogParser.parse()
7.14% ( 11.37s) org.kohsuke.stapler.jelly.JellyClassTearOff.parseScript()
6.25% ( 9.95s) net.sf.json.JSONObject.write()
3.13% ( 4.98s) ....kohsuke.stapler.jelly.CustomTagLibrary.loadJellyScri()

Eclipse TPTP
Here's an article about Java Application Profiling using TPTP and here's a tutorial Profiling J2SE 5.0 based applications using Eclipse TPTP.

If you are looking for a no-frills, easy to use open source profiler, you may want to take a look at Jip (Java Interactive Profiler). It's published under a BSD license. I found it to be quite useful for small programs. At least, the results it gives are way more easy to understand than hprofs output.

Java Mission Control, it's free to use for development and it integrates with Eclipse. It has very low overhead (<1%) since it piggybacks on the data the JVM is gathering anyway.
It's very easy to use and it can also give a lot information you typically won't find in other profiling tools, e.g. latency profiling, online memory inspection, detailed gc statistics

This is quick, dirty, and very effective: just take a few thread dumps, or pause the program several times, and look at the stack traces.

Consider cutting-edge https://github.com/jvm-profiling-tools/async-profiler
This project is a low overhead sampling profiler for Java that does not suffer from Safepoint bias problem. It features HotSpot-specific APIs to collect stack traces and to track memory allocations. The profiler works with OpenJDK, Oracle JDK and other Java runtimes based on HotSpot JVM.
It's also built-in into IntelliJ IDEA Ultimate: https://www.jetbrains.com/help/idea/cpu-profiler.html.
There is also similar https://github.com/jvm-profiling-tools/honest-profiler.
The comparison between async-profiler and honest-profiler: https://github.com/jvm-profiling-tools/async-profiler/issues/77

JVM Monitor is a Java profiler integrated with Eclipse to monitor CPU, threads and memory usage of Java applications.
If further deep analysis is needed, you may use other tools (e.g. TPTP, Memory Analyzer) as a next step.

Netbeans IDE includes a free profiler.
Also, if I remember correctly, the academic license for JProfiler is (relatively) inexpensive.

Know of any Java garbage collection log analysis tools? [closed]

Closed. This question does not meet Stack Overflow guidelines. It is not currently accepting answers.
We don’t allow questions seeking recommendations for books, tools, software libraries, and more. You can edit the question so it can be answered with facts and citations.
Closed 7 years ago.
Improve this question
I'm looking for a tool or a script that will take the console log from my web app, parse out the garbage collection information and display it in a meaningful way.
I'm starting up on a Sun Java 1.4.2 JVM with the following flags:
-verbose:gc -XX:+PrintGCTimeStamps -XX:+PrintGCDetails
The log output looks like this:
54.736: [Full GC 54.737: [Tenured: 172798K->18092K(174784K), 2.3792658 secs] 257598K->18092K(259584K), [Perm : 20476K->20476K(20480K)], 2.4715398 secs]
Making sense of a few hundred of these kinds of log entries would be much easier if I had a tool that would visually graph garbage collection trends.

gcviewer does what you want.

IBM's GC toolkit does exactly what you ask.
https://www.ibm.com/developerworks/java/jdk/tools/gcmv/
I'm not sure if it's compatible with GC logs from Sun's JVM though.

I think some people are adding Java probes which don't really parse garbage collection logs as the question states...
I've tried others (gcviewer, gchisto, IBM's) and the best tool I found for analyzing GC logs is HPjmeter
It is mainly for HP-UX JVMs, but it also usually works with Sun JVMs and does a great job.
(source: xebia.com)

I tried a online tool http://gceasy.io , it can read my sun jdk 1.8 gc log.

Even better than jconsole is visualvm, which is developed and distributed freely by Sun. It has a GC analyzing plugin called gchisto which might help you.
Edit: Sorry, I didn't see your JDK 1.4.2 requirement. In that case visualvm won't help you, alas.

The most powerful tool I've found to work with both IBM and Hotspot JVM logs and visualize them is IBM's PMAT:
https://www.ibm.com/developerworks/mydeveloperworks/groups/service/html/communityview?communityUuid=22d56091-3a7b-4497-b36e-634b51838e11
I find it both faster and gives more details than the tool in IBM Support Assistant.
It is being continually updated, lastly July'12.
However seems to have some problems parsing logs with policy CMS but hopefully that can be fixed.
PrintGCStats is pretty good too, and gives good statistics, but not for visualization over time, that needs some work.

I use YourKit java profiler, which lets you measure this sort of thing, and much more, but using it's own format rather than analysing the log. It can do more under Java 5, but should work under 1.4.

Try VisualGC from Sun. There are JDK 4 and 5 versions that give you a nice visual of what's going on in the eden, generational, and perm spaces. You need to add a JAR and get a PID and Bob's your uncle.

A few years ago, John Coomes (Hotspot GC group) had released PrintGCStats, an awk script to "summarize statistics about garbage collection, in particular gc pause time totals, averages, maximum and standard deviations.". A copy of the script is hosted on java.net : http://java.net/projects/printgcstats

jconsole can help you a lot, but I think it's Java 5 and later only. Once I heard someone of SUN speaking at our university and he said that Java 6's garbage collector is A LOT better than the old ones which needed complicated tuning nearly all the time for big applications. Java 6 GC seems to scale a lot better on SMPs.

gchisto plugin for VisualVM doesn't work https://gchisto.dev.java.net/
I have a file with all details of printgc for jdk1.6 but couldn't find a tool to read that.
Previously with jdk1.5 we used HPjmeter it worked fine, but now with jdk1.6 it doesn't
Tried following: IBM Pattern Modeling and Analysis Tool for Java Garbage Collector -- it doesn't recognizes the file. GCCollector doesn't work, it keep on reading file for analysis.

How about trying out some profiling tool like JProbe Freeware (Eclipse plug-in).