CN114996111A - Method and system for analyzing influence of configuration items on performance of software system - Google Patents

Abstract

The present invention provides a method and system for analyzing the impact of configuration items on software system performance, wherein the method includes: identifying and marking all performance operations in the software system according to a preset code pattern of the software system, and the performance operations are those that affect the performance of the software system. Time-intensive operations and/or space-intensive operations; identify the dependencies between each performance operation and each configuration item of the software system, and obtain the performance operation set corresponding to each configuration item; build the feature corresponding to each configuration item according to the performance operation set Vector; input the feature vector corresponding to each configuration item into the trained qualitative performance impact model, determine whether the configuration item affects the performance of the software system, and obtain the set of configuration items that affect the performance of the software system. The invention can discover the set of configuration items that really affects the performance of the software system without running the software system, can improve the efficiency of the software system configuration, and is beneficial to correctly configure the software system to improve the performance of the software system.

Description

A method and system for analyzing the impact of configuration items on software system performance

technical field

The invention relates to the technical field of software systems, in particular to a method and system for analyzing the influence of configuration items on the performance of software systems.

Background technique

The software system of a computer refers to various programs, data and related documents that the computer is running, including system software, supporting software and application software. A large number of modern software systems are designed as highly customizable systems, which can be configured according to the hardware platform, operating system and user needs used by the user, and can meet the user's software function or performance needs.

However, there are many software system configuration items, and some configuration items also have dependencies. The complexity of software system configuration makes adjusting software system configuration a huge challenge. Studies have shown that the misconfiguration of software systems has become one of the main reasons for system failures and system performance problems. Misconfiguration of software systems can have serious consequences, and misconfiguration of commercial storage systems and open source operating systems can cause hard-to-diagnose system crashes, hangs, or severe performance degradation.

In addition to common software system configuration errors, it is often difficult for users to clearly understand the actual impact of changing a configuration item on the software system. Therefore, users are usually forced to adjust the software system configuration in a time-consuming way of a lot of trial and error, resulting in inconsistent software system configuration. low efficiency.

SUMMARY OF THE INVENTION

The purpose of the present invention is to provide a method and system for analyzing the influence of configuration items on software system performance, so as to solve the technical problems of software system configuration errors and low configuration efficiency in the prior art.

The object of the present invention can be realized by the following technical solutions:

A method for analyzing the impact of configuration items on software system performance, including:

Identify and mark all performance operations in the software system according to a code pattern preset by the software system, where the performance operations are time-intensive operations and/or space-intensive operations that affect the performance of the software system;

Identify the dependency between each of the performance operations and each configuration item of the software system, and obtain a performance operation set corresponding to each of the configuration items, and each performance operation in the performance operation set has the same configuration as the configuration item. dependencies;

constructing a feature vector corresponding to each of the configuration items according to the performance operation set;

Input the feature vector corresponding to each of the configuration items into the trained qualitative performance impact model, determine whether the configuration item affects the performance of the software system, and obtain a set of configuration items that affect the performance of the software system, the qualitative performance impact model is to use It is obtained by training the feature vectors corresponding to the configuration items of multiple software systems.

Optionally, the qualitative performance impact model includes:

Random forest classification model and configuration item dependency detector;

Wherein, the random forest classification model performs binary classification on whether the configuration item affects the performance of the software system, and the configuration item depends on the detector to correct the classification result of the random forest classification model.

Optionally, the dependencies include:

Data dependencies and control dependencies;

The data dependencies are dependencies between data streams, and the control dependencies are dependencies caused by program control flows.

Optionally, identifying the dependencies between the performance operations and the configuration items of the software system includes:

Identify data dependencies between each of the performance operations and each configuration item of the software system by using taint analysis;

The program dependency graph is used to identify the control dependency relationship between each of the performance operations and the configuration items of the software system; the program dependency graph is constructed by using the program dependency analysis technology to describe the control dependency and data dependency of the program relation.

Optionally, using taint analysis to identify data dependencies between each of the performance operations and each configuration item of the software system includes:

Enter the program entry of the software system, traverse the control flow, and create a taint at the configuration item loading API as a source point;

Record the data propagation path of the source point and the finally reached sink point, then the performance operation at the sink point has a data dependency on the configuration item; the sink point is the program statement that the source point is not expected to reach, so The sink point is preset before the statement corresponding to the performance operation.

Optionally, identifying the control dependency between each of the performance operations and each configuration item of the software system by using a program dependency graph includes:

Traverse all the nodes in the program dependency graph, and construct the control area of each configuration item, where the control area of the configuration item is a statement sequence that has a direct control dependency relationship with the configuration item;

A control dependency relationship between each of the performance operations and each of the configuration items of the software system is identified according to the control area of each of the configuration items.

Optionally, the training process of the random forest classification model includes:

Divide the feature vectors corresponding to the configuration items of multiple software systems into a training set and a test set;

The random forest classification model is trained according to the training set and the random forest algorithm.

Optionally, the configuration item-dependent detector revising the classification result of the random forest classification model includes:

When the first configuration item of the software system depends on the second configuration item, if the random forest classification model determines that the first configuration item affects the performance of the software system and the second configuration item does not affect the performance of the software system, then The configuration item dependency detector corrects the second configuration item to affect software system performance.

Optionally, before identifying the dependencies between the performance operations and the configuration items of the software system, the method further includes:

The configuration item information of the software system is extracted, where the configuration item information at least includes the name, quantity of the configuration item, and an API used when the configuration item is loaded into the software system.

The present invention also provides a system for analyzing the impact of configuration items on software system performance, including:

A performance operation identification module, configured to identify and mark all performance operations in the software system according to a code pattern preset by the software system, where the performance operations are time-intensive operations and/or space-intensive operations that affect the performance of the software system;

A dependency relationship identification module is used to identify the dependency relationship between each of the performance operations and each configuration item of the software system, and obtain a performance operation set corresponding to each of the configuration items, and each performance operation in the performance operation set have dependencies with the configuration items;

a feature vector building module, configured to build a feature vector corresponding to each of the configuration items according to the performance operation set;

A configuration item set determination module, configured to input the feature vector corresponding to each of the configuration items into the trained qualitative performance impact model, determine whether the configuration item affects the performance of the software system, and obtain a set of configuration items that affect the performance of the software system, The qualitative performance impact model is obtained by training the feature vectors corresponding to the configuration items of multiple software systems.

The present invention provides a method and system for analyzing the impact of configuration items on software system performance, wherein the method includes: identifying and marking all performance operations in the software system according to a preset code pattern of the software system, and the performance operations are Time-intensive operations and/or space-intensive operations of software system performance; identify the dependencies between each of the performance operations and each configuration item of the software system, and obtain a performance operation set corresponding to each of the configuration items. Each performance operation in the performance operation set has a dependency on the configuration item; construct a feature vector corresponding to each of the configuration items according to the performance operation set; input the feature vector corresponding to each of the configuration items into the training In the qualitative performance impact model, it is judged whether the configuration item affects the performance of the software system, and a set of configuration items that affect the performance of the software system is obtained. .

In view of this, the beneficial effects brought by the present invention are:

The present invention adopts program analysis technology to track time-intensive operations or space-intensive operations that have dependencies on configuration items, constructs corresponding feature vectors for configuration items according to the program analysis results, and can fine-grained configuration items, not limited to Boolean type or Exhaustive limited numerical types, support any type of configuration items; use random forest to build qualitative performance impact models, without time-consuming local measurement operations, only need to analyze the source code of the software system once to determine whether a specific configuration item affects The performance of the configurable system greatly reduces the overhead of performance analysis, and can more accurately predict whether each configuration item of the software system affects the performance of the software system without running the software system, and can find the configuration items that really affect the performance of the software system. Set, can improve the efficiency of software system configuration, is conducive to the correct configuration of the software system to improve the performance of the software system. In addition, the present invention also has interpretability, and the underlying reason that the configuration item affects the performance can be understood through the program analysis result and the classification rule of the performance model.

Description of drawings

Fig. 1 is the schematic flow chart of the method of the present invention;

Fig. 2 is the structural representation of the system of the present invention;

3 is a program dependency diagram of an example program, wherein the solid line represents the control dependency, and the dashed line represents the data dependency;

Figure 4 is an example diagram of the taint analysis of FlowDroid;

5 is a schematic flowchart of a method embodiment of the present invention;

6 is an example diagram of the categories of performance operations and their code patterns in the method of the present invention;

Fig. 7 is the dependency relationship classification and example diagram of performance operation and configuration item in the method of the present invention;

8 is a schematic diagram of a stain analysis process flow of the method of the present invention;

9 is an example diagram of a configuration item control area of the method of the present invention;

10 is a schematic diagram of a qualitative performance impact model in the method of the present invention;

FIG. 11 is a schematic diagram of a program analysis module of the ConfigAnalyzer tool of the present invention.

Detailed ways

Terminology Explanation:

Configuration item (Option): a special type of input, with a type and a certain range of values, for example: a configuration item of type Boolean has a value range of {true, false}, a configuration item of type Integer The value range of is {0,1,2,3}. The configuration item allows the user to change the internal execution logic of the software system without modifying the software code, so the user can change the function or performance of the software system by changing the value of the configuration item. In some literature, configuration items are also often referred to as features or functions.

Configuration: The complete settings of all configuration items in the software system. All configuration items set to definite values constitute the configuration of the software system.

Configuration Space: All possible configurations in a software system constitute a configuration space.

Configurable System: A software system that provides users with configurations for customized operation.

Misconfiguration: A configuration item that is set to an inappropriate value resulting in a software system that does not behave or behave as expected. Software system errors caused by misconfiguration are called configuration errors.

Environment: The entirety of hardware and software on which the software system operates. Generally speaking, when running a software system, the environment in which it is located does not change.

Workload: The amount of work that the software system needs to complete within a certain period of time. The user inputs tasks to the software system in order to complete a predetermined task or goal. The greater the workload of the task that the software system needs to complete within a certain period of time, the greater the workload, and the more computing resources the software system needs to use.

Performance: It is used to represent the nature of the working ability of a software system, which is usually directly related to energy consumption and operating costs. In general, performance evaluation has different measurement methods under different software service quality requirements. The most intuitive way to measure the performance of a software system is the running time required to complete a task.

Performance-influence Model: A type of model that describes the performance of a software system running under a specific environment and specific workload.

Control Flow: Refers to the execution order of each statement, instruction or function call when the program is running. For an imperative programming language such as Java, the program has a clear control flow (different from programs written in a declarative programming language).

Control-flow Statement: A type of program statement that affects the control flow of the actual execution of the program depending on the control flow decision. For example, the if statement, switch statement, for loop statement, and while loop statement in Java are all control flow statements.

Control-flow Decision: Refers to the actual execution of a control-flow statement, that is, choosing to execute a specific branch.

Control-flow Graph (Control-flow Graph): CFG is a type of flow chart used to represent the control flow of a program.

Data Flow: An abstraction of the data dependency chain in a program.

Embodiments of the present invention provide a method and system for analyzing the impact of configuration items on software system performance, so as to solve the technical problems of software system configuration errors and low configuration efficiency in the prior art.

In order to facilitate understanding of the present invention, the present invention will be described more fully hereinafter with reference to the related drawings. Preferred embodiments of the invention are shown in the accompanying drawings. However, the present invention may be embodied in many different forms and is not limited to the described embodiments of the present invention. Rather, these embodiments are provided so that this disclosure will be thorough and complete.

Unless otherwise defined, all technical and scientific terms used herein have the same meaning as commonly understood by one of ordinary skill in the art to which this invention belongs. The terms used in the present specification in the present invention are for the purpose of describing specific embodiments only, and are not intended to limit the present invention. As used herein, the term "and/or" includes any and all combinations of one or more of the associated listed items.

(1) Configuration and complexity of modern software systems

Today, a large number of modern software systems are designed to be highly customizable systems that can be configured according to the hardware platform, operating system, and needs of the user. The configuration of the software system allows users to easily change the behavior or state of the software system without modifying the software code, thereby improving the flexibility and security of the software and meeting the needs of users in terms of software functions or performance. A software system that provides configuration to users is called a Configurable system.

In simple terms, a configuration can be represented as a set of several configuration items (Option), where each configuration item represents a certain property of the software, such as the used hardware platform, operating system, whether to load a certain plug-in, and so on. However, the highly customizable configuration brings potential enrichment of software functions or improvement of software performance, but also brings great challenges to users and developers.

Studies have shown that the misconfiguration of software systems has become one of the main reasons for system failures and system performance problems. In Google's main production service, misconfiguration was reported to be the second leading cause of service-level incidents; in Facebook, misconfiguration was responsible for 16% of service-level incidents and was considered a key to Facebook's reliability challenge. Studies of enterprise backup systems have shown that most mission failures are caused by configuration errors. The consequences of misconfiguration can be severe, and studies of misconfiguration of commercial storage systems and open source operating systems have shown that a significant percentage of misconfigurations can cause hard-to-diagnose system crashes, hangs, or severe performance degradation.

In addition to common misconfigurations, understanding what configuration does is a challenge. It is often difficult for users to clearly understand the actual impact of changing a configuration item on the software system. Therefore, users are often forced to adjust the configuration in a time-consuming way of extensive trial and error. To that end, vendors have also taken a toll, with reports showing that configuration issues are a major source of user support costs for cloud service and data center software vendors. At the same time, configuration complicates the development, testing, and operation and maintenance of software systems.

To sum up, the configuration of modern software systems can meet the needs of users in terms of software functions or performance, but the complexity of configuration (reflected in the number of configuration items, and the interactions and dependencies between configuration items) makes it difficult to adjust the software. Configuration became a huge challenge.

(2) Influence of configuration on software system performance

The performance of a software system (and often directly related energy consumption and operating costs) is a software system attribute that is highly valued by both users and developers. From the perspective of users, users often hope that the system can reduce energy consumption and operating costs on the basis of specific functions; from the perspective of developers, developers often hope to develop systems that can be configured efficiently and provide high-quality user experience . The inventor found through research that in the open source cloud system, the performance problems of the software system lead to the release of about 50% of the configuration-related patches, and about 30% of the configuration-related forum discussions. Serious performance issues and outages caused by misconfigurations cost hundreds of millions of dollars in cloud systems.

Setting configuration items that are sensitive to software system performance is a challenging task that often requires a deep understanding of the software system. For example, setting a configuration item may require a balance between memory usage and system response time, and balancing this trade-off requires a deep understanding of the software system, the hardware used, or the current workload. To make matters worse, there is often no clear explanation of these relationships in the documentation of software systems, and even with clear documentation, factors such as workload are often complex and variable, making it difficult for users to set appropriate configurations.

In another example, when a configuration item is a specific value, each write operation of the user may be locked, resulting in an increase in write latency, but the document only states that when the configuration item is a specific value, there is no object that supports write operations. limit. Unless the user traces the specific implementation logic through the code, it is impossible to understand the cause of the system performance change.

(3) Existing technical solutions

The performance impact model of a software system is used to express how the configuration affects the system performance. The application of the performance impact model is an important technical tool to analyze the relationship between the configuration and the performance of the software system. Different configurations are used as the input of the performance impact model to obtain the performance prediction value to determine whether the configuration affects the system performance. Therefore, the difference between the existing technical solutions lies in the way of constructing the performance impact model.

A related category of work is to use a black-box approach to model performance impact. The idea of using the black-box method to build a performance model is to treat the software system as a black box, sample the configuration space to obtain a configuration subset, and measure the performance of the system under each configuration of the configuration subset under a specific workload. performance, and then learn a performance impact model from these observations.

Existing black-box techniques require a trade-off between modeling cost and model accuracy. More samples are required to build a more accurate model, and more samples need to sample a larger subset of configurations. The number of times to measure the performance of the target software system under a specific load is more, and the cost of time is greater. In addition, most of the performance impact models constructed by the black-box method are based on deep learning models, which are generally low in interpretability and cannot explain the root cause of changes in software system performance caused by configuration item changes.

Another category of related work uses a white-box approach to model performance impacts. Building a performance impact model using the white-box method no longer regards the software system as a complete black box, but divides it into multiple components or modules according to the idea of program analysis, and analyzes and models each component or module, thereby constructing Model the performance impact of the entire system. In addition to being able to correctly predict performance, it can also explain why the performance occurs, such as which components or modules cause the performance to occur.

However, the existing white-box methods to build performance impact models have certain defects. Some white-box methods only support configuration items of Boolean type or exhaustive finite numerical type (configuration items of exhaustive finite type need to be discretized into several Boolean type configuration items), which is a big limitation, and is equivalent to configuration after discretization The number of items has increased dramatically, and the runtime of the tool has grown exponentially.

Although some white-box methods can learn a more accurate performance impact model, they still need to prepare the software system operating environment, sample the configuration space, run the target software system based on the sampled configuration subset, and collect various item performance indicators.

Although the above-mentioned existing technical methods have their own shortcomings due to different implementation details, there is an inevitable software system runtime overhead, that is, these existing technical methods all need to prepare the software system operating environment, and select the software system operating environment. And traverse the configuration subsets to measure the performance of the software system under different configuration subsets under a specific load. The huge time overhead required to repeatedly run the software system and collect the runtime performance indicators of the software system has far exceeded the time overhead required to analyze and build performance impact models.

(4) Program analysis

Program analysis is a process of automatically analyzing program performance. The focus of the analysis includes program correctness, robustness, security, and activity. In other words, program analysis systematically examines programs to analyze their properties.

Program analysis can be divided into:

1) Static program analysis: program analysis without running the program;

2) Dynamic program analysis: Run the program on a real or virtual processor, and analyze the program according to its runtime performance.

Although static program analysis cannot obtain the runtime information of the program, because static program analysis does not need to actually run the program, it can save a lot of time and computing resources compared to dynamic program analysis. In addition, the information to be obtained by program analysis is not as much as possible, and it is necessary to seek a balance between benefits and costs. Therefore, the method proposed in the present invention uses static program analysis technology.

(5) Stain analysis

Taint analysis is a type of program analysis, also known as information-flow analysis, which is an analysis that detects whether any sensitive private information can be obtained through injected vulnerabilities in source code. Taint analysis is generally used to identify the flow of user input through a system to understand the security implications of system design. The taint analysis can be divided into static taint analysis and dynamic taint analysis.

The taint analysis defines the quadruple (P, SO, SI, SA), where:

1) P represents the program under analysis (Program);

2) SO represents a collection of source points (Source), and the source point is the information that needs to be tracked.

3) SI represents a collection of sinks, and sinks are program statements that are not expected to be reached by the source.

4) SA represents a set of sanitizers. If the source point passes through the sanitizer during the propagation process, its harmfulness is eliminated.

Theorem 1: There is an information leakage vulnerability or a taint flow vulnerability in a program if and only if there is a path from a source to a sink in the program, and the path does not pass through any purifier.

It should be noted that the vulnerability generally refers to all the sinks in the program code. In information security analysis, a vulnerability represents a place where information is leaked in all programs. Leaving the context of information security, a vulnerability refers to all places where sensitive information is used.

In summary of this embodiment, in the context of the current configurable system performance analysis, the existence of a taint flow vulnerability is a path through which a configuration item affects space-intensive and time-intensive operations.

(6) Program dependency analysis

There are many ways to define the control dependencies and data dependencies of a program. The following is a more intuitive one:

(6.1) Control dependencies

Definition of control dependencies: For any program branch statement S1 and program statement S2, there are:

If the statement S1 is the branch statement before the statement S2 and the closest to the statement S2, the statement S1 has multiple branch targets, and the change of the branch decision of the statement S1 may cause the statement S2 not to be executed, then the statement S2 control depends on the Statement S1, or statement S2 has a control dependency on statement S1, denoted as S2δc S1.

(6.2) Data dependencies

Data dependencies exist between program statements that access or modify the same resource. Data dependencies include stream dependencies, anti-dependencies, output dependencies, and input dependencies. Among them, stream dependencies are the most basic data dependencies.

(6.3) Program dependency analysis and program dependency graph

The purpose of program dependency analysis is to analyze the control dependencies and data dependencies in the program. In actual analysis, the program dependency analysis generally takes the basic block as the smallest unit, which is different from the above-mentioned granularity definition of the statement.

A program dependency graph (PDG for short) is used to describe the control dependencies and data dependencies of a program.

A sample program looks like this:

FIG. 3 is a program dependency diagram of the above-mentioned example program, in which solid lines indicate control dependencies and dashed lines indicate data dependencies.

(7) Random Forest

A decision tree is a white-box predictive model commonly used in data mining or machine learning. The structure of a decision tree is a tree structure similar to a flowchart, where:

Each internal node represents a test for a property;

each branch represents the result of the above test;

Each leaf node represents a type label;

• Paths from root nodes to leaf nodes represent classification rules. The classification rules of a decision tree are constructed by the decision tree algorithm based on feature vectors and classification labels.

Decision tree learning is a method of building a decision tree based on the source database. In the process of decision tree learning, the original database is continuously divided, and the tree is recursively pruned until it can no longer be divided or a branch can be attributed to a certain kind. The learned decision tree is prone to overfitting the training set.

Random forest is a classifier that contains multiple decision trees, and the final output category is determined by the mode of the categories output by the contained decision trees. In the process of building a random forest, multiple decision trees are randomly constructed using different parts of the training set.

As a widely used classifier, random forest has the following significant advantages:

1) In many application scenarios, random forest is not easy to overfit;

2) When using random forest to process high-dimensional data (that is, data with many features), feature selection is generally not required;

3) For imbalanced classification datasets, random forest can balance the error.

(8) Soot: Analysis and conversion framework for Java and Android applications

Soot was originally a Java optimization framework, and then gradually developed into an analysis, measurement, optimization, and visualization framework for Java and Android applications. Simply put, the working principle of Soot is to convert the input program (Java bytecode) into an intermediate language (Intermediate representation, referred to as IR), and then analyze and convert the intermediate language, and the processed code can be further converted into Java bytes code and other target language output.

Using the Soot framework, the following functions can be achieved:

· Build a call graph (Call graph);

· Conduct directional analysis;

Build definition and usage chains (the basis of data flow analysis, on which data dependencies can be analyzed);

Perform template-driven in-program data flow analysis;

Perform template-driven inter-program data flow analysis;

Perform stream, field, context sensitive pointer analysis.

(9) FlowDroid: A taint analysis framework for Java and Android applications

FlowDroid is a static taint analysis framework sensitive to context, stream, field, and object for Java and Android applications. The implementation of FlowDroid is based on Soot and Heros, where Heros is a general-purpose multi-threaded IDFS (inter-program finitely distributed subset problem), IDE (inter-program distributed environmental problem) solver.

FlowDroid ensures context and flow sensitivity by building a fairly accurate call graph, and ensures field and object sensitivity through IDFS-based flow functions. Among them, to ensure context and field sensitivity, FlowDroid implements accurate and efficient alias tracking.

Figure 4 is a practical example of FlowDroid taint analysis. From 1 to 7 in Figure 4 is a path analyzed by FlowDroid from the source to the sink without going through the purifier. It is easy to see that in this process, FlowDroid found that z.g.f, a.g.f, b.g are all Alias for x.f.

Because the program often uses local variables with different names, fields in classes, global variables and other variables to refer to the same variable. When the program is not running, there is no guarantee that a variable is referred to by a variable of which name. Therefore, static program analysis requires alias analysis to obtain all variable names that refer to a variable.

Referring to FIG. 1 and FIG. 5 , the present invention provides an embodiment of a method for analyzing the impact of configuration items on software system performance, including:

S100: Identify and mark all performance operations in the software system according to a code pattern preset by the software system, where the performance operations are time-intensive operations and/or space-intensive operations that affect the performance of the software system;

S200: Identify the dependency between each of the performance operations and each configuration item of the software system, and obtain a performance operation set corresponding to each of the configuration items, where each performance operation in the performance operation set is related to the configuration item have dependencies;

S300: Construct a feature vector corresponding to each of the configuration items according to the performance operation set;

S400: Input the feature vector corresponding to each of the configuration items into the trained qualitative performance impact model, determine whether the configuration item affects the performance of the software system, and obtain a set of configuration items that affect the performance of the software system, and the qualitative performance affects the model It is obtained by training the feature vectors corresponding to the configuration items of multiple software systems.

The method for analyzing the impact of configuration items on software system performance provided in this embodiment is a new white-box configuration performance analysis method. Step S100 identifies and marks all performance operations in the software system according to a code pattern preset by the software system. .

The performance operation (PerfOp) in this embodiment refers to a time-intensive operation or a space-intensive operation. The main difference between a time-intensive operation and a space-intensive operation is that the computer takes a long time to complete the time-intensive operation, and the computer Memory, disk and other resources required for space-intensive operations are expensive.

Understandably, performance operations are strongly correlated with time-consuming, space-consuming operations. It is worth noting that time-intensive operations and time complexity are two different concepts, and similarly, space-intensive operations and space complexity are also two different concepts. Evaluating the time complexity and space complexity needs to take into account the input size when actually running. For example, the time complexity and space complexity of a function f() are very small, but if an operation o needs to run the function f() 1000 times to be completed, then the operation o may be time-intensive or space-intensive. However, the time complexity and space complexity of this operation still depend on the complexity of the function f(). Since the time complexity and space complexity of the function f() are excellent, the time complexity of the operation o And space complexity is also excellent. That is, the time and space complexity of the operation o is very small, but the operation o may be a time-intensive operation or a space-intensive operation.

Referring to FIG. 6 , according to the observation and research on the software system, taking the Java software system as an example, the performance operations can be divided into four categories in this embodiment, and the corresponding code patterns are summarized as shown in FIG. 6 . The performance operations in Figure 6 are divided into JavaIO, thread operations, synchronization operations, and array creation. Each type of performance operation has its corresponding code pattern. For example, the code pattern corresponding to Java IO is: calling methods in the java.io package, Call methods in the java.nio package.

It should be noted that, for different types of software systems, the performance operations involved are different, and the above types of performance operations do not necessarily cover all software systems. The method proposed in this embodiment is universal and extensible, as long as a new type of performance operation is defined and a code mode of the performance operation is provided, the new type of performance operation can be supported.

In step S200, a dependency relationship between each of the performance operations and each configuration item of the software system is identified, and a performance operation set corresponding to each of the configuration items is obtained, and each performance operation in the performance operation set is related to the Configuration items all have dependencies.

In this embodiment, before identifying the dependencies between the performance operations and the configuration items of the software system, the method further includes: extracting configuration item information of the software system, where the configuration item information at least includes the name of the configuration item , quantity, and the API used when the configuration items are loaded into the software system.

In this embodiment, any configuration item that affects the performance of the software system has a data dependency or a control dependency with some performance operations. Please refer to Figure 7. The configuration item in Figure 7 is OptionX. OptionX is an abstract configuration item, which can be any configuration item in the program. In Figure 7, there are data dependencies and control dependencies between the performance operation of creating the array arr and the configuration item OptionX, where the control dependencies include if branch control dependencies and loop control dependencies, and loop control dependencies include loop boundary control dependencies and loop step Long control dependency.

It is worth noting that the control dependencies and data dependencies between the configuration items and performance operations of the software system are relatively independent, but combined: Identifying control dependencies and data dependencies are independent in most cases, but in most cases A combination of the two is required in some cases.

As a means of information flow tracking and analysis, taint analysis is essentially a data flow analysis technology, which can be used to identify the data dependencies of configuration items in the program. In step S200 of this embodiment, taint analysis is used to track information flow to identify data dependencies between performance operations and configuration items in the program. The process of identifying data dependencies is shown in Figure 8, and each step is explained in detail below:

The first step is to enter the program entry.

If the program provides multiple program entries, a virtual entry is created as the only program entry, and there are control flow edges between the virtual entry and all program entries.

The second step is to traverse the control flow and insert the sink mark performance operation.

Traversing the control flow, after identifying the corresponding branch statement and performance operation through the code pattern, insert the statement calling the sink function before the corresponding statement.

Step 3: Return to the program entry and traverse the control flow again.

The first two steps are preparatory work (setting the sink), and the third step is to return to the program entry, re-traverse the control flow, and analyze the program after the sink has been inserted.

Step 4: Create a taint (source point) at the configuration loading API

The configuration loading API is where configuration first enters the program, and we start tracking from there.

The fifth step: taint propagation (information flow propagation).

The taint propagation is simply: the source point is the original taint, and the taint will mark other variables as taints in the process of data propagation. Therefore, the path of taint propagation is the data dependency chain.

Step 6: Record the arrival point

For a configuration item, the taint created from the configuration loading API finally reaches the pre-inserted sink through data propagation, and the information indicates that the performance operation (or branch statement) where the sink is located has a data dependency on the configuration item.

It can be understood that the process of identifying data dependencies between various performance operations and various configuration items of the software system by using taint analysis in this embodiment specifically includes: entering the program entry of the software system, traversing the control flow, and loading the API in the configuration item. Create a taint at the source point as the source point; record the data propagation path of the source point and the finally reached sink point, then the performance operation at the sink point has a data dependency on the configuration item; wherein, the sink point is the program that does not want the source point to reach Statements, sinks are preset before the statement corresponding to the performance operation.

It is worth noting that the control flow is the execution order of each statement, instruction or function in the code, and it must be combined with the control flow when identifying data dependencies. The execution order of each part of the code in the program code is known only through the control flow.

In step S200 of this embodiment, the control dependency relationship between the performance operation and the configuration item in the program is identified by constructing the control area of the configuration item.

Specifically, the control area of a configuration item is: for a certain configuration item, its control area is a statement sequence that has a control dependency relationship with the configuration item, and in the control flow sequence, the next statement of the sequence is the sequence statement The immediate after-governing statement in .

In the control flow graph, the postdominate relationship means: for the control flow nodes n and m, if all the paths starting with the program entry (entry) and passing through n must go through m to reach the program exit, then the node m is called post-dominant node n. If node m later dominates node n, and does not later dominate any other node that later dominates n, then node m is said to directly dominate node n, and node m is the direct subsequent dominate of node n.

Intuitively, for a specific configuration item, the control area of the configuration item is a program directly controlled by the configuration item. Figure 9 shows the affected areas of the four configuration items OptionA, OptionB, OptionC, and OptionD.

In this embodiment, using the program dependency graph to identify the control dependency between each performance operation and each configuration item of the software system includes: traversing all nodes in the program dependency graph, constructing the control area of each configuration item, and the control area of the configuration item It is a sequence of statements that has a direct control dependency relationship with the configuration item; the control dependency relationship between each performance operation and each configuration item of the software system is identified according to the control area of each configuration item.

Specifically, the process of identifying the control dependencies between performance operations and configuration items of the software system is as follows:

1) Use program dependency analysis technology to build a program dependency graph;

2) Traverse all nodes in the program dependency graph, and build a configuration item control area;

3) For a configuration item, after the configuration item control area is constructed, there are two types of performance operations in the configuration item control area: performance operations that are data-dependent and control-dependent with the configuration item; no data to the configuration item. A performance operation that depends, but has control dependencies.

It is worth noting that analyzing control dependencies will use control flow, but only using control flow can only analyze a part of control dependencies. Specifically, only using simple control flow can only analyze performance operations that have data dependencies and control dependencies with configuration items, while performance operations that have no data dependencies but have control dependencies with configuration items need to build configuration items. control area to complete.

In step S300, a feature vector corresponding to each configuration item is constructed according to the performance operation set.

For any configuration item, the set of performance operations that are known to have data dependencies or control dependencies. It can be understood that the performance operation set of the configuration item can be regarded as a specific code set, which is identified by a specific code pattern.

After the performance operation set corresponding to the configuration item is obtained, a corresponding feature vector is constructed for the configuration item according to the performance operation set, that is, the feature vector is used to describe the dependency between the configuration item and the performance operation.

The construction of eigenvectors is more complicated. The construction of some eigenvectors is explained below:

Assume that the set of configuration items is Options, and the set of four different performance operations proposed in this embodiment is PerfOps. For any configuration item option∈Options and performance operation perfOp∈PerfOps, let the function f(option, perfOp) represent the number of performance operations perfOp that have data dependencies or control dependencies with the configuration item option in the target software system.

In addition, use perfOp ^data , perfOp ^if , and perfOp ^loop to represent the perfOp that has data dependencies, if branch control dependencies, and loop control dependencies with the configuration item option, respectively. For k∈{data,if,loop}, let the function g(option,perfOp ^k ) be the number of performance operations perfOp in the target software system that have k corresponding dependencies with the configuration item option.

The first 22 dimensions of the feature vector v are:

Among them, i and j are only used to represent the subscript count. For example, when i=0, the first formula v ₀ =f(option,PerfOps ₀ ) indicates that the first dimension in the feature vector is option and the first-class performance The number of operations that have dependencies on Java IO.

以一个例子去解释：当i＝0时，表示与第一类性能操作JavaIO存在数据依赖关系。类似地，

以一个例子去解释：当i＝0时，表示与第一类性能操作Java IO存在if分支控制依赖关系；

以一个例子去解释：当i＝0时，表示与第一类性能操作Java IO存在循环控制依赖关系。As for

Explain with an example: when i=0, it means that there is a data dependency with the first type of performance operation JavaIO. Similarly,

Explain with an example: when i=0, it means that there is an if branch control dependency with the first type of performance operation Java IO;

To explain with an example: when i=0, it means that there is a circular control dependency with the first type of performance operation Java IO.

In step S400, the feature vector corresponding to each of the configuration items is input into the trained qualitative performance impact model, and it is judged whether the configuration item affects the performance of the software system, and a set of configuration items that affect the performance of the software system is obtained. The influence model is obtained by training the feature vectors corresponding to the configuration items of multiple software systems.

In this embodiment, a qualitative performance impact model of the configuration item needs to be constructed. After that, for any brand-new target software system, after calculating the corresponding feature vector for each configuration item of the target software system by the aforementioned method, the feature vector is input into the In the constructed qualitative performance impact model, you can automatically determine whether the configuration item affects the performance of the software system, add all the configuration items that affect the performance of the software system to the set of configuration items, and finally get all the configuration items that affect the performance of the software system. . The specific process is:

First, several software systems are collected for building the training set. For each software system, run the software system multiple times under different configurations and record the actual running time to determine whether each configuration item of the software system actually affects the performance of the software system. In addition, by constructing the feature vector corresponding to each configuration item in the software system, the training set data can be obtained.

Then, this embodiment establishes a qualitative performance impact model of a configuration item. As shown in FIG. 10 , the qualitative performance impact model consists of a random forest classification model and a cDEP configuration item dependency detector. Among them, the training of the random forest model uses the random forest algorithm in the sklearn library, and the focus is to divide the feature vector into a training set and a test set for the construction of the random forest classification model RandomForestClassifier.

In this embodiment, a feature vector is constructed for each configuration item, and the dimension of the feature vector is positively correlated with the number of classes of performance operations that have appeared in the target software system. Therefore, the dimension of the feature vector corresponding to the configuration item is usually higher . In addition, due to the different functions of each software system, for different types of software systems (such as: computation-intensive or memory-intensive), the frequency and characteristics of its performance operations are also significantly different. Probably not balanced.

Because random forest has the advantages of not easy overfitting, can handle high-dimensional data, and can balance the errors of classification data sets, it can solve the above problems, and use random forest to learn some interpretable classification rules. Therefore, this paper The embodiment adopts the random forest classification model to carry out the binary classification of "whether the configuration item affects the performance of the software system", and preliminarily answers the question of the influence of the configuration item on the performance of the software system.

So far, in this embodiment, the dependency between configuration items has not been considered, but each configuration item is considered as an independent configuration item. But in fact, there may also be dependencies between configuration items of a software system. When adjusting the configuration, configuration items with dependencies are usually considered together.

This embodiment considers that: if the configuration item OptionA depends on the configuration item OptionB, and the configuration item OptionA affects the performance of the software system, then the OptionB also affects the performance of the software system.

cDEP is a detection tool for discovering configuration item dependencies, proposed by Qingrong Chen et al. in 2020. In order to take the dependencies among the configuration items into consideration, this embodiment uses cDEP to detect the dependencies between the configuration items in the software system, and further corrects and improves the classification results of the random forest classification model.

In this embodiment, the classification result of the configuration item dependency detector to correct the random forest classification model includes:

When the first configuration item of the software system depends on the second configuration item, if the random forest classification model determines that the first configuration item affects the performance of the software system and the second configuration item does not affect the performance of the software system, the cDEP configuration item dependency detector will The second configuration item is corrected to affect the performance of the software system.

In the method for analyzing the impact of configuration items on software system performance provided by the embodiments of the present invention, program analysis technology is used to track time-intensive operations or space-intensive operations that have dependencies on configuration items, and corresponding features are constructed for configuration items according to the program analysis results. Vector, which can be fine-grained to configuration items, not limited to Boolean types or exhaustive finite numerical types, and supports any type of configuration items; using random forests to build qualitative performance impact models without time-consuming local measurement operations, only one software The analysis of the system source code can determine whether a specific configuration item affects the performance of the configurable system, which greatly reduces the overhead of performance analysis, and can more accurately predict whether each configuration item of the software system is not running on the premise of not running the software system. Affect the performance of software system, can find the set of configuration items that really affect the performance of the software system, can improve the efficiency of software system configuration, and is conducive to the correct configuration of the software system to improve the performance of the software system. In addition, the embodiments of the present invention are also interpretable, and the underlying reasons why the configuration items affect the performance are known through the program analysis results and the classification rules of the performance model.

Referring to FIG. 2, the present invention also provides an embodiment of a system for analyzing the impact of configuration items on software system performance, including:

A performance operation identification module 11, configured to identify and mark all performance operations in the software system according to a code pattern preset by the software system, where the performance operations are time-intensive operations and/or space-intensive operations that affect the performance of the software system ;

The dependency relationship identification module 22 is configured to identify the dependency relationship between each of the performance operations and each configuration item of the software system, and obtain a performance operation set corresponding to each of the configuration items, and each performance operation set in the performance operation set The operation has a dependency on the configuration item;

A feature vector building module 33, configured to build a feature vector corresponding to each of the configuration items according to the performance operation set;

The configuration item set determination module 44 is configured to input the feature vector corresponding to each of the configuration items into the trained qualitative performance impact model, determine whether the configuration item affects the performance of the software system, and obtain a set of configuration items that affect the performance of the software system , the qualitative performance impact model is obtained by training the feature vectors corresponding to the configuration items of multiple software systems.

The system for analyzing the impact of configuration items on software system performance provided by the embodiments of the present invention uses program analysis technology to track time-intensive operations or space-intensive operations that have dependencies on configuration items, and builds corresponding features for configuration items according to program analysis results Vector, which can be fine-grained to configuration items, not limited to Boolean types or exhaustive finite numerical types, and supports any type of configuration items; using random forests to build qualitative performance impact models without time-consuming local measurement operations, only one software The analysis of the system source code can determine whether a specific configuration item affects the performance of the configurable system, which greatly reduces the overhead of performance analysis, and can more accurately predict whether each configuration item of the software system is not running on the premise of not running the software system. Affect the performance of software system, can find the set of configuration items that really affect the performance of the software system, can improve the efficiency of software system configuration, and is conducive to the correct configuration of the software system to improve the performance of the software system. In addition, the present invention also has interpretability, and the underlying reason that the configuration item affects the performance can be understood through the program analysis result and the classification rule of the performance model.

In addition, according to the white box performance analysis method based on program analysis proposed above, the present invention designs and implements a configuration analysis tool ConfigAnalyzer oriented to Java applications.

The ConfigAnalyzer tool implements the white-box performance analysis method proposed by the present invention, and supports the Java software system. ConfigAnalyzer uses FlowDroid to implement static taint analysis sensitive to context, flow, field, and object, and makes necessary custom extensions to the Soot analysis framework that FlowDroid is based on to support the analysis logic required by ConfigAnalyzer.

ConfigAnalyzer is divided into the following two main modules:

1) Program analysis module: realizes the identification of performance operation tags, the dependencies between configuration items and performance operations;

2) Performance model module: The feature vector of configuration items and the construction of qualitative performance impact model are realized. The performance analysis module includes two parts: constructing the feature vector according to the result obtained by the program analyzing module, and constructing the qualitative performance impact model according to the feature vector.

Among them, the program analysis module of the ConfigAnalyzer tool is shown in Figure 11. The program analysis module contains three packages, whose functions are:

1) edu.sysu.dds.analysis: realizes taint analysis, program dependency analysis and information extraction, etc.;

2) edu.sysu.dds.visual: realize the visualization of intermediate results;

3) edu.sysu.dds.utility: the assistance provided by the previous two packages.

Among them, the information extraction is mainly used to extract the configuration item information of the software system, such as which configuration items are, the number of configuration items, and the API used by the configuration items to be loaded into the software system.

The visualization of the intermediate results mainly includes the visualization of the control area of the configuration item (as shown in Figure 9), the visualization of the insertion marker sink, and so on.

The present invention refers to the existing evaluation methods for the research work of the white box performance analysis method, and makes a balance based on the evaluation effect and the workload. From the existing 19 real software systems, 6 representative software systems are selected to carry out the evaluation of the ConfigAnalyzer The established qualitative performance impact model is evaluated. Table 1 is an overview of the target software system.

Table 1

It is worth noting that an effective configuration refers to a configuration that enables the software system to execute correctly without crashing. These configurations enable the software system to complete corresponding tasks, but different configurations require different resources to complete tasks.

Consider 5 configuration items, their type is boolean and the value range is {false,true}. Only 5 configuration items can constitute 2 ⁵ =32 configurations. 10 Boolean configuration items can form 1024 configurations. If the configuration item is not a Boolean type, the value space will be larger, and the total number of configurations will be very large.

In the experiment of the present invention, the six target software systems are divided into two categories, and the data corresponding to the configuration items (total) of the four software systems of Batik, H2, Kanzi, and Prevayler are used as the training set, and the configuration of the two software systems of Catena and Sunflow is used as the training set. The samples corresponding to the items (total) are used as the test set.

The feature vector constructed based on the results of program analysis has a total of 50 dimensions. Build a random forest regressor model, then run cDEP to refine configuration dependencies.

In this embodiment, after the configuration item uses the program analysis module of the ConfigAnalyzer tool to generate a feature vector, the feature vector is input into the random forest model. The random forest is composed of many decision trees, and the feature vector needs to pass through each decision tree and use its classification The rule gets the predicted class label.

The experimental results are shown in Table 2. The predicted impact of the qualitative performance model on the configuration items of the tested software system is compared with the actual impact. Among them, y represents the actual classification of the configuration item, and y _predit represents the predicted classification of the configuration item by the model. A classification of -1 indicates that the configuration item does not affect the performance of the software system, and a classification of 1 indicates that the configuration item affects the performance of the software system.

Table 2

The experimental results show that ConfigAnalyzer can accurately predict whether 84.21% of the configuration items in the tested software system affect the performance without running the program, and the accuracy rate is high. It can be seen that ConfigAnalyzer can indeed effectively establish the qualitative performance impact model of the software system.

The invention provides an analysis system for the impact of configuration items on software system performance, and implements a ConfigAnalyzer tool, which is a configuration analysis tool oriented to Java applications.

ConfigAnalyzer first uses program analysis techniques such as taint analysis and program control analysis to statically track time- or space-intensive operations that have dependencies on configuration items. Then, ConfigAnalyzer builds feature vectors based on the results of program analysis, and uses random forests to build qualitative performance impact models.

ConfigAnalyzer helps users discover the set of configuration items that really affect system performance without running a software system. Different from the traditional black box method, ConfigAnalyzer is interpretable. Users can understand the underlying reasons why configuration items affect performance through program analysis results and performance model classification rules. Different from the existing white-box methods, ConfigAnalyzer supports any type of configuration items, and because it builds a qualitative performance impact model, it does not require time-consuming local measurement operations, which greatly reduces the analysis overhead.

The ConfigAnalyzer tool of the present invention has the following advantages:

(1) Explainable

ConfigAnalyzer first uses program analysis techniques such as taint analysis and program control analysis to statically track time- or space-intensive operations that have dependencies on configuration items. Then, ConfigAnalyzer builds feature vectors based on the results of program analysis, and uses random forests to build qualitative performance impact models. Different from the traditional black box method, ConfigAnalyzer is interpretable. Users can understand the underlying reasons why configuration items affect performance through program analysis results and performance model classification rules.

(2) Accuracy

The experimental results show that ConfigAnalyzer can accurately predict whether 84.21% of the configuration items in the tested software system affect the performance without running the program, and can indeed effectively establish the qualitative performance impact model of the software system.

(3) Analysis of particle size

The invention can accurately judge whether a specific configuration item affects the performance of a configurable system, and is different from other software systems that regard the software system as a black box, sample the configuration space to obtain a configuration subset, and measure the system performance under a specific workload. A test method for performance under each configuration of this subset of configurations. These test methods can only determine whether a configuration affects the performance of a configurable system, and cannot be fine-grained to configuration items.

(4) Efficiency and completeness

The white-box performance analysis method proposed by someone in the existing scheme only supports configuration items of Boolean type or exhaustive finite numerical type (configuration items of exhaustive finite type need to be discrete into several Boolean type configuration items), which is a very large , and the number of configuration items increases significantly after discrete, and the running time of the tool increases exponentially. The invention only needs to analyze the source code of the configurable system once to determine whether a specific configuration item affects the performance of the configurable system. The type of the configuration item can cover all types allowed by Java programs, and is not limited to Boolean type or exhaustive The finite numerical type does not require hardware equipment to support the operation of the software system, no need to build an execution environment for the configurable system, and no need to consider the test overhead of the configurable system under different configurations of specific loads.

The embodiment of the present invention provides a ConfigAnalyzer tool. The ConfigAnalyzer analyzes the source code of the target system at one time and finds a set of configuration items that really affect the performance of the system, and the configuration items are not limited by types. Different from the traditional black-box method of constructing an accurate software system performance impact model, ConfigAnalyzer is interpretable. Users can analyze the configuration items and specific performance through the program analysis results generated by ConfigAnalyzer and the classification rules of the qualitative performance model. Operational relationship, and further understand the root cause of each configuration item affecting system performance.

Different from the existing method of constructing a performance impact model with white box thinking, ConfigAnalyzer does not require the hardware equipment, software environment, time, energy consumption and other overheads required to run a configurable software system. Limits, greatly reducing the cost of analyzing the relationship between configuration items and software system performance.

The qualitative performance impact model established by ConfigAnalyzer is evaluated through experiments. The results show that ConfigAnalyzer can accurately predict whether 84.21% of the configuration items in the tested software system will affect the performance without running the program, and it can effectively establish the software system. The qualitative performance affects the model, and it can be seen that ConfigAnalyzer has better accuracy performance.

It should be noted that the present invention includes but is not limited to the above-mentioned specific embodiments, as long as all technical solutions conforming to the inventive concept belong to the protection scope of the present invention, for example, the following contents also belong to the protection scope of the present invention:

(1) Replacing the static taint analysis used in the present invention with dynamic taint analysis, and combining with program testing to make the test coverage reach a higher level (80%-99%), the program analysis module in the present invention can also be obtained The output is used as input to the performance model module.

(2) Replacing the random forest classification model of the performance model module in the present invention with any classification model can classify configuration items, which may lose the interpretability of some classification results, but does not affect the generation of classification results.

(3) It is also possible to judge whether a configuration item affects the performance of a configurable system only by using configuration item sampling and program testing. Sampling each configuration item, and then performing the Cartesian product operation on the sampling results of each configuration item to obtain a subset of the configuration space (at this time, there is only a difference in the value of one configuration item between the configurations in the subset, except for this In addition to the configuration items, other configuration items are set to the same value), perform program performance test for each configuration in the subset, and analyze the program performance test results between different configurations to determine whether a configuration item affects the performance of the configurable system. performance or behavior.

Those skilled in the art can clearly understand that, for the convenience and brevity of description, the specific working process of the system, device and unit described above may refer to the corresponding process in the foregoing method embodiments, which will not be repeated here.

In the embodiments provided in this application, it should be understood that the disclosed system, apparatus and method may be implemented in other manners. For example, the apparatus embodiments described above are only illustrative. For example, the division of the units is only a logical function division. In actual implementation, there may be other division methods. For example, multiple units or components may be combined or Can be integrated into another system, or some features can be ignored, or not implemented. On the other hand, the shown or discussed mutual coupling or direct coupling or communication connection may be through some interfaces, indirect coupling or communication connection of devices or units, and may be in electrical, mechanical or other forms.

The units described as separate components may or may not be physically separated, and components displayed as units may or may not be physical units, that is, may be located in one place, or may be distributed to multiple network units. Some or all of the units may be selected according to actual needs to achieve the purpose of the solution in this embodiment.

In addition, each functional unit in each embodiment of the present invention may be integrated into one processing unit, or each unit may exist physically alone, or two or more units may be integrated into one unit. The above-mentioned integrated units may be implemented in the form of hardware, or may be implemented in the form of software functional units.

The integrated unit, if implemented in the form of a software functional unit and sold or used as an independent product, may be stored in a computer-readable storage medium. Based on this understanding, the technical solution of the present invention is essentially or the part that contributes to the prior art, or all or part of the technical solution can be embodied in the form of a software product, and the computer software product is stored in a storage medium , including several instructions for causing a computer device (which may be a personal computer, a server, or a network device, etc.) to execute all or part of the steps of the methods described in the various embodiments of the present invention. The aforementioned storage medium includes: U disk, removable hard disk, Read-Only Memory (ROM, Read-Only Memory), Random Access Memory (RAM, Random Access Memory), magnetic disk or optical disk and other media that can store program codes.

The above embodiments are only used to illustrate the technical solutions of the present invention, but not to limit them; although the present invention has been described in detail with reference to the foregoing embodiments, those of ordinary skill in the art should understand that: The recorded technical solutions are modified, or some technical features thereof are equivalently replaced; and these modifications or replacements do not make the essence of the corresponding technical solutions deviate from the spirit and scope of the technical solutions of the embodiments of the present invention.

Claims (10)

1. a method for analyzing the impact of a configuration item on software system performance, is characterized in that, comprising: Identify and mark all performance operations in the software system according to a code pattern preset by the software system, where the performance operations are time-intensive operations and/or space-intensive operations that affect the performance of the software system; Identify the dependency between each of the performance operations and each configuration item of the software system, and obtain a performance operation set corresponding to each of the configuration items, and each performance operation in the performance operation set has the same configuration as the configuration item. dependencies; constructing a feature vector corresponding to each of the configuration items according to the performance operation set; Input the feature vector corresponding to each of the configuration items into the trained qualitative performance impact model, determine whether the configuration item affects the performance of the software system, and obtain a set of configuration items that affect the performance of the software system, the qualitative performance impact model is to use It is obtained by training the feature vectors corresponding to the configuration items of multiple software systems. 2. The method for analyzing the impact of configuration items on software system performance according to claim 1, wherein the qualitative performance impact model comprises: Random forest classification model and configuration item dependency detector; Wherein, the random forest classification model performs binary classification on whether the configuration item affects the performance of the software system, and the configuration item depends on the detector to correct the classification result of the random forest classification model. 3. The method for analyzing the impact of a configuration item on software system performance according to claim 1, wherein the dependency relationship comprises: Data dependencies and control dependencies; The data dependencies are dependencies between data streams, and the control dependencies are dependencies caused by program control flows. 4. The method for analyzing the impact of configuration items on software system performance according to claim 3, wherein identifying the dependencies between each of the performance operations and each of the configuration items of the software system comprises: Identify data dependencies between each of the performance operations and each configuration item of the software system by using taint analysis; The program dependency graph is used to identify the control dependency relationship between each of the performance operations and the configuration items of the software system; the program dependency graph is constructed by using the program dependency analysis technology to describe the control dependency and data dependency of the program relation. 5. The method for analyzing the impact of configuration items on software system performance according to claim 4, wherein identifying data dependencies between each of the performance operations and each of the configuration items of the software system using taint analysis comprises: Enter the program entry of the software system, traverse the control flow, and create a taint at the configuration item loading API as a source point; Record the data propagation path of the source point and the finally reached sink point, then the performance operation at the sink point has a data dependency on the configuration item; the sink point is the program statement that the source point is not expected to reach, so The sink point is preset before the statement corresponding to the performance operation. 6 . The method for analyzing the impact of configuration items on software system performance according to claim 4 , wherein identifying the control dependencies between each of the performance operations and each of the configuration items of the software system by using a program dependency graph comprises the following steps: 7 . : Traverse all the nodes in the program dependency graph, and construct the control area of each configuration item, where the control area of the configuration item is a statement sequence that has a direct control dependency relationship with the configuration item; A control dependency relationship between each of the performance operations and each of the configuration items of the software system is identified according to the control area of each of the configuration items. 7. The method for analyzing the impact of configuration items on software system performance according to claim 2, wherein the training process of the random forest classification model comprises: Divide the feature vectors corresponding to the configuration items of multiple software systems into a training set and a test set; The random forest classification model is trained according to the training set and the random forest algorithm. 8. The method for analyzing the impact of configuration items on software system performance according to claim 2, wherein the configuration item-dependent detector revising the classification result of the random forest classification model comprises: When the first configuration item of the software system depends on the second configuration item, if the random forest classification model determines that the first configuration item affects the performance of the software system and the second configuration item does not affect the performance of the software system, then The configuration item dependency detector corrects the second configuration item to affect software system performance. 9. The method for analyzing the impact of configuration items on software system performance according to any one of claims 1 to 8, characterized in that, before identifying the dependencies between the performance operations and the configuration items of the software system Also includes: The configuration item information of the software system is extracted, where the configuration item information at least includes the name, quantity of the configuration item, and an API used when the configuration item is loaded into the software system. 10. A system for analyzing the impact of configuration items on software system performance, comprising: A performance operation identification module, configured to identify and mark all performance operations in the software system according to a code pattern preset by the software system, where the performance operations are time-intensive operations and/or space-intensive operations that affect the performance of the software system; A dependency relationship identification module is used to identify the dependency relationship between each of the performance operations and each configuration item of the software system, and obtain a performance operation set corresponding to each of the configuration items, and each performance operation in the performance operation set have dependencies with the configuration items; a feature vector building module, configured to build a feature vector corresponding to each of the configuration items according to the performance operation set; A configuration item set determination module, configured to input the feature vector corresponding to each of the configuration items into the trained qualitative performance impact model, determine whether the configuration item affects the performance of the software system, and obtain a set of configuration items that affect the performance of the software system, The qualitative performance impact model is obtained by training with feature vectors corresponding to configuration items of multiple software systems.

Images