WO2009087317A2

WO2009087317A2 - Method for managing preemptions in a real-time operating system

Info

Publication number: WO2009087317A2
Application number: PCT/FR2008/001481
Authority: WO
Inventors: Fabrice Muller; Farooq Muhammad; Michel Auguin
Original assignee: Centre National De La Recherche Scientifique
Priority date: 2007-10-24
Filing date: 2008-10-22
Publication date: 2009-07-16
Also published as: WO2009087317A3; JP2011501309A; FR2923039A1; EP2203817A2

Abstract

The invention relates to a method for managing preemptions between at least two tasks having different priorities in a real-time operating system, characterised in that during the execution request of a task having a priority higher than that of the current task, the execution of the current task is interrupted only after a calculated time interval so that at least the current task and the higher-priority task can be executed before the execution deadlines allocated thereto have expired.

Description

METHOD FOR MANAGING PREEMPTIONS IN A REAL-TIME OPERATING SYSTEM

The subject of the present invention is a method for managing preemptions between several tasks in a real-time operating system (RTOS).

It is known to preempt a task by a higher priority task to allow it to be completed before a deadline that is fixed, whether in the case of fixed priority scheduling ("fixed priority scheduling"). or FPS) or dynamic (priority to the nearest deadline is "earliest deadline first" or EDF), or even minimum latency (or "least laxity").

However, pre-emption of tasks and more specifically the number of such pre-emptions has sometimes significant consequences on performance. Indeed, the processor can not be used to its maximum, because each preemption causes changes in the state of the cache memories (instructions and data), and these changes in turn lead to an increase in the execution time of the tasks (this which means that real-time constraints are no longer guaranteed) and the power consumption increases due to data movements between the different levels of the memory hierarchy at each preemption and each preemption return.

It is therefore desirable to reduce the number of pre-emptions.

The article by Radu DOBRIN and Gerhard FOHLER published in Real Systems 2004 - Proceedings ECRT 2004 - 16th Euromicro Conference on Real Time Systems, June 30 - July 2, 2004, pages 144 to 152 entitled "Reducing the Number of Preemptions in Standard Fixed Priority Scheduling"", proposes a fixed priority preemption algorithm (FPS) by analyzing a set of tasks (" artifact tasks ") having periods equal to the least common multiple of the periods of the two tasks and scheduled by a fixed priority preemption algorithm, then calculating the number of preemptions that may occur and requiring the pre-emptive task or pre-empted tasks to be performed so that it avoids pre-emption of tasks during execution while permitting their execution within the prescribed time. The described technique makes it possible to reduce the number of pre-emptions only in the case where the occupation rate of the processors is noticeably less than 100%.

Sung-Heun Oh and Seung-Min YANG's article "A Modified Least-Laxity-First Scheduling for Real-Time Tasks" in Proceedings of the 3rd International Conference on Real Time Computing Systems and Applications 1998 (27-29 October 1998, pages 31-36) proposes an LLF (minimum latency priority) scheduling algorithm to solve a problem of incompatibility between two tasks by allowing one of the two tasks to execute completely without preemption.

The algorithm dedicated to the latency link problem ("laxity tie") relating to the LLT scheduling effect indeed for each task of the set of tasks and assigns individually to each task of the set of tasks a fixed priority for a time of dynamically calculated release, which greatly increases the complexity of task control ("TCB"), and increases execution times which leads to lower processor availability for its essential task which is the execution of tasks, except to choose a processor with greater processing power.

The article by Cécilia EKELIN "Clairvoyant Non-Preemption EDF Scheduling" (18th Euromicro Conference on Real Time Systems ECRTS'06 pages 23-32) proposes to delay the execution of certain tasks taking into account the future arrival of new tasks , but this technique applies only to the case of tasks without preemption rule.

The paper by Yun WANG and Manas SAKSENA "Scheduling Fixed-Priority Tasks with Preemption Threshold" (Sixth Conference on Real Time Computing Systems and Applications RCTSA'99 pages 328-335) proposes a preemptions reduction algorithm that requires computation for each pre-emption thresholds, resulting in complexity proportional to the square of the number n of tasks. The article by Woonseok KIM, Jihong KIM and Sang Lyul MIN published in "Proceedings of the 2004 International Symposium on Low Power Electronics and Design"ISPLED'04, August 9-11, 2004, pages 393-398, and titled "Preemption- Aware Dynamic Voltage Scaling in Hard Real-Time Systems "analyzes the negative effect of preemptions on the processor's power consumption and offers two solutions. The first proposed solution is an acceleration of the clock rate to allow a lower priority task to complete before the arrival of a higher priority task, which requires that before the priority task higher happens, the CPU utilization rate is significantly less than 100% to allow then restore the clock rate, and this requires, for good efficiency, to oversize the processor.

The second proposed solution is to provide a largely oversized processor with respect to its total workload and to use a low clock rate so that it remains possible to finish tasks with low priority while there is a task of highest priority.

It follows from the above that there is currently no known technology that is able to reduce the number of preemptions without there is an associated disadvantage related to the availability and / or sizing of the processor.

The basic idea of the invention is to determine for each task a non-preemption interval during which the task can remain in execution while a more priority task appears. The invention thus relates to a method for managing preemptions between at least two tasks having different priorities in a real-time operating system, characterized in that, during a request to execute a task having a higher priority. the current task, the execution of the current task is interrupted only after a calculated time interval to allow at least the current task and the higher priority task to be executed before the end of the execution time assigned to them.

The time interval can be calculated once and for all for each task taking into account the execution of all other tasks that may have a higher priority, or dynamically taking into account all the other tasks having a priority. higher and for which an execution request is formed. In this case, the time interval of the current task can be refreshed each time an execution request is formed for a task having a higher priority than the current task. The invention also relates to a method as defined above characterized in that the management of the preemption of several tasks whose indices i are chosen so that the tasks are classified in increasing order of execution priority, the index 1 being assigned to the task having the highest execution priority, and so on until the index p which is assigned to the task whose execution priority is the lowest, the time interval NPj non-preemption of the task of rank ia for value:

with

P ₁ designating the execution time assigned to the task Tj. This time is equal to the period of the task in the case of EDF scheduling with static calculation of NPj values, and also RM ("Rate Monotonic") by definition. In the case of EDF orders with dynamic calculation of the values of NPi, or DM ("Deadline monotony"), Pj can be equal in this equation and in all the following equations to a deadline Dj of value less than or equal to the period of task.

Cj designating the duration of execution of the task Ti Other features and advantages of the invention will appear on reading the description below in conjunction with the drawings in which: - Figure 1 is an example of implementation of an algorithm according to the invention, FIG. 2 illustrates the accumulation of the latency or laxity of the higher priority tasks than the current task T, FIGS. 3a and 3b are an example of implementation in a system implementing three tasks of which T ₁ is the highest priority, respectively with an algorithm according to the invention and with a conventional "EDF" algorithm, and FIGS. 4 and 5 illustrate the case of chain preemptions in the case of an "EDF" algorithm classic (Figure 4) and how a algorithm according to the invention allows to avoid them (Figure 5) or to reduce the number.

For example, a real-time system is considered in which real-time tasks are ordered according to a closest maturity scheme (EDF). The tasks T are of number n and are denoted (Ti, T ₂ , ... T _n ). These tasks are supposed to be mutually independent. Each task Tj has its own execution time ("deadline") Pj which is imposed on it and a runtime Ci calculated in the worst case execution time ("worst case execution time" or WCET). Each task Tj has a latency or laxity Li which is defined by:

Li = Pi - Q

Each task reappears cyclically and the k ^th implementation of the task Tj is denoted Tj. _k .

Each implementation k of the task Tj, _k has a wake-up date π, k = kPj and an execution time (due date) dj, k ≈ (k + 1) P |.

With an EDF algorithm, the task that runs is the one that expires at the nearest one. The algorithm is based on dynamic priorities. The algorithm described below is distinguished from a conventional EDF type ¹¹ algorithm by the moment when the preemptions are performed, because the algorithm makes it possible to know whether immediate preemption is necessary or whether it is possible to delay it and for how long.

By convention, the tasks are sorted in ascending order with respect to their period P so that whatever is i, we have Pj <Pj + i, Pi being the task whose expiry time Pi is the shortest.

NPi defines the duration during which the current task Tj can proceed without inconvenience even in the presence at time t of one or more other tasks of higher priority than that of the current task. For this purpose, three conditions can be enumerated.

Condition 1: the latency Lj of the task Tj can be shifted over the entire time interval defined between its wake-up date and its due date

Ft.

Indeed, the task Tj never exceeds the deadline as, during the maturity period Pi, the processor assigns a processor time Cj. Condition 2: the task Tj can be pre-empted only by a task having a higher priority and therefore a shorter expiration period Pj (in the case of an EDF or RM algorithm).

Forcing a lower priority task to continue execution when a higher priority task is to be executed is a priority override that can cause the higher priority task to be exceeded.

Only higher priority tasks can therefore preempt lower priority tasks. The RM ("Rate Monotonic") preemptive algorithm is based on fixed priorities. The tasks are periodic and of period Pj, but the deadline is not necessarily at the end of the period. Tasks are sorted by increasing periods and priority is allocated inversely to the period. In the case of the "EDF" algorithm, the priority criterion is the absolute deadline d.

If the task Tj is preempted at time n by the task T _j ready for the moment k, which implies that:

Since the task Tj is preempted at the instant n by the task T _j , which implies that the deadline of T _j is closer than that of Ti, hence:

It follows that Pj <Pj.

A task Tj can therefore be pre-empted only by a task which has a lower due period P.

In an "RM" algorithm, a task that appears less frequently will always be preempted by a more frequent task. In the case of an EDF algorithm, a more frequent task may or may not pre-empt an infrequent task. In the case of an "EDF" algorithm, condition 2 is necessary, and for an "RM" algorithm it is necessary and sufficient. As a corollary, only tasks that have a timeout lower than that of the task Tj can exceed their deadline in case of priority reversal in favor of the task Tj. Condition 3: In the case of an algorithm of type "EDF" giving priority to the deadline whose term is closest, a task T ₁ may continue execution by causing a priority inversion during a statically or dynamically calculated NP time without any other task exceeding the assigned time.

In other words, each task Tj has two main parameters which are its execution time Cj in the worst case and its period Pj which sets the maturity period, that is to say the time that remains available to complete. the task within the prescribed time.

The expiry date of the task is only equal to its period in the case of EDF ₁ scheduling if the NP values of tasks and RM scheduling are statically calculated. For EDF scheduling with dynamic calculation of NPi values or DM ("Deadline Monotonicity"), Pj can be equal to a deadline Di of value less than or equal to the period of the task.

The third parameter developed from the first two is the latency or laxity L ₁ .

If a higher priority task has sufficient latency, then its execution can be delayed by delaying preemption for a time that is compatible with the fact that all tasks are performed without exceeding their deadlines. A logic algorithm is shown in FIG. 1. At the arrival of a task Tj, if no task is active, the procedure is conventional (for example "EDF" algorithm). If a task Tj is already active, the procedure "EDF" is continued if Pj <Pj, and otherwise the task T _j is inserted in a temporary queue for a duration equal to the minimum between the execution time remaining for Tj and NPj value of the duration of non-preemption

As soon as this duration is reached, the task Tj preempts the task Tj, except of course if the task Tj has already completed its execution, in which case the task Tj starts its execution as soon as the task Tj is completed. The NPj value of the non-preemption period can be determined either statically or dynamically.

A static determination is described below:

The latency L ₁ of the task Tj defines the duration NPj ₊ i during which a task T _{i +} i of lower priority can cause a priority inversion without Tj missing its deadline.

So we have : NP ₂ = L ₁

The task Ti with the shortest expiry time can not be preempted by any other task, and the task T ₂ can only be preempted by the task Ti, and so on until the task T _p which can be preempted by the higher priority tasks T _p- i, T _p-2 , .. Ti.

To calculate NP ₃ for the task T ₃ , we define a virtual task used only in the calculations and whose objective is to model the deadlines and the execution times induced by the tasks higher priority than T ₃ . This virtual task has a latency L ² ₇ and an execution time abs C ² , defined in the worst case as equal to the sum of abs

C ₂ and an execution time proportional to that of the task Ti for the period equal to the period of this virtual task, ie: pp ² - ri ² p

^ abs ~ ^ 2 ⁺ p * -l We will have:

NP ₃ = Min (NP ₂ , L ² _abs )

That is, we choose the minimum between the two values in parentheses. We will have the same way:

NP ₄ = Mm (NP ₃ , L ³ _abs )

Indeed, the task T ₃ has the largest expiry time among the tasks Ti, T ₂ , T ₃ that can preempt the task T ₄ .

In general, the task Tj can be preempted by the tasks (Ti, T ₂ ,..., TM), which have a duration of maturity shorter than its duration Pj.

If we take into account all the tasks that can preempt the task Tj, we can define a virtual task T ^ ₅ whose laxity corresponds to the duration of no expiry NPj. It is thus possible to compute, from Ti up to T _j , all NPj non-preemption times (i varying from 1 to j). To calculate the worst execution time of a virtual task, the task Tj is chosen for the case where all the tasks having a higher priority level are called at the same time during the execution of the task Tj . The virtual task T ^ has a period equal to the due time P, -i of the task TVi and its execution time in the worst case noted C ¹ ^ ₃ is the weighted sum of the execution times in the most unfavorable case of all the tasks having a duration of expiration less than the duration C, of the task T ,.

We will have:

i ^{υ t} -Obs ~ ^r abs ^U abs

The latency L ¹ ^ ₅ of the task T ^ indeed accumulates the latencies or laxities of all the higher priority tasks than the task T ₁ .

Figure 2 shows that virtual task T ^ ₈ collates the

Accumulated latency L ^{1 '} ^ of all the tasks higher priority than the task T, while the duration P ^ ₅ of the virtual task T ₃ ¹ ^ ₅ has a higher value than for each of the tasks of higher priority than T , and C ^ ₅ is the weighted accumulation of the worst execution times of these tasks.

This accumulated latency gives a greater ability to 0 a given task to continue without its execution being preempted by a more priority task.

The non-preemption time NP, of the task T, is then defined:

NP ₁ = Mm (NP ₁₄ ,)) 5

The formula giving NP, takes into account by its method of calculating the minimum value of the latency of the tasks of lower rank. Thus none of the tasks will be able to miss its deadline. The algorithm described above delays the preemption of the current task for a duration equal to the value of NP ₁ for the current task T ₁ . It should be noted that the possible values of NP can be precalculated and placed in a table thus giving for each task the NP value.

This delay is counted by a counter and when this counter reaches the value 0, there is preemption of the current task unless of course the current task has ended before which case the new task is executed as soon as the task is completed. completion of the current task and without preemption.

If during the time interval NPj of the current task Tj, other tasks appear, they will be delayed until the interval NPi is completed. Only then will the deadlines for these tasks be taken into account.

The calculation of NP takes into account the case where all the tasks higher priority than the current task appear simultaneously, which ensures that in the worst case, all the tasks will be carried out according to their deadline, whatever the tasks likely to appear later.

Example:

We take a simple model presenting three tasks T ₁ , T ₂ , T ₃ . They have been ranked in order of priority, according to their period, with T ₁ being the highest priority, as indicated below:

We have :

T ₂ C ₂ = 6 P ₂ = 21

T ₃ C ₃ = 9 P ₃ = 33 Ti can not be preempted

T ₂ can only be preempted by T ₁

T ₃ can only be preempted by Ti or T ₂ .

We have NP ₃ = P ₂ - J ^ C _; either NP ₃ = 21 - - x 4- 6 = 6.6

NP ₂ = P ₁ - C ₁ = 6

FIGS. 3a and 3b are chronograms amounting on the one hand (FIG. 3a) to the operation of the algorithm according to the invention and on the other hand (FIG. 3b) according to a conventional EDF algorithm, for a task T ₂ arriving at instants t = 0 and 21 (two occurrences), a task Ti arriving at times 3, 13, 23 and 33 (4 occurrences), and a task T ₃ arriving at times 0 and 33.

In Figure 3a, there is no preemption, while in Figure 3b, there are two preemptions. Indeed, the task T ₂ is not pre-empted by the task at all.

Ti arrives at the moment 3 because NP ₂ = 6 which is greater than the time required for the task P ₂ to be completed. The task T ₁ begins its execution at the instant t = 6 and ends before its expiry at t = 10. At the instant t = 10, the task T ₃ begins its execution until the second occurrence of the T1 task appear at time t = 13, but the preemption of T ₃ is delayed because NP ₃ = 6.6, which allows the task T ₃ to end without preemption. The second occurrence of the task Ti is executed between the instants t = 19 and t = 23, and the third occurrence of the task T ₁ is executed between the instants t = 23 and t = 27. The task Tj which has the highest priority not being preempted, the second occurrence of T ₂ at time t = 20 is delayed until t = 27 when task T ₁ is completed, and the second occurrence of task T ₂ is executed between t = 27 and t = 33.

The static algorithm described in general does not allow to remove all preemptions, but only to reduce the number. It is possible to improve performance and further reduce the number of preemptions by dynamically adjusting the preemption time.

The previous calculation is indeed to take into account the fact that all low-frequency tasks are called simultaneously what is in practice.

The dynamic calculation aims to take into account only the tasks actually called to be executed.

If a task T _k is called and has a deadline earlier than that of the current task Ti, then NPi is calculated and decremented while the task T ₁ continues until the duration NP - has elapsed or task Tj ends. It is therefore necessary to recalculate NPj each time a new task called has a deadline before that of the current task, and restart the decrementation of NP, with the new value and with this new starting point, the calculation of NPj is done using the preceding equations, but taking into account only the tasks which are ready for execution and have an absolute deadline prior to that of task Tj

In this dynamic calculation, the tasks selected for the calculation of the NPj parameter are ordered according to the value of their absolute maturity date dj and not according to the value of their maturity period P _j .

If the task TR is the first to be called while Tj is executed (d _k <dj), NPj will be chosen equal to the latency L _k of the task Tk _. If a new task Ti is ready (d | <dj), then NPj will be recalculated taking into account the parameters of the tasks T _k and Ti according to the formulas given above.

A recalculated value can only be less than or equal to the previous value. It should be noted that a statically calculated value NPj can not be greater than a dynamically calculated value NPj, since the static computation takes into account all the higher priority tasks whether or not they are ready, whereas the dynamic computation does not take place. only takes into account tasks that are actually ready for execution.

The complexity of the dynamic computation is proportional to the total number n of tasks, and the algorithm requires n iterations in the worst case, but the number of iterations will generally be much smaller than n. This calculation of NP values can be incorporated into the algorithm used to place the newly called tasks for execution in the queue and whose complexity is also proportional to n.

A particularly troublesome phenomenon in the case of RM or EDF type algorithms is the existence of chain preemptions, that is to say that a task in progress is preempted by a higher priority task, itself pre-empted by a task even more priority and so on.

Because the algorithm according to the invention, whether static or dynamic, always takes into account all the tasks ready for execution (of all the tasks that can be ready in the case of a static algorithm and really ready in the case of a dynamic algorithm), this phenomenon can be avoided or mitigated.

This is illustrated in FIGS. 4 and 5 for chain preemption for 6 tasks Ti to I classified as before in order of decreasing priority (Ti being the highest priority task). In FIG. 4 TQ is preempted by T ₅ , T ₅ by T ₄ , T ₄ by T ₃ , T ₃ by T ₂ and finally T ₂ by T ₁ , ie five cascaded preemptions which are avoided by the algorithm according to FIG. invention (Figure 5).

It should be noted that the introduction of the algorithm according to the invention does not modify the feasibility conditions of conventional algorithms which is, for example in the case of the EDF algorithm, that, U being the maximum rate of use of the processor : nz " ¹ / i = l / '

Claims

A method for managing preemptions between at least two tasks having different priorities in a real-time operating system, characterized in that during a request to execute a task having a higher priority than that of the current job, the execution of the current job is interrupted only after a calculated time interval to allow at least the current job and the higher priority job to be executed before end of the execution times assigned to them and characterized in that for the management of the preemption of several tasks whose indices i are chosen so that the tasks are classified in increasing order of the execution time, the index 1 being assigned to the task with the shortest execution time, and so on up to the index p which is assigned to the task whose execution time is the longest, the time interval NPi of no preemption of the rank i task has the value:

NP ₁ = Mm (NP ₁ ,, ^) with

P ₁ designating the execution time assigned to the task T ₁

C ₁ designating the duration of execution in the worst case of the task T ₁

2. Method according to claim 1 characterized in that said time interval is calculated for each task in a fixed manner taking into account the execution of all other tasks that may have a higher priority.

3. Method according to claim 2 characterized in that said time intervals are precalculated.

4. Method according to claim 1 characterized in that said time interval is determined for the current task dynamically taking into account all the other tasks having a higher priority and for which an execution request is formed.

5. Method according to claim 4 characterized in that said time interval of the current task is updated each time an execution request is formed for a task having a higher priority than the current task.

6. Method according to one of the preceding claims, characterized in that the tasks have a fixed priority.

7. Method according to one of claims 1 to 5, characterized in that the tasks have a dynamic priority.

8. Method according to claim 1 characterized in that said time interval NPj is computed in a fixed manner taking into account all other tasks having a shorter execution time than the execution time Pj of the current task Tj and in that the current task Tj can only be preempted by a task having a turnaround time which is less than its execution time Pj.

9. Method according to claim 1 characterized in that said NPj time interval is dynamically calculated by taking into account all the tasks called for execution and having an absolute deadline prior to that of the current task T, and in that that the current task can only be preempted by a task with an absolute deadline before its absolute deadline d ,.