Robust dependent task scheduling method for fault recoverable mobile edge computing

Abstract

The invention provides a fault-recoverable mobile edge computing-oriented robust dependent task scheduling method, which comprises the following steps of: acquiring mobile edge computing system parameters which comprise a dependent task set, an edge network, the number of available CPU (Central Processing Unit) kernels of a server, kernel processing capability and link bandwidth; calling an adaptive resource allocation algorithm based on the system parameters to dynamically determine the scheduling sequence of the sub-tasks, and allocating system resources required for execution to the sub-tasks to obtain a resource allocation matrix; executing the subtasks according to the resource allocation matrix; when a server fault occurs, calling a server fault rescheduling algorithm to update the resource allocation matrix; when a communication link fault occurs, calling a link fault rescheduling algorithm to update the resource allocation matrix; executing the subtasks according to the updated resource allocation matrix until all the outlet subtasks are executed; obtaining execution completion time frames of all the dependent tasks; according to the invention, the robustness and effectiveness of the mobile edge computing system can be improved.

Description

Technical Field

[0001] This invention relates to the field of edge computing task scheduling technology, and in particular to a robust dependency task scheduling method for fault-recoverable mobile edge computing. Background Technology

[0002] Unlike cloud computing, mobile edge computing (MEC), as a new computing paradigm, is closer to the user's geographical location. It has significant advantages in handling massive numbers of terminal devices and user requests, thus better meeting the user's needs for low latency, real-time response, and low energy consumption. Therefore, it is suitable for processing short-cycle, real-time data and shows broad application prospects in fields such as autonomous driving, smart healthcare, and intelligent manufacturing. In practical applications of MEC, complex user tasks are typically decomposed into a series of dependent subtasks. For example, an autonomous driving task can be decomposed into four subtasks: environmental perception, policy decision-making, trajectory planning, and motion control. These four subtasks have a clear sequence and strong dependencies. Directed acyclic graphs (DAGs) are often used to characterize the dependencies between subtasks. Based on DAGs, complex tasks can be decomposed into a series of parallelizable subtasks, significantly reducing task completion time. This task scheduling method has shown extremely important value in key edge computing application scenarios such as real-time video analytics, autonomous driving, and smart cities.

[0003] Dependency task scheduling in MEC is an NP-hard problem. Most current dependency task scheduling methods employ static scheduling strategies. These strategies determine the execution order of all subtasks before the main task begins execution and then allocate edge server resources to the subtasks according to this order. However, unlike highly reliable cloud center servers, edge servers are typically small and unreliable. Therefore, edge servers are prone to failure at any time. Due to the lack of responsiveness to dynamic changes in the network environment, static subtask scheduling strategies are often inefficient when dealing with dynamic and uncertain edge computing environments.

[0004] Cloud central servers and multiple edge servers can be networked to provide edge services, achieving cloud-edge collaboration and optimizing system service performance. However, communication links between edge servers may fail due to disruption. Therefore, fault handling is crucial for designing robust task scheduling strategies. However, existing scheduling methods typically allocate network resources greedily based on task completion time, failing to account for potential future server or communication link failures. This significantly impacts task execution performance and fails to ensure the robustness of the scheduling method in the face of faults. Summary of the Invention

[0005] In view of the shortcomings of the prior art described above, the purpose of this invention is to provide a robust dependent task scheduling method for fault-recoverable mobile edge computing, which solves the technical problem of poor robustness of robust dependent task scheduling in fault-recoverable mobile edge computing.

[0006] To achieve the above objectives, this invention provides a robust dependency task scheduling method for fault-recoverable mobile edge computing, comprising:

[0007] Obtain the parameters of the mobile edge computing system, including the set of dependent tasks. Edge network Number of available CPU cores on the server Kernel processing capabilities and link bandwidth ;

[0008] An adaptive resource allocation algorithm is invoked based on system parameters to dynamically determine the scheduling order of subtasks and allocate the system resources required for the execution of subtasks, thereby obtaining a resource allocation matrix.

[0009] Execute subtasks based on the resource allocation matrix;

[0010] When a server failure occurs, the server failure rescheduling algorithm is invoked to update the resource allocation matrix;

[0011] When a communication link failure occurs, the link failure rescheduling algorithm is invoked to update the resource allocation matrix;

[0012] Then execute subtasks according to the updated resource allocation matrix until all exit subtasks have been executed;

[0013] Obtain the execution completion time frames of all dependent tasks.

[0014] The beneficial effects of the principle of this invention are as follows: This invention considers the system model under the simultaneous existence of server failure and link failure, and constructs a dependent task model based on DAG. Based on the idea of ​​software-defined networking, it proposes the concept of resource allocation matrix, and uses the resource allocation matrix to finely characterize the system resource usage, formally describes the robust dependent task scheduling problem, and optimizes the task completion time.

[0015] This invention first constructs a directed acyclic hypergraph to achieve effective scheduling of multi-dependent tasks. Then, based on the real-time resource usage of the system, it dynamically determines the scheduling order of subtasks, introduces a failure rate calculation to calculate the expected completion time frame to weigh the advantages and disadvantages of different server resources, and performs adaptive resource allocation based on the resource allocation matrix. Finally, when a server or link fails, the affected subtasks are rescheduled, thereby improving the robustness and effectiveness of the system. Attached Figure Description

[0016] Figure 1 This is the cloud-edge-device system model for this embodiment;

[0017] Figure 2 A directed acyclic graph (DAG) is an example of a dependent task.

[0018] Figure 3 This is an exemplary resource allocation matrix for this embodiment;

[0019] Figure 4 This is a flowchart of this embodiment;

[0020] Figure 5 This embodiment illustrates the construction of a directed acyclic hypergraph;

[0021] Figure 6 This is an example of server failure rescheduling. The left side of the diagram is the DAG of dependent tasks, and the right side is the resource allocation matrix.

[0022] Figure 7 This is an example of a backbone link failure task rescheduling diagram. The left side of the diagram is the DAG of dependent tasks, and the right side is a link scheduling diagram.

[0023] Figure 8 The figure shows the results of a comparative experiment on task scheduling with varying numbers of subtasks. (a) Comparison of task completion times without failures; (b) Comparison of the number of failures; (c) Comparison of task completion times under failure conditions.

[0024] Figure 9 To compare the experimental results of task scheduling with varying link bandwidth, the figure shows (a) the comparison of task completion time without faults; (b) the comparison of the number of faults; and (c) the comparison of task completion time under fault conditions.

[0025] Figure 10 The experimental results of resource allocation with varying link bandwidth are shown in the figure. (a) shows the comparison of task completion time without faults; (b) shows the comparison of the number of faults; and (c) shows the comparison of task completion time under fault conditions.

[0026] Figure 11To compare the results of resource allocation experiments with varying numbers of dependent tasks, the figure shows (a) the comparison of task completion time without failures; (b) the comparison of the number of failures; and (c) the comparison of task completion time under failure conditions. Detailed Implementation

[0027] The following specific examples illustrate the implementation of the present invention. 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 other different specific embodiments, and various 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.

[0028] The purpose of this invention is to address the Robust Dependent Task Scheduling (RDTS) problem in fault-recoverable mobile edge computing. It designs a robust task scheduling strategy by comprehensively considering factors such as server failure rate and computing speed, and further designs adaptive resource allocation algorithms, server failure rescheduling algorithms, and link failure rescheduling algorithms to minimize task completion time. However, solving the RDTS problem faces significant challenges. On the one hand, the dynamic and random occurrence of failures makes finding the optimal solution extremely difficult; on the other hand, most existing technologies either do not consider server failure handling methods or only consider how to handle situations after a server failure occurs.

[0029] This invention utilizes the concept of cloud-edge collaboration and proposes a robust dependency task scheduling method (RDTDS) for fault-recoverable mobile edge computing, taking into account various factors of the system. The invention first formalizes the problem by establishing a cloud-edge-device system model, a dependency task model, and a resource allocation model.

[0030] The cloud-edge-device system model is established as follows:

[0031] This invention establishes as follows Figure 1 The cloud-edge-device system model shown is a three-layer architecture. The first layer is the device layer, comprising various wireless devices, primarily responsible for collecting application data and wirelessly uploading it to the edge network for processing. The second layer is the edge network layer, consisting of a wired network of multiple edge servers and switches. Edge servers communicate with each other via connected switches and collaboratively complete the data processing tasks uploaded from the device layer. The third layer is the cloud layer, including a remote cloud center server that connects to the edge servers via the internet. This server is responsible for generating robust dependency task scheduling strategies for both fault-free and faulty scenarios and distributing these strategies to the edge servers for execution. The cloud layer and the edge network layer collaborate to improve the system's robustness.

[0032] Assume that the task processing is mainly performed by the edge network layer, and describe this edge network as an undirected graph. ,in This represents a set of edge servers. Assume the system contains... Taiwan edge server, , of which Taiwan server is represented as , . This represents a set of switches used for edge server networking and communication. Assume the system contains... One switch, then , of which Each switch is represented as , .

[0033] In edge networks, communication links include backbone links and edge links. A backbone link is a link connecting two switches, while an edge link is a link connecting an edge server and a switch. The collection of backbone links is... It means that, among them Representative switch With switch A direct communication link between them. (Link) Transmission bandwidth Representation. The set of edge links is represented by... It means that, among them Represents edge server With switch A direct communication link between them, and the transmission bandwidth of this link is used express.

[0034] Edge servers provide computing services through service function instances implemented using virtual machine technology, representing the entire set of service functions in the edge network as... Assuming the network includes... Different service functions have Deployment of any edge server in the edge network A subset of, in which the first The set of service functions deployed on the server is represented as ,satisfy The complete set of service functions deployed on all servers equals That is:

[0035] (1)

[0036] Each server in a network has a different set of service functions, CPU resources, and processing capabilities. To better represent the computation, this paper uses... Indicates server The number of available CPU cores, and using Indicates server Processing capacity of each kernel. Assume that each dependent subtask uses only one kernel resource during runtime.

[0037] The dependency task model is established as follows:

[0038] Assume that the terminal can offload dependent tasks to the edge network for processing via a connected edge server. A dependent task can be decomposed into several subtasks with dependencies, and this can be represented by a directed acyclic graph. To express. Represents the set of all subtasks, i.e. ,in Indicates the number of subtasks; This represents the set of dependencies between all subtasks. Depends on subtasks The execution result is then used This indicates the first subtask of the dependent task. As the entry subtask, it is responsible for processing the raw data. It is the last subtask that depends on the task. As an exit subtask, it returns the result after execution. Figure 2 The example shown is a dependency task based on DAG characterization. It is its entry subtask. It is its export sub-task. yes The preceding subtasks, therefore, have data edges. ,express execution dependencies The execution result.

[0039] Set subtasks The execution server is Each subtask has a specific service function type. Then there is Subtasks can only be offloaded to servers where the relevant service functions are deployed, and their offloading scheduling must meet the following requirements:

[0040] (2)

[0041] The start and end times of subtasks can be calculated based on the dependencies between them. The start time can be expressed as:

[0042] (3)

[0043] in, express One of the preceding subtasks; Subtasks The set of all preceding subtasks; Subtasks Completion time; express arrive Dependency edges The transmission time is calculated using the following formula:

[0044] (4)

[0045] in, express Data load express transmission bandwidth The size cannot exceed The maximum available bandwidth of any link traversed.

[0046] From formula (3), we can know that the subtask It must wait for all its preceding subtasks to complete and for the results to be transmitted to the destination. Allocated edge servers Only then can execution begin, then there are The earliest completion time is expressed as:

[0047] (5)

[0048] in, express On the server The execution time is calculated using the following formula:

[0049] (6)

[0050] express The computational load, i.e., the number of CPU cycles required. Indicates server The calculation speed. In formula (5) express There may be a delay when the server is busy.

[0051] After the exit subtask is completed, its execution result needs to be returned to the user. Since the execution result of the task is often only a few bits, its transmission delay can be ignored. Therefore, the response delay of a dependent task can be expressed as:

[0052] (7)

[0053] in, Indicates dependent tasks The final completion time is the completion time of its exit sub-task; Indicates dependent tasks Time to reach the edge network.

[0054] The resource allocation model is established as follows:

[0055] To gain a global view of the network, enabling finer-grained allocation of system resources and accurate and convenient modeling of server and link failure events, we propose a resource allocation matrix based on the concept of software-defined networking. The concept of resource allocation matrix. Assume the task scheduling time is divided into several time frames of equal length. The horizontal axis represents consecutive time frames, and the vertical axis represents the system's available resources, including edge servers and links. Table 1 illustrates the details of an edge server performing a subtask in the network through an example.

[0056] Table 1. Examples of Server Subtask Execution Schemes

[0057]

[0058] Note: √ indicates that the server can execute the current DAG subtask, and √ indicates the server that will ultimately execute the task.

[0059] based on Figure 1 The topology shown is Figure 2 The dependent tasks shown in Table 1, based on the server execution subtask scheme table, yield a typical resource allocation matrix as follows: Figure 3 As shown.

[0060] The horizontal axis of the resource allocation matrix represents time frames, and the vertical axis represents resources in the edge network layer, including edge servers and links. Squares of different colors represent different subtasks of a dependent task, dashed lines represent the execution flow of subtasks within network resources, and gray ellipses represent data dependencies between subtasks. The position of a square in the resource allocation matrix indicates that the subtask consumed a portion of the edge server's resources in a given time frame. The position of the gray ellipse in the resource allocation matrix indicates the bandwidth resources consumed in the link resources of the edge network layer.

[0061] For edge servers executing subtasks in the edge network layer, failures may occur due to configuration errors, external environmental factors (such as power outages or equipment damage), or external attacks, leading to downtime. In such cases, server repair and restart operations are required. During the period when the server recovers, its available resources are 0, which can be represented by a resource allocation matrix model.

[0062] Assume a certain edge server At any moment A failure occurred, and the server needs to be restarted. There are 1 time frames, each time frame being 1 unit in size. Then we have:

[0063] (8)

[0064] in Indicates server exist The number of available cores at any given time.

[0065] Communication links are also susceptible to failure due to various factors, which can affect data transmission. When a short-term link failure occurs, assuming restoration takes... If there are 10 time frames, then:

[0066] (9)

[0067] In the formula, Indicates communication link exist Available bandwidth resources at any given time.

[0068] When a failure occurs, it will affect the currently executing or subsequently executing subtasks and their dependent data edges. At this time, it is necessary to reschedule the affected subtasks to ensure the smooth execution of the tasks.

[0069] Based on the definitions of each model above, this invention considers the following problem: In the edge network layer, when some servers or some links fail and affect the progress of dependent task processing, how to ensure that dependent tasks in the network are executed smoothly and the total task completion time is minimized.

[0070] Assuming there is in the network The first dependent task is waiting to be executed. Each dependent task is represented as Then the set of dependent tasks is In a short-term failure scenario, the dependent task... The execution completion time is The optimization objective of this invention is to minimize the completion time frames of all dependent tasks, expressed as:

[0071] (10)

[0072] (11)

[0073] (12)

[0074] In the formula, what do s and t represent in formula (11), and what do they represent in formula (12)? What does it mean?

[0075] Theorem 1. Problem yes Difficult problem.

[0076] Proof: In the problem In this context, we consider the set of subtasks and the set of transfers between subtasks as the complete set. By constructing a resource allocation matrix, we can obtain the resource allocation results for each time frame. The sequence of subtasks executed and the transmission sequence between subtasks. Our goal is to find the minimum number of subsets, or time frames, that can be combined to cover the entire set. This falls under the category of set covering problems. And set covering problems... Difficult problem, therefore problem Too Difficult problem.

[0077] Problem Solving It is necessary to collect the available resources of the system for collaborative optimization. However, due to the heterogeneity and multidimensionality of system resources, the solution space grows exponentially, leading to a sharp increase in solution time. Solving this problem using traditional methods... It is extremely difficult to meet the stringent real-time requirements. Furthermore, existing scheduling methods do not account for potential future server or communication link failures, which can significantly impact task execution performance and fail to ensure the robustness of the scheduling method in the face of failures.

[0078] To solve the above problems, such as Figure 4 As shown, this invention proposes a robust dependency task scheduling method for fault-recoverable mobile edge computing to achieve robust task scheduling in fault scenarios and effectively improve task completion performance, as detailed below:

[0079] Obtain the parameters of the mobile edge computing system, including the set of dependent tasks. Edge network Number of available CPU cores on the server Kernel processing capabilities and link bandwidth ;

[0080] The system parameters are used to call the adaptive resource allocation algorithm RDTDS-ARA to dynamically determine the scheduling order of subtasks and allocate the system resources required for the execution of subtasks, thereby obtaining a resource allocation matrix.

[0081] Execute subtasks based on the resource allocation matrix;

[0082] When a server failure occurs, the Server Failure Rescheduling Algorithm RDTDS-SFR is invoked to update the resource allocation matrix;

[0083] When a communication link failure occurs, the link failure rescheduling algorithm RDTDS-LFR is invoked to update the resource allocation matrix;

[0084] Then execute subtasks according to the updated resource allocation matrix until all exit subtasks have been executed;

[0085] Obtain the execution completion time frames of all dependent tasks.

[0086] The pseudocode for this algorithm is shown in Algorithm 1.

[0087]

[0088] Among them, the adaptive resource allocation algorithm RDTDS-ARA is used to dynamically determine the scheduling order of subtasks and allocate the mobile edge computing system resources required for the execution of subtasks to obtain the resource allocation matrix, that is, to obtain the resource allocation scheme, which includes the allocation of edge servers, result transmission links and execution time frames.

[0089] The adaptive resource allocation algorithm RDTDS-ARA is as follows:

[0090] First, based on the set of dependent tasks We construct a Directed Acyclic Graph (DAG) or a Directed Acyclic Hypergraph (GDT). Specifically, for multiple dependent tasks awaiting resource allocation, we utilize a workflow merging method to construct a GDT based on the system dependency tree. The main method is to merge multiple interdependent tasks by adding virtual worker nodes with zero resource requirements. Specifically, such as... Figure 5 As shown, this is an example of constructing a directed acyclic hypergraph, where virtual nodes (SDTs) are added. and We merge DAG 1 and DAG 2 into a single directed acyclic hypergraph, DAG 3. After merging, we only need to allocate resources to DAG 3 to complete the two dependent tasks. This workflow merging method improves resource utilization because the merged DAG contains more parallel tasks, which can more effectively utilize the multi-core or multi-node parallel computing power in the edge network, thereby improving task execution efficiency.

[0091] Next, the resource allocation matrix is ​​initialized to obtain available resources in the system, and then dynamically updated based on the system's actual operating status and resource requirements. Specifically, the resource allocation matrix is ​​initialized using the model parameters of the edge network, taking into account relevant data. A crucial aspect is obtaining the available resources in the system, which include all servers, switches, and links within the edge network. After initialization, the resource allocation matrix can be dynamically updated based on the system's actual operating status and resource requirements, thereby achieving fine-grained allocation and management of resources.

[0092] Finally, the selection of subtasks for scheduling and resource allocation mainly includes three parts: subtask selection, resource allocation, and subtask scheduling.

[0093] Subtask selection involves choosing the subtask to be scheduled. When initializing the resource allocation matrix, it's crucial to ensure that each source subtask on the DAG data edge is scheduled before the target subtask. Therefore, a sorting algorithm is first used to sort the subtasks within the DAG, establishing their scheduling order based on data dependencies.

[0094] Common sorting algorithms are based on DAG topology. They start by traversing the entry subtask, selecting a subtask with an in-degree of 0, adding it to the sorted list, and then deleting the node containing that subtask from the DAG topology. This process is repeated until the exit subtask has been traversed. This method is a static sorting approach. Its advantage is that the execution order of all subtasks can be determined before scheduling begins. However, its disadvantage is that the subtask sorting is random, failing to consider the current available network resources when selecting schedulable subtasks, which to some extent affects the achievement of the optimization objective.

[0095] Considering the limitations of static sorting algorithms, this invention employs a dynamic sorting method to schedule DAG subtasks. The key to this method lies in the selection of the currently scheduled subtask. During the scheduling of a DAG, the following situation may occur: multiple subtasks' predecessors have all been scheduled, and only one subtask can ultimately be selected for priority scheduling. This invention selects and schedules subtasks based on the principle of prioritizing the subtask whose predecessor has the earliest completion time. However, typically, a subtask has more than one predecessor; therefore, the completion time of a subtask's predecessor refers to the completion time of all its predecessors. The set of schedulable subtasks is defined as follows: Subtask The set of preceding subtasks is Subtask The earliest completion time is Select the priority to schedule subtasks. The formula is:

[0096] (13)

[0097] This subtask selection metric ensures that subsequent subtasks are scheduled only after the preceding subtasks are completed, thus guaranteeing the correctness of the task execution order. Furthermore, because the earliest completed preceding subtask is prioritized for scheduling, it reduces the waiting time of subtasks during actual task execution.

[0098] After selecting subtasks and scheduling them, the system resources for executing the subtasks are allocated based on their scheduling order, and the resource allocation matrix is ​​updated synchronously, as follows:

[0099] For the constructed directed acyclic hypergraph, we determine the subtask to be scheduled based on the subtask scheduling execution order obtained during the initialization phase, and then apply a resource allocation algorithm to that subtask. That is, based on the current real-time network state, we pre-allocate resources such as servers, transmission links, and link bandwidth, and update the resource allocation matrix accordingly. Once the execution order of a specific subtask is determined, the key is to first determine the server executing that subtask, then determine the transmission path of the data edge and the corresponding link bandwidth resources, and simultaneously update the resource allocation matrix.

[0100] In existing technologies, the simplest and most commonly used method for resource allocation is random allocation. This involves randomly selecting one of the available resources (e.g., an executable server or a transferable path) for a subtask when multiple resources are available within a given time period. While simple and convenient, random allocation cannot guarantee the effectiveness of the allocation or the achievement of the optimal goal, exhibiting significant randomness. Furthermore, server failures have a substantial impact on task completion time, necessitating a comprehensive consideration of server failures when allocating resources. Therefore, to overcome the shortcomings of existing methods, the adaptive resource allocation algorithm of this invention comprehensively considers both server failures and subtask completion time.

[0101] Adaptive resource allocation algorithms primarily focus on server failure rates and subtask completion times. Therefore, this invention assumes that the server... The probability of failure is , For server Working hours. As working hours increase, the server... The probability of failure also increases continuously. Based on this failure probability, this invention proposes the expected completion time frame as an evaluation metric for edge servers. For tasks... ,server Expected completion time frame The calculation formula is:

[0102] (14)

[0103] In the formula, Indicates the start time of the task, usually determined by the task... The end time of the parent task, the parent task server to server Transmission time and server The waiting time is determined jointly by both parties;

[0104] This indicates that on the server The task was completed without any problems. The time; among which, Indicates on the server Complete the task without any faults. Time required; Indicates time frame At that time, the server The probability of failure. Indicates server The current time, Indicates a time frame; This represents the probability of completing the task without any failures.

[0105] This indicates the time required for task rescheduling and recovery in the event of a failure. Indicates server Execute the task At that time, the data collection time before rescheduling after a failure. Indicates server exist After a time frame failure, the task The shortest completion time after rescheduling; This indicates another time frame.

[0106] To simplify The computational difficulty is obtained using the following formula. :

[0107] (15)

[0108] Allocate system resources for executing subtasks, including selecting and allocating servers for subtasks according to the following criteria. In other words, it involves selecting servers for task allocation and fault rescheduling. The standard is:

[0109] (16)

[0110] In the formula, For server The expected completion time frame, As a sub-task, A set of schedulable subtasks. What does it mean?

[0111] Based on the calculations in formulas (14)-(16), we can determine on which server the current subtask should be scheduled, that is, from the set of servers. Find the optimal server node Subtasks Assigned to server Execute; and update the resource allocation matrix accordingly.

[0112] During adaptive resource allocation, the above process is repeated until all subtasks are scheduled. Specifically, it checks whether all subtasks in the current directed acyclic hypergraph have been scheduled. If not, the above process is repeated until all subtasks are scheduled. Once all subtasks are scheduled, the execution phase begins, and the subtasks are executed according to the resource allocation matrix.

[0113] The pseudocode for the adaptive resource allocation algorithm RDTDS-ARA is shown in Algorithm 2:

[0114]

[0115] During actual task scheduling and execution, servers in the edge network may fail. If no action is taken after a failure, it may lead to scheduling failures of dependent tasks or increase task execution latency. To effectively mitigate the impact of server failures, the method of this invention includes the Server Failure Rescheduling Algorithm RDTDS-SFR. Specifically, in this method, when a server failure occurs, the RDTDS-SFR algorithm is invoked to update the resource allocation matrix. This includes: identifying, from the current resource allocation matrix, class A and class B subtasks affected by the failed server during the failure execution period. Class A subtasks are the subtasks originally executed by the failed server, and class B subtasks are the subsequent subtasks corresponding to class A subtasks; rescheduling the class A and class B subtasks; and updating the resource allocation matrix.

[0116] In this embodiment, it is assumed that at a certain time frame... ,server If a malfunction occurs, then during the period of the malfunction, the reservations originally made on the server will be cancelled. Subtasks originally scheduled to run on the faulty server will be directly affected and require rescheduling. These subtasks are designated as Class A subtasks. After the resource allocation of Class A subtasks and their dependencies changes, all subsequent subtasks of Class A subtasks will be unable to execute according to the initial scheduling. These subtasks are indirectly affected and are referred to as Class B subtasks.

[0117] To reschedule subtasks of type A and type B, the resources pre-allocated to these subtasks in the resource allocation matrix must first be cleared. Similar to the initial scheduling, except that type A and type B subtasks are a subset of all subtasks of the dependent task, they are sorted according to their execution order, and resources are pre-allocated to each subtask and its corresponding data edge in turn according to the sorting result.

[0118] like Figure 6 The diagram illustrates an example of subtask rescheduling in the event of a server failure. The solid black circles represent the number of cores the server has, which represents the number of subtasks a server can execute concurrently. The white squares represent the subtasks before the failure, while the squares of other colors represent the subtasks after the resource allocation matrix has been updated. Figure 6 The left side shows the DAG of dependent tasks, and the right side shows the resource allocation matrix, which illustrates the subtasks. , , , and The resource allocation situation. The original pre-scheduling plan was: At time frame 1 implement, At time frames 3-4 implement, At time frame 3 implement, At time frame 6 implement, At time frame 8 Execution. During the actual execution of the dependent tasks, the server node... A failure occurs in time frame 2, and it is estimated that service will be restored in 5 time frames (represented by gray elliptical bars in the diagram). In this failure scenario, and The pre-assigned server malfunctioned, directly impacting all subtasks, all of which fall under category A. and Rescheduling is required. Because... yes and The precursor task, therefore After rescheduling, and It is also impossible to carry out the original plan. and Indirectly affected, it belongs to sub-task category B.

[0119] We now need to use the RDTDS-ARA algorithm to reallocate resources for subtasks of types A and B. Querying Table 1, the server's subtask execution plan, reveals that... Available on server and Execute above. Because... A malfunction occurred, so it can be Assigned to Execute on top, and for data-side tasks Link resources are reallocated. Calculations show that the transmission task execution time period is time frame 2, and the server task execution time period is time frames 3-4. Available on server , and Execute above. Because... A fault has occurred, and currently... The only idle kernel was Occupied, therefore Only can be assigned to Execution on top, similarly, is for data-side tasks. Link resources are reallocated, and the execution times of transmission and server tasks are recalculated. Then, following the same principle... In time frame 6 Execute on, Will be in time frame 8 The above is executed. For ease of distinction, the gray and red lines in the diagram represent the data transmission paths before and after the rescheduling, respectively.

[0120] The pseudocode for the Server Failure Rescheduling Algorithm RDTDS-SFR is shown in Algorithm 3:

[0121]

[0122] In edge networks, if a communication link on the transmission path fails, resources need to be reallocated for the affected subtasks and edges. Communication links are divided into backbone links in the switching network and edge links directly connected to edge servers. A failure in an edge link will render its directly connected server unavailable, equivalent to a server failure. However, if a backbone link fails, data edges can choose other links for transmission, but the available transmission bandwidth in the network will be reduced.

[0123] When a communication link failure occurs, the link failure rescheduling algorithm RDTDS-LFR is invoked to update the resource allocation matrix, specifically as follows:

[0124] If the faulty communication link is an edge link, then the edge server directly connected to the faulty edge link is taken as the faulty server, and the server fault rescheduling algorithm is called. That is, when the edge link on the transmission path fails, the server fault rescheduling algorithm can be called to handle it. The faulty server in the algorithm input is the edge server directly connected to the faulty edge link.

[0125] If the failed communication link is a backbone link, first identify the endpoint subtasks and their subsequent subtasks of the dependent edges during the failure period of the backbone link as Class B subtasks. Then, clear the resources occupied by Class B subtasks, and finally reschedule the Class B subtasks and update the resource allocation matrix. In other words, if the backbone link on the edge task transmission path fails, first calculate the set of affected subtasks. The endpoint subtasks and their subsequent subtasks of the dependent edges need to be rescheduled, as they are all indirectly affected Class B subtasks. Next, clear the resources occupied by Class B subtasks, and then reschedule the Class B subtasks.

[0126] like Figure 7 The image shows an example of subtask rescheduling in a backbone link failure scenario. The pre-scheduling of the subtask is as follows: Figure 7 As shown, however, in actual execution, the link The failure directly affected the data edge. and The execution of the transmission task, and consequently all subsequent server tasks and link transmission tasks on that link, were affected. In this failure scenario, subtasks... This becomes a subtask of type B. After clearing the resources from the faulty link, an adaptive resource allocation algorithm needs to be called to allocate resources to it. as well as and Reallocate resources. Now. This has become the task to be scheduled, and the appropriate server to assign the task needs to be selected based on the metrics. Assume... They were also redirected to the server. Next, we need to call the shortest path algorithm (we'll use Dijkstra's algorithm) to find a path from all paths to retransmit data for the corresponding dependent edges. The example graph shows the data edges after reallocation. and The corresponding transmission paths are respectively and Finally, the execution time of the transmission task and the server task is calculated.

[0127] The pseudocode for the link failure rescheduling algorithm is shown in Algorithm 4.

[0128]

[0129] To verify the effectiveness of the proposed algorithm, large-scale simulation experiments were conducted. All experiments in this embodiment were tested and evaluated using a computer configured with an Intel Core i5-10210U 2.11 GHz CPU, 16 GB RAM, and Windows 10 Home operating system, with Python 3.9 as the software environment.

[0130] Regarding parameter settings, the edge network topology for the simulation experiment was constructed using a random generation method, with the number of edge servers ranging from 5 to 10. It was assumed that all network failures encountered were short-lived. The parameter settings for the simulation experiment are shown in Table 2 below. To better compare the algorithm performance, we performed programming simulations for task execution within the edge network. By changing the task size or edge network configuration, we observed the performance metrics of different algorithms.

[0131] Table 2 Experimental Parameter Settings

[0132]

[0133] This invention evaluates the performance of task scheduling algorithms through extensive experiments. The following sections primarily analyze three performance metrics: task completion time under fault-free conditions, the number of faults during task execution, and task completion time under fault conditions.

[0134] The task completion time refers to the time when all dependent tasks in the network have been completed, i.e., the time frame when the last exit subtask in the network is completed. Task completion time can be divided into two cases: no-fault and fault-prone. In the ideal, fault-free scenario, the execution process is consistent with the initial scheduling result, and the resulting completion time frame is the task completion time under fault-free conditions. Conversely, in reality, servers or links often experience failures. After a failure, execution will follow the rescheduling result, thus yielding the task completion time under fault-prone conditions.

[0135] The failure count refers to the number of times the edge network fails during task execution; it is the sum of server failures and link failures. The failure count measures the reliability and stability of the scheduling algorithm, and its calculation formula is as follows:

[0136] (17)

[0137] in, Indicates the number of failures. Indicates the first Number of server failures Indicates the first The number of failures on each link.

[0138] First, the RDTDS algorithm used in this embodiment is compared with the traditional Topology-sorting based Static Scheduling Algorithm (TSSA). The TSSA algorithm first performs a topology sort on the tasks, and then allocates resources to each task according to the sorted order. The experimental results are compared below:

[0139] Regarding the impact of the number of subtasks: In the same edge network, when the number of subtasks increases from 10 to 20, we observe the changing trends of three performance metrics when scheduling is performed using TSSA and RDTDS respectively. The experimental results are as follows: Figure 8 As shown, where, Figure 8 (a) Comparison of fault-free task completion times for TSSA and RDTDS. In the fault-free scenario, the completion time frame of the exit subtask shows an observable increasing trend as the number of subtasks increases. This phenomenon is attributed to two main factors. First, as the number of subtasks increases, the total computational workload of the task also increases, leading to a longer task completion time frame. Second, the increase in the number of subtasks leads to more frequent resource contention, and tasks must wait for server and link resources to become available. These two factors work together to extend the completion time frame of the exit subtask. Experimental results show that the similarity of the two algorithms in the exit subtask completion time frame can be attributed to the similarity of the scheduling order generated by the two algorithms in our experimental DAG. Figures 8(b) and 8(c) show the experimental results under fault conditions. Specifically, Figure 8 (b) Comparison of the number of failures for TSSA and RDTDS. Figure 8 (c) Comparison of task completion time under TSSA and RDTDS failure conditions. Experimental results show that, in the presence of failures, RDTDS-ARA has fewer failures and shorter task completion time compared to TSSA. This can be attributed to the fact that when a failure occurs, RDTDS prioritizes scheduling critical tasks to servers with lower failure rates, thereby reducing the number of failures and task completion time.

[0140] Regarding the impact of link bandwidth: In the same edge network, when using TSSA and RDTDS for scheduling, as the link bandwidth increases from 300Mbps to 1200Mbps, the trends of three performance indicators were observed, as shown in the following figures. Figure 9 As shown. Figure 9 (a) Comparison of fault-free task completion time for TSSA and RDTDS. Figure 9The results shown in (a) indicate that, in a fault-free scenario, the task completion time of both algorithms decreases continuously with the increase of link bandwidth. This is mainly because the increase in link bandwidth reduces transmission time overhead, resulting in a shorter completion time frame for the egress subtask. During this stage, TSSA and RDTDS produce almost identical scheduling sequences, leading to substantially the same completion time for the egress subtask. Figure 9 (b) Comparison of the number of failures for TSSA and RDTDS. Figure 9 (c) Comparison of task completion times under TSSA and RDTDS failure conditions. Figure 9 (b) and Figure 9 Experimental results in (c) show that, under fault scenarios, both the number of faults and task completion time decrease continuously with the increase of link bandwidth. The increase in link bandwidth reduces transmission time overhead, thereby shortening task completion time and simultaneously reducing the number of faults. After the bandwidth change, TSSA maintains a consistent task execution order, while RDTDS prioritizes tasks that complete earlier in their predecessor tasks. Therefore, RDTDS exhibits better performance in terms of both the number of faults and task completion time.

[0141] Resource allocation algorithm comparison experiment

[0142] Secondly, the performance of the adaptive resource allocation algorithm described in this embodiment in an edge computing environment is evaluated through a series of experiments, and compared with the following four benchmark resource allocation algorithms.

[0143] Random selection algorithm: Randomly assigns tasks to edge servers from the set of available edge servers for execution, without considering latency or failure-related factors.

[0144] The Latency-based Selection Algorithm (LSA) selects edge servers with task latency as the sole optimization objective, without considering server failure scenarios.

[0145] The Failure-based Selection Algorithm (FSA) focuses only on the historical number of server failures, prioritizing the server with the fewest failures for task execution, while ignoring task latency.

[0146] Latency-Failures-Tradeoff-based Selection Algorithm (LFTSA): This algorithm comprehensively considers the task completion time frame. ) and expected number of server failures ( The edge server is selected based on a weighting coefficient. The LFTSA algorithm considers the following formula to select edge servers:

[0147] (18)

[0148] In the formula, This indicates that the subtask is on the server. The completion time frame. Indicates server The expected number of failures when executing this subtask. The weighting coefficients represent a trade-off between the importance of control delay and faults. The LFTSA algorithm sets the weight values. The value is set to 0.5 to balance the delay and the number of failures.

[0149] The adaptive resource allocation algorithm described in this embodiment is compared and analyzed with the four algorithms mentioned above in terms of the impact on link bandwidth and the number of dependent tasks. The analysis results are as follows:

[0150] Regarding the impact of link bandwidth, the experiment compared the performance trends of the adaptive resource allocation algorithm of this invention with four benchmark algorithms under different link bandwidths. The link bandwidth increased from 300Mbps to 1200Mbps, and each dependent task contained 10 subtasks. The experimental results are as follows: Figure 10 As shown. The task completion time results under a fault-free scenario are as follows. Figure 10 As shown in (a), increasing link bandwidth leads to a continuous decrease in task completion time. The main reason is that greater bandwidth results in lower data transmission time. In a fault-free scenario, the LSA algorithm achieves the lowest task completion time because it uses latency as the sole optimization objective, followed by the RDTDS algorithm proposed in this paper. The random algorithm exhibits the worst performance and is the most unstable. In a fault-prone scenario, the number of faults is compared, as shown in... Figure 10 As shown in (b), the number of failures decreases slowly with increasing link bandwidth. The FSA algorithm prioritizes the server with the fewest failures to execute tasks, thus minimizing the number of failures. The LFTSA algorithm and the proposed RDTDS algorithm both have relatively few failures, while LSA and random algorithms have the most failures. The proposed RDTDS algorithm comprehensively considers latency and the number of failures for adaptive resource allocation and can quickly reschedule tasks when failures occur, thus achieving the optimal task completion time. Experimental results are shown in [figure missing]. Figure 10 As shown in (c).

[0151] Regarding the impact of the number of dependent tasks, the performance trends of different resource allocation algorithms under different numbers of dependent tasks were tested. The number of dependent tasks increased from 3 to 10, with each dependent task containing 10 subtasks. The experimental results are as follows: Figure 11 As shown. In a fault-free scenario, the fault-free task completion time is as follows: Figure 11 As shown in (a), the task completion time increases with the number of dependent tasks. The LSA algorithm has the lowest task completion time because it selects the edge server with the shortest task execution time to complete the task. The RDTDS algorithm proposed in this paper also shows good performance, with a task execution time second only to the LSA algorithm. Experimental results under fault scenarios are as follows: Figure 11 (b) and Figure 11 As shown in (c) Figure 11 (b) represents the number of failures. Figure 11 (c) This represents the task completion time under fault conditions. As the number of dependent tasks increases, both the number of faults and the task completion time increase. The FSA algorithm has the fewest faults, but its task completion time is longer than the RDTDS algorithm proposed in this paper. The random algorithm and LSA algorithm both have relatively high fault numbers and task completion times. The RDTDS algorithm proposed in this paper can adaptively allocate available edge servers and link resources to affected dependent tasks under fault scenarios, thus achieving the lowest task completion time.

[0152] In summary, this invention addresses the robust dependency task scheduling problem in fault-recoverable mobile edge computing. First, it establishes a cloud-edge-device system model and a dependency task model. Then, it uses a resource allocation matrix to represent network resource occupancy. The RDTDS algorithm employs a dynamic task scheduling strategy and an adaptive resource allocation strategy, thereby achieving robust dependency task scheduling based on the real-time network status and the data dependencies between tasks, effectively optimizing task completion time in both fault-free and fault-free scenarios.

[0153] Unlike existing technologies, RDTDS can dynamically adjust the execution order of subtasks based on the real-time status of the edge network. It also takes into account various system factors such as server failure rate, task execution time, and communication link transmission time. By introducing a DAG hypergraph, resource allocation matrix, and expected task completion time, it adaptively allocates system resources to tasks, thereby enhancing the robustness and effectiveness of task scheduling in the event of a failure.

[0154] This invention considers a system model under conditions of simultaneous server and link failures, and constructs a dependent task model based on DAG. Based on the idea of ​​software-defined networking, it proposes the concept of a resource allocation matrix and uses the resource allocation matrix to finely characterize the system resource usage, formally describe the robust dependent task scheduling problem, and optimize the task completion time.

[0155] To address the RDTS problem, this invention proposes an adaptive resource allocation algorithm, RDTDS-ARA, based on a resource allocation matrix. Specifically, this invention first constructs a directed acyclic hypergraph to achieve efficient scheduling of multi-dependent tasks. Then, based on the real-time resource usage of the system, it dynamically determines the scheduling order of subtasks. It introduces a failure rate calculation to determine the expected completion time frame, balancing the advantages and disadvantages of different server resources. Adaptive resource allocation is then performed based on the resource allocation matrix. Finally, when a server or link fails, the affected subtasks are rescheduled, thereby simultaneously improving the robustness and effectiveness of the system.

[0156] Experimental results show that, in terms of task scheduling, this invention achieves similar task completion times to the static scheduling algorithm under fault-free conditions, and in the event of faults, it has fewer faults and shorter task completion times than the static scheduling algorithm. Regarding resource allocation, compared to the four benchmark algorithms, this invention achieves a lower number of faults and the lowest task completion time. These results verify the robustness and effectiveness of this invention.

[0157] The above embodiments are merely illustrative of the principles and effects of the present invention and are not intended to limit the invention. Any person skilled in the art can modify or alter the above embodiments without departing from the spirit and scope of the present invention. Therefore, all equivalent modifications or alterations made by those skilled in the art without departing from the spirit and technical concept disclosed in the present invention should still be covered by the claims of the present invention.

Claims

1. A robust dependency task scheduling method for fault-recoverable mobile edge computing, characterized in that, include: Obtain the parameters of the mobile edge computing system, including the set of dependent tasks. Edge network Number of available CPU cores on the server Kernel processing capabilities and link bandwidth ; An adaptive resource allocation algorithm is invoked based on system parameters to dynamically determine the scheduling order of subtasks and allocate the system resources required for the execution of subtasks, thereby obtaining a resource allocation matrix. Execute subtasks based on the resource allocation matrix; When a server failure occurs, the server failure rescheduling algorithm is invoked to update the resource allocation matrix; When a communication link failure occurs, the link failure rescheduling algorithm is invoked to update the resource allocation matrix; Then execute subtasks according to the updated resource allocation matrix until all exit subtasks have been executed; Obtain the execution completion time frames of all dependent tasks.

2. The method according to claim 1, characterized in that, Adaptive resource allocation algorithms include: Step 1: Based on the set of dependent tasks Construct a directed acyclic graph or a directed acyclic hypergraph; Step 2: Initialize the resource allocation matrix, obtain the available resources in the system, and dynamically update the resource allocation matrix according to the actual operating status and resource requirements of the system; Step 3: Select and schedule subtasks according to the principle of prioritizing the subtasks with the earliest completion time. Then, based on the scheduling order of the selected subtasks, allocate system resources for executing the subtasks and update the resource allocation matrix synchronously. Step 4: Repeat step 3 until all subtasks have been scheduled.

3. The method according to claim 2, characterized in that, Select priority scheduling subtasks The formula is: In the formula, A set of schedulable subtasks. For subtasks The earliest completion time, What does it mean? 4. The method according to claim 2, characterized in that, Allocate system resources for executing subtasks, including selecting and allocating servers for subtasks according to the following criteria. : In the formula, For server The expected completion time frame, As a sub-task, This is the set of schedulable subtasks.

5. The method according to claim 4, characterized in that, The expression is: In the formula, Indicates the start time of the task; This indicates that on the server The task was completed without any problems. The time; among which, Indicates on the server Complete the task without any faults. Time required; Indicates time frame At that time, the server The probability of failure. Indicates server The current time, Indicates a time frame; This represents the probability of completing the task without any failures. This indicates the time required for task rescheduling and recovery in the event of a failure. Indicates server Execute the task At that time, the data collection time before rescheduling after a failure. Indicates server exist After a time frame failure, the task The shortest completion time after rescheduling; This indicates another time frame.

6. The method according to claim 5, characterized in that, The expression is: In the formula, express?, express?, ? 7. The method according to claim 2, characterized in that, When there are multiple dependent tasks waiting for resource allocation, multiple interdependent tasks can be merged by adding virtual worker nodes with zero resource requirements to construct a directed acyclic hypergraph.

8. The method according to claim 1, characterized in that, The server failure rescheduling algorithm is invoked to update the resource allocation matrix, specifically including: From the current resource allocation matrix, find the subtasks of type A and type B that were affected by the faulty server during the fault execution period. Subtasks of type A are the subtasks that were originally executed by the faulty server, and subtasks of type B are the subsequent subtasks that correspond to the subtasks of type A. Reschedule subtasks of type A and type B and update the resource allocation matrix.

9. The method according to claim 8, characterized in that, Rescheduling of subtasks of type A and type B includes: Clear the resources pre-allocated in the resource allocation matrix for subtasks of type A and type B; Sort the subtasks of type A and type B in the order of execution; Resources are pre-allocated to each subtask and its corresponding data edge according to the sorting results.

10. The method according to claim 1, characterized in that, The link failure rescheduling algorithm is invoked to update the resource allocation matrix, specifically including: If the faulty communication link is an edge link, then the edge server directly connected to the faulty edge link is regarded as the faulty server, and the server fault rescheduling algorithm is invoked. If the faulty communication link is a backbone link, first find the endpoint subtask and its subsequent subtasks of the dependency edge during the faulty backbone link's fault time as Class B subtasks. Clear the resources used by subtasks of type B; Reschedule the B-type subtasks and update the resource allocation matrix.

Images