Tools for native memory leak analysis

I am suspecting a native memory leak in my java code. Are there any tools which do native memory profiling? Also, does any t开发者_高级运维ool support native memory analysis of a running java process?

Thanks!!

Edit: I have already tried Memory Validator and Purify but it seems they support only 32-bit processes. Is there some tool similar to the above ones which can simply attach to a running windows process and give us native memory analysis for that particular process?

The Troubleshooting guide for Java SE 6 with Hotspot VM contains a fairly elaborate section on techniques to aid in detecting native memory leaks. These include:

• wrapping all memory allocation and deallocation calls to track the amount of memory used.
• relying on platform specific support like the debug support provided by the Microsoft Visual C++ compiler or on mtrace (and MALLOC_TRACE) to debug memory allocations on Linux.
• using memory leak analysis tools like Rational Purify.

among others. Notably, the article mentions that no ideal solution exists for all platforms.

Also, consider using the -Xcheck:jni flag that appears to be available in most JVMs. The -X flag itself indicates that the flag is non-standard, but the flag appears to be available in the IBM JDK, Oracle JRockit R28, and even the Oracle/Sun JVM. Enabling the flag switches on a mode where wrappers are added around JNI calls, thereby allowing you to track illegal arguments passed to JVM calls as noted in the JNI programmers' guide and specification. While, it's use in detecting memory leaks is subjective, it would definitely help if you suspect that the leak is being caused due to invalid parameters being issued.

AFAIK you can't do it with Java tools like JProfiler, JVisualVM etc. If you have memory leak in native code use tools for native code. You ie. can run it from C (i.e. loading jvm.dll). You can look at this articles finding memory leaks using Visual Studio or Memory Leak Detection in C++ (Linux)

Note: of course if you leak is connected to heap leak (forgot about deleteglobalref) you can find it with Java tools, but it is very rare in JNI.

I have been working on an open-source project named "MySafe" (https://github.com/serkan-ozal/mysafe) It basicly intercepts and monitors "Unsafe" calls. (In fact, it makes more than). With version 2.0, it can be useful for tracking and detecting "Unsafe" based native memory leaks.

Demo code: https://github.com/serkan-ozal/mysafe/blob/master/src/test/java/tr/com/serkanozal/mysafe/NativeMemoryLeakHuntingDemo.java

Diagram showing source of the leak: https://github.com/serkan-ozal/mysafe/blob/master/src/test/resources/native-memory-leak-hunting.png

To diagnose native memory leak, JIT code symbol mapping and Linux recent profiling tools are required: perf, perf-map-agent and bcc.

Please refer to details in related answer https://stackoverflow.com/a/52767721/737790

Many thanks to Brendan Gregg

These are tools you can use for debugging

1. libtcmalloc HPROF: For heap profiling
2. The jcmd Utility, PSS for the process: Can help in confirming a native leak.
3. Native Memory Tracking: Tracking native memory leak in JVM (only works for allocation inside JVM)
4. Core dump analysis, pmap and gdb checking for anon blocks and process memory overtime
5. -Xcheck:jni

Further details can be found out here https://www.bro-code.in/blog/java-debugging-native-memory-leak http://www.oracle.com/technetwork/java/javase/memleaks-137499.html#gbyvk

I'm a big fan of JProfiler. That's the best tool for profiling and memory leaks. It's fairly cheap relative to most tools, really easy to learn, and lots of features.

http://www.ej-technologies.com/products/jprofiler/overview.html