Android Studio Memory Profiler and ART Heap Dump Interoperability

Question

Heap Analysis Boundary
The Android Studio Memory Profiler integrates with the Android Runtime (ART) to capture HPROF dumps for leak detection. While the tool identifies objects held by the Garbage Collector through GC root paths, there is a distinct boundary between JVM/ART heap analysis and native memory tracking.
When managing complex lifecycles in Kotlin or Java, the profiler marks objects with a "Leak" badge if they persist beyond their expected destruction. However, the performance overhead during the capture process can introduce latency that affects the timing of lifecycle callbacks in real-time environments.
Given the reliance on the Android Gradle Plugin (AGP) for heap dump processing, it is unclear how the profiler distinguishes between intentional long-lived references and actual leaks in non-standard lifecycle components.

Does the Memory Profiler provide a mechanism to define custom lifecycle boundaries for leak detection beyond standard Activity/Fragment patterns?
How does the tool handle the discrepancy between ART heap dumps and native memory allocations when a leak originates in a JNI boundary?

Tasadduq Burney · Answer

Answer to Your Questions
1. Custom lifecycle boundaries

The profiler does not expose a UI to declare arbitrary lifecycle scopes beyond the default Activity/Fragment tree.
Its leak detector relies solely on GC‑root paths; any object that survives a GC with no reachable root is flagged.
To emulate a custom boundary you can manually Mark as No Leak on objects you know are intentionally long‑lived (e.g., singletons, services, or custom components).

2. ART heap vs. native memory in JNI leaks

ART heap dumps contain only Java/Kotlin objects; native allocations are not represented in the dump.
If a Java object holds a native reference, the profiler will show that Java object as a potential leak, but the actual native footprint remains invisible.
To quantify native memory you must use separate native heap tools (e.g., ndk-stack, heaptrack, or adb shell dumpsys meminfo).
The profiler will still flag the Java side; you can then correlate the Java object’s stack trace with the native stack to locate the JNI source.

Confirmed Facts (from Android Studio 4.x–2024.x)

Heap dumps are generated via Dump Java Heap and parsed by the AGP HPROF parser.
Manual “Mark as No Leak” overrides are the only supported way to exclude known long‑lived objects.
Native memory is omitted from ART dumps; visibility requires enabling native heap profiling or using external tools.

Practical Steps for Your Scenario

Launch the app in Debug mode.
Open the Memory Profiler tab.
Click “Dump Java Heap.” Wait for parsing to finish.
Navigate to the Leak Detector panel.
Inspect GC‑root paths for flagged objects. If an object is intentionally retained, click Mark as No Leak and re‑run the detector.
For suspected JNI leaks:

Enable native heap profiling: adb shell setprop debug.atrace.tags.enableflags native and adb shell am dumpheap <pid>.
Compare the native stack traces with the Java object’s stack to pinpoint the JNI source.
Use ndk-stack or heaptrack to measure the actual native allocation.

Re‑evaluate the leak list after each change.

Missing Diagnostic Detail
Do you have any custom lifecycle components (e.g., services or custom views) that you want to exclude from leak detection? Knowing this will help decide whether to rely on manual “Mark as No Leak” or to add code‑level reference clearing.

Android Studio Memory Profiler and ART Heap Dump Interoperability

Heap Analysis Boundary

1 answer

Answer to Your Questions

Confirmed Facts (from Android Studio 4.x–2024.x)

Practical Steps for Your Scenario

Missing Diagnostic Detail

Your perspective belongs here.

0 question comments