A task scheduling method with dependencies for fog computing

Abstract

The present invention discloses a method for task scheduling with dependencies for fog computing. The present invention includes the following steps: 1. Task modeling; using a directed acyclic graph to model the dependencies between subtasks of a terminal node user task; 2. Collecting public information of the network in the area; 3. Task execution delay modeling; 4. Task transmission delay modeling; using the following steps to model the transmission delay when the i-th terminal device matches the k-th edge server; 5. Subtask scheduling when a single terminal matches a single edge server, scheduling the execution of all subtasks of the terminal node between the local and edge servers; 6. Task scheduling in a multi-terminal and multi-edge server scenario; performing terminal device task scheduling for multiple terminals and multiple edge servers according to the following steps. The present invention explores a task offloading scheme that takes into account the dependencies between subtasks, in order to pursue the reduction of delay and the improvement of edge server utilization, so that the task offloading model in the edge fog network is closer to actual application.

Description

Technical Field

[0001] The present invention belongs to the field of distributed fog computing, and in particular relates to a task scheduling method with dependency relationships for fog computing. Background Art

[0002] With the development of the internet and driven by enormous application demand, IoT systems are expected to perform computationally intensive and latency-sensitive sensing and computing tasks. This poses a significant challenge to IoT devices with limited computing power and battery capacity. To address this issue, edge computing is a promising architecture in which IoT devices can offload their tasks to edge servers. Edge servers typically possess significant processing power. Through task offloading, they provide IoT end users with less computational power the opportunity to complete large tasks, facilitate the deployment of more large-scale software, and provide greater user convenience without requiring hardware upgrades. Therefore, task offloading in edge fog networks has been a hot topic in fog computing research.

[0003] Current task offloading work can be divided into partial offloading and full offloading. Partial offloading usually models the task into two subtasks that can be arbitrarily divided, one subtask is executed locally, and the other is executed on the edge server. Full offloading considers the task as a whole, either all executed locally or all executed on the edge server. However, in actual applications, in most cases, user tasks are actually composed of multiple subtasks with dependencies. At this time, if full offloading technology is adopted, this will lead to a waste of local computing resources after task offloading; if partial offloading technology is adopted, the existing partial offloading research is inconsistent with the actual task model. In response to the above problems, the work of the present invention is to explore task offloading schemes that take into account subtask dependencies, in order to pursue the reduction of latency and the improvement of edge server utilization, which will make the task offloading model in the edge fog network closer to actual applications. Summary of the Invention

[0004] The main devices in the application scenario of the present invention include terminal devices, edge servers, and a control center. Due to the limited number of edge servers, one edge server can match multiple terminal devices and provide services to the terminal devices at different times. Each terminal device can only match one edge server. If the match is successful, the terminal device's subtask can be selected to be executed locally or offloaded to the matching edge server. The terminal device and the edge server communicate via a wireless connection. The control center collects various operating indicators of the terminal and edge devices through wired or wireless communication with the terminal device and edge server, including the CPU operating frequency, device location information, transmission power, noise power, channel quality, and task information. Based on this collected data, the control center executes the greedy strategy-based task offloading scheduling decision proposed in the present invention, obtaining the matching vector between the terminal device and the edge server and the scheduling vector of the terminal device subtask. The control center broadcasts the matching results and subtask scheduling vector to the terminal user and edge server, and the terminal device and edge server transmit and execute the task based on the scheduling results.

[0005] To achieve the above objectives, the technical solution of the present invention includes the following steps:

[0006] S1. Task Modeling: A directed acyclic graph (DAG) is used to model the dependencies between subtasks of a terminal node user task.

[0007] Each user task at a terminal node is modeled using a DAG. DAG nodes represent subtasks, and edges represent dependencies between tasks. Each subtask is uniquely identified by a sequence number, and subtasks are executed sequentially based on the sequence number and dependencies. For each subtask, it is assumed that the amount of data output by the subtask to the next dependent subtask and the computational cycle required by the subtask itself are known.

[0008] Because the first task requires data input when it begins execution, this paper adds a node numbered 0 during task modeling. This node only outputs data but does not perform any computational tasks. Its subsequent dependent subtasks (such as subtask 1) need to receive data from subtask 0 when they begin execution. Subtask 0 is executed on the local device by default. Furthermore, this paper assumes that the amount of result data output by the last subtask of a terminal node is negligible. That is, once the last subtask is calculated, the task processing for that terminal node is considered complete.

[0009] S2. Collect public information about the network in the region.

[0010] Public information about the network in the region includes: the number of edge servers N and the computing power of each edge server f fog ; The number of terminal devices M and the computing power of each terminal device flocal , the channel bandwidth B allocated to each terminal user; the location coordinates (x, y) of the terminal device and the edge server, the noise power W; the transmission power p of information transmission between the terminal and the edge server.

[0011] S3. Task execution delay modeling.

[0012] The following formula is used to model the latency of terminal task processing.

[0013] The latency of subtask j in local computation is modeled as:

[0014]

[0015] represents the local computation delay of the jth subtask, f local Indicates the computing power of the terminal device, C j represents the computational cycles required for the jth subtask.

[0016] The computation delay of subtask j on the edge server is modeled as:

[0017]

[0018] represents the computational delay of the jth subtask on the edge server, f fog Indicates the computing power of the edge server.

[0019] S4. Task transmission delay modeling. Use the following steps to model the transmission delay when the i-th terminal device matches the k-th edge server.

[0020] S4-1. Calculate the transmission rate when the i-th terminal device matches the k-th edge server. The transmission rate is calculated using the Shannon formula:

[0021]

[0022] r i k represents the transmission rate from the i-th terminal device to the matching server k, where B is the channel bandwidth, p and is the transmission power and channel gain between the i-th terminal device and the matching server k, and the denominator W is the noise power.

[0023] Channel gain The calculation formula is:

[0024]

[0025] in, represents the path loss between the i-th terminal device and the matching server k. The calculation formula of the path loss is:

[0026]

[0027] where d ik is the Euclidean distance between the i-th terminal device and the matching server k, which can be calculated from the location coordinates of the two devices.

[0028] S4-2. When the i-th terminal device is matched with the k-th edge server, the data transmission delay between the terminal device's subtask j and its dependent subtask f is modeled as:

[0029]

[0030] In the above formula, D f,j represents the amount of data that subtask f needs to transfer to subtask j, Indicates the transmission rate between the edge server and the local terminal.

[0031] S5. Subtask scheduling when a single terminal is matched with a single edge server. The execution of all subtasks of the terminal node is scheduled between the local and edge servers according to the following steps.

[0032] S5-1. Initialization. Set the local calculation start time T local , Edge server calculation can start time T fog , the completion time FT(0) of subtask 0 is all initialized to 0.

[0033] S5-2. Schedule each subtask j of the terminal node in sequence according to the dependency order, and obtain its completion time FT(j) and subtask offloading result D(j).

[0034] Calculate the set of pre-order dependent subtasks Φ of subtask j j .

[0035] Calculate the earliest completion time FT of subtask j executed locally according to the following formula: local (j).

[0036]

[0037] The earliest completion time FT of subtask j executed on the edge server is calculated according to the following formula: fog (j).

[0038]

[0039] Compare FT fog (j) and FT local (j) and update the subtask scheduling results. If FTlocal (j) greater than FT fog (j), then D(j)=1, FT(j)=T fog =FT fog (j), subtask j is executed on the edge server; otherwise, D(j) = 0, FT(j) = T local =FT local (j), subtask j is executed locally.

[0040] S5-3. Output the final task offloading result D of the terminal on the edge server, and the earliest completion time ET=FT(s), where s is the sequence number of the last subtask of the terminal node.

[0041] S6. Task Scheduling in Multi-Terminal and Multi-Edge Server Scenario: Follow the steps below to schedule terminal device tasks for multi-terminal and multi-edge servers.

[0042] S6.1 Initialization. Assume there are M terminals and N edge servers. The time to start computing for each edge server is T. fog (k)=0,k=1,...N.

[0043] S6.2 Assuming that all tasks of the terminal are executed locally, calculate the time t required for each terminal to complete the task all-local (i)=0,i=1,...M.

[0044] S6-3 will T all-local Sort in descending order, that is, put the terminal with the longest processing delay in the front and the terminal with the shortest processing delay in the back, to obtain the scheduling order set SCH.

[0045] S6-4 takes out the terminal node from SCH in sequence, matches the node with N edge servers one by one, and compares the time T required for local processing of all subtasks of the terminal node all-local The earliest possible start time of edge server k, if T all-local <T fog (k), give up matching with the server; otherwise, use the method in step S5 to schedule its subtasks and obtain the earliest completion time ET(k) when it matches with edge server k.

[0046] In addition, when executing step S5-1, the earliest time that the edge server k can start computing is T fog (k) Perform initialization.

[0047] S6-5 in T all-local And all ET(k), k=1,...N take the minimum value. If T all-local, it means that all tasks of the terminal are calculated locally; if it is ET(k), then the edge server k acts as the task offloading server of the terminal, outputs its offloading decision corresponding to the edge server k, and updates the T of the edge server k. fog (k) = ET(k).

[0048] S6-6 Repeat steps S6-4 and S6-5 until all terminal nodes in the SCH are scheduled. The control center broadcasts the matching results between the terminal and the server and the offloading decisions of each terminal subtask, and the tasks begin to execute according to the scheduling results.

[0049] The advantages of the present invention are:

[0050] (1) Most existing research methods for fog computing task offloading are based on task scheduling based on the assumption that tasks are indivisible and have no dependencies between them. However, this invention focuses on complex dependencies between tasks and more fine-grained task scheduling. This solves the latency increase problem caused by intelligent application task expansion to users to a greater extent.

[0051] (2) The present invention adopts a task scheduling scheme similar to the greedy algorithm, which minimizes the total delay while more reasonably utilizing the computing resources of the edge server, thereby improving the utilization rate of the edge server. BRIEF DESCRIPTION OF THE DRAWINGS

[0052] Figure 1 It is a user task model with task dependencies.

[0053] Figure 2 Task scheduling results in a single-task, single-server scenario. DETAILED DESCRIPTION

[0054] The following describes the embodiments of the present invention through specific embodiments. Those skilled in the art can easily understand other advantages and effects of the present invention from the content disclosed in this specification. The present invention can also be implemented or applied through different specific embodiments. The details in this specification can also be modified or changed based on different viewpoints and applications without departing from the spirit of the present invention. It should be noted that the following embodiments and features in the embodiments can be combined with each other unless they conflict.

[0055] Embodiment one:

[0056] Reference Figure 1 This embodiment provides a fog computing network model based on inter-task dependencies. In this network, edge servers and terminal devices are randomly distributed within a square area with a length and width of 1 km. Each terminal device and edge server has a corresponding location coordinate (x, y). This embodiment makes the following assumptions:

[0057] (1) Ignore the return time of the final result of the task-dependent DAG of the terminal device.

[0058] (2) Ignore the communication interference when different terminal devices are matched with the same edge server.

[0059] This embodiment includes the following steps:

[0060] S1. Task modeling.

[0061] A directed acyclic graph (DAG) is used to model the dependencies between subtasks of a terminal node user task.

[0062] Each user task at a terminal node is modeled using a DAG. DAG nodes represent subtasks, and edges represent dependencies between tasks. Each subtask is uniquely identified by a sequence number, and subtasks are executed sequentially based on the sequence number and dependencies. For each subtask, it is assumed that the amount of data output by the subtask to the next dependent subtask and the computational cycle required by the subtask itself are known.

[0063] Because the first task requires data input when it begins execution, this paper adds a node numbered 0 during task modeling. This node only outputs data but does not perform any computational tasks. Its subsequent dependent subtasks (such as subtask 1) need to receive data from subtask 0 when they begin execution. Subtask 0 is executed on the local device by default. Furthermore, this paper assumes that the amount of result data output by the last subtask of a terminal node is negligible. That is, once the last subtask is calculated, the task processing for that terminal node is considered complete.

[0064] In addition, subtasks with dependencies can only be executed serially, while subtasks without dependencies can be executed in parallel.

[0065] like Figure 1 As shown in the figure, it indicates that the task of this terminal node can be divided into seven subtasks. In the figure, the circle represents the subtask, the number inside the circle represents the subtask sequence number or identifier, and the number above the circle represents the number of cycles required to process the subtask. The directed edges represent dependencies, and the numbers on the edges represent the data that needs to be transmitted. Figure 1 In the example, subtasks 2 and 3 can be executed in parallel, but subtasks 2 and 4 can only be executed serially.

[0066] S2. Collect public information about the network in the region.

[0067] Public information about the network in the region includes: the number of edge servers N and the computing power of each edge server f fog ; The number of terminal devices M and the computing power of each terminal device f local, the channel bandwidth B allocated to each terminal user; the location coordinates (x, y) of the terminal device and the edge server, the noise power W; the transmission power p of information transmission between the terminal and the edge server.

[0068] S3. Task execution delay modeling.

[0069] The following formula is used to model the latency of terminal task processing.

[0070] The latency of subtask j in local computation is modeled as:

[0071]

[0072] represents the local computation delay of the jth subtask, f local Indicates the computing power of the terminal device, C j represents the computational cycles required for the jth subtask.

[0073] The computation delay of subtask j on the edge server is modeled as:

[0074]

[0075] represents the computational delay of the jth subtask on the edge server, f fog Indicates the computing power of the edge server.

[0076] S4. Task transmission delay modeling. Use the following steps to model the transmission delay when the i-th terminal device matches the k-th edge server.

[0077] S4-1. Calculate the transmission rate when the i-th terminal device matches the k-th edge server. The transmission rate is calculated using the Shannon formula:

[0078]

[0079] r i k represents the transmission rate from the i-th terminal device to the matching server k, where B is the channel bandwidth, p and is the transmission power and channel gain between the i-th terminal device and the matching server k, and the denominator W is the noise power.

[0080] Channel gain The calculation formula is:

[0081]

[0082] in, represents the path loss between the i-th terminal device and the matching server k. The calculation formula of the path loss is:

[0083]

[0084] where d ik is the Euclidean distance between the i-th terminal device and the matching server k, which can be calculated from the location coordinates of the two devices.

[0085] S4-2. When the i-th terminal device is matched with the k-th edge server, the data transmission delay between the terminal device's subtask j and its dependent subtask f is modeled as:

[0086]

[0087] In the above formula, D f,j represents the amount of data that subtask f needs to transfer to subtask j, Indicates the transmission rate between the edge server and the local terminal.

[0088] S5. Subtask scheduling when a single terminal matches a single edge server. The execution of all subtasks of the terminal node is scheduled between the local and edge servers according to the following steps, such as Figure 2 shown.

[0089] S5-1. Initialization. Set the local calculation start time T local , Edge server calculation can start time T fog , the completion time FT(0) of subtask 0 is all initialized to 0.

[0090] S5-2. Schedule each subtask j of the terminal node in sequence according to the dependency order, and obtain its completion time FT(j) and subtask offloading result D(j).

[0091] Calculate the set of pre-order dependent subtasks Φ of subtask j j .

[0092] Calculate the earliest completion time FT of subtask j executed locally according to the following formula: local (j).

[0093]

[0094] The earliest completion time FT of subtask j executed on the edge server is calculated according to the following formula: fog (j).

[0095]

[0096] Compare FT fog (j) and FT local (j) and update the subtask scheduling results. If FT local (j) greater than FTfog (j), then D(j)=1, FT(j)=T fog =FT fog (j), subtask j is executed on the edge server; otherwise, D(j) = 0, FT(j) = T local =FT local (j), subtask j is executed locally.

[0097] S5-3. Output the final task offloading result D of the terminal on the edge server, and the earliest completion time ET=FT(s), where s is the sequence number of the last subtask of the terminal node.

[0098] S6. Task Scheduling in Multi-Terminal and Multi-Edge Server Scenario: Follow the steps below to schedule terminal device tasks for multi-terminal and multi-edge servers.

[0099] S6-1. Initialization. Assume there are M terminals and N edge servers. The time for each edge server to start calculating is T. fog (k)=0,k=1,...N.

[0100] S6-2. Assuming that all tasks of the terminal are executed locally, calculate the time T required for each terminal to complete the task all-local (i)=0,i=1,...M.

[0101] S6-3.T all-local Sort in descending order, that is, put the terminal with the longest processing delay in the front and the terminal with the shortest processing delay in the back, to obtain the scheduling order set SCH.

[0102] S6-4. Take out the terminal node from SCH in turn, match the node with N edge servers one by one, and compare the time T required for local processing of all subtasks of the terminal node all-local The earliest possible start time of edge server k, if T all-local <T fog (k), give up matching with the server; otherwise, use the method in step S5 to schedule its subtasks and obtain the earliest completion time ET(k) when it matches with edge server k.

[0103] In addition, when executing step S5-1, the earliest time that the edge server k can start computing is T fog (k) Perform initialization.

[0104] S6-5.In T all-local And all ET(k), k=1,...N take the minimum value. If T all-local, it means that all tasks of the terminal are calculated locally; if it is ET(k), then the edge server k acts as the task offloading server of the terminal, outputs its offloading decision corresponding to the edge server k, and updates the T of the edge server k. fog (k) = ET(k).

[0105] S6-6. Repeat steps S6-4 and S6-5 until all terminal nodes in the SCH are scheduled. The control center broadcasts the matching results between the terminal and the server and the offloading decisions of each terminal subtask, and the tasks begin to execute according to the scheduling results.

Claims

1. A method for scheduling tasks with dependencies for fog computing, characterized in that The main devices in this application scenario include terminal devices, edge servers, and a control center. An edge server can match multiple terminal devices and provide services to terminal devices at different times. Each terminal device can only match one edge server. If the match is successful, the terminal device's subtasks can be executed locally or offloaded to the matching edge server. The terminal device and the edge server communicate via a wireless connection. The control center collects various working indicators of the terminal and edge devices through wired or wireless communication with the terminal device and the edge server, including CPU operating frequency, device location information, transmission power, noise power, channel quality, and task information. The method includes the following steps: S1. Task modeling: Using a directed acyclic graph to model the dependencies between subtasks of a terminal node user task; S2. Collect public information about the network in the region; S3. Task execution delay modeling; S4. Task transmission delay modeling: Modeling the transmission delay when the i-th terminal device matches the k-th edge server; S5. Subtask scheduling when a single terminal is matched with a single edge server. The execution of all subtasks of the terminal node is scheduled between the local and edge servers according to the following steps. The specific implementation is as follows: S5-1. Initialization; local calculation can start time T local , Edge server calculation can start time T fog , the completion time FT(0) of subtask 0 is all initialized to 0; S5-2. Schedule each subtask j of the terminal node in the order of dependency to obtain its completion time FT(j) and subtask unloading result D(j); Calculate the set of pre-order dependent subtasks Φ of subtask j j ; Calculate the earliest completion time FT of subtask j executed locally according to the following formula: local (j); The earliest completion time FT of subtask j executed on the edge server is calculated according to the following formula: fog (j); Compare FT fog (j) and FT local (j) and update the subtask scheduling results; if FT local (j) greater than FT fog (j), then D(j)=1, FT(j)=T fog =FT fog (j), subtask j is executed on the edge server; otherwise, D(j) = 0, FT(j) = T local =FT local (j), subtask j is executed locally; S5-3 outputs the terminal on the edge server final task offloading result D, and the earliest completion time ET = FT (s), s is the sequence number of the last subtask of the terminal node; S6. Task Scheduling in Multi-Terminal and Multi-Edge Server Scenario: Follow the steps below to schedule terminal device tasks for multi-terminal and multi-edge servers. The specific implementation is as follows: S6-1 Initialization: Assume there are M terminals and N edge servers. The time for each edge server to start calculating is T fog (k)=0, k=1,...N; S6-2 Assume that all tasks of the terminal are executed locally. Calculate the time T required for each terminal to complete the task. all-local (i) = 0, i = 1, ... M; S6-3 will T all-local Sort in descending order, that is, put the terminal with the longest processing delay in the front and the terminal with the shortest processing delay in the back, to obtain the scheduling order set SCH; S6-4 takes out the terminal node from SCH in sequence, matches the node with N edge servers one by one, and compares the time T required for local processing of all subtasks of the terminal node all-local The earliest possible start time of edge server k, if T all-local <T fog (k), give up matching with the server; otherwise, use the method in step S5 to schedule its subtasks and obtain the earliest completion time ET(k) when it matches with edge server k; S6-5 in T all-local and all ET(k), k=1,...N, take the minimum value; if T all-local , it means that all tasks of the terminal are calculated locally; if it is ET(k), then the edge server k acts as the task offloading server of the terminal, outputs its offloading decision corresponding to the edge server k, and updates the T of the edge server k. fog (k) = ET(k); S6-6 Repeat steps S6-4 and S6-5 until all terminal nodes in the SCH are scheduled; the control center broadcasts the matching results between the terminal and the server and the offloading decisions of each terminal subtask, and the task begins to execute according to the scheduling results.

2. A method for scheduling tasks with dependencies for fog computing according to claim 1, characterized in that Step S1 is specifically implemented as follows: Each user task at a terminal node is modeled using a DAG. DAG nodes represent subtasks, and edges represent dependencies between tasks. Each subtask is identified by a unique sequence number, and subtasks are executed in order based on the sequence number and dependencies. For each subtask, it is assumed that the amount of data output by the subtask to the next dependent subtask and the computational cycle required by the subtask itself are known. Since the first task requires data input when it starts executing, a node with sequence number 0 is added during task modeling. This node only outputs data but does not perform any computation. Its subsequent dependent subtasks need to receive data from subtask 0 when they start executing. Subtask 0 is executed on the local device by default. In addition, it is assumed that the amount of result data output by the last subtask of the terminal node is negligible. That is, after the calculation of the last subtask is completed, the task processing of the terminal node is considered completed.

3. The method for scheduling tasks with dependencies for fog computing according to claim 2 is characterized in that The public information of the network in the step S2 area includes: the number of edge servers N and the computing power of each edge server f fog ; The number of terminal devices M and the computing power of each terminal device f local , the channel bandwidth B allocated to each terminal user; the location coordinates (x, y) of the terminal device and the edge server, the noise power W; the transmission power p of information transmission between the terminal and the edge server.

4. The method for scheduling tasks with dependencies for fog computing according to claim 2 is characterized in that Step S3: Task execution delay modeling, specifically implemented as follows: S3-1. The latency of subtask j in local computation is modeled as: represents the local computation delay of the jth subtask, f local Indicates the computing power of the terminal device, C j represents the computational cycle required for the jth subtask; S3-2. The computation delay of subtask j at the edge server is modeled as: represents the computational delay of the jth subtask on the edge server, f fog Indicates the computing power of the edge server.

5. The method for scheduling tasks with dependencies for fog computing according to claim 4 is characterized in that Step S4: Task transmission delay modeling. This is achieved by modeling the transmission delay when the i-th terminal device matches the k-th edge server. S4-1. Calculate the transmission rate when the i-th terminal device matches the k-th edge server; the transmission rate is calculated using the Shannon formula: r i k represents the transmission rate from the i-th terminal device to the matching server k, where B is the channel bandwidth, p and is the transmission power and channel gain between the i-th terminal device and the matching server k, and the denominator W is the noise power; Channel gain The calculation formula is: in, represents the path loss between the i-th terminal device and the matching server k. The calculation formula of the path loss is: where d ik is the Euclidean distance between the i-th terminal device and the matching server k, which can be calculated from the location coordinates of the two devices; S4-2. When the i-th terminal device is matched with the k-th edge server, the data transmission delay between the terminal device's subtask j and its dependent subtask f is modeled as: In the above formula, D f,j represents the amount of data that subtask f needs to transfer to subtask j, Indicates the transmission rate between the edge server and the local terminal.

Images