CN111611158A - Application performance analysis system and method - Google Patents
Application performance analysis system and method Download PDFInfo
- Publication number
- CN111611158A CN111611158A CN202010383480.XA CN202010383480A CN111611158A CN 111611158 A CN111611158 A CN 111611158A CN 202010383480 A CN202010383480 A CN 202010383480A CN 111611158 A CN111611158 A CN 111611158A
- Authority
- CN
- China
- Prior art keywords
- video memory
- program
- pointer
- kernel function
- abstract
- 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.)
- Pending
Links
- 238000004458 analytical method Methods 0.000 title claims abstract description 37
- 238000000034 method Methods 0.000 title claims abstract description 18
- 230000006870 function Effects 0.000 claims abstract description 69
- 238000013507 mapping Methods 0.000 claims abstract description 23
- 230000003068 static effect Effects 0.000 claims abstract description 22
- 238000005259 measurement Methods 0.000 claims abstract description 9
- 238000012217 deletion Methods 0.000 claims abstract description 7
- 230000037430 deletion Effects 0.000 claims abstract description 7
- 238000007792 addition Methods 0.000 claims abstract description 5
- 238000012986 modification Methods 0.000 claims abstract description 4
- 230000004048 modification Effects 0.000 claims abstract description 4
- 238000001514 detection method Methods 0.000 claims description 23
- 230000014509 gene expression Effects 0.000 claims description 4
- HPTJABJPZMULFH-UHFFFAOYSA-N 12-[(Cyclohexylcarbamoyl)amino]dodecanoic acid Chemical compound OC(=O)CCCCCCCCCCCNC(=O)NC1CCCCC1 HPTJABJPZMULFH-UHFFFAOYSA-N 0.000 description 4
- 238000010586 diagram Methods 0.000 description 4
- 230000000903 blocking effect Effects 0.000 description 2
- 239000008186 active pharmaceutical agent Substances 0.000 description 1
- 230000009286 beneficial effect Effects 0.000 description 1
- 150000001875 compounds Chemical class 0.000 description 1
- 238000000605 extraction Methods 0.000 description 1
- 238000003780 insertion Methods 0.000 description 1
- 230000037431 insertion Effects 0.000 description 1
- 238000012545 processing Methods 0.000 description 1
- 238000004904 shortening Methods 0.000 description 1
- 238000012546 transfer Methods 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/3636—Software debugging by tracing the execution of the program
-
- 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 relates to an application performance analysis system and a method, wherein the system comprises a video memory leakage analysis module and a kernel function execution time module; the video memory leakage analysis module is used for performing addition, deletion and modification operations on the pointer address mapping set by analyzing an abstract syntax tree of a static program to record the operations on the video memory; whether a pointer is available or a video memory address which is not released is analyzed in the pointer address mapping set; and the kernel function execution time module is used for capturing kernel function execution names needing to be counted through corresponding interfaces, capturing the kernel function execution names before the target kernel function of the application program is executed, inserting CPU/GPU time measurement code segments, summarizing the counted time when the program is finished running, and displaying the collected time. The invention analyzes before the program runs and finds whether the program has the problem of video memory leakage as early as possible.
Description
Technical Field
The invention relates to an application performance analysis technology, in particular to an application performance analysis system and method.
Background
HPCToolkit is a set of multi-platform tools for performance analysis of applications. The HPCToolkit performs video memory leakage detection through a dynamic detection method, the dynamic detection method needs to insert piles or set interruption to capture some information in the program running process, and the actual running efficiency of the application program is influenced to a greater or lesser extent. In the hpctookit, when counting kernel function execution time, it is necessary to capture the time when kernel function execution starts and the time when kernel function execution ends. Through the API function provided by the platform, such as cudadevicesyncronize (AMD platform corresponds to hipdevicesyncronize function), the program will remain in the blocking state until all the previously requested tasks have been completely executed, and an error will be returned if any previously executed task fails.
Disclosure of Invention
The invention aims to solve the problems of the conventional application performance analysis system in the video memory leakage detection.
In order to achieve the above object, in one aspect, the present invention provides an application performance analysis system, which includes a memory leakage analysis module and a kernel function execution time module; wherein,
the video memory leakage analysis module is used for performing addition, deletion and modification operations on the pointer address mapping set by analyzing the abstract syntax tree of the static program so as to record the operations on the video memory; whether a pointer is available or a video memory address which is not released is analyzed in the pointer address mapping set; and
and the kernel function execution time module is used for capturing kernel function execution names needing to be counted through corresponding interfaces, capturing the kernel function execution names before the target kernel function of the application program is executed, inserting CPU/GPU time measurement code segments, summarizing the counted time when the program is finished running, and displaying the collected time.
In another aspect, the present invention provides an application performance analysis method, including the steps of:
the method comprises the steps of performing addition, deletion and change operations on a pointer address mapping set by analyzing an abstract syntax tree of a static program to record the operation on the video memory; whether a pointer is available or a video memory address which is not released is analyzed in the pointer address mapping set; and
capturing kernel function execution names needing to be counted through corresponding interfaces, capturing before target kernel functions of application programs are executed, inserting CPU/GPU time measurement code segments, summarizing counted time when the programs are operated, and displaying.
The invention has the beneficial effects that:
(1) and analyzing before the program runs to discover whether the program has a video memory leakage problem as early as possible.
(2) The static detection does not relate to the actual operation of the application program and does not influence the actual operation efficiency.
(3) Because static analysis is adopted, detection is only carried out on source codes, so that detection software can be deployed to different heterogeneous platforms for application.
Drawings
The invention is further illustrated with reference to the following figures and examples.
Fig. 1 is a schematic structural diagram of an application performance analysis system according to an embodiment of the present invention;
FIG. 2 is a schematic diagram of an extended video memory leak detection process;
FIG. 3 is a schematic diagram illustrating a statistical process of execution time of extended kernel functions;
FIG. 4 is a flowchart illustrating the CPU/GPU function execution time statistics.
Detailed Description
The embodiment of the invention adds the functions of video memory leakage analysis and kernel function execution time statistics on the Invitta GPU and the domestic advanced computing system accelerator on the basis of the open source software HPCToolKit tool to form a program performance analysis system D-HPCToolKit of a cross-platform heterogeneous system structure.
Aiming at the lower-layer display card programming languages, such as CUDA and HIP, an application program needs functions such as cudaMalloc or hipMalloc to apply for a display memory space, when the program uses up the corresponding space, the functions such as cudaFree or hipFlee and the like must be called manually to release the space, otherwise, as the program continuously applies, the display memory is always used up, and the program and even the system are crashed.
In order to solve the problem of video memory leakage in a heterogeneous system, the embodiment of the invention provides a video memory leakage static detection algorithm, which refers to a memory leakage static detection method and has the following characteristics: (1) static detection: and analyzing before the program runs to discover whether the program has a video memory leakage problem as early as possible. (2) No impact on application performance: the dynamic detection has more or less influence on the actual running efficiency of the application program due to the fact that pile insertion or interruption is required to capture some information in the running process of the program; the static detection does not relate to the actual running of the application program, so the actual running efficiency is not influenced. (3) Cross-platform performance: because static analysis is adopted, detection is only carried out on source codes, so that detection software can be deployed to different heterogeneous platforms for application.
Fig. 1 is a schematic structural diagram of an application performance analysis system according to an embodiment of the present invention. As shown in fig. 1, the system includes a memory leak analysis module and a kernel function execution time module.
First, display memory leakage static analysis module
The video memory leakage static analysis module mainly detects the following two video memory leakage types: (1) the applied memory space is forgotten to be released: the method is used for calling only cudaMalloc and hipMalloc, and calling cudaFree and hipFare without matching. (2) The applied video memory space is released for multiple times: and the release of cudaFree and hippree is called for multiple times aiming at the same video memory space of the application. (3) "field space": the pointer after the space is applied through cudaMalloc and hipCalloc changes the value of the pointer through other assignment operations, so that the video memory space applied at the beginning cannot be reached, and leakage is caused.
Fig. 2 is a flow chart of the D-hpctoikit work flow after adding a video memory leakage static detection function. Source, wherein "static analysis" indicates that analysis of the source program app.source is required, i.e. static detection; the hpcren-memleak is a tool for statically detecting whether the video memory is leaked or not; the "memleak profile" corresponds to the detection result: the DUPLICATE _ ERR corresponds to a repeated release error, the wildspace _ ERR corresponds to a wild space error, and the READMINPOINTER _ ERR corresponds to a video memory unreleased error.
The step of performing static detection analysis on the source program comprises the following steps:
step one, abstract nodes of source program
Because the programming style of each person is different, the program code structure is different, and the direct analysis of the source code of the source program is difficult. The embodiment of the invention abstracts the source program code into the SPAN program intermediate expression and then analyzes the SPAN.
SPAN abstracts the following for each row of the source program:
<node>
<lineNum>i</lineNum>
<code>code</code>
<nextLine>j1(,j2,j3…jn)</nextLine>
</node>
wherein < node > represents a node, which represents a certain line in the program source code, i represents a line number, code is a source code statement, j 1-jn represents a line number of a statement next to the current statement (generally, for an expression statement, nextLine is a line number of a next line statement; for a control statement, nextLine is a plurality of branch line numbers); the < node > node of the ith row is represented by the variable nodei.
The final program is abstracted into a node tree, and the source program abstract node tree contains information of each line of codes and the transfer relation among the codes.
Step two, controlling the flow chart
The control flow graph is a directed graph reflecting the logic control flow of a program. Generally, a control flow graph of a function can be represented as (N, E, Entry, Exit). Wherein, N represents the condition judgment of simple sentences and compound sentences in the program and the control flow junction, and E represents the set of directed edges to reflect the control flow relation among the sentences in the program. Entry is a fixed unique Entry node of the function, and Exit is a unique deduction node of the function. A control flow graph is a directed graph with a single, fixed ingress node and egress node. For the programs with non-single inlet and single outlet, the method can be solved by artificially adding a unified inlet and outlet. The control flow graph may be used to analyze branch flow direction of program source code for determining call relationships between code blocks. A control flow graph is a path from a root node to a leaf node of a tree of abstract nodes of a source program in a previous section.
Step three, pointer address mapping set
Each address in the video memory has a variable corresponding to it, and the application and release of the video memory are based on the operation of the pointer variable.
The set of pointer addresses is defined as follows. Let P denote the video memory pointer variable set in the program, M denotes the video memory address set, and for Pi belongs to P, Mi belongs to M, { < { Pi }, Mi > } denotes the pointer address mapping set.
The embodiment of the invention records the operation of the program on the video memory by analyzing the abstract syntax tree of the static program and performing the operations of adding, deleting and changing the pointer address mapping set. And finally, analyzing whether the pointer address mapping set has an empty pointer or a video memory address which is not released.
The pointer variable of each operation is set as pointer, and the video memory address is memory (because of static analysis, the real video memory address cannot be obtained, and the embodiment of the invention replaces the current time).
The operation for the pointer address mapping set is as follows.
(1) malloc (< pointer, memory >): and inserting the pointer and the video memory address into the P-MSet, and applying for video memory mainly aiming at cudaMalloc and hipMalloc functions.
The algorithm is as follows: adding pointer address mapping to P-M Set
Inputting: pointer variable name pointer, video memory address memory
And (3) outputting: is free of
Begin
Acquiring the current time, and assigning the time to the memory
Newly-built pointer address mapping relation < { pointer }, memory >
Insert < { pointer }, memory > into P-M Set
End
(2) free (pointer): and releasing the video memory address pointed by the pointer, wherein the video memory is released mainly aiming at cudaFree and hippree functions.
The algorithm is as follows: deleting pointer and memory address pointed by pointer from P-M Set
Inputting: pointer variable name pointer
And (3) outputting: video memory detection error code
Begin
Traversing each group of < { pointers }, memory >, and taking out a pointer variable set { pointers }
Determine if the pointer is among the set { pointers }
If yes, deleting the current < { pointers }, memory > mapping, exiting the loop and returning SUCCESS
If not, continue the next traversal
When the traversal is finished, the current pointer is not found, a repeated deletion exception is recorded and the repeated deletion _ ERR is returned
End
(3) modify (< pointeri, memoryi >, < pointerj, memoryj >): and carrying out assignment modification on the pointer variable. For an assignment operation of i-j.
The algorithm is as follows: modifying elements of a P-M Set
Inputting: pointer address mapping relationships < pointeri, memoryi >, < pointerj, memoryj >
And (3) outputting: is free of
Begin
Traversing each group of < { pointers }, memory >, and taking out a pointer variable set { pointers }
Find the set of pointeri < { pointers } i, memoryi >
Find the set of pointerj < { pointers } j, memoryj >
If the memoryi and the memoryj are the same video memory address
Do nothing
If the memoryi and the memoryj are not the same video memory address
Pointeri is removed from { pointers } i and added to { pointers } j
End
(4) check (): and traversing the pointer address mapping set when the program is ended, and checking whether an unreleased video memory space exists.
The algorithm is as follows: traversing P-M Set
Inputting: is free of
And (3) outputting: video memory detection error code
Begin
Judging whether the P-M Set is empty or not
If empty, return SUCCESS
If not, go through each set < { pointers }, memory >
If { pointers } is NULL, return WILDMEMORY _ ERR
If { pointers } is not NULL, return REAMINPOINTER _ ERR
End
The embodiment of the invention also provides a video memory leakage fault detection method, which comprises the following steps:
(1) converting a source program into a source program abstract node set;
(2) constructing an abstract node tree according to the source program abstract node set;
(3) starting analysis from the root node of the abstract node tree, and establishing and maintaining a pointer address mapping set according to 3P-MSet operation functions in the analysis process;
(4) executing a check function after the leaf node is executed, and returning a corresponding result;
(5) deeply traversing the abstract node tree;
(6) and (5) circulating the steps (3) to (5) until the depth traversal is completed.
Kernel function execution time module
The CPU end in the heterogeneous system program is responsible for the distribution of tasks and data, and the GPU end is responsible for the parallel processing of the data, so that the shortening of the execution time of the kernel function running on the GPU is a key index for improving the overall running efficiency of the program.
Designing the kernel function execution time module requires consideration of the following points:
1. and synchronously executing the kernel functions: the kernel execution time is counted, and it is necessary to capture the time when the kernel execution starts and the time when the kernel execution ends. Through the API function cudadevicesynchronization (AMD platform corresponds to hipdevicesynchronization), the program will stay in the blocking state until all the previously requested tasks have been completely executed, and an error will be returned if any previously executed task fails.
2. Cross-platform performance: and calling an API (application programming interface) provided by the heterogeneous system to carry out kernel function time statistics when the kernel function execution time statistics is carried out. The embodiment of the invention adopts 2 time statistics APIs: (1) for CPU system call, adopting gettimeoffset function in < sys/time.h > system library to count TIME difference to obtain CPU _ TIME measurement TIME of kernel function; (2) for GPU system call, 2 sets of measurement modes are provided for 2 heterogeneous system Inviandard systems and AMD systems supported by the embodiment of the invention, and a cudaEventElapsedTime function is adopted for counting aiming at a CUDA platform; for HIP platforms, adopt
And counting hipentelapsedtime, and obtaining the TIME difference to obtain the GPU _ TIME. The access to the bottom hardware counter of the display card can be avoided through a general API calling mode provided by the system, and the non-universality and the lack of infrastructure support are avoided.
3. Coarse granularity: as the kernel function execution time statistics is carried out by adopting the interface provided by the CPU system or the GPU system, the granularity of time measurement is coarse granularity, and the time statistical unit is microsecond.
FIG. 3 is a flow chart illustrating the statistics of the execution time of the extended kernel function. FIG. 3 shows the D-HPCToolkit workflow after kernel function execution time is extended, and the kernel extraction profile part is the kernel function execution time output result of the extended hprun. The original hprun function can only count the execution time of the CPU function and the loop, and a call stackprofile statistical result is formed. Now, a statistical function of hprun is added to support statistics of execution time of the GPU kernel, and a macroscopic D-hpctookit function is shown in fig. 3, and a specific statistical flow is shown in fig. 4.
FIG. 4 is a flowchart illustrating the CPU/GPU function execution time statistics. As shown in fig. 4, on the basis of hpcontrol, the upper layer captures a kernel execution name to be counted through a dlopen interface provided by Libmonitor in hpctolkit, captures the kernel execution name before the target kernel of the application program is executed, inserts a CPU/GPU TIME measurement code segment (CPU/GPU timeout and CPU/GPU TIME end), and finally, after the program is finished running, displays the summary counted TIME. Capturing a target kernel function through a CUDA _ RUNTIME _ SYNC _ WRAPPER function, for example, for a testKernel < < < grid, threads > () function, inserting a GPU TIME start code before the function runs, wherein the code is as follows:
float gpuTime＝0.f；
cudaEvent_t start,stop；
cudaEventCreate(&start)；
cudaEventCreate(&stop)；
cudaEventRecord(start)；
after the kernel function is finished, inserting a GPU TIME end code, wherein the code is as follows:
cudaEventRecord(stop)；
cudaEventSynchronize(stop)；
cudaEventElapsedTime(&gpuTime,start,stop)；
cudaEventDestroy(start)；
cudaEventDestroy(stop)；
the result of gpuTime counted in the final CUDA _ running _ SYNC _ WRAPPER function is the execution time of the kernel function.
The embodiment of the invention analyzes before the program runs and discovers whether the program has the problem of video memory leakage as early as possible. Since the static detection does not involve the actual running of the application program, the actual running efficiency is not affected. Because static analysis is adopted, detection is only carried out on source codes, so that detection software can be deployed to different heterogeneous platforms for application.
It will be obvious that many variations of the invention described herein are possible without departing from the true spirit and scope of the invention. Accordingly, all changes which would be obvious to one skilled in the art are intended to be included within the scope of this invention as defined by the appended claims. The scope of the invention is only limited by the claims.
Claims (8)
1. An application performance analysis system is characterized by comprising a video memory leakage analysis module and a kernel function execution time module; wherein,
the video memory leakage analysis module is used for performing addition, deletion and modification operations on the pointer address mapping set by analyzing the abstract syntax tree of the static program so as to record the operations on the video memory; whether a pointer is available or a video memory address which is not released is analyzed in the pointer address mapping set; and
and the kernel function execution time module is used for capturing kernel function execution names needing to be counted through corresponding interfaces, capturing the kernel function execution names before the target kernel function of the application program is executed, inserting CPU/GPU time measurement code segments, summarizing the counted time when the program is finished running, and displaying the collected time.
2. The system of claim 1, wherein the video memory leak analysis module specifically detects the following video memory leak types: (1) the applied memory space is forgotten to be released: aiming at calling only cudaMalloc and hipMalloc, and calling cudaFree and hipFare without matching; (2) the applied video memory space is released for multiple times: the cudaFree and hippree are called for releasing for multiple times aiming at the same video memory space of the application; (3) "field space": the pointer after the space is applied through cudaMalloc and hipCalloc changes the value of the pointer through other assignment operations, so that the video memory space applied at the beginning cannot be reached, and leakage is caused.
3. The system of claim 1, wherein the graphics memory leak analysis module is specifically configured to abstract source program code into a SPAN program intermediate expression, and then analyze SPAN.
4. The system of claim 1, wherein the video memory leak analysis module further uses video memory leak fault detection, comprising:
(1) converting a source program into a source program abstract node set;
(2) constructing an abstract node tree according to the source program abstract node set;
(3) starting to analyze from the root node of the abstract node tree, and establishing and maintaining a pointer address mapping Set according to 3P-M Set operation functions in the analyzing process;
(4) executing a check function after the leaf node is executed, and returning a corresponding result;
(5) deeply traversing the abstract node tree;
(6) and (5) circulating the steps (3) to (5) until the depth traversal is completed.
5. An application performance analysis method is characterized by comprising the following steps:
the method comprises the steps of performing addition, deletion and change operations on a pointer address mapping set by analyzing an abstract syntax tree of a static program to record the operation on the video memory; whether a pointer is available or a video memory address which is not released is analyzed in the pointer address mapping set; and
capturing kernel function execution names needing to be counted through corresponding interfaces, capturing before target kernel functions of application programs are executed, inserting CPU/GPU time measurement code segments, summarizing counted time when the programs are operated, and displaying.
6. The method of claim 5, wherein the following types of memory leaks are detected: (1) the applied memory space is forgotten to be released: aiming at calling only cudaMalloc and hipMalloc, and calling cudaFree and hipFare without matching; (2) the applied video memory space is released for multiple times: the cudaFree and hippree are called for releasing for multiple times aiming at the same video memory space of the application; (3) "field space": the pointer after the space is applied through cudaMalloc and hipCalloc changes the value of the pointer through other assignment operations, so that the video memory space applied at the beginning cannot be reached, and leakage is caused.
7. The method of claim 5, wherein the source program code is abstracted into SPAN program intermediate expressions, and SPAN is analyzed.
8. The method of claim 5, further comprising the step of detecting a memory leak fault, comprising the steps of:
(1) converting a source program into a source program abstract node set;
(2) constructing an abstract node tree according to the source program abstract node set;
(3) starting to analyze from the root node of the abstract node tree, and establishing and maintaining a pointer address mapping Set according to 3P-M Set operation functions in the analyzing process;
(4) executing a check function after the leaf node is executed, and returning a corresponding result;
(5) deeply traversing the abstract node tree;
(6) and (5) circulating the steps (3) to (5) until the depth traversal is completed.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202010383480.XA CN111611158A (en) | 2020-05-08 | 2020-05-08 | Application performance analysis system and method |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202010383480.XA CN111611158A (en) | 2020-05-08 | 2020-05-08 | Application performance analysis system and method |
Publications (1)
| Publication Number | Publication Date |
|---|---|
| CN111611158A true CN111611158A (en) | 2020-09-01 |
Family
ID=72201487
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN202010383480.XA Pending CN111611158A (en) | 2020-05-08 | 2020-05-08 | Application performance analysis system and method |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN111611158A (en) |
Cited By (2)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN112083956A (en) * | 2020-09-15 | 2020-12-15 | 哈尔滨工业大学 | Heterogeneous platform-oriented automatic management system for complex pointer data structure |
| WO2023143426A1 (en) * | 2022-01-28 | 2023-08-03 | 清华大学 | Performance analysis programming framework, method and apparatus |
Citations (6)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US5590329A (en) * | 1994-02-04 | 1996-12-31 | Lucent Technologies Inc. | Method and apparatus for detecting memory access errors |
| CN101017458A (en) * | 2007-03-02 | 2007-08-15 | 北京邮电大学 | Software safety code analyzer based on static analysis of source code and testing method therefor |
| CN104133733A (en) * | 2014-07-29 | 2014-11-05 | 北京航空航天大学 | Memory error detection method |
| US20150169226A1 (en) * | 2013-12-17 | 2015-06-18 | Xipeng Shen | Technologies for persistent memory programming |
| CN106294156A (en) * | 2016-08-11 | 2017-01-04 | 北京邮电大学 | A kind of static code fault detection analysis method and device |
| CN107608885A (en) * | 2017-09-13 | 2018-01-19 | 郑州云海信息技术有限公司 | Localization method, device, system and the readable storage medium storing program for executing of memory overflow point |
-
2020
- 2020-05-08 CN CN202010383480.XA patent/CN111611158A/en active Pending
Patent Citations (6)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US5590329A (en) * | 1994-02-04 | 1996-12-31 | Lucent Technologies Inc. | Method and apparatus for detecting memory access errors |
| CN101017458A (en) * | 2007-03-02 | 2007-08-15 | 北京邮电大学 | Software safety code analyzer based on static analysis of source code and testing method therefor |
| US20150169226A1 (en) * | 2013-12-17 | 2015-06-18 | Xipeng Shen | Technologies for persistent memory programming |
| CN104133733A (en) * | 2014-07-29 | 2014-11-05 | 北京航空航天大学 | Memory error detection method |
| CN106294156A (en) * | 2016-08-11 | 2017-01-04 | 北京邮电大学 | A kind of static code fault detection analysis method and device |
| CN107608885A (en) * | 2017-09-13 | 2018-01-19 | 郑州云海信息技术有限公司 | Localization method, device, system and the readable storage medium storing program for executing of memory overflow point |
Non-Patent Citations (4)
| Title |
|---|
| 叶俊民等: "内存泄漏故障静态分析研究", 《计算机科学》 * |
| 张威等: "基于指针分析的内存泄露故障测试方法研究", 《计算机应用研究》 * |
| 张威等: "基于指针映射集的动态内存故障测试方法研究", 《计算机学报》 * |
| 程润伟等: "《CUDA C编程权威指南》", 30 June 2017 * |
Cited By (3)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN112083956A (en) * | 2020-09-15 | 2020-12-15 | 哈尔滨工业大学 | Heterogeneous platform-oriented automatic management system for complex pointer data structure |
| CN112083956B (en) * | 2020-09-15 | 2022-12-09 | 哈尔滨工业大学 | Heterogeneous platform-oriented automatic management system for complex pointer data structure |
| WO2023143426A1 (en) * | 2022-01-28 | 2023-08-03 | 清华大学 | Performance analysis programming framework, method and apparatus |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| CN112100054B (en) | Data management and control oriented program static analysis method and system | |
| CN102073589B (en) | Code static analysis-based data race detecting method and system thereof | |
| CN100517235C (en) | Method and system for detecting potential race conditions in multithreaded programs | |
| CN110941528B (en) | Log buried point setting method, device and system based on fault | |
| CN101710378B (en) | Software security flaw detection method based on sequential pattern mining | |
| CN100405294C (en) | System, method and program product to optimize code during run time | |
| US8504996B2 (en) | Method and computer programming product for detecting memory leaks | |
| CN108153587B (en) | Slow task reason detection method for big data platform | |
| CN102063328B (en) | System for detecting interrupt-driven type program data competition | |
| CN102243609A (en) | Embedded software-based test analysis method and system | |
| US20120054722A1 (en) | Trace generating unit, system, and program of the same | |
| US8141082B2 (en) | Node-based representation of multi-threaded computing environment tasks, and node-based data race evaluation | |
| CN111611158A (en) | Application performance analysis system and method | |
| CN103186463B (en) | Determine the method and system of the test specification of software | |
| CN116431476A (en) | JVM fuzzy test method based on code context variation | |
| US20040128661A1 (en) | Automatic data locality optimization for non-type-safe languages | |
| CN114816971A (en) | Data processing method, related equipment and storage medium | |
| CN112445706A (en) | Program abnormal code acquisition method and device, electronic equipment and storage medium | |
| CN115456628A (en) | Intelligent contract viewing method and device based on block chain, storage medium and equipment | |
| CN115098355A (en) | Historical data drive-based JVM test program generation method | |
| CN111666216B (en) | Intelligent contract analysis method and device | |
| CN112445512A (en) | Hotspot analysis method and device for program codes | |
| CN111984311A (en) | Software structure reproduction method based on running log | |
| CN113204765B (en) | Method and system for testing HyperLegger Fabric chain code | |
| CN109308256A (en) | A kind of java dynamically analyzing of program method, equipment and storage medium |
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 |