Key node determination method and system for industrial operating system software test

Abstract

The invention discloses a key node determination method and system for industrial operating system software testing, and relates to the field of software testing, and the key node determination method comprises the following steps: constructing a software calling graph based on a calling relation of industrial operating system software; calculating the initial importance degree of each node in the software calling graph, and calculating the own importance degree of each node based on the importance degree transfer matrix of each node; iteratively calculating the interaction importance degree of each node according to the connection relationship among the nodes, and calculating the contribution degree value of each node according to the own importance degree of each node; and sorting the nodes according to the contribution degree values, and determining the key nodes of the industrial operating system software test according to a set threshold value or range. According to the method, automatic analysis and key node identification of the industrial operating system software can be realized, and the test efficiency and pertinence are improved, so that the labor cost and the time cost of iterative updating of the industrial operating system software are reduced.

Description

Technical Field

[0001] The present invention relates to the technical field of software testing, and more particularly to a method and system for determining key nodes in industrial operating system software testing. Background Art

[0002] Industrial operating system software is software used to manage and control industrial equipment and processes, usually including data collection and analysis, real-time monitoring and control, human-computer interaction, automated control logic programming, safety fault diagnosis and other functions. Industrial operating system software involves a large number of interfaces, protocols, control function modules and safety monitoring modules. In order to adapt to the complex and changing industrial production environment requirements, industrial operating system software suppliers need to work closely with industrial users, continuously iterate and optimize, and ensure that the system can continue to meet actual application needs.

[0003] However, in the iterative update of industrial operating system software, in order to ensure the safe and stable operation of the software, the industrial operating system software needs to be tested every time it is updated to ensure that the system software can run stably and normally. However, comprehensive testing of industrial operating system software requires a lot of manpower costs and testing time. For industrial operating system software suppliers, it will significantly increase the iterative update cost of system software. For industrial users, the longer testing time is not conducive to meeting the actual production needs of the factory. During the software iteration process, some modules or functional nodes are not updated or have little impact on the updated industrial operating system software. By determining the key nodes of the system software and conducting targeted testing, the testing time can be effectively reduced, the testing efficiency can be improved, and the testing cost can be reduced.

[0004] Therefore, how to determine the key points in the industrial operating system software testing process to improve the testing efficiency is a problem that technical personnel in this field urgently need to solve. Summary of the invention

[0005] In view of this, the present invention provides a method and system for determining key nodes in industrial operating system software testing, so as to determine the key points in the industrial operating system software testing process.

[0006] In order to achieve the above object, the present invention provides the following technical solutions:

[0007] The present invention discloses a method for determining key nodes of industrial operating system software testing, and the specific steps are as follows:

[0008] Construct a software call graph based on the calling relationship of industrial operating system software;

[0009] Calculating the initial importance of each node in the software call graph, and calculating the importance of each node based on the importance transfer matrix of each node;

[0010] According to the connection relationship between each node, the interaction importance of each node is iteratively calculated, and the contribution value of each node is calculated in combination with the self-importance of each node;

[0011] Sort each node according to its contribution value, and determine the key nodes of industrial operating system software testing based on the set threshold or range.

[0012] Furthermore, the construction of the software call graph specifically includes: obtaining the industrial operating system software code to be tested, taking each subsystem or link library as a parent node, and determining the edges between each parent node according to the calling relationship between each subsystem or the link library; taking each internal sub-module of the parent node as a child node, and determining the edges between each child node according to the calling relationship between each child node; and performing flattening processing to obtain the software call graph.

[0013] Furthermore, the calculation process of the initial importance is as follows:

[0014] Traversing the software call graph to determine the reachability relationship between nodes;

[0015] The distance between each node is determined by taking the distance of each edge as 1, and the reciprocal of the distance is taken as the efficiency value between two nodes;

[0016] Calculating the efficiency value of the software call graph according to the efficiency values ​​between the nodes;

[0017] For any node, the efficiency value of the software call graph after removing the node is calculated, and the initial importance of the node is calculated according to the efficiency value of the software call graph containing all nodes; the initial importance of all nodes is calculated one by one.

[0018] Furthermore, the calculation formula of the efficiency value between the two nodes is:

[0019]

[0020] Among them, ε ij represents the efficiency value between node i and node j, i = 1, 2, 3 ... N, j = 1, 2, 3 ... N, N is the total number of nodes; d ij Represents the distance between node i and node j;

[0021] The calculation formula of the efficiency value E of the software call graph is:

[0022]

[0023] The calculation formula of the initial importance is:

[0024]

[0025] Among them, C i represents the initial importance value of node i, E(G) represents the efficiency value of the software call graph containing all nodes, E(G′) represents the efficiency value of the software call graph after removing node i, G represents the software call graph set, and G′ represents the software call graph set after removing node i.

[0026] Furthermore, the calculation process of the self-importance is as follows:

[0027] Calculate the degree centrality of each node based on its degree;

[0028] Determine the set of second-order internal adjacent nodes of each node and calculate the influence effect between each node;

[0029] According to the degree centrality of node i, the influence of each node in the second-order inner neighbor node set of node i and node i, and the degree centrality of each node in the second-order inner neighbor node set of node i, the transmission probability between node i and any node j is calculated;

[0030] According to the transmission probability between each node and the initial importance, the importance transmission correlation matrix of each node is obtained, and the self-importance of each node is calculated.

[0031] Furthermore, the calculation formula of the degree centrality is:

[0032]

[0033] Among them, DC(i) represents the degree centrality of node i, L i represents the degree of node i, N is the total number of nodes;

[0034] The calculation formula of the influence effect between the nodes is:

[0035]

[0036] Among them, DD(i,j) represents the influence effect between node i and node j, d ij represents the distance between node i and node j, τ i Represents the set of second-order inner adjacent nodes of node i;

[0037] The calculation formula of the transmission probability is:

[0038]

[0039] Among them, p ij represents the transmission probability between node i and node j, DC(j) represents the degree centrality of node j, and DD(i,k) represents τ iThe influence of any node k on node i, DC(k) represents the degree centrality of node k;

[0040] The calculation formula of the self-importance is:

[0041]

[0042] Among them, I j represents the importance value of node j, C j Represents the initial importance value of node j.

[0043] Furthermore, the calculation process of the interaction importance is as follows:

[0044] Determine the entire task chain based on the connection relationship between each node;

[0045] Determine an in-chain set and an out-chain set of each node according to the task chain;

[0046] Determine the root node of each task chain according to the task chain, calculate the average distance between each node and the root node, and number them in order from small to large according to the average distance;

[0047] Assign an initial interaction importance value to each node, and iteratively calculate the interaction importance value of each node in the order of the node numbers;

[0048] Determine whether the number of iterations is less than the maximum length of the task chain. If so, recalculate the interaction importance value of each node in the order of the node numbers; otherwise, stop the iteration and use the current interaction importance value of each node as the final interaction importance value of each node.

[0049] Furthermore, the formula for the iterative calculation is:

[0050]

[0051] in, represents the interaction importance value of node i after the t+1th iteration; z represents the damping coefficient; B(i) represents the in-link set of node i, v represents the node with a distance of 1 from node i in the in-link set, and n is the total number of nodes v; PR t (v) represents the interaction importance value of node v after the tth iteration; m(v) is the total number of outbound links of node v; p(v) is the ratio of the total number of inbound links to the total number of outbound links of node v, which represents the authority of node v.

[0052] Furthermore, the contribution value calculation formula is:

[0053] w i =k1×I i +k2×PR(i);

[0054] Among them, w i Represents the contribution value of node i, I i The node i’s own importance value, PR(i) represents the interaction importance value of node i, k1 and k2 are standardization coefficients, k1=0.15 and k2=0.85.

[0055] The present invention also discloses a key node determination system for industrial operating system software testing, comprising:

[0056] Call graph construction module: builds software call graph based on the call relationship of industrial operating system software;

[0057] A self-importance calculation module: calculates the initial importance of each node in the software call graph, and calculates the self-importance of each node based on the importance transfer matrix of each node;

[0058] Contribution value calculation module: iteratively calculates the interaction importance of each node according to the connection relationship between each node, and calculates the contribution value of each node according to the self-importance of each node;

[0059] Key node determination module: Sort each node according to the contribution value, and determine the key nodes of the industrial operating system software according to the set threshold or range.

[0060] It can be known from the above technical solutions that, compared with the prior art, the present invention discloses a method and system for determining key nodes in industrial operating system software testing, abstracting the interfaces, protocols, functional modules, functions, link library files, etc. involved in the system software into nodes, and modeling the industrial operating system software in a two-level manner, which can comprehensively and systematically characterize the operating system software. At the same time, by systematically analyzing the self-importance of each node, the importance of each node in the industrial operating system software is evaluated; according to the relationship of the task chain, the interactive importance of each node is analyzed, so as to evaluate the comprehensive contribution of each node according to the self-importance and interactive importance of each node, and determine the final key node by sorting and threshold. The present invention can realize the automated analysis and key node identification of industrial operating system software, improve the efficiency and pertinence of testing, thereby reducing the labor cost and time cost of iterative updates of industrial operating system software, and improving the benefits and service level of software suppliers. BRIEF DESCRIPTION OF THE DRAWINGS

[0061] In order to more clearly illustrate the embodiments of the present invention or the technical solutions in the prior art, the drawings required for use in the embodiments or the description of the prior art will be briefly introduced below. Obviously, the drawings described below are only embodiments of the present invention. For ordinary technicians in this field, other drawings can be obtained based on the provided drawings without paying creative work.

[0062] Figure 1 It is a schematic diagram of the overall process of an embodiment of the present invention.

[0063] Figure 2 Schematic diagram of child nodes and parent nodes according to an embodiment of the present invention.

[0064] Figure 3 It is a schematic diagram of a software call graph obtained after flattening processing according to an embodiment of the present invention. DETAILED DESCRIPTION

[0065] The following will be combined with the drawings in the embodiments of the present invention to clearly and completely describe the technical solutions in the embodiments of the present invention. Obviously, the described embodiments are only part of the embodiments of the present invention, not all of the embodiments. Based on the embodiments of the present invention, all other embodiments obtained by ordinary technicians in this field without creative work are within the scope of protection of the present invention.

[0066] The embodiment of the present invention discloses a method for determining key nodes of industrial operating system software testing, such as Figure 1 As shown, the specific steps are as follows:

[0067] Construct a software call graph based on the calling relationship of industrial operating system software;

[0068] Calculate the initial importance of each node in the software call graph, and calculate the importance of each node based on the importance transfer matrix of each node;

[0069] According to the connection relationship between each node, the interaction importance of each node is iteratively calculated, and the contribution value of each node is calculated in combination with the importance of each node itself;

[0070] Sort each node according to its contribution value, and determine the key nodes of industrial operating system software testing based on the set threshold or range.

[0071] In a specific embodiment, constructing a software call graph specifically includes: obtaining the industrial operating system software code to be tested, taking each subsystem or link library as a parent node, and determining the edges between each parent node according to the calling relationship of each subsystem or link library; taking each internal sub-module of the parent node as a child node, and determining the edges between each child node according to the calling relationship of each child node; and performing flattening processing to obtain a software call graph.

[0072] Specifically, in industrial operating system software testing, key nodes refer to critical time points or key links in a process, project or task. These nodes are usually key points of interaction between software modules, such as communication interfaces, data processing nodes, etc. These nodes have a decisive impact on the function and performance of the entire software system. By identifying and testing key nodes, the testing team can conduct more targeted testing, thereby improving testing efficiency; key nodes are usually the most problematic parts of the system, so focusing on testing them helps to promptly discover and fix potential problems and ensure system stability; by testing key nodes, the correctness and reliability of the software in key functions can be ensured, thereby improving the overall quality of the software; key nodes can also be used to test program execution anomalies, determine the location of code injection, etc.

[0073] Industrial operating system software is usually composed of multiple subsystems or basic link libraries, and each subsystem or link library is composed of multiple modules, calling functions, etc. Therefore, first obtain the industrial operating system software code to be tested, and divide it into multiple large parent nodes according to the function and scale of the software, and determine the calling relationship of each parent node; then abstract each module, function, etc. in each parent node into multiple child nodes, and determine the directed edges of each child node according to the calling relationship, and determine the initial child node and parent node connection relationship diagram, such as Figure 2 Finally, the child node and parent node connection relationship graph is flattened, that is, it is determined through which child nodes the connection relationship of each parent node is actually established, and the edges connecting the parent nodes are replaced with the edges connecting the child nodes to obtain the final software call graph, as shown in Figure 3 By constructing a software call graph and abstracting each module and function into a node, the difficulty of determining the corresponding relationship between the two can be greatly reduced.

[0074] In a specific embodiment, the calculation process of the initial importance is as follows:

[0075] The software call graph is traversed to determine the reachability relationship between each node; specifically, the edges between each node in the software call graph are directed edges, and whether the two nodes are reachable can be determined by determining whether all the same-direction edges exist in any link among all the links between the two nodes.

[0076] For two reachable nodes, the distance between each node is determined by taking the distance of each edge as 1, and the inverse of the distance is taken as the efficiency value between the two nodes;

[0077] Calculate the efficiency value of the software call graph according to the efficiency value between each node;

[0078] For any node, the efficiency value of the software call graph after removing the node is calculated, and the initial importance of the node is calculated according to the efficiency value of the software call graph containing all nodes; the initial importance of all nodes is calculated one by one.

[0079] Specifically, any node in the call graph does not exist in isolation, and is inevitably affected and restricted by adjacent nodes. Nodes and links form a unified whole and play a role together, and this mutual influence relationship between nodes can be described by the node importance transfer probability matrix. This method avoids the change of the call graph topology structure by algorithms such as the node shrinkage method, and when the topology structure changes, the node importance transfer matrix will also change accordingly, which has strong adaptability to the call graph.

[0080] For a connected call graph, in addition to its own functions, a node also needs to complete a task of the industrial operating system with other nodes connected to it. Moreover, the influence of each node in the call graph is different. For example, for the root node, its importance is often greater than that of the leaf node. The more important a node is, the greater its influence on the entire call graph. Once it fails, the impact on the function and performance of the entire operating system represented by the call graph will be greater. Therefore, considering this point, we borrow the idea of ​​node deletion method to remove individual nodes in the call graph one by one, and consider the changes in the structure, efficiency and functional integrity of the call graph before and after deletion. Once a functional module or function represented by a node has a bug, the node function fails, and the functional integrity of each task of the node connected to it is also at risk of failure. Depending on the node, the effect of deleting the node may be very different. If a node is very important, removing it will bring about changes in the call graph structure and a sharp decline in the function and efficiency of the industrial operating system software represented by the call graph; if it is a terminal node, removing it will have a smaller impact and have a lower priority in the system software iteration test.

[0081] In a specific embodiment, the calculation formula of the efficiency value between two nodes is:

[0082]

[0083] Among them, ε ij represents the efficiency value between node i and node j, i = 1, 2, 3 ... N, j = 1, 2, 3 ... N, N is the total number of nodes; d ij Represents the distance between node i and node j;

[0084] The calculation formula of the efficiency value E of the software call graph is:

[0085]

[0086] The calculation formula for the initial importance is:

[0087]

[0088] Among them, C i represents the initial importance value of node i, E(G) represents the efficiency value of the software call graph containing all nodes, E(G′) represents the efficiency value of the software call graph after removing node i, G represents the software call graph set, and G′ represents the software call graph set after removing node i.

[0089] In a specific embodiment, the calculation process of the self-importance is as follows:

[0090] Calculate the degree centrality of each node based on its degree;

[0091] Determine the set of second-order internal adjacent nodes of each node and calculate the influence effect between each node;

[0092] According to the degree centrality of node i, the influence of each node in the second-order inner neighbor node set of node i and node i, and the degree centrality of each node in the second-order inner neighbor node set of node i, the transmission probability between node i and any node j is calculated;

[0093] According to the transmission probability and initial importance between each node, the importance transmission correlation matrix of each node is obtained, and the importance of each node itself is calculated.

[0094] Specifically, if the degree of a node is smaller, it is more susceptible to the influence of other nodes; conversely, if the node degree is larger, that is, it has more adjacent nodes, then when one of the nodes fails, due to the existence of other adjacent nodes, its importance will not change too much, and there is an inverse relationship between them. Degree centrality is the simplest evaluation indicator for evaluating node centrality. The more edges a node is connected to, the greater the degree centrality of the node, and the more critical the node is in the call graph. Since the importance contribution of a node to other nodes is different, and the node degree centrality can intuitively reflect the influence of the node in the call graph, we choose to use degree centrality to determine the dependency relationship between the importance of nodes. In addition, the influence between nodes is inversely proportional to the shortest distance between the two points, that is, the shorter the distance between the two points, the greater the interaction between the nodes, and vice versa.

[0095] In a specific embodiment, the calculation formula of degree centrality is:

[0096]

[0097] Among them, DC(i) represents the degree centrality of node i, L i represents the degree of node i, N is the total number of nodes;

[0098] The calculation formula for the influence effect between nodes is:

[0099]

[0100] Among them, DD(i,j) represents the influence effect between node i and node j, d ij represents the distance between node i and node j, τ i represents the set of second-order inner adjacent nodes of node i, that is, the set of nodes whose distance from node i is 2;

[0101] The formula for calculating the transmission probability is:

[0102]

[0103] Among them, p ij represents the transmission probability between node i and node j, DC(j) represents the degree centrality of node j, and DD(i,k) represents τ i The influence of any node k on node i, DC(k) represents the degree centrality of node k;

[0104] The importance transfer correlation matrix is ​​expressed as:

[0105]

[0106] Among them, H ij Represents the importance contribution value of node i to node j. By using the node importance transfer matrix and comprehensively considering the global call graph efficiency and local transfer probability of the node, the calculation formula of its own importance can be defined as:

[0107]

[0108] Among them, I j represents the importance value of node j, C j Represents the initial importance value of node j.

[0109] It can be seen that the importance of a node is related to the importance of the node itself, degree centrality and distance between nodes. It integrates the global information and local information of the node and can improve the evaluation accuracy. When the topological structure changes, the importance of the node itself and the distance between nodes will change accordingly. The evaluation algorithm can effectively feedback the node importance value, which meets the actual needs of the call graph node importance evaluation.

[0110] In a specific embodiment, the calculation process of the interaction importance is as follows:

[0111] Determine the entire task chain based on the connection relationship between each node;

[0112] Determine the in-chain set and out-chain set of each node according to the task chain;

[0113] Determine the root node of each task chain based on the task chain, calculate the average distance between each node and the root node, and number them in order from small to large according to the average distance;

[0114] Assign an initial interaction importance value to each node, and iteratively calculate the interaction importance value of each node in the order of the node numbers;

[0115] Determine whether the number of iterations is less than the maximum length of the task chain. If so, recalculate the interaction importance value of each node in the order of the node numbers; otherwise, stop the iteration and use the current interaction importance value of each node as the final interaction importance value of each node.

[0116] Specifically, in the functions and tasks of the industrial software operating system, the interaction between a node and other nodes is realized by calling each node in sequence. This process is abstracted as a task chain, such as Figure 3 As shown in the figure, the red line represents a task chain, in which the direction of the directed edge of each node is not shown. Therefore, it can be considered that when the function of a node fails, the node can no longer undertake the collaborative task assigned by the functional task, and the industrial software operating system will not be able to implement the functional task. Therefore, by providing each node with an initial interaction importance value (value of 1), and performing iterative update calculations according to the task chain relationship of each node, the final interaction importance value of each node is obtained. Among them, the interaction between each node and other nodes can be abstracted as the set of nodes i pointing to other nodes, and the set of nodes pointing to node i. During the iterative update, each node evenly distributes its current interaction importance value to the outbound links included in this node, so that each link obtains the corresponding weight; and each node sums the weights passed in by all the inbound links pointing to this node to obtain the new interaction importance value of this node; when each node obtains the updated interaction importance value, a round of update is completed. When updating nodes, considering the practical significance of nodes, existing drift, node weight averaging and other problems, damping coefficients and authority are introduced.

[0117] In a specific embodiment, the formula for iterative calculation is:

[0118]

[0119] in, represents the interaction importance value of node i after the t+1th iteration; z represents the damping coefficient; B(i) represents the in-link set of node i, v represents the node with a distance of 1 from node i in the in-link set, and n is the total number of nodes v; PR t (v)represents the interaction importance value of node v after the tth iteration; m(v) is the total number of outbound links of node v; p(v) is the ratio of the total number of inbound links to the total number of outbound links of node v, which represents the authority of node v.

[0120] In a specific embodiment, the contribution value calculation formula is:

[0121] w i =k1×I i +k2×PR(i);

[0122] Among them, w i Represents the contribution value of node i, I i The node i’s own importance value, PR(i) represents the interaction importance value of node i, k1 and k2 are standardization coefficients, k1=0.15 and k2=0.85.

[0123] In a specific embodiment, after determining the final contribution value of each node, the nodes are sorted according to the contribution value, and the threshold of the contribution value is set, or according to the ranking range, for example, the top 30% of the nodes are used as the key nodes for industrial operating system software testing. Targeted testing is performed according to the functional modules, communication interfaces, data processing nodes, functional functions, etc. corresponding to the key nodes. The proportion of test cases for the software code corresponding to each node can also be set according to the proportion of the contribution values ​​of all nodes, thereby improving the efficiency of software testing.

[0124] The embodiment of the present invention also discloses a key node determination system for industrial operating system software testing, including:

[0125] Call graph construction module: builds software call graph based on the call relationship of industrial operating system software;

[0126] Self-importance calculation module: calculates the initial importance of each node in the software call graph, and calculates the self-importance of each node based on the importance transfer matrix of each node;

[0127] Contribution value calculation module: According to the connection relationship between each node, it iteratively calculates the interaction importance of each node, and calculates the contribution value of each node according to the importance of each node itself;

[0128] Key node determination module: Sort each node according to the contribution value, and determine the key nodes of the industrial operating system software according to the set threshold or range.

[0129] In this specification, each embodiment is described in a progressive manner, and each embodiment focuses on the differences from other embodiments. The same or similar parts between the embodiments can be referred to each other. For the device disclosed in the embodiment, since it corresponds to the method disclosed in the embodiment, the description is relatively simple, and the relevant parts can be referred to the method part.

[0130] The above description of the disclosed embodiments enables one skilled in the art to implement or use the present invention. Various modifications to these embodiments will be apparent to one skilled in the art, and the general principles defined herein may be implemented in other embodiments without departing from the spirit or scope of the present invention. Therefore, the present invention will not be limited to the embodiments shown herein, but rather to the widest scope consistent with the principles and novel features disclosed herein.

Claims

1. A method for determining key nodes in industrial operating system software testing, characterized in that: The specific steps are as follows: Construct a software call graph based on the calling relationship of industrial operating system software; Calculating the initial importance of each node in the software call graph, and calculating the importance of each node based on the importance transfer matrix of each node; According to the connection relationship between each node, the interaction importance of each node is iteratively calculated, and the contribution value of each node is calculated in combination with the self-importance of each node; Sort each node according to its contribution value, and determine the key nodes of industrial operating system software testing based on the set threshold or range.

2. The method for determining key nodes of industrial operating system software testing according to claim 1, characterized in that: The construction of the software call graph specifically includes: obtaining the industrial operating system software code to be tested, taking each subsystem or link library as a parent node, and determining the edges between each parent node according to the calling relationship between each subsystem or the link library; taking each internal sub-module of the parent node as a child node, and determining the edges between each child node according to the calling relationship between each child node; and performing flattening processing to obtain the software call graph.

3. The method for determining key nodes of industrial operating system software testing according to claim 1, characterized in that: The calculation process of the initial importance is as follows: Traversing the software call graph to determine the reachability relationship between nodes; The distance between each node is determined by taking the distance of each edge as 1, and the reciprocal of the distance is taken as the efficiency value between two nodes; Calculating the efficiency value of the software call graph according to the efficiency values ​​between the nodes; For any node, the efficiency value of the software call graph after removing the node is calculated, and the initial importance of the node is calculated according to the efficiency value of the software call graph containing all nodes; the initial importance of all nodes is calculated one by one.

4. The method for determining key nodes of industrial operating system software testing according to claim 3 is characterized in that: The calculation formula of the efficiency value between the two nodes is: Among them, ε ij represents the efficiency value between node i and node j, i = 1, 2, 3 ... N, j = 1, 2, 3 ... N, N is the total number of nodes; d ij Represents the distance between node i and node j; The calculation formula of the efficiency value E of the software call graph is: The calculation formula of the initial importance is: Among them, C i represents the initial importance value of node i, E(G) represents the efficiency value of the software call graph containing all nodes, E(G′) represents the efficiency value of the software call graph after removing node i, G represents the software call graph set, and G′ represents the software call graph set after removing node i.

5. The method for determining key nodes of industrial operating system software testing according to claim 1, characterized in that: The calculation process of the self-importance is as follows: Calculate the degree centrality of each node based on its degree; Determine the set of second-order internal adjacent nodes of each node and calculate the influence effect between each node; According to the degree centrality of node i, the influence of each node in the second-order inner neighbor node set of node i and node i, and the degree centrality of each node in the second-order inner neighbor node set of node i, the transmission probability between node i and any node j is calculated; According to the transmission probability between each node and the initial importance, the importance transmission correlation matrix of each node is obtained, and the self-importance of each node is calculated.

6. A method for determining key nodes of industrial operating system software testing according to claim 5, characterized in that: The calculation formula of the degree centrality is: Among them, DC(i) represents the degree centrality of node i, L i represents the degree of node i, N is the total number of nodes; The calculation formula of the influence effect between the nodes is: Among them, DD(i,j) represents the influence effect between node i and node j, d ij represents the distance between node i and node j, τ i Represents the set of second-order internal adjacent nodes of node i; The calculation formula of the transmission probability is: Among them, p ij represents the transmission probability between node i and node j, DC(j) represents the degree centrality of node j, and DD(i,k) represents τ i The influence of any node k on node i, DC(k) represents the degree centrality of node k; The calculation formula of the self-importance is: Among them, I j represents the importance value of node j, C j Represents the initial importance value of node j.

7. The method for determining key nodes of industrial operating system software testing according to claim 1, characterized in that: The calculation process of the interaction importance is as follows: Determine the entire task chain based on the connection relationship between each node; Determine an in-chain set and an out-chain set of each node according to the task chain; Determine the root node of each task chain according to the task chain, calculate the average distance between each node and the root node, and number them in order from small to large according to the average distance; Assign an initial interaction importance value to each node, and iteratively calculate the interaction importance value of each node in the order of the node numbers; Determine whether the number of iterations is less than the maximum length of the task chain. If so, recalculate the interaction importance value of each node in the order of the node numbers. Otherwise, the iteration is stopped, and the current interaction importance values ​​of each node are used as the final interaction importance values ​​of each node.

8. The method for determining key nodes of industrial operating system software testing according to claim 7, characterized in that: The formula for the iterative calculation is: in, represents the interaction importance value of node i after the t+1th iteration; z represents the damping coefficient; B(i) represents the in-link set of node i, v represents the node with a distance of 1 from node i in the in-link set, and n is the total number of nodes v; PR t (v) represents the interaction importance value of node v after the tth iteration; m(v) is the total number of outbound links of node v; p(v) is the ratio of the total number of inbound links to the total number of outbound links of node v, which represents the authority of node v.

9. The method for determining key nodes of industrial operating system software testing according to claim 1, characterized in that: The contribution value calculation formula is: In i =k1×I i +k2×PR(i); Among them, w i Represents the contribution value of node i, I i The node i’s own importance value, PR(i) represents the interaction importance value of node i, k1 and k2 are standardization coefficients, k1=0.15 and k2=0.

85.

10. A key node determination system for industrial operating system software testing, applying a key node determination method for industrial operating system software testing according to any one of claims 1 to 9, characterized in that: include: Call graph construction module: builds software call graph based on the call relationship of industrial operating system software; A self-importance calculation module: calculates the initial importance of each node in the software call graph, and calculates the self-importance of each node based on the importance transfer matrix of each node; Contribution value calculation module: iteratively calculates the interaction importance of each node according to the connection relationship between each node, and calculates the contribution value of each node according to the self-importance of each node; Key node determination module: Sort each node according to the contribution value, and determine the key nodes of the industrial operating system software according to the set threshold or range.

Images