Satellite-borne safety-critical software distributed multitasking self-organizing scheduling method

Abstract

A distributed multi-task self-organizing scheduling method for spaceborne safety-critical software is proposed. Based on classic distributed scheduling algorithms, and considering the relatively high safety-criticality requirements of spaceborne systems and the dynamic changes in tasks, an extended weighted directed acyclic graph model is established to achieve multi-point mapping of safety-critical tasks. At the same time, methods such as idle slot insertion and related task scheduling time reallocation are adopted to rationally allocate dynamically changing tasks to corresponding computing nodes while maintaining the current multi-node allocation state of tasks. This ensures the reliable operation of safety-critical tasks and ensures the real-time operation of new tasks without affecting the operation status of existing tasks.

Description

Technical Field

[0001] This invention belongs to the field of spaceborne mission scheduling and relates to a scheduling method for multiple safety-critical software tasks in complex distributed spaceborne systems. Background Technology

[0002] As the complexity of spacecraft space application missions continues to increase and computing capabilities expand, spacecraft computing information systems are developing towards a distributed and integrated approach. Representative integrated electronic systems for spacecraft abroad include Astrium's Alphabus communication satellite platform, the Orion spacecraft's electronic system, and the Space Integrated Electronic Open Interface Architecture (SAVOIR) currently under development by ESA. Based on this architecture, the software corresponding to spacecraft space application functions will no longer be fixed on specific terminals, but will be scheduled and allocated to computing nodes by the onboard operating system in the form of tasks. Task allocation and scheduling mechanisms, as one of the standard services of the onboard operating system, mainly study how to rationally allocate the tasks to be executed to appropriate computing nodes based on mission requirements, system composition, and system status, thereby optimizing the overall satellite system's task computing speed, system reliability, and overall energy consumption.

[0003] Task scheduling is a fundamental problem in distributed computing. Based on the existence of dependencies between scheduled tasks, task scheduling can be divided into independent task scheduling and dependent task scheduling. Dependent tasks consist of a group of multiple tasks that have both sequential data transfer constraints and parallel relationships. This problem is generally modeled using a weighted directed acyclic graph (DAG). Currently, many DAG task scheduling methods have been proposed, employing different scheduling techniques and addressing the problem from different perspectives. A brief summary is as follows:

[0004] (1) First-in-first-out task scheduling algorithm

[0005] The algorithm uses the order in which tasks arrive as the scheduling order, allocating the fastest computing resources to the current task. While the algorithm's logic is clear and scheduling is easy, it doesn't fully consider task and computing resource priorities, lacks parallelism, and its execution time and complexity increase rapidly when the workload is large.

[0006] (2) Min-Min task scheduling algorithm

[0007] The Min-Min task scheduling algorithm is a fast task scheduling strategy. Its basic idea is to prioritize assigning smaller tasks to resources with the shortest execution time, aiming to minimize the execution time of individual tasks. The algorithm works by mapping subtasks to resources and calculating their completion times, identifying the earliest completion time and corresponding resource for each subtask, then assigning the task with the earliest completion time. Once completed, the task is removed from the task set. This process is repeated until the task set is empty. While this algorithm uses time as the sole weight and guarantees the shortest task execution time, it also results in smaller tasks or high-capacity resources being constantly active, while other tasks or resources remain idle for extended periods.

[0008] (3) Max-Min task scheduling algorithm

[0009] The Max-Min task scheduling algorithm is mainly designed for long tasks. It schedules long tasks to the resource with the shortest execution time first. This algorithm has good load balancing performance when the execution time of tasks varies greatly. Its scheduling process is basically similar to that of the Min-Min task scheduling algorithm, so the problems it has are also similar.

[0010] (4) DSH task scheduling algorithm

[0011] The Duplication Scheduling Heuristic (DSH) algorithm is based on a task replication scheduling algorithm. The algorithm works as follows: each computing resource processes one current computational task. When a task finishes and the next task begins, there is a time gap. The preceding task is continuously replicated into this time gap until no more tasks can be replicated. This algorithm has relatively high time and space consumption, making its practical application difficult.

[0012] Building upon this foundation, other related scheduling algorithms have continuously emerged. Based on whether the attributes of the DAG graph can be obtained in advance, algorithms for solving scheduling problems are categorized into static and dynamic scheduling algorithms. According to the actual environment of distributed computing, they can be divided into algorithms for homogeneous and heterogeneous environments. From a heuristic strategy perspective, these include priority list-based scheduling (such as HEFT, CPOP, and DCPD), cluster-based scheduling, and task replication-based scheduling. Some of these algorithms have been successfully applied to practical workflow scheduling systems such as grid computing and cloud computing. For example, the heterogeneous distributed computing system DAG task scheduling model proposed by Topcuoglu.H in 2002, along with its famous HEFT scheduling algorithm, has been practically applied in the ASKALON grid workflow system.

[0013] However, the schedulability analysis of the above-mentioned algorithms is generally based on specific assumptions. These assumptions often prove difficult to adapt to actual operating conditions. The most typical conditions include the following:

[0014] (1) Safety-critical tasks: In spacecraft software, some tasks are of very high safety-critical level. To ensure the correctness of these tasks, relevant reliability measures are generally taken, such as multi-machine synchronous operation and result comparison. That is, the corresponding task will be operated synchronously by multiple nodes at the same time. This requirement has not been considered in classic algorithms.

[0015] (2) Task execution continuity: All classic algorithms currently focus only on the optimal allocation of tasks and do not pay attention to the task execution continuity problem. Embedded system tasks have sequential continuity. The process of task execution involves variables, memory states, register contexts, etc. The process of migrating a task to other running nodes is very complex and even impossible. Therefore, once a task is running on a certain node, it is generally not periodically reallocated according to the allocation algorithm.

[0016] Based on the above analysis, it can be seen that existing typical task scheduling algorithms are not suitable for systems with relatively high safety criticality, such as spaceborne systems. Summary of the Invention

[0017] The technical problem solved by this invention is to overcome the shortcomings of existing technologies and provide a distributed multi-task self-organizing scheduling method for spaceborne safety-critical software. Based on classic distributed scheduling algorithms (such as HEFT, CPOP, and DCPD), and considering the relatively high safety-criticality requirements of spaceborne systems and the dynamic changes in tasks, this invention establishes an extended weighted directed acyclic graph model to achieve multi-point mapping of safety-critical tasks. Simultaneously, it employs methods such as idle slot insertion and associated task scheduling time reallocation to rationally allocate dynamically changing tasks to corresponding computing nodes while maintaining the current multi-node allocation state of tasks. This ensures the reliable operation of safety-critical tasks and guarantees the real-time operation of new tasks without affecting the existing task status.

[0018] The technical solution of this invention is: a distributed multi-task self-organizing scheduling method for spaceborne safety-critical software, comprising the following steps:

[0019] (1) Based on the functions of the spacecraft software system and the set of tasks it contains, construct a weighted directed acyclic graph model;

[0020] (2) By identifying high-security-critical tasks in the task set and the number of processor nodes required for synchronous operation of these tasks, the weighted directed acyclic graph model of the task set is improved into an extended weighted directed acyclic graph model; the improvement method is as follows:

[0021] (21) Based on the number of processor nodes B required to run synchronously for a high safety criticality task, the high safety criticality task is expanded from a single processor node to be executed by B processor nodes.

[0022] (22) The B processor nodes mentioned above have the same task attribute information as the originally allocated single processor node;

[0023] (23) The B processor nodes mentioned above have the same set of predecessor tasks pred(i) and set of successor tasks succ(i) as the original single processor node.

[0024] (3) Calculate the rank value rank(i) of each task i in the task set, and sort the tasks in descending order according to the rank value; the rank value is calculated as follows:

[0025]

[0026] in w represents the average execution time of task i. i,j C(i,j) represents the computation time of task i on node j, and C(i,j) represents the transmission delay required to transfer the data of the predecessor task to the successor task when task i and task j are assigned to different processor nodes. The horizontal line above indicates that the average value is calculated.

[0027] (4) According to the sorting result obtained in step (3), take out each task i in turn and calculate the earliest end time EFT(i,j) of task i running on each node j.

[0028] (5) Sort the EFT(i,j) values ​​obtained in step (4) in ascending order, select the minimum EFT(i,j) value, and at the same time determine whether the task sequence already assigned on the processor node j corresponding to the minimum EFT(i,j) value contains a task that is an extension of the same high security criticality task as task i. If not, assign task i to processor node j. If so, select the next combination from the EFT(i,j) sequence and repeat the judgment in this step until task i is assigned to a specific node, and ensure that tasks extended from the same high security criticality task are assigned to different processor nodes.

[0029] (6) Return to step (4) to continue assigning other tasks in the task set until all tasks in the task set have been assigned.

[0030] Furthermore, the extended weighted directed acyclic graph model is represented as follows:

[0031] G = (V, E, P, T, C, S)

[0032] The attributes of each element in the model are as follows:

[0033] V = {1, 2, ..., n} represents the set of tasks, where n is the number of tasks;

[0034] E = {(i,j):(i,j∈V); i→j} represents the set of constraint edge relations, indicating that task j depends on task i;

[0035] P = {1, 2, ..., m}, is the set of available processors, where m represents the number of available processors;

[0036] T is a two-dimensional matrix represented by n*m. For i∈V and p∈P, T(i,p) represents the computational cost required for task i on processor p.

[0037] C represents an n*n two-dimensional matrix. For i∈V, j∈V and (i,j)∈E, then C(i,j) represents the transmission delay required to transmit the data of the predecessor to the successor task when task i and task j are assigned to different processor nodes.

[0038] S = {(i,j):(i,j∈V);} indicates that task i and task j belong to the same high-security-critical task extension and have the same state.

[0039] pred(i) = {j∈E} represents the set of predecessor tasks of i;

[0040] succ(i) = {j∈E} represents the set of successor tasks for i.

[0041] Furthermore, the earliest completion time EFT(i,j) of the computation task i running on each node j is specifically:

[0042] EFT(i,j)=w i,j +EST(i,j)

[0043] in:

[0044]

[0045] avail[j] is the earliest time that processor j is available, and AFT(k) is the actual end time of task k.

[0046] Furthermore, in step (5), if the task sequence already allocated on processor j corresponding to the minimum value of EFT(i,j) contains a task extended from the same high-security-critical task as task i, then the maximum value in the EFT(i,j) sort is selected as the unified EFT value for the high-security-critical task and its extended tasks, and then combined with the actual execution time w of each task on different processor nodes. i,j Determine the start time of each task on each processor node: EST(i,j) = EFT(i,j) - w i,j .

[0047] Furthermore, if there is a need to inject a new task x during task scheduling, the set of predecessor tasks of the new task x and the running time w of the new task x on the corresponding processor node j are obtained first. x,j The earliest start time (EST) of the task on each processor node is calculated. Using this EST as a reference, the time difference (dt(x,j)) between this time and the most recent task scheduling start time on the current processor node (j) is determined within the task queues allocated to each processor node. If dt(x,j) > w x,j If task x is inserted into a free slot on the current node j, then if multiple processor nodes can insert task x, then calculate the free slots on each processor node j and the processing time w of task x on that node. x,j The difference dt(x,j)-w x,j Sort the differences and select the processor node with the largest difference for task insertion;

[0048] If the idle slot time on any relevant processor node is less than the execution time w of task x x,j Then calculate the processing time w of task x at the relevant nodes. x,j The difference w between the free slot segments of each associated processor node j x,j -dt(x,j) sorts the differences and selects the processor node with the largest difference for task insertion. Simultaneously, subsequent tasks on that node, as well as related tasks on other nodes, are scheduled to be shifted back by a time interval w. x,j -dt(x,j).

[0049] Furthermore, if there is a need to delete a task during task scheduling, the corresponding task will be deleted directly based on the currently completed task allocation and scheduling sequence, while the scheduling time and allocated processor node for other tasks will remain unchanged.

[0050] The advantages of this invention compared to the prior art are:

[0051] (1) The method of the present invention comprehensively considers the reliability requirements of safety-critical task allocation, scheduling and operation status in software. By designing an extended weighted directed acyclic graph model, while ensuring the real-time performance of task scheduling, the safety-critical task can be synchronously allocated to multiple suitable computing nodes according to the operation requirements, so that the task can run synchronously and concurrently on multiple nodes and output the calculation results synchronously. This provides a basis for subsequent comparison and confirmation of the task's operation results, ensuring the availability of the next step of calculation input. It is suitable for application fields with high reliability and high safety requirements such as spacecraft.

[0052] (2) The method of the present invention takes into account the need for the continuity of software task operation in the embedded environment. By adopting methods such as idle slot insertion and related task scheduling time reallocation, while maintaining the current multi-node allocation state of the task, the dynamically changing task is reasonably allocated to the corresponding computing node. This ensures that the original task operation state is not affected and adjusts the system task operation state in real time. It avoids the overhead of task migration, task state saving and restoration caused by the overall rescheduling of tasks during the system task state adjustment process, which is conducive to the stable operation of the system. Attached Figure Description

[0053] Figure 1 This is a diagram of the extended weighted directed acyclic graph model of the present invention;

[0054] Figure 2 This is a schematic diagram of the present invention based on the insertion of idle slot segments and the redistribution of associated task scheduling time. Detailed Implementation

[0055] The specific implementation steps of this invention will be further described in detail below, taking into account the current on-orbit application requirements of spacecraft.

[0056] The main steps of the method of the present invention are as follows:

[0057] (1) Based on the functions of the spacecraft software system and the set of tasks it contains, a basic weighted directed acyclic graph (DAG) model is constructed:

[0058] G = (V, E, P, T, C)

[0059] The specific attributes of each element in the model are described as follows:

[0060] V = {1, 2, ..., n} represents the set of tasks, where n is the number of tasks;

[0061] E = {(i,j):(i,j∈V); i→j} represents the set of constraint edge relations, indicating that task j depends on task i;

[0062] P = {1, 2, ..., m}, is the set of available processors, where m represents the number of available processors;

[0063] T is a two-dimensional matrix represented by n*m. For i∈V and p∈P, T(i,p) represents the computational cost required for task i on processor p.

[0064] C represents an n*n two-dimensional matrix. For i∈V, j∈V and (i,j)∈E, then C(i,j) represents the transmission delay required to transfer the data of the predecessor to the successor task when task i and task j are assigned to different processors.

[0065] pred(i) = {j∈E} represents the set of predecessor tasks of i;

[0066] succ(i) = {j∈E} represents the set of successor tasks for i;

[0067] (2) By identifying high-security-critical tasks in the task set and the number of processor nodes required for such tasks to run synchronously, the basic weighted directed acyclic graph in step (1) is improved into an extended weighted directed acyclic graph model, such as... Figure 1 As shown, each node in the graph represents a task within the software system, the connections between nodes represent the order in which tasks are executed, and the connection value represents the communication overhead between two tasks. The construction principles of the extended weighted directed acyclic graph model are as follows:

[0068] First, for high-security-critical task nodes, the task node is expanded to the corresponding number of task nodes based on the number of processor nodes that need to run synchronously.

[0069] Second, the task nodes extended from high safety-critical tasks have the same task attribute information as the original task nodes, including the T and C attributes in the DAG model.

[0070] Third, the task nodes extended from high-safety-critical tasks have the same set of predecessor tasks and successor tasks as the original task nodes.

[0071] like Figure 1 As shown, assuming that task 8 is a safety-critical task, in the extended weighted directed acyclic graph model, task 8 is extended into three task nodes 8(a), 8(b), and 8(c) according to the above construction principles.

[0072] (3) Based on the extended weighted directed acyclic graph model, reconstruct G = (V, E, P, T, C, S) and the elements in model G. The extended weighted directed acyclic graph model adds an element S, S = {(i, j): (i, j ∈ V);}, indicating that task i and task j belong to the same high-security-critical task extension and their states are consistent.

[0073] (4) Calculate the task ranking value rank(i) according to the task set V, and sort the tasks in descending order. The task ranking value is defined as follows:

[0074]

[0075] in: w represents the average execution time of task i. i,j This represents the computation time of task i on node j. In the DAG, the average computation time is used as the weight of the task node. C(i,j) represents the transmission delay required to transfer the data of the predecessor task to the successor task when task i and task j are assigned to different processors. The horizontal line above indicates that the average value is calculated.

[0076] (5) According to the descending sorting result of the task set obtained in step (4), take out task i in turn and calculate the earliest end time EFT(i,j) of the task running on each node j.

[0077] EFT(i,j)=w i,j +EST(i,j)

[0078] in:

[0079]

[0080] avail[j] is the earliest time processor j is available, and AFT(k) is the actual end time of task k. For the entry task, its EST is 0, and its AFT is its processing time on the corresponding processor.

[0081] (6) Sort the sequence of earliest end times (EFT(i,j)) of task i on each node j in ascending order according to the sequence obtained in step (5), where j∈P. Select the minimum value of EFT(i,j) and determine whether the task sequence already assigned on the current processor j contains a task that is an extension of the same high security criticality task as task i. If not, assign task i to processor node j; if so, select the next combination from the EFT(i,j) sequence and repeat this step until task i is assigned to a specific node, and ensure that tasks extended from the same high security criticality task can be assigned to different processor nodes. After task i is assigned, update the actual end time (AFT(i)) of task i and the earliest available time (avail[j]) of the corresponding processor node j.

[0082] (7) To ensure the synchronous execution of tasks extended from the same high-security-critical task, based on the EFT values ​​corresponding to the allocated tasks after allocation calculated in step (6), the maximum EFT value is selected as the unified EFT value for the high-security-critical task and its extended tasks. This ensures that multiple tasks extended from the same high-security-critical task are completed at the same time. This is further combined with the actual execution time w of each task on different processor nodes. i,j Determine the start time EST(i,j) for each task on each processor.

[0083] EST(i,j)=EFT(i,j)-w i,j

[0084] (8) Return to step (5) to continue assigning other tasks in the task set until all tasks in the task set have been assigned.

[0085] (9) If a new task x needs to be injected during system operation, the system first obtains the set of predecessor tasks of the task and the running time w of the task on the corresponding processor node j. x,j The earliest start time (EST) of the task on each processor is calculated. Using this EST as a reference, the time difference (dt(x,j)) between this time and the start time of the most recent task scheduling on the current processor node j is determined within the task queues allocated to each processor node. This time difference represents the available slots. If dt(x,j) > w x,j If so, task x is inserted into an empty slot on the current node j.

[0086] If multiple processor nodes are available to insert task x, then calculate the number of free slots on each processor node j and the processing time w of task x on that node. x,j The difference dt(x,j)-w x,j The differences are sorted, and the processor node with the largest difference is selected for task insertion.

[0087] If the idle slot time on any relevant processor node is less than the execution time w of task x x,j Then calculate the processing time w of task x at the relevant nodes. x,j The difference w between the free slot segments of each associated processor node j x,j -dt(x,j) sorts the differences and selects the processor node with the largest difference for task insertion. Simultaneously, subsequent tasks on that node, as well as related tasks on other nodes, undergo unified scheduling time reallocation, using an overall time shift to the next node by w. x,j -dt(x,j).

[0088] like Figure 2 As shown, Task 9 is inserted directly into an empty slot. After Task A is inserted, the scheduling time of all tasks related to the insertion point and tasks of other processor nodes related to it is postponed.

[0089] (10) If there is a need to delete a task during system operation, the corresponding task will be deleted directly based on the currently completed task allocation and scheduling sequence, while the scheduling time and allocated processor node for other tasks will remain unchanged. For example... Figure 2 As shown, task 4 has no effect on other tasks after it is deleted.

[0090] The contents not described in detail in this specification are common knowledge to those skilled in the art.

Claims

1. A distributed multi-task self-organizing scheduling method for spaceborne safety-critical software, characterized in that... Includes the following steps: (1) Based on the functions of the spacecraft software system and the set of tasks it contains, construct a weighted directed acyclic graph model; (2) By identifying high-security-critical tasks in the task set and the number of processor nodes required for synchronous operation of these tasks, the weighted directed acyclic graph model of the task set is improved into an extended weighted directed acyclic graph model; the improvement method is as follows: (21) Based on the number N of processor nodes required to run synchronously for a high security critical task, the high security critical task is expanded from a single processor node to be executed by N processor nodes. (22) The N processor nodes mentioned above have the same task attribute information as the originally allocated single processor node; (23) The N processor nodes have the same predecessor task set pred(i) and successor task set succ(i) as the original single processor node; (3) Calculate the ranking value rank(i) of each task i in the task set, and sort the tasks in descending order according to the ranking value. The ranking value is calculated as follows: in Let i be the average execution time of task i. This represents the computation time of task i on processor node j. This represents the transmission delay required to transfer data from the predecessor task to the successor task when tasks i and k are assigned to different processor nodes. The horizontal line above indicates that the average value is calculated. m is the number of available processors. (4) According to the sorting result rank(i) obtained in step (3), take out the earliest end time of task i running on each processor node j, and define it as EFT(i,j); (5) Sort the EFT(i,j) values ​​obtained in step (4) in ascending order, select the minimum EFT(i,j) value, and at the same time determine whether the task sequence already assigned on the processor node j corresponding to the minimum EFT(i,j) value contains a task that is an extension of the same high security criticality task as task i. If not, assign task i to processor node j. If so, select the next combination from the EFT(i,j) sequence and repeat step (5) until task i is assigned to a specific processor node, and ensure that tasks extended from the same high security criticality task are assigned to different processor nodes. (6) Return to step (4) to continue assigning other tasks in the task set until all tasks in the task set have been assigned.

2. The distributed multi-task self-organizing scheduling method for spaceborne safety-critical software according to claim 1, characterized in that: The extended weighted directed acyclic graph model is represented as follows: G = (V, E, P, T, C, S) The attributes of each element in the model are as follows: V = {1, 2, ..., n} represents the set of tasks, where n is the number of tasks; E={(i, k):(i, k∈V); i→k}, represents the set of constraint edge relations, indicating that task k depends on task i; P = {1, 2, …, m}, is the set of available processors, where m represents the number of available processors. T is a two-dimensional matrix represented by n*m. For i∈V and p∈P, T(i, p) represents the computational cost required for task i on processor node p. C represents an n*n two-dimensional matrix. For i∈V, k∈V and (i, k)∈E, then This represents the transmission delay required to transfer data from the predecessor task to the successor task when task i and task k are assigned to different processor nodes. S={(a,b):(a,b∈V);} indicates that task a and task b belong to the same high-security-critical task extension and have the same state. pred(i) = {k: (k,i)∈E} represents the set of predecessor tasks of i; succ(i)={k:(i, k)∈E} represents the set of successor tasks of i.

3. The distributed multi-task self-organizing scheduling method for spaceborne safety-critical software according to claim 2, characterized in that: The earliest end time EFT(i,j) of the computation task i running on each processor node j is specifically: in: avail[j] is the earliest time that processor node j is available, and AFT(k) is the actual end time of task k.

4. The distributed multi-task self-organizing scheduling method for spaceborne safety-critical software according to claim 3, characterized in that: In step (5), if the task sequence already allocated on processor node j corresponding to the minimum value of EFT(i,j) contains a task extended from the same high-security-critical task as task i, then the maximum value in the EFT(i,j) sort is selected as the unified EFT value for the high-security-critical task and its extended tasks, and then combined with the actual execution time of each task on different processor nodes. Determine the start time of each task on each processor node. .

5. The distributed multi-task self-organizing scheduling method for spaceborne safety-critical software according to claim 4, characterized in that: If a new task x needs to be injected during task scheduling, the set of predecessor tasks of the new task x and the running time of the new task x on the corresponding processor node j are obtained first. The earliest start time (EST) of the task on each processor node is calculated. Using this EST time series as a reference, the time difference (dt(x,j)) between this time and the most recent task scheduling start time on the current processor node j is determined from the task queues already allocated to each processor node. If... If so, task x is inserted into an empty slot on the current processor node j; If multiple processor nodes are capable of inserting task x, then calculate the number of free slots on each processor node j and the processing time of task x on that processor node. The difference Sort the differences and select the processor node with the largest difference for task insertion; If the idle slot time on any relevant processor node is less than the execution time of task x Then the processing time of task x on the relevant processor node is... The difference between the free slot segments of each relevant processor node j Sort the differences and select the processor node with the largest difference for task insertion. Simultaneously, subsequent tasks on that processor node, as well as related tasks on other processor nodes, are scheduled to be shifted backwards by a time interval of [time value missing]. .

6. The distributed multi-task self-organizing scheduling method for spaceborne safety-critical software according to claim 4, characterized in that: If there is a need to delete a task during task scheduling, the corresponding task will be deleted directly based on the currently completed task allocation and scheduling sequence, while the scheduling time and allocated processor node for other tasks will remain unchanged.

Images