WO2022218057A1 - Memory leak attribution method and apparatus, and electronic device and storage medium - Google Patents

Abstract

Disclosed in the embodiments of the present disclosure are a memory leak attribution method and apparatus, and an electronic device and a storage medium. The method comprises: acquiring a first file and a second file of a target process in an application, wherein the first file comprises information related to the target process during a crash, and the second file comprises information related to the target process when the application is restarted; during a process of performing a first traversal on each memory segment in the first file and the second file, respectively marking memory segments, which match a stack space, in the first file and the second file; during a process of performing a second traversal on each memory segment in the first file and the second file, marking unmarked memory segments according to the names of the unmarked memory segments in the first file and the second file; and determining a memory leak attribution type according to two marking results. A memory leak attribution type obtained thereby has guiding significance, and the workload of a service developer performing memory leak attribution can be greatly reduced.

Description

Memory leak attribution method, apparatus, electronic device and storage medium

CROSS-REFERENCE TO RELATED APPLICATIONS

This application claims the priority of the Chinese patent application filed on April 14, 2021, the application number is 202110401515.2, and the invention name is "memory leak attribution method, device, electronic device and storage medium", the entire content of the application Incorporated herein by reference.

technical field

The present disclosure relates to the field of information technology, and in particular, to a memory leak attribution method, apparatus, electronic device, and storage medium.

Background technique

With the development of information technology, various types of application programs (Application, APP) can be installed on the terminal to provide users with various types of services.

In general, an APP can be executed by one or more processes, and the virtual address space of the process consists of one or more virtual memories addressable by the process. The size of the virtual address space is usually limited. In the process of continuously occupying the virtual address space, virtual memory leaks may occur, resulting in the crash of the APP.

However, in view of the problem of virtual memory leakage, it is difficult to effectively locate the cause of virtual memory leakage in the prior art.

SUMMARY OF THE INVENTION

In order to solve the above technical problem or at least partially solve the above technical problem, the embodiments of the present disclosure provide a method, apparatus, electronic device, and storage medium for attributing a memory leak.

An embodiment of the present disclosure provides a method for attributing a memory leak, the method comprising:

Obtain the first file and the second file of the target process in the application, the first file includes the relevant information of the target process when it crashes, and the second file includes the target process when the application restarts. Related Information;

During the first traversal of each memory segment in the first file and the second file, mark the memory segments in the first file and the second file that match the stack space respectively ;

During the second traversal of each memory segment in the first file and the second file, all memory segments in the first file and the second file are named according to the names of the unmarked memory segments. Mark the unmarked memory segment;

The attribution type of the memory leak is determined according to the marking result corresponding to each memory segment in the first file and the marking result corresponding to each memory segment in the second file.

The embodiment of the present disclosure also provides a memory leak attribution device, including:

The acquisition module is used to acquire the first file and the second file of the target process in the application program, the first file includes the relevant information of the target process when it crashes, and the second file includes when the application program restarts relevant information of the target process;

a first traversal module, configured to perform a first traversal on each memory segment in the first file and the second file;

A second traversal module, configured to perform a second traversal on each memory segment in the first file and the second file;

A marking module, used for the first traversal module to perform the first traversal of each memory segment in the first file and the second file, respectively, to the first file and the second file. Mark the memory segment in the file that matches the stack space; in the process of the second traversal module performing the second traversal on each memory segment in the first file and the second file, according to the first the name of the unmarked memory segment in the file and the second file marks the unmarked memory segment;

The determining module is configured to determine the attribution type of the memory leak according to the marking result corresponding to each memory segment in the first file and the marking result corresponding to each memory segment in the second file.

Embodiments of the present disclosure also provide an electronic device, the electronic device comprising:

one or more processors;

a storage device for storing one or more programs;

When the one or more programs are executed by the one or more processors, the one or more processors implement the memory leak attribution method as described above.

Embodiments of the present disclosure also provide a computer-readable storage medium on which a computer program is stored, and when the program is executed by a processor, implements the above-mentioned method for attributing memory leaks.

Embodiments of the present disclosure also provide a computer program product, the computer program product includes a computer program or instructions, and when the computer program or instructions are executed by a processor, implements the method for attributing a memory leak as described above.

Compared with the prior art, the technical solutions provided by the embodiments of the present disclosure have at least the following advantages:

The essence of the technical solution provided by the embodiments of the present disclosure is to classify the memory segment through two traversals, and to attribute the memory leak based on the classification result. Finally, the attribution type of the memory leak can be given to the developer, and the service developer can make the attribution based on the attribution type. Type, positioning problem. The attribution type of the resulting memory leak is a directional range, which has guiding significance and can fully reduce the workload of business developers.

Description of drawings

The above and other features, advantages and aspects of various embodiments of the present disclosure will become more apparent when taken in conjunction with the accompanying drawings and with reference to the following detailed description. Throughout the drawings, the same or similar reference numbers refer to the same or similar elements. It should be understood that the drawings are schematic and that the originals and elements are not necessarily drawn to scale.

FIG. 1 is a flowchart of a method for attributing a memory leak according to an embodiment of the present disclosure;

FIG. 2 is a flowchart of a method for implementing S140 in FIG. 1 according to an embodiment of the present disclosure;

FIG. 3 is a flowchart of a method for implementing S120 in FIG. 1 according to an embodiment of the present disclosure;

FIG. 4 is a schematic structural diagram of a memory leak attribution device according to an embodiment of the disclosure;

FIG. 5 is a schematic structural diagram of an electronic device according to an embodiment of the disclosure.

Detailed ways

In order to more clearly understand the above objects, features and advantages of the present disclosure, the solutions of the present disclosure will be further described below. It should be noted that the embodiments of the present disclosure and the features in the embodiments may be combined with each other under the condition of no conflict.

Many specific details are set forth in the following description to facilitate a full understanding of the present disclosure, but the present disclosure can also be implemented in other ways different from those described herein; obviously, the embodiments in the specification are only a part of the embodiments of the present disclosure, and Not all examples.

FIG. 1 is a flowchart of a method for attributing memory leaks according to an embodiment of the present disclosure. This embodiment can be applied to a situation where memory leak attribution is performed in a terminal. The method can be executed by a memory leak attribution device. The device can be implemented in software and/or hardware, and the device can be configured in an electronic device, such as a terminal, specifically including but not limited to a smart phone, a PDA, a tablet, a wearable device with a display screen, a desktop computer, a notebook Computers, all-in-one computers, smart home devices, etc. Alternatively, this embodiment may be applicable to the case of performing memory leak attribution in the server, and the method may be executed by a memory leak attribution device, the device may be implemented in software and/or hardware, and the device may be configured in electronic devices, such as servers. Alternatively, this embodiment may be applicable to the case where the server and the terminal cooperate to perform memory leak attribution, the method may be executed by a memory leak attribution device, the device may be implemented in software and/or hardware, and the device may be partially It is configured in the terminal and partly in the server. Exemplarily, in this method, S110 is performed by the terminal, and S120-S140 are performed by the server.

As shown in Figure 1, the method may specifically include:

S110. Acquire a first file and a second file of the target process in the application, where the first file includes relevant information of the target process when it crashes, and the second file includes relevant information of the target process when the application restarts.

The target process refers to the crashed process. It should be noted that, in practice, the crash of the target process may or may not cause the crash of the APP.

Optionally, both the first file and the second file are maps files.

The maps file is a file under the /proc/[pid]/maps path. The process uses the mmap function to establish the mapping between the physical disk address of the file and the virtual memory. The information related to each mapping will be saved in the maps file as a piece of data. The data includes (from left to right): the start address of the virtual memory area, the end address of the virtual memory area, the access rights of the virtual memory area, the offset, the device information, the inode, and the memory segment name.

Optionally, each piece of data formed based on the mmap function is stored as a memory segment in the maps file. In the maps file, the information in the same memory segment is recorded in the same line, and the information in different memory segments is recorded in different lines.

There are various implementation methods of this step. Exemplarily, if the execution body of this step is a terminal, the specific implementation method of this step includes: the terminal records the first file of the target process when the target process crashes; the terminal restarts the application program When getting the second file of the target process.

If the execution body of this step is a server, the specific implementation method of this step includes: the server receives the first file and the second file of the target process in the application program from the terminal, the application program is installed in the terminal, and the first file is when the target process crashes. The file is recorded by the terminal when the application is restarted, and the second file is the file recorded by the terminal when the application is restarted.

S120. During the first traversal of each memory segment in the first file and the second file, mark the memory segments in the first file and the second file that match the stack space, respectively.

In practice, the crashed process may include one or more threads, each thread corresponds to a stack space, and the stack space of a thread is the thread stack. A thread's stack space may correspond to one or more memory segments. And if the stack space of a thread corresponds to multiple memory segments, the multiple memory segments are contiguous.

In this step, "matching" mainly includes two cases. Case 1, the address range of the memory segment is the same as the address range of the stack space; case 2, the address range of the memory segment falls within the address range of the stack space.

The essence of this step is to determine whether each memory segment has a corresponding relationship with the stack space of the thread during the first traversal of each memory segment in the first file and the second file, and based on the corresponding relationship The file and the memory segment in the second file are marked. Illustratively, memory segments corresponding to the stack space of the same thread may be given the same label. The memory segments corresponding to the stack space of different threads are given different marks. Alternatively, the memory segments corresponding to the stack space of all threads of the target process can be given the same label.

S130. During the second traversal of each memory segment in the first file and the second file, perform a traversal on the unmarked memory segment according to the name of the unmarked memory segment in the first file and the second file. mark.

In practice, there may be situations where some memory segments do not match the stack space of all threads of the target process. The essence of this step is to mark the unmarked memory segments after the first traversal process is completed, so as to detect and fill in the gaps, so as to realize the purpose of marking all the memory segments in the first file and the second file. . The method of marking is to mark according to the name of the memory segment. The name of the memory segment is recorded in the memory segment data.

Optionally, the name of the memory segment can be pre-built including the mapping relationship between the content and the mark. Exemplarily, the mapping relationship is shown in Table 1. When marking, the name of the memory segment is identified, and each memory segment is marked according to the name of the memory segment including the content, and the name of the pre-built memory segment including the mapping relationship between the content and the mark. Specifically, the memory segment name may be marked according to one or more of prefix matching, inclusion relationship, and suffix matching.

Table 1

The name of the memory segment includes the contents

mark

-/data	DATA
-/data/app/*.apk	APK
-/system, /vendor, /apex	SYSTEM
-libc_malloc, bionic_alloc, linker_alloc, heap	NATIVE HEAP
-dalvik-, jit, cfi shadow	JAVA RUNTIME
-TLS, xxx stack	SYSTEM
-/dev	DEVICES
-/dev/ashmem	ASHMEM
-/dev/ashmem/shared_memory	SHARED_MEMORY
-dmabuf	DMABUF
-[anon:xxx	ANON

Exemplarily, based on Table 1, if a memory segment name is prefixed with /data/, it is marked as DATA. (where data represents the memory map related to application data). If a memory segment name is prefixed with /system or /apex or /vendor, it is marked as SYSTEM (where system represents the memory mapping related to system data). If the suffix of a memory segment name is .apk—> marked as APK (where apk represents the mapping of the application .apk file).

Further, if the name of any unmarked memory segment in the first file or the second file includes the first preset name and is in a mapping relationship with the previous memory segment of any unmarked memory segment, the third file can be set. If the name includes the second preset name, the marking result of any unmarked memory segment is set to the same marking result as the previous memory segment. The purpose of this setting is to filter out two adjacent memory segments with an associated relationship, and assign the same mark to the filtered memory segment, so that the setting can ensure the accuracy of subsequent memory leak attribution.

Exemplarily, the first preset name is .bss. The second preset name is any one of .so.apk.dex.vdex.odex.oat and .art. In the specific implementation, if it is detected that the memory segment C (here specifically refers to the memory segment that is not marked in the first traversal process) name includes . Refers to the unmarked memory segment in the first traversal process) in the name of the file with the mapping relationship (that is, the third file), whether it includes any of .so.apk.dex.vdex.odex.oat and .art One, if so, assigns memory segment C and memory segment D the same label.

S140. Determine the attribution type of the memory leak according to the marking result corresponding to each memory segment in the first file and the marking result corresponding to each memory segment in the second file.

Determining the attribution type of a memory leak is the type that caused the memory leak.

The attribution type of the memory leak may be one or more of the flagged result formed by the process of the first traversal and/or the flagged result formed by the process of the second traversal.

Since the essence of S120 and S130 is to mark the memory segment according to the characteristic attribute of the memory segment, the purpose of the marking is to classify the memory segment.

The essence of this step is, first, for the first file and the second file, classify all memory segments based on the marking results (including the marking results formed by the first traversal process and the marking results formed by the second traversing process) respectively. . The marking result of each memory segment in the same type is the same, and the marking result of each memory segment in different types is different. Then, compare all memory segments of the same type one by one, the attribute characteristics recorded in the first file and the attribute characteristics recorded in the second file, to determine which type or types are the attribution types of the memory leak. Optionally, the attribute features of each type in the first file classification result include but are not limited to the size of the corresponding total virtual memory.

Optionally, in practice, when the attribution type of the memory leak needs to be output, the attribution type of the memory leak can be converted into synonymous or synonymous text description information, so that the business developers can understand. Exemplarily, Table 2 presents the attribution types of several memory leaks and the corresponding relationship of their corresponding text description information.

Table 2

Attribution type	Text description information
JAVA_RUNTIME	JAVA runtime
NATIVE_HEAP	Native heap
THREAD_STACK	thread stack
DATA	File mapping for the /data folder
APK	Mapping of .apk files
SYSTEM	/system, /vendor, /apex system file mapping
DEVICES	Device file mapping
GPU	GPU-dependent mapping
ASHMEM	Device file mapping
SHARED_MEMORY	Shared anonymous memory
DMABUF	dma related
ANON	Anonymous mapping, which is a named anonymous mapping
NAMELESS	Anonymous mapping, belonging to unnamed anonymous mapping
OTHER	other mappings

At present, due to the lack of an effective automatic memory leak attribution method, business developers need to locate the problem according to logs and various crash files when solving the memory leak problem, resulting in a huge workload of memory leak attribution. The essence of the above technical solution is to classify the memory segment through two traversals, and to attribute the memory leak based on the classification result. Finally, the attribution type of the memory leak can be given to the developer, and the business developer can locate the problem according to the attribution type. The attribution type of the resulting memory leak is a directional range, which has guiding significance and can fully reduce the workload of business developers.

Optionally, on the basis of the above technical solution, the first file and the second file of the target process in the application program and the attribution type of the memory leak may also be output at the same time. This can further ensure that the information obtained by developers is more comprehensive, reduce the workload of business developers, and improve the efficiency and accuracy of memory leak problem location.

In the above technical solution, there are various methods for implementing S140. Exemplarily, the method for implementing S140 can be set based on the attribute features recorded in the first file and the second file of each type in the classification result.

Typically, if the set attribute feature is the virtual memory size, FIG. 2 is a flowchart of a method for implementing S140 in FIG. 1 according to an embodiment of the present disclosure. Referring to Figure 2, the method includes:

S141. Determine the total size of the virtual memory corresponding to the memory segments with the same marking result in the first file and the second file, respectively.

Usually, a memory segment corresponds to a virtual memory area.

The implementation method of this step includes: classifying memory segments with the same marking result in the first file into the same type, classifying memory segments with different marking results in the first file into different types, and separately calculating one or more memory segments included in each type. The sum of the sizes of the virtual memory regions corresponding to the memory segments respectively. Classify the memory segments with the same marking result in the second file into the same type, classify the memory segments with different marking results in the first file into different types, and calculate the virtual memory corresponding to one or more memory segments included in each type. The sum of the sizes of the regions.

S142: Determine the attribution type of the memory leak according to the total size of the virtual memory corresponding to the same marking result in the first file and the total size of the virtual memory corresponding to the same marking result in the second file.

Optionally, when performing this step, the target marking result can be determined according to the total size of the virtual memory corresponding to the same marking result in the first file and the total size of the virtual memory corresponding to the same marking result in the second file. The leaked attribution type is target tagging results.

The target marking result is one or more of the marking result formed by the first traversing process and/or the marking result formed by the second traversing process.

There are various methods for determining the target marking result. Exemplarily, the total size of the virtual memory corresponding to the target marking result in the first file and the total size of the virtual memory corresponding to the target marking result in the second file may be set. difference is greater than the threshold.

Or, the difference between the total size of the virtual memory corresponding to the target marking result in the first file and the total size of the virtual memory corresponding to the target marking result in the second file is the largest.

It should be noted that, in practice, there may be a situation in which type B exists in the first file, but there is no type B in the second file. In this case, the total virtual memory size of type B in the second file is regarded as 0. Subtract 0 from the total virtual memory size of type B in the first file to obtain the difference between the two, and determine the target marking result based on the difference.

In practice, memory leak means that the heap memory that has been dynamically allocated in the program is not released or cannot be released for some reason. The most direct consequence is the total size of the virtual memory corresponding to the same type in the first file and The difference in the total size of the virtual memory corresponding to the second file is relatively large, and the above technical solution is based on the total size of the virtual memory corresponding to the same marking result in the first file and the virtual memory corresponding to the same marking result in the second file. The total size of the memory leak determines the type of attribution of memory leaks, which can achieve fast, direct, simple, accurate, and effective attribution of memory leaks.

In the above technical solutions, there are various methods for implementing S120 in FIG. 1 , and FIG. 3 is a flowchart of a method for implementing S120 in FIG. 1 provided by an embodiment of the present disclosure. Referring to Figure 3, the method includes:

S121. Obtain a target file, where the target file includes relevant information of one or more threads in the target process, and the relevant information of each thread includes address information of the stack space corresponding to the thread.

Illustratively, the target file is a file that is independent of both the first file and the second file. Typically, the target file may be a pthread.txt file or a thread.txt file. The storage path of the pthread.txt file is /proc/[pid]/pagemap. There are two storage paths for the thread.txt file, /proc/[pid]/stat and /proc/[pid]/task/[tid]/stat. Among them, the thread.txt file under the /proc/[pid]/stat path stores the relevant information of the main thread in the process, and the thread.txt file under the /proc/[pid]/task/[tid]/stat path stores the relevant information Information about all threads in the process.

There are various methods for implementing this step. Exemplarily, multiple fourth files are obtained, and each fourth file in the multiple fourth files includes relevant information of one or more threads in the target process; The target file is obtained from the file, where the target file is the fourth file with the highest priority that is not used for matching among the plurality of fourth files.

Exemplarily, both the pthread.txt file and the thread.txt file are used as the fourth file, because usually, the address information about the stack space in the pthread.txt file is more detailed than the address information about the stack space in the thread.txt file. , set the matching priority of the pthread.txt file to be higher than the thread.txt file. When this step is performed, the pthread.txt file and the thread.txt file are obtained at the same time. If the pthread.txt file and the thread.txt file are obtained at the same time, the pthread.txt file is preferentially used as the target file.

Optionally, if this step is performed by the server, acquiring multiple fourth files includes: the server receives multiple fourth files from the terminal, and the multiple fourth files are files recorded by the terminal when the target process crashes.

S122. During the first traversal of each memory segment in the first file and the second file, determine whether the address information of each memory segment matches the address information of any stack space in the target file.

Assume that the pthread.txt file is used as the target file. Illustratively, the pthread.txt file includes a record:

[tid:16963][routine:0xb3b3fb29][arg:0xa272d900][stack_base:0xa107b000][stack_size:0x104920][sigstack:0xa4a99000][no_present:0x0]

This record is a stack space information. In practice, the pthread.txt file can contain one or more records. In the above record, stack_base is the starting address of the stack space, and stack_size is the size of the stack space.

When performing this step, compare the address ranges of all memory segments in the first file and the second file with each record in the pthread.txt file. If the address range of the memory segment is the same as the address range of the stack space or the memory If the address range of the segment falls within the address range of the stack space, it matches; otherwise, it does not match.

Assume thread.txt file is used as object file. Illustratively, the thread.txt file includes a record:

12845(mple.crash.test)S 654 654 0 0-1 1077952832 14110 149798 1 1 44 10 38 38 0 -20 50 0 195456544 6116872192 28379 18446744073709551615 371830566912 371830591584 548710979296 548710959856 0 0 4672 1 1073779964 1 0 0 17 6 0 0 0 0 0 371830595584 371830596992 372594491392 548710981061 548710981160 548710981160 548710985694 0

This record is a stack space information. In practice, the thread.txt file can contain one or more records. In the above record, 548710959856 is the address of the top of the stack.

When performing this step, since each record only records the address of the top of the stack, it is necessary to combine multiple records to determine the starting address of each stack space and the size of each stack space (or the end address of each stack space), that is, to determine The address range of each stack space.

Compare the address range of all memory segments in the first file and the second file with each record in the thread.txt file, if the address range of the memory segment is the same as the address range of the stack space or the address range of the memory segment falls within The address range of the stack space is matched; otherwise, it is not matched.

S123: When the address information of any memory segment in the first file or the second file matches the address information of any stack space in the target file, mark any memory segment.

Exemplarily, if the address information of the memory segment M in the first file matches the address information of a certain stack space in the target file, the memory segment M is marked as THREAD_STACK. If the address information of the memory segment N in the first file does not match the address information of a certain stack space in the target file, the memory segment N is not marked, and is left to be marked when S130 is executed.

The above technical solution provides a method for specifically implementing memory segment marking in the first traversal process, which cleverly utilizes the target file to realize the first round of marking, which can simplify the difficulty of marking and improve the speed of the first round of marking.

FIG. 4 is a schematic structural diagram of a memory leak attribution apparatus according to an embodiment of the disclosure. The apparatus for attributing memory leaks provided by the embodiments of the present disclosure may be configured in the client or in the server, and the apparatus for attributing memory leaks specifically includes:

The obtaining module 410 is configured to obtain the first file and the second file of the target process in the application program, the first file includes the relevant information of the target process when it crashes, and the second file includes the restart of the application program information about the target process at that time;

a first traversal module 420, configured to perform a first traversal on each memory segment in the first file and the second file;

A second traversal module 430, configured to perform a second traversal on each memory segment in the first file and the second file;

The marking module 440 is used for the first traversal module to perform the first traversal of each memory segment in the first file and the second file, respectively, on the first file and the second file. The memory segment matching the stack space in the second file is marked; in the process of the second traversal module performing the second traversal of each memory segment in the first file and the second file, according to the second traversal module Mark the unmarked memory segment with the name of the unmarked memory segment in a file and the second file;

The determining module 450 is configured to determine the attribution type of the memory leak according to the marking result corresponding to each memory segment in the first file and the marking result corresponding to each memory segment in the second file.

Further, the determining module 450 is configured to respectively determine the total size of the virtual memory corresponding to the memory segment with the same marking result in the first file and the second file;

The attribution type of the memory leak is determined according to the total size of the virtual memory corresponding to the same marking result in the first file and the total size of the virtual memory corresponding to the same marking result in the second file.

Further, the determining module 450 is configured to determine the target according to the total size of the virtual memory corresponding to the same marking result in the first file and the total size of the virtual memory corresponding to the same marking result in the second file. Mark the result, the attribution type of the memory leak is the target marked result.

Further, the difference between the total size of the virtual memory corresponding to the target marking result in the first file and the total size of the virtual memory corresponding to the target marking result in the second file is greater than a threshold.

Further, the difference between the total size of the virtual memory corresponding to the target marking result in the first file and the total size of the virtual memory corresponding to the target marking result in the second file is the largest.

Further, the marking module 440 is used for:

Obtain a target file, where the target file includes relevant information of one or more threads in the target process, and the relevant information of each thread includes address information of the stack space corresponding to the thread;

During the first traversal of each memory segment in the first file and the second file, determine whether the address information of each memory segment is the same as the address of any stack space in the target file information matching;

When the address information of any memory segment in the first file or the second file matches the address information of any stack space in the target file, mark the any memory segment.

Further, the marking module 440 is used for:

Obtaining a plurality of fourth files, each of the fourth files in the plurality of fourth files includes relevant information of one or more threads in the target process;

A target file is obtained from the plurality of fourth files, the target file being the fourth file with the highest priority that is not used for the matching among the plurality of fourth files.

Further, the marking module 440 is configured to: in the process of the second traversal module performing the second traversal on each memory segment in the first file and the second file, if the first file or The name of any unmarked memory segment in the second file includes the first preset name, and the name of the third file in a mapping relationship with the previous memory segment of the any unmarked memory segment includes the second preset name, the marking result of any unmarked memory segment is set to be the same marking result as the previous memory segment.

Further, an acquisition module, configured to control the server to receive the first file and the second file of the target process in the application program from the terminal, the application program is installed in the terminal, and the first file is in the target process. A file recorded by the terminal when a process crashes, and the second file is a file recorded by the terminal when the application is restarted.

Further, a marking module is configured to control the server to receive the plurality of fourth files from the terminal, where the plurality of fourth files are files recorded by the terminal when the target process crashes.

Further, an obtaining module is configured to control the terminal to record the first file of the target process when the target process crashes; and to control the terminal to obtain the second file of the target process when the application program is restarted.

The memory leak attribution device provided by the embodiment of the present disclosure can perform the steps performed by the client or the server in the memory leak attribution method provided by the method embodiment of the present disclosure, and the execution steps and beneficial effects are not repeated here. Repeat.

FIG. 5 is a schematic structural diagram of an electronic device according to an embodiment of the disclosure. Referring specifically to FIG. 5 below, it shows a schematic structural diagram of the electronic device 1000 suitable for implementing the embodiments of the present disclosure. The electronic device 1000 in the embodiment of the present disclosure may include, but is not limited to, such as a mobile phone, a notebook computer, a digital broadcast receiver, a PDA (personal digital assistant), a PAD (tablet computer), a PMP (portable multimedia player), a vehicle-mounted terminal ( Mobile terminals such as in-vehicle navigation terminals), wearable electronic devices, etc., and stationary terminals such as digital TVs, desktop computers, smart home devices, and the like. The electronic device shown in FIG. 5 is only an example, and should not impose any limitation on the function and scope of use of the embodiments of the present disclosure.

As shown in FIG. 5, an electronic device 1000 may include a processing device (eg, a central processing unit, a graphics processor, etc.) 1001, which may be loaded into random access according to a program stored in a read only memory (ROM) 1002 or from a storage device 1008 A program in the memory (RAM) 1003 performs various appropriate actions and processes to implement the memory leak attribution method according to the embodiment of the present disclosure. In the RAM 1003, various programs and information necessary for the operation of the electronic device 1000 are also stored. The processing device 1001, the ROM 1002, and the RAM 1003 are connected to each other through a bus 1004. An input/output (I/O) interface 1005 is also connected to the bus 1004 .

Typically, the following devices can be connected to the I/O interface 1005: input devices 1006 including, for example, a touch screen, touchpad, keyboard, mouse, camera, microphone, accelerometer, gyroscope, etc.; including, for example, a liquid crystal display (LCD), speakers, vibration An output device 1007 such as a computer; a storage device 1008 including, for example, a magnetic tape, a hard disk, etc.; and a communication device 1009 . Communication means 1009 may allow electronic device 1000 to communicate wirelessly or by wire with other devices to exchange information. While FIG. 5 illustrates the electronic device 1000 having various means, it should be understood that not all of the illustrated means are required to be implemented or provided. More or fewer devices may alternatively be implemented or provided.

In particular, according to embodiments of the present disclosure, the processes described above with reference to the flowcharts may be implemented as computer software programs. For example, embodiments of the present disclosure include a computer program product comprising a computer program carried on a non-transitory computer readable medium, the computer program comprising program code for performing the method shown in the flowchart, thereby achieving the above The described memory leak attribution method. In such an embodiment, the computer program may be downloaded and installed from the network via the communication device 1009, or from the storage device 1008, or from the ROM 1002. When the computer program is executed by the processing apparatus 1001, the above-mentioned functions defined in the methods of the embodiments of the present disclosure are executed.

It should be noted that the computer-readable medium mentioned above in the present disclosure may be a computer-readable signal medium or a computer-readable storage medium, or any combination of the above two. The computer-readable storage medium can be, for example, but not limited to, an electrical, magnetic, optical, electromagnetic, infrared, or semiconductor system, apparatus or device, or a combination of any of the above. More specific examples of computer readable storage media may include, but are not limited to, electrical connections with one or more wires, portable computer disks, hard disks, random access memory (RAM), read only memory (ROM), erasable Programmable read only memory (EPROM or flash memory), fiber optics, portable compact disk read only memory (CD-ROM), optical storage devices, magnetic storage devices, or any suitable combination of the foregoing. In this disclosure, a computer-readable storage medium may be any tangible medium that contains or stores a program that can be used by or in conjunction with an instruction execution system, apparatus, or device. In the present disclosure, however, a computer-readable signal medium may include an information signal in baseband or propagated as part of a carrier wave with computer-readable program code embodied thereon. Such propagated information signals may take a variety of forms, including but not limited to electromagnetic signals, optical signals, or any suitable combination of the foregoing. A computer-readable signal medium can also be any computer-readable medium other than a computer-readable storage medium that can transmit, propagate, or transport the program for use by or in connection with the instruction execution system, apparatus, or device . Program code embodied on a computer readable medium may be transmitted using any suitable medium including, but not limited to, electrical wire, optical fiber cable, RF (radio frequency), etc., or any suitable combination of the foregoing.

In some embodiments, the client and server can communicate using any known or future developed network protocol such as HTTP (HyperText Transfer Protocol), and can communicate with digital information in any form or medium (eg, a communications network) interconnected. Examples of communication networks include local area networks ("LAN"), wide area networks ("WAN"), the Internet (eg, the Internet), and peer-to-peer networks (eg, ad hoc peer-to-peer networks), as well as any known or future developed network.

The above-mentioned computer-readable medium may be included in the above-mentioned electronic device; or may exist alone without being assembled into the electronic device.

The above-mentioned computer-readable medium carries one or more programs, and when the above-mentioned one or more programs are executed by the electronic device, the electronic device:

Obtain the first file and the second file of the target process in the application, the first file includes the relevant information of the target process when it crashes, and the second file includes the target process when the application restarts. Related Information;

During the first traversal of each memory segment in the first file and the second file, mark the memory segments in the first file and the second file that match the stack space respectively ;

During the second traversal of each memory segment in the first file and the second file, all memory segments in the first file and the second file are named according to the names of the unmarked memory segments. Mark the unmarked memory segment;

The attribution type of the memory leak is determined according to the marking result corresponding to each memory segment in the first file and the marking result corresponding to each memory segment in the second file.

Optionally, when the above one or more programs are executed by the electronic device, the electronic device may also perform other steps described in the above embodiments.

Computer program code for performing operations of the present disclosure may be written in one or more programming languages, including but not limited to object-oriented programming languages—such as Java, Smalltalk, C++, and This includes conventional procedural programming languages - such as the "C" language or similar programming languages. The program code may execute entirely on the user's computer, partly on the user's computer, as a stand-alone software package, partly on the user's computer and partly on a remote computer, or entirely on the remote computer or server. In the case of a remote computer, the remote computer may be connected to the user's computer through any kind of network, including a local area network (LAN) or a wide area network (WAN), or may be connected to an external computer (eg, using an Internet service provider through Internet connection).

The flowchart and block diagrams in the Figures illustrate the architecture, functionality, and operation of possible implementations of systems, methods and computer program products according to various embodiments of the present disclosure. In this regard, each block in the flowchart or block diagrams may represent a module, segment, or portion of code that contains one or more logical functions for implementing the specified functions executable instructions. It should also be noted that, in some alternative implementations, the functions noted in the blocks may occur out of the order noted in the figures. For example, two blocks shown in succession may, in fact, be executed substantially concurrently, or the blocks may sometimes be executed in the reverse order, depending upon the functionality involved. It is also noted that each block of the block diagrams and/or flowchart illustrations, and combinations of blocks in the block diagrams and/or flowchart illustrations, can be implemented in dedicated hardware-based systems that perform the specified functions or operations , or can be implemented in a combination of dedicated hardware and computer instructions.

The units involved in the embodiments of the present disclosure may be implemented in a software manner, and may also be implemented in a hardware manner. Among them, the name of the unit does not constitute a limitation of the unit itself under certain circumstances.

The functions described herein above may be performed, at least in part, by one or more hardware logic components. For example, without limitation, exemplary types of hardware logic components that may be used include: Field Programmable Gate Arrays (FPGAs), Application Specific Integrated Circuits (ASICs), Application Specific Standard Products (ASSPs), Systems on Chips (SOCs), Complex Programmable Logical Devices (CPLDs), etc.

In the context of the present disclosure, a machine-readable medium may be a tangible medium that may contain or store a program for use by or in connection with the instruction execution system, apparatus or device. The machine-readable medium may be a machine-readable signal medium or a machine-readable storage medium. Machine-readable media may include, but are not limited to, electronic, magnetic, optical, electromagnetic, infrared, or semiconductor systems, devices, or devices, or any suitable combination of the foregoing. More specific examples of machine-readable storage media would include one or more wire-based electrical connections, portable computer disks, hard disks, random access memory (RAM), read only memory (ROM), erasable programmable read only memory (EPROM or flash memory), fiber optics, compact disk read only memory (CD-ROM), optical storage, magnetic storage, or any suitable combination of the foregoing.

It should be noted that, in this document, relational terms such as "first" and "second" etc. are only used to distinguish one entity or operation from another entity or operation, and do not necessarily require or imply these There is no such actual relationship or sequence between entities or operations. Moreover, the terms "comprising", "comprising" or any other variation thereof are intended to encompass a non-exclusive inclusion such that a process, method, article or device that includes a list of elements includes not only those elements, but also includes not explicitly listed or other elements inherent to such a process, method, article or apparatus. Without further limitation, an element qualified by the phrase "comprising a..." does not preclude the presence of additional identical elements in a process, method, article or apparatus that includes the element.

The above descriptions are only specific embodiments of the present disclosure, so that those skilled in the art can understand or implement the present disclosure. Various modifications to these embodiments will be readily apparent to those skilled in the art, and the generic principles defined herein may be implemented in other embodiments without departing from the spirit or scope of the present disclosure. Therefore, the present disclosure is not intended to be limited to the embodiments described herein, but is to be accorded the widest scope consistent with the principles and novel features disclosed herein.

Claims (14)

1. A memory leak attribution method, characterized in that the method includes:

   Obtain the first file and the second file of the target process in the application, the first file includes the relevant information of the target process when it crashes, and the second file includes the target process when the application restarts. Related Information;

   During the first traversal of each memory segment in the first file and the second file, mark the memory segments in the first file and the second file that match the stack space respectively ;

   During the second traversal of each memory segment in the first file and the second file, all memory segments in the first file and the second file are named according to the names of the unmarked memory segments. Mark the unmarked memory segment;

   The attribution type of the memory leak is determined according to the marking result corresponding to each memory segment in the first file and the marking result corresponding to each memory segment in the second file.
2. The method according to claim 1, wherein the memory leak is determined according to the marking result corresponding to each memory segment in the first file and the marking result corresponding to each memory segment in the second file respectively of attribution types, including:

   Determine the total size of the virtual memory corresponding to the memory segment with the same marking result in the first file and the second file respectively;

   The attribution type of the memory leak is determined according to the total size of the virtual memory corresponding to the same marking result in the first file and the total size of the virtual memory corresponding to the same marking result in the second file.
3. The method according to claim 2, wherein, according to the total size of the virtual memory corresponding to the same marking result in the first file and the total size of the virtual memory corresponding to the same marking result in the second file Size, determines the type of attribution of memory leaks, including:

   The target marking result is determined according to the total size of the virtual memory corresponding to the same marking result in the first file and the total size of the virtual memory corresponding to the same marking result in the second file. Marks the result because of type for the target.
4. The method according to claim 3, wherein the total size of the virtual memory corresponding to the target marking result in the first file and the total size of the virtual memory corresponding to the target marking result in the second file The difference between the total sizes is greater than the threshold.
5. The method according to claim 3, wherein the total size of the virtual memory corresponding to the target marking result in the first file and the total size of the virtual memory corresponding to the target marking result in the second file The difference between the total sizes is the largest.
6. The method according to claim 1, wherein in the process of performing the first traversal of each memory segment in the first file and the second file, the first file and the The memory segments in the second file that match the stack space are marked, including:

   Obtain the target file, the target file includes the relevant information of one or more threads in the target process, and the relevant information of each thread includes the address information of the corresponding stack space of the thread;

   During the first traversal of each memory segment in the first file and the second file, determine whether the address information of each memory segment is the same as the address of any stack space in the target file information matching;

   When the address information of any memory segment in the first file or the second file matches the address information of any stack space in the target file, mark the any memory segment.
7. The method according to claim 6, wherein obtaining the target file comprises:

   Obtaining a plurality of fourth files, each of the fourth files in the plurality of fourth files includes relevant information of one or more threads in the target process;

   A target file is acquired from the plurality of fourth files, where the target file is the fourth file with the highest priority that is not used for the matching among the plurality of fourth files.
8. The method according to claim 1, wherein marking the unmarked memory segments according to the names of the unmarked memory segments in the first file and the second file comprises:

   If the name of any unmarked memory segment in the first file or the second file includes the first preset name and is in a mapping relationship with the memory segment preceding any unmarked memory segment, the third file The name includes the second preset name, then the marking result of any unmarked memory segment is set to be the same marking result as the previous memory segment.
9. The method according to claim 1, wherein obtaining the first file and the second file of the target process in the application program comprises:

   The server receives the first file and the second file of the target process in the application program from the terminal, the application program is installed in the terminal, and the first file is recorded by the terminal when the target process crashes file, and the second file is a file recorded by the terminal when the application is restarted.
10. The method according to claim 7, wherein acquiring a plurality of fourth files comprises:

    The server receives the plurality of fourth files from the terminal, and the plurality of fourth files are files recorded by the terminal when the target process crashes.
11. The method according to claim 1, wherein obtaining the first file and the second file of the target process in the application program comprises:

    The terminal records the first file of the target process when the target process crashes;

    The terminal acquires the second file of the target process when the application is restarted.
12. A memory leak attribution device, characterized in that it includes:

    The acquisition module is used to acquire the first file and the second file of the target process in the application program, the first file includes the relevant information of the target process when it crashes, and the second file includes when the application program restarts relevant information of the target process;

    a first traversal module, configured to perform a first traversal on each memory segment in the first file and the second file;

    A second traversal module, configured to perform a second traversal on each memory segment in the first file and the second file;

    A marking module, used for the first traversal module to perform the first traversal of each memory segment in the first file and the second file, respectively, to the first file and the second file. Mark the memory segment in the file that matches the stack space; in the process of the second traversal module performing the second traversal on each memory segment in the first file and the second file, according to the first the name of the unmarked memory segment in the file and the second file marks the unmarked memory segment;

    The determining module is configured to determine the attribution type of the memory leak according to the marking result corresponding to each memory segment in the first file and the marking result corresponding to each memory segment in the second file.
13. An electronic device, characterized in that the electronic device comprises:

    one or more processors;

    a storage device for storing one or more programs;

    The one or more programs, when executed by the one or more processors, cause the one or more processors to implement the method of any one of claims 1-11.
14. A computer-readable storage medium on which a computer program is stored, characterized in that, when the program is executed by a processor, the method according to any one of claims 1-11 is implemented.

Images