CN115237593A

CN115237593A - Workflow scheduling method with multiple timing constraints in mixed cloud environment

Info

Publication number: CN115237593A
Application number: CN202210816561.3A
Authority: CN
Inventors: 梁合兰; 李煌; 李凡长
Original assignee: Suzhou University
Current assignee: Suzhou University
Priority date: 2022-07-12
Filing date: 2022-07-12
Publication date: 2022-10-25
Anticipated expiration: 2042-07-12
Also published as: CN115237593B

Abstract

The invention relates to a workflow scheduling method with multi-timing constraint in a mixed cloud environment, which comprises the following steps: establishing a formalized model of a mixed cloud multi-timing-constraint workflow scheduling problem comprising decision variables of the model, model constraints and a model target, establishing a multi-timing-constraint decomposition strategy, a heuristic task allocation strategy and a cost optimization strategy considering a charging period under the formalized model of the mixed cloud multi-timing-constraint workflow scheduling problem, and obtaining an optimal scheme of workflow scheduling with timing constraints in a mixed cloud by using the multi-timing-constraint decomposition strategy, the heuristic task allocation strategy and the cost optimization strategy considering the charging period. The invention can improve the effectiveness of optimal solution generation, and formulate a scheduling solution with lower cost in complex environments such as complex flow structures, multi-time-sequence constraints, mixed cloud resources and the like.

Description

Workflow scheduling method with multiple timing constraints in mixed cloud environment

Technical Field

The invention relates to the technical field of cloud computing resource scheduling, in particular to a workflow scheduling method with multiple timing constraints in a hybrid cloud environment.

Background

A workflow refers specifically to a set of related tasks that are completed according to a chronological order. With the complication of business requirements, especially under the rapid development of industrial clusters, the computing requirements of workflows are higher and higher. The enterprise can fully utilize the computing resources of the enterprise and protect the data security by constructing a hybrid cloud environment consisting of private cloud resources and public cloud resources, has the advantage of elastic expansion of the public cloud, and is the most popular cloud architecture mode at present. In a hybrid cloud environment, not only the "limited" resources owned by the enterprise themselves need to be considered, but also the "unlimited" resources in the public cloud are managed, and Virtual Machines (VMs) with various Machine configuration and pricing models are provided in the cloud, so how to allocate workflow tasks to appropriate Virtual machines, and thus determining a scheduling solution with the lowest cost (i.e., hybrid cloud workflow scheduling) is a hot spot and a difficult point of current research.

With the complication of business requirements, the computational requirements of workflows are becoming higher and higher. Although some enterprises have built private cloud environments, the resources of the private cloud environments are limited, and in order to meet peak demands, the operation of workflows by combining public cloud resources is receiving wide attention. The hybrid cloud combining private cloud resources and public cloud resources manages not only the "limited" resources owned by the enterprise itself, but also the "unlimited" resources in the public cloud, so workflow scheduling in the hybrid cloud is different and more difficult than traditional public cloud or private cloud scheduling.

In the prior art, there are researches on the scheduling problem of the hybrid cloud service process, and some research achievements are obtained. The workflow scheduling problem with workflow cut-off time constraint under the cost minimization target is considered in some researches, and various meta-heuristic methods are designed to improve the solving precision and efficiency. Some heuristics have been devised, such as an algorithm that reschedules tasks onto resources of the public cloud greedily once the workflow deadline constraints are violated. There is also a study to design an integer programming model that takes into account deadline constraints and resource limitations with the goal of profit maximization from the resource provider's perspective. However, these studies only consider the deadline constraint, but do not consider the task-level timing constraint that is widely existed in the real flow, and are difficult to be applied to the resource scheduling problem with multiple timing constraints.

Due to enterprise business policies, legal settings, and the like, a timing constraint is usually set in the workflow, and if the timing constraint is violated, execution errors of the workflow will be caused, and unnecessary loss or even disastrous consequences are caused to the enterprise. Many workflow scheduling studies consider Deadline constraints (deadlines constraints) which are the most basic timing constraints of the whole workflow, but in order to ensure correct execution of key business processes in daily business, besides the Deadline constraints, timing requirements among certain tasks or data in the processes are often defined, which are called task-level timing constraints. Compared with the process deadline constraint, the task-level timing constraint has wider and more flexible definition range. Since multiple timing constraints can be set in one flow, each timing constraint can contain multiple tasks, the feasible domain of the tasks becomes very narrow, and it is very complicated to find a scheduling solution that satisfies the multiple timing constraints.

The timing constraint defines the execution sequence and the longest execution time requirement among different tasks or data, and the formulated scheduling plan must be ensured to meet the timing constraint requirement in the scheduling problem. As a special timing constraint, current research considers the deadline constraint of a workflow, which limits the maximum executable time of the entire workflow. To solve the problem of deadline constraints for workflows, there are studies that propose constrained repair operators that filter out the best solution by repairing infeasible solutions. To make the search more efficient, some studies have proposed decomposing the workflow deadline into a local deadline for the task, thereby ensuring that only virtual machines that meet the task local deadline constraint can be assigned to the task. To meet increasingly complex business requirements, research has proposed more flexible task-level timing constraints. Compared with the process deadline constraint, the task-level timing constraint can be used for defining the timing requirement between any tasks or data in the process, the definition range is wider and more flexible, and a plurality of timing constraints can be set in one process. While these studies consider the case of multiple timing constraints, the above studies only consider the multiple timing constraint workflow scheduling problem in a public cloud environment. Unlike a public cloud environment, which can provide unlimited resources, resources in a private cloud are limited, and multiple tasks are often assigned to the same virtual machine. Once a task scheduled into a virtual machine has not completed, all subsequent tasks on the same virtual machine need to wait. Therefore, time delay due to resource limitation, task misscheduling and the like in the hybrid cloud environment is widely existed. Such delays can easily cause the execution time between tasks to exceed expectations, violating timing constraints. Therefore, the task scheduling problem under the hybrid cloud is very complicated due to the multi-timing constraint. In addition, in order to handle multiple timing constraints, current research adopts a method based on the satisfaction degree of the timing constraints. The method is characterized in that after a solution is generated, the feasibility of the solution is evaluated through a time sequence constraint satisfaction degree parameter, and therefore the optimal solution meeting all time sequence constraints is filtered. However, the strategy can only filter the solution based on the timing constraint requirement in the solution evaluation stage, and does not consider how to guide the generation of the solution based on the task-level timing constraint in the solution construction process, so that the search effectiveness and efficiency need to be improved.

The solving algorithm of the cloud scheduling problem can be divided into a heuristic algorithm and a meta-heuristic algorithm. The heuristic strategy is highly dependent on the characteristics of the problem, only one solution can be considered, the problem is easy to fall into the infeasible solution, and the heuristic strategy is difficult to be applied to the problem. The meta-heuristic operator does not depend on the problem characteristic, so that the meta-heuristic algorithm has higher diversity and expandability. However, as the flow structure is complicated and the number of timing constraints increases, the solution space for satisfying the constraints becomes narrow, and the algorithm highly dependent on the problem-independent meta-heuristic operator is also difficult to be applied to the problem.

In summary, compared with other cloud workflow scheduling problems, the hybrid cloud scheduling problem considering multiple timing constraints has the following difficulties: firstly, the hybrid cloud environment determines that the problem needs to consider not only the 'limited' resources owned by the enterprise itself, but also the 'unlimited' resources in the public cloud, and the private cloud resources are often low in cost but limited in resources. Second, the feasible execution time of a task becomes very narrow due to the presence of multiple complex timing constraints. How to comprehensively consider various resource elements to formulate a scheduling solution with the lowest cost under the time sequence constraint condition is a difficult problem. The problem of workflow scheduling with multiple timing constraints in a mixed cloud environment can be solved without a reasonable scheduling strategy.

Disclosure of Invention

Therefore, the technical problem to be solved by the invention is to overcome the defects in the prior art, and provide a workflow scheduling method with multiple timing constraints in a hybrid cloud environment, which can improve the effectiveness of optimal solution generation and make a scheduling solution with lower cost in complex environments such as complex flow structures, multiple timing constraints, hybrid cloud resources and the like.

In order to solve the technical problem, the invention provides a workflow scheduling method with multi-timing constraint in a hybrid cloud environment, which comprises the following steps:

s1: establishing a formal model of a hybrid cloud multi-timing constraint workflow scheduling problem, wherein the formal model of the hybrid cloud multi-timing constraint workflow scheduling problem comprises decision variables, model constraints and a model target of the model;

s2: establishing a multi-timing constraint decomposition strategy, a heuristic task allocation strategy and a cost optimization strategy considering a charging period under a formal model of the mixed cloud multi-timing constraint workflow scheduling problem;

s3: and obtaining an optimal scheme of workflow scheduling with time sequence constraint in the hybrid cloud by using the multi-time sequence constraint decomposition strategy, the heuristic task allocation strategy and the cost optimization strategy considering the charging period.

Preferably, the formal model of the mixed cloud multi-timing constraint workflow scheduling problem specifically includes:

s1-1: setting parameters in a formal model of a mixed cloud multi-timing constraint workflow scheduling problem:

representing private clouds as pc ₁ Public cloud resource provider is denoted as EC = { EC = { EC } ₁ ,…,ec _m Therein each ec _m Representing a public cloud service provider, each cloud provider providing a virtual machine type of a different machine configuration and pricing model; representing virtual machine types as VMTs _i ＝{vmt _i ¹ ,…,vmt _i ^j ,…,vmt _i ^k Vmt _i ^j Representing a jth virtual machine type provided by an ith cloud;

the workflow set is defined as WP = { WP = { WP = ₁ ,…,wp _i ,…,wp _m Wherein each workflow is formally defined based on a Petri Net model, denoted wp _i ＝<TS _i ，P _i ，A _i >，TS _i Is a set of tasks in the ith workflow, P _i Is a state set of the task, A _i Is a directed arc set of connection tasks;

defining a flexible timing constraint set TCN = { TCN ₁ ,…,tcn _u ,…,tcn _n Where each flexible timing constraint tcn _u ＝<swp _u ,e _u ,d _u ,pa _u >Wherein swp _u Is the u-th timing constraint sub-flow,

storing tasks and data sequences related to the u-th time sequence constraint; e.g. of the type _u Is the u-th timing constraint ideal execution time limit, d _u Is the cut-off time, pa _u Is loss compensation; if in the Dispatch plan, execution swp _u Is less than the ideal execution time e _u If so, the scheduling plan is shown to completely meet the time sequence constraint requirement; if swp is executed _u Exceeds the cut-off time d _u If the scheduling plan completely violates the timing constraint, the scheduling plan is not feasible; if execution swp _u Is in the range of e _u And d _u Indicates that the dispatch plan partially satisfies the constraint for exceeding e _u Each time unit of (1) needs to be additionally added with a unit penalty cost pa _u ；

S1-2: setting decision variables of a model according to parameters in a formalized model of a mixed cloud multi-timing constraint workflow scheduling problem:

setting a decision variable x _ij ^kvq Is used forAnswering to which virtual machine each task is scheduled; x is a radical of a fluorine atom _ij ^kvq Is a variable from 0 to 1, if x _ij ^kvq =1 representing task t _ij Executed by a v-th type of virtual machine instance q, t of a k-th cloud provider _ij Is the jth task of the ith workflow; the number of each type of virtual machine in the public cloud is set as the task number | TS |, x _ij ^kvq The expression of (a) is:

setting a decision variable st _ij And ft _ij ，st _ij Start time, ft, for answering each task call to the virtual machine _ij An end time for answering each task call to the virtual machine;

s1-3: setting model constraints:

s1-3-1: setting a start time st of a task _ij The constraints of (2) are:

wherein pred (t) _ij ) As task t _ij The immediate predecessor task set of, adb (t) _ij ) As task t _ij Set of tasks currently scheduled on the scheduled resource, t _iu Represents t _ij Any one of the immediately preceding tasks of, t _hp Representing a task t _ij Any task currently scheduled on the scheduled resource, ft _iu Representing a task t _iu End time of ft _hp Representing a task t _hp The end time of (d);

setting the end time ft of each task calling virtual machine _ij Equal to the start time plus the execution time:

wherein,

representing a task t _ij Execution time under a v type of virtual machine provided by a k type of cloud provider;

s1-3-2: obtaining a timing constraint formula according to the flexible timing constraint:

wherein,

for the u-th timing constraint subprocess swp _u The end time of (a) is set,

for the u-th timing constraint subroutine swp _u Start time of (d) _u Is the cutoff time of the u-th timing constraint, tcn _u Representing the u flexible timing constraint, and TCN representing a flexible timing constraint set;

s1-3-3: setting limits that each task can only be scheduled to one virtual machine:

s1-3-4: setting limits that each virtual machine can only execute one task at the same time:

wherein, zt _ij ^s Is a variable from 0 to 1 and is used for marking the task t _ij Whether or not to execute at time s; if zt _ij ^s =1 indicates renAffair t _ij At time s;

s1-3-5: setting resource constraints for limiting the private cloud:

wherein, vcpu _v Number of CPUs vmem required for virtual machine type v representing a private cloud _v Amount of memory required for virtual machine type v representing private cloud, C ^cpu Representing the maximum CPU number, C, of the resource pool of the private cloud ^mem Representing the maximum memory quantity of the resource pool of the private cloud; x is the number of _ij ^1vq Is a variable from 0 to 1, if x _ij ^1vq =1 representing task t _ij Executing by a virtual machine instance q of a v-th type of a private cloud provider;

s1-4: setting a model target:

min TotalCost＝ProcCost+TranCost+TemPen (10)；

wherein, totalCost is the total cost of the scheduling model, procCost is the resource execution cost, and the method specifically comprises the following steps:

wherein, cr _k ^v Billing unit price for the v-th virtual machine type of the k-th cloud provider, b _k ^v A charging period for a vth virtual machine type of a kth cloud provider;

the TranCost is transmission cost, and specifically includes:

wherein,

is a variable from 0 to 1, if

Indicating a task t _iu Completed by the qth instance of the v 'th VM type of the kth' cloud service provider; g _d For an arbitrary task t _ij And its immediate preceding task t _iu The amount of data transmission between the first and second terminals,

as task t _iu Matched cloud service provider k' and task t _ij A unit transmission cost between the matched cloud service providers k;

TemPhen is constraint penalty cost, and the TemPhen summarizes default penalty of each time sequence constraint according to flexible time sequence constraint to obtain total constraint penalty cost:

wherein pa _u Unit penalty cost for the u-th timing constraint, e _u The ideal execution time for the u-th timing constraint.

Preferably, the multi-timing constraint decomposition policy specifically includes:

s2-1-1: establishing a global maximum execution duration md for each task _ij And initialized to a maximum value;

s2-1-2: ordering the time sequence constraint from less to more according to the number of tasks;

s2-1-3: sequentially traversing each time sequence constraint from the time sequence constraint with a small number of tasks, calculating the relaxation time of the tasks, and updating the global maximum execution time;

s2-1-4: for each time sequence constraint, sequentially calculating task t in each time sequence constraint _ij Local cut-off time of

Wherein, sd _ij ^u For task t in the u-th timing constraint _ij Local cut-off time of (est) _ij ^u For task t in the u-th timing constraint _ij TCN represents a set of timing constraints.

Preferably, the traversing each timing constraint specifically includes:

s2-1-3-1: initializing a task set which can be counted into a local critical path into a task set contained in the timing constraint;

s2-1-3-2: generating a local critical path PCP according to a task set which can be included in the local critical path;

s2-1-3-3: decomposing the total relaxation time of the PCP into the maximum relaxation time of each task in the PCP, and obtaining the desired relaxation amount edt of each task _ij Comprises the following steps:

where tst is the current total slack time, dur _ij Is task t _ij Length of relaxation of dur _ij Is at an initial value of t _ij Shortest execution time on all resources; USet is a set of tasks in PCP whose execution time can be further relaxed, eft _ij Is task t _ij Lft _ij Is task t _ij The latest end time of (d);

updating per-task slack duration dur _ij Comprises the following steps:

wherein md is _ij Is a task t obtained under the comprehensive consideration of other timing constraints _ij The global maximum execution duration of;

distributing the total slack time to the slackable tasks in the local critical path according to a formula (14) and a formula (15) in sequence, and updating the total slack time and the slack time of each task;

s2-1-3-4: repeatedly executing S2-1-3-3 until the current total relaxation time is less than or equal to 0 or the relaxable task set in the local critical path is empty, and updating the task set capable of counting the local critical path into the task set capable of counting the local critical path and subtracting the local critical path from the original task set capable of counting the local critical path;

s2-1-3-5: repeatedly executing the S2-1-3-2 until the task set which can be counted in the local critical path is empty, and updating the global maximum execution time md of each task _ij ←min(dur _ij ,md _ij )。

Preferably, when it is determined that the current total slack time is less than or equal to 0 or the set of slackable tasks in the local critical path is empty, the condition that the execution time of the task can be further relaxed and must be satisfied is as follows:

the first condition is as follows: the ending time of the relaxed task must be less than the latest ending time, otherwise the subsequent task cannot be completed on time;

and a second condition: the relaxation time of a task must be less than the global maximum execution time of the task;

once the task is limited to its latest end time or global maximum execution duration, indicating that the execution time of the task cannot be further relaxed; at this time, the task is deleted from the USet, and the remaining slack time of the task is allocated to other tasks.

Preferably, the heuristic task allocation policy specifically includes:

s2-2-1: forming a candidate virtual machine set by virtual machines distributed by an immediately previous task, and sequentially calculating the execution time of the task in each virtual machine;

s2-2-2: deleting virtual machines which do not meet the local deadline of the task from the candidate virtual machine set;

if the virtual machine set meeting the local deadline is not empty, allocating the task to the virtual machine with the lowest execution cost, and finishing the calculation; if the virtual machine set meeting the local deadline is empty, executing S2-2-3;

s2-2-3: taking the currently started virtual machine set as a new candidate virtual machine set, and sequentially calculating the execution time of tasks in each virtual machine;

s2-2-4: deleting virtual machines which do not meet the local deadline of the task from the candidate virtual machine set;

if the virtual machine set meeting the local deadline is not empty, allocating the task to the virtual machine with the lowest execution cost, and finishing the calculation; if the virtual machine set meeting the local deadline is empty, executing S2-2-5;

s2-2-5: and forming a new candidate virtual machine set by the virtual machines which are not considered in the private cloud and the new virtual machine instances in the public cloud, and distributing the tasks to the virtual machines with the lowest execution cost.

Preferably, the cost optimization policy considering the charging period specifically includes:

s2-3-1: for each virtual machine to which a task is assigned, checking a billing interval for each group of adjacent tasks scheduled to that virtual machine, and once the interval is greater than the billing period, shutting down the current virtual machine and starting a new instance when the next task starts;

s2-3-2: and after all the virtual machines are checked, optimizing and calculating the calling cost of each resource according to the adjusted result to obtain the total cost of the scheduling solution.

Preferably, the optimizing and calculating the call cost of each resource according to the adjusted result to obtain the total cost of the scheduling solution specifically includes:

s2-3-2-1: and optimizing and calculating the execution cost ProcCost of each resource according to the adjusted result:

s2-3-2-1-1: initializing the execution cost ProcCost =0 of the solution, and executing S2-3-2-1-2 and S2-3-2-1-3 in sequence on each virtual machine called by the solution to obtain the updated resource execution cost ProcCost considering the charging interval;

s2-3-2-1-2: for each pair of adjacent tasks distributed to the virtual machine, judging whether the starting time of the task immediately after the task and the ending time of the task immediately before the task are more than one charging period, stopping charging after the task immediately before the task is ended, and starting a new charging interval when the task immediately after the task is started; updating a charging interval of ProcCost = ProcCost + virtual machine and a charging unit price of the virtual machine;

s2-3-2-1-3: updating ProcCost by using the cost of the last charging interval of the virtual machine, wherein ProcCost = ProcCost + the last charging interval of the virtual machine + the charging unit price of the virtual machine;

s2-3-2-2: calculating a transmission cost TrnCost and a time sequence constraint penalty cost TemPon;

s2-3-2-3: and calculating the total cost TotalCost = ProcCost + TrnCost + TemPon of the scheduling solution according to the execution cost ProcCost of each resource.

Preferably, the optimal scheme for workflow scheduling with timing constraints in a hybrid cloud is obtained by using the multi-timing constraint decomposition policy, the heuristic task allocation policy and the cost optimization policy considering the charging period, and specifically includes:

s3-1: calculating a local deadline constraint for each task using the multi-timing constraint decomposition strategy;

s3-2: in the first iteration, randomly initializing the coding value of a scheduling solution; in the subsequent iteration process, generating a coding value by using a meta-heuristic strategy;

s3-3: mapping the coding value vector to a task priority vector to obtain a scheduling sequence of the tasks;

s3-4: guiding a searching process by using the local cut-off time of the tasks calculated by the multi-timing constraint decomposition strategy, and sequentially allocating each task to a proper virtual machine by using the heuristic task allocation strategy according to the scheduling sequence of the tasks;

s3-5: judging whether time sequence constraints which take the task as a starting task exist, if so, updating local deadline time of the task related to the constraints according to the starting time of the starting task, specifically: firstly, according to the execution sequence of the service flow, the local deadline of the related task in the corresponding time sequence constraint is updated in sequence

Wherein sd _ij ^u For task t in the u-th timing constraint _ij Local cut-off time of t _ij Is any one of the tasks, est, in a time-series constraint starting with the currently scheduled task _ij ^u For task t in the u-th timing constraint _ij Earliest start time of (md) _ij As task t _ij TCN' represents a set of timing constraints starting with the currently scheduled task; next, the local deadline for the task involved is updated to

After the local deadline of the related task is completely updated, continuing to execute S3-4 to allocate a proper virtual machine for the next task; if the time sequence constraint taking the task as the starting task does not exist, re-executing S3-4 to allocate a proper virtual machine for the next task;

s3-6: after all tasks are distributed to the virtual machines, calculating the total cost of a scheduling solution based on the cost optimization strategy considering the charging period, and updating the current optimal scheduling solution;

s3-7: and repeating S3-3 to S3-6 until a preset iteration number is reached, and taking the current optimal scheduling solution as an optimal scheme of workflow scheduling with time sequence constraint in the hybrid cloud.

Preferably, the mapping the coding value vector to the task priority vector to obtain the scheduling order of the tasks specifically includes:

mapping the code value of the new scheduling solution to a priority list of tasks by using an epsilon-greedy rule, wherein the tasks with higher priorities are firstly allocated to resources;

the mapping of the code value of the new scheduling solution to the priority list of the task by using an epsilon-greedy rule specifically comprises the following steps: randomly generating a decimal between 0 and 1, and selecting a task with the highest code value from the current optional task list when the decimal is larger than a threshold epsilon; otherwise, randomly selecting the task.

Compared with the prior art, the technical scheme of the invention has the following advantages:

aiming at the problem of insufficient scheduling modeling of multi-timing-sequence constrained workflow under a mixed cloud, the flexible multi-timing-sequence constrained formalized model which is more fit with a service scene is designed; in the solution construction process, a multi-time-sequence constraint decomposition strategy is used for guiding the generation of a solution; when the optimal scheme of workflow scheduling is solved, the problem of narrow solving space caused by multi-timing-sequence constraint is optimized by using a heuristic task allocation strategy and a cost optimization strategy considering a charging period, the effectiveness and the efficiency of optimal solution generation are improved, and a scheduling solution with lower cost is formulated in complex environments such as a complex flow structure, multi-timing-sequence constraint, mixed cloud resources and the like.

Drawings

In order that the present disclosure may be more readily understood, a more particular description of the disclosure will be rendered by reference to specific embodiments thereof which are illustrated in the appended drawings

FIG. 1 is a flow chart of the present invention;

fig. 2 is a schematic diagram of cost optimization calculation considering a charging period in the present invention.

Detailed Description

The present invention is further described below in conjunction with the drawings and the embodiments so that those skilled in the art can better understand the present invention and can carry out the present invention, but the embodiments are not to be construed as limiting the present invention.

As shown in fig. 1, the invention discloses a workflow scheduling method with multiple timing constraints in a hybrid cloud environment, which comprises the following steps:

s1: establishing a formal model of a hybrid cloud multi-timing constraint workflow scheduling problem, wherein the formal model of the hybrid cloud multi-timing constraint workflow scheduling problem comprises decision variables, model constraints and a model target of the model.

the hybrid cloud is composed of a private cloud and a public cloud. Representing private clouds composed of enterprise's own resources as pc ₁ Further, a series of external public cloud resource providers are denoted as EC = { EC ₁ ,…,ec _m Therein each ec _m Representing a public cloud service provider, each cloud provider providing a virtual machine type of a different machine configuration and pricing model so that customers can use the virtual machine as needed;in the present invention, a virtual machine type is represented as a VMT _i ＝{vmt _i ¹ ,…,vmt _i ^j ,…,vmt _i ^k Vmt _i ^j Representing a jth virtual machine type provided by an ith cloud; the private cloud resources are limited, that is, the private cloud resources invoked by the workflow cannot exceed the private cloud resource limit. Unlike this, the number of virtual machines in a public cloud is unlimited.

To meet the requirements of a specific business process, defining the business process as a workflow is a common method for enterprises at present. According to the workflow model, a set of workflow sets can be formally defined as WP = { WP = ₁ ,…,wp _i ,…,wp _m Wherein each workflow is formally defined based on a Petri Net model, denoted wp _i ＝<TS _i ，P _i ，A _i >，TS _i Is a set of tasks in the ith workflow, P _i Is a state set of tasks, A _i Is a directed arc set of connected tasks;

furthermore, timing constraints are set in the workflow. In consideration of the fact that in actual business, a timing violation is often accepted to some extent when a user is under economic compensation. Therefore, the flexible time sequence constraint formalized model more fitting the practical business is designed. As shown in definition 1, in contrast to the conventional timing constraints, the user can set not only the ideal execution time limit e between tasks or data, but also its maximum deadline limit d, and a penalty compensation pa between the two.

Definition 1 (flexible timing constraints): defining a flexible timing constraint set TCN = { TCN ₁ ,…,tcn _u ,…,tcn _n Where each flexible timing constraint tcn _u ＝<swp _u ,e _u ,d _u ,pa _u >Wherein swp _u Is the u-th timing constraint sub-flow,

storing tasks and data sequences related to the u-th time sequence constraint; e.g. of the type _u Is the u-th timing constraint idealExecution time limit, d _u Is the cut-off time, pa _u Is loss compensation; if in the Dispatch plan, execution swp _u Is less than the ideal execution time e _u If so, the scheduling plan is shown to completely meet the time sequence constraint requirement; if execution swp _u Exceeds the cut-off time d _u If the scheduling plan completely violates the timing constraint, the scheduling plan is not feasible; if execution swp _u Is in the range of e _u And d _u In between, it shows that the dispatch plan partially satisfies the constraint for exceeding e _u Each time unit of (1) needs to be additionally added with a unit penalty cost pa _u 。

to formalize the problem, a decision variable x is first set _ij ^kvq For answering to which virtual machine each task is scheduled. x is a radical of a fluorine atom _ij ^kvq Is a variable from 0 to 1, if x _ij ^kvq =1 representing task t _ij Executed by a v-th type of virtual machine instance q, t of a k-th cloud provider _ij Is the jth task of the ith workflow; considering that the number of the called public cloud resources does not exceed the number of tasks in the process, the number of each type of virtual machine in the public cloud is set as the number of tasks | TS |, x _ij ^kvq The expression of (a) is:

it is noted that the virtual machines in the private cloud are known, while the virtual machines of each public cloud are unlimited. In addition, a decision variable st is set _ij And ft _ij ，st _ij Start time, ft, for answering each task call to the virtual machine _ij For answering the end time of each task call to the virtual machine.

S1-3: setting model constraints:

s1-3-1: since the task must be executed with the required input data complete and the required resources free, the start time st of the task is set _ij The constraints of (2) are:

wherein pred (t) _ij ) As task t _ij Is immediately before task (i.e. task t) _ij Set of tasks that must be completed before starting), adb (t) _ij ) As task t _ij Set of tasks currently scheduled on the scheduled resource, t _iu Represents t _ij Any one of the immediately preceding tasks of, t _hp Representing a task t _ij Any task currently scheduled on the scheduled resource, ft _iu Representing a task t _iu End time of ft _hp Representing a task t _hp The end time of (d);

further, an end time ft of calling the virtual machine per task is set _ij Equal to the start time plus the execution time, as shown in equation (3):

wherein,

representing a task t _ij Execution time under a v-th virtual machine type provided by a k-th cloud provider.

S1-3-2: the flexible timing constraints according to definition 1 result in that the cutoff time f requirement of each timing constraint must not be violated, so the timing constraint equation:

wherein,

for the u-th timing constraint subprocess swp _u The end time of (a) is set,

for the u-th timing constraint subprocess swp _u Start time of (d) _u Is the cutoff time of the u-th timing constraint, tcn _u Represents the u-th flexible timing constraint and the TCN represents a set of flexible timing constraints.

wherein zt _ij ^s Is a variable from 0 to 1 and is used for marking the task t _ij Whether or not to execute at time s; if zt _ij ^s =1 indicates task t _ij At time s.

S1-3-5: setting resource constraints for limiting the private cloud:

wherein, vcpu _v Number of CPUs vmem required for virtual machine type v representing a private cloud _v To representAmount of memory required for virtual machine type v of private cloud, C ^cpu Representing the maximum CPU number, C, of the resource pool of the private cloud ^mem Representing the maximum memory quantity of the resource pool of the private cloud; x is the number of _ij ^1vq Is a variable from 0 to 1, if x _ij ^1vq =1 representing task t _ij Executed by a v-th type of virtual machine instance q of a private cloud provider.

S1-4: setting a model target:

the goal of the model is to minimize the overall cost of execution of the workflow, taking into account the resource invocation cost and the transmission cost that would result from using cloud resources. Furthermore, there is a penalty cost when timing constraints are locally satisfied. Thus, the goal of the scheduling model consists of three components, including resource invocation cost, transmission cost, and constraint penalty cost, with the model objective being:

min TotalCost＝ProcCost+TranCost+TemPen (10)；

the formula summarizes the resource execution costs assigned to the private cloud, the tasks of the private cloud. Wherein, cr _k ^v Charging unit price for the v-th virtual machine type of the k-th cloud provider, b _k ^v For the charging period of the v-th virtual machine type of the kth cloud provider (in this embodiment, charging by hour), each item is the product of the allocated virtual machine charging unit price and the subscribed time length.

The TranCost is transmission cost, and specifically includes:

the formula summarizes the transmission cost of all tasks with dependency relationship according to the workflow structure. Wherein,

is a variable from 0 to 1, if

Indicating a task t _iu Completed by the qth instance of the v 'th VM type of the kth' cloud service provider; g _d For any task t _ij And its immediate preceding task t _iu The amount of data transmission between the first and second terminals,

as task t _iu Matched cloud service provider k' and task t _ij The matched unit transfer cost between the cloud service providers k.

TemPer is a constraint penalty cost, temPer is a flexible timing constraint according to definition 1, and part of the timing constraint allows a certain range of violations in the event of payment of default claims. Thus, summarizing the penalty for each timing constraint, the total constraint penalty cost can be derived:

By means of a multi-timing-constraint workflow scheduling formalized model under a hybrid cloud, timing requirements among any tasks or data are flexibly defined, and flexible constraint punishment is considered, so that the scheduling method is more suitable for actual business and is more flexible in scheduling.

S2: and under a formalized model of the mixed cloud multi-timing-constraint workflow scheduling problem, establishing a multi-timing-constraint decomposition strategy, a heuristic task allocation strategy and a cost optimization strategy considering a charging period.

S2-1: and establishing a multi-timing constraint decomposition strategy.

S2-1-1: establishing a global maximum execution duration md for each task _ij And initialized to a maximum value.

S2-1-2: the timing constraints are ordered from as few as many tasks.

S2-1-3: and traversing each time sequence constraint in turn from the time sequence constraint with a small number of tasks, calculating the relaxation time of the tasks, and updating the global maximum execution time.

S2-1-3-1: the set of tasks that can account for the local critical path is initialized to the set of tasks included in the timing constraint.

S2-1-3-2: generating a local critical path PCP according to a task set which can be included in the local critical path; for each timing constraint, the maximum slack time for each task in the timing constraint is calculated to update its maximum execution duration. Specifically, a local critical path PCP of a current timing constraint needs to be calculated first; the PCP is a sub-process of the timing constraint process swp, the earliest ending time of each task in swp is calculated from front to back according to a process structure, and the latest ending time of each task is calculated from back to front, so that the task sequence with the earliest ending time equal to the latest executable time forms the PCP.

wherein tst is the total current slackable duration dur _ij Is task t _ij Length of relaxation of dur _ij Is t as an initial value _ij Shortest execution time on all resources; USet is a set of tasks in PCP whose execution time can be further relaxed, eft _ij Is task t _ij Lft _ij Is task t _ij The latest end time of (c).

Updating the slack duration dur for each task _ij Comprises the following steps:

wherein md is _ij Is a task t obtained under the comprehensive consideration of other timing constraints _ij Of the global maximum execution time duration.

And (5) allocating the total slack time to the slackable tasks in the local critical path according to the formula (14) and the formula (15) in turn, and updating the total slack time and the slack time length of each task.

S2-1-3-4: and repeatedly executing the S2-1-3-3 until the current total relaxation time is less than or equal to 0 or the relaxable task set in the local critical path is empty, and updating the task set capable of counting the local critical path into the task set capable of counting the local critical path minus the task set of the local critical path.

When the current total relaxation time is less than or equal to 0 or the relaxable task set in the local critical path is judged to be empty, two conditions that the execution time of the task can be further relaxed and must be satisfied are as follows:

the first condition is as follows: as shown in equation (14), the relaxed ending time of a task must be less than its latest ending time, otherwise the subsequent task cannot be completed in time (since the task is completed at the latest ending time, it is guaranteed that the subsequent task can be completed within its shortest execution time), and condition one represents the time requirement of the current timing constraint.

And a second condition: as shown in equation (15), the slack duration of a task must be less than the global maximum execution duration of the task, and condition two represents the other timing constraint requirements recorded by the global maximum execution duration.

Once the task is limited to its latest end time or global maximum execution duration, indicating that the execution time of the task cannot be further relaxed; at this time, the task is deleted from the USet, and the remaining slack time of the task is distributed to other tasks so as to fully utilize the slack time.

S2-1-4: for each time sequence constraint, sequentially calculating task t in each time sequence constraint _ij Office ofPartial cut-off time

Wherein, sd _ij ^u For the task t in the u-th timing constraint _ij Local cut-off time of _ij ^u For task t in the u-th timing constraint _ij TCN represents a set of timing constraints.

S2-2: due to the existence of a plurality of time sequence constraints, a feasible solution space is narrow, and a good solution is not easy to find only by using a metaheuristic operator independent of a problem, so that the solution diversity is improved by using the metaheuristic operator, and the quality of the solution is improved by combining heuristic search. Establishing a heuristic task allocation strategy:

s2-2-1: and forming the virtual machines distributed by the immediately previous task into a candidate virtual machine set, and sequentially calculating the execution time of the task in each virtual machine.

S2-2-2: deleting the virtual machines which do not meet the local deadline of the task from the candidate virtual machine set, wherein the threshold value is set to be 0.3 in the embodiment;

if the virtual machine set meeting the local deadline is not empty, allocating the task to the virtual machine with the lowest execution cost, and finishing the calculation; and if the virtual machine set meeting the local deadline is empty, executing S2-2-3.

S2-2-3: and taking the currently started virtual machine set as a new candidate virtual machine set, and sequentially calculating the execution time of the task in each virtual machine.

S2-2-4: virtual machines that do not meet the local deadline for the task are deleted from the set of candidate virtual machines.

If the virtual machine set meeting the local deadline is not empty, allocating the task to the virtual machine with the lowest execution cost, and finishing the calculation; and if the virtual machine set meeting the local deadline is empty, executing S2-2-5.

S2-2-5: and forming a new candidate virtual machine set by the virtual machines which are not considered in the private cloud and the new virtual machine instances in the public cloud, and allocating tasks to the virtual machines with the lowest execution cost.

S2-3: and establishing a cost optimization strategy considering the charging period.

S2-3-1: since each virtual machine is charged on a periodic basis, it is considered how to fully utilize the charging interval. It is contemplated that if a task is assigned to a virtual machine that performs its immediate prior task, then transmission costs may be saved, and device idleness is avoided and utilization of billing intervals is facilitated. Thus, in the present invention, for each virtual machine to which a task is assigned, the billing interval for each set of adjacent tasks scheduled to that virtual machine is checked, and a new instance is invoked as soon as this interval is greater than the billing period. I.e. the current virtual machine is shut down and a new instance is started at the start of the next task to save costs.

S2-3-2: as shown in fig. 2, each resource is charged per hour in this embodiment. According to the coding result, t ₁₁ 、t ₁₂ 、t ₂₄ And t ₂₅ Are assigned to virtual machine pc1_ Small _1 (i.e. Small type number 1 virtual machine instance of private cloud provider pc 1). The results show that from t ₁₂ To t ₂₄ Is much larger than 1 hour. Thus, according to the strategy of the present invention, at t ₁₂ Close instance when completed and at t ₂₄ And a new instance is called during starting, so that the execution cost of the service flow is effectively reduced. And after all the virtual machines are checked, optimizing and calculating the calling cost of each resource according to the adjusted result to obtain the total cost of the scheduling solution.

s2-3-2-1-1: and initializing the execution cost ProcCost =0 of the solution, and executing S2-3-2-1-2 and S2-3-2-1-3 in sequence to each virtual machine called by the solution to obtain the updated resource execution cost ProcCost considering the charging interval.

S2-3-2-1-2: for each pair of adjacent tasks distributed to the virtual machine, judging whether the starting time of the task immediately after the task and the ending time of the task immediately before the task are more than one charging period, stopping charging after the task immediately before the task is ended, and starting a new charging interval when the task immediately after the task is started; update ProcCost = ProcCost + charging interval of virtual machine ×. Charging unit price of virtual machine.

S2-3-2-1-3: and updating the ProcCost by using the cost of the last charging interval of the virtual machine, wherein the ProcCost = ProcCost + the last charging interval of the virtual machine + the charging unit price of the virtual machine.

S2-3-2-2: and calculating a transmission cost TransCost and a timing constraint penalty cost TemPon according to the formula (12) to the formula (13).

Aiming at the difficulty that the solving space is narrow due to multi-time-sequence constraint, a local cutoff time constraint calculation strategy supporting the multi-time-sequence constraint is designed. On the basis, the invention not only combines the use of the meta-heuristic optimization operator to increase the diversity of the solution, but also utilizes heuristic strategies such as local cut-off time constraint, cost optimization calculation of the charging period and the like to improve the quality of the solution.

The workflow scheduling method with multi-timing constraint in the mixed cloud environment increases the diversity of solutions by using a meta-heuristic framework, and guides search by using heuristic information, thereby improving the solution quality. The optimal scheme of workflow scheduling with timing constraints in a hybrid cloud is obtained by using the multi-timing constraint decomposition strategy, the heuristic task allocation strategy and the cost optimization strategy considering the charging period, and specifically comprises the following steps:

s3-1: calculating local cut-off time constraint of each task by using the multi-time-sequence constraint decomposition strategy, and providing heuristic information for searching;

s3-2: in the first iteration, randomly initializing the coding value of a scheduling solution; and in the subsequent iteration process, generating a coding value by using a meta-heuristic strategy.

Since generating a sequence of encoded values can be regarded as a search process in a continuous space, the search process has been widely studied in meta-heuristic strategies, which may be genetic algorithms, ant colony algorithms, etc., in the present embodiment, genetic algorithms are used. The meta-heuristic strategy has strong universality and is often irrelevant to problems, so that the method generates the coding value of a new scheduling solution by using the meta-heuristic strategy in an iteration stage (namely, except the coding value of the first solution is randomly generated).

S3-3: mapping the coding value vector to a task priority vector to obtain the scheduling sequence of the tasks:

and mapping the coding value of the new scheduling solution to a priority list of the tasks by using an epsilon-greedy rule, wherein the tasks with higher priorities are firstly allocated to the resources.

The mapping of the coding value of the new scheduling solution to the priority list of the task by using an epsilon-greedy rule specifically comprises the following steps: randomly generating a decimal between 0 and 1, and selecting the task with the highest code value from the current optional task list when the randomly generated decimal is larger than a threshold epsilon (the threshold epsilon takes a value of 0.1 in the embodiment); otherwise, randomly selecting a task, thereby increasing the diversity of the solution; furthermore, only after a task is selected, its successors can be considered to ensure that each task must be less prioritized than its immediate predecessor.

S3-4: and guiding a searching process by using the local cut-off time of the tasks calculated by the multi-timing constraint decomposition strategy, and sequentially allocating each task to a proper virtual machine by using the heuristic task allocation strategy according to the scheduling sequence of the tasks.

Wherein sd _ij ^u For the task t in the u-th timing constraint _ij Local cut-off time of t _ij Starting with the currently scheduled taskAny one of the tasks in the time sequence constraint of (est) _ij ^u For task t in the u-th timing constraint _ij Earliest start time of (md) _ij As task t _ij TCN' represents a set of timing constraints starting with the currently scheduled task; next, the local deadline for the task involved is updated to

After the local deadline of the related task is completely updated, continuing to execute S3-4 to allocate a proper virtual machine for the next task; and if the timing constraint taking the task as the starting task does not exist, re-executing S3-4 to allocate a proper virtual machine for the next task.

After the priorities of the tasks are determined, the tasks are sequentially distributed to the virtual machines according to the priority order by using a heuristic task distribution strategy, and the purpose of the heuristic task distribution strategy is to distribute each task to a proper virtual machine on the basis of the minimum cost principle. When each task is allocated to a proper virtual machine by using the heuristic task allocation strategy, the satisfaction of the time sequence constraint is considered, namely the local cut-off time of the task calculated by using the multi-time sequence constraint decomposition strategy is used for guiding the search process.

S3-6: and after all tasks are distributed to the virtual machines, calculating the total cost of the scheduling solution based on the cost optimization strategy considering the charging period, and updating the current optimal scheduling solution.

S3-7: and repeating S3-2 to S3-6 until a preset iteration number is reached, and taking the current optimal scheduling solution as an optimal scheme of workflow scheduling with time sequence constraint in the hybrid cloud.

Aiming at the defects of workflow scheduling formal modeling with time sequence constraint at present, the invention provides a more universal flexible time sequence constraint formal model. The model not only considers the deadline constraint of the workflow, but also can flexibly define the time sequence requirement among any tasks or data. In addition, expected timing requirements and flexible constraint punishments within a certain range can be defined in each timing constraint, so that the method is more suitable for actual services and more flexible in scheduling. Meanwhile, in order to better meet the difficulty of narrow solution space caused by multi-time-sequence constraint, the invention particularly designs a local cut-off time constraint calculation strategy supporting multi-time-sequence constraint, thereby guiding the generation of a solution based on local cut-off time constraint information in the solution construction process. In addition, the algorithm of the invention not only combines the use of a meta-heuristic optimization operator to increase the diversity of the solution, but also utilizes heuristic strategies such as local cut-off time constraint, cost optimization calculation of the charging period and the like to improve the quality of the solution.

To further illustrate the beneficial effects of the present invention, a set of workflow generators provided by the workflow management system Pegasus is used in the present embodiment to perform simulation experiments. The generator provides five types of workflows, including Montage, cybersake, sipht, ligo, and Genome. The proposed algorithm was evaluated in this example using workflow instances with task numbers of 100, 200 and 300. Each test case is expressed as "workflow structure type _ number of tasks _ number of timing constraints", and the settings of the test cases are shown in table 1:

table 1 experimental case setup table

The inventive Method (MTWHC) was compared to two representative meta-heuristic algorithms in recent years for Workflow scheduling, direct and Non-local-variant Swarm Optimization (DNCPSO), guided Multi Genetic Algorithm (GMGA). All algorithms were run on machines with 3.6ghz Intel Core i7 and 8GB RAM, with the population size set to 50. The stop conditions were: at least 500 iterations are performed, with unmodified iterations up to 300 or total iterations up to 15000. Each algorithm was run independently 20 times for each test case, taking into account algorithm randomness. The running results are counted to evaluate the effect of each algorithm. Since the comparison algorithm cannot output a feasible solution in some of the test examples, the average cost is calculated considering only those times that a feasible solution can be output.

The effectiveness is analyzed by counting the total cost ratio, which is calculated by the formula:

total cost ratio = total cost (MTWHC)/total cost (comparison algorithm) (16);

from the formula, if the total cost ratio is less than 1, the solution obtained by the invention has lower cost, namely the solution effect is better; and the smaller the total cost ratio is, the larger the cost reduction value of the invention compared with the comparison algorithm is, namely the better the solving effect is. The analysis was performed from two sets of experiments that varied the number of tasks in the workflow and varied the number of timing constraints.

(1) Changing the number of tasks in a workflow

In this set of experiments, the number of tasks in the workflow was 100, 200, 300, respectively. The number of timing constraints is 20. Each test case is denoted "workflow Structure type _ number of tasks _ number of timing constraints". The results are shown in table 2:

TABLE 2 results table of infeasible computation times, total cost ratio for different task quantities

0/n/0 in Table 2 indicates that the GMGA fails to output a feasible solution n times in 20 runs. As can be seen from table 2, as the number of tasks increases, it becomes more complex for the algorithm to find a feasible solution that satisfies the timing constraints. For example, in the case of Ligo _200_20, the DNCPSO and MTWHC algorithms of the present invention can output a feasible solution each time, whereas 3 out of 20 times of GMGA cannot. The number of times each algorithm outputs an infeasible solution is shown in table 2.

It can be seen from table 2 that the computational cost increases as the number of tasks per workflow increases. The MTWHC algorithm of the present invention can achieve the lowest cost in different workflows with different numbers of tasks. For example, as the number of tasks in a Montage workflow increases to 100, 200, and 300, the average cost of the optimal scheduling solution provided by the algorithm of the present invention is $46.60, $120.79, and $160.77, respectively. Taking M _100 _20as an example, the algorithm of the present invention can output a better scheduling solution with an average cost of $46.60 for 20 iterations, while the average costs of the DNCPSO and GMGA algorithms are $94.15 and $76.45, respectively.

As can be seen from table 2, taking M _100 \/20 as an example, the total cost ratio of the MTWHC algorithm of the present invention to DNCPSO is 46.60/94.15=0.49, and the total cost ratio to GMGA is 46.60/76.45=0.61. The cost of the solution of the invention is 49% of the optimal solution of DNCPSO and 61% of the optimal solution of GMGA. As can be seen from table 2, the ratio of the MTWHC algorithm of the present invention to the total cost of DNCPSO and GMGA was 0.03 at the minimum and 0.87 at the maximum in all test cases. Since a total cost ratio <1 indicates that the solution solved by the algorithm herein is less costly, the above results indicate that the algorithm is superior to other algorithms for different task counts.

(2) Varying the number of timing constraints

In this set of experiments, the number of tasks in the workflow was 200. The number of timing constraints is 10, 20 and 30, respectively. The results are shown in table 3:

TABLE 3 infeasible computation times, total cost ratio results Table for different timing constraint quantities

As can be seen from table 3, the present invention can achieve the lowest total cost under different number of timing constraints in the mixed cloud, and the ratio of the total cost of the proposed MTWHC algorithm to DNCPSO and GMGA is 0.03 at the minimum and 0.81 at the maximum. The feasible region of the task becomes narrow due to timing constraints, thereby increasing the difficulty of scheduling problems. Especially as the number of timing constraints increases, the scheduling problem becomes more complex. In contrast, the present invention can use local deadline constraint computation to guide the search, thereby greatly improving the solution effect. As the number of constraints increases, it is difficult for both DNCPSO and GMGA to find a feasible solution. The invention can output feasible solutions each time, and the total cost of the obtained optimal solution is lower than that of a comparison algorithm.

As will be appreciated by one skilled in the art, embodiments of the present application may be provided as a method, system, or computer program product. Accordingly, the present application may take the form of an entirely hardware embodiment, an entirely software embodiment or an embodiment combining software and hardware aspects. Furthermore, the present application may take the form of a computer program product embodied on one or more computer-usable storage media (including, but not limited to, disk storage, CD-ROM, optical storage, and the like) having computer-usable program code embodied therein.

The present application is described with reference to flowchart illustrations and/or block diagrams of methods, apparatus (systems), and computer program products according to embodiments of the application. It will be understood that each flow and/or block of the flow diagrams and/or block diagrams, and combinations of flows and/or blocks in the flow diagrams and/or block diagrams, can be implemented by computer program instructions. These computer program instructions may be provided to a processor of a general purpose computer, special purpose computer, embedded processor, or other programmable data processing apparatus to produce a machine, such that the instructions, which execute via the processor of the computer or other programmable data processing apparatus, create means for implementing the functions specified in the flowchart flow or flows and/or block diagram block or blocks.

These computer program instructions may also be stored in a computer-readable memory that can direct a computer or other programmable data processing apparatus to function in a particular manner, such that the instructions stored in the computer-readable memory produce an article of manufacture including instruction means which implement the function specified in the flowchart flow or flows and/or block diagram block or blocks.

These computer program instructions may also be loaded onto a computer or other programmable data processing apparatus to cause a series of operational steps to be performed on the computer or other programmable apparatus to produce a computer implemented process such that the instructions which execute on the computer or other programmable apparatus provide steps for implementing the functions specified in the flowchart flow or flows and/or block diagram block or blocks.

It should be understood that the above examples are only for clarity of illustration and are not intended to limit the embodiments. Various other modifications and alterations will occur to those skilled in the art upon reading the foregoing description. And are neither required nor exhaustive of all embodiments. And obvious variations or modifications of the invention may be made without departing from the spirit or scope of the invention.

Claims

1. A workflow scheduling method with multi-timing constraint in a hybrid cloud environment is characterized by comprising the following steps:

s3: and obtaining the optimal scheme of workflow scheduling with timing constraints in the hybrid cloud by using the multi-timing constraint decomposition strategy, the heuristic task allocation strategy and the cost optimization strategy considering the charging period.

2. The workflow scheduling method with multiple timing constraints in a hybrid cloud environment according to claim 1, wherein: the formalized model of the mixed cloud multi-time-sequence constraint workflow scheduling problem specifically comprises the following steps:

representing private clouds as pc ₁ Public possession ofCloud resource provider as EC = { EC ₁ ,…,ec _m Therein each ec _m Representing a public cloud service provider, each cloud provider providing a virtual machine type of a different machine configuration and pricing model; representing virtual machine types as VMTs _i ＝{vmt _i ¹ ,…,vmt _i ^j ,…,vmt _i ^k Vmt _i ^j Representing a jth virtual machine type provided by an ith cloud;

the workflow set is defined as WP = { WP = { WP = ₁ ,…,wp _i ,…,wp _m Wherein each workflow is formally defined based on a Petri Net model, denoted wp _i ＝<TS _i ，P _i ，A _i >，TS _i Is the set of tasks in the ith workflow, P _i Is a state set of tasks, A _i Is a directed arc set of connection tasks;

storing tasks and data sequences related to the u-th time sequence constraint; e.g. of a cylinder _u Is the u-th timing constraint ideal execution time limit, d _u Is the cut-off time, pa _u Is loss compensation; if in the Dispatch plan, execution swp _u Is less than the ideal execution time e _u If so, the scheduling plan is shown to completely meet the time sequence constraint requirement; if swp is executed _u Exceeds the cut-off time d _u If the scheduling plan completely violates the timing constraint, the scheduling plan is not feasible; if swp is executed _u Is in the range of e _u And d _u Indicates that the dispatch plan partially satisfies the constraint for exceeding e _u Each time unit of (2) needs to be additionally added with a sheetBit penalty cost pa _u ；

setting a decision variable x _ij ^kvq For answering to which virtual machine each task is scheduled; x is the number of _ij ^kvq Is a variable from 0 to 1, if x _ij ^kvq =1 representing task t _ij Executed by a v-th type of virtual machine instance q, t of a k-th cloud provider _ij Is the jth task of the ith workflow; the number of each type of virtual machine in the public cloud is set as the task number | TS |, x _ij ^kvq The expression of (a) is:

s1-3: setting model constraints:

s1-3-1: setting a start time st of a task _ij The constraint of (2) is:

wherein pred (t) _ij ) As task t _ij The immediate predecessor task set of, adb (t) _ij ) As task t _ij Set of tasks currently scheduled on the scheduled resource, t _iu Represents t _ij Any one immediately preceding task of, t _hp Representing a task t _ij Any task currently scheduled on the scheduled resource ft _iu Representing a task t _iu End time of ft _hp Representing a task t _hp The end time of (d);

wherein,

wherein,

for the u-th timing constraint subprocess swp _u The end time of (a) is set,

for the u-th timing constraint subprocess swp _u Start time of (d) _u Is the cutoff time of the u-th timing constraint, tcn _u Representing the u flexible timing constraint, and TCN representing a flexible timing constraint set;

wherein,

is a variable from 0 to 1 and is used for marking the task t _ij Whether or not to execute at time s; if zt _ij ^s =1 indicates task t _ij At time s;

s1-3-5: setting resource constraints for limiting the private cloud:

wherein, vcpu _v Number of CPUs required for virtual machine type v representing a private cloud, vmem _v Amount of memory required for virtual machine type v representing private cloud, C ^cpu Representing the maximum CPU number, C, of the resource pool of the private cloud ^mem Representing the maximum memory quantity of the resource pool of the private cloud; x is the number of _ij ^1vq Is a variable from 0 to 1, if x _ij ^1vq =1 representing task t _ij Executing by a virtual machine instance q of a v-th type of a private cloud provider;

s1-4: setting a model target:

min TotalCost＝ProcCost+TranCost+TemPen (10)；

wherein TotalCost is the total cost of the scheduling model, procCost is the resource execution cost, and the method specifically comprises the following steps:

wherein, cr _k ^v Charging unit price for the v-th virtual machine type of the k-th cloud provider, b _k ^v A charging period for a vth virtual machine type of a kth cloud provider;

the TranCost is transmission cost, and specifically includes:

wherein,

is a variable from 0 to 1, if

TemPin is a constraint penalty cost, and the TemPin summarizes the penalty of each time sequence constraint according to the flexible time sequence constraint to obtain a total constraint penalty cost:

3. The workflow scheduling method with multiple timing constraints in a hybrid cloud environment according to claim 2, wherein: the multi-timing constraint decomposition strategy specifically comprises the following steps:

s2-1-3: sequentially traversing each time sequence constraint from the time sequence constraint with a small number of tasks, calculating the relaxation time of the tasks, and updating the global maximum execution time length of the tasks;

Wherein sd _ij ^u For task t in the u-th timing constraint _ij Local cut-off time of _ij ^u For the task t in the u-th timing constraint _ij TCN represents a set of timing constraints.

4. The workflow scheduling method with multiple timing constraints under the hybrid cloud environment according to claim 3, wherein: the traversing of each timing constraint specifically includes:

where tst is the current total slack time, dur _ij Is task t _ij Length of relaxation of dur _ij Is at an initial value of t _ij All information inA shortest execution time on the source; USet is a set of tasks in PCP whose execution time can be further relaxed, eft _ij Is task t _ij Lft _ij Is task t _ij The latest end time of (d);

updating per-task slack duration dur _ij Comprises the following steps:

5. The workflow scheduling method with multiple timing constraints in a hybrid cloud environment according to claim 4, wherein: when the current total relaxation time is less than or equal to 0 or the relaxable task set in the local critical path is judged to be empty, the condition that the execution time of the task can be further relaxed and must be met is as follows:

the first condition is as follows: the ending time of the task after relaxation is less than the latest ending time, otherwise the subsequent task cannot be completed on time;

6. The workflow scheduling method with multiple timing constraints in a hybrid cloud environment according to claim 2, wherein: the heuristic task allocation strategy specifically comprises the following steps:

7. The workflow scheduling method with multiple timing constraints in a hybrid cloud environment according to claim 2, wherein: the cost optimization strategy considering the charging period specifically comprises the following steps:

8. The workflow scheduling method with multiple timing constraints in a hybrid cloud environment according to claim 7, wherein: the optimizing and calculating the calling cost of each resource according to the adjusted result to obtain the total cost of the scheduling solution specifically comprises the following steps:

s2-3-2-3: and calculating the total cost TotalCost = ProcCost + TranCost + TemPon of the scheduling solution according to the execution cost ProcCost of each resource.

9. The workflow scheduling method with multiple timing constraints under the hybrid cloud environment according to any one of claims 2 to 8, wherein: the optimal scheme of workflow scheduling with timing constraints in a hybrid cloud is obtained by using the multi-timing constraint decomposition strategy, the heuristic task allocation strategy and the cost optimization strategy considering the charging period, and specifically comprises the following steps:

s3-5: judging whether a time sequence constraint taking the task as a starting task exists, if so, updating local deadline of the task related to the constraint according to the starting time of the starting task, specifically: firstly, according to the execution sequence of the service flow, the local deadline sd of the related task in the corresponding time sequence constraint is updated in sequence _ij ^u ←est _ij ^u +md _ij ，

Wherein sd _ij ^u For the task t in the u-th timing constraint _ij Local cut-off time of t _ij Is any one of the tasks, est, in a time-series constraint starting with the currently scheduled task _ij ^u For task t in the u-th timing constraint _ij Earliest start time of (md) _ij As task t _ij TCN' represents a set of timing constraints starting with the currently scheduled task; next, the local deadline for the task involved is updated to

After the local deadline of the related task is completely updated, S3-4 is continuously executed to allocate a proper virtual machine for the next task; if the time sequence constraint taking the task as the starting task does not exist, re-executing S3-4 to allocate a proper virtual machine for the next task;

10. The workflow scheduling method with multiple timing constraints in a hybrid cloud environment according to claim 9, wherein: the mapping of the coding value vector to the task priority vector to obtain the scheduling sequence of the task specifically comprises the following steps:

mapping the coding value of the new scheduling solution to a priority list of tasks by using an epsilon-greedy rule, wherein the tasks with higher priorities are firstly allocated to resources;

the mapping of the coding value of the new scheduling solution to the priority list of the task by using an epsilon-greedy rule specifically comprises the following steps: randomly generating a decimal between 0 and 1, and selecting a task with the highest code value from the current optional task list when the decimal is larger than a threshold epsilon; otherwise, randomly selecting the task.