ArkTS Memory Snapshots and Memory Leak Debugging

This article aims to deeply explore the technical details of the Huawei HarmonyOS Next system (up to API 12 as of now), and is summarized based on actual development practices.
It mainly serves as a vehicle for technical sharing and communication. Mistakes and omissions are inevitable. Colleagues are welcome to put forward valuable opinions and questions so that we can make progress together.
This article is original content, and any form of reprint must indicate the source and the original author.

Introduction

Memory leaks are an important factor affecting the performance and stability of applications. ArkTS provides functions such as memory snapshots and garbage collection logs, which can help developers diagnose and solve memory leak problems. This article will introduce in-depth how to use the memory snapshot function of ArkTS for problem troubleshooting, and locate memory leaks by analyzing garbage collection logs. It will also provide some common memory leak problems and debugging techniques.

Memory Snapshots

ArkTS provides a memory snapshot function that can help developers capture the current state of the heap memory and analyze it. Developers can use the following method to obtain a memory snapshot:

// Get a memory snapshot
let snapshot = ArkRuntimeConfig.takeHeapSnapshot();

After obtaining the memory snapshot, it can be analyzed using a memory analysis tool (such as gcore). gcore is an open-source memory analysis tool that can be used to analyze the memory snapshots of HarmonyOS applications and provide detailed memory analysis reports.

Garbage Collection Logs and Debugging

The garbage collection mechanism of ArkTS provides rich log information that can help developers analyze GC behavior and performance. Developers can use the following method to obtain GC logs:

// Print GC logs
ArkTools.logGCInfo();

The GC logs contain information such as the trigger reason, time consumption, and memory usage of GC, which can help developers locate memory leak problems. For example, the following information may appear in the logs:

• [gc] [HPP YoungGC] 26.1164 (35) -> 7.10049 (10.5) MB, 160.626(+0)ms, Switch to background
• IsInBackground: 1; SensitiveStatus: 0; OnStartupEvent: 0; BundleName: com.huawei.hmos.filemanager
• AllSpaces used: 7270.9KB committed: 10752KB
• Heap alive rate: 0.202871 By analyzing this information, developers can understand the trigger reason, time consumption, memory usage, and heap memory survival rate of GC, which can help locate memory leak problems. ### Common Memory Leak Problems The following are some common memory leak problems:
• Global or static variables holding object references: This causes the object to not be garbage collected.
• Closures holding references to external variables: This causes the object to not be garbage collected.
• Objects being added multiple times to a collection: This causes the object to not be garbage collected.
• Objects being referenced by external APIs: This causes the object to not be garbage collected.
• Improper use of object pools: This causes the object to not be garbage collected.
• Objects being referenced in asynchronous tasks: This causes the object to not be garbage collected. ### Debugging Tools and Techniques Developers can use the following tools and techniques to debug memory leak problems:
• ArkTools.hintGC(): Manually trigger GC to help locate memory leak problems.
• Analyze GC logs: Check the trigger reason, time consumption, and memory usage of GC.
• Memory analysis tools: Use tools like gcore to analyze memory snapshots and view object graphs, memory usage, and reference relationships.
• Code review: Carefully review the code to find potential problems that may cause memory leaks.
• Memory leak detection tools: Use some memory leak detection tools (such as Valgrind) to detect memory leaks. ### An Example The following sample code shows how to call the memory snapshot function of ArkTS:

// Get a memory snapshot
let snapshot = ArkRuntimeConfig.takeHeapSnapshot();
// Analyze the memory snapshot using gcore
let gcore = new Gcore();
gcore.load(snapshot);
gcore.analyze();

In the above code, we first call the ArkRuntimeConfig.takeHeapSnapshot() method to obtain a memory snapshot, and then use the gcore tool to load and analyze the memory snapshot. The gcore tool will generate a memory analysis report, which includes information such as the object graph, memory usage, and reference relationships, which can help developers locate memory leak problems.

Summary

Memory leaks are an important factor affecting the performance and stability of applications. By using the memory snapshot and garbage collection log functions of ArkTS, we can effectively diagnose and solve memory leak problems. Understanding common memory leak problems and taking corresponding measures to avoid memory leaks is crucial to ensure the stability and performance of applications.