CN112463632A - Memory leak detection method and device - Google Patents
Memory leak detection method and device Download PDFInfo
- Publication number
- CN112463632A CN112463632A CN202011445457.5A CN202011445457A CN112463632A CN 112463632 A CN112463632 A CN 112463632A CN 202011445457 A CN202011445457 A CN 202011445457A CN 112463632 A CN112463632 A CN 112463632A
- Authority
- CN
- China
- Prior art keywords
- function
- traversed
- linked list
- functions
- classes
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Granted
Links
- 238000001514 detection method Methods 0.000 title claims abstract description 27
- 230000006870 function Effects 0.000 claims abstract description 211
- 238000010586 diagram Methods 0.000 claims abstract description 31
- 238000000034 method Methods 0.000 claims abstract description 30
- 238000010276 construction Methods 0.000 claims description 6
- 238000004590 computer program Methods 0.000 description 5
- 230000000694 effects Effects 0.000 description 2
- 238000012986 modification Methods 0.000 description 2
- 230000004048 modification Effects 0.000 description 2
- 230000003068 static effect Effects 0.000 description 2
- 230000002159 abnormal effect Effects 0.000 description 1
- 230000009286 beneficial effect Effects 0.000 description 1
- 238000004883 computer application Methods 0.000 description 1
- 238000012790 confirmation Methods 0.000 description 1
- 230000001186 cumulative effect Effects 0.000 description 1
- 238000013461 design Methods 0.000 description 1
- 238000011161 development Methods 0.000 description 1
- 238000005516 engineering process Methods 0.000 description 1
- 230000003287 optical effect Effects 0.000 description 1
- 238000012795 verification Methods 0.000 description 1
- 239000002699 waste material Substances 0.000 description 1
Images
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F11/00—Error detection; Error correction; Monitoring
- G06F11/36—Preventing errors by testing or debugging software
- G06F11/362—Software debugging
- G06F11/366—Software debugging using diagnostics
Landscapes
- Engineering & Computer Science (AREA)
- Theoretical Computer Science (AREA)
- Computer Hardware Design (AREA)
- Quality & Reliability (AREA)
- Physics & Mathematics (AREA)
- General Engineering & Computer Science (AREA)
- General Physics & Mathematics (AREA)
- Debugging And Monitoring (AREA)
Abstract
The invention provides a method and a device for detecting memory leakage, wherein the method comprises the following steps: traversing classes contained in the project, and recording classes possibly having memory leak risks and member variables having risks in the classes to form a risk class diagram; traversing all functions contained in the project, and constructing a linked list between function calls according to the call relation between the functions to form a function linked list; and detecting memory leakage existing in the items based on the risk class diagram and the function linked list. By using the scheme of the invention, the false alarm and the false alarm in the memory leakage detection can be reduced, and the quality and the efficiency of scanning and checking the memory leakage are improved.
Description
Technical Field
The field relates to the field of computers, and more particularly to a method and apparatus for memory leak detection.
Background
Memory leaks are the waste of memory caused by the fact that dynamically allocated heap memory in a program cannot be released or cannot be released for some reason. Memory leaks may reduce the performance of the computer by reducing the amount of available memory, and even cause all or part of the devices to stop working properly or cause application program to crash, thereby bringing serious security risks to enterprises and clients.
Memory leaks are characterized by being covert, cumulative, and more difficult to detect. With the increasing demand of computer applications, effective memory allocation and release are performed, and the problem of preventing memory leakage is more and more prominent. The static scanning mode and the dynamic execution mode are common for detecting the memory leak, but the two modes have the situations of missing report or false report. In order to confirm whether the false alarm is caused, a developer needs to perform secondary verification and confirmation on the false alarm, so that the working efficiency of the developer is reduced, the performance of a computer is reduced due to the false alarm. Therefore, it is very necessary to improve the accuracy of memory leak detection.
Disclosure of Invention
In view of this, an object of the embodiments of the present invention is to provide a method and a device for detecting a memory leak, which can reduce false negative and false positive in memory leak detection, and improve quality and efficiency of scanning and auditing memory leak.
In view of the above, an aspect of the embodiments of the present invention provides a method for detecting memory leak, including the following steps:
traversing classes contained in the project, and recording classes possibly having memory leak risks and member variables having risks in the classes to form a risk class diagram;
traversing all functions contained in the project, and constructing a linked list between function calls according to the call relation between the functions to form a function linked list;
and detecting memory leakage existing in the items based on the risk class diagram and the function linked list.
According to an embodiment of the present invention, traversing the classes included in the project, and recording the classes that may have the risk of memory leak and the member variables that have the risk in the classes to form the risk class diagram includes:
traversing all classes in the project, and recording the classes which contain pointers or structural class member variables and have no destructor;
records classes that contain pointers or structural class member variables and are not released in the destructor.
According to an embodiment of the present invention, traversing all functions included in the item, and constructing a linked list between function calls according to a call relation between the functions to form the function linked list includes:
acquiring a function which is not traversed in the project, and judging whether the entry parameter of the function which is not traversed contains a pointer or a structure variable;
responding to the fact that the entries of the functions which are not traversed do not contain pointers or structure variables, and judging that the functions which are not traversed are the starting ends of the linked lists;
responding to the fact that the entries of the functions which are not traversed contain pointers or structure variables and the functions which are not traversed are called in the traversed function chain table, and inserting the functions which are not traversed into the function chain table;
responding to the function which is not traversed and calling the function in the traversed function linked list, and inserting the function which is not traversed before the function in the traversed function linked list;
and responding to the situation that the function which is not traversed does not call the function in the traversed function linked list, and judging that the function which is not traversed is the starting end of the linked list.
According to an embodiment of the present invention, detecting memory leaks existing in items based on a risk class diagram and a function linked list includes:
traversing each function in the linked list, and judging whether the function contains a pointer or a structure variable;
responding to the fact that the function does not contain a pointer or a structure variable, and judging that the function does not have memory leakage;
and responding to the existence of a pointer or a structure variable in the function, checking the variable and recording the existence of memory leakage.
According to one embodiment of the invention, checking the variables includes checking pointer class variables, class object checks, and structure class variables.
In another aspect of the embodiments of the present invention, there is also provided a device for detecting memory leak, where the device includes:
the recording module is configured to traverse the classes contained in the project, and record the classes possibly having the memory leakage risk and the member variables having the risks in the classes to form a risk class diagram;
the construction module is configured to traverse all functions contained in the project and construct a linked list between function calls according to the call relation between the functions to form a function linked list;
and the detection module is configured to detect memory leakage existing in the project based on the risk class diagram and the function linked list.
According to an embodiment of the invention, the recording module is further configured to:
traversing all classes in the project, and recording the classes which contain pointers or structural class member variables and have no destructor;
records classes that contain pointers or structural class member variables and are not released in the destructor.
According to one embodiment of the invention, the construction module is further configured to:
acquiring a function which is not traversed in the project, and judging whether the entry parameter of the function which is not traversed contains a pointer or a structure variable;
responding to the fact that the entries of the functions which are not traversed do not contain pointers or structure variables, and judging that the functions which are not traversed are the starting ends of the linked lists;
responding to the fact that the entries of the functions which are not traversed contain pointers or structure variables and the functions which are not traversed are called in the traversed function chain table, and inserting the functions which are not traversed into the function chain table;
responding to the function which is not traversed and calling the function in the traversed function linked list, and inserting the function which is not traversed before the function in the traversed function linked list;
and responding to the situation that the function which is not traversed does not call the function in the traversed function linked list, and judging that the function which is not traversed is the starting end of the linked list.
According to one embodiment of the invention, the detection module is further configured to:
traversing each function in the linked list, and judging whether the function contains a pointer or a structure variable;
responding to the fact that the function does not contain a pointer or a structure variable, and judging that the function does not have memory leakage;
and responding to the existence of a pointer or a structure variable in the function, checking the variable and recording the existence of memory leakage.
According to one embodiment of the invention, checking the variables includes checking pointer class variables, class object checks, and structure class variables.
The invention has the following beneficial technical effects: according to the memory leak detection method provided by the embodiment of the invention, a risk class diagram is formed by traversing classes contained in a project and recording classes possibly having memory leak risks and member variables having risks in the classes; traversing all functions contained in the project, and constructing a linked list between function calls according to the call relation between the functions to form a function linked list; the technical scheme for detecting the memory leak in the project based on the risk class diagram and the function linked list can reduce the false alarm and the false alarm in the memory leak detection, and improve the quality and the efficiency of scanning and checking the memory leak.
Drawings
In order to more clearly illustrate the embodiments of the present invention or the technical solutions in the prior art, the drawings used in the description of the embodiments or the prior art will be briefly described below, and it is obvious that the drawings in the following description are only some embodiments of the present invention, and it is obvious for those skilled in the art that other embodiments can be obtained by using the drawings without creative efforts.
FIG. 1 is a schematic flow chart diagram of a method of memory leak detection according to one embodiment of the present invention;
FIG. 2 is a diagram illustrating an apparatus for memory leak detection according to an embodiment of the present invention;
FIG. 3 is a schematic flow diagram of constructing a risk class diagram according to one embodiment of the present invention;
FIG. 4 is a schematic flow diagram of a constructor list according to one embodiment of the invention;
FIG. 5 is a schematic flow chart diagram of memory leak detection according to one embodiment of the present invention;
FIG. 6 is a schematic flow diagram of checking pointers or structure class variables in a function according to one embodiment of the invention.
Detailed Description
In order to make the objects, technical solutions and advantages of the present invention more apparent, the following embodiments of the present invention are described in further detail with reference to the accompanying drawings.
In view of the above-mentioned objects, a first aspect of the embodiments of the present invention provides an embodiment of a method for detecting a memory leak. Fig. 1 shows a schematic flow diagram of the method.
As shown in fig. 1, the method may include the steps of:
s1 traversing the classes contained in the project, recording the classes possibly having memory leak risks and the member variables having risks in the classes to form a risk class diagram, and treating the classes without memory leak risks as common variables without extra attention;
s2 traversing all functions contained in the project, and constructing a linked list between function calls according to the call relation between the functions to form a function linked list, wherein the linked list represents the trend of data space flow in the functions, and whether the space is released or not can be judged by tracking the process;
s3, based on the risk class diagram and the function linked list, detecting the memory leak existing in the project, traversing the function linked list, and detecting and recording the memory leak existing in the code by judging the scene of the common memory leak in combination with the function detection process.
By the technical scheme of the invention, the false alarm and the false alarm in the memory leakage detection can be reduced, and the quality and the efficiency of scanning and checking the memory leakage are improved.
Memory leaks occur primarily in the mishandling of occupied memory space, which is often inseparable from pointers, as will be described in more detail below with respect to pointer types and handling of pointers.
In project development, a common pointer type major class can be divided into a pointer type and a class (structure) variable.
(1) Pointer variables: can be divided into an intelligent pointer, a structural pointer variable and a common pointer variable.
The intelligent pointer behaves like a conventional pointer, but is responsible for automatically releasing the memory space pointed to, and therefore does not need to consider the problem of memory leakage.
Global pointer variable: the life cycle of the pointer of the type exists in the whole project process, the project program is finished, and the pointer variable is also naturally released, so that the problem of memory leakage does not need to be considered.
The structure pointer variable: the space pointed by the pointer is a structure type such as class, structure, array, vector and the like, and data types needing to be released independently are stored in the space.
The common pointer variable: that is, after the space occupied by the current variable pointer is released, the problem that the space occupied by the variable is not released does not exist.
(2) The structure class variable is as follows: if a pointer type variable exists in the structure, the problem of memory leak needs to be considered.
Common memory leak cases are analyzed for the above types:
structure type pointer: when the space occupied by the pointer of the type is released, only the space of the current pointer is released, and the space in the structure is not released; releasing only the space inside the structure, not releasing the space of the current pointer, etc., all of which may result in memory leakage.
The common pointer variable: the common pointer variable in the function is divided into two cases and is released in the current function; use continues through shallow copy assignments or direct returns.
The structure class variable is as follows: if pointer type variables exist in the structure, and are not released outside and inside the structure, therefore, when the life cycle of the structure type variables is finished, unreleased space exists.
And others: namely, the memory leak is caused because the code logic design is not reasonable. If the pointer variable is assigned, the space before assignment is not released; an exception occurs before the variable is released, the function ends early, the variable does not come, the variable is released, and the like, so that memory leakage is caused.
Common static scan tools mainly focus on memory leaks caused by changes of common pointers in current functions, structural class pointers and logic errors of partial codes. And no additional consideration is given to the condition that the structure type variable and the pointer variable return to be used continuously. The invention carries out the detection on the whole framework of the flow of the structure class and the function variable through the detailed analysis of the memory leakage, and reduces the false alarm and the false negative in the memory leakage detection.
As shown in fig. 3, in a preferred embodiment of the present invention, traversing the classes included in the project, and recording the classes that may have risk of memory leak and the member variables that have risk in the classes to form the risk class diagram includes:
traversing all classes in the project, and recording the classes which contain pointers or structural class member variables and have no destructor;
records classes that contain pointers or structural class member variables and are not released in the destructor.
As shown in fig. 4, in a preferred embodiment of the present invention, traversing all functions contained in the entry, and constructing a linked list between function calls according to a call relation between the functions to form the function linked list includes:
acquiring a function which is not traversed in the project, and judging whether the entry parameter of the function which is not traversed contains a pointer or a structure variable;
responding to the fact that the entries of the functions which are not traversed do not contain pointers or structure variables, and judging that the functions which are not traversed are the starting ends of the linked lists;
responding to the fact that the entries of the functions which are not traversed contain pointers or structure variables and the functions which are not traversed are called in the traversed function chain table, and inserting the functions which are not traversed into the function chain table;
responding to the function which is not traversed and calling the function in the traversed function linked list, and inserting the function which is not traversed before the function in the traversed function linked list;
and responding to the situation that the function which is not traversed does not call the function in the traversed function linked list, and judging that the function which is not traversed is the starting end of the linked list.
As shown in fig. 5, in a preferred embodiment of the present invention, detecting memory leaks existing in items based on a risk class diagram and a function linked list includes:
traversing each function in the linked list, and judging whether the function contains a pointer or a structure variable;
responding to the fact that the function does not contain a pointer or a structure variable, and judging that the function does not have memory leakage;
and responding to the existence of a pointer or a structure variable in the function, checking the variable and recording the existence of memory leakage.
In a preferred embodiment of the present invention, checking the variables includes checking a pointer class variable, a class object, and a structure class variable. The process of checking a pointer or a structure variable in a function is shown in fig. 6, and mainly includes judgment of the pointer variable, the class object, and the structure variable, where the judgment of the class variable needs to be performed in combination with a risk class diagram, and the specific process is as follows:
detection of pointer type variables:
(1) the method is a singleton or global variable, and no memory leak exists;
(2) the variable is transmitted, the trend of the variable is tracked according to the function linked list, and if the variable is released, no memory leakage exists; otherwise, memory leak exists;
(3) if the variable is not assigned and not released, the memory leakage exists; if the variable is circularly assigned and the variable is not released before being assigned, then there is memory leak.
Detection of class objects:
(1) traversing the risk class diagram, and if the class is not in the risk class, then no memory leak exists;
(2) if the variables are not released or abnormal before the variables are released in the risk classes, the memory leakage exists;
(3) if the variable is circularly assigned, the variable is not released before the assignment, or whether an exception occurs before the assignment, then a memory leak exists.
And (3) detecting a structure class variable: the judgment process of the process is the same as the detection process of the class object.
By the technical scheme of the invention, the false alarm and the false alarm in the memory leakage detection can be reduced, and the quality and the efficiency of scanning and checking the memory leakage are improved.
It should be noted that, as will be understood by those skilled in the art, all or part of the processes in the methods of the above embodiments may be implemented by instructing relevant hardware through a computer program, and the above programs may be stored in a computer-readable storage medium, and when executed, the programs may include the processes of the embodiments of the methods as described above. The storage medium may be a magnetic disk, an optical disk, a Read-Only Memory (ROM), a Random Access Memory (RAM), or the like. The embodiments of the computer program may achieve the same or similar effects as any of the above-described method embodiments.
Furthermore, the method disclosed according to an embodiment of the present invention may also be implemented as a computer program executed by a CPU, and the computer program may be stored in a computer-readable storage medium. The computer program, when executed by the CPU, performs the above-described functions defined in the method disclosed in the embodiments of the present invention.
In view of the above object, according to a second aspect of the embodiments of the present invention, there is provided an apparatus for detecting memory leak, as shown in fig. 2, the apparatus 200 includes:
the recording module is configured to traverse the classes contained in the project, and record the classes possibly having the memory leakage risk and the member variables having the risks in the classes to form a risk class diagram;
the construction module is configured to traverse all functions contained in the project and construct a linked list between function calls according to the call relation between the functions to form a function linked list;
and the detection module is configured to detect memory leakage existing in the project based on the risk class diagram and the function linked list.
In a preferred embodiment of the present invention, the recording module is further configured to:
traversing all classes in the project, and recording the classes which contain pointers or structural class member variables and have no destructor;
records classes that contain pointers or structural class member variables and are not released in the destructor.
In a preferred embodiment of the invention, the construction module is further configured to:
acquiring a function which is not traversed in the project, and judging whether the entry parameter of the function which is not traversed contains a pointer or a structure variable;
responding to the fact that the entries of the functions which are not traversed do not contain pointers or structure variables, and judging that the functions which are not traversed are the starting ends of the linked lists;
responding to the fact that the entries of the functions which are not traversed contain pointers or structure variables and the functions which are not traversed are called in the traversed function chain table, and inserting the functions which are not traversed into the function chain table;
responding to the function which is not traversed and calling the function in the traversed function linked list, and inserting the function which is not traversed before the function in the traversed function linked list;
and responding to the situation that the function which is not traversed does not call the function in the traversed function linked list, and judging that the function which is not traversed is the starting end of the linked list.
In a preferred embodiment of the present invention, the detection module is further configured to:
traversing each function in the linked list, and judging whether the function contains a pointer or a structure variable;
responding to the fact that the function does not contain a pointer or a structure variable, and judging that the function does not have memory leakage;
and responding to the existence of a pointer or a structure variable in the function, checking the variable and recording the existence of memory leakage.
In a preferred embodiment of the present invention, checking the variables includes checking a pointer class variable, a class object, and a structure class variable.
The embodiments described above, particularly any "preferred" embodiments, are possible examples of implementations and are presented merely to clearly understand the principles of the invention. Many variations and modifications may be made to the above-described embodiments without departing from the spirit and principles of the technology described herein. All such modifications are intended to be included within the scope of this disclosure and protected by the following claims.
Claims (10)
1. A method for memory leak detection, comprising:
traversing classes contained in the project, and recording classes possibly having memory leak risks and member variables having risks in the classes to form a risk class diagram;
traversing all functions contained in the project, and constructing a linked list between function calls according to the call relation between the functions to form a function linked list;
and detecting memory leakage existing in the item based on the risk class diagram and the function linked list.
2. The method of claim 1, wherein traversing the classes included in the project and recording the classes that may have risk of memory leaks and the member variables that have risk in the classes to form a risk class graph comprises:
traversing all classes in the project, and recording the classes which contain pointers or structural class member variables and have no destructor;
records classes that contain pointers or structural class member variables and are not released in the destructor.
3. The method of claim 1, wherein traversing all functions contained in the item and constructing a linked list between function calls according to call relationships between the functions to form the linked list of functions comprises:
acquiring a function which is not traversed in a project, and judging whether the entry parameter of the function which is not traversed contains a pointer or a structure variable;
responding to the fact that the entries of the functions which are not traversed do not contain pointers or structure variables, and judging that the functions which are not traversed are the starting ends of the linked lists;
responding to the fact that the entries of the functions which are not traversed contain pointers or structure type variables and the functions which are not traversed are called in the traversed function chain table, and inserting the functions which are not traversed into the function chain table;
responding to the function which is not traversed and calling the function in the traversed function linked list, and inserting the function which is not traversed to the front of the function in the traversed function linked list;
and responding to the situation that the function which is not traversed does not call the function in the traversed function linked list, and judging that the function which is not traversed is the starting end of the linked list.
4. The method of claim 1, wherein detecting the memory leak in the item based on the risk class diagram and the function linked list comprises:
traversing each function in the linked list, and judging whether the function contains a pointer or a structure variable;
responding to the fact that the function does not contain a pointer or a structure variable, and judging that the function does not have memory leakage;
and responding to the existence of a pointer or a structure variable in the function, checking the variable and recording the existence of memory leakage.
5. The method of claim 4, wherein checking variables comprises checking pointer class variables, class object checks, and structure class variables.
6. An apparatus for memory leak detection, the apparatus comprising:
the recording module is configured to traverse classes contained in the project, and record classes possibly having memory leak risks and member variables having risks in the classes to form a risk class diagram;
the construction module is configured to traverse all functions contained in the project and construct a linked list between function calls according to the call relation between the functions to form a function linked list;
and the detection module is configured to detect memory leak existing in the project based on the risk class diagram and the function linked list.
7. The device of claim 6, wherein the recording module is further configured to:
traversing all classes in the project, and recording the classes which contain pointers or structural class member variables and have no destructor;
records classes that contain pointers or structural class member variables and are not released in the destructor.
8. The apparatus of claim 6, wherein the construction module is further configured to:
acquiring a function which is not traversed in a project, and judging whether the entry parameter of the function which is not traversed contains a pointer or a structure variable;
responding to the fact that the entries of the functions which are not traversed do not contain pointers or structure variables, and judging that the functions which are not traversed are the starting ends of the linked lists;
responding to the fact that the entries of the functions which are not traversed contain pointers or structure type variables and the functions which are not traversed are called in the traversed function chain table, and inserting the functions which are not traversed into the function chain table;
responding to the function which is not traversed and calling the function in the traversed function linked list, and inserting the function which is not traversed to the front of the function in the traversed function linked list;
and responding to the situation that the function which is not traversed does not call the function in the traversed function linked list, and judging that the function which is not traversed is the starting end of the linked list.
9. The device of claim 6, wherein the detection module is further configured to:
traversing each function in the linked list, and judging whether the function contains a pointer or a structure variable;
responding to the fact that the function does not contain a pointer or a structure variable, and judging that the function does not have memory leakage;
and responding to the existence of a pointer or a structure variable in the function, checking the variable and recording the existence of memory leakage.
10. The apparatus of claim 9, wherein checking variables comprises checking pointer class variables, class object checks, and structure class variables.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202011445457.5A CN112463632B (en) | 2020-12-11 | 2020-12-11 | Memory leak detection method and device |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202011445457.5A CN112463632B (en) | 2020-12-11 | 2020-12-11 | Memory leak detection method and device |
Publications (2)
| Publication Number | Publication Date |
|---|---|
| CN112463632A true CN112463632A (en) | 2021-03-09 |
| CN112463632B CN112463632B (en) | 2022-06-07 |
Family
ID=74801433
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN202011445457.5A Active CN112463632B (en) | 2020-12-11 | 2020-12-11 | Memory leak detection method and device |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN112463632B (en) |
Cited By (2)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN112882943A (en) * | 2021-03-11 | 2021-06-01 | 腾讯音乐娱乐科技（深圳）有限公司 | Interface updating collapse risk detection method and device, electronic equipment and storage medium |
| CN117707920A (en) * | 2023-08-31 | 2024-03-15 | 荣耀终端有限公司 | Memory leakage positioning method, electronic equipment and storage medium |
Citations (3)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN101763305A (en) * | 2009-12-29 | 2010-06-30 | 青岛海信宽带多媒体技术有限公司 | Method for detecting memory leak of embedded system |
| CN104572460A (en) * | 2014-12-30 | 2015-04-29 | 大唐移动通信设备有限公司 | Memory leak detecting method and memory leak detecting device |
| CN109144872A (en) * | 2018-08-20 | 2019-01-04 | 杭州迪普科技股份有限公司 | Detection method, device, terminal device and the readable storage medium storing program for executing of memory overflow |
-
2020
- 2020-12-11 CN CN202011445457.5A patent/CN112463632B/en active Active
Patent Citations (3)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN101763305A (en) * | 2009-12-29 | 2010-06-30 | 青岛海信宽带多媒体技术有限公司 | Method for detecting memory leak of embedded system |
| CN104572460A (en) * | 2014-12-30 | 2015-04-29 | 大唐移动通信设备有限公司 | Memory leak detecting method and memory leak detecting device |
| CN109144872A (en) * | 2018-08-20 | 2019-01-04 | 杭州迪普科技股份有限公司 | Detection method, device, terminal device and the readable storage medium storing program for executing of memory overflow |
Cited By (2)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN112882943A (en) * | 2021-03-11 | 2021-06-01 | 腾讯音乐娱乐科技（深圳）有限公司 | Interface updating collapse risk detection method and device, electronic equipment and storage medium |
| CN117707920A (en) * | 2023-08-31 | 2024-03-15 | 荣耀终端有限公司 | Memory leakage positioning method, electronic equipment and storage medium |
Also Published As
| Publication number | Publication date |
|---|---|
| CN112463632B (en) | 2022-06-07 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| CN112463632B (en) | Memory leak detection method and device | |
| US20080127112A1 (en) | Software tracing | |
| US7434206B2 (en) | Identifying memory leaks in computer systems | |
| US8074116B2 (en) | Exception raised notification | |
| KR101143214B1 (en) | Method and system for detecting potential races in multithreaded program | |
| CN110134385B (en) | Method for recording C language function call chain and C language general log frame | |
| CN108197032B (en) | Main thread jamming monitoring method, medium, equipment and system for IOS application | |
| US8806462B2 (en) | Identifying code that wastes time switching tasks | |
| US7865901B2 (en) | Managing memory resident objects to optimize a runtime environment | |
| CN103699480A (en) | WEB dynamic security flaw detection method based on JAVA | |
| US20080215305A1 (en) | Emulated Memory Management | |
| US8793289B2 (en) | Method and system for detecting memory leaks and copying garbage collection files | |
| CN101763305A (en) | Method for detecting memory leak of embedded system | |
| US20070156939A1 (en) | Deadlock detection by lock classification | |
| Hu et al. | A memory-related vulnerability detection approach based on vulnerability features | |
| CN110688245B (en) | Information acquisition method, device, storage medium and equipment | |
| US20040143824A1 (en) | Method and apparatus for detecting an overflow condition in a kernel stack during operating system development | |
| CN114428733A (en) | Kernel data competition detection method based on static program analysis and fuzzy test | |
| JP2007004413A (en) | Memory leak detection means | |
| CN112596823B (en) | Safety control method and device and electronic equipment | |
| US20120159457A1 (en) | Validating run-time references | |
| Dahlgren et al. | Improving scientific software component quality through assertions | |
| CN112528331A (en) | Privacy disclosure risk detection method, device and system | |
| CN116502239B (en) | Memory vulnerability detection method, device, equipment and medium for binary program | |
| CN117608890A (en) | Method and device for detecting memory fault |
Legal Events
| Date | Code | Title | Description |
|---|---|---|---|
| PB01 | Publication | ||
| PB01 | Publication | ||
| SE01 | Entry into force of request for substantive examination | ||
| SE01 | Entry into force of request for substantive examination | ||
| GR01 | Patent grant | ||
| GR01 | Patent grant |