CN112306642A

CN112306642A - Workflow scheduling method based on stable matching game theory

Info

Publication number: CN112306642A
Application number: CN202011329163.6A
Authority: CN
Inventors: 贾兆红; 潘磊; 唐俊
Original assignee: Anhui University
Current assignee: Anhui University
Priority date: 2020-11-24
Filing date: 2020-11-24
Publication date: 2021-02-02
Anticipated expiration: 2040-11-24
Also published as: CN112306642B

Abstract

The invention provides a workflow scheduling method based on a stable matching game theory, which comprises the following steps: step A: DAG graph of input workflow, virtual machine pool V ═ { VM₀,VM₁,…,VM_m‑1And CCR values; and B: calculating the rank value of each task, and selecting the task with the maximum rank value in each layer to be added into the CP; and C: allocating tasks to the virtual machines based on a stable matching game theory to obtain a scheduling scheme; step D: and optimizing a scheduling scheme, traversing all tasks, and copying a precursor node which leads the start time of the current task to a virtual machine where the current task is located. The invention has the advantages that: two local optimization strategies based on the key path and the task replication effectively reduce the maximum completion time of the workflow, comprehensively consider the task fairness problem and improve the customer satisfaction.

Description

Workflow scheduling method based on stable matching game theory

Technical Field

The invention relates to the technical field of workflow scheduling, in particular to a workflow scheduling method based on a stable matching game theory.

Background

Cloud computing provides a new resource delivery and service provision model that can provide a wide variety of computing and resource services such as servers, storage capacity, cpus, etc., as well as e-commerce, social networking, etc., application services running over the entire network. In order to take advantage of the resource advantages of the cloud computing service mode, greatly save investment cost and get rid of the limitation of the resource by region and time, any work task can be executed in the cloud computing environment, such as a widely researched workflow task. A workflow is a series of interrelated, automatically executed business activities or tasks. We refer to workflows placed in a cloud computing environment as cloud workflows. Tasks in scientific applications like high energy physics, gravitational wave, geography, bioinformatics, astronomy and the like are based on centralized control, and strong interdependent relationships exist among data. Because the requirement of Quality of Service (QoS) of a user needs to be met to the greatest extent in a cloud computing environment, the significance of researching a workflow task scheduling algorithm in the cloud environment is significant. The selection of the workflow task scheduling strategy has important influence on the efficiency and performance of cloud computing, and improper scheduling strategies not only cause resource waste but also cannot meet the requirements of users on QoS, so that cloud resource providers and cloud service users cannot achieve the targets of the cloud resource providers and the cloud service users.

Currently, most cloud workflow scheduling algorithms focus on the common goal of minimizing the total cost or maximum completion time of the entire workflow. However, in reality, for example, in workflows such as video monitoring, object tracking, face recognition, etc., each subtask has its own target, such as minimum response time or fastest processing speed, etc. For some scheduling algorithms, if the current optimal resources (such as maximum bandwidth, fastest processing speed, etc.) are always allocated to tasks according to priorities, a workflow scheduling method based on workflow throughput maximization disclosed in the invention patent with publication number CN103838627A, and a workflow scheduling method, a multi-workflow scheduling method and a system thereof disclosed in the invention patent with publication number CN103914754A all complete the scheduling of workflows based on priorities, and paying more attention to the processing order of multiple workflows, part of tasks may not meet the requirements of clients, thereby resulting in unfair allocation. Unfair allocation of resources can result in significant reduction in satisfaction of some task objectives, thereby affecting customer satisfaction with cloud services. Therefore, while the global target of the workflow is considered, the fairness among the tasks in the workflow is also considered. How to minimize the completion time of the workflow is of great significance on the premise of ensuring the task fairness.

Game Theory (GT) mainly studies strategic interaction among rational decision makers, and is widely applied to various fields such as logics and system science. In consideration of the reliability of balanced tasks, Yang and the like provide a task scheduling algorithm based on a cooperative game model, so that the efficiency is ensured, and the complexity of the algorithm is reduced. In order to solve the task scheduling problem in grid computing, Gao and the like regard the grid load balancing problem as a non-cooperative game model and provide a grid cost minimization algorithm based on GT. Experimental results show that the game-based algorithm has better capability of solving the task scheduling problem. Wang et al propose a multi-objective workflow scheduling algorithm based on a dynamic game model to minimize the maximum completion time and the total cost and maximize the system fairness of workload distribution among heterogeneous cloud virtual machines. Sujana et al define the multi-objective workflow scheduling problem as a dual-objective sequence cooperative game model that minimizes execution time and economic cost under two constraints. Although GT has certain advantages in solving the workflow scheduling problem, in the existing research, there are still few researches considering the task fairness problem, and the effect and processing speed of the existing algorithm still cannot meet the requirements of all users.

Disclosure of Invention

The technical problem to be solved by the invention is to provide a method for dispatching the workflow based on the stable matching game theory in the GT model, so as to solve the problem that the prior art does not consider task fairness and simultaneously minimize the completion time of the workflow.

The invention solves the technical problems through the following technical scheme: a workflow scheduling method based on a stable matching game theory comprises the following steps:

step A: the DAG graph of the input workflow is expressed as DAG ═ (T, E), T ═ T₀,t₁,...,t_n-1Representing n task sets in the workflow, and E representing a dependency relationship set among the n tasks; if it is not

Then the delegate is only at task t_iExecuteCompletes and passes the data to t_jUpper time, task t_jCan be executed; task t_jIs task t_iSuccessor node of (1), task t_iIs task t_jThe predecessor node of (1);

virtual machine pool V ═ { VM ═ VM₀,VM₁,...,VM_m-1Represents a set of m virtual machines;

and CCR values;

and B: calculating the rank value of each task, and selecting the task with the maximum rank value in each layer to be added into the CP;

and C: allocating tasks to the virtual machines based on a stable matching game theory to obtain a scheduling scheme;

step D: and optimizing a scheduling scheme, traversing all tasks, and copying a precursor node which leads the start time of the current task to a virtual machine where the current task is located.

The scheduling scheme is optimized based on the stable matching game theory and the task starting time, the problem that the task fairness is not considered in the prior art is solved, and the overall completion time of the workflow can be minimized.

Preferably, the task rank value calculating method in step B is:

wherein succ (t)_i) As task t_iSet of successor nodes of, t_exitAn egress task without a successor node;

representing a task t_iThe average calculation time of (a) is,

representing a task t_iAnd task t_jAverage contact time of;

wherein s is_iRepresenting a task t_iSize of p_kRepresenting virtual machines VM_kProcessing capacity of, ET (t)_i,VM_k) Representing a task t_iIn a virtual machine VM_kCalculated time of (TT)_ijRepresents a predecessor node t_iTo successor node t_jTransmitted data size, BVM_k,VM_lRepresenting virtual machines VM_kTo virtual machine VM_lBandwidth of the transmitted data, task t_jIn a virtual machine VM_lWhen p is k, BVM_k,VM_l＝0，T_tran(t_i,t_j)＝0。

Preferably, the DAG layering method in step B is:

wherein, t_iLevel represents the task t_iLayer of, pre (t)_i) Representing a task t_iSet of predecessor nodes of, t_entryIndicating that there is no predecessor node's ingress task.

Preferably, the method for allocating tasks in step C comprises the following steps:

step i: let l equal to 0;

step ii: if it is not

Go to step x, otherwise add the task at layer l to the set task (l) { t }_i|t_iLevel ═ l };

step iii: acquiring the key task t of the l layer_x,t_xE (task (l) # CP) at each virtual machine VM_kThe completion time of the processing is sequenced from morning to evening according to the completion time to obtain the task t_xPreference queue taskpference (x);

step iv: the key task t of the l layer_xVirtual machine VM assigned to earliest completion time_kUp, update task t_xAnd a start processing time ST, an execution time ET, and a completion time FT of the task t_xDeleted from set task (l);

step v: if it is not

Making l ═ l +1, and returning to the step ii; otherwise, let j equal to 0, go to step vi;

step vi: acquiring 1 st task task.get (0) in the set task (l), and generating a preference queue task preference (0) of the task task.get (0);

step vii: calculating the j virtual machine VM in the preference queue taskPreference (0)_uIf u.waiting.size < threshold (u, l), assign task task.get (0) to virtual machine VM_uGet (0) and delete task from set task (l); if u.waiting.size is threshold (u, l), execute step viii, where u.waiting.size is virtual machine VM_uA number of tasks waiting to be performed;

step viii: for each task in set task (l), based on VM in virtual machine_uGet the virtual machine VM from the morning to the evening_uPreference queue VM for layer I task_uReference (l) for obtaining task in virtual machine VM (0)_uPreference queue VM of_uLocation p in preference (l), find virtual machine VM_uThe upper preference value is maximum and is at any position of the l layerTask b, acquiring the preference queue VM of the task b_uReference (l), wherein all tasks on the virtual machine are numbered as preference values in sequence from 0 to u.waiting.size-1 in processing order;

step ix: if p is less than q, replacing the task b with the task (0), updating ST, ET and FT of the task (0), deleting the task (0) from the set task (l), adding the task b into the task (l), and returning to the step v; otherwise, let j ═ j +1, return to step vii;

step x: and outputting the scheduling scheme S.

Preferably, task t_iIn a virtual machine VM_kThe time ST and the completion time FT of the upper start processing are respectively

FT(t_i,VM_k)＝ST(t_i,VM_k)+ET(t_i,VM_k)。

Preferably, the virtual machine VM_kThe threshold value is calculated by

Wherein n is_vIndicating the number of tasks at level v.

Preferably, the method for optimizing the scheduling scheme in step D comprises:

step 1: let k equal to 0;

step 2: if k is less than or equal to m-1, acquiring the virtual machine VM_kWait queue VM_kWaiting for the first task t, otherwise, jumping to step 7;

and step 3: if the start time ST (t, VM) of the task t_k) Making k equal to k +1, and returning to the step 2; otherwise, let p be 0, minST ═ infinity, minpredcesor ═ minST, go to step 4;

and 4, step 4: if p ≦ pre (t) 1, copy task p to virtual machine VM_kIn the above, the start time ST 'of the task t at this time is calculated (ST')t,VM_k) Go to step 5, otherwise go to step 6;

and 5: if ST' (t, VM)_k) If minST is less than minST, let minST be ST' (t, VM)_k) If p is p +1, returning to step 4, otherwise, returning to step 4;

step 6: if minST < ST (t, VM)_k) Copying task minPredepcessor to virtual machine VM_kIf not, making k equal to k +1 and returning to the step 2;

and 7: and outputting the optimized scheduling method S'.

The invention also provides a workflow scheduling system based on the stable matching game theory, which comprises the following components:

an input module: the DAG graph of the input workflow is expressed as DAG ═ (T, E), T ═ T₀,t₁,...,t_n-1Representing n task sets in the workflow, and E representing a dependency relationship set among the n tasks; if it is not

Then the delegate is only at task t_iExecution completes and passes data to t_jUpper time, task t_jCan be executed; task t_jIs task t_iSuccessor node of (1), task t_iIs task t_jThe predecessor node of (1);

and CCR values;

the key path extraction module: calculating the rank value of each task, and selecting the task with the maximum rank value in each layer to be added into the CP;

a scheduling module: allocating tasks to the virtual machines based on a stable matching game theory to obtain a scheduling scheme;

an optimization module: and optimizing a scheduling scheme, traversing all tasks, and copying a precursor node which leads the start time of the current task to a virtual machine where the current task is located.

The invention also provides an electronic processing device, which comprises at least one processor and a storage device for storing at least one executive program, wherein when the at least one executive program is executed by the at least one processor, the at least one processor realizes the workflow scheduling method.

The invention also provides a computer readable storage medium storing a computer program which, when executed by a processor, is capable of implementing the workflow scheduling method.

The workflow scheduling method based on the stable matching game theory has the advantages that: two local optimization strategies based on the key path and the task replication effectively reduce the maximum completion time of the workflow, comprehensively consider the task fairness problem and improve the customer satisfaction.

Drawings

FIG. 1 is a DAG diagram of a CyberShake workflow provided by an embodiment of the present invention;

FIG. 2 is a DAG diagram of a workflow used in a comparative experiment provided by an embodiment of the present invention;

FIG. 3 is a schematic diagram comparing SLRs in CCR and small-scale workflow provided by embodiments of the present invention;

FIG. 4 is a comparative schematic of SLR in CCR and Medium Scale workflow provided by an embodiment of the present invention;

FIG. 5 is a schematic diagram comparing SLR in CCR and large-scale workflow provided by embodiments of the present invention;

FIG. 6 is a comparative schematic of AVU in CCR and small scale workflow provided by embodiments of the present invention;

FIG. 7 is a comparative schematic of AVU in a CCR and Medium Scale workflow as provided by an embodiment of the present invention;

FIG. 8 is a comparative schematic of AVU in a CCR and Medium Scale workflow as provided by an embodiment of the present invention;

FIG. 9 is a diagram illustrating SLR comparison among different VM numbers and large-scale workflows according to an embodiment of the present invention;

FIG. 10 is a comparative illustration of AVU in different VM numbers and large-scale workflows as provided by an embodiment of the invention;

fig. 11 is a diagram illustrating comparison of VF provided by an embodiment of the present invention in different large-scale workflows.

Detailed Description

To make the objects, technical solutions and advantages of the present invention more apparent, the technical solutions of the present invention are described below in detail and completely with reference to the accompanying drawings, and it is apparent that the described embodiments are some, but not all embodiments of the present invention. All other embodiments, which can be derived by a person skilled in the art from the embodiments given herein without making any creative effort, shall fall within the protection scope of the present invention.

First, we introduce workflow models, one usually using a Directed Acyclic Graph (DAG) representation, denoted DAG ═ T, E with a bigram. Wherein T ═ { T ═ T₀,t₁,...,t_n-1And E represents a dependency relationship set among the n tasks. If it is not

Then it represents task t_iAnd task t_jDependencies exist, only at task t_iExecution completes and passes data to t_jUpper time, task t_jCan be executed; and weigh task t_jIs task t_iSuccessor node of (1), task t_iIs task t_jThe predecessor node of (1). Task t_iIs denoted as pre (t) and the predecessor and successor node sets of_i) And succ (t)_i). A task without predecessor nodes is called an ingress task t_entryTasks without successor nodes are called egress tasks t_exit. There may be multiple ingress or egress tasks in a DAG, and the amount of data transferred between tasks may be represented by a TT matrix:

wherein TT_i,jRepresenting a task t_iTo task t_jThe amount of data transferred. TT when there is no dependency between tasks_i,j＝0。

Suppose a cloud model exists in a Virtual Machine (VM) pool formed by m VMs, and the VM pool is represented by a set as V ═ VM₀,VM₁,...,VM_m-1}. The processing capacity of each virtual machine is different and independent, the bandwidth between different virtual machines is represented by a matrix B, and B is not necessarily a symmetric matrix. That is, B VM_k,VM_lNot necessarily equal to B VM_l,VM_k. When k is l, B VM_k,VM_l0. Task t_iTo task t_jThe time for transmitting data can be calculated by the data transmission quantity between the virtual machines and the bandwidth between the virtual machines, and the specific steps are as follows:

wherein VM_kAnd VM_lAre respectively task t_iAnd task t_jThe virtual machine is located. When two tasks are executed on the same virtual machine, the data transmission time between the two tasks can be ignored, namely T_tran(t_i,t_j)＝0。

Task t_iIn VM_kStart time of ST (t)_i,VM_k) Can be calculated from the following formula:

task t_iIn VM_kExecution time on ET (t)_i,VM_k) Can be calculated by

Wherein s is_iRepresenting a task t_iSize of p_kRepresenting a VM_kThe processing power of (1).

Task t_iIn VM_kCompletion time FT (t) of_i,VM_k) Can be calculated by

FT(t_i,VM_k)＝ST(t_i,VM_k)+ET(t_i,VM_k)

The optimization objectives for this embodiment are as follows:

the completion time makespan of the workflow is the maximum completion time in all exit tasks, and is also the final time for all virtual machines to complete all tasks, and can be calculated by the following formula.

makespan＝max{MS(VM_k)},0≤k＜m

Wherein MS (VM)_k) Representing a VM_kThe time to complete all tasks.

The quality of the solution obtained by the algorithm is evaluated by using three indexes, namely a Scheduling Length Ratio (SLR), an average virtual machine resource utilization rate (AVU) and a fairness Variance (VF), and a calculation formula is shown as follows.

1) And (7) SLR. To avoid parameter differences, resulting in excessive differences in makespan, it is necessary to normalize makespan to a lower bound. Therefore, the embodiment normalizes the makespan obtained by the algorithm according to the following formula.

Where | CP | represents the length of the critical path, it can be seen that the smaller SLR, the shorter the completion time of the workflow.

2) AVU are provided. This index is used to evaluate the average resource utilization of all virtual machines, i.e. the ratio of the busy time of the virtual machine to makespan, as shown in the following formula.

Where waiting is VM_kI.e. the queue of tasks to be executed.

3) And VF. This index is to evaluate the fairness gap between tasks. The satisfaction value S of each task is calculated by the following formula i.e. the ratio of the actual execution time AET of the task to the desired execution time EET,

the EFT is the execution time of the task on the virtual machine with the fastest execution capacity. The larger the S, the higher the satisfaction of the task. The variance of all tasks is then calculated, where M is the average of all task satisfaction. The smaller the VF, the better the algorithm can balance fairness between tasks.

Based on the above model, the embodiment provides a workflow scheduling method based on stable matching game interest rate, which includes the following steps:

and a CCR value, wherein CCR is an empirical value representing the ratio of the average computation time to the average contact time of the workflow, the value of CCR determining whether the type of workflow is computation intensive or data intensive; the determination may be made based on the experience of a worker, or a test.

And B: calculating the rank value of each task, and selecting the task with the maximum rank value in each layer to be added into the CP; the method for calculating the rank value comprises the following steps:

representing a task t_iThe average calculation time of (a) is,

representing a task t_iAnd task t_jAverage contact time of;

wherein s is_iRepresenting a task t_iSize of p_kRepresenting virtual machines VM_kProcessing capacity of, ET (t)_i,VM_k) Representing a task t_iIn a virtual machine VM_kOnCalculating time, TT_ijRepresents a predecessor node t_iTo successor node t_jTransmitted data size, BVM_k,VM_lRepresenting virtual machines VM_kTo virtual machine VM_lBandwidth of the transmitted data, task t_jIn a virtual machine VM_lThe upper process, when p is k, B VM_k,VM_l＝0，T_tran(t_i,t_j)＝0。

The DAG layering method comprises the following steps:

And C: allocating tasks to the virtual machines based on a stable matching game theory to obtain a scheduling scheme; the method specifically comprises the following steps:

step i: let l equal to 0;

step ii: if it is not

wherein, the task t_iIn a virtual machine VM_kThe completion time FT of (c) is:

FT(t_i,VM_k)＝ST(t_i,VM_k)+ET(t_i,VM_k)

ST(t_i,VM_k) As task t_iIn a virtual machine VM_kThe time to start the process;

step v: if it is not

virtual machine VM_kThe threshold value calculating method comprises the following steps:

wherein n is_vIndicating the number of tasks of the v-th layer; the threshold value can balance the load of the virtual machines, excessive tasks are prevented from being distributed to the same virtual machine, and one threshold value is set for each virtual machine according to the number of tasks on the current layer and the processing capacity of the virtual machine, so that the virtual machine with strong processing capacity can execute more tasks.

Step viii: for each task in the set task (l)Service based on VM in virtual machine_uGet the virtual machine VM from the morning to the evening_uPreference queue VM for layer I task_uReference (l) for obtaining task in virtual machine VM (0)_uPreference queue VM of_uLocation p in preference (l), find virtual machine VM_uAcquiring the task b with the largest upper preference value and at the l-th layer, namely b.level ═ l, in the preference queue VM_uReference (l), wherein all tasks on the virtual machine are numbered as preference values in sequence from 0 to u.waiting.size-1 in processing order;

step x: and outputting the scheduling scheme S.

Step D: optimizing a scheduling scheme, traversing all tasks, and copying a precursor node which leads the start time of the current task to a virtual machine where the current task is located;

in the scheduling of the workflow, it is possible that the current task is not executed on the same virtual machine as its predecessor node, and the current task needs to be executed, and the predecessor node must wait for the data to be transmitted to its virtual machine. Therefore, the appropriate predecessor node is selected to be copied to the virtual machine of the task, so that the data transmission time between tasks can be reduced, and the start time of the current task is advanced.

Based on the above principle, the principle of the optimization performed by the present embodiment is as follows:

1) task t_iCan only be copied to the virtual machine where the subsequent node is located.

2) Task t_iCopying to a certain virtual machine cannot increase the completion time of other tasks on the virtual machine.

The method specifically comprises the following steps:

step 1: let k equal to 0;

step 2: if k is less than or equal to m-1, acquiring the virtual machine VM_kWait queue VM_k.wThe first task t in the accessing, otherwise, jumping to step 7;

and 4, step 4: if p ≦ pre (t) 1, copy task p to virtual machine VM_kIn the above, the start time ST' (t, VM) of the task t at this time is calculated_k) Go to step 5, otherwise go to step 6;

and 7: and outputting the optimized scheduling method S'.

The workflow scheduling method is described below by using the example of the cybersake workflow shown in fig. 1, the cybersake workflow includes 30 tasks and 52 edges, and the sizes of the tasks and the calculated rank values are shown in table 1:

table 1: task size and rank value of CyberShake workflow

The data transfer matrix TT between tasks is calculated according to:

TT(t_i,t_j)＝s_i×CCR

in this embodiment, CCR is 0.4, and the computing capacities of 5 virtual machines are 5,8,7,9, and 6; the bandwidth B between the virtual machines is shown in Table 2:

	VM₀	VM₁	VM₂	VM₃	VM₄
						VM₀	0	7	8	9	6
VM ₁	5	0	8	7	5
						VM ₂	7	6	0	8	4
VM ₃	7	8	6	0	5
						VM ₄	9	7	6	4	0

table 2: bandwidth between virtual machines of cybersheke workflow

As can be seen from Table 1, the key path of the CyberShake workflow is { t }₂,t₅,t₆,t₀Explaining by taking task allocation of a first layer and a second layer as an example;

	VM.preference	VM.threshold
			VM

	₀	2,13	1
VM ₁				2,13	1
	VM ₂	2,13	1
VM ₃				2,13	1
	VM ₄	2,13	1

table 3: preference queue for cybersheke workflow first tier virtual machines

And in the first layer, the preference queue of the virtual machine is obtained according to the completion time of the task on the virtual machine. But since the first layer task has no predecessor nodes, the start time of all tasks is 0, and all virtually generated preference queues are the same considering only the task completion time. For the first distributed critical path task, the priority is distributed to the virtual with the highest processing speed, so that the preference queue does not need to be calculated. At task t₂After the allocation is completed, the task t is calculated₁₃The queue of available preferences for elapsed time on each virtual machine is shown in Table 4; then task t₁₃Is assigned to a virtual machine VM₁The above.

Unassigned task	Task	Task.preference	VM	VM.waiting	Task.ST	Task.FT
							2,13	2	2	2	0	5.11
13	13	2,3,5,1,4	1	13	0	5.25

Table 4: preference queue for cybersheke workflow first layer tasks

Because the second layer of tasks have precursor nodes and the completion time sequence of the tasks on different virtual machines is different, the preference queues of the virtual machines are different, and firstly, the critical path task t is processed₅Assigned to the VM that made it finish earliest₃And sequentially distributing each task in sequence. When assigning task t₂₂Due to the current VM₃Is full, by comparing task t₂₂And VM₃Task(s) above, task(s) t with lower preference value₉Removed and redistributed.

	VM.preference	VM.threshold
			VM










₀		22,16,14,26,18,20,11,24,7,5,3,9,28	3
	VM ₁			11,7,5,3,9,22,14,16,26,18,20,24,28	4
VM ₂		11,22,7,16,14,5,3,26,18,20,9,24,28	3
	VM ₃			22,16,14,26,18,20,24,11,7,5,3,9,28	4
VM ₄		22,16,14,11,26,7,18,5,20,3,24,9,28	3

Table 5: preference queue of cybersheke workflow second-tier virtual machine

Table 6: preference queue for cybersheke workflow second layer tasks

In this way, the scheduling result of the workflow scheduling method provided by this embodiment to the DAG can be obtained, as shown in table 7, where "+" and "-" respectively represent idle time of the virtual machine and execution time of the task; in addition, the task of replication is shown in bold.

Table 7: gantt chart of cybersheke workflow

The embodiment also aims at the four reference workflow structures of cybersheke, Epigenomics, LIGO and Montage shown in fig. 2 to compare the workflow scheduling method (SM-CPTD) provided by the embodiment with the existing TDA, GSS, NMMWS and Min-Min algorithms, where TDA is an algorithm for minimizing the total completion time of a workflow based on task replication and task grouping. GSS minimizes completion time and maximizes virtual machine average resource utilization based on task granularity in the workflow. The NMMWS calculates the dynamic threshold of the task through a minimum-maximum normalization method so as to ensure the maximum completion time of each workflow and the utilization rate of cloud resources. Min-Min is a commonly used workflow scheduling algorithm, generally considered to be one of the most efficient scheduling algorithms for benchmarking, and may directly reflect the performance of different algorithms. The time complexity of the four algorithms is respectively: o (n)³)，O(n²m)，O(n³ml) andO(n²m). While the time complexity of our proposed SM-CPTD algorithm is O (n)²l), similar to Min-Min. In addition, in order to verify the two local optimization strategies proposed in the present application, the most primitive stable matching algorithm is also referred to as a comparison algorithm and is referred to as SM.

The parameters and their value ranges used in the present application are shown in table 8. The task size, the processing speed of the virtual machines, and the bandwidth between the virtual machines are all randomly generated according to a uniform distribution. Each example was run 10 times with an average. All algorithms are implemented on Eclipse by using java language programming, and the running environment is Intel core i7-9750H CPU @2.60GHz, 8GB RAM and Microsoft Windows 10Professional 64-bit operating system.

Table 8: parameters and values

In order to study the influence of the CCR and the number m of virtual machines on the algorithm, the number of virtual machines of the small, medium and large workflows is respectively set to 5, 10 and 50 when the influence of the CCR on the algorithm is considered. Similarly, when considering the effect of m on the algorithm, the value of CCR is set to 1. Meanwhile, in order to study the fairness of different algorithms to different workflows, CCR is set to 1, and m is set to 50.

As is clear from FIGS. 3-5, as CCR increases from 0.4 to 2, the data transfer time between tasks increases, causing the SLR values of all algorithms to increase, and thus the completion time of the workflow to increase. However, in the case of workflows of different sizes, the SM-CPTD can obtain the minimum SLR compared with the other four comparison algorithms, i.e., the SM-CPTD can obtain the minimum workflow completion time. In addition, GSS performs similarly to NMMWS and in most cases both algorithms and Min-Min outperform TDA. Furthermore, from the results of SM-CPTD and SM, two local optimization strategies can effectively reduce the completion time of a workflow, especially for data intensive workflows.

In TDA, in order to reduce the transmission time between tasks, a large number of tasks need to be duplicated, resulting in data redundancy and extra execution time for the tasks. Thus, it performs better in data-intensive workflows than in compute-intensive workflows. The performance of an NMMWS depends on the size of the task and the processing power of the virtual machine. However, NMMWS has poor performance in the case of small-scale workflows, since it is difficult to obtain good batch processing results.

As can be seen from FIGS. 6-8, as the CCR value is increased, the task needs to wait for a longer time to transmit data, so that the AVU values of all algorithms are decreased. Furthermore, unlike the results of SLR, TDA works best at AVU because the large number of replication tasks in TDA take full advantage of the virtual machine's idle time, increasing the virtual machine's utilization. While SM-CPTD is inferior to TDA in AVU, it is superior to GSS, NMMWS and Min-Min. Compared with SM, similar to TDA, SM-CPTD utilizes the idle time of the virtual machine, and improves the resource utilization rate of the virtual machine.

As can be seen from FIGS. 9-10, for large workflows, SM-CPTD can get the smallest SLR regardless of the number of virtual machines. In addition, as the number of virtual machines increases, the parallel processing capacity of the virtual machines increases, and although the completion time of the workflow is reduced, the utilization rate of the virtual machines is also reduced. In addition, while SM-CPTD performed less than TDA at AVU, it outperformed GSS, NMMWS and Min-Min on all the example groups.

In addition, it can be seen from fig. 11 that the VF of the SM is the smallest among the different large-scale workflows. Meaning that the stable matching algorithm can effectively balance the fairness of each task compared to the other four. However, the addition of two local optimization strategies affects the fairness of partial tasks, thus leading the VF value of SM-CPTD to be slightly larger than SM.

In summary, the performance of the algorithm SM-CPTD proposed in this embodiment is better than that of all other algorithms. In addition, two local optimization strategies based on critical path and task replication effectively reduce the maximum completion time of the workflow. In addition, when CCR is 1, the average operating time ranges of SM-CPTD are 10ms to 20ms, 30ms to 40ms, 1200ms to 1400ms for four different configurations of small, medium and large-scale workflows, respectively. Therefore, the SM-CPTD has better distribution efficiency and can be applied to an online workflow scheduling scene.

This embodiment also provides a workflow dispatch system based on stably match game theory, includes:

and CCR values;

The present embodiment also provides an electronic processing device, including at least one processor and a storage device storing at least one execution program, where when the at least one execution program is executed by the at least one processor, the at least one processor implements the following method:

step A: the DAG graph of the input workflow is expressed as DAG ═ (T, E), T ═ T₀,t₁,...,t_n-1Represents the workThe method comprises the steps that n task sets in a flow, and E represents a dependency relationship set among the n tasks; if it is not

and CCR values;

The present embodiments also provide a computer-readable storage medium storing a computer program which, when executed by a processor, is capable of implementing the method of:

and CCR values;

The above examples are only intended to illustrate the technical solution of the present invention, but not to limit it; although the present invention has been described in detail with reference to the foregoing embodiments, it will be understood by those of ordinary skill in the art that: the technical solutions described in the foregoing embodiments may still be modified, or some technical features may be equivalently replaced; and such modifications or substitutions do not depart from the spirit and scope of the corresponding technical solutions of the embodiments of the present invention.

Claims

1. A workflow scheduling method based on a stable matching game theory is characterized by comprising the following steps: the method comprises the following steps:

and CCR values;

2. The workflow scheduling method based on the stable matching game theory as claimed in claim 1, wherein: the task rank value calculating method in the step B comprises the following steps:

representing a task t_iThe average calculation time of (a) is,

representing a task t_iAnd task t_jAverage contact time of;

wherein s is_iRepresenting a task t_iSize of p_kRepresenting virtual machines VM_kProcessing capacity of, ET (t)_i,VM_k) Representing a task t_iIn a virtual machine VM_kCalculated time of (TT)_ijRepresents a predecessor node t_iTo successor node t_jData size of transfer, BVM_k,VM_lRepresenting virtual machines VM_kTo virtual machine VM_lBandwidth of the transmitted data, task t_jIn a virtual machine VM_lThe upper process, when p is k, B VM_k,VM_l＝0，T_tran(t_i,t_j)＝0。

3. The workflow scheduling method based on the stable matching game theory as claimed in claim 2, wherein: the DAG layering method in the step B comprises the following steps:

wherein, t_iLevel denotes the layer at which the task is located, pre (t)_i) Representing a task t_iSet of predecessor nodes of, t_entryIndicating that there is no predecessor node's ingress task.

4. The workflow scheduling method based on the stable matching game theory as claimed in claim 3, wherein: the method for distributing tasks in the step C comprises the following steps:

step i: let l equal to 0;

step ii: if it is not

step v: if it is not

step viii: for each task in set task (l), based on VM in virtual machine_uGet the virtual machine VM from the morning to the evening_uPreference queue VM for layer I task_uReference (l) for obtaining task in virtual machine VM (0)_uPreference queue VM of_uLocation p in preference (l), find virtual machine VM_uAcquiring a task b with the maximum upper preference value and positioned at the l-th layer in a preference queue VM_uPreference(l), wherein all tasks on the virtual machine are numbered in sequence from 0 to u.waiting.size-1 as preference values in processing order;

step x: and outputting the scheduling scheme S.

5. The workflow scheduling method based on the stable matching game theory as claimed in claim 4, wherein: task t_iIn a virtual machine VM_kThe time ST and the completion time FT of the upper start processing are respectively

FT(t_i,VM_k)＝ST(t_i,VM_k)+ET(t_i,VM_k)。

6. The workflow scheduling method based on the stable matching game theory as claimed in claim 5, wherein: virtual machine VM_kThe threshold value is calculated by

Wherein n is_vIndicating the number of tasks at level v.

7. The workflow scheduling method based on the stable matching game theory as claimed in claim 6, wherein: the method for optimizing the scheduling scheme in the step D comprises the following steps:

step 1: let k equal to 0;

step 2: if k is less than or equal to m-1, acquiring the virtual machine VM_kWait queue VM_k.waThe first task t in iting, otherwise, jumping to the step 7;

and 7: and outputting the optimized scheduling method S'.

8. The utility model provides a workflow dispatch system based on stable matching game theory which characterized in that: the method comprises the following steps:

and CCR values;

9. An electronic processing device, characterized by: comprising at least one processor and a storage device having at least one executable program stored thereon, the at least one processor implementing the method according to any one of claims 1-7 when the at least one executable program is executed by the at least one processor.

10. A computer-readable storage medium storing a computer program, characterized in that: the computer program is capable of implementing the method of any one of claims 1-7 when executed by a processor.