CN115185818A - Program dependence cluster detection method based on binary set - Google Patents
Program dependence cluster detection method based on binary set Download PDFInfo
- Publication number
- CN115185818A CN115185818A CN202210697962.1A CN202210697962A CN115185818A CN 115185818 A CN115185818 A CN 115185818A CN 202210697962 A CN202210697962 A CN 202210697962A CN 115185818 A CN115185818 A CN 115185818A
- Authority
- CN
- China
- Prior art keywords
- dependency
- data
- program
- operation interface
- binary
- 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
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/3604—Software analysis for verifying properties of programs
Landscapes
- Engineering & Computer Science (AREA)
- Theoretical Computer Science (AREA)
- Software Systems (AREA)
- Computer Hardware Design (AREA)
- Quality & Reliability (AREA)
- Physics & Mathematics (AREA)
- General Engineering & Computer Science (AREA)
- General Physics & Mathematics (AREA)
- Stored Programmes (AREA)
Abstract
The invention discloses a program dependence cluster detection method based on a binary system set, which comprises the following steps: defining a dependency set by a data structure in a binary set form, inputting a general set operation interface based on bit operation to obtain new dependency set data, storing the new dependency set data to each instruction node of a general set operation interface program, and traversing each instruction node of the program; calculating the dependency relationship among the instructions by using a general set operation interface to obtain dependency analysis data of each instruction node; and recombining and classifying the obtained dependency analysis result according to the set content in the new set data, obtaining the corrected dependency analysis result and realizing correct detection of the program dependency cluster in the program source code. The invention defines a set data structure by a binary set, defines an operation interface according to the data structure, calls the interface to calculate dependence, corrects the dependence result, and stores the correction result, thereby remarkably reducing the problem of space overhead during analysis.
Description
Technical Field
The invention belongs to the field of detection program analysis, and particularly relates to a program dependence cluster detection method based on a binary system set.
Background
With the continuous increase of the software scale, the difficulty of software operation and maintenance is also increasing. One important reason is that inevitable interdependencies exist among the program components of the software, the interdependencies form a program dependency cluster, and the accurate detection of the dependency cluster widely existing in the program is of great significance to the work of software understanding, testing, maintenance and the like.
At present, the research at home and abroad focuses on analyzing the formation reason of the program-dependent cluster, and how to improve the program-dependent cluster detection method is not further researched. A traditional dependency cluster detection algorithm needs to be based on a System Dependency Graph (SDG), wherein the SDG is a graph representation of control dependency and data dependency among software programs, edges represent the dependency, unique identifications (Id) of nodes represent an element of a dependency set, during detection, the dependency relationship of each node is collected through a reachability traversal algorithm of the graph, finally, dependency analysis results of all the nodes are integrated to obtain slicing criteria with the same dependency set, and the nodes corresponding to the criteria are mutually dependent, so that a dependency cluster in the program is detected. However, the SDG construction process is complex and difficult to understand, especially when analyzing inter-process dependency relationships, the construction process needs to consider different parameter transmission situations, the above process often generates huge time overhead, and meanwhile, the unique identifier of the SDG node is used to identify one element of the corresponding dependency set, and especially for a large program containing many SDG nodes, the problem of space occupation is more significant, so the SDG-based dependency cluster detection method cannot meet the requirement of dependency cluster detection and analysis for the large program in terms of time and space efficiency.
Disclosure of Invention
The purpose of the invention is as follows: in order to overcome the defects in the prior art, the invention provides a program dependency cluster detection method based on a binary system set, wherein the binary system set defines a set data structure, defines an operation interface according to the data structure, calls the interface to calculate dependency, corrects a dependency result, and stores a correction result, so that the space overhead during analysis is remarkably reduced, and the problem of overlarge space-time overhead under the traditional detection method is solved.
The technical scheme is as follows: the invention provides a program dependent cluster detection method based on a binary set, which comprises the following steps:
defining a dependency set by a data structure in a binary set form, and inputting the dependency set data in the binary set form into a general set operation interface based on bit operation to obtain new dependency set data;
storing the new dependent set data to each instruction node of the general set operation interface program, and traversing each instruction node of the program; during traversal, calculating the dependency relationship among the instructions by using a general set operation interface to obtain dependency analysis data of each instruction node;
after each instruction node is traversed, recombining and classifying the obtained dependency analysis result according to the set content in the new set data to obtain a corrected dependency analysis result;
and according to the corrected dependency analysis result, correctly detecting the program dependency cluster in the program source code.
In a further embodiment, the data structure is in a binary form, the minimum unit of the data structure is a bit, and an extended integer method is adopted for integer representation, so as to replace the traditional integer representation of 0 to 64 bits, and the extended integer method of the data structure is as follows:
and carrying out bit operation and serialization processing on the data structure by adopting a primary basic data type Integer in a functional programming language Haskell to obtain infinite extension of the storage length of the data structure.
In a further embodiment, the basic representation method of dependent aggregate data: and representing an empty set by 0, and representing a non-empty set by an integer binary string, wherein in the case of the non-empty set, the storage condition of the element of the dependent set data is judged according to 0 or 1 of the binary string.
In a further embodiment, inputting the dependency set data in the form of binary set into a general set operation interface based on bit operation to obtain new dependency set data further comprises predefining the general set operation interface;
the method for defining the universal set operation interface comprises the following steps:
inputting the associated element value of the operation interface and judging whether the element value belongs to the general set of the operation interface;
and according to the judgment result, selecting to add element values without the relationship to the general set of the operation interface, thereby merging the general sets before and after the judgment, wherein the merged general set does not contain repeated element values, and finally defining the operation interface associated with the new element value as the general set operation interface.
In a further embodiment, the universal set operation interfaces each process input dependent set data based on bit operations having a plurality of operation classes, including: and (&), or (|), shift to the right (>), shift to the left (< >.
In a further embodiment, each instruction node of the program is traversed; during traversal, the method for calculating the dependency relationship among the instructions by using the universal set operation interface to obtain the dependency analysis data of each instruction node comprises the following steps:
the dependency set data utilizes a general set operation interface to calculate program dependency data of the related dependency set data under each instruction node, and dependency analysis data of each instruction node is obtained; the dependency comprises data dependency existing among the instructions due to definition use relation of variables and control dependency existing among the instructions due to jump relation;
and storing the dependency analysis data of each instruction node by using key value pair type data, wherein the unique label of each instruction is taken as an index key in the stored dependency analysis data, and the binary stored dependency set data is used as an index value.
In a further embodiment, the method of obtaining the corrected dependency analysis result by recombining and classifying the stored dependency analysis results comprises:
extracting the data stream value of each instruction node, and indexing by using key values when extracting the dependency analysis result so as to inquire a dependency set corresponding to each instruction node;
remapping the key-value pair relation associated with the query dependency set to obtain a remapped key-value pair relation;
re-indexing according to the re-mapped key-value pair relationship, extracting key-value pairs of the same index key and combining the key-value pairs of the same index key to obtain a recombined and combined key-value pair relationship, and finishing the correction of the dependency analysis result;
and the corrected dependency analysis result is a standard for detecting whether the program dependency cluster in the program source code is correct or not.
In a further embodiment, the method for data persistent caching depending on cluster detection results comprises:
and quickly storing the integer data in a local hard disk and a distributed database by using a serialization method supported by the native in the Haskell language, wherein a Python algorithm is used for caching in the storage process, and only the integer serialization method supported by the native is required to be called in the caching process.
In a further embodiment, the method for correctly detecting the program dependent cluster in the program source code according to the corrected dependency analysis result includes:
performing data persistent cache on the detection result of the program dependence cluster, and directly performing subsequent loading of the dependence analysis result when the same program is analyzed subsequently;
when program dependence cluster analysis starts, loading historical dependence relationship analysis results which are cached in a local hard disk and a distributed database;
and after the program dependence cluster analysis is finished, repeatedly storing the complete dependence cluster analysis result for subsequent loading access according to needs.
Has the beneficial effects that: compared with the prior art, the invention has the following advantages:
(1) Binary set representations have significant advantages in both time efficiency and space occupation. Meanwhile, compared with a common set compression method such as a binary decision diagram, the method has lower time complexity based on inter-set operation of bit operation, is easier to serialize and deserialize, is beneficial to caching and reloading intermediate calculation results, defines a set data structure by a binary set, defines an operation interface according to the data structure, calls interface calculation dependence, and corrects the dependence result, thereby remarkably reducing the space overhead of analysis.
(2) Compared with a method for constructing a huge system dependency graph and detecting program dependency clusters by using a reachability traversal algorithm of the graph, the method disclosed by the invention uses bit operation to instantiate a series of set operations to merge control dependency and data dependency in a binary representation form, so that the program dependency clusters can be correctly detected, and the time and space overhead of analysis is greatly reduced.
Drawings
FIG. 2 is a block diagram of a binary set-based program dependent cluster detection method according to the present invention.
FIG. 1 is a process for caching and loading program dependent clusters according to the present invention.
Detailed Description
In order to more fully understand the technical content of the present invention, the technical solution of the present invention will be further described and illustrated with reference to the following specific embodiments, but not limited thereto.
A method for detecting program dependent clusters based on binary set as shown in fig. 1 includes:
defining a dependency set by a data structure in a binary set form, and inputting the dependency set data in the binary set form into a general set operation interface based on bit operation to obtain new dependency set data;
storing the new dependency set data to each instruction node of the general set operation interface program, and traversing each instruction node of the program; during traversal, calculating the dependency relationship among the instructions by using a general set operation interface to obtain dependency analysis data of each instruction node;
after each instruction node is traversed, recombining and classifying the obtained dependency analysis result according to the set content in the new set data to obtain a corrected dependency analysis result;
and according to the corrected dependency analysis result, correctly detecting the program dependency cluster in the program source code.
The data structure is in a binary form, the minimum unit of the data structure is a bit, and the integer representation is carried out by adopting an extended integer method, so that the traditional integer representation of 0 to 64 bits is replaced, wherein the extended integer method of the data structure comprises the following steps:
and (3) carrying out bit operation and serialization processing on the data structure by adopting a native basic data type Integer in a functional programming language Haskell to obtain infinite extension of the storage length of the data structure.
Basic representation method of dependent set data: and representing an empty set by 0, and representing a non-empty set by an integer binary string, wherein in the case of the non-empty set, the storage condition of the element of the dependent set data is judged according to 0 or 1 of the binary string.
Inputting the dependency set data in the form of binary set into a general set operation interface based on bit operation to obtain new dependency set data, and also comprising a predefined general set operation interface;
the method for defining the universal set operation interface comprises the following steps:
inputting the associated element value of the operation interface and judging whether the element value belongs to the general set of the operation interface;
and according to the judgment result, selecting to add element values without the affiliation to the general set of the operation interface, thereby merging the general sets before and after the judgment, wherein the merged general set does not contain repeated element values, and finally defining the operation interface associated with the new element value as the general set operation interface.
The universal set operation interfaces each process input dependent set data based on bit operations having a plurality of operation categories, including: and (&), or (|), shift to the right (>), shift to the left (<).
The main idea of binary set representation method is to use bit 0 or 1 to represent whether the corresponding position number belongs to the element in the set, and since the range of the corresponding unique identifier (integer) of each variable in the source code is determined, the dependency set represented by any binary form is a subset of a full set a, which is represented by a full 1 binary integer.
For example, a = [0,1,2,3,4,5,6,7,8,9], the binary representation of which is 1111111111. The representation underlying data structure uses the native primitive data type Integer in Haskell, which can support infinite length Integer data.
Assuming that A1 = [2,4,6], A2= [1,3,5] are two subsets of a, based on the idea that 0/1 represents a number set, it can be obtained that a binary set corresponding to A1 is represented as 0001010100, a binary set corresponding to A2 is represented as 0000101010, it should be noted that the insertion order of elements is from right to left, subscripts start from 0, and if a number 1 on a 0 bit from right to left represents a number 0.
A1 \200A2, which can be obtained by using bitwise AND operation to obtain 0001010100 | 0000101010 = 0001111110, the representation of the corresponding set is [1,2,3,4,5,6], which is in line with the expectation of the merging result of the two sets.
Traversing each instruction node of the program; during traversal, the method for calculating the dependency relationship among the instructions by using the universal set operation interface to obtain the dependency analysis data of each instruction node comprises the following steps:
the dependency set data utilizes a general set operation interface to calculate program dependency data of the related dependency set data under each instruction node, and dependency analysis data of each instruction node is obtained; the dependencies comprise data dependencies existing among the instructions due to definition use relations of variables and control dependencies existing among the instructions due to jump relations;
and storing the dependency analysis data of each instruction node by using key value pair type data, wherein the unique label of each instruction is taken as an index key in the stored dependency analysis data, and the binary stored dependency set data is used as an index value.
The method for recombining and classifying the stored dependency analysis result to obtain the corrected dependency analysis result comprises the following steps:
extracting the data stream value of each instruction node, and indexing by using key values when extracting the dependency analysis result so as to query a dependency set corresponding to each instruction node;
remapping the key-value pair relation associated with the query dependency set to obtain a remapped key-value pair relation;
re-indexing according to the re-mapped key-value pair relationship, extracting key-value pairs of the same index key and combining the key-value pairs of the same index key to obtain a recombined and combined key-value pair relationship, and finishing the correction of the dependency analysis result;
and the corrected dependency analysis result is a standard for detecting whether the program dependency cluster in the program source code is correct or not.
Specifically, in the face of the problem of insufficient computing power of a large program dependent cluster detection analysis task, map Reduce, namely a mapping-reduction idea, can be performed on a distributed computing cluster by using an open-source cloud computing framework, so that remapping of the key-value pairs in the step 4.1 according to the slicing criterion and the variable unique identifier (integer) is realized, and the dependent set > is performed, so as to obtain a new key-value pair: and (4) carrying out reduction (Reduce process) simultaneously so that the slice criteria with the same slice result can be clustered, thereby realizing the detection of the program dependent cluster.
Meanwhile, the dependence set uses a binary set representation form, so that intermediate results obtained in the Map Reduce process are convenient to transmit among all nodes, network load is reduced, a single integer is used as a key, the internal sequencing comparison process is accelerated, and the efficiency of distributed computation is improved.
The method for carrying out data persistent caching on the dependence cluster detection result comprises the following steps:
and quickly storing the integer data in a local hard disk and a distributed database by using a serialization method supported by the native in the Haskell language, wherein a Python algorithm is used for caching in the storage process, and only the integer serialization method supported by the native is required to be called in the caching process.
According to the corrected dependency analysis result, the method for correctly detecting the program dependency cluster in the program source code comprises the following steps:
performing data persistent cache on the detection result of the program dependence cluster, and directly performing subsequent loading of the dependence analysis result when the same program is analyzed subsequently;
when program dependence cluster analysis starts, loading historical dependence relationship analysis results which are cached in a local hard disk and a distributed database;
and after the program dependence cluster analysis is finished, repeatedly storing the complete dependence cluster analysis result for subsequent loading access according to needs.
Specifically, caching is the process of converting dependent cluster information that is not temporarily required to participate in computation into a form that can be stored or transmitted according to the analysis needs. The loading process is a process of reading the dependent cluster information from the Storage area and continuing analysis, and the process can utilize networked transmission or local Storage to perform corresponding operations, such as utilizing a local database, a database based on a master-slave mode in a distributed environment, an NAS (Network Attached Storage) and the like.
The binary set representation of the present invention has significant advantages in both time efficiency and space occupation. Meanwhile, compared with a common set compression method such as a binary decision diagram, the method has lower time complexity based on inter-set operation of bit operation, is easier to serialize and deserialize, is beneficial to caching and reloading intermediate calculation results, defines a set data structure by a binary set, defines an operation interface according to the data structure, calls interface calculation dependence, and corrects the dependence result, thereby remarkably reducing the space overhead of analysis.
Compared with a method for constructing a huge system dependency graph and detecting program dependency clusters by using a reachability traversal algorithm of the graph, the method disclosed by the invention uses bit operation to instantiate a series of set operations to merge control dependency and data dependency in a binary representation form, so that not only can the program dependency clusters be correctly detected, but also the time space overhead of analysis is greatly reduced.
Embodiments of the present application may be provided as methods, systems, or computer program products. Accordingly, the present application may take the form of an entirely hardware embodiment, an entirely software embodiment or an embodiment combining software and hardware aspects. Furthermore, the present application may take the form of a computer program product embodied on one or more computer-usable storage media (including, but not limited to, disk storage, CD-ROM, optical storage, and the like) having computer-usable program code embodied therein.
Embodiments of the present application may be provided as methods, systems, or computer program products. Accordingly, the present application may take the form of an entirely hardware embodiment, an entirely software embodiment or an embodiment combining software and hardware aspects. Furthermore, the present application may take the form of a computer program product embodied on one or more computer-usable storage media (including, but not limited to, disk storage, CD-ROM, optical storage, and the like) having computer-usable program code embodied therein.
The present application is described with reference to flowchart illustrations and/or block diagrams of methods, apparatus (systems), and computer program products according to embodiments of the application. It will be understood that each flow and/or block of the flow diagrams and/or block diagrams, and combinations of flows and/or blocks in the flow diagrams and/or block diagrams, can be implemented by computer program instructions. These computer program instructions may be provided to a processor of a general purpose computer, special purpose computer, embedded processor, or other programmable data processing apparatus to produce a machine, such that the instructions, which execute via the processor of the computer or other programmable data processing apparatus, create means for implementing the functions specified in the flowchart flow or flows and/or block diagram block or blocks.
These computer program instructions may also be stored in a computer-readable memory that can direct a computer or other programmable data processing apparatus to function in a particular manner, such that the instructions stored in the computer-readable memory produce an article of manufacture including instruction means which implement the function specified in the flowchart flow or flows and/or block diagram block or blocks.
These computer program instructions may also be loaded onto a computer or other programmable data processing apparatus to cause a series of operational steps to be performed on the computer or other programmable apparatus to produce a computer implemented process such that the instructions which execute on the computer or other programmable apparatus provide steps for implementing the functions specified in the flowchart flow or flows and/or block diagram block or blocks.
The above description is only a preferred embodiment of the present invention, and several modifications and variations can be made without departing from the technical principle of the present invention, and should be regarded as the protection scope of the present invention.
Claims (9)
1. A program dependent cluster detection method based on binary set is characterized by comprising the following steps:
defining a dependency set by a data structure in a binary set form, and inputting the dependency set data in the binary set form into a general set operation interface based on bit operation to obtain new dependency set data;
storing the new dependency set data to each instruction node of the general set operation interface program, and traversing each instruction node of the program; during traversal, calculating the dependency relationship among the instructions by using a general set operation interface to obtain dependency analysis data of each instruction node;
after each instruction node is traversed, recombining and classifying the obtained dependency analysis result according to the set content in the new set data to obtain a corrected dependency analysis result;
and according to the corrected dependency analysis result, correctly detecting the program dependency cluster in the program source code.
2. The method according to claim 1, wherein the data structure is in a binary form, the minimum unit of the data structure is a bit, and an extended integer method is used for integer representation, so as to replace the traditional integer representation of 0 to 64 bits, and the extended integer method of the data structure is as follows:
and carrying out bit operation and serialization processing on the data structure by adopting a primary basic data type Integer in a functional programming language Haskell to obtain infinite extension of the storage length of the data structure.
3. The method of claim 1, wherein the basic representation method of the dependent set data comprises: and 0 is used for representing an empty set, and an integer binary string is used for representing a non-empty set, wherein in the case of the non-empty set, the storage condition of the elements of the dependent set data is judged according to 0 or 1 of the binary string.
4. The method for detecting the program dependency cluster based on the binary set according to claim 1, wherein the step of inputting the dependency set data in the form of the binary set into a general set operation interface based on bit operation to obtain new dependency set data further comprises the step of predefining the general set operation interface;
the method for defining the universal set operation interface comprises the following steps:
inputting the associated element value of the operation interface and judging whether the element value belongs to the general set of the operation interface;
and according to the judgment result, selecting to add element values without the affiliation to the general set of the operation interface, thereby merging the general sets before and after the judgment, wherein the merged general set does not contain repeated element values, and finally defining the operation interface associated with the new element value as the general set operation interface.
5. The method of claim 1, wherein the universal set operation interface processes the input dependent set data based on bit operations, the bit operations having a plurality of operation categories, comprising: and (&), or (|), shift to the right (>), shift to the left (< >.
6. The binary set based program dependency cluster detection method of claim 1, wherein each instruction node of the program is traversed; during traversal, the method for calculating the dependency relationship among the instructions by using the universal set operation interface to obtain the dependency analysis data of each instruction node comprises the following steps:
the dependency set data utilizes a general set operation interface to calculate program dependency data of the related dependency set data under each instruction node, and dependency analysis data of each instruction node is obtained; the dependency comprises data dependency existing among the instructions due to definition use relation of variables and control dependency existing among the instructions due to jump relation;
and storing the dependency analysis data of each instruction node by using key value pairs as type data, wherein the unique label of each instruction in the stored dependency analysis data is taken as an index key, and the binary stored dependency set data is taken as an index value.
7. The method for detecting program dependence clusters based on binary sets according to claim 1, wherein the method for obtaining the corrected dependence analysis results by recombining and classifying the stored dependence analysis results comprises:
extracting the data stream value of each instruction node, and indexing by using key values when extracting the dependency analysis result so as to query a dependency set corresponding to each instruction node;
remapping the key-value pair relation associated with the query dependency set to obtain a remapped key-value pair relation;
re-indexing according to the re-mapped key-value pair relation, extracting key-value pairs of the same index key and combining the key-value pairs of the same index key to obtain a recombined and combined key-value pair relation, and completing correction of a dependency analysis result;
and the corrected dependency analysis result is a standard for detecting whether the program dependency cluster in the program source code is correct or not.
8. The method for detecting the program dependent cluster based on the binary set as claimed in claim 1, wherein the method for caching the data of the dependent cluster detection result comprises:
and quickly storing the integer data in a local hard disk and a distributed database by using a serialization method supported by the native in the Haskell language, wherein a Python algorithm is used for caching in the storage process, and only the integer serialization method supported by the native is required to be called in the caching process.
9. The method for detecting the program dependent cluster based on the binary set as claimed in claim 1, wherein the method for correctly detecting the program dependent cluster in the program source code according to the corrected dependency analysis result comprises:
performing data persistent cache on the detection result of the program dependence cluster, and directly performing subsequent loading of the dependence analysis result when the same program is analyzed subsequently;
when program dependence cluster analysis starts, loading historical dependence relationship analysis results which are cached in a local hard disk and a distributed database;
and after the program dependence cluster analysis is finished, repeatedly storing the complete dependence cluster analysis result for subsequent loading access according to needs.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202210697962.1A CN115185818A (en) | 2022-06-20 | 2022-06-20 | Program dependence cluster detection method based on binary set |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202210697962.1A CN115185818A (en) | 2022-06-20 | 2022-06-20 | Program dependence cluster detection method based on binary set |
Publications (1)
| Publication Number | Publication Date |
|---|---|
| CN115185818A true CN115185818A (en) | 2022-10-14 |
Family
ID=83513724
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN202210697962.1A Pending CN115185818A (en) | 2022-06-20 | 2022-06-20 | Program dependence cluster detection method based on binary set |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN115185818A (en) |
Cited By (2)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN115794120A (en) * | 2023-02-06 | 2023-03-14 | 南京邮电大学 | Dynamic program dependence cluster detection method based on high-order function |
| CN117421252A (en) * | 2023-12-18 | 2024-01-19 | 荣耀终端有限公司 | Code detection method, device and computer readable storage medium |
-
2022
- 2022-06-20 CN CN202210697962.1A patent/CN115185818A/en active Pending
Cited By (3)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN115794120A (en) * | 2023-02-06 | 2023-03-14 | 南京邮电大学 | Dynamic program dependence cluster detection method based on high-order function |
| CN117421252A (en) * | 2023-12-18 | 2024-01-19 | 荣耀终端有限公司 | Code detection method, device and computer readable storage medium |
| CN117421252B (en) * | 2023-12-18 | 2024-05-31 | 荣耀终端有限公司 | Code detection method, device and computer readable storage medium |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| CN115185818A (en) | Program dependence cluster detection method based on binary set | |
| US7831594B2 (en) | Estimating the static execution time of a database query | |
| US10394694B2 (en) | Unexplored branch search in hybrid fuzz testing of software binaries | |
| CN107612886A (en) | A kind of Spark platforms Shuffle process compresses algorithm decision-making techniques | |
| CN107908536B (en) | Performance evaluation method and system for GPU application in CPU-GPU heterogeneous environment | |
| CN110908789B (en) | Visual data configuration method and system for multi-source data processing | |
| CN113965389B (en) | Network security management method, device and medium based on firewall log | |
| CN114691148B (en) | Model reasoning acceleration method, device, electronic equipment and storage medium | |
| CN102541736A (en) | Acceleration test method in software reliability execution process | |
| CN116368494A (en) | Neural network compiling optimization method and related device | |
| CN107025273A (en) | Data query optimization method and device | |
| CN111078573A (en) | Test message generation method and device | |
| CN110264392A (en) | A kind of strongly connected graph detection method based on more GPU | |
| CN116680258B (en) | Data processing method and system based on PDM system and readable storage medium | |
| CN115033434B (en) | Method and device for calculating kernel performance theoretical value and storage medium | |
| CN115221045A (en) | Multi-target software defect prediction method based on multi-task and multi-view learning | |
| CN109976802B (en) | Mode-oriented software architecture reconstruction method | |
| CN114138330A (en) | Code clone detection optimization method and device based on knowledge graph and electronic equipment | |
| CN111881128B (en) | Big data regression verification method and big data regression verification device | |
| CN116629348B (en) | Intelligent workshop data acquisition and analysis method and device and computer equipment | |
| CN117312350B (en) | Steel industry carbon emission data management method and device | |
| US11823065B2 (en) | Enterprise market volatility predictions through synthetic DNA and mutant nucleotides | |
| US11823064B2 (en) | Enterprise market volatility prediction through synthetic DNA and mutant nucleotides | |
| CN111813845B (en) | Incremental data extraction method, device, equipment and medium based on ETL task | |
| CN115510170A (en) | Real-time index calculation method based on financial data incremental calculation |
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 |