Scheduling Slack Time in Fixed Priority Pre-emptive Systems

Transcription

1 Scheduling Slack Tie in Fixed Priority Pre-eptive Systes R.I.Davis, K.W.Tindell, A.Burns Departent of Coputer Science, University of York, England. Abstract This paper addresses the proble of jointly scheduling tasks with both hard and soft tie constraints. We present a new analysis which builds upon previous research into slack stealing algoriths. Our analysis deterines the axiu processing tie which ay be stolen fro hard deadline periodic or sporadic tasks, without jeopardising their tiing constraints. It extends to tasks with characteristics such as synchronisation, release jitter and stochastic execution ties, as well as foring the basis for a faily of optial and approxiate slack stealing algoriths. 1. Introduction In a recent paper [7], Lehoczky and Raos-Thuel presented a new approach to servicing aperiodic requests within the context of a hard real-tie syste. Their ethod, known as the Slack Stealer is applicable to systes scheduled using a fixed priority pre-eptive dispatcher, with priorities assigned according to a policy such as the Rate Monotonic algorith [11]. The Slack Stealer addresses the proble of iniising the response ties of soft aperiodic tasks whilst guaranteeing that the deadlines of hard periodics are et. In this paper, we present new analysis which fors the basis of other ore generally applicable slack stealing algoriths. The proble of jointly scheduling both hard and soft deadline tasks is an iportant issue in any real-tie systes. This is due to tension between the scheduling requireents of tasks in the two categories. Typically, soft tasks benefit fro being delivered as early as possible, whilst hard tasks need to be guaranteed to eet their deadlines. Further, it is expected that future realtie systes ay include optional soft tasks, which can be used to increase the precision, utility or confidence level of hard real-tie services [3]. These soft tasks do not constitute background services but are inextricably linked to the behaviour of the set of hard tasks. Clearly if soft tasks of this type are to provide benefit to the syste, then they need to be allowed soe execution tie prior to the deadline of the hard service which they support. Analysis of fixed priority pre-eptive scheduling has provided a sound theoretical basis for designing predictable hard real-tie systes [1, 9]. Within this fraework, a nuber of approaches have been developed for scheduling ixed task sets. The siplest and perhaps least effective of these is to execute soft deadline tasks at a lower priority level than any of those with hard deadlines. This effectively relegates the soft tasks to background processing. Alternatively, soft tasks ay be run at a higher priority under the control of a pseudo hard realtie server task, such as a siple polling server. A polling server is a periodic task with a fixed priority level (usually the highest) and an execution capacity. The capacity of the server is calculated off-line and is norally set to the axiu possible, such that the hard task set, including server, is schedulable. At run-tie, the polling server is released periodically and its capacity is used to service soft real-tie tasks. Once this capacity has been exhausted, execution is suspended until it can be replenished at the server s next release. The polling server will usually significantly iprove the response ties of soft tasks over background processing. However, if the ready soft tasks exceed the capacity of the server, then soe of the will have to wait until its next release, leading to potentially long response ties. Conversely, no soft tasks ay be ready when the server is released, wasting its high priority capacity. This latter drawback is avoided by the Priority Exchange, Deferrable server [8] and Sporadic server [13] algoriths. These are all based on siilar principles to the polling server. However, they are able to preserve capacity if no soft tasks are pending when they are released. Due to this property, they are tered "bandwidth preserving algoriths". The three algoriths differ in the ways in which the capacity of the server is preserved and replenished and in the schedulability analysis needed to deterine their axiu capacity. In general, all three offer iproved responsiveness over the polling approach. However, there are still disadvantages with these ore coplex server algoriths.

2 They are unable to ake use of slack tie which ay be present due to the often favourable phasing of periodic tasks (i.e. not worst case). Further, they tend to degrade to providing essentially the sae perforance as the polling server at high loads. The Deferrable and Sporadic servers are also unable to reclai spare capacity gained, when for exaple, hard tasks require less than their worst case execution tie. This spare capacity, tered gain tie, can however be reclaied by the Extended Priority Exchange algorith [14]. The Slack Stealing algorith of Lehoczky and Raos-Thuel [7] suffers fro none of these disadvantages. It is optial in the sense that it iniises the response ties of soft aperiodic tasks aongst all algoriths which eet all hard periodic task deadlines. The Slack Stealer services aperiodic requests by aking any spare processing tie available as soon as possible. In doing so, it effectively steals slack fro the hard deadline periodic tasks. A eans of deterining the axiu aount of slack which ay be stolen, without jeopardising the hard tiing constraints, is thus key to the operation of the algorith. In [7] Lehoczky and Raos-Thuel describe how the slack available can be found. This is done by apping out the processor schedule for the hard periodic tasks over their hyperperiod (the least coon ultiple of task periods). The apping is then inspected to deterine the slack present between the deadline on one invocation of a task and the next. The values found are stored in a table. At run-tie, a set of counters are used to keep track of the slack which ay be stolen at each priority level. These counters are decreented depending on which tasks, if any, are executing and updated by reference to the table, at the copletion of each task. Whenever, the counters indicate that there is slack available at all priority levels, then soft tasks ay be executed at the highest priority level. Unfortunately, the need to ap out the hyperperiod restricts the applicability of the Slack Stealer: Slack can only be stolen fro hard deadline tasks which are strictly periodic and have no release jitter [1] or synchronisation. Realistically, it is also liited to task sets with a anageably short hyperperiod. This is a significant restriction, as even odest task sets (e.g. 10 tasks) ay have very long hyperperiods. In this paper, we extend the deadline onotonic analysis given by Audsley et al [2] to deterine the slack which ay be stolen fro both hard deadline sporadic and hard deadline periodic tasks. This new analysis fors the basis for a dynaic slack stealing algorith, which we prove to be optial. The dynaic slack stealer is equivalent to the static Slack Stealer of Lehoczky and Raos-Thuel, in the liited case of independent periodic tasks. However, by virtue of coputing the slack at runtie, the dynaic algorith is applicable to a ore general class of scheduling probles including hard deadline sporadics and tasks which exhibit release jitter and synchronisation. Further, the dynaic algorith is able to iprove the response ties of soft tasks by exploiting run-tie inforation about hard task execution requireents, extended inter-arrival ties and deadlines. It can also be readily extended to cover a broad spectru of other task characteristics. Unfortunately, the execution tie overhead of the optial dynaic algorith is such that it is infeasible in practice. We address this proble by presenting a faily of approxiate algoriths which provide close to optial perforance with practical utility. In section 2, we outline the coputational odel and assuptions used. Section 3 presents analysis of the axiu aount of slack which ay be stolen at each priority level. This is used as the basis for the dynaic algorith. In section 4, we show how our analysis can be extended to tasks which exhibit blocking and release jitter. Further, we exaine how gain tie can be reclaied fro tasks which require less than their worst case execution tie or extend their current period or deadline. We also briefly discuss resource sharing between hard and soft tasks and give an outline of how tasks with arbitrary deadlines ay be incorporated into our odel. In section 5, we consider the ipleentation of approxiate slack stealing algoriths and copare their perforance to that of the optial algorith. Finally, we briefly discuss the overheads involved in calculating slack dynaically. Section 6 offers our conclusions. 2. Coputational odel and assuptions In this paper, we consider the scheduling of n hard deadline tasks on a single processor. The analysis given, is however, equally applicable to ultiprocessor systes with a static allocation of tasks. Each task has a base priority i where 1 i n, thus 1 is the highest priority level and n the lowest. We use hp (i ) to denote the set of tasks with a higher base priority than i and lp (i ) to denote the tasks with base priority i or lower. Each task gives rise to an infinite sequence of invocation requests, separated by a inial inter-arrival tie T i. Each invocation of task i perfors an aount of coputation between 0 and C i (its bounded worst case execution tie) and has a deadline D i easured relative to the tie of the request. Further, each task ay lock and unlock seaphores according to the Priority Ceiling Protocol [12]. The worst case blocking tie which an invocation of task i can experience due to the operation of this protocol is denoted by B i. Although the tasks are assigned unique static priorities, they ay have their priorities

3 teporarily increased due to priority inheritance, as part of the operation of the Priority Ceiling Protocol. Finally, tasks can arrive at any tie after their iniu interarrival interval, but be delayed for a variable but bounded aount of tie (tered the release jitter, J i ) before being placed on a notional run-queue by the dispatcher, they are then said to be released. The analysis presented in section 3 uses the concept of busy and idle periods [6]. These are defined as follows: A level i busy period is a continuous tie interval during which the notional run-queue contains one or ore tasks of priority level i or higher. Siilarly, a level i idle period is a tie interval during which the run-queue is free of level i or higher priority tasks. (We note that the run queue ay becoe oentarily free of level i tasks, when one tasks copletes and another is released. This appears in our forulation as an idle period of zero length.) In subsequent sections, the following assuptions apply: The hard deadline task set is assued to be schedulable using fixed priority pre-eptive dispatching with a priority ordering deterined by soe eans such as deadline onotonic priority assignent [10]. All overheads for context switching, scheduling etc. are subsued into the worst case execution ties and blocking factors. Tasks cannot voluntarily suspend theselves. 3. Schedulability Analysis In this section, we deterine the axiu aount of processing tie which ay be stolen fro an invocation of a hard deadline task without causing its deadline to be issed. For clarity, we initially assue that the task set exhibits no synchronisation or release jitter and that each invocation takes its worst case execution tie. Further, we assue that the deadline of each task is less than or equal to its iniu inter-arrival tie. In section 4, we relax these assuptions. Our forulation stes fro considering the schedulability of each hard real-tie task at soe arbitrary tie t. We assue that at tie t, the following data is available via the operating syste, (typically derived fro data stored in a task control block): l i,t The tie at which task i was last released. x i,t The earliest possible next release of task i. Typically x i,t = l i,t + T i. d i,t The next deadline on an invocation of task i. (Note, if the current invocation of task i is coplete, then d i,t = x i,t + D i, i.e. d i,t is the deadline following the next release). c i,t The reaining execution tie budget for the current invocation of task i. Typically found by subtracting the execution tie used fro the worst case execution tie, C i. (Note, if at tie t task i is coplete and thus awaiting release, then c i,t = 0). Note, l i,t, x i,t and d i,t are all easured relative to tie t. Initially, we focus on finding the axiu aount of slack tie, S ax i,t, which ay be stolen at priority level i, during the interval [t, t + d i,t ), whilst guaranteeing that task i eets its deadline. (Note, S ax i,t ay not actually be available for soft task processing due to the constraints on hard deadline tasks with priorities lower than i. We return to this point in section 3.1.) To guarantee that task i will eet its deadline, we need to analyse the worst case scenario fro tie t onwards. We therefore assue that all tasks j are re-invoked at their earliest possible next release x j,t and subsequently with a period of T j. In attepting to deterine the axiu guaranteed slack, S ax i,t, it is instructive to view the interval [t, t + d i,t ) as coprising a nuber of level i busy and idle periods. Any level i idle tie between the copletion of task i and its deadline could be swapped for task i coputation without causing the deadline to be issed. Hence the axiu slack which ay be stolen is equal to the total level i idle tie in the interval. We use this result to calculate S ax i,t. Our ethod for finding the level i idle tie relies on two equations: equation (1), deterines w i,t, the length of a level i busy period which starts at tie t. Equation (2) deterines the length of a level i idle period given its start tie. By cobining these two equations, we are able to iterate over the interval [t, t + d i,t ), totaling up all the idle tie, and hence find S ax i,t. We first derive equation (1) using techniques given in [1]; two coponents deterine the extent of the busy period: 1. The level i or higher priority processing outstanding at tie t. 2. The level i or higher priority processing released during the busy period. The second coponent iplies a recursive definition. As the processing released increases onotonically with the length of the busy period, a recurrence relation can be used to find w i,t : Note, (x ) 0 is notational shorthand for ax(x,0), i.e. the iniu value of (x ) 0 is zero. y is notation for the ceiling function.

4 w +1 i,t = S i,t + Σ j hp (i ) i c j,t + (w i,t x j,t ) 0 C j (1) The ter S i,t represents level i slack processing released at tie t. We return to this shortly. The recurrence relation begins with w 0 i,t = 0 and ends when w +1 i,t = w n i or w +1 i,t >d i,t. Proof of convergence follows fro analysis of siilar recurrence relations by Joseph and Pandya [5] and Audsley et al [1]. The final value of w i,t defines the length of the busy period. Alternatively, we ay view t + w i,t as defining the start of a level i idle period. Given the start of a level i idle period, within the interval [t, t + d i,t ), the end of the idle tie, which ay be converted to slack, occurs either at the next release of a task of priority i or higher or at the end of the interval. Equation (2) gives the length, v i (w i,t ), of the level i idle window. (d i,t w i,t ) 0, v i,t (w i,t ) = in w i,t x j,t in T j hp (i ) i T j + x j,t w i,t j 0 (2) Cobining equations (1) and (2), our ethod for deterining the axiu slack, S ax i,t, proceeds as follows: 1. The slack which ay be stolen, S i,t, is initially set to zero. 2. Equation (1) is used to copute the end of a busy period in the interval [t, t + d i,t ). 3. The end of the busy period is used as the start of an idle period by equation (2) which returns the length of contiguous idle tie. 4. The slack processing, S i,t is increented by the aount of idle tie found in step If the deadline on task i has been reached, then the axiu slack which can be stolen is given by S i,t. Otherwise, we repeat steps 2 to 5. This ethod can be ipleented as detailed in algorith (3). The coplexity of the above approach is O(n) where is the nuber of iterations and n is the nuber of hard deadline tasks. Hence, coputing the exact slack available at all n priority levels can be done in O(n 2 ) tie. We note that the nuber of iterations,, depends on the periods and deadlines of the hard tasks, thus the coplexity of algorith (3) is pseudo-polynoial. T j Algorith for deterining the level i slack S i,t = 0 w +1 i,t = 0 do while w +1 i,t d i,t w +1 i,t = w i,t w +1 i,t = S i,t + Σ (w i,t x j,t ) c j,t + 0 C j hp (i ) i T j j if w +1 i,t = w i,t then S i,t = S i,t + v i,t (w i,t ) +ε w +1 i,t = w +1 i,t + v i,t (w i,t ) +ε endif S ax i,t = S i,t ε (3) (Note: ε, set to the granularity of tie, is a atheatical device used to force the recurrence relation to continue.) If the schedulability of the hard task set has been guaranteed off-line, then S ax i,t will always be greater than or equal to zero. However, if the hard task set is not guaranteed, then algorith (3) provides early error detection as S ax i,t < 0 indicates that task i could iss its next deadline. It is iportant to note that the above forulation is applicable regardless of whether each hard deadline task is periodic or sporadic. Further, it can be readily extended to handle ore coplex task characteristics. (See section 4.) 3.1. Dynaic slack stealing algorith In this section, we use our previous analysis as the basis for a dynaic slack stealing algorith. We require that soft tasks are executed as soon as possible, such that the deadlines on all hard real-tie tasks are still guaranteed to be et. In the case of strictly periodic tasks discussed by Lehoczky and Raos-Thuel [7], this can be achieved by servicing soft tasks at the highest priority, when there is slack available at all priority levels. However, when hard sporadic tasks are considered, there are probles with this approach. Suppose, at tie t there are soft tasks pending and the highest priority hard task in the run-queue is task k. Further, suppose a hard sporadic task with priority higher than k has zero slack (say D = C for this task) and could arrive at any tie. This sporadic task ay never arrive, preventing slack fro ever being available at all priority levels. To avoid the above proble, we use a different criteria for deterining when soft tasks ay execute. Our analysis guarantees that, provided level k soft task

5 processing is liited to S ax k,t in the interval [t, t + d k,t ) then hard tasks at priority levels k and higher will eet their deadlines. As we require that the deadlines of all hard real-tie tasks are et, soft task processing is only perissible at priority k whilst there is slack present at priority level k and all lower levels: in S ax j,t > 0 (4) j lp (k ) (Note, for copleteness, when there are no hard tasks runnable, we regard there as being infinite slack available at priority level n+1). Provided inequality (4) is true, soft tasks can execute at priority k, (in preference to hard task k) even though higher priority sporadics apparently have zero slack. Using the above result, the dynaic slack stealing algorith is forulated as follows: Whenever there are soft tasks pending, algorith (3) is used to find the slack available at each priority level lower than or equal to k. Where k is the priority level of the highest priority runnable hard task. Inequality (4) is then used to deterine if soft task processing can proceed iediately in preference to task k. We note that the dynaic algorith, described above, potentially requires the slack at each priority level to be re-coputed at each tie increent. We explore this proble further in section Optiality of the dynaic algorith In this section, we prove that the dynaic slack stealing algorith described above is optial. Theore: For any hard deadline task set scheduled according to a fixed priority schee and a strea of soft deadline tasks processed in FIFO order, the dynaic slack stealing algorith, iniises the response tie of every soft task, aongst all algoriths which are guaranteed to eet all hard task deadlines. (Note, we exclude clairvoyant algoriths which ay use prior knowledge of sporadic arrivals.) Proof: We prove the theore by showing that any alternative algorith, A, which results in a shorter response tie for any soft task cannot guarantee that the deadlines of all the hard tasks will be et. Let f be the first soft task which has a shorter response tie when scheduled by algorith A. As f is the first such task, the response ties of all previously serviced soft tasks ust be the sae as, or longer than when scheduled by the dynaic slack stealer. Thus f reaches the head of the queue no earlier when scheduled by algorith A. Once at the head of the queue, f is serviced by the dynaic slack stealer so long as inequality (4) reains true. For algorith A to result in a lower response tie, it ust process f for at least one clock tick when the dynaic slack stealer is unable to do so. We denote the tie at which this occurs by t. Further, we assue that the highest priority runnable task at tie t is task k. The dynaic slack stealer uses the exact upper bound on the slack which ay be stolen, this is zero at tie t. Hence at least one of the hard deadline tasks with priority equal to or lower than k has zero slack at tie t, let this be task i. In servicing soft task f at tie t, algorith A has therefore lengthened the worst case level i busy period culinating in the copletion of task i beyond its deadline. Algorith A cannot therefore guarantee that the deadline of task i will be et. A siple induction arguent proves that the dynaic slack stealer iniises the response ties of all the soft tasks. We note that the dynaic slack stealer is optial for stealing slack fro both periodic and sporadic tasks with hard deadlines. In the case of task sets coprising only periodic tasks, its behaviour is equivalent to the static, table driven Slack Stealing algorith of Lehoczky and Raos-Thuel. We return to this point in section Feasibility of the dynaic algorith We now seek to reduce the run-tie overheads of the dynaic algorith. To do this, we exaine the feasibility of deriving the slack available at soe later tie t fro the values coputed at tie t. First, we assue that no hard tasks coplete during the interval [t, t ) and that each task i is released at t + x i,t and subsequently with a period of T i. By considering the level i idle tie in the intervals [t, t + d i,t ) and [t, t + d i,t ), it can be seen that, if the processor serviced soft tasks or was idle between t and t then slack is consued at all priority levels: j hp (i ) lp (i ): S ax j,t = S ax j,t ( t t ) (5) Whereas, if the processor was busy with hard deadline task i, then slack is consued at all priority levels higher than i: j hp (i ): S ax j,t = S ax j,t ( t t ) (6) Next, we consider the effect of task i copleting on the level i slack. The next deadline which task i could iss increases by at least T i when it copletes. As any level i idle tie in the interval [t, t + d i,t ) ust also be present in [t, t + d i,t + T i ), the level i slack cannot be reduced when task i copletes. On the contrary, it ay well be increased. Hence, for stealing slack fro strictly periodic hard deadline tasks we need only re-copute the level i slack each tie task i copletes. (Note, the level i slack present iediately prior to copletion provides a lower bound which can be used as an initial value for S i,t in algorith (3), reducing the coputation required.) Finally, we consider the effect of sporadic tasks not

6 arriving at their axiu rate. Suppose a sporadic task i is not released at its earliest possible next release tie, t 1, but at soe later tie t 2. Equations (5) and (6) provide a lower bound on the level i slack at tie t 2. However, the deadline on the request at t 2 is later than it would have been had the request occurred at tie t 1, potentially increasing the slack. Therefore to ensure that we have the exact upper bound on the slack available, we are copelled to re-evaluate S ax i at each tie increent in the interval [t 1, t 2 ]. Again, this ay be done using the lower bound given by equations (5) and (6) as an initial value. In addition to the possible increase in level i slack, the interference on lower priority tasks ay be reduced. (This can be seen by exaining the effect of increasing the values of x j,t in algorith (3)). To retain optiality, we are therefore copelled to also re-evaluate the slack available at all priority levels lower than i. With a large nuber of sporadic tasks, the exact slack available at each priority level can potentially change on each processor clock tick. Thus the slack at each priority level ay still need to be re-evaluated at each clock tick. Clearly, this is infeasible in practice. It does however provide us with an optial algorith for stealing slack fro both hard deadline periodic and sporadic tasks. Moreover, it fors the basis for approxiate, but ore efficient, slack stealing algoriths which we discuss in section Extensions The analysis given in section 3 extends the scope of slack stealing algoriths to task sets coprising hard deadline sporadic as well as periodic tasks. In this section, we augent this analysis further, to handle tasks which exhibit stochastic execution ties, release jitter and blocking. We also discuss resource sharing between hard and soft tasks. Finally, we briefly outline how tasks with arbitrary deadlines ay be incorporated into our odel Reclaiing Gain Tie Gain tie is generated when a guaranteed hard deadline task requires less than its worst case execution tie. Gain tie ay be identified at various points during the execution of a task: for exaple, at the start by inspecting the task s input paraeters. (These can have a critical influence on the execution path, by deterining the nuber of ties around a loop etc.) Using this run-tie inforation, a less pessiistic, specific worst case execution tie can be calculated [15]. Alternatively, gain tie ay be identified part way through task execution via ilestones [4]. The ilestones separate the task into sections each of which has a worst case execution tie. This enables gain tie to be identified when a section copletes in less than its worst case tie. Finally, gain tie can be identified when the entire task copletes in less than its worst case tie. The analysis given in section 3 requires no odification to reclai gain tie. The worst case execution tie reaining, c i,t, is norally found by subtracting the execution tie used fro the worst case execution tie, C i. However, the three ethods of identifying gain tie described above ay be used to provide less pessiistic values for c i,t, enabling algorith (3) to reclai gain tie as slack. In fact, gain tie ay be directly added to the slack available without recourse to algorith (3): Suppose gain tie g i is identified at level i, then the slack available at level i and all lower priority levels is increased by g i [7]. Additional slack ay also be generated when it is known that the next release of a sporadic task will occur after a tie greater than its iniu inter-arrival tie. An exaple of this is a task which carries out soe operation when a easured value reaches a certain level. It is assued that the axiu rate of change of the value is known. Once a easureent has been taken, it is often possible to deterine when the task should be next released, so that it is guaranteed not to iss the value reaching its specified level. Thus the task operates with a guaranteed iniu period when the value is close to its critical level and less frequently otherwise. In the above scenario, an extended earliest possible release, x i,t, of an invocation ay result in increased slack tie. Siilarly if the deadline on a hard real-tie service is dependent on the external environent, it will be guaranteed at a iniu acceptable level, however, at run-tie, the deadline on specific invocations ay be increased. Again this is potentially a source of gain tie. It is interesting to note the effect of executing an independent hard deadline task i in slack tie (i.e. effectively at a raised priority). This results in gain tie being generated at level i, whilst slack tie is reduced at all priority levels. The gain tie produced ay be transfored into slack at level i and below, illustrating the equivalence between slack and gain tie Release jitter When a task is subject to a bounded delay between its arrival and release, it is said to exhibit release jitter [1]. To incorporate release jitter into our analysis, we need only consider the effect on the earliest possible next release of each task. We also assue that there ay only be one invocation of each task present at any given tie, hence D i + J i T i. For each task i with release jitter, we odify the calculation of x i,t as follows: x i,t = (l i,t + T i J i ) 0 (7)

7 4.3. Blocking We now relax the assuption that the hard real-tie tasks are independent. We assue that each invocation of a task i ay lock and unlock seaphores according to the Priority Ceiling Protocol. Each invocation of task i ay therefore be blocked for at ost B i, the worst case blocking tie. Where B i is equal to the longest critical section of any lower priority task which accesses a seaphore with a ceiling priority of i or higher [12]. For the oent, we assue that for Sha et al s analysis of the Priority Ceiling Protocol to hold, we require that no seaphores, used by hard deadline tasks, ay be accessed by any task executing in slack tie, (we return to this point in section 4.4). In section 3, we derived the slack available fro a consideration of busy and idle periods. Taking account of seaphore access, task i ay be blocked for at ost B i, extending the busy period given by equation (1). As the busy period includes precisely one invocation of task i, we augent our analysis by including the blocking factor in equation (1). (Siilar changes are needed to algorith (3).) w +1 i,t = B i + S i,t + Σ (w i,t x j,t ) c j,t + 0 C j hp (i ) i T j j (8) We note that this represents the pessiistic view that task i will always be subject to blocking. However, at run-tie, it is possible to deterine a less pessiistic bound on the tie for which the current invocation of a task i could be blocked. The dynaic slack stealing algorith can be augented to use this inforation and thus reclai unused blocking tie. Unfortunately, space considerations prevent us fro describing our research in this area Resource sharing between hard and soft tasks We now briefly consider the situation where a soft task shares one or ore seaphores with the hard deadline tasks. Suppose that the soft task wishes to lock a seaphore with ceiling priority j. The deadlines of tasks at priority levels j or lower could be jeopardised by being blocked by the soft task. To ensure that this cannot happen, the soft task ust be guaranteed sufficient slack processing tie to coplete its critical section, prior to the continued execution of any tasks of priority j or lower. Only then can it be allowed to lock the seaphore. If the length of the critical section is bounded by c, the ceiling priority of the seaphore is j and the tie of the request is t, then the soft task is only allowed to succeed in locking the seaphore if: in S ax i,t c (9) i lp (j ) Provided the above condition holds, only hard tasks with priority higher than j can pre-ept execution of the soft task s critical section. Fro the definition of the priority ceiling, none of these higher priority tasks use the seaphore and hence none of the can be blocked by the soft task. Further, the soft task is guaranteed execution tie of at least c in preference to hard tasks of priority j and lower. It is therefore able to coplete its critical section before being pre-epted by any task of priority j or lower. Thus using the criteria given in (9) resources ay be shared between hard and soft tasks without increasing the blocking on any hard task Arbitrary deadlines Tasks can be peritted arbitrary deadlines (i.e. D i >T i ) [6] by cobining the analysis of Tindell et al [16, 17] with that given in section 3. To find the worst-case response tie of a task i the arbitrary deadline analysis exaines a nuber of level i busy periods and takes the largest response tie corresponding to each of these. To apply the arbitrary deadline analysis to the algorith for deterining slack (3), we ust check when evaluating a level i busy period to see if the end of the busy period exceeds the subsequent release of task i, denoted by y i,t = d i,t D i + T i (i.e. if w i,t >y i,t ). If it does then we ust deterine if the level i slack is liited by the invocation of task i released at y i,t. This is done by exaining another level i busy period starting at tie t but including additional coputation tie C i. If this new busy period exceeds the subsequent invocation of task i (i.e. w i,t >y i,t + T i ), then we ust check if the slack is liited by the invocation of task i released at y i,t + T i. To do this, we exaine a further busy period, again starting at tie t, but including additional coputation tie 2C i. In general, if the (q 1)th busy period exceeds y i,t + qt i we need to check if the level i slack is liited by the invocation of task i released at y i,t + qt i. The slack available at level i is then the iniu of the slack on each of the q invocations exained. This value is used as before, in inequality (4) to deterine whether soft task processing ay take place. The algorith for deterining slack extends the busy period to d i,t + qt i which given D i >T i, always exceeds the next release of task i. The sequence of busy periods which require exaination is therefore potentially infinite. The invocation of task i with the least slack ust however, be one of the first h i exained, (where h i is the nuber of invocations of task i in H i, the hyperperiod of the subset of tasks with priority i and higher). This can be seen by considering the slack on the qth and (q + h i )th invocations of task i. All the level i idle tie in H i lies between these two invocations, hence the slack on the (q + h i )th invocation exceeds that on the q th by the level i

8 idle tie in the level i hyperperiod. Thus the invocation with the least slack ust be one of the first h i. As noted earlier, the hyperperiod of task sets is often very large, hence exaining h i invocations is infeasible in practice. The authors have therefore developed an iprecise algorith which provides a lower bound on the available slack and converges to the exact value. The detailed operation of this algorith is however beyond the scope of this paper. 5. Approxiate slack stealing algoriths In this section, we discuss approxiations to the optial dynaic algorith. Here, our ai is to produce slack stealing algoriths which are efficient enough for runtie usage. First we consider stealing slack fro purely periodic task sets. We indicate how our analysis can be used in an algorith which replicates the behaviour of the optial Slack Stealer of Lehoczky and Raos-Thuel. We then present an approxiate algorith which can be used to steal slack fro both hard deadline periodic and sporadic tasks. We copare the perforance of this algorith to the optial and background processing ethods. Finally, we discuss the overheads of the approxiate algorith and their justification in ters of iproved soft task response ties. For hard deadline periodic task sets, the slack available at priority level i only increases when task i copletes. We ay therefore replicate the behaviour of optial Slack Stealer of Lehoczky and Raos-Thuel by using algorith (3) to calculate S ax i,t at each copletion of task i. Equations (5) and (6) are then used to keep track of the slack available at other ties. The overhead of coputing the slack can be reduced by a priori calculation of the least additional slack, S add i, which becoes available at every copletion of task i. This enables a less pessiistic initial value for S i,t to be used in algorith(3), thus reducing coputation. The least additional level i slack is generated when task i copletes as late as possible (i.e. at its deadline) and the subsequent invocation is subject to the axiu interference fro higher priority tasks. Maxiu interference occurs when all higher priority tasks are released at the above deadline. This is effectively a critical instant [11] for task i. Thus S add i is equivalent to the level i idle tie in the interval [0, T i ) where tie 0 is a critical instant. Algorith (3) ay be used to calculate the value of S add i off-line. We ay ipleent a siple slack stealing algorith by increenting the level i slack available by S add i at each copletion of task i, whilst again using equations (5) and (6) to keep track of the slack at other ties. Our approxiate slack stealing algorith coprises this siple algorith augented by periodically evaluating the exact slack available at all priority levels. Varying the period at which this is done enables the overhead of the dynaic slack stealer to be traded off against a decrease in the responsiveness of soft tasks. A very short period iniises the response ties of soft tasks at the expense of a large overhead (c.f. the optial dynaic algorith). Whilst a very long period iniises the overhead, but increases the response ties. In the next section, we exaine this perforance trade-off Perforance coparison For evaluation purposes, we used sets of hard deadline periodic tasks, enabling coparisons to be ade between the approxiate algorith described above and the optial Slack Stealer of Lehoczky and Raos-Thuel. Our results are averaged over 10 task sets, each coprising 10 hard deadline periodic tasks. The periods of the hard deadline tasks were chosen at rando in the range 2 to 1000 ticks. Deadlines were randoly chosen, but constrained to be less than or equal to the period. Finally coputation ties were adjusted randoly until the total processor utilisation of the hard deadline task set was approxiately 50%. Each task set was then subject to a sufficient and necessary schedulability test. Unschedulable task sets were discarded. The soft task load was siulated by a FIFO queue of tasks, each requiring 1 tick of processing tie. The arrival ties of the soft tasks followed a unifor distribution over the test duration ( ticks). The nuber of soft tasks was varied to produce a siulated total processor loading of 80%, 85%, 90% and 95%. For each utilisation level, we recorded the response tie of each soft task scheduled by background, optial and approxiate slack stealing algoriths. In the case of the approxiate algorith, the siulation was repeated using periods of 250, 500, 1000, 2000, 4000, 8000, and ticks between calculations of the exact slack available. Figure 1 shows how the ean response tie of the soft tasks varied with the period of the approxiate slack stealing algorith for the four values of processor loading. (Note, for coparison purposes, the ean response ties of soft tasks scheduled by the optial algorith are plotted on the left, whilst corresponding values for background processing are plotted on the right). The graph shows that for all loadings the ean response tie of soft tasks, scheduled by the approxiate algorith, was very close to the optial provided the period of the approxiate algorith was less than the ean task period (500 ticks). Increasing the period of the approxiate algorith resulted in decreased responsiveness, until with a large period (32000), it was close to that of background.

9 Mean 50 Response 40 Tie of Soft Tasks Approxiate Optial B Period Figure 1. Perforance of the approxiate slack stealing algorith A Background Processor loading - 95% x - 90% - 85% o - 80% (We note that all the hard task sets used in the test were close to the schedulability bound. This represents a severe test of slack scheduling algoriths. Under these conditions, algoriths which cannot take advantage of favourable task phasing fair little better than background processing.) Figure 1 also shows that the coputation of exact slack does not need to be co-ordinated with hard task copletion in order to ensure highly responsive soft task processing. This is an iportant result as it allows flexibility in scheduling the coputation of slack, (for exaple as a soft task scheduled in slack tie) Overheads The eory requireents of the approxiate algorith are generally uch lower than those of the static Slack Stealer of Lehoczky and Raos-Thuel. The static Slack Stealer uses a table of values for each invocation of each task over the hyperperiod. By coparison, the dynaic algorith requires eory for the task which coputes the exact slack and storage for the n values of c i, x i and d i. Both static and approxiate algoriths also require a set of n counters to record the slack available each priority level. The execution tie overhead of the approxiate algorith is uch higher than that of the static Slack Stealer due to the run-tie coputation of slack. This overhead increases the processor loading, reducing the responsiveness of soft tasks below the theoretical levels shown in figure 1. We now exaine to what degree, this overhead can be tolerated and still iprove response ties. Suppose we have a real-tie syste coprising one of the 85% loading task sets described above. Using an algorith which does not exploit run-tie inforation on task phasings, we can expect the ean response tie of the soft tasks to be approxiately 45 ticks (point A, figure 1). We next assue that the coputation of slack can be ipleented as a task with period and deadline of 1000 ticks and a processor loading of 5%. Using the approxiate algorith and including this overhead, we can expect the ean response tie of soft tasks to lie in the vicinity of point B on the 90% load curve of figure 1. This represents a response tie of 9 ticks, a factor of five iproveent. We easured the ean tie to copute the exact slack for all priority levels for sets of 10,15 and 20 hard deadline tasks. (The task sets were generated as described in section 5.1). Tiings were recorded using a Sun Sparc workstation. The ean coputation tie is given in the table below: Tiings No. Tasks Tie (s) Assuing that the task sets are typical of real task sets with 1 tick = 1s, the above figures represent a processor loading of between 0.1% and 1%. This is well below the level at which coputation of exact slack can be expected to iprove soft task response ties. These results show that although algorith (3) is pseudo-polynoial, there are any hard tasks sets for which the overheads of dynaically coputing slack are

10 justifiable. 6. Suary and Conclusions This paper extended previous research on slack stealing algoriths. New analysis was presented which allows the slack available on hard deadline periodic and hard deadline sporadic tasks to be calculated. This new analysis fors the basis of a dynaic slack stealing algorith which we proved to be optial. We augented our analysis to cater for tasks which have release jitter, synchronisation, stochastic execution ties and arbitrary deadlines. We then constructed an approxiate algorith and copared its perforance to the optiu. Siulation studies indicated that the approxiate algorith can offer significant iproveents over ethods which do not exploit run-tie phasing inforation. Furtherore, for the task sets studied, the overhead of dynaically coputing slack was shown to be justified. In light of these results, we intend to carry out further research into approxiate slack stealing algoriths using the Distributed Real-tie Execution Environent (DrTEE) currently being developed at the University of York. Acknowledgeents This work is supported, in part, by the UK Science and Engineering Research Council, Grant GR/H The authors would also like to thank the anonyous reviewers for their coents on an earlier draft of this paper. References 1. N. Audsley, A. Burns, M. Richardson, K. Tindell and A.J. Wellings, Applying New Scheduling Theory to Static Priority Pre-eptive Scheduling, Software Enginnering Journal (to appear). 2. N. C. Audsley, A. Burns, M. F. Richardson and A. J. Wellings, Hard Real-Tie Scheduling: The Deadline Monotonic Approach, Proceedings 8th IEEE Workshop on Real-Tie Operating Systes and Software, Atlanta, GA, USA (15-17 May 1991). 3. N. C. Audsley, A. Burns, M. F. Richardson and A. J. Wellings, Incorporating Unbounded Algoriths Into Predictable Real-Tie Systes, Coputer Systes Science and Engineering 8(3), pp (April 1993). 4. A. Dix, R. F. Stone and H. S. M. Zedan, Design Issues for Reliable Tie-Critical Systes, Proceedings of Workshop on Real-Tie Systes, University of York (Septeber 1989). 5. M. Joseph and P. Pandya, Finding Response Ties in a Real-Tie Syste, The Coputer Journal (British Coputer Society) 29(5), pp , Cabridge University Press (October 1986). 6. J. P. Lehoczky, Fixed Priority Scheduling of Periodic Task Sets With Arbitrary Deadlines, Proceedings 11th IEEE Real-Tie Systes Syposiu, Lake Buena Vista, FL, USA, pp (5-7 Deceber 1990). 7. J. P. Lehoczky and S. Raos-Thuel, An Optial Algorith for Scheduling Soft-Aperiodic Tasks Fixed-Priority Preeptive systes, Proceedings Real-Tie Systes Syposiu, pp (Deceber 1992). 8. J. P. Lehoczky, L. Sha and J. K. Strosnider, Enhanced Aperiodic Responsiveness in Hard Real-Tie Environents, Proceedings IEEE Real-Tie Syste Syposiu, San Jose, California, pp (1987). 9. J. Lehoczky, L. Sha and Y. Ding, The Rate-Monotonic Scheduling Algorith: Exact Characterization and Average Case Behaviour, Proceedings IEEE Real-Tie Systes Syposiu, Santa Monica, California, pp , IEEE Coputer Society Press (5-7 Deceber 1989). 10. J. Y. T. Leung and J. Whitehead, On the Coplexity of Fixed-Priority Scheduling of Periodic, Real-Tie Tasks, Perforance Evaluation (Netherlands) 2(4), pp (Deceber 1982). 11. C. L. Liu and J. W. Layland, Scheduling Algoriths for Multiprograing in a Hard Real-Tie Environent, Journal of the ACM 20(1), pp (1973). 12. L. Sha, R. Rajkuar and J. P. Lehoczky, Priority Inheritance Protocols: An Approach to Real-Tie Synchronisation, IEEE Transactions on Coputers 39(9), pp (Septeber 1990). 13. L. Sha, B. Sprunt and J. P. Lehoczky, Aperiodic Task Scheduling for Hard Real-Tie Systes, The Journal of Real-Tie Systes 1, pp (1989). 14. B. Sprunt, J. Lehoczky and L. Sha, Exploiting Unused Periodic Tie For Aperiodic Service Using the Extended Priority Exchange Algorith, Proceedings IEEE Real- Tie Systes Syposiu, pp (Deceber 1988). 15. J. A. Stankovic and K. Raaritha, The Spring Kernel: A New Paradig for Real-Tie Operating Systes, COINS Technical Report 88-97, Departent of Coputer and Inforation Science, University of Massachusetts at Aherst (Noveber 7, 1988). 16. K. Tindell, An Extendible Approach for Analysing Fixed Priority Hard Real-Tie Tasks, YCS189, Departent of Coputer Science, University of York (Deceber 1992). 17. K. Tindell, A. Burns and A.J. Wellings, An Extendible Approach for Analysing Fixed Priority Hard Real-Tie Tasks, Journal of Real Tie Systes (to appear).