Error rate based dependent task priority

Abstract

A method for dependency task prioritization is disclosed. The method includes providing base data including task identifiers, failure values, and dependency data values, where each dependency data value is associated with a pair of tasks. The method also includes generating a probabilistic model using a directed acyclic graph, where each task is associated with a network node and each dependency data value is associated with a network edge of the directed acyclic graph, where each dependency data value represents a conditional probability related to a respective per-time-unit failure rate. Additionally, the method includes determining, for each task in the directed acyclic graph, a posterior marginal probability value representing a probability of the task experiencing a failure, and selecting, based on the posterior marginal probability values, a sequence of tasks that are most likely to fail the fastest.

Description

Background Technology

[0001] Various aspects of the present invention generally relate to a method for controlling tasks, and more specifically, to a computer implementation method for prioritizing dependent tasks. Various aspects of the present invention also relate to a dependent task prioritization system for dependent task priorities, and a related computer program product. Related technologies

[0002] Computer systems, especially their software applications (and operating system components), are now largely modular. Increasingly, services running on different servers and cloud environments need to work together to ensure a good user experience. Testing such systems—whether entirely new developments or component upgrades—is becoming increasingly challenging due to the numerous dependencies between different software components. Therefore, test case prioritization—the order in which test cases are executed to achieve a higher defect detection rate—is becoming increasingly important. This is because test case prioritization aims to balance two crucial constraints in software testing and development: time and budget, in order to find bugs as quickly as possible. The earlier bugs and software code are identified and eliminated, the faster reliable software can be developed. This becomes a competitive advantage for manufacturers of standard software, as well as IT departments of enterprises and consulting firms.

[0003] However, for other components that depend on each other in many permutations and combinations, it may also be advantageous to identify alternatives as quickly as possible to save computational resources. This could be in Natural Language Processing (NLP) or autonomous driving, for example. Similarly, it is important to eliminate alternatives with a lower probability of correct interpretation as quickly as possible. Therefore, the same priority requirements as for test cases in software development apply to such systems.

[0004] Several publications have emerged in this context. For example, document US 2008 / 0 256 392 A1 describes a technique for prioritizing test dependencies. Computer systems employing such techniques can present a test structure for a set of test cases. This test structure can include prioritized test cases and dependencies between them. These dependencies can be based on predicted test case failures caused by the failure of another test case. Furthermore, the paper "TestCases Prioritization using Open Dependency Structure Algorithm" by Indumathi, CP, and Selvamani K., published in Procedia Computer Science 48 (2015), 250-255 and presented at the International Conference on Intelligent Computing and Communication Convergence (ICCC-2014), also describes test case prioritization as a key element in detecting errors and improving the early error detection rate of relationships between dependent components.

[0005] In summary, experience shows that generating a simple tree containing all possible test case sequences is extremely inefficient. Similarly, simply using error propagation probabilities offers only limited advantages, as it works well only when all test runs take roughly the same amount of time. However, if the execution times of components in the test chain differ, more advanced test case priority metrics may be required.

[0006] Therefore, the industry needs to propose a method for prioritizing test cases based on the error propagation probability and dependencies per unit of time. Summary of the Invention

[0007] According to one aspect of the invention, a computer-implemented method for prioritizing tasks can be provided. The method may include providing basic data including task identifiers, each task identifier indicating a corresponding task, failure values, each failure value indicating a failure rate per unit time for the corresponding task, and dependency data values, each dependency data value associated with a pair of tasks. The method may further include generating a probabilistic model based on the basic data, wherein tasks and associated dependency data values ​​are associated with a directed acyclic graph (DAG), and each task is associated with a network node of the DAG, each dependency data value is associated with a network edge of the DAG, wherein each dependency data value indicates a conditional probability associated with a corresponding failure rate per unit time.

[0008] Furthermore, the method may include determining a posterior marginal probability value for each task in the directed acyclic graph, indicating the probability of task failure, and selecting a sequence of tasks most likely to fail the fastest based on the posterior marginal probability value.

[0009] According to another aspect of the invention, a task priority dependency system can be provided. The system may include one or more processors and a memory operatively coupled to the one or more processors, wherein the memory stores program code portions that, when executed by the one or more processors, enable the one or more processors to provide basic data, the basic data including task identifiers, wherein each task identifier indicates a corresponding task; failure values, wherein each failure value indicates a failure rate per unit time for the corresponding task; and dependency data values, wherein each dependency data value is associated with a pair of tasks.

[0010] The one or more processors can also be configured to generate probabilistic models based on underlying data, wherein task and associated dependency data values ​​are associated with a directed acyclic graph, each task is associated with a network node of the directed acyclic graph, each dependency data value is associated with a network edge of the directed acyclic graph, and each dependency data value indicates a conditional probability associated with the corresponding failure rate per unit of time.

[0011] Furthermore, the processor can be configured to determine a posterior marginal probability value for each task in the directed acyclic graph, which indicates the probability of task failure; and based on the posterior marginal probability value, select the sequence of tasks most likely to fail the fastest. Furthermore, embodiments may take the form of a related computer program product accessible from a computer-usable or computer-readable medium that provides program code for use by or connection to a computer or any instruction execution system. For the purposes of this description, a computer-usable or computer-readable medium may be any means capable of containing, storing, communicating, propagating, or transmitting the program for use by or connection to an instruction execution system, apparatus, or device. Attached Figure Description

[0012] It should be noted that embodiments of the present invention are described with reference to different subject matters. Specifically, some embodiments are described with reference to method-type claims, while others are described with reference to apparatus-type claims. However, those skilled in the art will understand from the foregoing and following description that, unless otherwise stated, any combination of features relating to different subject matters, particularly combinations of features between method-type claims and apparatus-type claims, is also considered disclosed in this document, except for any combination of features belonging to one subject matter.

[0013] The aspects defined above, as well as other aspects of the invention, will be apparent from the examples of embodiments described below and explained with reference to these examples, but the invention is not limited to these examples.

[0014] Preferred embodiments of the inventive concept are described with reference to the following figures. These embodiments are merely examples, and the inventive concept—variants and at least partial alternatives exist—is not limited thereto:

[0015] Figure 1 A block diagram illustrating an embodiment of a computer implementation method for task priority-dependent processing according to the present invention is shown.

[0016] Figure 2 It showed in Figure 1 A block diagram of an embodiment of the inventive concept described in the context of [the present invention].

[0017] Figure 3 A diagram showing a basic dependency example, along with a corresponding success / failure table, is provided.

[0018] Figure 4 A diagram of a basic dependency example and the associated Bayesian network diagram are shown again.

[0019] Figure 5 It showed Figure 4 The Bayesian network diagram and a chart of three potential outcomes.

[0020] Figure 6 The diagram illustrates an embodiment of the greedy method used in the present invention and the results thereof.

[0021] Figure 7 A flowchart illustrating a best-first-exploration (BFS) embodiment of the present invention is shown.

[0022] Figure 8 A diagram illustrating a BFS implementation and its results is provided.

[0023] Figure 9 A flowchart illustrating an embodiment of the KNN concept of the present invention is shown.

[0024] Figure 10 A graph showing an example of KNN and its results is provided.

[0025] Figure 11 A block diagram illustrating an embodiment of a creative task priority-dependent system based on the present invention is shown.

[0026] Figure 12 It shows including according to Figure 11 An example of a computing system. Detailed Implementation

[0027] Embodiments of the present invention can be described as follows:

[0028] According to one embodiment of the present invention, a computer-implemented method for prioritizing task dependencies can be provided. The method may include providing basic data including task identifiers, each task identifier indicating a corresponding task, failure values, each failure value indicating a failure rate per unit time for the corresponding task, and dependency data values, each dependency data value being associated with a pair of tasks. The method may further include generating a probabilistic model based on the basic data, wherein tasks and associated dependency data values ​​are associated with a directed acyclic graph (DAG), and each task is associated with a network node of the DAG, each dependency data value is associated with a network edge of the DAG, wherein each dependency data value indicates a conditional probability associated with a corresponding failure rate per unit time.

[0029] Furthermore, the method may include determining a posterior marginal probability value for each task in the directed acyclic graph that indicates the probability of task failure, and selecting a sequence of tasks most likely to fail the fastest based on the posterior marginal probability value.

[0030] According to another related embodiment, a task priority system for task priority can be provided. The system may include one or more processors and memory operatively coupled to the one or more processors, wherein the memory stores program code portions that, when executed by the one or more processors, enable the one or more processors to provide basic data, including task identifiers, wherein each task identifier indicates a corresponding task, failure values, wherein each failure value indicates a failure rate per unit time for the corresponding task, and dependency data values, wherein each dependency data value is associated with a pair of tasks.

[0031] The one or more processors are also capable of generating probabilistic models based on underlying data, where task and associated dependency data values ​​are associated with a directed acyclic graph, each task is associated with a network node of the directed acyclic graph, each dependency data value is associated with a network edge of the directed acyclic graph, and each dependency data value indicates a conditional probability associated with the corresponding failure rate per unit time.

[0032] Furthermore, the processor can determine the posterior marginal probability value indicating the probability of task failure for each task in the directed acyclic graph; and based on these posterior marginal probability values, select the sequence of tasks most likely to fail the fastest.

[0033] The proposed computer implementation method for time series prediction of time series data with periodic behavior greater than the corresponding sampling rate offers multiple advantages, technical benefits, contributions, and / or improvements:

[0034] First, the concept proposed in this paper overcomes the limitations of existing test case prioritization methods because it adopts a more dynamic and flexible approach, not requiring all tests to have roughly the same execution time. Therefore, a better balance can be achieved between the time required to run a specific test case and budget / computing resources. This is based on identifying the test cases with the highest probability of failure compared to all permutations of other dependent components first—or at least as early as possible.

[0035] The three proposed implementation options—a "greedy" approach, a breadth-first search (BFS) based approach, and a K-nearest neighbor approach—allow for selection between speed and required computational resources. This enables test case managers to choose different implementation options based on the type of software development project or other application domain. This may be acceptable for the development of highly safe control systems for potentially hazardous materials, simple IoT (Internet of Things) systems, commercial software applications, and operating systems or middleware components with different fault tolerance levels.

[0036] However, there are other additional benefits, such as saving resources in regression testing by increasing the probability of early failures. The inventive concept can also reduce risk and project risk by conducting real-world testing on the highest-risk tasks as quickly as possible, and can shorten development time due to shorter developer feedback loops. All of this is based on efficiently discovering sequences of execution tests or sequences of other dependencies, based on specific objective functions, such as using Bayesian network representations of the input tests and the associated prior failure rate per unit of time. Due to its relatively broad scope, the inventive concept can be advantageously implemented in several different fields, such as regression testing and software development, for example, for highly complex mainframe, power system, quantum firmware development, project planning and management, and scheduling of operating system development projects. Applications in areas such as autonomous driving, NLP, and launching large software systems (such as operating systems and large enterprise or real-time control applications) can also benefit from the inventive concept, as conflicts between competing modules executing in parallel on hardware resources can be successfully avoided.

[0037] Additional embodiments of the inventive concept applicable to the method and system will be described below.

[0038] According to an advantageous embodiment of the method, selecting the sequence of tasks most likely to fail the fastest may include selecting the sequence of tasks with the highest sum of increasing failure probabilities among adjacent tasks—for example, denoted as F(X), see below. Adjacent tasks may represent tasks at the same level in the dependency tree. For implementation purposes, using the value 1 – F(X) may be better, where X represents a sequence of tasks (e.g., ABE, where A, B, and E represent both tasks and nodes in the tree). In this case, the “sequence of tasks with the highest sum of increasing failure probabilities among adjacent tasks” can be achieved by selecting the lowest value of 1 – F(X) to avoid overflow. This is because in larger trees, many probability values ​​are very close to “1”. By accumulating the increasing failure probabilities and rounding errors, it is likely in most cases to unexpectedly “exceed 1”. This is much less likely to occur when using 1 – F(X).

[0039] According to a very useful embodiment of this method, the task can be a testing task for the system under test. This also presents a very good use case scenario. Therefore, the task can be any combination of the following: tasks related to the setup of developed software components, installed hardware components, network infrastructure components, and tasks related to configuring cloud computing services.

[0040] According to another interesting embodiment of this method, the task can be a project task, and the failure rate per unit of time can be the risk value of the corresponding project task. The overall goal / purpose might be to minimize the overall risk of the project, such as exceeding the set deadline or jeopardizing the entire project. Therefore, a normalized risk value can be used as the risk value to achieve comparability.

[0041] According to another advantageous embodiment of the method, the task can be one service in the startup process of an operating system that includes multiple services, and the failure rate per unit time can represent the probability that the service has failed to complete. In one scenario, this might be because another "earlier" process has not yet finished. The multiple services can also be large enterprise applications, such as ERP (Enterprise Resource Planning), CRM (Customer Relationship Management), or SCM / Logistics (Supply Chain Management) systems with a large number of internal dependencies, complex database systems, patent management systems, and IoT (Internet of Things) systems that use measurement data to control actuators, or any other complex (software or computing) system.

[0042] According to an advantageous embodiment of this method, the directed acyclic graph can be a Bayesian network graph. This type of network graph has proven to be easier to use, understand, implement, and serve as the basis for search trees.

[0043] Therefore, according to another relaxed embodiment, the method may also include constructing a search tree based on a directed acyclic graph (i.e., a Bayesian network graph). From an implementation perspective, this could represent an elegant solution.

[0044] According to an enhanced embodiment, the method may also include filtering branches of the directed acyclic graph using a breadth-first search (BFS) technique. This may not represent the most complete and fully optimized method, but the BFS method may represent a good trade-off between speed, required computational resources, and results.

[0045] Alternatively, according to another enhanced embodiment of the method, the search tree can be constructed using the K-Nearest Neighbors (KNN) technique. Here, the K-Nearest Neighbors algorithm can be used to prune the search tree and obtain results faster, thus accepting optimizations that are not 100% perfect.

[0046] According to a high-level embodiment, the method may further include creating a conditional probability table for each node of the directed acyclic graph (i.e., each task)—specifically, its associated parent node. This can be represented using a failure rate value per unit time as P(x i |pa i This will be explained in more detail in the context of the accompanying drawings.

[0047] In the context of this description, the following technical conventions, terms, and / or expressions may be used:

[0048] The term "dependent task prioritization" here means that interdependent tasks can be organized and executed according to priority in order to reach the sequence with the highest probability of failure as quickly as possible. By doing so, the total time required to identify potentially faulty sequences of tasks can be reduced. In software testing, this means that potentially faulty modules can be identified as quickly as possible.

[0049] The term "baseline data" can refer to historical data about a task, which can be identified by the task identifier, the corresponding failure rate per unit of time, and the corresponding dependencies (e.g., derived from a directed acyclic graph).

[0050] The term "task" can refer to any activity to be performed, which may depend on another related task. This could be tests when testing a large software system, project activities, routines to be executed during the startup of an operating system, a large application system, or a database system, to name a few.

[0051] The term "failure rate per unit of time" can be used to represent the number of unsuccessful executions a corresponding task has experienced in its history.

[0052] The term "dependency data value" indicates whether activity or task A depends on another activity or task B. This can be represented using the notation [A, B].

[0053] The term "probabilistic model" can refer to a decision model that executes (potentially) dependent activities or tasks based on historical values ​​and relevant probability values, as well as the probability values ​​to be determined for a sequence of tasks to be performed.

[0054] The term "directed acyclic graph" (DAG) can represent a known conceptual representation of a series of activities. The sequence of activities can be depicted graphically, visually represented as a set of circles or ellipses (usually boxes), each representing an activity (or task, etc.), some connected by lines that represent the flow from one activity to another. Task identifiers can be represented by symbols within the circles or ellipses.

[0055] The term "network node" refers to a connection point within a directed acyclic graph. Node n is typically represented by an uppercase letter, such as A, B, C, ... or X, Y, Z.

[0056] The term "network edge" can refer to the connection between different nodes in a graph, such as a directed acyclic graph.

[0057] The term "conditional probability" can be used to represent the probability of failure of a task or a sequence of tasks, where the task itself depends on the probability of failure (or success) of previous tasks in the sequence.

[0058] The term "posterior marginal probability value" can be used to represent the probability that a downstream task will fail given that we observe the state of other upstream tasks (i.e., failure or success).

[0059] The term "highest sum of increasing failure probabilities" or the highest f-value F(n) can be used to represent the sum of failure probabilities in a sequence of tasks. To avoid overflow, it is recommended to use the inverse f-value N(n) = 1 – F(n).

[0060] The term "adjacent tasks" can refer to tasks that share the same level and direct parent node in the dependency tree.

[0061] Detailed descriptions of the accompanying drawings are provided below. All illustrations in the drawings are schematic. First, a block diagram of an embodiment of the computer implementation method of the inventive concept for task priority-dependent processing is given. Further embodiments, as well as embodiments for task priority-dependent processing, will then be described.

[0062] Figure 1A block diagram of a preferred embodiment of a computer implementation method 100 for prioritizing dependent tasks is shown. Method 100 includes providing 102 basic data, which contains task identifiers (where each task identifier indicates a corresponding task), failure values ​​(where each failure value indicates the failure rate per unit of time for the corresponding task), and dependency data values. Therefore, the basic data provides a basis for predicting dependencies (particularly predictive sequences, i.e., "looking ahead" to which task is most likely to fail). The basic data is data from past, historical cases that are collected over time. It forms the empirical backbone of the inventive concept. It should also be noted that in a minimal basic dataset, there may be only one record, or it may be a mapping where tasks are represented by keys and corresponding values ​​represent dependencies, or it may be empty, i.e., NULL values, for example, in the case of only one pair. However, typical basic data has multiple records containing task identifiers, failure values, and dependency data values. Each dependency data value is associated with a pair of tasks.

[0063] Method 100 also includes generating a 104-probability model based on underlying data, wherein task and associated dependency data values ​​are associated with a directed acyclic graph—specifically, a Bayesian network—and each task is associated with a network node of the directed acyclic graph. Furthermore, each dependency data value is associated with a network edge of the directed acyclic graph, wherein each dependency data value indicates a conditional probability associated with the failure rate per task time unit, i.e., a conditional probability associated with the sequence of tasks involved.

[0064] In addition, method 100 includes determining 106 posterior marginal probability values ​​for each task in the directed acyclic graph, which indicate the probability of task failure, and selecting 108 sequences of tasks that are most likely to fail the fastest—i.e., network nodes—based on the posterior marginal probability values.

[0065] Figure 2 The first embodiment 200, one of several implementations closer to the actual implementation, is shown. The basic idea is to use a simple topological sort, i.e., a "greedy" approach. The process begins by providing, 202, input data, which includes a set of tests, the (historical) failure rate per time unit associated with each test, and dependencies, for example, in the form of a dependent directed acyclic graph (DAG). Using this input data—especially the dependencies—204 a Bayesian network is constructed, and on this basis, 206 a search tree is built for all possible sequences of activities (e.g., tasks).

[0066] Therefore, to determine the nodes of the graph, the following formula is used: F(n) = F(parent) + P(n) - F(parent) × P(n); N(n) = 1 - F(n); ΔN (X, Y, Z) = N (X) + N (X, Y) + N (X, Y, Z).

[0067] The process continues searching for nodes in the 208 subtrees and selecting the 210th node with the smallest sum of increments, until a leaf node (i.e., a node with no children) is reached. This leaf node corresponds to the sequence of tasks most likely to fail the fastest. Finally, the search tree sequence is reversed by 212 to determine the sequence of tasks to be executed.

[0068] In summary, there are basically three steps: (i) providing input data, (ii) preparation, including steps 204 and 206, and (iii) determining the sequence of tasks, i.e. the sequence of tasks with the highest and fastest failure probability.

[0069] More specifically, a Bayesian network is constructed as follows: the input data includes tasks / tests / activities x1, …, x n and its time unit failure rate values ​​r1, …, r n And dependencies (DAG represented as (x i , x j ), which means x i Must be x j (Executed previously). The output of this step is the overlay network x1, …, x n Therefore, a Bayesian network DAG exists. G Its variables are x1, …, x n Starting from this point, towards G Add a directed edge x i →x j Next, regarding G Each variable x in i and its related parent node pa i A conditional probability table (CPT) is constructed using the failure rates of variables. P(x) i | pa i (See Figure 3).

[0070] Figure 3 Figure 302 illustrates five tasks A, B, C, D, and E that are at least partially interdependent, where dependencies are represented by arrows between nodes representing tasks A, B, C, D, and E. Additionally, Figure 3Conditional probability table 304 is shown. For task / node “D”, its probability is shown as dependent on tasks “B” and “C”. Here, “S” represents the successful termination of the corresponding task, and “F” represents the failure of the corresponding task. For the first dependency row of the table, it can be expressed as P(D=f | B=f and C=f) = 1; here, “F” represents failure, meaning that the probability of “D” failing is equal to 1, since it is known that “B” and “C” have both failed. Similarly, the probability of “D” succeeding is equal to zero, since it is known that “B” and “C” have both failed, and so on. Finally, the probability of D failing—see the second-to-last row—is equal to 0.04 (r D Therefore, the probability of D succeeding—see the last line of the CPT—is equal to 0.96, or 1 - r. D .

[0071] Therefore, it can be said that Bayesian networks are used to calculate the posterior marginal probability of variables, taking into account both test / task dependencies and the prior failure rate of the task. The posterior marginal node P(x) i The probability density function (RDF) is determined (e.g., computed) using any probabilistic inference algorithm suitable for Bayesian networks (e.g., VE, i.e., variable elimination; IBP, i.e., iterative belief propagation; or WMD, i.e., weighted bucket algorithm). For more implementation details, see, for example, https: / / github.ibm.com / IBM-Research-AI / merlin. However, any probabilistic inference library can be used, such as pgmpy (see https: / / github.com / pgmpy / pgmpy) or merlin (see https: / / github.com / radum2275 / merlin).

[0072] In other words, more specifically, the inputs used when constructing a Bayesian network include: the task / test set x1,…, x… n Their respective failure rates per unit of time, r1,…, r n and dependencies (x) i , x j ), which means x i Must be x j The previous execution will output a list of x1, ..., x... n Bayesian networks.

[0073] Thus, variables x1, …, x were created. n Bayesian DAG G Therefore, for each dependency (x) i ,x j ),Towards GAdd a directed edge x i →x j .

[0074] Additionally, for G Each variable x in i and its parent node pa i Create a CPT using the failure rate of the variable P(x) i |pa j ).

[0075] Figure 4 The diagram for basic dependency example 302 is shown again, containing nodes or tasks A, B, C, D, E to determine the modules and the associated Bayesian network graph 402. This network graph illustrates all the different sequences of tasks that depend on each other according to dependency graph 302. Note that tasks have unique identifier values ​​A, B, C, D, E. That is, task D can only be executed if task A and either task B or C have been successfully completed. Therefore, the second level of execution options in the Bayesian tree is represented by the probability of executing tasks A and B or tasks A and C. These two options are represented by ellipses 404 and 406. In tree 402, these ellipses 404 and 406 can be represented as "neighbors".

[0076] The structure of dependency 302 is the same as that used before. Here, we assume the following posterior marginal probabilities:

[0077] P(A) = 0.1; P(B) = 0.7; P(C) = 0.3; P(D) = 0.6; P(E) = 0.8. Here, a node n in the search tree represents a partial test sequence that satisfies the test prerequisite constraints (i.e., dependencies). Its respective f-value F(N) estimates the probability of failure. The f-value can be determined as: 1. F(n) = F (parent) + P(n) – F(parent) × P(n).

[0078] Therefore, the following f value can be determined: F(A) = P(A) = 0.1 F(A,B) = F(A) + P(B) – F(A) P(B) = 0.1 + 0.7 – 0.1 0.7 = 0.73 F(A,C) = F(A) + P(C) – F(A) P(C) = 0.1 + 0.3 – 0.1 0.3 = 0.37 F(A,B,E) = F(A,B) + P(E) – F(A,B) P(E) = 0.73 + 0.8 – 0.73 0.8 =0.946 F(A,B,C) = F(A,B) + P(C) – F(A,B) P(C) = 0.73 + 0.3 – 0.73 0.3 =0.811 F(A,C,B) = F(A,C) + P(B) – F(A,C) P(B) = 0.37 +0.7 – 0.37 0.7 = 0.811 F(A,B,E,C) = F(A,B,E) + P(C) – F(A,B,E) P(C) = 0.946 + 0.3 – 0.946 0.3 = 0.9622 F(A,B,C,D) = F(A,B,C) + P(D) – F(A,B,C) P(D) = 0.811 + 0.6 - 0.811 0.6 = 0.9244 F(A,C,B,D) = F(A,C,B) + P(D) – F(A,C,B) P(D) = 0.811 + 0.6 – 0.811 0.6 = 0.9244 F(A,B,E,C,D) = F(A,B,E,C) + P(D) – F(A,B,E,C) P(D) = 0.9622 + 0.6 –0.9622 0.6 = 0.98488 F(A,B,C,D,E) = F(A,B,C,D) + P(E) – F(A,B,C,D) P(E) = 0.9244 + 0.8 –0.9244 0.8 = 0.98488 F(A,C,B,D,E) = F(A,C,B,D) + P(E) – F(A,C,B,D) P(E) = 0.9244 + 0.8 –0.9244 0.8 = 0.98488

[0079] Figure 5 It shows Figure 4 The Bayesian network diagram and a graph of three potential outcomes. In this sense, Figure 5 Is using Figure 4 Continuing from the context of the discussion, tree structure 500 shows nodes "ABE", "ABEC", and "ABECD" marked with stripes. As a repetition of the above, example data is as follows:

[0080] Based on the above value, P(X), where X = node identifier, the following n value can be determined, where N(n) = 1 – F(n).

[0081] Therefore, this value can be determined for three different options: "A, B, E, C, D" (comparison 502), "A, B, C, D, E" (comparison 504), and "A, C, B, D, E" (comparison 506). Figure 5 The lower half is shown.

[0082] For N(n) = 1 – F(n) and the given numbers, we can conclude that: For “A, B, E, C, D”, 502: N(A) = 1 – 0.1 = 0.9 N(A,B) = 1 – 0.73 = 0.27 N(A,B,E) = 1 - 0.946 = 0.054 N(A,B,E,C) = 1 – 0.9622 = 0.0378 N(A,B,E,C,D) = 1 – 0.98488 = 0.01512

[0083] For "A, B, C, D, E", 504: N(A) = 1 – 0.1 = 0.9 N(A,B) = 1 – 0.73 = 0.27 N(A,BC) = 1 - 0.811 = 0.189 N(A,B,C,D) = 1 – 0.9244 = 0.0756 N(A,B,C,D,E) = 1 – 0.98488 = 0.01512

[0084] And for “A, C, B, D, E”, 506: N(A) = 1 – 0.1 = 0.9 N(A,C) = 1 – 0.37 = 0.63 N(A,C,B) = 1 – 0.811 = 0.189 N(A,C,B,D) = 1 – 0.9244 = 0.0756 N(A,C,B,D,E) = 1 – 0.98488 = 0.01512

[0085] Therefore, the calculation yields: The result of N (A,B,C,D,E) = N(A) + N(A, B) + N(A, B, C) + N(A, B, C, D, E) is N(A,B,E,C,D) = N(A) + N(A,B) + N(A,B,E) + N(A,B,E,C) + N(A,B,E,C,D)= 0.9 + 0.27 + 0.054 + 0.0378 + 0.01512 = 1.27692 N(A,B,C,D,E) = N(A) + N(A,B) + N(A,B,C) + N(A,B,C,D) + N(A,B,C,D,E)= 0.9 + 0.27 + 0.189 + 0.0756 + 0.01512 = 1.44972 N(A,C,B,D,E) = N(A) + N(A,C) + N(A,C,B) + N(A,C,B,D) + N(A,C,B,D,E)= 0.9 + 0.63 + 0.189 + 0.0756 + 0.01512 = 1.80972

[0086] Ultimately, having the minimum The sequence N (here, 1.27692) is the solution; therefore, in this greedy approach, the sequence "A, B, E" is likely to fail the fastest.

[0087] Figure 6 A diagram 600 illustrating an embodiment of the greedy method of the present invention is shown, which includes results and a summary. Figure 5Details of the description. The starting point is also dependency graph 602, which is the same as the dependency graph used previously. The values ​​in table 604 are also the same. Based on this, the f-value is determined, 606. As a result, three sequence graphs 608, 610, and 612 representing sequences of different task executions can be generated, again showing that the sequence "ABE" has the highest probability of fastest failure. Note the following correspondence between reference numerals 502 / 608, 504 / 610, and 506 / 612. Among them, graphs 608, 610, and 612 include the included n-values ​​in the graph.

[0088] Figure 7 A flowchart 700 illustrating a preferred exploration embodiment of the inventive concept is shown. This represents a different embodiment compared to previous embodiments, and is also a possible solution generally presented by the inventive concept.

[0089] Input data 702 and Figure 2 The same concept discussed in the examples refers to the task set, the failure rate per second (or any other time unit) for each task (or task and its respective dependencies). Also here, the Bayesian network is constructed using dependencies, 704. From here on, sequences and... Figure 2 The sequences are different.

[0090] In step 706, the best-priority exploration of the search tree is checked. To do this, the corresponding node values ​​are assigned according to the formulas already used. F(n) = F(parent) + P(n) – F(parent) × P(n) N(n) = 1 – F(n) N(X,Y,Z) = N(X) + N(X,Y) + N(X,Y,Z), for any nodes X, Y, Z.

[0091] Based on this, the root node is determined, 708, and the next "stage" of the tree is generated based on the Bayesian network, 710. Then, the optimal path is determined based on exploration, 712. Next, it is determined whether 714 is the final stage. If not—"No"—the process returns to determine the corresponding root node, 708. If the final stage is reached—determining 714 as "Yes"—the search tree sequence is reversed, 716, to find the task or test sequence with the highest probability of failure.

[0092] Figure 8 Illustration 800 shows a BFS embodiment with results. The starting point of dependency graph 602 and table 604, as well as the calculation of f-values, remain the same as previously explained. However, the Bayesian network graph / tree is now shown in a shortened version 802, reflecting a shortcut approach to the BFS algorithm. The original tree (e.g., Figure 4 , Figure 5 The parts of the tree that were not further examined were not immediately shown.

[0093] Similarly, in this embodiment, the sequence with the minimum increasing sum between nodes is the correct solution, namely "A, B, E, C, D", 804: (0.9+0.26+0.054+0.0378+0.01512). This also holds true in Figures 806 and 808.

[0094] Figure 9 A flowchart 900 illustrating a KNN embodiment of the present invention is shown, representing a third alternative solution to the present invention concept. The process steps, identical to those of the greedy method and the BFS method, include: accessing input data 902, namely the task set, the failure rate per time unit for each test (or task or activity), and related dependencies; and constructing a Bayesian network 904 using the dependencies.

[0095] Next, we perform a K-nearest neighbor search of the search tree (906). Again, we use the methods discussed above. F(n) = F(parent) + P(n) – F(parent) × P(n) N(n) = 1 – F(n) N(X,Y,Z) = N(X) + N(X,Y) + N(X,Y,Z), which also applies to any nodes X, Y, Z.

[0096] As the next activity in the process, step 908 identifies the corresponding root node, followed by step 910: the next "stage" of generating (sub)trees based on the Bayesian network. From here, the process continues to determine the optimal path based on the corresponding approximation in step 912. This is followed by determining whether the final stage has been reached in step 914. If not—"No"—the process loops back to the determination of the root node, step 908. If the final stage has been reached—determining "Yes" in step 914—then step 916 determines that there are no child nodes, and step 918 selects the sequence with the smallest incrementing sum. The process finally ends in step 920 by reversing the search tree to determine the sequence of tests / tasks / activities to be selected.

[0097] Figure 10 A diagram 1000 showing a KNN embodiment with results is provided. The dependency graph 602, table 604, and the preconditions for calculating / determining the f-values ​​are the same as in the previously discussed embodiments. However, the resulting / residual Bayesian network 1002 now has a different form, derived from... Figure 4 The Bayesian network 402. The Bayesian network 1002 does not have node numbers internally; instead, it orients nodes based on graphical representations as much as possible. Results show that the right-hand branch is more... Figure 4 The short one.

[0098] Additionally, Figure 10 Additional charts are shown for sequences “A, B, E, C, D”1004, “A, B, C, D, E”1006, and “A, C, B”1008. As mentioned above, the sequence with the smallest sum of node-to-node increments is selected as the optimal sequence with the highest probability of fastest failure. In this example, it is again the sequence “A, B, E, C, D”1004, whose sum of increments is again (0.9 + 0.27 + 0.054 + 0.0378 + 0.01512).

[0099] Figure 11 A block diagram of an embodiment of a task prioritization system 1100 for task prioritization is shown. System 1100 includes one or more processors 1102 and a memory 1104 operatively coupled to the one or more processors 1102, wherein the memory 1104 stores program code portions that, when executed by the one or more processors 1102, enable the one or more processors 1102 to provide basic data including task identifiers, where each task identifier indicates a corresponding task, failure values, where each failure value indicates a failure rate per unit time for the corresponding task, and dependency data values, where each dependency data value is associated with a pair of tasks. This can be performed by a basic data providing unit 1106.

[0100] One or more processors 1104 are further configured to generate a probabilistic model from underlying data, wherein task and related dependency data values ​​are associated with a directed acyclic graph (DAG), and each task is associated with a network node of the DAG. Additionally, each dependency data value is associated with a network edge of the DAG, wherein each dependency data value indicates a conditional probability relative to the corresponding failure rate per unit of time. This task can be performed by generator unit 1108.

[0101] Furthermore, one or more processors 1102 are configured to determine—in particular by determination module 1110—for each task in the directed acyclic graph, a posterior marginal probability value indicating the probability of task failure, and select—in particular by selection unit 1112—a sequence of tasks most likely to fail the fastest based on the posterior marginal probability value.

[0102] It should also be mentioned that all functional units, modules, and function blocks can be communicatively coupled to each other in a selected 1:1 manner for signal or message exchange. Alternatively, functional units, modules, and function blocks can be linked to the system's internal bus system 1114 for selective signal or message exchange. As functional units, modules, and function blocks, at least the following components are considered: one or more processors 1102, memory 1104, basic data providing unit 1106, generator unit 1108, determination module 1110, and selection unit 1112.

[0103] Various aspects of this disclosure are described by narrative text, flowcharts, computer system block diagrams, and / or machine logic block diagrams included in embodiments of a computer program product (CPP). Regarding any flowchart, operations may be performed in a different order than shown in a given flowchart, depending on the art involved. For example, again according to the art involved, two operations shown in consecutive flowchart blocks may be performed in reverse order, as a single integrated step, concurrently, or with at least partial temporal overlap.

[0104] Computer Program Product Embodiment (CPP Embodiment or CPP) is a term used in this disclosure to describe one or more storage media (also referred to as media) included in one or more storage devices, which collectively contain machine-readable code corresponding to instructions and / or data for performing computer operations specified in a given CPP claim. A storage device is any tangible device capable of holding and storing instructions for use by a computer processor. Without limitation, a computer-readable storage medium can be an electronic storage medium, a magnetic storage medium, an optical storage medium, an electromagnetic storage medium, a semiconductor storage medium, a mechanical storage medium, or any suitable combination thereof. Some known types of storage devices that include these media include floppy disks, hard disks, random access memory (RAM), read-only memory (ROM), erasable programmable read-only memory (EPROM or flash memory), static random access memory (SRAM), optical disc read-only memory (CD-ROM), digital versatile optical disc (DVD), memory sticks, floppy disks, mechanical encoding devices (e.g., punched cards or pits / planes formed in the main surface of a disc), or any suitable combination thereof. As used in this disclosure, computer-readable storage media should not be construed as storage of transient signals, such as radio waves or other freely propagating electromagnetic waves, electromagnetic waves propagating through waveguides, optical pulses transmitted through fiber optic cables, electrical signals transmitted through wires, and / or other transmission media. As those skilled in the art will understand, during normal operation of a storage device, data typically moves at occasional points in time, such as during access, defragmentation, or garbage collection, but this does not make the storage device transient, because data is not transient at the time of storage.

[0105] Figure 12 A computing environment 1200 is shown, including methods relating to the execution of the present invention (e.g., implementing a computer-based method 100 for task-priority dependent methods). Figure 1 Examples of environments for at least some computer code, such as code block 1250.

[0106] In addition to block 1250, the computing environment 1200 also includes, for example, a computer 1201, a wide area network (WAN) 1202, an end-user equipment (EUD) 1203, a remote server 1204, a public cloud 1205, and a private cloud 1206. In this embodiment, the computer 1201 includes a processor set 1210 (including processing circuitry 1220 and a cache 1221), a communication structure 1211, volatile memory 1212, persistent storage 1213 (including an operating system 1222 and block 1250 as described above), a peripheral device set 1214 (including a user interface (UI) device set 1223, a storage device 1224, and an Internet of Things (IoT) sensor set 1225), and a network module 1215. The remote server 1204 includes a remote database 1230. Public cloud 1205 includes gateway 1240, cloud orchestration module 1241, host physical machine set 1242, virtual machine set 1243, and container set 1244.

[0107] Computer 1201 may take the form of a desktop computer, laptop computer, tablet computer, smartphone, smartwatch or other wearable computer, mainframe computer, quantum computer, or any other computer or mobile device now known or to be developed in the future capable of running programs, accessing networks, or querying databases (e.g., remote database 1230). As is well known in the field of computer technology, and depending on the technology, the performance of a computer-implemented method can be distributed across multiple computers and / or multiple locations. On the other hand, in this illustration of computing environment 1200, the detailed discussion focuses on a single computer, specifically computer 1201, to keep the illustration as simple as possible. Computer 1201 may be located in the cloud, even... Figure 12 The computer is not shown in the cloud. On the other hand, unless explicitly instructed otherwise, computer 1201 does not need to be in the cloud.

[0108] Processor set 1210 includes one or more computer processors of any type currently known or to be developed in the future. Processing circuitry 1220 may be distributed across multiple packages, for example, multiple coordinated integrated circuit chips. Processing circuitry 1220 may implement multiple processor threads and / or multiple processor cores. Cache 1221 is memory located within the processor chip package(s) and is typically used to store data or code that should be quickly accessed by the threads or cores running on processor set 1210. Cache memory is typically organized into multiple levels based on its relative proximity to the processing circuitry. Alternatively, some or all of the cache of the processor set may be located "off-chip". In some computing environments, processor set 1210 may be designed to process qubits and perform quantum computing.

[0109] Computer-readable program instructions are typically loaded onto computer 1201 to cause processor set 1210 of computer 1201 to perform a series of operational steps to implement a computer-implemented method, such that the instructions, when executed, instantiate the method specified in the flowcharts and / or the descriptive description of the computer-implemented method included in this document (collectively, the “method of the invention”). These computer-readable program instructions are stored in various types of computer-readable storage media, such as cache 1221 and other storage media discussed below. Processor set 1210 accesses the program instructions and associated data to control and direct the execution of the method of the invention. In computing environment 1200, at least a portion of the instructions for performing the method of the invention may be stored in block 1250 of persistent storage device 1213.

[0110] The communication structure 1211 is a signal transmission path that allows the various components of the computer 1201 to communicate with each other. Typically, this structure consists of switches and conductive paths, such as switches and conductive paths that form buses, bridges, physical input / output ports, etc. Other types of signal communication paths may also be used, such as fiber optic communication paths and / or wireless communication paths.

[0111] Volatile memory 1212 is any type of volatile memory currently known or to be developed in the future. Examples include dynamic random access memory (RAM) or static RAM. Typically, volatile memory is characterized by random access, but is not required unless explicitly indicated. In computer 1201, volatile memory 1212 is located within a single package and is an internal component of computer 1201. Alternatively or additionally, volatile memory may be distributed across multiple packages and / or located externally to computer 1201.

[0112] The persistent storage device 1213 is any form of non-volatile storage device currently known or to be developed in the future for use in a computer. The non-volatility of this storage device means that the stored data will be retained regardless of whether power is supplied to the computer 1201 and / or directly to the persistent storage device 1213. The persistent storage device 1213 may be a read-only memory (ROM), but typically at least a portion of the persistent storage device allows data to be written, deleted, and rewritten. Some common forms of persistent storage devices include hard disks and solid-state storage devices. The operating system 1222 can take many forms, such as various known proprietary operating systems or open-source portable operating system interface type operating systems employing a kernel. The code contained in block 1250 typically includes at least some of the computer code involved in performing the methods of the present invention.

[0113] Peripheral device set 1214 includes the peripheral device set of computer 1201. Data communication connections between peripheral devices and other components of computer 1201 can be achieved in various ways, such as Bluetooth connection, near field communication (NFC) connection, connection established via cable (e.g., Universal Serial Bus (USB) type cable), plug-in connection (e.g., Secure Digital (SD) card), connection established via local area network, or even connection established via wide area network (e.g., Internet). In various embodiments, UI device set 1223 may include components such as display screen, speaker, microphone, wearable devices (e.g., goggles and smartwatches), keyboard, mouse, printer, touchpad, game controller, and haptic device. Storage device 1224 is an external storage device, such as an external hard drive, or a pluggable storage device, such as an SD card. Storage device 1224 may be persistent and / or volatile. In some embodiments, storage device 1224 may take the form of a quantum computing storage device for storing data in the form of qubits. In embodiments where computer 1201 requires significant storage (e.g., when computer 1201 locally stores and manages a large database), this storage can be provided by peripheral storage devices designed for storing large amounts of data, such as a storage area network (SAN) shared by multiple geographically distributed computers. The IoT sensor set 1225 consists of sensors that can be used in IoT applications. For example, one sensor might be a thermometer, and another might be a motion detector.

[0114] Network module 1215 is a collection of computer software, hardware, and firmware that allows computer 1201 to communicate with other computers via wide area network 1202. Network module 1215 may include hardware (e.g., a modem or Wi-Fi transceiver), software for packetizing and / or depacketizing data for transmission over the communication network, and / or web browser software for communicating data over the Internet. In some embodiments, the network control functions and network forwarding functions of network module 1215 are performed on the same physical hardware device. In other embodiments (e.g., embodiments utilizing software-defined networking (SDN), the control and forwarding functions of network module 1215 are performed on physically separate devices, such that the control functions manage multiple different network hardware devices. Computer-readable program instructions for performing the methods of the present invention can typically be downloaded to computer 1201 from an external computer or external storage device via a network adapter card or network interface included in network module 1215.

[0115] WAN 1202 refers to any wide area network (such as the Internet) capable of communicating computer data over non-local distances using any currently known or future technologies for communicating computer data. In some embodiments, a WAN can be replaced and / or supplemented by a local area network (LAN), which is designed to communicate data between devices located in a local area (such as a Wi-Fi network). WANs and / or LANs typically include computer hardware such as copper transmission cables, optical fiber transmissions, wireless transmissions, routers, firewalls, switches, gateway computers, and edge servers.

[0116] End User Equipment (EUD) 1203 is any computer system used and controlled by an end user (e.g., a customer of the enterprise operating computer 1201), and may take any form as described above in relation to computer 1201. EUD 1203 typically receives useful and helpful data from the operation of computer 1201. For example, assuming computer 1201 is designed to provide recommendations to the end user, these recommendations would typically be communicated from network module 1215 of computer 1201 to EUD 1203 via WAN 1202. Thus, EUD 1203 may show or otherwise present the recommendations to the end user. In some embodiments, EUD 1203 may be a client device, such as a thin client, a thick client, a mainframe computer, a desktop computer, etc.

[0117] Remote server 1204 is any computer system that provides at least some data and / or functionality to computer 1201. Remote server 1204 may be controlled and used by the same entity operating computer 1201. Remote server 1204 represents multiple machines that collect and store beneficial and useful data for use by other computers (such as computer 1201). For example, assuming computer 1201 is designed and programmed to provide recommendations based on historical data, this historical data may be provided to computer 1201 from a remote database 1230 of remote server 1204.

[0118] Public cloud 1205 is any computer system available to multiple entities, providing on-demand availability of computer system resources and / or other computing capabilities, particularly data storage (cloud storage) and computing power, without the need for direct, active management by users. Cloud computing typically leverages resource sharing to achieve consistency and economies of scale. Direct and active management of the computing resources of public cloud 1205 is performed by the computer hardware and / or software of cloud orchestration module 1241. The computing resources provided by public cloud 1205 are typically implemented using virtual computing environments that run on various computers constituting host physical set 1242, which is a collection of physical computers within and / or available to public cloud 1205. Virtual computing environments (VCEs) typically take the form of virtual machines from virtual machine set 1243 and / or containers from container set 1244. It should be understood that these virtual computing environments can be stored as images and can be transferred between various physical hosts, either as images or after VCE instantiation. The cloud orchestration module 1241 manages the transport and storage of images, deploys new instantiations of VCE, and manages active instantiations of VCE deployments. Gateway 1240 is a collection of computer software, hardware, and firmware that allows the public cloud 1205 to communicate via WAN 1202.

[0119] We will now explain Virtualized Computing Environments (VCEs) further. A VCE can be stored as an "image." A new active instance of a VCE can be instantiated from this image. Two common types of virtualized computing environments are virtual machines and containers. A container is a virtualized computing environment that uses operating system-level virtualization. This refers to a feature of the operating system where the kernel allows multiple isolated user-space instances (called containers) to exist. From the perspective of a program running within it, these isolated user-space instances typically behave like a real computer. A computer program running on a regular operating system can utilize all the resources of that computer, such as connected devices, files and folders, network shares, CPU power, and quantifiable hardware capabilities. However, a program running in a container can only use the contents of the container and the devices allocated to the container; this feature is called containerization.

[0120] Private cloud 1206 is similar to public cloud 1205, except that its computing resources are available only to a single enterprise. While private cloud 1206 is depicted as communicating with WAN 1202, in other embodiments, the private cloud may be completely disconnected from the internet and accessible only via a local / private network. A hybrid cloud is a complex of multiple clouds of different types (e.g., private, community, or public cloud types), typically implemented by different vendors. Each cloud remains an independent and discrete entity, but the larger hybrid cloud architecture is joined together through standardized or proprietary technologies that enable orchestration, management, and / or data / application portability across the multiple component clouds. In this embodiment, both public cloud 1205 and private cloud 1206 are part of a larger hybrid cloud.

[0121] It should also be mentioned that the task priority system 1100 used for task priority can be the operating subsystem of computer 1201 and can be connected to the computer's internal bus system.

[0122] The terminology used herein is for the purpose of describing particular embodiments only and is not intended to limit the invention. As used herein, the singular forms “a,” “an,” and “the” are intended to include the plural forms as well, unless the context clearly indicates otherwise. It should also be understood that the terms “comprising” and / or “including” as used in this specification indicate the presence of the stated features, integers, steps, operations, elements, and / or components, but do not exclude the presence or addition of one or more other features, integers, steps, operations, elements, components, and / or combinations thereof.

[0123] The structures, materials, actions, and their equivalents corresponding to all "means plus function" or "step plus function" elements in the following claims are intended to cover any structure, material, or action combined with other claim elements to perform the said function. The description of the invention is presented for illustrative and elucidating purposes, but is not intended to be exhaustive or to limit the invention to the forms disclosed. Many modifications and variations will be apparent to those skilled in the art without departing from the scope and spirit of the invention. The embodiments were chosen and described in order to best explain the principles and practical application of the invention and to enable others skilled in the art to understand the various modifications applicable to the various embodiments to suit the intended particular use.

[0124] In short, the concept of this invention can be summarized by the following terms: 1. A computer implementation method for task-priority dependent processes, the method comprising: - Provide basic data, which includes - Task identifiers, where each task identifier indicates the corresponding task. - Failure values, where each failure value indicates the failure rate per unit of time for the corresponding task, and - Dependency data values Each dependency data value is associated with a pair of tasks; - Generate a probability model based on this basic data. The task and its related dependency data values ​​are associated with a directed acyclic graph, and Each task is associated with a network node in the directed acyclic graph, and Each dependency data value is associated with a network edge of the directed acyclic graph, and each dependency data value indicates a conditional probability associated with the corresponding failure rate per unit of time. - For each task in the directed acyclic graph, determine a posterior marginal probability value indicating the failure probability of that task; and - Based on this posterior marginal probability value, select the sequence of tasks that are most likely to fail the fastest. 2. The method according to Clause 1, wherein the sequence of tasks in which the selection is most likely to fail fastest includes... - Select the sequence of tasks that has the highest sum of increasing failure probabilities among adjacent tasks. 3. The method described in accordance with Clause 1 or 2, wherein the task is a test task for the system under test. 4. The method described in accordance with any of the preceding clauses, - This task is a project task, and - The failure rate per unit of time is the risk value of the corresponding project task. 5. The method described in accordance with any of the preceding clauses, - This task involves the operating system's boot process, which includes multiple services, and - The failure rate per unit of time represents the probability that the service could not be completed. 6. The method according to any of the preceding clauses, wherein the directed acyclic graph is a Bayesian network graph. 7. The method described in Clause 6 also includes - Construct a search tree based on this directed acyclic graph. 8. The method described in Clause 7 also includes - Use breadth-first search to filter the branches of the directed acyclic graph. 9. The method according to Clause 7, wherein the construction of the search tree uses the k-nearest neighbor technique. 10. The method according to any of the foregoing clauses further includes - Create a conditional probability table for each node of the directed acyclic graph using the failure rate value per unit of time. 11. A system for prioritizing tasks that depend on task priorities, the system comprising: - One or more processors and a memory operatively coupled to the one or more processors, wherein the memory stores a portion of program code that, when executed by the one or more processors, causes the one or more processors to... - Provide basic data, which includes - Task identifiers, where each task identifier indicates the corresponding task. - Failure values, where each failure value indicates the failure rate per unit of time for the corresponding task, and - Dependency data values, where each dependency data value is associated with a pair of tasks; - Generate a probability model based on this basic data. The task and its related dependency data values ​​are associated with a directed acyclic graph, and Each task is associated with a network node in the directed acyclic graph, and Each dependency data value is associated with a network edge of the directed acyclic graph, and each dependency data value indicates a conditional probability associated with the corresponding failure rate per unit of time. - For each task in the directed acyclic graph, determine a posterior marginal probability value indicating the failure probability of that task; and - Based on this posterior marginal probability value, select the sequence of tasks that are most likely to fail the fastest. 12. The system according to Clause 11, wherein the sequence of tasks in which the selection is most likely to fail fastest includes... - Select the sequence of tasks that has the highest sum of increasing failure probabilities among adjacent tasks. 13. The system described in Clause 11 or 12, wherein the task is a test task for the system under test. 14. The system pursuant to any one of the preceding clauses 11 to 13, - This task is a project task, and - The failure rate per unit of time is the risk value of the corresponding project task. 15. The system pursuant to any one of the preceding clauses 11 to 14, - This task involves the operating system's boot process, which includes multiple services, and - The failure rate per unit of time represents the probability that the service could not be completed. 16. The system according to any one of the preceding clauses 11 to 15, wherein the directed acyclic graph is a Bayesian network graph. 17. The system described in Clause 16 further includes - Construct a search tree based on this directed acyclic graph. 18. The system described in Clause 17, further comprising: - Use the breadth-first search technique to filter the branches of the directed acyclic graph. 19. The system according to any one of the preceding clauses 11 to 18 further includes - Create a conditional probability table for each node of the directed acyclic graph using the failure rate value per unit of time. 20. A computer program product for task-priority dependent operations, the computer program product comprising a computer-readable storage medium having program instructions thereon, the program instructions being executable by one or more computing systems or controllers to cause the one or more computing systems to... - Provide basic data, including - Task identifiers, where each task identifier indicates the corresponding task. - Failure values, where each failure value indicates the failure rate per unit of time for the corresponding task, and - Dependency data values, where each dependency data value is associated with a pair of tasks; - Generate a probability model based on this basic data. The task and its related dependency data values ​​are associated with a directed acyclic graph, and Each task is associated with a network node in the directed acyclic graph, and Each dependency data value is associated with a network edge of the directed acyclic graph, and each dependency data value indicates a conditional probability associated with the corresponding failure rate per unit of time. - For each task in the directed acyclic graph, determine a posterior marginal probability value indicating the failure probability of that task; and - Based on this posterior marginal probability value, select the sequence of tasks that are most likely to fail the fastest.

Claims

1. A computer implementation method for task-priority dependent operations, the method comprising: - Provide basic data, which includes - Task identifiers, where each task identifier indicates the corresponding task. - Failure values, where each failure value indicates the failure rate per unit of time for the corresponding task, and - Dependency data values Each dependency data value is associated with a pair of tasks; - Generate a probability model based on the aforementioned basic data. The task and related dependency data values ​​are associated with a directed acyclic graph, and Each task is associated with a network node in the directed acyclic graph, and Each dependency data value is associated with a network edge of the directed acyclic graph, and each dependency data value indicates a conditional probability associated with the corresponding failure rate per unit of time. - Determine a posterior marginal probability value indicating the failure probability of each task in the directed acyclic graph; and - Based on the posterior marginal probability value, select the sequence of tasks that are most likely to fail the fastest.

2. The method of claim 1, wherein the sequence of selecting the task most likely to fail fastest includes... - Select the sequence of tasks that has the highest sum of increasing failure probabilities among adjacent tasks.

3. The method according to claim 1 or 2, wherein the task is a test task for the system under test.

4. The method according to any of the preceding claims, - The tasks mentioned therein are project tasks, and - The failure rate per unit of time mentioned therein is the risk value of the corresponding project task.

5. The method according to any of the preceding claims, - The task described therein is a service that includes the operating system's boot process, which comprises multiple services, and - Wherein the failure rate per unit of time represents the probability of failing to complete the service.

6. The method according to any of the preceding claims, wherein the directed acyclic graph is a Bayesian network graph.

7. The method of claim 6, further comprising: - Construct a search tree based on the directed acyclic graph.

8. The method of claim 7, further comprising: - Use breadth-first search to filter the branches of the directed acyclic graph.

9. The method of claim 7, wherein the search tree is constructed using the k-nearest neighbor technique.

10. The method according to any of the preceding claims, further comprising: - Create a conditional probability table for each node in the directed acyclic graph using the failure rate value per unit of time.

11. A system for prioritizing tasks that depend on task priorities, the system comprising: - One or more processors and a memory operatively coupled to the one or more processors, wherein the memory stores a portion of program code that, when executed by the one or more processors, causes the one or more processors to... - Provide basic data, which includes - Task identifiers, where each task identifier indicates the corresponding task. - Failure values, where each failure value indicates the failure rate per unit of time for the corresponding task, and - Dependency data values, where each dependency data value is associated with a pair of tasks; - Generate a probability model based on the aforementioned basic data. The task and related dependency data values ​​are associated with a directed acyclic graph, and Each task is associated with a network node in the directed acyclic graph, and Each dependency data value is associated with a network edge of the directed acyclic graph, and each dependency data value indicates a conditional probability associated with the corresponding failure rate per unit of time. - Determine a posterior marginal probability value indicating the failure probability of each task in the directed acyclic graph; and - Based on the posterior marginal probability value, select the sequence of tasks that are most likely to fail the fastest.

12. The system of claim 11, wherein the sequence of tasks in which the selection is most likely to fail includes - Select the sequence of tasks that has the highest sum of increasing failure probabilities among adjacent tasks.

13. The system according to claim 11 or 12, wherein the task is a test task for the system under test.

14. The system according to any one of claims 11 to 13, - The tasks mentioned therein are project tasks, and - The failure rate per unit of time mentioned therein is the risk value of the corresponding project task.

15. The system according to any one of claims 11 to 14, - The task described therein is a service that includes the operating system's boot process, which comprises multiple services, and - Wherein the failure rate per unit of time represents the probability of failing to complete the service.

16. The system according to any one of claims 11 to 15, wherein the directed acyclic graph is a Bayesian network graph.

17. The system of claim 16, further comprising: - Construct a search tree based on the directed acyclic graph.

18. The system of claim 17, further comprising: - Use the breadth-first search technique to filter the branches of the directed acyclic graph.

19. The system according to any one of claims 11 to 18, further comprising: - Create a conditional probability table for each node in the directed acyclic graph using the failure rate value per unit of time.

20. A computer program product for task-priority dependent operations, the computer program product comprising a computer-readable storage medium having program instructions thereon, the program instructions being executable by one or more computing systems or controllers to cause the one or more computing systems to... - Provide basic data, including - Task identifiers, where each task identifier indicates the corresponding task. - Failure values, where each failure value indicates the failure rate per unit of time for the corresponding task, and - Dependency data values, where each dependency data value is associated with a pair of tasks; - Generate a probability model based on the aforementioned basic data. The task and related dependency data values ​​are associated with a directed acyclic graph, and Each task is associated with a network node in the directed acyclic graph, and Each dependency data value is associated with a network edge of the directed acyclic graph, and each dependency data value indicates a conditional probability associated with the corresponding failure rate per unit of time. - Determine a posterior marginal probability value indicating the failure probability of each task in the directed acyclic graph; and - Based on the posterior marginal probability value, select the sequence of tasks that are most likely to fail the fastest.

Images