Profiling your application (Yourkit)
Install Yourkit
Linux
./yjp.sh
Windows
yjp-12.0.5.exe
Profile your application by Yourkit
Plugin IDE
Manual config
-agentpath:<profiler directory>\bin\win64(win32)\yjpagent.dll
-agentpath:<profiler directory>/bin/linux-x86-64(linux-x86-32)/libyjpagent.so
default port:10001
-agentpath:<profiler directory>\bin\win64(win32)\yjpagent.dll=port=1090
more options: http://www.yourkit.com/docs/java/help/startup_options.jsp
Attach in runtime
a. Attach for local connect purpose
b. Attach for remote connet purpose
(1) The attach mode is only supported for Sun Java (HotSpot) and JRockit
(2) Attach may fail due to insufficient access rights
(3) Requires kernel 2.6
...
not suggestion using attach mode
Before profiling
JVM memory structure
Shallow size/Retained size
Shallow heap is the memory consumed by one object. An object needs 32 or 64 bits (depending on the OS architecture) per reference, 4 bytes per Integer, 8 bytes per Long, etc. Depending on the heap dump format the size may be adjusted (e.g. aligned to 8, etc...) to model better the real consumption of the VM.
Retained set of X is the set of objects which would be removed by GC when X is garbage collected.
Retained heap of X is the sum of shallow sizes of all objects in the retained set of X, i.e. memory kept alive by X.
Generally speaking, shallow heap of an object is its size in the heap and retained size of the same object is the amount of heap memory that will be freed when the object is garbage collected.
GC root
A garbage collection root is an object that is accessible from outside the heap. The following reasons make an object a GC root:
System Class
Class loaded by bootstrap/system class loader. For example, everything from the rt.jar like java.util.* .
JNI Local
Local variable in native code, such as user defined JNI code or JVM internal code.
JNI Global
Global variable in native code, such as user defined JNI code or JVM internal code.
Thread Block
Object referred to from a currently active thread block.
Thread
A started, but not stopped, thread.
Busy Monitor
Everything that has called wait() or notify() or that is synchronized. For example, by calling synchronized(Object) or by entering a synchronized method. Static method means class, non-static method means object.
Java Local
Local variable. For example, input parameters or locally created objects of methods that are still in the stack of a thread.
Native Stack
In or out parameters in native code, such as user defined JNI code or JVM internal code. This is often the case as many methods have native parts and the objects handled as method parameters become GC roots. For example, parameters used for file/network I/O methods or reflection.
Finalizer
An object which is in a queue awaiting its finalizer to be run.
Unfinalized
An object which has a finalize method, but has not been finalized and is not yet on the finalizer queue.
Unreachable
An object which is unreachable from any other root, but has been marked as a root by MAT to retain objects which otherwise would not be included in the analysis.
Unknown
An object of unknown root type. Some dumps, such as IBM Portable Heap Dump files, do not have root information. For these dumps the MAT parser marks objects which are have no inbound references or are unreachable from any other root as roots of this type. This ensures that MAT retains all the objects in the dump.
CPU time/Work time
CPU time is the time on scheduler
Work time is the total time from request in to response out
Thread status
NEW: The thread is created but has not been processed yet.
RUNNABLE: The thread is occupying the CPU and processing a task. (It may be in WAITING status due to the OS's resource distribution.)
BLOCKED: The thread is waiting for a different thread to release its lock in order to get the monitor lock.
WAITING: The thread is waiting by using a wait, join or park method.
TIMED_WAITING: The thread is waiting by using a sleep, wait, join or park method. (The difference from WAITING is that the maximum waiting time is specified by the method parameter, and WAITING can be relieved by time as well as external changes.)
5 CPU profile
# Telemetry
# Sampling
# Tracking
To begin obtaining profiling results, start CPU measuring when your application requires it.
You can choose either of two available measurement modes: sampling or tracing.
Sampling
|
Tracing
|
|
Measured time accuracy
|
High for long running methods, low for short running methods
|
Low to high, depending on profiled application and
settings
|
Invocation counts
|
Not available
|
Available
|
Overhead
|
Negligible unless
J2EE high-level profiling is enabled in the
settings
|
Low to high, depending on profiled application and
settings
|
# Filter methods
6 Thread monitor
# Telemetry
# Monitor profile
7 Memory profile
# Telemetry
The "Memory" tab shows live memory usage statistics:
The bottom table on "Memory" tab provides a class instance count statistics - a quick overview of current heap state:
# Record by thread/method/classloader/GC root (allocation)
# Compare two snapshot
# Object generations
# Support of HPROF format snapshots
8 Exception profile
# Show where the exception throws
Conclusion
# Out of memory occurd
# Memory leak
# Timeout
# Deadlock
# Also anytime when you want to refine your application