Automatic resolution of dependency version conflicts

Through the global dependency data structure, the inefficiency problem of dependency management in complex task flow is solved, and efficient job execution and resource management are achieved.

CN113811852BActive Publication Date: 2024-11-08MICROSOFT TECHNOLOGY LICENSING LLC
View PDF 0 Cites 0 Cited by

Patent Information

Application Number
CN202080035507.4
Authority / Receiving Office
CN · China
Patent Type
Patents(China)
Current Assignee / Owner
Priority Date
2019-05-14
Filing Date
2020-02-25
Publication Date
2024-11-08
Estimated Expiration
2040-02-25

AI Technical Summary

Technical Problem

In complex task flows, dependency version conflicts are difficult to resolve automatically, resulting in increased computing resources and bandwidth consumption, and the prior art requires manual processing, which is complex and time-consuming.

Method used

Using a global dependency data structure, conflicts are determined by retrieving dependency information from the data structure at runtime, and based on the information of dependencies and workflows, correction actions are automatically identified and performed to resolve conflicts.

Benefits of technology

It improves the efficiency of job execution, reduces computing resources and bandwidth consumption, simplifies dependency management, reduces the need for manual processing, and realizes automated resolution of cross-job dependency conflicts.

✦ Generated by Eureka AI based on patent content.

Smart Images

  • Figure CN113811852B_ABST
    Figure CN113811852B_ABST
Patent Text Reader

Abstract

Described herein is a system and method for automatically resolving dependency version conflicts for (multiple) execution jobs. During execution of a specific version of a workflow including a task, information about a specific task to be executed is received. The specific task is dependent on another task. Information about the dependency is retrieved from a global dependency data structure (e.g., a graph) that stores current dependency information about the task. When it is determined that there is a conflict regarding the dependency of the specific task on another task, information about the dependency and the workflow, information about a dependency change history associated with at least one of the multiple tasks, information about the specific version of the workflow, and different versions of the workflow are retrieved. A resolution to the conflict can be identified based at least in part on the retrieved information, and corrective actions can be performed.
Need to check novelty before this filing date? Find Prior Art

Description

Background Art

[0001] Complex processes involving many tasks, some of which may depend on other tasks, may be difficult to accurately model a priori. For example, the processing performed by a particular task may change frequently, and / or the dependencies of a particular task may change after a particular job has started. Summary of the invention

[0002] Described herein is a system for job execution, the system comprising: a computer comprising a processor and a memory, the memory having computer executable instructions stored thereon, the computer executable instructions when executed by the processor causing the computer to: during execution of a specific version of a workflow comprising a plurality of tasks, receive information about a specific task to be executed among the plurality of tasks, the specific task being dependent on another task among the plurality of tasks; retrieve information about the dependency from a global dependency data structure, wherein the global dependency data structure stores current dependency information about the plurality of tasks; determine whether there is a conflict regarding the dependency of the specific task on another task; and when it is determined that there is a conflict: retrieve information about the dependency and the plurality of workflows; retrieve information about a dependency change history associated with at least one of the plurality of tasks; retrieve information about a specific version of the workflow and different versions of the workflow; identify a resolution to the conflict based at least in part on the information retrieved from the global dependency data structure, the information retrieved about the dependency change history associated with at least one of the plurality of tasks, the information retrieved about the dependency and the plurality of workflows, and the information retrieved about the specific version of the workflow and different versions of the workflow; and perform a corrective action to resolve the conflict based at least in part on the identified resolution.

[0003] This Summary is provided to introduce a selection of concepts in a simplified form that are further described below in the Detailed Description. This Summary is not intended to identify key features or essential features of the claimed subject matter, nor is it intended to be used to limit the scope of the claimed subject matter. BRIEF DESCRIPTION OF THE DRAWINGS

[0004] Figure 1 is a functional block diagram illustrating a system for job execution.

[0005] Figure 2 is a functional block diagram showing a workflow submission system.

[0006] Figure 3 and Figure 4 It is a flow chart of a method for automatically resolving dependency version conflicts.

[0007] Figure 5 It is a flowchart of the workflow submission method.

[0008] Figure 6 is a functional block diagram illustrating an exemplary computing system. DETAILED DESCRIPTION

[0009] Various techniques related to automatic resolution of dependency version conflicts are now described with reference to the accompanying drawings, wherein the same reference numerals are used throughout to refer to the same elements. In the following description, for the purpose of explanation, numerous specific details are set forth to provide a thorough understanding of one or more aspects. However, it may be apparent that (multiple) such aspects may be practiced without these specific details. In other examples, well-known structures and devices are shown in block diagram form to facilitate description of one or more aspects. In addition, it is to be understood that functions described as being implemented by certain system components may be performed by multiple components. Similarly, for example, a component may be configured to perform functions described as being implemented by multiple components.

[0010] The subject matter discloses various products and processes that support performing or are configured to perform various actions regarding automatic resolution of dependency version conflicts. The following are one or more exemplary systems and methods.

[0011] Aspects of the subject disclosure relate to the technical problem of detecting dependency conflicts of tasks and / or subtasks of a job(s) of execution. Technical features associated with solving the problem relate to: during execution of a specific version of a workflow including multiple tasks, receiving information about a specific task to be executed from the multiple tasks, the specific task being dependent on another task from the multiple tasks; retrieving information about the dependency from a global dependency data structure, wherein the global dependency data structure stores current dependency information about the multiple tasks; determining whether there is a conflict about the dependency of the specific task on the other task; and when it is determined that there is a conflict: retrieving information about the dependency and the multiple workflows; retrieving information about dependency change history associated with at least one of the multiple tasks; retrieving information about a specific version of the workflow and different versions of the workflow; identifying a solution to the conflict based at least in part on the information retrieved from the global dependency data structure, the information retrieved about dependency change history associated with at least one of the multiple tasks, the information retrieved about the dependency and the multiple workflows, and the information retrieved about the specific version of the workflow and different versions of the workflow; and performing a corrective action to resolve the conflict based at least in part on the identified solution. Therefore, aspects of these technical features exhibit the technical effect of performing tasks more efficiently and effectively, for example, thereby reducing the consumption of (multiple) computing resources and / or bandwidth.

[0012] Moreover, the term "or" is intended to mean an inclusive "or" rather than an exclusive "or." That is, unless specified otherwise or clear from context, the phrase "X employs A or B" is intended to mean any of the natural inclusive permutations. That is, the phrase "X employs A or B" is satisfied by any of the following instances: X employs A; X employs B; or X employs both A and B. Furthermore, the articles "a" and "an" as used in this application and the appended claims should generally be construed to mean "one or more" unless specified otherwise or clear from context to be directed to a singular form.

[0013] As used herein, the terms "component" and "system" and their various forms (e.g., component, system, subsystem, etc.) are intended to refer to a computer-related entity, which is hardware, a combination of hardware and software, software, or software in execution. For example, a component can be, but is not limited to, a process running on a processor, a processor, an object, an instance, an executable file, an execution thread, a program, and / or a computer. For example, both an application running on a computer and a computer can be a component. One or more components can reside within a process and / or execution thread, and a component can be located on one computer and / or distributed between two or more computers. In addition, as used herein, the term "exemplary" is intended to mean an illustration or example used as something, and is not intended to indicate a preference.

[0014] Conventionally, job(s) and process(es) may be automated workflows (tasks). A typical workflow may be a complex composite of many sub-workflows (sub-jobs) and individual activities (tasks) owned by various teams (owning teams), some of which run in parallel with each other and may have a large number of dependencies.

[0015] Systems designed to drive long-running processes need to declare dependencies between various stages and need to be orchestrated according to those dependencies. For example, a long-running process / job may have multiple instances running simultaneously with various versions of a particular workflow. This can present significant challenges regarding how to orchestrate between jobs with different versions of the same workflow (e.g., different versions of task(s) / subtask(s) and / or dependencies of task(s) / subtask(s)).

[0016] As discussed in more detail below, for purposes of explanation and not limitation, a job may be represented as an execution graph (or tree) consisting of a plurality of nodes, where each node represents a particular task (or subtask). At least some of the nodes may depend on the processing of one or more other nodes. In some embodiments, the dependency may be based on a particular node that can only be executed after the processing of another node is completed. In some embodiments, the dependency may be based on a particular node that can only be executed after receiving information from another node (e.g., during the processing of another node and / or when the processing of another node is completed).

[0017] Described herein is a system and method for job execution that utilizes a single version of a global dependency data structure. The global dependency data structure serves as a single source of truth for all dependency modeling currently applied to the job execution environment (e.g., for current version(s), previous version(s), and optionally future version(s)). In some embodiments, an advantage of this approach is that it simplifies the graph deployment model when dealing with cross-job dependencies, as only a single version needs to be maintained. For cross-version orchestration, the system employs an automated conflict resolution process, rather than the significantly more complex solution of maintaining multiple versions of the dependency graph.

[0018] For purposes of explanation and not limitation, the system and method are described in the context of a workflow / job for a build process in a (multiple) computer data center; however, the system and method can be used to perform automatic resolution of dependency version conflicts for other complex processes involving many tasks, some of which depend on (multiple) other tasks. For example, the system and method can be used to perform automatic resolution of dependency version conflicts in (multiple) processes for software development, manufacturing, etc.

[0019] refer to Figure 1 , a system 100 for job execution is shown. The system 100 employs dependency-aware orchestration by employing a global dependency data structure 110 (e.g., a global dependency graph). The global dependency data structure 110 can be used as a single source of truth regarding dependency modeling currently applied to the system 100. In some embodiments, an advantage of this approach is that it simplifies the schema deployment model when dealing with cross-job dependencies, because only a single version of the system 100 is maintained via the global dependency data structure 110.

[0020] As used herein, a "job" refers to an overall process consisting of multiple workflows including one or more tasks. Each task may include zero, one or more subtasks, etc. In some embodiments, an owner (e.g., an ownership team) may be assigned responsibility for each task. A task may be an automated process (e.g., configuration of a software module), a semi-automated process (e.g., configuration of a software module with manual input), and / or a manual process (e.g., receiving manual input, physically installing a piece of hardware).

[0021] Information about workflow(s) (and any associated task(s) and / or subtask(s)) may be stored in the workflow repository 114. In some embodiments, this information may include code for a particular version of a workflow, and declarations of dependency(s), if any. The workflow repository 114 may store information (e.g., code and declaration(s) of dependency(s)) for multiple versions of a particular workflow.

[0022] The system 100 may also include a workflow / mapping repository 118 that stores information about the dependencies of the task(s) and the plurality of workflows. In some embodiments, information about how a specific entity is connected to a workflow may be stored in the workflow / entity mapping repository 118. The information may include tracking information that maps entities to workflow code packages. In some embodiments, the workflow / mapping repository 118 may also store: information about the dependency change history of at least one of the plurality of tasks, and / or information about a specific version of a workflow and different versions of a workflow.

[0023] The management of changing dependency schema(s) for job(s) during various phases of execution is an extremely complex scenario. For example, rolling out new schema updates may become increasingly cumbersome and may result in breaking existing job(s).

[0024] Using the global dependency data structure 110, when a specific dependency for a specific workflow needs to be removed, the developer can perform the following sequence of steps. First, the developer removes the dependency association from the workflow code (for example, by removing its binding to the task, or by removing the entire task from the workflow). Next, the new workflow code is pushed out to run the job. In some examples, the average job execution environment may have approximately one thousand jobs for each build type run per day, so updating all of their packages may be a huge operational burden. Moreover, there may be numerous complex scenarios where jobs run for months and pushing out package changes may not be feasible. Finally, the dependency is removed from the global dependency data structure 110.

[0025] If there are any deviations from these steps, the removal process may lead to (multiple) issues. For example, if the workflow code rollout misses any jobs, the removed dependencies are still bound to the active jobs and may lead to issues, requiring manual backfilling of data.

[0026] Similarly, with the global dependency data structure 110, when a dependency needs to be added within a particular workflow, a developer may need to follow a precise sequence of steps. First, add a new dependency to the global dependency data structure 110. Next, update the first workflow code to bind a certain task to the prerequisite end of the dependency entity. Next, push out new workflow code to run the job (e.g., this may be very expensive and sometimes impractical). Then, then update the second workflow code to bind a certain task to the wait end of the dependency entity. Then, push out the second workflow code to run the job. Again, any deviation from these steps may cause(multiple) problems and require(multiple) manual workarounds.

[0027] The global dependency data structure 110 tracks changes to dependency entities of various versions of, for example, workflow(s). Figure 2 , a workflow submission system 200 is shown. The system 200 includes a workflow update component 210 that receives an updated workflow. The workflow update component 210 stores the updated workflow in the workflow repository 114.

[0028] System 200 also includes dependency update component 220 that determines any change(s) to the schema of the updated workflow based at least in part on information previously stored in global dependency data structure 110. In some embodiments, dependency update component 220 can achieve understanding of schema change(s) by tracking dependency entity changes.

[0029] Next, the dependency update component 220 can also determine how a specific entity is connected to a specific workflow. This can be achieved by tracking the mapping between the entity and the workflow code package. In some embodiments, the dependency update component 220 can store information about any changes to the schema in the global dependency data structure 110 (e.g., schema change delta) and how the specific entity is connected to a specific workflow in the global workflow / mapping repository 118 (e.g., tracking of dependency entity mappings). This information can be utilized at runtime to allow the job execution environment to determine what is happening on the package associated tasks in addition to checking the existence of the entity, taking into account changes to the entity, as discussed below.

[0030] return Figure 1The system 100 includes a runtime dependency component 120 that can perform automatic dependency conflict resolution at runtime to overcome potential problems caused by dependency version mismatches, such as potential problems caused by removed dependencies, added dependencies, and / or dependency scope changes.

[0031] Runtime dependency component 120 includes dependency identification component 130 and dependency automatic conflict resolution component 140. Dependency identification component 130 retrieves dependency information about a particular workflow from global dependency data structure 110 and identifies the dependency(s), if any, of the current version of the particular workflow.

[0032] If any of the identified dependencies (multiple) are determined to be problematic, the dependency automatic conflict resolution component 140 can perform one or more automatic conflict resolution actions. By reviewing the dependency (multiple) at runtime, the runtime dependency component 120 can (1) check the existence of the entity, (2) consider what has changed in the entity; and (3) what is happening on the tasks associated with the (multiple) packages. Since each job package can now mix and match dependency patterns - therefore, it is likely that for cross-job interaction scenarios, one package has dependency entities that conflict with dependency entities of other packages. In some embodiments, the automatic conflict resolution component 140 can automatically resolve conflicts based at least in part on information retrieved from the global dependency structure 110 and information about dependencies and multiple workflows retrieved from the workflow / entity mapping repository 118. In some embodiments, the runtime dependency component 120 can provide information about the broken dependency relationships (events) to a user (e.g., a human) via an output component 150 (e.g., via a graphical user interface, report).

[0033] (Multiple) dependency change scenarios may include dependency addition and / or dependency removal. For purposes of explanation and not limitation, the following symbols and conventions will be used to depict packages and their dependency patterns:

[0034] [package,job]:[dependent entity]

[0035] ->Indicates dependency relationship

[0036] N / A indicates "don't care or no dependency"

[0037] <-> indicates a task bound to a dependent entity

[0038] Table 1

[0039] Dependency removal scenario

[0040] 1. Work in progress, schema change to remove dependencies

[0041] Within package P, job J1 starts with the pattern A->B. However, while the job is in progress, the pattern is changed to remove the dependency:

[0042] initial

[0043] [P, J1]: A->B

[0044] at last

[0045] [P, J1]: N / A

[0046] Table 2

[0047] Normally, since the job starts with the pattern A->B, it uses that pattern and waits for the dependency.

[0048] With the system 100, when a job reaches a dependency check, it will not wait for any dependency-based dependency information stored in the global dependency data structure 110. Since the current workflow does not include a previous dependency, the job will not wait.

[0049] 2. In progress, the tasks that meet the requirements are changed to use different packages

[0050] A job starts with the pattern A -> B. However, while in progress, the tasks that satisfy B are changed to use a different package that does not contain entity B. This can be within the same job or across jobs.

[0051] Cross-operation

[0052] initial

[0053] [P1, J1]: A->B

[0054] [P2, J2]: A->B

[0055] at last

[0056] [P1, J1]: A->B

[0057] [P3, J2]: empty

[0058] In the job

[0059] initial

[0060] [P1, J1]: A->B

[0061] at last

[0062] [P2, J1]: empty

[0063] Table 3

[0064] As usual, an incident is created; however, the incident contains no additional details and it may be difficult to quickly understand what went wrong.

[0065] With the system 100, if there is a task <-> A, but there is no task <-> B, the dependency relationship is considered broken, and an event can be created with additional information identifying the broken dependency, such as "B is bound to a task in package P2, not a task in the current package P3." The additional information can be based at least in part on information obtained from the global dependency data structure 110 and the workflow / entity mapping repository 118.

[0066] 3. Workflow package changes are in progress

[0067] Initially, the job has a dependency A->B, where both A and B are attached to tasks within the same workflow. The workflow package changes so that there is no task emitting the entity.

[0068] initial

[0069] [P1, J1]: A->B

[0070] at last

[0071] [P2, J1]: empty

[0072] Table 4

[0073] As usual, create the event without any additional details.

[0074] With the system 100, if there is a task <-> A, but there is no task <-> B, the dependency relationship is considered broken and an event can be created with additional information, such as "B is bound to a task in package P1, not a task in the current package P2". The additional information can be based at least in part on information obtained from the global dependency data structure 110 and the workflow / entity mapping repository 118.

[0075] Dependency Addition Scenario

[0076] 1. Work in progress, with binding tasks, schema changes to add dependencies

[0077] Initially, the job starts with a task that is bound to A and bound to B with no dependencies. With the job in progress, the pattern changes to add A->B:

[0078] initial

[0079] [P, J1]: N / A

[0080] at last

[0081] [P, J1]: A->B

[0082] Table 5

[0083] Normally, because the schema has changed between the start of the job and the current time, and the current schema is always the source of truth, the job will wait for dependencies without checking for active bindings.

[0084] With the system 100, since the task is <-> A and the task is <-> B, but since the package has both tasks, additional information is needed in some embodiments. First, if the task is actively bound, the system 100 will wait for the dependency to be satisfied. If the task is bound but not active (e.g., it is protected by a flag whose value is unknown at this time), the system 100 will wait until the task starts.

[0085] In doing so, the system 100 will check the global dependency data structure 110 and the workflow / entity mapping repository 118 to obtain the current details of the entity and which package contains which entity. Also, the bound dependency entities are checked to see the active bindings of the task to the entity. 2. In progress, a schema change to add a dependency, with an initially unbound task

[0086] In this scenario, when the job starts, there are tasks that are bound to A but not to B with no dependencies. In the case where the job is in progress, the pattern changes to add A->B:

[0087] initial

[0088] [P, J1]: N / A

[0089] at last

[0090] [P, J1]: A->B

[0091] Table 6

[0092] Normally, the execution environment records the pattern, observes new dependencies, and throws unmet dependency errors without any additional details.

[0093] Using the system 100, it can be observed that the task is bound to A, but the task is not bound to B. Since the package has not changed, the system 100 can determine (a) when the dependency was introduced (from the global dependency data structure 110), and (b) when the package was created (from the workflow / entity mapping repository 118). If a>b (the dependency was introduced after the package was created), then the dependency can be skipped (e.g., ignored). If a<=b (the dependency was introduced before or at the same time as the package was created), then the system 100 determines that the dependency relationship is broken. The system 100 can create an event that provides information about the determined broken dependency relationship, such as "B was never bound to any task in P."

[0094] Dependency scope type change scenario

[0095] In some embodiments, dependency scope is another variable to be considered by the system 100. In some scenarios, each dependency exists in one or many different scope types (e.g., action A depends on action B for building a given new cluster, but they both depend on action C being performed by building the entire data center in which the new cluster is built). Automatic conflict resolution of the system 100 can be helpful when dependency scope types change.

[0096] Scope type removal is usually not a problem, as the scope type can simply be removed from the global schema and all jobs can immediately start ignoring it from their dependency orchestrations.

[0097] However, range type additions can be problematic because if old prerequisites are satisfied using an old subset of range types, this means that jobs that arrive at an orchestration point after the range type addition will not have the correct information about the prerequisites. System 100 can facilitate automatic resolution by extending the orchestration point check to take supported range types into account.

[0098] For example, if A depends on B, and dependency B has a scope of "cluster" and it is changed (expanded to have a scope of both "cluster" and "region"), the system 100 uses information from the workflow / entity mapping repository 118 (e.g., OtherScopeValue) when validating. Thus, when the system 100 evaluates A against prerequisite B, the system 100 can determine whether B exists at all. The system 100 can also determine, in one such case, whether the region value of OtherScopeValue also matches the region value in the context of A. If the system 100 determines a match, it will satisfy the dependency rather than discarding the event(s).

[0099] If the scope changes from one scope type to another, the automatic resolution of the system 100 can check the relationships between the scopes (e.g., scope types can be nested within each other or completely independent). If the change is from a smaller scope X to a larger scope Y that completely includes X, any dependencies with the new scope can be automatically resolved by checking that the older scope dependencies are satisfied. If the scope change has no nested relationships, the automatic resolution of the system 100 is not performed; however, the system 100 can, for example, populate the event with information to help an operator manually resolve the issue (e.g., "dependency pattern changed with change of scope from cluster to region").

[0100] Figures 3 to 5Exemplary methods related to automatic resolution of dependency version conflicts are shown. Although these methods are shown and described as a series of actions performed in sequence, it is to be understood and appreciated that these methods are not limited by the order of the sequence. For example, some actions may occur in an order different from the order described herein. In addition, an action may occur simultaneously with another action. In addition, in some instances, not all actions may be required to implement the methods described herein.

[0101] Furthermore, the actions described herein may be computer executable instructions, which may be implemented by one or more processors and / or stored on one or more computer readable media. Computer executable instructions may include routines, subroutines, programs, execution threads, etc. Furthermore, the results of the actions of the method may be stored in a computer readable medium, displayed on a display device, etc.

[0102] refer to Figure 3 and Figure 4 , a method 300 for automatically resolving dependency version conflicts is shown. In some embodiments, the method 300 is performed by the system 100.

[0103] At 310, during execution of a particular version of a workflow including a plurality of tasks, information is received regarding a particular task of the plurality of tasks to be performed. The particular task is dependent on another task of the plurality of tasks.

[0104] At 320, information about dependencies is retrieved from a global dependency data structure. The global dependency data structure stores current dependency information about a plurality of tasks.

[0105] At 330, a determination is made as to whether there is a conflict in the dependency of a particular task on another task. For example, a conflict may be: a task is linked to a dependency entity that does not exist; and / or one entity is dependent on another entity that is not linked to any task in any workflow that includes a given job.

[0106] If the determination at 330 is "no," no further processing occurs. If the determination at 330 is "yes," then at 340 when it is determined that there is a conflict: At 350, information about dependencies and the plurality of workflows is retrieved. At 354, information about dependency change histories associated with at least one of the plurality of tasks is retrieved. At 358, information about a particular version of a workflow and different versions of a workflow is retrieved.

[0107] At 360, a resolution to the conflict is identified based at least in part on information retrieved from a global dependency data structure, information retrieved about a dependency change history associated with at least one of the plurality of tasks, information retrieved about dependencies and a plurality of workflows, and information retrieved about a particular version of a workflow and different versions of the workflow.

[0108] At 364, based at least in part on the identified solution, a corrective action is performed to resolve the conflict. In some embodiments, the corrective action may include: skipping the dependency if it is no longer applicable; waiting for the dependency if it is still applicable; updating the version of the workflow to a newer version without the conflict; and / or reflecting to a user to manually perform the corrective action, for example, using detailed information about the identified conflict and its history.

[0109] Steering Figure 5 , a method 500 of workflow submission is shown. In some embodiments, the method 500 is performed by the system 200.

[0110] At 510, a version of a particular task in a plurality of tasks is received. At 520, dependency information stored in a global dependency data structure is updated based at least in part on the received version of the particular task. The global dependency data structure stores current dependency information about the plurality of tasks. At 530, a particular workflow is packaged, the particular workflow including the particular version of at least some of the plurality of tasks. At 540, information mapping the particular workflow to dependencies of at least some of the plurality of tasks is stored.

[0111] Described herein is a system for job execution, the system comprising: a computer comprising a processor and a memory, the memory having computer executable instructions stored thereon, the computer executable instructions when executed by the processor causing the computer to: during execution of a specific version of a workflow comprising a plurality of tasks, receive information about a specific task to be executed among the plurality of tasks, the specific task being dependent on another task among the plurality of tasks; retrieve information about the dependency from a global dependency data structure, wherein the global dependency data structure stores current dependency information about the plurality of tasks; determine whether there is a conflict regarding the dependency of the specific task on another task; and when it is determined that there is a conflict: retrieve information about the dependency and the plurality of workflows; retrieve information about a dependency change history associated with at least one of the plurality of tasks; retrieve information about a specific version of the workflow and different versions of the workflow; identify a solution to the conflict based at least in part on the information retrieved from the global dependency data structure, the information retrieved about the dependency change history associated with at least one of the plurality of tasks, the information retrieved about the dependency and the plurality of workflows, and the information retrieved about the specific version of the workflow and different versions of the workflow; and perform a corrective action to resolve the conflict based at least in part on the identified solution.

[0112] The system may include: wherein the conflict is automatically resolved by using different versions of a particular workflow. The system may also include: wherein the conflict is automatically resolved by executing a particular workflow. The system may include: wherein the conflict is automatically resolved by providing information about the conflict to a user via a graphical user interface.

[0113] The system may also include: wherein the information provided to the user is based at least in part on the information retrieved from the global dependency data structure, and the retrieved information about the dependency and the plurality of workflows. The system may also include: wherein the global dependency data structure also stores current dependency information for at least one of the plurality of tasks. The system may also include: wherein conflicts are also automatically resolved based on whether the task is bound to a dependency.

[0114] The system may include a memory having additional computer executable instructions stored thereon, which, when executed by a processor, cause the computer to: receive a version of a specific task among a plurality of tasks; update dependency information stored in a global dependency data structure based at least in part on the received version of the specific task; package a specific workflow that includes specific versions of at least some of the plurality of tasks; and store information mapping the specific workflow to dependencies of at least some of the plurality of tasks.

[0115] Described herein is a method for automatically resolving dependency version conflicts, the method comprising: during execution of a specific version of a workflow comprising a plurality of tasks, receiving information about a specific task to be executed among the plurality of tasks, the specific task being dependent on another task among the plurality of tasks; retrieving information about the dependency from a global dependency data structure, wherein the global dependency data structure stores current dependency information about the plurality of tasks; determining whether there is a conflict regarding the dependency of the specific task on another task; and when it is determined that there is a conflict: retrieving information about the dependency and the plurality of workflows; retrieving information about a dependency change history associated with at least one of the plurality of tasks; retrieving information about the specific version of the workflow and different versions of the workflow; identifying a solution to the conflict based at least in part on the information retrieved from the global dependency data structure, the retrieved information about the dependency change history associated with at least one of the plurality of tasks, the retrieved information about the dependency and the plurality of workflows, and the retrieved information about the specific version of the workflow and different versions of the workflow; and performing corrective actions to resolve the conflict based at least in part on the identified solution.

[0116] The method may also include: wherein the conflict is automatically resolved by using different versions of the specific workflow. The method may also include: wherein the conflict is automatically resolved by executing the specific workflow. The method may also include: wherein the conflict is automatically resolved by providing information about the conflict to a user via a graphical user interface.

[0117] The method may also include: wherein the information provided to the user is based at least in part on the information retrieved from the global dependency data structure and the retrieved information about the dependency and the plurality of workflows. The method may also include: wherein the global dependency data structure also stores dependency information of future dependencies of at least one of the plurality of tasks. The method may also include: wherein the conflict is also automatically resolved based on whether the task is bound to the dependency.

[0118] The method may also include: receiving a version of a specific task among multiple tasks; updating dependency information stored in a global dependency data structure based at least in part on the received version of the specific task; packaging a specific workflow, which includes a specific version of at least some of the multiple tasks; and storing information mapping the specific workflow to dependencies of at least some of the multiple tasks.

[0119] Described herein is a computer storage medium storing computer-readable instructions that, when executed, cause a computing device to: during execution of a specific version of a workflow that includes multiple tasks, receive information about a specific task to be executed among the multiple tasks, the specific task being dependent on another task among the multiple tasks; retrieve information about the dependency from a global dependency data structure, wherein the global dependency data structure stores current dependency information about the multiple tasks; determine whether there is a conflict regarding the dependency of the specific task on the other task; and when it is determined that there is a conflict: retrieve information about the dependency and the multiple workflows; retrieve information about a dependency change history associated with at least one of the multiple tasks; retrieve information about the specific version of the workflow and a different version of the workflow; identify a resolution to the conflict based at least in part on the information retrieved from the global dependency data structure, the information retrieved about the dependency change history associated with at least one of the multiple tasks, the information retrieved about the dependency and the multiple workflows, and the information retrieved about the specific version of the workflow and the different version of the workflow; and perform a corrective action to resolve the conflict based at least in part on the identified resolution.

[0120] The computer storage medium may also include: wherein conflicts are automatically resolved by using different versions of the particular workflow. The computer storage medium may also include: wherein the global dependency data structure further stores dependency information of future dependencies of at least one task in the plurality of tasks.

[0121] The computer storage medium may store additional computer-readable instructions that, when executed, cause a computing device to: receive a version of a particular task among a plurality of tasks; update dependency information stored in a global dependency data structure based at least in part on the received version of the particular task; package a particular workflow that includes the particular version of at least some of the plurality of tasks; and store information mapping the particular workflow to dependencies of at least some of the plurality of tasks.

[0122] refer to Figure 6 , illustrated is an example general purpose computer or computing device 602 (e.g., a mobile phone, desktop, laptop, tablet, watch, server, handheld device, programmable consumer or industrial electronics, set-top box, gaming system, computing node, etc.) For example, computing device 602 can be used in system 100 for job execution.

[0123] The computer 602 includes one or more processors 620, a memory 630, a system bus 640, (multiple) mass storage devices 650, and one or more interface components 670. The system bus 640 communicatively couples at least the above-mentioned system components. However, it is to be appreciated that the computer 602, in its simplest form, may include one or more processors 620 coupled to the memory 630, which one or more processors 620 execute various computer-executable actions, instructions, and / or components stored in the memory 630. For example, the instructions may be instructions for implementing the functions described as being performed by one or more components discussed above, or instructions for implementing one or more of the methods described above.

[0124] The processor(s) 620 may be implemented with a general purpose processor, a digital signal processor (DSP), an application specific integrated circuit (ASIC), a field programmable gate array (FPGA) or other programmable logic device, discrete gate or transistor logic, discrete hardware components, or any combination thereof, designed to perform the functions described herein. The general purpose processor may be a microprocessor, but in an alternative, the processor may be any processor, controller, microcontroller, or state machine. The processor(s) 620 may also be implemented as a combination of computing devices, such as a combination of a DSP and a microprocessor, a combination of multiple microprocessors, a combination of multi-core processors, a combination of one or more microprocessors in combination with a DSP core, or any other such configuration. In one embodiment, the processor(s) 620 may be a graphics processor.

[0125] Computer 602 may include or otherwise interact with a variety of computer-readable media to facilitate control of computer 602 to implement one or more aspects of the claimed subject matter. Computer-readable media can be any available media that can be accessed by computer 602, and includes both volatile and nonvolatile media and removable and non-removable media. Computer-readable media can include two different and mutually exclusive types, namely computer storage media and communication media.

[0126] Computer storage media include volatile and nonvolatile, removable and non-removable media implemented in any method or technology for storage of information, such as computer-readable instructions, data structures, program modules or other data. Computer storage media include storage devices, such as memory devices (e.g., random access memory (RAM), read-only memory (ROM), electrically erasable programmable read-only memory (EEPROM), etc.), magnetic storage devices (e.g., hard disks, floppy disks, cassettes, tapes, etc.), optical disks (e.g., compact disks (CDs), digital versatile disks (DVDs), etc.), and solid-state devices (e.g., solid-state drives (SSDs), flash drives (e.g., cards, sticks, key drives, etc.), or any other similar media that store (rather than transmit or communicate) desired information accessible by the computer 602. Therefore, computer storage media does not include modulated data signals, and what is described with respect to communication media.

[0127] Communication media embodies computer readable instructions, data structures, program modules or other data in a modulated data signal such as a carrier wave or other transport mechanism, and includes any information delivery media. The term "modulated data signal" means a signal that has one or more of its characteristics set or changed in such a manner as to encode information in the signal. By way of example, and not limitation, communication media include: wired media such as a wired network or direct-wired connection; and wireless media such as acoustic, RF, infrared and other wireless media.

[0128] Memory 630 and mass storage device(s) 650 are examples of computer-readable storage media. Depending on the exact configuration and type of computing device, memory 630 may be volatile (e.g., RAM), non-volatile (e.g., ROM, flash memory, etc.), or some combination of the two. By way of example, a basic input / output system (BIOS) (including basic routines to transfer information between elements within computer 602, such as during startup) may be stored in non-volatile memory, while volatile memory may act as external cache memory to facilitate processing by processor(s) 620, among other things.

[0129] The mass storage device(s) 650 include removable / non-removable, volatile / non-volatile computer storage media for storing large amounts of data relative to the memory 630. For example, the mass storage device(s) 650 include, but are not limited to, one or more devices such as a magnetic or optical disk drive, a floppy disk drive, a flash memory, a solid state drive, or a memory stick.

[0130] The memory 630 and the mass storage device(s) 650 may include or have stored therein an operating system 660, one or more applications 662, one or more program modules 664, and data 666. The operating system 660 is used to control and allocate resources of the computer 602. The application 662 includes one or both of system and application software, and can utilize the management of resources by the operating system 660 through the program modules 664 and data 666 stored in the memory 630 and / or the mass storage device(s) 650 for performing one or more actions. Thus, the application 662 can transform the general-purpose computer 602 into a special-purpose machine according to the logic provided thereby.

[0131] All or part of the claimed subject matter may be implemented using standard programming and / or engineering techniques to produce software, firmware, hardware, or any combination thereof to control a computer to implement the disclosed functionality. By way of example and not limitation, the system 100 or a portion thereof may be or form part of an application 662 and include one or more modules 664 and data 666 stored in memory and / or (multiple) mass storage devices 650, the functionality of which may be implemented when executed by one or more processors 620.

[0132] In some embodiments, (multiple) processors 620 may correspond to a system on chip (SOC) or similar architecture, which includes or in other words integrates both hardware and software on a single integrated circuit substrate. Here, among other aspects, (multiple) processors 620 may include one or more processors and memories that are at least similar to (multiple) processors 620 and memory 630. Conventional processors include a minimum amount of hardware and software and rely extensively on external hardware and software. In contrast, the SOC implementation of the processor is more powerful because it embeds hardware and software therein, which implements specific functions with minimal or no reliance on external hardware and software. For example, system 100 and / or associated functions can be embedded in hardware in a SOC architecture.

[0133] The computer 602 also includes one or more interface components 670 that are communicatively coupled to the system bus 640 and facilitate interaction with the computer 602. By way of example, the interface component 670 can be a port (e.g., serial, parallel, PCMCIA, USB, Firewire, etc.) or an interface card (e.g., sound, video, etc.), etc. In one example implementation, the interface component 670 can be embodied as a user input / output interface to enable a user to input commands and information into the computer 602, such as by way of one or more gestures or voice input, through one or more input devices (e.g., a pointing device such as a mouse, a trackball, a stylus, a touchpad, a keyboard, a microphone, a joystick, a game pad, a satellite dish, a scanner, a camera, other computers, etc.). In another example implementation, the interface component 670 can be embodied as an output peripheral interface to provide output to, among other things, a display (e.g., LCD, LED, plasma, etc.), a speaker, a printer, and / or other computers. Still further, the interface component 670 can be embodied as a network interface to enable communication with other computing devices (not shown), such as through a wired or wireless communication link.

[0134] What has been described above includes examples of aspects of the claimed subject matter. Of course, for the purposes of describing the claimed subject matter, it is not possible to describe every conceivable combination of components or methods, but one of ordinary skill in the art will recognize that many additional combinations and permutations of the disclosed subject matter are possible. Therefore, the disclosed subject matter is intended to include all such changes, modifications, and variations that fall within the spirit and scope of the appended claims. Furthermore, to the extent that the term "includes" is used in the detailed description or in the claims, such term is intended to be inclusive in a manner similar to the term "comprising," as interpreted when "comprising" is used as a transitional word in a claim.

Claims

1. A system for job execution, comprising: A computer, comprising a processor and a memory, wherein the memory stores computer executable instructions, and when the computer executable instructions are executed by the processor, the computer: During execution of a particular version of a workflow including a plurality of tasks, receiving information regarding a particular task of the plurality of tasks to be executed, the particular task having a dependency on another task of the plurality of tasks; retrieving information about the dependencies from a global dependency data structure, wherein the global dependency data structure stores current dependency information about the plurality of tasks; determining whether a conflict exists regarding the dependency of the particular task on the other task; as well as When it is determined that such a conflict exists: retrieving information about the dependencies and the plurality of workflows; retrieving information about a dependency change history associated with at least one task of the plurality of tasks; retrieving information about the particular version of the workflow and different versions of the workflow; identifying a resolution to the conflict based at least in part on the information retrieved from the global dependency data structure regarding the dependency, the information retrieved regarding a history of changes to the dependency associated with the at least one of the plurality of tasks, the information retrieved regarding the dependency and the plurality of workflows, and the information retrieved regarding the particular version of the workflow and the different version of the workflow; and Based at least in part on the identified solution, corrective action is performed to resolve the conflict. 2 . The system of claim 1 , wherein the conflict is automatically resolved by using the different versions of the workflow. The system of claim 1 , wherein the conflict is automatically resolved by executing the workflow. 4 . The system of claim 1 , wherein the conflict is automatically resolved by providing information about the conflict to a user via a graphical user interface.

5. The system of claim 4, wherein the information provided to the user is based at least in part on: the information about the dependencies retrieved from the global dependency data structure, and the information retrieved about the dependencies and the plurality of workflows. The system of claim 1 , wherein the conflict is also automatically resolved based on whether a task is bound to the dependency.

7. The system of claim 1 , the memory having stored thereon additional computer executable instructions that, when executed by the processor, cause the computer to: receiving a version of the specific task among the plurality of tasks; updating the current dependency information stored in the global dependency data structure based at least in part on the received version of the particular task; packaging a specific workflow, the specific workflow including specific versions of at least some of the plurality of tasks; as well as Information mapping the particular workflow to dependencies of the at least some of the plurality of tasks is stored.

8. A method for automatically resolving dependency version conflicts, comprising: During execution of a particular version of a workflow including a plurality of tasks, receiving information regarding a particular task of the plurality of tasks to be executed, the particular task having a dependency on another task of the plurality of tasks; retrieving information about the dependencies from a global dependency data structure, wherein the global dependency data structure stores current dependency information about the plurality of tasks; determining whether a conflict exists regarding the dependency of the particular task on the other task; as well as When it is determined that such a conflict exists: retrieving information about the dependencies and the plurality of workflows; retrieving information about a dependency change history associated with at least one task of the plurality of tasks; retrieving information about the particular version of the workflow and different versions of the workflow; identifying a resolution to the conflict based at least in part on the information retrieved from the global dependency data structure regarding the dependency, the information retrieved regarding a history of changes to the dependency associated with the at least one of the plurality of tasks, the information retrieved regarding the dependency and the plurality of workflows, and the information retrieved regarding the particular version of the workflow and the different version of the workflow; and Based at least in part on the identified solution, corrective action is performed to resolve the conflict.

9. The method of claim 8, wherein the conflict is automatically resolved by using the different versions of the workflow.

10. The method of claim 8, wherein the conflict is automatically resolved by executing the workflow.

11. The method of claim 8, wherein the conflict is automatically resolved by providing information about the conflict to a user via a graphical user interface.

12. The method of claim 11, wherein the information provided to the user is based at least in part on: the information about the dependencies retrieved from the global dependency data structure, and the information retrieved about the dependencies and the plurality of workflows. 13 . The method of claim 8 , wherein the global dependency data structure further stores future dependency information regarding future dependencies of one or more tasks in the plurality of tasks. The method of claim 8 , wherein the conflict is also automatically resolved based on whether a task is bound to the dependency.

15. The method according to claim 8, further comprising: receiving a version of the specific task among the plurality of tasks; updating the current dependency information stored in the global dependency data structure based at least in part on the received version of the particular task; packaging a specific workflow, the specific workflow including specific versions of at least some of the plurality of tasks; as well as Information mapping the particular workflow to dependencies of the at least some of the plurality of tasks is stored.

16. A computer storage medium storing computer readable instructions which, when executed, cause a computing device to: During execution of a particular version of a workflow including a plurality of tasks, receiving information regarding a particular task of the plurality of tasks to be executed, the particular task having a dependency on another task of the plurality of tasks; retrieving information about the dependencies from a global dependency data structure, wherein the global dependency data structure stores current dependency information about the plurality of tasks; determining whether a conflict exists regarding the dependency of the particular task on the other task; as well as When it is determined that such a conflict exists: retrieving information about the dependencies and the plurality of workflows; retrieving information about a dependency change history associated with at least one task of the plurality of tasks; retrieving information about the particular version of the workflow and different versions of the workflow; identifying a resolution to the conflict based at least in part on the information retrieved from the global dependency data structure regarding the dependency, the information retrieved regarding a history of changes to the dependency associated with at least one of the plurality of tasks, the information retrieved regarding the dependency and the plurality of workflows, and the information retrieved regarding the particular version of the workflow and the different version of the workflow; and Based at least in part on the identified solution, corrective action is performed to resolve the conflict.

17. The computer storage medium of claim 16, wherein the conflict is automatically resolved by using the different versions of the workflow.

18. The computer storage medium of claim 16, wherein the global dependency data structure further stores future dependency information related to future dependencies of one or more tasks in the plurality of tasks.

19. The computer storage medium of claim 16 storing computer readable instructions that when executed cause the computing device to: receiving a version of the specific task among the plurality of tasks; updating the current dependency information stored in the global dependency data structure based at least in part on the received version of the particular task; packaging a specific workflow, the specific workflow including specific versions of at least some of the plurality of tasks; as well as Information mapping the particular workflow to dependencies of the at least some of the plurality of tasks is stored.