CN109308216B

CN109308216B - Single-core system real-time task scheduling method aiming at inaccurate calculation

Info

Publication number: CN109308216B
Application number: CN201810260316.2A
Authority: CN
Inventors: 王文浩; 李幼萌; 章亦葵
Original assignee: Tianjin University
Current assignee: Tianjin University
Priority date: 2018-03-27
Filing date: 2018-03-27
Publication date: 2021-10-15
Anticipated expiration: 2038-03-27
Also published as: CN109308216A

Abstract

The invention relates to a real-time task scheduling method for a single-core system aiming at inaccurate calculation, which comprises the following steps: step one, establishing a task model in a single-core system according to task characteristics; step two, an offline scheduling module and an online scheduling module are constructed in the task model according to task scheduling time points; step three, constructing a task calculation precision unit for the online scheduling module according to the execution precision of the task; step four, constructing a task calculation over-deadline average degree unit for the online scheduling module according to the average degree of the task over deadline; step five, constructing a task cut-off time exceeding frequency calculation unit for the online scheduling module according to the frequency of the task exceeding the cut-off time; the invention can make full use of the systematic computing resources by respectively ensuring the computing precision, the exceeding degree of the deadline time and the exceeding probability upper limit of the deadline time on the premise of ensuring certain QoS (quality of service).

Description

Single-core system real-time task scheduling method aiming at inaccurate calculation

Technical Field

The invention relates to the scheduling of tasks of an approximate computation and real-time system, in particular to a real-time task scheduling method of a single-core system aiming at inaccurate computation

Background

In the related art of the recommendation method, the scheduling algorithm mainly includes:

WCET (worst execution time). The worst execution time for a computer task is the maximum amount of time that the task needs to execute on a particular hardware platform. Is important in the scheduling analysis of a hardware real-time system. Most of the conventional real-time scheduling algorithms at present adopt a pessimistic strategy to meet the deadline constraint of the worst case, which causes great waste of resources and energy.

2. And (4) a real-time scheduling algorithm. The real-time scheduling algorithm is mainly divided into an offline scheduling algorithm and an online scheduling algorithm.

In the offline scheduling algorithm, MILP (mixed integer linear programming) is generally used. The linear programming is an important branch of earlier research, faster development, wide application and more mature method in operational research, and is a mathematical method for assisting people in scientific management. MILP is one of integer linear programming models. Mainly used for solving the NP-hard problem. When the objective function is linear, the constraint condition is linear, and the decision variable can take any integer or decimal, the feasible solution of the single-core task scheduling can be solved through mixed linear programming

In the line scheduling algorithm, an EDF scheduling algorithm and an RMS scheduling algorithm are frequently used. EDF scheduling algorithm: the early Deadline First algorithm also becomes a Deadline driven scheduling algorithm, and is a dynamic scheduling algorithm. When the EDF is scheduled, the priority of the tasks is dynamically distributed according to the deadline of the tasks. The shorter the cutoff time, the higher the priority. EDF scheduling algorithms have proven to be the most dynamic and conditional. The RMS scheduling algorithm: the scheduling algorithm of tasks in monotonic rate priority assignment (RMPA), called monotonic rate scheduling. The scheduling algorithm means that the priority of the task is allocated according to the task period Tl. The scheduling priority is determined according to the execution period of the tasks, the tasks with small execution periods have higher priority, and the tasks with long periods have lower priority.

3. And (4) approximate calculation. In computer science, approximation calculation is an algorithm used to find an approximation method to solve an optimization problem. The approximation calculation is usually associated with the NP-hard problem. Since it is unlikely that an effective polynomial time can be accurately calculated to solve the NP-hard problem, a solution polynomial time sub-optimal solution is considered. Unlike heuristic algorithms, approximate calculations can often quickly find a reasonable solution within a provable solution quality and provable runtime range. Ideally, the approximation is optimally achieved by a small constant factor (e.g., within 5% of the optimal solution). Approximation calculations are increasingly used for problems with known accurate polynomial time algorithms but with too large inputs.

For many real-time scheduling algorithms, the worst-case execution time (WCET) is generally considered to be a critical parameter that satisfies the time limit constraint when the task runs in the worst case. Due to the use of WCET, these algorithms are quite pessimistic, much larger than the average execution time. Therefore, the scheduling strategy using WCET is too conservative, which means that much resources and energy are wasted. Without violations, all tasks must complete execution before the expiration date, even in the worst case. The WCET will be used to test schedulability. In many cases, the actual execution time is much less than the WCET. So there is some slack time in running. However, to reach the deadline in the worst case, other tasks cannot be scheduled to run while idle, which means that the resources of the processor are not fully utilized.

This problem can be solved by designing a total more aggressive solution strategy. For example, more tasks are allocated to be executed when the processor is idle, so as to achieve the purpose of fully utilizing the processor resources, or the frequency of the processor is reduced to save more energy. But also leads to new problems: theoretically, high load work cannot guarantee deadline constraints. In the present invention, we use an inaccurate calculation to solve this problem.

Traditional real-time scheduling algorithms employ pessimistic strategies to meet worst-case deadlines, resulting in significant waste of resources and energy. To solve this problem, we propose an offline non-preemptive scheduling algorithm based on MILP. The real-time constraint of the aperiodic task set with QoS (quality of service) guarantees is met by performing inaccurate calculation on the algorithm and the task granularity. Furthermore, we propose two pre-processing algorithms and three online scheduling schemes to improve different QoS (quality of service) factors at run-time. The present invention is primarily concerned with the application of imprecise calculations at the algorithm and task level. On the one hand, the approach algorithm level is achieved by precision assurance [13], reducing the execution time of the task to meet the deadline. On the other hand, schedulability is improved to an acceptable level during some occasional or small scale offending tasks. On the other hand, schedulability is increased to an acceptable level in case some occasional or small scale violations of the deadline are allowed.

Task scheduling is a key part of a kernel of a real-time system, and how to schedule tasks is to enable each task to be completed within the time limit of the task scheduling is an important research field of the real-time operating system.

Disclosure of Invention

The invention aims to overcome the defects in the background technology and provide a real-time task scheduling method for a mononuclear system aiming at inaccurate calculation. In addition, we propose three lightweight online scheduling adjustment methods, which make use of the time slack generated at runtime to perform targeted optimization on three indicators affecting QoS (quality of service) to use different task types. The simulation result shows that compared with the traditional scheduling algorithm, the method can support more task loads and less energy consumption on the premise of ensuring QoS (quality of service).

The technical scheme of the invention is as follows:

a real-time task scheduling method for an imprecise calculation single-core system comprises the following steps:

step one, establishing a task model in a single-core system according to task characteristics;

step two, an offline scheduling module and an online scheduling module are constructed in the task model according to task scheduling time points;

step three, constructing a task calculation precision unit for the task of the online scheduling module according to the execution precision of the task;

step four, constructing a task calculation over-deadline average degree unit for the online scheduling module according to the average degree of the task over deadline;

and fifthly, constructing a task cutoff time exceeding frequency calculation unit for the online scheduling module according to the frequency of the task exceeding the cutoff time.

The task calculation precision unit in the third step adopts the following steps:

step one, inputting the current time T, and tasks which are not executed in a task set T ', wherein T' is a part belonging to T. Assigning the current time to lastFinishTime, circularly judging whether the execution mode of the current task is 1 or not each time, and if the current task is executed in an inaccurate mode, calculating a slack time slot: subtracting the maximum value of lastFinishTime and task release time from the start time of the current task;

step two, judging whether the relaxation time can meet the time required by the current task to be converted from the inaccurate calculation mode to the accurate calculation mode, and if the relaxation time meets the condition, converting the current task from the inaccurate calculation mode to the accurate calculation mode;

step three, if the current task is executed in the accurate mode at first, the circular judgment is not carried out; the release time of the task and the maximum value of lastFinishTime are assigned as the start time of the task each time, and the completion time of the task under the worst condition is assigned as the lastFinishedtime.

The task exceeding deadline unit in the fourth step adopts the following steps:

step one, inputting the current time T, the serial number i of the next task and a task set T ', assigning the task set T ' to newT ' each time, taking one task tau j in the task set T ' each time, if the task exceeds the deadline, storing the set T ', assigning the maximum value of the current time T and the release time of the task tau i to the start time of the task, and assigning the worst execution time of the current task to lastFinishTime.

Step two, circularly judging the task tau between the ith task and the jth task_kThe release interval of the kth task is compared with lastFinishTime, and the maximum value is assigned as the start time sk of the task. And comparing the lastFinishTime with the release time of the ith task, and taking the maximum value as the start time si of the task.

And step three, circularly judging each task behind the jth task, comparing the release time of the task with the lastFinishTime, taking the maximum value as the start time of the task, and assigning the end time of the task under the worst condition as the new lastFinishTime.

Step four, if all tasks in the generated scheduling result meet the constraint condition of MILP, then: if the sum of the time exceeding the deadline of all the tasks is smaller than the sum of the time exceeding the deadline, exchanging the ith task and the jth task in the task set T ', and assigning T ' to newT '. .

Compared with the prior art, the invention has the advantages that: the invention provides a research for realizing non-preemptive real-time scheduling by introducing inaccurate calculation, and improves the schedulability of tasks on the premise of ensuring certain QoS (quality of service) from the aspects of off-line scheduling and on-line scheduling.

A. Offline scheduling method

The deadline requirements for non-hard real-time tasks may not be very strict. Therefore, the deadline of the task is relaxed, and the actual execution end time of the task is allowed to exceed the deadline to a certain extent without influencing the overall execution effect. By relaxing the cut-off time, the time relaxation caused by pessimistic calculation of the WCET can be effectively reduced, and the efficiency and the schedulability are improved.

B. Online scheduling method

The off-line scheduling algorithm of the non-preemptive periodic task based on the inaccurate calculation can achieve the effect of more fully utilizing the calculation resources of the system on the premise of ensuring certain QoS (quality of service) by setting the calculation precision, the degree exceeding the deadline and the upper limit of the probability exceeding the deadline.

In addition, we propose three lightweight online dispatch algorithms. The following effects can be achieved by the three algorithms respectively:

1. on the premise of ensuring certain QoS (quality of service), the overall precision of the tasks executed by the processor is improved.

2. On the premise of ensuring certain QoS (quality of service), the total time of the tasks executed by the processor exceeding the deadline is reduced, so that the overall execution effect of the tasks is ensured.

3. On the premise of ensuring certain QoS (quality of service), the frequency of the tasks executed by the processor exceeding the deadline is reduced, so that the overall execution effect of the tasks is ensured.

Drawings

FIG. 1: et al_iAt b_iAnd w_iThe distribution condition between the two;

FIG. 2 is a drawing: (f)_i-d_i) And (d)_i-r_i) A schematic diagram of (a);

FIG. 3: probability of completing the task before the deadline;

FIG. 4 is a drawing: legend for ARTBD algorithm;

FIG. 5: legend for ARFDV algorithm;

attached table 1: meaning of a symbol;

Detailed Description

The invention is further illustrated by the following specific examples and the accompanying drawings. The examples are intended to better enable those skilled in the art to better understand the present invention and are not intended to limit the present invention in any way.

The invention establishes a task model suitable for the invention according to task characteristics. The system is modeled from an algorithm level and a task level. According to different time of task scheduling, an offline scheduling method and an online scheduling method are respectively provided. In the online scheduling process, we define QoS (quality of service) as three indicators: the calculation accuracy of the task, the degree of the task exceeding the deadline, and the probability of the task exceeding the deadline. Aiming at three different indexes, in order to achieve different purposes, three online scheduling system models are respectively established.

1. Task model

And creating a task single-core task model according to the characteristics of the aperiodic single-core task. The task set T has n aperiodic real-time tasks. Each task has 2 precision modes at runtime, one is a precision mode and the other is an inexact mode. The inaccurate mode can be realized by considering an approximate calculation. By the implementation method, under an inaccurate mode, the task can be more reasonably scheduled and operated on the premise of ensuring QoS (quality of service), so that the task can be smoothly performed, the resource utilization rate is low, and the execution time is less than that of the accurate mode.

At the same time, we build a probabilistic model of execution time. The actual execution time of the system varies with different factors and is random. All, we need to analyze the possible relationship between the actual execution time and the worst execution time, and analyze the characteristics of the execution time probability model according to different situations.

Each task τ_iRepresented by a six-tuple (r)_i,s_i,d_i,m_i,b_i,w_i)，r_iDenotes τ_iRelease time of s_iIndicating the start time of the scheduler assignment, d_iRepresents the last deadline, which is a set of constants given before the start of the schedule. r is_i，s_iAnd d_iDenotes all time points, m_iIndicating the accuracy mode of the current task execution, assigned by the scheduler. m is_iThere are two values, 0 or 1. 0 denotes the precision mode execution and 1 denotes the non-precision mode execution. b_iIs the BCET, w in which the current task is executed in the selected mode_iIs the WCET that the current task is executing in the selected mode. b_iAnd w_iAll time-spanned, tasks being performed in different modes, b_iAnd w_iWill also be different. They are determined by mi and can be calculated by the formulas (1) and (2). (details of the symbols are shown in the attached Table 1)

In (1) and (2), B is contained_i，W_i，B’_iAnd W'_iMay be implemented by a number of techniques.

Furthermore, f_iThe execution end time indicating the worst case of the task can be calculated by equation (3).

f_i＝s_i+w_i (3)

Executing the time probability model: et for actual execution time of task_iAnd (4) showing. It is apparent that et_iCan not be less than bi nor more than w_i。et_iWill be in the interval [ b ]_i,w_i]And (4) internally generating randomly. In reality, execution time may vary widely. To simplify the problem, we assume et_iSatisfies b_iAnd w_iAre uniformly distributed, and the distribution is shown in figure 1.

Et_iThe probability of not greater than t can be calculated according to equation (4) with F at [ b ]_i,w_i]May be varied within the range of (1).

2. Offline scheduling module

We use the MILP algorithm to implement. The linear programming is an important branch of earlier research, faster development, wide application and more mature method in operational research, and is a mathematical method for assisting people in scientific management. MILP is one of integer linear programming models. Mainly used for solving the NP-hard problem. When the objective function is linear and the constraint condition is also linear, and the decision variables can take any integer or decimal number, the feasible solution of the single-core task scheduling can be solved through mixed linear programming.

The MILP algorithm: the non-hard real-time task τ i may not have very strict deadline requirements. The execution time for completion of these tasks exceeding the deadline does not produce fatal errors, but degrades the QoS (quality of service). The evaluation of whether the QoS (quality of service) is degraded can use the following two indicators:

1) the relative degree to which the worst-case task end time exceeds the deadline, ai. It can be calculated by equation (5).

Due to et_iIs in the interval [ B_i,W_i]Internal random generation until task τ i is completed, τ_iThe actual execution time after the deadline can be determined. The maximum extent of over-time can be evaluated in the worst case. If a task is a hard real-time task, then α_iThe value cannot be greater than 0, which means τ_iMust be done before the expiration date. Alpha is alpha_iThe larger the value, the greater the extent to which the task's completion time exceeds the deadline in the worst case. As shown in fig. 2.

2) Probability p of task completion by execution before deadline_i. According to formula (4), p_iCan pass through P (et)_i<dl_i-s_i) To calculate. When the value of pi is 1,the probability of a task completing before the deadline is 1, which is related to alpha_iThe effect is the same for a value of 0. P_iThe smaller the value, the higher the probability that the task violates the deadline constraint. As shown in fig. 3.

By using alpha_iAnd p_iTo limit the deadline constraints, we propose an MILP formula that can provide a schedulable solution for non-schedulable tasks with a certain QoS (quality of service) under strict constraints. The method only provides a scheduling solution for the task set T and meets the relaxation constraint condition. The constraints of the MILP formula are as follows:

1) task tau_iMust not start earlier than the release time

s_i≥r_i (7)

2) The processor can only execute one task at a time, any two tasks τ_iAnd τ_jThe execution times of (2) cannot overlap in the time axes (8) and (9). Variable y_ij(i>j) The value of which is 0 or 1_iAnd τ j. When tau is_iAt tau_jWhen previously executed, y_ij(i>j) Is 1, otherwise is 0.

f_i≤s_i+(1-y_ij)·∞ (8)

f_j≤s_i+y_ij·∞ (9)

3) Ratio alpha of time to maximum allowed execution time for exceeding the deadline in the worst case_iMust not be greater than A_i(11). For example, if τ i is a hard real-time task, then A_iMust be equal to 0; if τ_iIs a (firm and soft real-time task), then A_iAnd may be greater than 0. So Ai is task dependentThe feature gives an empirical value that guarantees a certain QoS (quality of service) even if the deadline constraint is violated in the worst case.

α_i≤A_i (11)

4) The probability that the task is completed before the deadline must not be less than P_i(12). Same as A_iSame, P_iIs also an empirical value given for different characteristics of the task, used to control the task τ_iProbability of completion within the deadline on the premise of guaranteeing QoS (quality of service).

p_i≤P_i (12)

The MILP solution: MILP is an NP-Hard problem. In order to ensure the performance of the solution, a heuristic algorithm is adopted for solution. Since this MILP formula has no objective function, we take the initial feasible solution as the final solution. The cost of computing the initial feasible solution is much lower than solving the optimal solution, so the method for solving the problem can obtain better performance. Pretreatment and online adjustment and time delay recovery.

3. Online scheduling module

In the online scheduling system model, different execution strategies are formulated according to different tasks. We reclaim different types of time slack that is generated during task execution and take full advantage of the time slack to increase the time utilization of the processor.

The sensitivity to QoS (quality of service) is also different for different types of tasks. For example: the occasional occurrence of a large delay in the audio-video playback has a greater impact on the user experience than the frequent occurrence of a small delay; frequent violations of deadlines for some near real-time tasks (e.g., navigation programs) have much greater impact on the user experience than low probability violations of deadlines to a greater extent, and some soft real-time tasks are more sensitive to computational accuracy than time requirements. Therefore, we define QoS (quality of service) as three indicators.

Calculating precision of tasks: for a task model requiring high precision in execution, scheduling is required to improve the task computation precision, that is, tasks in a non-precision computation execution mode are converted into a precision mode to be executed as much as possible.

Degree of task exceeding deadline: for a task model requiring an average execution degree of tasks, a system model needs to be designed for scheduling so as to realize that the degree of exceeding the deadline of a task set is as small as possible.

Probability of task exceeding deadline: for task models that require tasks to be performed as far as possible before the deadline, we need to design a system model to schedule to achieve as little probability as possible that the task exceeds the deadline.

When executing a task set, if the execution end time of the current task is earlier than the start time of the next task specified by the MILP. The processor will idle for this interval. This idle time may be defined as a time slack. Temporal redundancy occurs both in offline scheduling and runtime.

The time gaps may be used to optimize QoS (quality of service), for example, to improve the accuracy of tasks, to reduce the time for tasks to exceed deadline, and to reduce the frequency of occurrences of exceeding deadline conditions. Since QoS (quality of service) of different tasks may have different effects on these three factors, the preprocessing and online adjustment algorithms that optimize each factor will be discussed below.

When a task is completed, context switching of the task is performed in the system. In context switching of tasks, the scheduler will trigger the adaptation algorithm. Considering the overhead of task switching in a real-time system, the online adjustment algorithm must have high performance. Finding a globally optimal solution is an NP-Hard problem that does not guarantee the performance of the system. Therefore, a heuristic online adjustment algorithm is designed to simplify the problem, and an approximate optimal solution is calculated by using a better-performance algorithm.

1) Time relaxation

There are two types of slack in scheduling: offline relaxation and runtime relaxation

Offline relaxation: in offline scheduling, constraints (8) and (9) are both based on WCET. These constraints only guarantee that any start-up time interval for both tasks cannot be smaller than WCET. So even in the worst case, offline scheduling cannot guarantee that there is no time interval between the completion execution time of the current task and the start time of the next task.

Secondly, relaxation of operation time: the actual execution time of each task is typically less than the WCET, and thus, the processor is idle between the actual execution completion time and the scheduled execution completion time, referred to as a runtime slack.

Through pre-processing and online tuning, offline relaxation and runtime relaxation can be utilized to improve QoS (quality of service).

2) Pretreatment of

The pre-processing must be run before all tasks are performed. The invention provides two preprocessing algorithms to improve scheduling performance.

Preprocessing accumulated relaxation: to improve accuracy, under the MILP constraint, slack may be utilized to convert a portion of a task from inaccurate mode execution to accurate mode execution. If a task to be executed is executed in an imprecise mode and there is slack before the task is executed, the task may change its execution mode. Therefore, collecting sufficiently large slack in the pre-processing is important to improve the accuracy of the task set.

The PAS algorithm performs the process of: the algorithm firstly inputs a task set T (including the execution sequence, the starting time and the like of each task) generated by MILP offline scheduling, and assigns the last task in the task set T to Ti each time, wherein i is the subscript of the task. And comparing the last execution time of the task under the deadline constraint with the start time of the task in the last cycle, subtracting the WCET of the task executed in the precise mode from the smaller value of the last execution time of the task as the new start time of the task, and removing the task from the task set T, and thus cycling to stop until the task set T is empty. In the first cycle, the value of upperbound is assigned to infinity, and then after each cycle obtains a new start time of the task, new values are assigned to the upperbound, which is most compared with the execution time of the next cycle and the next task.

In the PAS algorithm, the start times of all tasks must be delayed as much as possible to allow forAll time ahead of the first task to be performed is accumulated. To obtain maximum slack, the tasks in T are delayed in order from back to front, as determined during offline scheduling. lf_iDenotes τ under constraints (11) and (12)_iMay be calculated by (13). The latest start time can be derived from the minimum value obtained by comparing the start time of the next task with the maximum time allowed in (11) and (12) (row 5). It allows all the time to be gathered together before the first task is executed. In this way, the adjustment of the accuracy can take full advantage of these slack. This preprocessing can make the effect of algorithm 3 more pronounced.

lf_i＝min{(A_i+1)·d_i-r_i,(1-P_i)(w_i-b_i)+d_i} (13)

Secondly, pretreatment for eliminating relaxation: to reduce the frequency of exceeding the sum of the cut-off times or the cut-off time, all tasks must be run as early in the sequence as possible. In these cases, the relaxation should be eliminated as much as possible after the pretreatment.

The PES algorithm is executed as follows: the algorithm still needs to input a task set T generated by MILP offline scheduling, assign a first task in the task set T to Ti each time, wherein i is a subscript of the task, compare the end time of the task executed according to the precise mode in the last cycle (namely, the execution time is WCET) with the release time of the current task each time, and take the maximum value as the start time of the current task. And ending until the task set T is empty. And after each cycle is finished, assigning the starting time of the current task and the WCET in the current task precision mode to the lowerbound, and comparing the starting time of the current task with the release time of the next task.

In the PES algorithm, each s_iIs the maximum value between the release time of the current task and the end execution time of the previous task. Thus, each task will run as early as possible under the constraints imposed by MILP, which can reduce the total time and deadline after the deadline has been exceededLimiting the frequency of violations. This preprocessing may enhance the effect of the ATRBD algorithm and the ARFDV algorithm.

3) Optimization for three indicators affecting QoS (quality of service)

(ii) online scheduling for improved accuracy

The AIP algorithm is executed as follows: the algorithm first inputs the current time T, the tasks in the task set T 'that have not yet been executed, where T' is part of T. Assigning the current time to lastFinishTime, circularly judging whether the execution mode of the current task is 1 (namely inaccurate execution) each time, and if the current task is executed in the inaccurate mode, calculating the slack time slack: and subtracting the maximum value of lastFinishTime and task release time from the start time of the current task, and continuing to judge whether the slack time can meet the time required by the current task to be converted from the inaccurate calculation mode to the accurate calculation mode (if Wi-Wi' is less than or equal to slack, the conversion condition is met), and if the condition is met, converting the current task from the inaccurate calculation mode to the accurate calculation mode. If the current task is initially executed in precision mode (mi is 0), no loop determination is made. The determination is made by dynamic online scheduling after the execution of each task is complete. Wherein the release time of a task and the maximum value of lastFinishTime are assigned to the start time of the task each time, and the worst case completion time of the task is assigned to lastFinishedtime.

During scheduling, the adjustment may change the execution mode of the tasks assigned by the MILP from imprecise to exacting as much as possible while satisfying the MILP constraints. Therefore, with offline relaxation and runtime relaxation, the accuracy of the task can be improved at runtime. Switching of the precision mode means that the actual execution time of the task may be longer than the original precision mode, and additional time may be balanced by using slack time.

The scheduler will execute the AIP algorithm during context switching of a task in order to adjust the start time and precision mode of the next task by using slack. If the slack is large enough, the precision is switched (lines 5 and 6) and then the next task τ is scheduled at the earliest time (line 9)_i。

② on-line scheduling for reducing time exceeding deadline

The implementation process of the ARTBD algorithm is as follows: the algorithm firstly inputs the current time T, the serial number i of the next task and the task set T ', assigns the task set T' to newT 'each time, takes one task tau j in the task set T' each time, and if the task exceeds the deadline (exj)>0) The set T' is saved and the maximum of the current time T and the release time of the task τ i is assigned as the start time of the task, and the worst case execution time of the current task is assigned as lastFinishTime. Continuing to circularly judge the task tau between the ith task and the jth task_kThe release interval of the kth task is compared with lastFinishTime, and the maximum value is assigned as the start time sk of the task. And comparing the lastFinishTime with the release time of the ith task, and taking the maximum value as the start time si of the task. Then, each task behind the jth task is judged in a circulating mode, the release time of the task is compared with lastFinishTime to the greatest extent, the maximum value is taken as the starting time of the task, and the ending time of the task under the worst condition is assigned as new lastFinishTime. When the operations are executed, if all tasks in the generated scheduling result meet the MILP constraint condition, then: if the sum of the time that all tasks exceed the deadline is less than the sum of the previous exceeding times, the ith and jth tasks in the task set T ' are swapped, and T ' is assigned to newT '. And finally returning a new set newT' through loop judgment.

This adjustment is intended to reduce the total time beyond the task deadline. Individual tasks tau beyond deadline_iTime out of deadline ex_iCan be calculated by equation (14). Therefore, Σ ex can be used_iTo indicate the total time over the deadline.

ex_i＝max(f_i-d_i,0) (14)

The main idea of the adjustment is to implement Σ ex for all unexecuted tasks by exchanging the execution order of the tasks_iIs minimized. To achieve the low overhead of the on-line tuning algorithm, we only consider the next task τ to be executed in the MILP scheduling_iAnd exchanges with other unexecuted tasks. An example is shown in figure 4.

In the ARTBD algorithm, the next task to be executed will attempt to swap with other unexecuted tasks separately, which may violate its deadline (line 4). After the swap, the start time of each task is recalculated to ensure that each task will be executed as early as possible according to the new execution order (lines 6 to 17). If the new execution order fails to satisfy the constraint, the schedule will not swap and try the next task that violates the deadline (line 18). Otherwise, it will be calculated. When smaller than the old candidate (line 19), τ_iAnd τ_jWill be swapped (line 21). In addition, the returned value candidate will be replaced by a new execution time table (line 22).

T' (line 5) must be saved before each swap and restored at the end of the iteration (line 25) because each new schedule must be calculated from the original schedule. The original schedule is not modified during the iteration. The new scheduling schedule will be stored in newT'.

In the iterative process, when j and i are equal, it means that all tasks will only be executed in advance without any exchange, which is also a candidate for returning a value. After scheduling is completed, the scheduler will use the new schedule to execute the tasks.

On-line scheduling for reducing frequencies exceeding a deadline

This adjustment scheme (called ARFDV) is similar to the algorithm ARTBD. The only difference is that line 19 and line 23 are replaced, which is a feature that defines the deadline violation frequency, where isEx_iIs a boolean value (15) that indicates whether there is a possibility of exceeding the expiration date. It can be calculated by (15).

In some cases, this adjustment has similar results to ARTBD. In other cases, however, the difference between ARTBD and ARFDV is evident. In fig. 4, the total time beyond the deadline has been reduced, but there is no change after the swap, which would not have occurred in the ARFDV. Swapping will only occur in the reduced case. This is illustrated in figure 5.

It should be understood that the embodiments and examples discussed herein are illustrative only and that various modifications or changes in light thereof will be suggested to persons skilled in the art and are to be included within the spirit and purview of this application and scope of the appended claims.

Claims

1. A real-time task scheduling method for an imprecise calculation single-core system is characterized by comprising the following steps:

step 3.1, inputting the current time T and tasks which are not executed in a task set T ', wherein T' is a part of T; assigning the current time to lastFinishTime, circularly judging whether the execution mode of the current task is inaccurate execution each time, and if the current task is inaccurate execution mode, calculating a slack time slot: subtracting the maximum value of lastFinishTime and task release time from the start time of the current task; wherein: the task set T has n aperiodic real-time tasks;

step 3.2, judging whether the relaxation time can meet the time required by the current task to be converted from the inaccurate calculation mode to the accurate calculation mode, and if so, converting the current task from the inaccurate calculation mode to the accurate calculation mode;

3.3, if the current task is executed in the accurate mode at first, no cyclic judgment is made; assigning the release time of the task and the maximum value of lastFinishTime as the start time of the task each time, and assigning the completion time of the task to lastFinishTime under the worst condition;

step 4.1, inputting the current time T, the serial number i of the next task and a task set T ', assigning the task set T ' to newT ' each time, taking one task tau j in the task set T ' each time, if the task exceeds the deadline, storing the set T ', assigning the maximum value of the release time of the current time T and the task tau i to the start time of the task, and assigning the execution time of the current task under the worst condition to lastFinishTime;

step 4.2, circularly judging the task tau between the ith and jth tasks_kComparing the release time of the kth task with lastFinishTime, and assigning the maximum value as the start time sk of the task; comparing lastFinishTime with the release time of the ith task, and taking the maximum value as the start time si of the task;

step 4.3, circularly judging each task behind the jth task, comparing the release time of the task with the lastFinishTime, taking the maximum value as the start time of the task, and assigning the end time of the task under the worst condition as new lastFinishTime;

step, if all tasks in the generated scheduling result meet the constraint condition of the given Mixed Integer Linear Programming (MILP), then: if the sum of the time exceeding the deadline of all the tasks is smaller than the sum of the time exceeding the deadline, exchanging the ith task and the jth task in the task set T ', and assigning the T ' to newT ';