An edge-computing-oriented start time-aware dependent task scheduling method

Abstract

This invention relates to the field of edge computing technology and discloses a startup-time-aware dependency task scheduling method for edge computing. The method includes edge devices, edge servers, and cloud servers, with the devices and servers connected via a network. It also includes an application, which consists of multiple interdependent computing tasks forming a task graph. The scheduling method includes the following steps: (1) setting task priorities; (2) selecting an edge server; (3) deploying task cloud clones; and (4) refining task scheduling. This startup-time-aware dependency task scheduling method for edge computing comprehensively considers factors such as task startup time, inter-task dependencies, and the heterogeneity of edge and cloud servers in addressing the scheduling problem of edge tasks. It optimizes the total latency of dependent tasks through four steps: setting task priorities, selecting edge servers, deploying task cloud clones, and refining task scheduling.

Description

Technical Field

[0001] This invention relates to the field of edge computing technology, specifically to a startup-aware dependency task scheduling method for edge computing. Background Technology

[0002] Compared to cloud servers, edge computing brings processing power to the network edge. In edge computing, mobile users can offload applications to edge servers closer to them to take advantage of more abundant computing resources and lower latency. To reduce overall latency, increase throughput, or minimize costs, mobile applications can be further divided into multiple interdependent tasks. Each task can be offloaded to a different edge or cloud server. However, before executing a task on the edge server, the corresponding runtime environment needs to be initialized in advance, a process called task startup. This increases task latency and affects the quality of user experience. Task startup includes two parts: downloading the runtime environment (such as container images, software packages, and functional code) from the cloud (if it does not exist) and preparing the runtime environment (i.e., starting the container and importing the package). The size of the runtime environment can range from tens of MB to several GB. Due to the limited memory and storage capacity of edge servers, and the increasing number of task types, it is impossible to store or initialize the runtime environment required for all tasks. Therefore, on-demand task startup is unavoidable and will lead to significant latency, especially in edge computing where download bandwidth is limited.

[0003] Most current research on task scheduling ignores task startup time or adds a constant startup time. Only a few studies have roughly considered task startup when making task scheduling decisions, but they assume that multiple tasks can be started simultaneously on a single edge server without affecting each other. At the same time, the startup time of each task is the same on different edge servers, which is also unrealistic. Since the size of a task's runtime environment can be as large as hundreds of MB, the download of the environment for multiple tasks on the same edge server must take into account the problem of limited bandwidth sharing, which will lead to additional latency. In addition, the heterogeneous bandwidth scenario common in edge computing will lead to different environment download times.

[0004] Considering the heterogeneous startup delay, edge dependency task scheduling faces the following new challenges: (1) how to comprehensively model the dependency task scheduling and task startup process; (2) how to reasonably coordinate task startup, task execution, and dependency data transmission in heterogeneous edge computing; and (3) how to effectively utilize the powerful cloud initialization runtime environment while avoiding long transmission times and further reducing the total latency.

[0005] To overcome the aforementioned challenges, we designed a startup-time-aware dependency task scheduling method for edge computing. First, we modeled the startup process of multiple tasks on a bandwidth-limited edge server, proposing a dependency task scheduling problem with startup latency in heterogeneous edge computing. Then, we determined the scheduling urgency of tasks based on the size of the runtime environment and the longest path of the subtasks, optimizing the task completion time on the edge server by overlapping startup times, related data transmission times, and task execution times. Finally, we deployed a cloud clone for each task to mitigate the impact of startup latency and utilize powerful cloud resources. This task clone adaptively decides whether to receive input data from the edge server or the cloud server. Furthermore, to further free up computing resources occupied by unused task executions, we designed task scheduling refinement, which removes tasks that do not contribute to latency reduction during scheduling. After scheduling, it tightens the schedule by utilizing the freed resources to reduce overall latency. Summary of the Invention

[0006] (a) Technical problems to be solved

[0007] To address the shortcomings of existing technologies, this invention provides a startup-aware dependency task scheduling method for edge computing. This method has advantages such as considering task startup time and optimizing the total latency of dependency tasks in resource-constrained edge computing, thus solving the problem of difficulty in optimizing the total latency of dependency tasks in edge computing.

[0008] (II) Technical Solution

[0009] To achieve the goal of optimizing the total latency of dependent tasks by considering task startup time in resource-constrained edge computing, the present invention provides the following technical solution: a startup time-aware dependent task scheduling method for edge computing, including edge devices, edge servers and cloud servers, wherein the devices and servers are connected through a network, and also includes an application, which consists of multiple interdependent computing tasks forming a task graph.

[0010] The scheduling method includes the following steps:

[0011] (1) Set task priority. Task priority is calculated based on the size of the task's runtime environment and the workload of its descendant tasks. Then, the ready task with the highest priority is selected and scheduled in sequence. The specific formula for calculating task priority is: ,in This represents the average download time for the task environment. The longest path among the descendant tasks of the destination task. It can be recursively defined as: ,in and ;

[0012] (2) Select edge servers, taking into account factors such as task startup, dependent data transmission, and task execution, and schedule each task to the edge server with the earliest completion time. For the current task, greedily search for the earliest time interval that meets the following conditions on each edge server: First, the start of the time interval must meet the task's dependency; second, the number of tasks running at any point in the time interval does not exceed the capacity of the edge server; and finally, the start of the time interval must meet the condition that the task's running environment has been started.

[0013] (3) Deploy task cloud clones. Although task replication can avoid long-term communication, it also brings additional computing and download overhead in the edge network. Deploy a clone in the cloud for each non-virtual task to benefit from the powerful cloud resources, while also avoiding task startup. The start-up time of the task clone in the cloud is: ;

[0014] (4) Refine task scheduling. After each task is scheduled, tasks that do not contribute to reducing the overall latency are effectively identified as redundant tasks and deleted. After all task scheduling decisions have been made, the start time and environment download completion time of the scheduled tasks are recalculated to further improve scheduling. After making the changes, redundant tasks that do not contribute to the minimum manufacturing period can be effectively identified and removed, thereby freeing up resources occupied on the edge servers. The tasks retained in the process are named valid tasks. A valid task must have at least one valid successor task that helps minimize manufacturing time; otherwise, it is redundant. Recursively, for each valid task, there must exist a successor task from it to... Virtual End Task The path, therefore, It is possible to reach The set of nodes is retained as valid tasks, while other tasks are identified as redundant and removed from the list. The removal of redundant tasks creates new idle time intervals for task execution and environment downloads on the edge servers. These idle time intervals can be used to tighten the schedule, thereby reducing overall latency. This is achieved by advancing the environment download completion time and task start time without changing other variables, such as the runtime environment download order, the edge server resources used by the tasks, or the selected edge server.

[0015] Preferably, the edge server: the set of all edge servers in the edge computing network is represented as follows To model the heterogeneous processing capabilities of edge servers, an uncorrelated machine model is used, where the execution time of each task on each server is machine-dependent, and each edge server... With limited computing resources, it can execute simultaneously. A function, the link connecting the edge servers has heterogeneous bandwidth, two edge servers and The bandwidth between them is defined as the delay per unit of data transmission. Specifically, Data transfer time on the same edge server is negligible, that is... .

[0016] Preferably, the cloud server is denoted as: , With unlimited computing resources, it can execute an unlimited number of tasks simultaneously. The cloud has already initialized the runtime environment for all tasks. The unit data transmission latency of the edge cloud link, denoted as dc, is much longer than the unit data transmission latency between two edge servers. Transmission time within the cloud is negligible. It is also assumed to be zero.

[0017] Preferably, the application: the application is represented as a and is powered by a mobile device. The deployment and application structure can be described using a directed acyclic graph (DAG), named the task graph. ,in This represents the set of nodes for a task. The set of directed edges representing the dependencies between tasks, where the execution time of each task is represented in the execution time matrix. Defined in, where each element Designated task On the server The execution time on the directed edge allows for task replication, meaning a task can be executed on multiple servers to reduce overall latency. Specify from task To the mission Some data transfer is required. If the task and tasks Stored on servers and server The data transmission time is as follows: For each edge ,Task Defined as a task Ex, mission Defined as a task The successor, on the edge server Execute the task Previously, the task should have been started. The task start time mainly consists of two parts: environment download time. ,in It is an edge server Download bandwidth, It is a task Environment size, environment preparation time This includes data decompression time and package import time, which depend on the task and server. The environment download time and environment preparation time for each task in the cloud are both zero. Two virtual nodes with zero execution time and zero startup time are inserted into the task graph. A virtual source task is inserted at the beginning to trigger the application, and a virtual sink task is inserted at the end to receive all the execution results. The total number of tasks in application 'a' becomes... Then, the task graph G is relabeled through topological sorting, after insertion and sorting. and Both will be updated; the source task and the sink task are represented as follows: and All must be released on mobile devices. Execute on top, for a task ,from Remittance task Tasks along the path are called its descendant tasks, from the source task. arrive The task on the path is called its ancestor task.

[0018] Preferably, the progress tightening process is as follows:

[0019] a. Calculate the download completion time for each task based on the download order on each edge server;

[0020] b. Sort the tasks on the edge servers according to dependency constraints;

[0021] The process of calculating the start time of these ordered tasks incurs additional computational overhead, so it is only run once after the entire application has been scheduled.

[0022] Preferably, the scheduling objective is to optimize the entire application, i.e., the end time of the final task that receives the running results, and the constraints are: task constraints for each server to process in parallel at the same time, dependency constraints between tasks, constraints to prevent task interruption, and bandwidth limitations on task running environment downloads.

[0023] (III) Beneficial Effects

[0024] Compared with existing technologies, this invention provides a startup-time-aware dependency task scheduling method for edge computing, which has the following advantages:

[0025] 1. This startup-aware dependency task scheduling method for edge computing comprehensively considers factors such as task startup time, inter-task dependencies, and heterogeneity between edge and cloud servers when addressing the scheduling problem of edge tasks.

[0026] 2. This startup-time-aware dependency task scheduling method for edge computing optimizes the total latency of dependency tasks through four steps: setting task priority, selecting edge servers, deploying task cloud clones, and refining task scheduling.

[0027] 3. This startup-time-aware dependency task scheduling method for edge computing quickly identifies and deletes redundant tasks by refining task scheduling, thereby optimizing the total latency of dependency tasks while saving computing resources.

[0028] 4. This startup-time-aware dependency task scheduling method for edge computing has been extensively tested on real datasets and can effectively reduce the total latency for different types of tasks. It can be applied to various heterogeneous edge computing environments. Attached Figure Description

[0029] Figure 1 This is an example diagram of the system model of the present invention;

[0030] Figure 2 This is a schematic diagram of the algorithm flow of the present invention;

[0031] Figure 3 This is a schematic diagram of the method for deleting redundant tasks according to the present invention;

[0032] Figure 4 This is an example of a task diagram, execution schedule, and unit data transmission schedule for the present invention;

[0033] Figure 5 This is a schematic diagram showing the results of the SDTS algorithm, GenDoc algorithm, and HEFT algorithm of the present invention;

[0034] Figure 6 This is a schematic diagram of the key parameters of the simulation of the present invention;

[0035] Figure 7 This is a schematic diagram illustrating the probability density distribution of the total delay for all scheduling algorithms in this invention.

[0036] Figure 8 This is a schematic diagram showing the pairwise comparison results between the scheduling algorithms of this invention;

[0037] Figure 9 This is a schematic diagram comparing the algorithms of the present invention under different conditions. Detailed Implementation

[0038] The technical solutions of the present invention will be clearly and completely described below with reference to the embodiments of the present invention. Obviously, the described embodiments are only some embodiments of the present invention, and not all embodiments. Based on the embodiments of the present invention, all other embodiments obtained by those skilled in the art without creative effort are within the scope of protection of the present invention.

[0039] Please see Figure 1-5 A startup-time-aware dependency task scheduling method for edge computing includes edge devices, edge servers, and cloud servers. The devices and servers are connected via a network. The method also includes an application, which consists of multiple interdependent computing tasks forming a task graph.

[0040] The scheduling method includes the following steps:

[0041] (1) Set task priority. Task priority is calculated based on the size of the task's runtime environment and the workload of its descendant tasks. Then, the ready task with the highest priority is selected and scheduled in sequence. The specific formula for calculating task priority is: ,in This represents the average download time for the task environment. The longest path among the descendant tasks of the destination task. It can be recursively defined as: ,in and ;

[0042] (2) Select edge servers, taking into account factors such as task startup, dependent data transmission, and task execution, and schedule each task to the edge server with the earliest completion time. For the current task, greedily search for the earliest time interval that meets the following conditions on each edge server: First, the start of the time interval must meet the task's dependency; second, the number of tasks running at any point in the time interval does not exceed the capacity of the edge server; and finally, the start of the time interval must meet the condition that the task's running environment has been started.

[0043] (3) Deploying task cloud clones: While task replication avoids prolonged communication, it also introduces additional computational and download overhead in the edge network. Deploying a cloud clone for each non-virtual task allows for the benefit of powerful cloud resources and avoids the need for task startup. The start-up time of the task clone in the cloud is: ;

[0044] (4) Refine task scheduling. After each task is scheduled, tasks that do not contribute to reducing the overall latency are effectively identified as redundant tasks and deleted. After all task scheduling decisions have been made, the start time and environment download completion time of the scheduled tasks are recalculated to further improve scheduling. After making the changes, redundant tasks that do not contribute to the minimum manufacturing period can be effectively identified and removed, thereby freeing up resources occupied on the edge servers. The tasks retained in the process are named valid tasks. A valid task must have at least one valid successor task that helps minimize manufacturing time; otherwise, it is redundant. Recursively, for each valid task, there must exist a successor task from it to... Virtual End Task The path, therefore, It is possible to reach The set of nodes is retained as valid tasks, while other tasks are identified as redundant and removed from the list. The removal of redundant tasks creates new idle time intervals for task execution and environment downloads on the edge servers. These idle time intervals can be used to tighten the schedule, thereby reducing overall latency. This is achieved by advancing the environment download completion time and task start time without changing other variables, namely the runtime environment download order, the edge server resources used by tasks, or the selected edge server. The schedule tightening process is as follows:

[0045] a. Calculate the download completion time for each task based on the download order on each edge server;

[0046] b. Sort the tasks on the edge servers according to dependency constraints;

[0047] The process of calculating the start time of these ordered tasks incurs additional computational overhead, so it is only run once after the entire application has been scheduled.

[0048] Wherein, edge servers: the set of all edge servers in the edge computing network is represented as... To model the heterogeneous processing capabilities of edge servers, an uncorrelated machine model is used, where the execution time of each task on each server is machine-dependent, and each edge server... With limited computing resources, it can execute simultaneously. A function, the link connecting the edge servers has heterogeneous bandwidth, two edge servers and The bandwidth between them is defined as the delay per unit of data transmission. Specifically, Data transfer time on the same edge server is negligible, that is... .

[0049] Meanwhile, cloud servers: denoted as , With unlimited computing resources, it can execute an unlimited number of tasks simultaneously. The cloud has already initialized the runtime environment for all tasks. The unit data transmission latency of the edge cloud link, denoted as dc, is much longer than the unit data transmission latency between two edge servers. Transmission time within the cloud is negligible. It is also assumed to be zero.

[0050] Additionally, the application: This application is represented as 'a' and is used by the mobile device. The deployment and application structure can be described using a directed acyclic graph (DAG), named the task graph. ,in This represents the set of nodes for a task. The set of directed edges representing the dependencies between tasks, where the execution time of each task is represented in the execution time matrix. Defined in, where each element Designated task On the server The execution time on the directed edge allows for task replication, meaning a task can be executed on multiple servers to reduce overall latency. Specify from task To the mission Some data transfer is required. If the task and tasks Stored on servers and server The data transmission time is as follows: For each edge ,Task Defined as a task Ex, mission Defined as a task The successor, on the edge server Execute the task Previously, the task should have been started. The task start time mainly consists of two parts: environment download time. ,in It is an edge server Download bandwidth, It is a task Environment size, environment preparation time This includes data decompression time and package import time, which depend on the task and server. The environment download time and environment preparation time for each task in the cloud are both zero. Two virtual nodes with zero execution time and zero startup time are inserted into the task graph. A virtual source task is inserted at the beginning to trigger the application, and a virtual sink task is inserted at the end to receive all the execution results. The total number of tasks in application 'a' becomes... Then, the task graph G is relabeled through topological sorting, after insertion and sorting. and Both will be updated; the source task and the sink task are represented as follows: and All must be released on mobile devices. Execute on top, for a task ,from Remittance task Tasks along the path are called its descendant tasks, from the source task. arrive Tasks on a path are called its ancestor tasks. The scheduling goal is to optimize the entire application, i.e., the end time of the final task that receives the running results. The constraints are: tasks that each server processes in parallel at the same time, dependencies between tasks, prohibition of interrupting tasks, and bandwidth limitations on task execution environment downloads.

[0051] It should be noted that, Figure 1 The application on the right is published by the mobile device, and the tasks it depends on are scheduled to different servers (including edge and cloud servers). Edge servers and the cloud can communicate with each other through a fully connected network. There is an environment download process before the task is executed on the edge server. The download process is executed sequentially. The computing resources on the edge server are limited, so it can execute a limited number of tasks at the same time. In the cloud, all the necessary environments have been initialized, and the computing resources are unlimited.

[0052] Where: Mobile Device: Mobile device

[0053] Cloud Server

[0054] Edge Server

[0055] Dummy Task: Virtual Character

[0056] Task: Computation task

[0057] Data Dependency

[0058] Environment Data Downloading Time: Environment download time

[0059] Environment Preparation Time:

[0060] Dependency Data Transmission: Dependency data transmission.

[0061] Figure 3 This demonstrates how to remove redundant tasks, including: (1) a data transfer graph with simple dependency task graphs. ( In scheduling Later changes, solid lines indicate actual data transmission adaptively selected based on transmission completion time; (2) Delete redundant tasks. And release the edge resources it occupies, since it does not contribute to the final result.

[0062] Among them, Cloud:

[0063] Edge Server

[0064] Redundant Task

[0065] Valid Task: Actual Task

[0066] Actual Transmission: The actual transmission of data.

[0067] Figure 4 The left side shows a task diagram example, the top right shows the execution schedule, and the bottom right shows the unit data transfer schedule.

[0068] Among them, Dummy Task: Virtual Task

[0069] Task: Computation task

[0070] Data Dependency

[0071] Execution Time Matrix: The time matrix used for execution.

[0072] Figure 5 The proposed SDTS, GenDoc, and HEFT algorithms yield the following results: (a) SDTS (total delay = 9.74), (b) GenDoc (total delay = 14.62), and (c) HEFT (total delay = 13.74).

[0073] Environment Data Downloading Time:

[0074] Environment Preparation Time:

[0075] Task Execution Time: The time it takes for the task to run.

[0076] Experimental example: This method was evaluated through simulation. SDTS and the simulation environment were implemented in Python 3.8 on a computer with an Intel Core i9-10900K 3.70 GHz CPU and 32GB RAM. The results of each experiment were repeated ten times with different random seeds to mitigate the influence of randomness.

[0077] in, Figure 6 Average task execution time: the average time a task runs.

[0078] CCR: Transmission Time to Runtime Ratio

[0079] DCR: Download Time to Run Time Ratio

[0080] Average environment preparation time.

[0081] An edge computing network consists of five edge servers and one cloud server. The average time for each unit of data transmission between the edge servers is denoted as... Then the server and Between from This represents heterogeneous bandwidth in edge computing. The default setting is $, The average value of each row, Selected from to indicate The workload, of which It is the average task execution time, and then, the execution time. from . The default setting is This means the powerful processing capabilities of the cloud for each edge server. Download bandwidth From Randomly selected from, among which This is the average download bandwidth, and the number of tasks that can be executed simultaneously for each edge server. From Randomly selected from among them.

[0082] To better compare with the GenDoc algorithm, we also generated a simulated dataset based on Alibaba's trace of data analysis, which contains over 2 million real applications with DAG dependency information. The average number of tasks in the Alibaba trace application is 5.3. After filtering out duplicate jobs with the same DAG structure, there are 16,176 applications with unique DAG structures, each with 2 to 205 tasks. Specifically, over 98% of the DAGs contain fewer than 50 tasks. The following simulation applies the task graph structure of the dependent tasks in the Alibaba dataset.

[0083] Then, the weights of tasks and edges are generated. The Communication-Computation Ratio (CCR) is used to represent the relationship between the communication data of dependencies and the computational workload of tasks. CCR is defined as follows: ,in This is the average size of the dependency data; the size of the data transmitted that the task depends on starts from... The Download Computation Ratio (DCR), randomly selected from the available data, is used to represent the relationship between environment size and task computational workload. DCR is defined as follows: ,in This is the average size of the task environment; the environment size for each task starts from... The environment preparation time for each task is randomly selected. from Randomly selected from, among which This is the average environmental preparation time. The default setting is .

[0084] For ease of representation, the average task execution time will be... Normalized to 1, the scheduling results of different types of applications under different edge network configurations are evaluated by controlling the proportion of different parts of the time to the average task. .

[0085] The proposed SDTS algorithm is compared with the following representative algorithms: HEFT: This is a well-known heuristic algorithm designed to minimize the total latency of related tasks in heterogeneous computing, but without considering task startup latency; GenDoc: Proposes to solve the placement and scheduling problem of dependent tasks using function configuration. GenDoc first determines which functions should be configured on each edge server, and then designs a dynamic programming method to schedule each task; Purely Cloud: Runs all tasks in the cloud; Purely Local: Places all tasks on a single edge server with minimal total latency.

[0086] Please refer to the experimental results. Figure 7-9;

[0087] in, Figure 7 Makespan: Total application runtime

[0088] CDF: Cumulative Distribution Function.

[0089] Figure 9 Avg. Makespan: Average application runtime

[0090] Purely Cloud: Running solely on cloud servers

[0091] Purely Local: Running solely on the local machine.

[0092] Although embodiments of the invention have been shown and described, it will be understood by those skilled in the art that various changes, modifications, substitutions and alterations can be made to these embodiments without departing from the principles and spirit of the invention, the scope of which is defined by the appended claims and their equivalents.

Claims

1. An edge computing oriented start time aware dependent task scheduling method, characterized in that, It includes edge devices, edge servers, and cloud servers, which are connected via a network. It also includes applications, which consist of multiple interdependent computing tasks forming a task graph. The scheduling method includes the following steps: (1) Set task priority. Task priority is calculated based on the size of the task's runtime environment and the workload of its descendant tasks. Then, the ready task with the highest priority is selected and scheduled in sequence. The specific formula for calculating task priority is: ,in This represents the average download time for the task environment. The longest path among the descendant tasks of the destination task. It can be recursively defined as: ,in and ; (2) Select edge servers, taking into account factors such as task startup, dependent data transmission, and task execution, and schedule each task to the edge server with the earliest completion time. For the current task, greedily search for the earliest time interval that meets the following conditions on each edge server: First, the start of the time interval must meet the task's dependency; second, the number of tasks running at any point in the time interval does not exceed the capacity of the edge server; and finally, the start of the time interval must meet the condition that the task's running environment has been started. (3) Deploy task cloud clones. Although task replication can avoid long-term communication, it also brings additional computing and download overhead in the edge network. Deploy a clone in the cloud for each non-virtual task to benefit from the powerful cloud resources, while also avoiding task startup. The start-up time of the task clone in the cloud is: ; (4) Refine task scheduling. After each task is scheduled, tasks that do not contribute to reducing the overall latency are effectively identified as redundant tasks and deleted. After all task scheduling decisions have been made, the start time and environment download completion time of the scheduled tasks are recalculated to further improve scheduling. After making the changes, redundant tasks that do not contribute to the minimum manufacturing period can be effectively identified and removed, thereby freeing up resources occupied on the edge servers. The tasks retained in the process are named valid tasks. A valid task must have at least one valid successor task that helps minimize manufacturing time; otherwise, it is redundant. Recursively, for each valid task, there must exist a successor task from it to... Virtual End Task The path, therefore, It is possible to reach The set of nodes is retained as valid tasks, while other tasks are identified as redundant tasks and removed from the list. The removal of redundant tasks creates new idle time intervals for task execution and environment downloads on the edge servers. These idle time intervals can be used to tighten the schedule, thereby reducing overall latency. This is achieved by advancing the environment download completion time and task start time without changing other variables, such as the runtime environment download order, the edge server resources used by the tasks, or the selected edge server. 2.The edge computing oriented start-time-aware dependent task scheduling method according to claim 1, wherein, The edge server: The set of all edge servers in the edge computing network is represented as follows. To model the heterogeneous processing capabilities of edge servers, an uncorrelated machine model is used, where the execution time of each task on each server is machine-dependent, and each edge server... With limited computing resources, it can execute simultaneously. A function, the link connecting the edge servers has heterogeneous bandwidth, two edge servers and The bandwidth between them is defined as the delay per unit of data transmission. Specifically, Data transfer time on the same edge server is negligible, that is... . 3.The edge computing oriented start-time-aware dependent task scheduling method according to claim 1, wherein, The cloud server is referred to as: , With unlimited computing resources, it can execute an unlimited number of tasks simultaneously. The cloud has already initialized the runtime environment for all tasks. The unit data transmission latency of the edge cloud link, denoted as dc, is much longer than the unit data transmission latency between two edge servers. Transmission time within the cloud is negligible. It is also assumed to be zero.

4. The edge computing oriented start-time-aware dependent task scheduling method according to claim 1, characterized in that, The application: This application is represented as a and is powered by a mobile device. The deployment and application structure can be described using a directed acyclic graph (DAG), named the task graph. ,in This represents the set of nodes for a task. The set of directed edges representing the dependencies between tasks, where the execution time of each task is represented in the execution time matrix. Defined in, where each element Designated task On the server The execution time on the directed edge allows for task replication, meaning a task can be executed on multiple servers to reduce overall latency. Specify from task To the mission Some data transfer is required. If the task and tasks Stored on servers and server The data transmission time is as follows: For each edge ,Task Defined as a task Ex, mission Defined as a task The successor, on the edge server Execute the task Previously, the task should have been started. The task start time mainly consists of two parts. Components: Environment download time ,in It is an edge server Download bandwidth, It is a task Environment size, environment preparation time This includes data decompression time and package import time, which depend on the task and server. The environment download time and environment preparation time for each task in the cloud are both zero. Two virtual nodes with zero execution time and zero startup time are inserted into the task graph. A virtual source task is inserted at the beginning to trigger the application, and a virtual sink task is inserted at the end to receive all the execution results. The total number of tasks in application 'a' becomes... Then, the task graph G is relabeled through topological sorting, after insertion and sorting. and Both will be updated; the source task and the sink task are represented as follows: and All must be released on mobile devices. Execute on top, for a task ,from Remittance task Tasks along the path are called its descendant tasks, from the source task. arrive The task on the path is called its ancestor task.

5. The edge computing oriented start-time-aware dependent task scheduling method according to claim 1, characterized in that, The progress tightening process is as follows: a. Calculate the download completion time for each task based on the download order on each edge server; b. Sort the tasks on the edge servers according to dependency constraints; The process of calculating the start time of these ordered tasks incurs additional computational overhead, so it is only run once after the entire application has been scheduled.

6. The edge computing oriented start-time-aware dependent task scheduling method according to claim 1, characterized in that, The goal of the scheduling is to optimize the entire application, specifically the end time of the final task that receives the execution results. The constraints include tasks that each server processes in parallel at the same time, dependencies between tasks, prohibition of task interruption, and bandwidth limitations on task execution environment downloads.

Images