Heterogeneous calculation list scheduling algorithm based on improved prediction cost matrix

Abstract

The invention belongs to the technical field of scheduling algorithms, and particularly relates to a heterogeneous computing list scheduling algorithm based on an improved prediction cost matrix. The BPPTS algorithm in the invention comprises two key stages. Firstly, in the task priority ranking stage, the average calculation cost of tasks is considered, and the calculation requirement of each task is efficiently evaluated so as to determine the ranking of task priorities. Secondly, in a processor selection stage, the algorithm considers the out-degree of each task, namely the number of subsequent tasks, optimizes the mapping relation between the tasks and the processors, reduces the waiting time of the subsequent tasks, avoids the problem that the processors are overloaded or idle due to the fact that the tasks with high calculation requirements are distributed to the low-performance processors, and improves the calculation efficiency. And the load balancing and scheduling efficiency is effectively improved.

Description

Technical Field

[0001] The invention belongs to the technical field of scheduling algorithms, and in particular relates to a heterogeneous computing list scheduling algorithm based on an improved prediction cost matrix. Background Art

[0002] In today's era of rapid development of computing technology, computationally intensive tasks are becoming more and more common in the fields of high-performance computing and scientific research, and are widely used in scientific computing, machine learning training, image and video processing, and other fields. However, such tasks involve complex computing operations and require extremely high computing power of the processor. Due to the limitations of computing resources, traditional single-type processing units are difficult to process efficiently. Therefore, heterogeneous computing architectures have been widely introduced in various scientific research and industrial applications. By utilizing the respective advantages of different types of processing units (such as CPU, GPU, FPGA, etc.) to collaboratively process complex computing tasks. Heterogeneous computing architectures can not only improve computing efficiency, but also significantly reduce energy consumption and meet the needs of various computationally intensive tasks. The introduction of heterogeneous computing systems has brought huge performance improvements, but also increased the complexity of task scheduling. Different types of processing units have different computing power, memory architecture, and communication delays, which makes the reasonable allocation of tasks particularly important. Effective task scheduling not only needs to consider the computing requirements of the tasks and the characteristics of the processing units, but also needs to optimize the execution order of tasks and resource allocation to ensure that all tasks can be completed by the appropriate processor at the right time. This goal is particularly complex and challenging in heterogeneous computing systems because it is necessary to balance the load between different processing units and maximize resource utilization. Task scheduling is a recognized NP-complete problem. Heuristic algorithms are usually used to obtain reasonable solutions within an acceptable time. List scheduling algorithm, as an effective heuristic scheduling strategy, sets priorities for tasks and then assigns each task to the most suitable processor according to preset rules. It has been widely used in heterogeneous systems. This method is simple and efficient, and can generate high-quality scheduling solutions in a short time, thereby optimizing the execution order and scheduling efficiency of tasks.

[0003] However, existing algorithms do not pay enough attention to the high execution cost of computationally intensive tasks, thus assigning these tasks to processors with lower performance, causing processor overload or idleness, which in turn leads to inefficient scheduling and unbalanced resource utilization. Currently, in heterogeneous computing environments, effective task scheduling is crucial to optimize resource utilization and improve system efficiency. Existing algorithms have certain problems, especially not paying enough attention to the computational cost of computationally intensive tasks, and failing to fully consider load balancing when selecting processors. Summary of the invention

[0004] The present invention proposes a heterogeneous computing list scheduling algorithm based on an improved prediction cost matrix, which can improve the scheduling efficiency of computing-intensive tasks in a heterogeneous computing system and solve the above-mentioned problems.

[0005] The technical solution of the present invention is achieved in this way: A heterogeneous computing list scheduling algorithm based on an improved prediction cost matrix includes a task priority stage and a processor selection stage. The task priority stage adopts an improved prediction cost matrix Representative tasks In the processor When executed, the task The maximum value of the shortest path to the exit task, including the task The average execution cost of , the BPCM matrix is ​​calculated as follows: ; Among them, when hour, , for the exit task, = ; In the processor selection phase, when the out-degree of a task exceeds the number of processors, the processor with the smallest EFT value is selected to execute the task. Otherwise, the processor is calculated. For each task value, which is and The sum of is defined as follows:

[0006] Then, select The smallest processor performs the task.

[0007] Through the above technical solution, the first formula: by considering the average execution cost of the task, the improved BPCM calculation method can optimize the task priority sorting; the second formula, by considering the processor selection strategy, to find the most suitable processor for the task; both aim to optimize the overall scheduling performance.

[0008] Optionally, during the task prioritization phase, each task is first evaluated The average BPCM value is It means that the definition is as follows: ; Where P is the number of processors, according to Sort the tasks in descending order.

[0009] Through the above technical solution, by calculating the average BPCM value, the execution cost of the task can be balanced to avoid over-reliance on the extreme performance of a certain processor. It provides a basis for subsequent task priority sorting, aiming to optimize the overall scheduling performance.

[0010] After adopting the above technical solution, the beneficial effects of the present invention are: This paper proposes a new list scheduling algorithm for heterogeneous computing systems. The algorithm introduces a prediction mechanism in the task priority and processor selection stage, aiming to balance the load by considering the average computational cost and out-degree of computationally intensive tasks. The main features include: (1) A new balanced prediction priority task scheduling algorithm (BPPTS) based on list scheduling is proposed to minimize the scheduling time of task flows. At the same time, the algorithm maintains the complexity of 𝑂(𝑣2𝑝).

[0011] (2) A new computational matrix, BPCM, is proposed. It is based on the processor execution cost and task dependencies, calculates the predicted cost of each task on different processors, and accurately evaluates the computational requirements of the task, aiming to optimize task scheduling and resource allocation.

[0012] (3) Task priority sorting based on BPCM takes into account the average computational cost of tasks and aims to optimize the scheduling efficiency of computationally intensive tasks.

[0013] (4) A new processor selection strategy is studied. The algorithm fully considers the out-degree characteristics of the task to ensure efficient utilization of processor resources and achieve optimal load balancing.

[0014] The BPPTS algorithm in the present invention includes two key stages. First, in the task priority sorting stage, the average computational cost of the task is taken into account, and the computational requirements of each task are efficiently evaluated to determine the task priority sorting. Second, in the processor selection stage, the algorithm optimizes the mapping relationship between tasks and processors by considering the out-degree of each task, that is, the number of successor tasks, reduces the waiting time of subsequent tasks, avoids processor overload or idle problems caused by assigning high computational demand tasks to low-performance processors, and effectively improves load balancing and scheduling efficiency. BRIEF DESCRIPTION OF THE DRAWINGS

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

[0016] Figure 1 is an example directed acyclic graph; Figure 2 is the computational cost matrix of the example directed acyclic graph; Figure 3 It is the result of algorithm execution; Figure 4 is the average scheduling length of the random DAG graph; Figure 5 is the average speedup of a random DAG graph; Figure 6 is the average scheduling length of random DAGs with different CCRs; Figure 7 is the average scheduling length of random DAGs with different numbers of processors; Figure 8 This is the task flow model diagram of Epigenomics; Fig. 9 This is a graph of different CCR results from Epigenomics; Fig.10 This is a graph of different isomerism results from Epigenomics; Fig.11 This is the result graph of Epigenomics with different numbers of processors; Fig.12 is a diagram of the task flow model of LIGO in the embodiment; Fig.13 This is a diagram of different CCR results from LIGO; Fig.14 This is a graph of different isomerism results from LIGO; Fig.15 This is the result graph for different numbers of LIGO processors. DETAILED DESCRIPTION

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

[0018] The embodiment of the present application discloses a heterogeneous computing list scheduling algorithm based on an improved prediction cost matrix.

[0019] Embodiment, according to Figures 1 to 15 As shown, a heterogeneous computing list scheduling algorithm based on an improved prediction cost matrix is ​​proposed.

[0020] 1. Background 1.1 Heuristic Scheduling Algorithm Heuristic scheduling algorithms are usually divided into three main types: list-based scheduling, clustering-based scheduling, and replication-based scheduling.

[0021] List scheduling algorithms usually consist of two main stages: first assigning a priority to each task in the workflow, and then selecting the processors to execute these tasks. Task priorities and processor selection are based on specific performance metrics, such as in the min-min algorithm, the task with the shortest estimated completion time is prioritized for execution on the fastest processor.

[0022] In contrast, cluster-based scheduling methods aim to group tasks that need to communicate frequently onto the same processor. Cluster-based scheduling consists of three stages: initially grouping tasks into different clusters, then merging these clusters at runtime and mapping them to a limited number of processors, and finally determining the execution order of each task within the cluster. In the reference List-scheduling versus cluster-scheduling, the authors compared list-based scheduling algorithms with cluster-based scheduling algorithms. Experimental results show that the cluster scheduling algorithm performs better when the communication-computation ratio (CCR) between tasks is high, while the list scheduling algorithm performs better when the CCR is low.

[0023] The replication-based scheduling strategy uses the processor's idle time to replicate tasks, thereby reducing the need for communication between tasks. This strategy optimizes scheduling by creating redundant copies of tasks, but its complexity is relatively high.

[0024] Through these different strategies, the heuristic scheduling algorithm can provide diverse solutions based on specific system requirements and task characteristics to optimize processor resource allocation and overall system performance.

[0025] 1.2 Scheduling Model The scheduling model consists of a program (or application), a target system, and performance metrics. Figure 1 An example of a directed acyclic graph (DAG) Indicates that V is a set of v nodes, representing an application, and E is a set of E edges. In the directed acyclic graph of task scheduling, tasks Known as The direct predecessor task, task Known as If a task has multiple direct predecessor tasks, it can only start computing after all direct predecessor tasks have completed computing and transmission. A task without a direct predecessor task is called the entry task of the DAG, and a task without a direct successor task is called the exit task of the DAG. For computationally intensive tasks, in order to ensure that the computing resources of the processor are fully utilized, this paper considers the average computing cost of tasks on different processors, and the average cost of tasks on different processors. In the processor The estimated execution time on Indicates that the task The average execution time is calculated as follows:

[0026] Represents a task dependency, establishes the execution order between tasks, and indicates that the tasks On Task Each edge is also associated with a weight. , which means that the task arrive The communication cost, i.e. the transmission data The communication cost is calculated by the following formula:

[0027] in, represents the average communication startup time of all processors, It refers to the average bandwidth of all links connecting P processors. Indicates that from the execution of tasks The processor is sent to perform the task In addition, when two tasks are assigned to the same processor, the communication cost between them is assumed to be zero, because the data transmission cost within the processor is negligible compared to the data transmission cost between processors.

[0028] The target system is assumed to consist of a set of P heterogeneous processors named Q, which adopt a fully connected topology. In this network structure, the communication between processors is assumed to be contention-free. The target system is considered heterogeneous because the execution speeds of the processors are different and the system contains various types of resources, such as CPUs and GPUs. In addition, the execution mode of tasks is assumed to be non-preemptive. Such assumptions are typical when dealing with scheduling problems.

[0029] The following are some key properties of task scheduling, which will be frequently referenced in the rest of this article.

[0030] Definition 1. In DAG, Indicates the task The set of direct predecessor tasks. ,but , that is, the entry task. In general, a DAG has a unique entry task. When there are multiple entries, a zero-cost virtual node can be created, and all entry tasks can be connected to this virtual node through zero-cost edges to form a single-entry structure without affecting the actual scheduling process.

[0031] Definition 2. In DAG, Indicates the task The set of direct successor tasks of . ,but , that is, exit the task. Similar to the entry node, if there are multiple exit nodes, a virtual exit node with zero weight and zero communication edge from the current multiple exit nodes to the virtual node can be added.

[0032] Definition 3. Indicates the task In the processor The earliest start time of the execution, which is calculated as:

[0033] in, It is the processor The earliest time to be ready, Representative tasks The required data arrives to execute the task Processor The time on which It's a task The actual completion time, that is, the time scheduled on the processor Tasks on The actual time of completion.

[0034] Definition 4. Indicates the task In the processor When executed, the task The earliest completion time is calculated as:

[0035] It is a task In the processor The earliest start time plus the task In the processor Calculate the cost.

[0036] Definition 5. The scheduling length, i.e., the overall completion time, also called makespan, is the actual completion time (AFT) of the exiting task and is defined as:

[0037] Refers to the actual completion time of the exit node. When there are multiple exit nodes and no redundant nodes are added, the completion time of the entire workflow, i.e., makespan, is the maximum value of the actual completion time of all exit tasks.

[0038] Definition 6. The out-degree of a task is the number of its direct successor tasks, for example, Figure 1 In the DAG, the task There are 5 direct successor tasks, namely .

[0039] 2. Related Work 2.1 List Scheduling Algorithm 2.1.1 HEFT algorithm The HEFT algorithm is a list scheduling algorithm with high efficiency and low time complexity. The HEFT algorithm consists of two stages. In order to calculate each task The priority of is given by formula (6). Indicates that from the task The length of the critical path to exit the task. Includes tasks The average computational cost ,in By arranging tasks in Create a priority list by sorting the values ​​in descending order. When the values ​​are the same, a random selection is performed. Secondly, the first task in the priority list, i.e. The task with the largest value is assigned to the processor with the smallest EFT value. The complexity of the HEFT algorithm is .

[0040]

[0041] 2.1.2 PEFT algorithm The main feature of the PEFT algorithm is that it can predict the impact of allocating the current task on all subsequent tasks without increasing the time complexity. The prediction mechanism is based on the "optimistic cost table (OCT)". OCT is a matrix with rows representing the number of tasks and columns representing the number of processors. Each element of the matrix Represents the selection of processors Execute the task ,Task The maximum value of the shortest paths from all successor tasks to the exit task. The OCT element is calculated as follows:

[0042] Among them, when hour, , and for all processors , PEFT algorithm uses For each task Calculate the priority as follows:

[0043] By placing the tasks In the processor selection phase, an optimistic EFT is defined, i.e. , calculated as follows:

[0044] Finally, the PEFT algorithm selects the The processor with the highest priority executes the task .

[0045] 2.1.3 PEFT algorithm The Improved Predicted Earliest Finish Time (IPEFT) algorithm is an improved version of the PEFT algorithm. The IPEFT algorithm is based on the Pessimistic Cost Table (PCT) and the Critical Node Cost Table (CNCT). Each element of the PCT Indicates the selection of processor Execute the task When, the task The maximum value of the longest path from the successor task to the exit task. Each element of CNCT Considering the task At least one neighboring node is a key node. The maximum value of the shortest path from the critical neighbor node to the exit task; otherwise, it is the maximum value of the shortest path from the task The maximum value of the shortest path from the direct successor to the exit task.

[0046] PCT and CNCT are calculated as follows:

[0047]

[0048] The IPEFT algorithm consists of two key stages. The first is to calculate the priority of the task based on the PCT matrix. In the processor selection phase, the priority of each task on a specific processor is calculated. Value, if the task The parent node of the key node is equivalent to the EFT value, that is, , otherwise it is the EFT of the task on the processor plus the communication cost CNCT, that is . IPEFT then selects the processor with the smallest EFT_CNC value to execute the current task.

[0049] 2.1.4 PPTS algorithm The characteristic of the PPTS algorithm is that it considers the relative importance of tasks, which is achieved through the prediction cost matrix (PCM). Each element in represents a task The maximum value of the shortest path to the exit task. It is defined as follows:

[0050] PPTS algorithm usage To calculate the priority of the task, according to Sort in descending order to get a priority list.

[0051]

[0052] During the processor selection phase, each task’s value, as shown in formula (14). The algorithm selects the task with the minimum processor to execute.

[0053]

[0054] 3.1.5 IPPTS algorithm The IPPTS algorithm is an improved version of the PPTS algorithm. A new strategy is added in the processor stage, namely the "upward" selection strategy, and the calculation method is shown in formula (15):

[0055] In the task priority stage, the out-degree of the task is considered. The priority calculation is as follows:

[0056] In the processor selection phase, the algorithm calculates the , as shown in formula (17). Then, the IPPTS algorithm follows The generated task priority list selects the task with the minimum processor to execute.

[0057]

[0058] 3.1.6 Limitations of existing algorithms When selecting a processor, the HEFT algorithm focuses on finding the processor with the smallest estimated completion time (EFT) for the current task. Although this method improves the execution efficiency of a single task, it does not consider the negative impact of the selection on the subsequent task, that is, the selection of the predecessor task causes the processor allocation of the subsequent task to face unfavorable communication delay problems, resulting in poor overall scheduling efficiency.

[0059] To overcome the above problems, PEFT and IPEFT algorithms introduce a calculation matrix to predict the impact of the current scheduled task on all subsequent tasks. The priority of the task is not considered In the processor The computational cost on , due to the computational cost and communication cost of the task It is an important factor to measure the relative importance of tasks. Therefore, ignoring these two factors will lead to inaccurate assessment of the relative importance of tasks. Moreover, these two factors jointly determine the urgency of tasks and their impact on the overall scheduling effect. Studies have shown that scheduling more important tasks before less important tasks can significantly shorten the scheduling time of the algorithm.

[0060] Therefore, the PPTS algorithm uses The PCM calculates the task priority of the prediction cost matrix. However, since PCM calculation tends to be more favorable to tasks and tasks In the case of running on the same processor, the predictions made tend to be local optimal solutions for dependent tasks to be executed on the same processor. This strategy can effectively reduce the communication cost between tasks. Although PPTS can obtain better scheduling results in some cases due to local savings in communication time, for computationally intensive tasks, the computing power and load of the processor are very important considerations. If multiple computationally intensive tasks are concentrated on a high-performance processor, the processor will be overloaded, thus affecting the overall execution efficiency. In the reference IPPTS: An efficient algorithm for scientific workflow scheduling in heterogeneous computing systems, the author improved the IPPTS algorithm of PPTS and considered the out-degree of the task in the priority stage, but the local optimization strategy problem of PCM was not solved.

[0061] In order to overcome the above problems, the present invention proposes a balanced prediction priority task scheduling algorithm (BPPTS). The novelty of the BPPTS algorithm is that in the task priority sorting stage, the average computing cost of the task is combined to effectively evaluate the computing requirements of each task and optimize the priority sorting; in the processor selection stage, the mapping relationship between the task and the processor is optimized in combination with the characteristics of the task out-degree to ensure that the computing resources of the processor are fully utilized to avoid the situation where some processors are overloaded while other processors are idle. In addition, the algorithm integrates a prediction mechanism in two stages to optimize the scheduling strategy, effectively improving load balancing and scheduling efficiency.

[0062] 3. BPPTS algorithm In the invention, a new list-based heterogeneous processor scheduling algorithm BPPTS is introduced. The BPPTS algorithm is divided into two stages: task priority stage and processor selection stage. First, an improved prediction cost matrix is ​​introduced and used in the task priority sorting stage.

[0063] 3.1 Improved prediction cost matrix The task priority stage of the BPPTS algorithm uses an improved prediction cost matrix Representative tasks In the processor When executed, the task The maximum value of the shortest path to the exit task, including the task The BPCM matrix is ​​calculated as follows:

[0064] Among them, when hour, For exit tasks, = .

[0065] Table 1 BPCM values ​​of example directed acyclic graphs

[0066] 3.2 Task Priority Stage In the task priority stage, each task is first calculated The average BPCM value of the task The average of the comprehensive computing costs on all processors. By calculating this average, the execution costs of tasks can be balanced to avoid over-reliance on the extreme performance of a single processor. It provides a basis for subsequent task priority sorting, aiming to optimize overall scheduling performance). It means that the definition is as follows:

[0067] Where P is the number of processors. The tasks are arranged in descending order. In addition, the present invention considers the average computational cost of the tasks in the BPCM calculation, which can average the different computational costs of the tasks on different processors and provide a more stable cost estimate, thereby improving the robustness and adaptability of the scheduling algorithm and reducing improper scheduling problems caused by estimation errors. Moreover, the introduction of the average computational cost enables the algorithm to better balance the load when facing tasks with different characteristics and requirements, reduce task waiting time and resource competition, and thus significantly improve the overall scheduling efficiency and system performance. In this way, the BPPTS algorithm can perform well in a variety of computing environments, especially in the scheduling of computationally intensive tasks, reflecting its outstanding performance advantages.

[0068] 3.3 Processor Selection Phase In the processor selection stage, the characteristics of the task out-degree are considered. If a task with more successor tasks is not executed first, it will cause the successor tasks to start late, thereby directly or indirectly extending the scheduling time. Therefore, when the out-degree of a task exceeds the number of processors, the processor with the smallest EFT value is selected to execute the task; otherwise, the processor is calculated. For each task value, which is and The sum of is defined as follows:

[0069] Then, select The smallest processor executes the task. This ensures that tasks with a large out-degree can be executed quickly, speeding up the processing speed of the entire task flow. By reasonably allocating these key tasks to suitable processors, the system can distribute the load more evenly, reduce processor idleness, and improve computing resource utilization. In the prior art, most insertion-based strategies are used to optimize task allocation by maximizing the utilization of processor idle time slots, further shortening the scheduling time. The present invention also uses this strategy.

[0070] Table 2 rankBPCM, rankPCM and rankOCT values ​​in the example directed acyclic graph

[0071] 3.4 Detailed description of the algorithm The pseudo code of the BPPTS algorithm is represented by Algorithm 1. BPPTS first calculates BPCM and (The first line) creates an empty ready list named , and put the entry task at the top of the list, from row 3 to row 13, the algorithm follows Select the task scheduling in descending order. When selecting a processor, if the out-degree is greater than the number of processors, select the processor with the smallest EFT; otherwise, select The smallest processor loops until the list is empty. The pseudo code of the algorithm is shown in Table 3: Table 3 Pseudo code of the algorithm

[0072] use Figure 1 The example directed acyclic graph in is used to illustrate the performance of the proposed BPPTS algorithm. Table 1 shows Figure 1 The BPCM elements of the directed acyclic graph are shown in Table 2. , and ,pass and The resulting priority list is divided into ( , , , , , , , , , )、( , , , , , , , , , ). Table 4 shows Figure 1 An example of using the BPPTS algorithm in a directed acyclic graph. As can be seen from Table 1, for the task Scheduled to the processor In addition to the HEFT algorithm, it is believed that the processor It's a task The best choice for . Allocating to other processors will be better than allocating to processor The computational cost is increased, which causes its non-critical successor tasks to be affected by the task In the processor selection phase of the BPPTS algorithm, the out-degree characteristics of the task are considered and the task Assign to processor This allows subsequent tasks to be executed as early as possible, effectively alleviating the delayed start of subsequent tasks, thereby directly or indirectly reducing the scheduling time. Figure 3Scheduling results for example directed acyclic graphs using the BPPTS, HEFT, PEFT, IPEFT, PPTS, and IPPTS algorithms are shown. Figure 3 Yes Figure 1 The execution results of the directed acyclic graph are given as examples and compared with other algorithms. The results show that the BPPTS algorithm of the present invention performs well.

[0073] In terms of time complexity, the computational complexity of the BPCM table of BPPTS is , the complexity of assigning tasks to processors is , the total time complexity is For dense DAG, where e is equal to v², the total complexity of the algorithm is That is, the time complexity of BPPTS is the same as that of HEFT, PEFT, IPEFT, PPTS and IPPTS algorithms.

[0074] Table 4 BPPTS algorithm usage Processor selection schedule generated by the selected processor

[0075] 4. Results and Discussion This paper evaluates the performance of the BPPTS algorithm and compares it with six related algorithms (HEFT, PEFT, IPEFT, PPTS, and IPPTS). To this end, the paper uses two types of graphs as workloads: one is a randomly generated application graph, and the other is based on tasks that simulate real-world applications. Next, the paper will first introduce the indicators used for performance comparison 4.1 Comparison indicators (1) Average scheduling length The main metric for evaluating the performance of scheduling algorithms on DAG is the schedule length (makespan). According to this metric, the algorithm with the smallest average completion time is considered the optimal algorithm. This metric also represents the performance of the algorithm in a statistical sense. During each execution, the algorithm generates a completion time value, which may be a suboptimal solution or a global optimal solution. For example, after 1000 simulation runs, each algorithm will generate 1000 different completion time values. Then, the average of these 1000 completion time values ​​is calculated. The formula is as follows:

[0076] in, is the number of runs, is the algorithm running for the i-th time (i=1,..., )’s scheduling length value.

[0077] (2) Speedup The speedup ratio is defined as the ratio of the sequential execution time (i.e., the cumulative computational cost of the task) to the parallel execution time (i.e., the completion time). The sequential execution time is obtained by assigning all tasks to a single processor and minimizing the total computational cost of the tasks. The formula is as follows: .

[0078] This comparison is presented as a global pairwise comparison of all algorithms so that the algorithms can be ranked according to their performance. The percentage of scheduling quality that is better, same, and worse than other algorithms is calculated in the experiments.

[0079] (3) Efficiency Efficiency is defined as the ratio of the speedup to the number of processors used in each run. The algorithm with the highest efficiency value is the best algorithm under this metric.

[0080] 4.2 Random DAG Generation An open source DAG generation software is used: Directed Acyclic Graph Generator. The following parameters need to be input to generate DAGs with different characteristics: : The number of compute nodes in the DAG.

[0081] : The maximum number of tasks to execute, smaller values ​​have lower task parallelism, larger values ​​have higher parallelism.

[0082] : Determines the number of task dependencies between consecutive DAG levels.

[0083] : Determines the uniformity of the distribution of tasks between different levels. A higher regularity value means that the number of tasks is evenly distributed between levels, and a lower value means that the number of tasks is unevenly distributed between levels.

[0084] : Determines the number of levels that dependencies between tasks can span.

[0085] : Communication-computation ratio. It represents the ratio of the sum of communication weights to the sum of task computation weights in the DAG.

[0086] : The percentage range of the computational cost of a task on a processor. A higher β value means that the computational cost of the same task will vary greatly on different processors of the target system; a lower β value means that the computational cost of the same task on any given processor is almost the same. Use Indicates the task In the processor The execution time on The range is expressed as:

[0087] In the random DAG experiment, the following parameters are used: =[50,100,200,300,400,500,600,700,800,900,1000]; =[0.1,0.4,0.8]; =[0.2,0.8]; =[0.2,0.8]; =[1,2,4]; =[0.1,0.5,1,5,10]; =[0.1,0.25,0.5,1,2].

[0088] These combinations generate 9900 different DAG graphs, each of which contains 25 DAGs with different weights. Therefore, the present invention uses 247500 random DAGs. A large number of task graphs are used for experiments because when the number of tasks is small, the performance of various algorithms usually behaves similarly, making it difficult to effectively compare the performance differences of different algorithms.

[0089] 4.3 Performance Analysis Figure 4 shows the average completion time (makespan), while Figure 5The average speedup of all algorithms on DAGs of random sizes is shown. The BPPTS algorithm significantly outperforms the other algorithms in terms of average completion time. Specifically, for a DAG with 50 tasks, the average completion time of the BPPTS algorithm is 11.5%, 13.13%, 14.3%, 15.1%, and 15.8% higher than that of the IPPTS, PPTS, IPEFT, PEFT, and HEFT algorithms, respectively. For 500 tasks, the average completion time of the BPPTS algorithm is 2.94%, 3.4%, 6.0%, 5.4%, and 9.1% higher than that of the IPPTS, PPTS, IPEFT, PEFT, and HEFT algorithms, respectively. Finally, for 1000 tasks, the average completion time of the BPPTS algorithm is 3.1% and 3.6% higher than that of the IPPTS and PPTS algorithms, respectively. In terms of average speedup, the BPPTS algorithm again performs well on DAGs with 50 to 800 tasks. The BPPTS algorithm considers the average computational cost of tasks in the task priority stage, which enables the algorithm to more accurately evaluate the execution time of each task on different processors. This ensures that computationally intensive tasks are prioritized on the most appropriate processor, reducing their waiting time and resource competition, and significantly improves the scheduling efficiency and load balancing of computationally intensive tasks compared to other algorithms. Figure 4 The DAG graph generation tool is used to generate DAG graphs containing different numbers of tasks for algorithm testing. The results show that the algorithm BPPTS of the present invention performs well under the DAG graph test containing 50-1000 tasks. Figure 5 , Speedup is an indicator to measure the algorithm. Figure 4 ,The results of tests on different numbers of tasks show that the algorithm BPPTS of the present invention performs well ,under the DAG graph test containing 50-1000 tasks.

[0090] The average completion time generated by the algorithm is a function of CCR as follows Figure 6 As shown. When CCR <1, the BPPTS algorithm shows the best scheduling effect. When the CCR value is greater than 1, the performance of the BPPTS algorithm is improved compared with other algorithms. For example, when the CCR values ​​are 0.1 and 0.5 respectively, the BPPTS algorithm is 10.6% and 13.7% higher than the IPPTS algorithm, 7.2% and 12.6% higher than the PPTS algorithm, 5.8% and 4.7% higher than the IPEFT algorithm, 6.8% and 5.9% higher than the PEFT algorithm, and 7.6% and 8.6% higher than the HEFT algorithm. Figure 7 The efficiency results of different algorithms under different numbers of processors are shown. The BPPTS algorithm proposed in this invention performs the best. In addition, it can be seen that as the number of processors increases, the efficiency of each algorithm decreases, because the size of the DAG is fixed. Figure 6In the figure, the CCR value on the horizontal axis represents the communication-computation ratio. Different CCRs represent different computation and communication weights. It can be seen that no matter what the CCR value is, the algorithm performs well. Figure 7 ,The DAG graph is tested under different numbers of processors. It can be seen that no matter how many processors there are, the algorithm BPPTS of the present invention has good efficiency.

[0091] Finally, Table 5 shows the percentage of each algorithm in producing better, same, and worse scheduling length results. Compared with IPPTS, PPTS, IPEFT, PEFT, and HEFT, the BPPTS algorithm achieved better scheduling results in 63%, 64%, 67%, 65%, and 66% of the runs, achieved similar scheduling results in 1%, 1%, 2%, 1%, and 0% of the runs, and produced worse scheduling results in 36%, 35%, 31%, 34%, and 34% of the runs. From the comprehensive results, BPPTS outperformed other algorithms in 65% of the cases, performed the same in 1% of the cases, and performed worse in 34% of the cases, with the best performance overall. The order of the number of occurrences of the best results of the algorithms is {BPPTS, IPPTS, PPTS, PEFT, IPEFT, HEFT}.

[0092] The BPPTS algorithm is the best among all algorithms, especially for compute-intensive tasks, because it comprehensively considers the average execution cost of tasks on different processors at the priority stage and the processor stage, and can better measure the relative importance of tasks, optimize the execution order of tasks and the allocation of processors to produce better scheduling results.

[0093] Table 5 Comparison of pairwise scheduling lengths of scheduling algorithms

[0094] 4.4 Real Application In addition to the random DAG experiments, the present invention also evaluates two real-world application workflows: Epigenomics and Ligo [. Scientific applications include a series of processing stages that involve extremely complex heavy calculations and have implicit dependencies. Therefore, these applications can be represented as workflows and are therefore called scientific workflows. The Epigenomics and Ligo used are computationally intensive workflows. The DAGs of these two applications have certain parallelism and complexity, and the number of tasks can be flexibly defined. Therefore, these two workflows are used to evaluate the performance of the algorithm in real applications. The same values ​​of CCR, heterogeneity, and number of processors given in 4.2 are used to test the performance of the proposed scheduling algorithm.

[0095] 4.4.1 Epigenomics The Epigenomics Workflow is used by the Epigenomics Center for DNA processing. It is a computationally intensive and primarily data-parallel pipeline application. The workflow is structured as Figure 8 As shown. For the epigenomic workflow, the present invention considers graphs with 24, 46 and 100 tasks. Table 6 shows the average completion time (makespan) of the algorithms under different numbers of tasks, among which our BPPTS algorithm performs best. Fig. 9 The average completion time under different computation communication ratios (CCR) is shown. When CCR=0.1, the average completion time of the BPPTS algorithm is 12.9% higher than that of the PPTS algorithm; when CCR=0.5, the average completion time of the BPPTS algorithm is 10.5% higher than that of the PPTS algorithm. This is because when the CCR is low, the BPPTS algorithm performs better when performing computationally intensive tasks. Fig.10 The average completion time under different heterogeneity levels is shown. Fig.11 The average completion time under different numbers of processors is shown. The BPPTS algorithm shows better results regardless of the change in heterogeneity or the number of processors. This is because the BPPTS algorithm comprehensively considers the average computational cost of tasks in the task priority stage, allowing the algorithm to more accurately evaluate the execution time of each task on different processors. This ensures that computationally intensive tasks are prioritized to the most appropriate processor, reducing their waiting time and resource competition. Fig. 9 Different CCR experiments were conducted using the DAG graph of the Epigenomics example. The CCR value on the horizontal axis represents the communication-computation ratio. Different CCRs represent different computation and communication weights. It can be seen that no matter what the CCR value is, the algorithm performs well. Fig.10 Experiments with different heterogeneity levels using the DAG graph of the Epigenomics example. Lower heterogeneity levels indicate greater differences between processors, and 1 indicates a homogeneous system. Fig.11 Experiments with different numbers of processors were conducted using the DAG graph of the Epigenomics example. The DAG graph was tested with different numbers of processors. It can be seen that no matter how many processors there are, the algorithm BPPTS of the present invention has good efficiency.

[0096] Table 6 Average scheduling length of epigenomics workflow algorithms

[0097] 4.4.2 LIGO LIGO is an analytical workflow for detecting gravitational waves generated by cosmic events. The workflow is computationally intensive and its architecture supports highly parallel processing. Fig.12As shown, for this process, the present invention considers graphs containing 30, 50 and 100 tasks. Table 7 shows the average completion time (makespan) of the algorithms under different numbers of tasks, among which the BPPTS algorithm performs best. Fig.13 The average completion time under different computation communication ratios (CCR) is shown. When CCR=0.1, the average completion time of the BPPTS algorithm is improved by 10.6% compared with the PPTS algorithm; when CCR=0.5, the BPPTS algorithm is improved by 9.8% compared with the PPTS algorithm. This is because the BPPTS algorithm performs better in executing computationally intensive tasks, so it produces better scheduling results when the CCR is lower. Fig.14 and Fig.15 The average completion time under different heterogeneity and different numbers of processors is shown respectively. Regardless of the change in heterogeneity or the number of processors, the BPPTS algorithm shows better results. This is because the BPPTS algorithm can handle complex task dependencies and processor characteristics, and can effectively manage resource allocation for compute-intensive tasks in a heterogeneous computing environment. Therefore, in complex applications such as LIGO, the BPPTS algorithm performs better. Fig.13 Different CCR experiments were conducted using the DAG graph of the example Ligo. The CCR value on the horizontal axis represents the communication-computation ratio. Different CCRs represent different computation and communication weights. It can be seen that no matter what the CCR value is, the algorithm performs well. Fig.14 Experiments with different heterogeneity levels using the DAG graph of the example Ligo. The lower the heterogeneity, the greater the difference between the processors, and 1 represents a homogeneous system. Fig.15 The DAG graph of the example Ligo is used to conduct experiments with different numbers of processors. The DAG graph is tested with different numbers of processors. It can be seen that no matter how many processors there are, the algorithm BPPTS of the present invention has the best efficiency.

[0098] Table 7 Average scheduling length of the LIGO workflow algorithm

[0099] This paper proposes a scheduling algorithm specifically for computationally intensive tasks, the BPPTS algorithm, which aims to optimize processor resource utilization and improve scheduling efficiency. The BPPTS algorithm introduces innovative processing strategies in two key stages. First, BPCM sorts all tasks in the workflow according to priority, and then assigns them to the most suitable processor according to a well-defined processor selection strategy. The effectiveness of the BPPTS algorithm is verified by experiments using randomly generated task graphs and well-known scientific workflow graphs (such as Epigenomics and Ligo). Experimental results show that the BPPTS algorithm is significantly superior to related algorithms in terms of average completion time, speedup, average slack, frequency of best results, and efficiency, and effectively improves the scheduling efficiency and system performance of computationally intensive tasks. A potential area for further research is to consider incorporating other key performance indicators (such as resource utilization, task waiting time, etc.) into the optimization objectives and develop a multi-objective optimization version of the BPPTS algorithm to meet the needs of different application scenarios.

[0100] The above are only preferred embodiments of the present invention and are not intended to limit the present invention. Any modifications, equivalent substitutions, improvements, etc. made within the spirit and principles of the present invention should be included in the protection scope of the present invention.

Claims

1. A heterogeneous computing list scheduling algorithm based on an improved prediction cost matrix, characterized in that: It includes the task priority stage and the processor selection stage, in which the task priority stage adopts an improved prediction cost matrix Representative tasks In the processor When executed, the task The maximum value of the shortest path to the exit task, including the task The average execution cost of , the BPCM matrix is ​​calculated as follows: ； Among them, when hour, , for the exit task, = ; In the processor selection phase, when the out-degree of a task exceeds the number of processors, the processor with the smallest EFT value is selected to execute the task. Otherwise, the processor is calculated. For each task value, which is and The sum of is defined as follows: ； Then, select The smallest processor performs the task.

2. The heterogeneous computing list scheduling algorithm based on the improved prediction cost matrix according to claim 1 is characterized in that: In the task priority stage, each task is first calculated The average BPCM value is It means that the definition is as follows: ； Where P is the number of processors, according to Sort the tasks in descending order.

Images