Response Time Analysis for Tasks Scheduled under EDF within Fixed Priorities

Transcription

1 Response Time Analysis for Tasks Scheduled under EDF within Fixed Priorities M. González Harbour and J.C. Palencia Departamento de Electrónica y Computadores Universidad de Cantabria 39-Santander, SPAIN {mgh, palencij}@unican.es Abstract 1 Hierarchical schedulers are getting increased attention in many research projects because they bring in flexibility, they can take advantage of the best features of different scheduling policies, and allow the composability of applications developed under different scheduling strategies. Most commercial real-time operating systems have an underlying fixed priority scheduler, and for this reason it is necessary to be able to analyze hierarchically-scheduled applications in which the underlying scheduler is of that kind. In this paper we extend the classic response time analysis techniques to analyze applications which can have a mixture of tasks scheduled either with fixed priorities, or with an earliest deadline first (EDF) scheduler running on top of an underlying fixed priority scheduler. We show that the complexity of this analysis is similar to that of existing response time analysis for EDF tasks. 1. Introduction 1. This work has been funded by the Comisión Interministerial de Ciencia y Tecnología of the Spanish Government under grant TIC C3 and by the European Commission under grant IST FIRST Hierarchical schedulers are getting increased attention by many real-time researchers. It is well known that different application requirements are better matched by different scheduling policies. For example, earliest deadline first (EDF) and similar dynamic priority policies are well suited for multimedia systems in which a high throughput is important, while fixed priority systems are very common in control or high-integrity systems with more strict real-time requirements and where a more predictable mechanism is needed for handling overloads. Technology is making it possible to have systems with mixed applications and timing requirements, for example a control system that also has to process some multimedia information. In these systems the ideal scheduling strategy comes form mixing several schedulers, in some hierarchical way. Implementations of such hierarchical schedulers have been proposed. In RED Linux [23], a two-level scheduler is used, where the upper level is implemented as a user process that maps several quality of service parameters into a low-level attributes object to be handled by the lower level scheduler. In [16] and [3] the underlying scheduler is used to schedule real-time tasks, while the next level of scheduling is used for multimedia tasks. In [] and [7] hierarchical scheduling is used to integrate hard real-time with soft realtime tasks. The Jorvik scheduling framework [4] uses a hierarchical scheduler that can mix hard and soft periodic and aperiodic tasks. It maximizes the throughput of the system through the use of flexible scheduling schemes at one level, while ensuring that hard tasks that get very close to their deadlines are promoted to a higher level in the scheduling hierarchy to ensure that they meet their timing requirements. Techniques for analyzing timing requirements in such hierarchical schedulers have also been developed for some particular strategies. Because most commercial real-time operating systems have an underlying fixed priority scheduler it is necessary to be able to analyze hierarchicallyscheduled applications in which the underlying scheduler is of that kind. Unfortunately, to our knowledge this kind of analysis has not yet been developed. In this paper we extend the classic response time analysis techniques to analyze applications which can have a mixture of tasks scheduled either with fixed priorities, or with an earliest deadline first (EDF) scheduler running on top of an underlying fixed priority scheduler. We call this kind of scheduler EDF within priorities, because EDF scheduling is used for tasks of a given priority level, and several such EDF schedulers can coexist at different priority levels. An implementation of this scheduling framework is available in our MaRTE real-time operating system using the application-defined scheduling services [1]. 1

2 Response Time Analysis (RMA) [8][11] allows an exact calculation of the worst-case response time of tasks in single- and multi-processor real-time systems scheduled under fixed priorities, including the effects of task synchronization [17], the presence of aperiodic tasks, the effects of deadlines before, at or after the periods of the tasks [1] and tasks with precedence constraints in single processor systems[6]. Spuri [18] introduced response-time analysis techniques for EDF (Earliest-Deadline First) [11] based scheduling, similar to those existing for fixed priorities. The main difference between the EDF and FP (fixed priorities) techniques is that in the former, the task under analysis is no longer activated at the start of the busy period that leads to the worst-case response time. The release of the task under analysis, called the critical instant, may take place at a later instant in the busy period. This critical instant is not known in advance, and thus a set of possible values needs to be checked, making the analysis slower than the equivalent FP analysis. For multiprocessor and distributed hard real-time systems schedulability analysis techniques exist, such as the Holistic analysis [21], which make an independent analysis on each processing or communication resource, and then iterate over this analysis. Offset-based analysis techniques [22][12][13] make a global analysis of the distributed system and are able to eliminate much of the pessimism, obtaining response times that are significantly lower, and increasing the maximum schedulable utilization up to an additional 2%. In [19], Spuri adapted the Holistic Analysis technique to systems based on EDF schedulers. Later, in [14] we extended Spuri's techniques and the offset-based analysis techniques developed for fixed-priority systems to analyze systems based on dynamic priorities, under EDF. This extension allowed us to take advantage of the benefits that a global system-wide analysis has on improving the estimations of worst-case response times over the values obtained through the holistic analysis. Because offsetbased analysis techniques for EDF are very similar to those for fixed priorities, by combining the two it is possible to analyze heterogeneous systems in which some nodes are scheduled under EDF while others are scheduled under fixed priorities. Although the above techniques are capable of analyzing heterogeneous systems with a mixture of EDF and FP scheduling, the scheduling mechanism in each processing resource needs to be uniform, either EDF of FP. In this paper we extend Spuri s Analysis techniques to single processor systems in which a base fixed-priority scheduler schedules tasks using their priority value, and then other secondary EDF schedulers may exist, each used to schedule tasks of the same fixed priority. Fixed priorities take precedence over EDF scheduling, i.e., whenever there is a higher priority task, either with a fixed priority or belonging to an EDF scheduler working at a higher priority level, it will preempt any lower priority task, whether FP or EDF. This hierarchical composition of schedulers is called the EDF-within-priorities scheduling policy. This paper is restricted to the analysis of single processor systems with a set of periodic tasks which may need mutually exclusive synchronization to share data or resources. We do not impose any restriction of the deadlines. The paper is organized as follows. In Section 2 we specify the computational model of the system for which we develop the analysis. In section 3 we repeat Spuri s Analysis for EDF tasks, to make the paper self contained; a few notational changes will be introduced to align this work with the offset-based analysis techniques presented in [14]. In Section 4 we develop the analysis for EDF-within-priorities, separating the analysis of FP tasks from the analysis of EDF tasks. In Section we discuss the synchronization policies that can be used in a system with EDF-within-priorities schedulers, and we show how to calculate the blocking times. An example of applying the analysis techniques developed in the paper is presented in Section 6. Finally, in Section 7 we provide some conclusions. 2. Computational Model We will consider a task model with periodic tasks scheduled under the EDF-within-priorities policy. In this model, the system is composed of a set of n periodic tasks executing in a single processor. Each task τ i is activated periodically with a period of, and has a worst-case execution time of C i, a fixed priority P i, and a scheduling policy, S i, which can be FP or EDF. Each task activation or instance is called a job, and must execute before a deadline d i, relative to its activation time. Each task job can have a release jitter bounded by a maximum value J i, so the release of the task may be delayed a maximum of J i from its activation time. Both J i and d i may be greater than the task's period, in such a way that several activations of a task can be pending for execution at a given instant. Tasks may share resources and require mutual exclusion. We will assume that the delay effects of synchronization on any given task i can be modeled as a single blocking time, B i. We will use the immediate priority ceiling (IPC) protocol, originally introduced in [9] (also called Priority Ceiling Locking in Ada and Priority Protection in POSIX) for synchronization of fixed priority tasks as well as synchronization among priority levels, and the stack resource policy (SRP) [2] for EDF tasks of the same priority level. In Section we will justify this decision, we will describe the synchronization protocols and we will show how to calculate these B i terms. We also have to consider that in some 2

3 computations, only the delay effects caused by tasks of lower priority need to be considered. We will call this alternative blocking time B i. ipc Although we assume a periodic task model, the techniques presented in this paper can be applied to sporadic tasks (i.e., aperiodic tasks with a specific minimum interarrival time that can be used as the period for the purpose of worst-case analysis) and also to aperiodic tasks if appropriate techniques are used to bound the bandwidth allocated to them: for example, polling from a periodic task, or some kind of server technique, like the sporadic server for FP tasks, or a constant bandwidth server for EDF tasks. In summary, the notation used for the parameters of each task, τ i, is the following: Period ( > ) C i Worst-case execution time ( C i ) d i Relative deadline ( d i > ) ϕ i Initial phase ( ϕ i ) J i Maximum release jitter ( J i ) P i Fixed priority level; a larger value indicates a higher priority S i Scheduler; may be FP or EDF B i Blocking time: maximum delay that τ i may experience due to mutual exclusion synchronization ipc B i Blocking time by lower priority tasks: maximum delay that lower priority tasks may cause to the task under analysis due to mutual exclusion synchronization. For fixed priority tasks B i = B i. ipc Each task instance or job j is released at an instant a ij [ ϕ i + i, ϕ i + i + J i ]. The initial phase is usually not known, and may even drift. Therefore, it is not included in the worst-case analysis. Each task instance has an absolute deadline D ij = ϕ i + i + d i, i.e., the activation time (not the release time) plus the relative deadline. At each priority level P, all tasks must be either S i =FP or S i =EDF. Figure 1 shows an example of several tasks with different priorities and schedulers, where we can see that there can be several EDF schedulers, each at a different fixed priority level. No restrictions are placed on the jitter or the deadline, relative to the task s period. Context switch times are considered null. For each task τ i we define its worst-case response time as the maximum of the response times of all the jobs, each of which is defined as the difference between the job s completion time and its release time. The worst-case response time will be called R i. FP EDF FP FP EDF FP Fixed Priority t1 Task set t21 t22 t23 t3 t4 t1 t2 t3 t6 Figure 1. A Particular Application Configuration Using Hierarchical Schedulers 3. Analysis for EDF Periodic Tasks In this section we will analyze a task set that is scheduled under a preemptive EDF scheduler only, that is, if some tasks are ready to execute, the scheduler will run the task with the earliest deadline, relative to the current time. This implies a restriction on the computational model described in Section 2, by which all tasks have the same fixed priority (P 1 =P 2 =...P n ), and they are all scheduled under EDF (S 1 =S 2 =...S n =EDF). In [18] Spuri develop a method to calculate the worstcase response times of tasks under this model. We will present here that analysis technique with some changes in notation to align it with the offset-based analysis techniques presented in [14]. The response time analysis is based on the creation of the longest busy period. A busy period is defined for EDF scheduling as an interval of time during which the CPU is busy processing pending execution of any task. In fixed priority scheduling, the worst-case response time of a task τ a is found after a critical instant, when the activation of τ a coincides with the activation of all tasks with higher priority after having experienced the maximum jitter. In that situation, the critical instant coincides with the start of a busy period. In EDF scheduling that property is not true, but the busy period concept is still useful. The following theorem helps us to find the critical instant for a task: Theorem 1 (Spuri). The worst-case response time of a task τ a is found in a busy period in which all other tasks are released simultaneously at the beginning of the busy period, after having experienced their maximum jitter (i.e., each task τ i with an activation J i time units before the start of the busy period). Proof: Let t be the instant at which a task τ i is activated the first time in the busy period, and let D be the t7 t4 3

4 deadline of an instance of the analyzed task, τ a, relative to the beginning of the busy period. Suppose that t does not coincide with the beginning of the busy period: in this circumstance, if we move the activation pattern of τ i to occur earlier, down to the point when the first activation coincides with the beginning of the busy period, it is possible that new activations occur in the busy period, making it longer. The deadlines of each activation of τ i will be earlier, so an activation with a deadline after instant D may have been moved to have a deadline before D, thus increasing the response time of task τ a. On the other hand, if the first activation had experienced its maximum jitter but continues to be released at the start of the busy period, the following activations will occur the earliest possible and with a deadline that is earlier, relative to the beginning of the busy period. Therefore, increasing the jitter of the first activation can only increase the response time of task τ a, and the theorem follows. Note that, contrary to the other tasks, releasing the analyzed task at the start of the busy period may not lead to its worst-case response time. If we move the activation pattern of τ a to occur earlier, we are causing deadline D to be earlier too, and this could imply that some deadlines of other tasks that previously occurred before D could now occur after D, and thus make the response time of task τ a become smaller. So, the critical instant for a task, i.e., the instant of the first release of the task under analysis occurring inside the busy period that leads to the worst-case response time, is found in a busy period that is started by the simultaneous activation of all tasks except perhaps the one under analysis. In order to calculate the worst-case response time of task τ a, we will now calculate, under the conditions of Theorem 1, the worst-case contribution of a task τ i to a busy period of length t when the deadline of τ a occurs at instant D. We will name this contribution W i (t,d). Figure 2 shows a scenario for calculating this contribution. Figure 2. Scenario for calculating the worst-case contribution When we calculate the worst-case contribution of a task τ i to a busy period we must consider the activations that occur in the interval [,t) but we must only consider the activations with deadline before or at D. Each of the activations will be identified with a sequence number p, starting at p=1. In Figure 2, activation p=4 occurs before t, but its deadline is after D, so under the EDF rules it must not be considered for the worst-case contribution. To calculate the number of activations of τ i in the busy period we can see that the identifier of the last activation in that busy period, p t, is the only value of p that simultaneously satisfies: and: from which we get: Given that p t is an integer number, the solution to the above two expressions is: Similarly, the last activation that verifies the deadline condition, p D, is the only value of p that simultaneously verifies: and: from which we get: so, we get the expression: ( p 1) J i < t (1) p J i t (2) t + J p i t + J < + 1 and p i (3) Given that d i may be longer than the period, expression (8) may return a negative value, indicating that all activations have their deadlines after D and so, that the contribution is. With (x) we indicate that if x is negative the result is. t + J p i t = (4) J i + ( p 1) + d i D () J i p + d i + > D (6) J p i + D d i J + 1 and p i + D d > i (7) J p i + D d i D = (8) Given that the activations that contribute to the worst case are those with p p t and p p D, using equations (4) and (8) the worst-case contribution of task τ i to the busy period is: t + J i J W i ( t, D) min i + D d i =, C T i i (9) 4

5 Using this expression we can calculate the worst-case response time of task τ a. Unfortunately, we don't know which instant in the busy period corresponds to the critical instant, but it is easy to see that it can be found at the beginning of the busy period, or at an instant such that the deadline of the analyzed job of τ a coincides with the deadline of a task τ i s job. Otherwise the activation of task τ a could be moved to an earlier time without changing the execution schedule, but making the response time larger. The set of instants, Ψ, at which the deadline of τ a s job coincides with the deadlines of one of the task jobs in the busy period (including the task under analysis itself) is: Ψ = ( p 1) J + i d { } i p 1 L + = J i , i (1) Only positive values are taken into account, since the start of the busy period is set at t=. The value L corresponds to longest busy period, calculated as: L L + J = i C i (11) i The equation above is one of many recurrence equations found in response time analysis [8] in which the value to be calculated is in both sides of the equation; of the many solutions, only the one with the minimum positive value is valid. These equations can be easily solved iteratively by starting with a small value of L and using the value obtained from the equation in the next iteration, until a stable solution is found. The equation is guaranteed to have a solution if the utilization of the task set is under 1%. Although the computation time is pseudopolynomial, it is usually short except for utilizations very close to 1%. It is important to mention that the length of the busy period does not change due to synchronization blocking when the stack resource protocol [2] is used. In any given busy period, only one critical section may delay the start of the execution of a given task, but since the deadlines are not changed, although the ordering of the execution of the different tasks may be different, the total amount of work that has to be executed in the busy period does not change. Each potential critical instant is obtained by subtracting d a from each value in Ψ. Checking all the possible critical instants we can find the critical instant that causes the worst-case response time of the task. Given that there may be several activations of τ a in the busy period, we must analyze them all. If the first activation of τ a occurs at time A after the beginning of the busy period, the completion A time of activation p of τ a, w a ( p), can be calculated by adding the worst-case contribution of all tasks, which is: w A a ( p) = B a + pc a + W i ( w A a ( p), D A ( p) ) (12) i a where D A (p) is the deadline of activation p, having the first activation of τ a occurred at A: D A ( p) = A J a + ( p 1)T a + d a (13) The worst-case response time is calculated by subtracting the activation time from the obtained completion time: R A ( p) = w A ( p) A + J a ( p 1)T a (14) For each value of p, we only need to check the values of A within the period, i.e., between and T a (if A was greater than the period, then we would be analyzing another activation with a different value of p). That is, we only need to check the values of Ψ in the subset: Ψ = { Ψ x Ψ ( p 1)T a J a + d a Ψ x < pt a J a + d a } (1) For each element of Ψ*, named Ψ x, the value to check is A (Ψ x )= Ψ x - [(p-1)t a -J a +d a ]. To calculate the worst-case response time of task τ a we must determine the maximum response times within all the potential critical instants examined: A R a = max ( R a ( p) ) p 1 L J (16) = a , A( Ψ x ) Ψ x Ψ T a 4. Response-Time Analysis for EDF-Within- Priorities 4.1. Analysis of FP tasks In this subsection we will show how to calculate the worst-case response time for a task τ a scheduled under fixed priorities, i.e., with S a =FP. For fixed priorities, a τ a - busy period is defined as a time interval in which the processor is continuously busy executing jobs of τ a or tasks with higher or equal priority that were released before the end of that busy period. Theorem 2. An EDF task τ j, with S j =EDF, and a fixed priority P j > has the same worst-case interference on τ a as it would have if it was an FP task, with S j =FP. Proof. Let us analyze a worst-case busy period with tasks scheduled under EDF-within-priorities, and any particular job p of τ a in that busy period. There is a fixed set of jobs of task τ j in that busy period that can interfere job p of τ a. Each job in that set has its own release time, which must occur before the completion time of job p of τ a, and has an

6 execution time equal to the worst case, C a. Because all these jobs have a priority higher than, they will be completed before the completion time of job p of τ a. Therefore, their contribution to the completion time of that job of τ a, i.e., the interference, is equal to the sum of their execution times. Now let us suppose that those same jobs are scheduled under fixed priorities. Although their relative ordering with respect to jobs of other tasks in the busy period will be different, they continue to have a release time before the completion of job p of τ a, and a fixed priority P j higher than ; therefore, they must all be completed before the end of job p of τ a. Consequently the interference would be the at least equal to the case of EDF scheduling. To prove that both scheduling policies lead to the same interference we now have to prove that there are no new jobs of τ j interfering job p of τ a when an FP scheduler is used for tasks in the P j priority level. Let us focus on the set of jobs of tasks of priority P j that are inside the busy period and have a release time that is before the completion time of job p of τ a. When these jobs are scheduled under fixed priorities, their relative execution ordering changes, but their interference on job p of τ a does not change. Therefore the completion time of job p of τ a would be unaffected, and no new jobs would be added to the set. As a consequence of Theorem 2, the interference of a higher priority task on a fixed priority task τ a under analysis is the same regardless of the scheduler being used for that task. According to the results in [2], in the presence of jitter, the worst-case busy period is created in the following way: The first job of each task τ j in the busy period coincides with the start of the busy period, and arrives with the longest possible delay (i.e., when the release jitter is the maximum). All subsequent jobs arrive within the busy period with the shortest possible delay but inside the busy period. This means that each of them is released at t=nt j -J j (or at t= if the result of this expression is negative), for n=1,2,3...; consequently, the first J j T j jobs of τ j arrive at the start of the busy period, and the following jobs arrive periodically with a null jitter. Under these conditions, the response time of job p of τ a can be obtained form the workload equation: t + J w a ( t, p) = B a + pc j a C j (17) j P j This equation is solved iteratively with the following recursion, which is performed until two successive values of the equation are the same. The initial value is any positive number that is less than or equal to the final solution; T j for example, the sum of all the worst-case execution times of the tasks involved. k + 1 w a w a( p) = Ba + pc a + C j j P j w k ( p) B a pc a ( p) + J = + j a C j j P j According to [1], it is not necessary to check all the jobs in the busy period, but just the initial jobs, until the following condition is true The response time of each job p of τ a is: And the worst-case response time is: R a It is obvious from these equations that if there are no EDF tasks, the analysis is exactly the same as for fixed priority tasks only Analysis of EDF tasks In this subsection we will show how to calculate the worst-case response time for a task τ a scheduled under EDF, i.e., with S a =EDF, at a given fixed priority level. According to the fixed priority scheduling rules, tasks with a fixed priority less than have no influence on the response time. Therefore, to obtain the interference term in the response-time analysis we have to include the effects of: Set 1: Tasks of the same fixed priority. According to our model, all these tasks are scheduled under EDF together with the task under analysis. Set 2: Tasks of higher priority, either with a fixed priority scheduler, or with an EDF scheduler. Theorem 1 can be applied to the tasks in Set 1. Their contribution to the worst case response time is maximized by releasing them at the beginning of the busy period, after having experienced their maximum jitter. The interference of a task τ i in this set is obtained from Eq. (9): For those tasks in Set 2 that are scheduled under an EDF scheduler, we can apply Theorem 2 to calculate their interference term. T j (18) w a ( p ) p T a (19) R a ( p) = w a ( p) ( p 1)T a + J a (2) = max( R a ( p) ), p { 12,, p } (21) t + J i J W i ( t, D) min i + D d i =, C T i i (22) 6

7 Therefore, the interference of all tasks in Set 2 is the same as when we are analyzing fixed priority tasks only. Their contribution to the worst case response time is also maximized by releasing them at the beginning of the busy period, after having experienced their maximum jitter. The interference of a task τ i in this set can be inferred from Eq. (17): W i () t t + J = i C i (23) We have seen that all tasks of the same and higher priority relative to the task under analysis are released in the same way, at the beginning of the busy period and having experienced their maximum jitter. Now, we have to determine how to phase the task under analysis relative to all the other tasks in the busy period. Spuri [18] showed that the instant at which the task under analysis is released in the busy period is not necessarily the start of the busy period for the worst-case. This instant is either the beginning of the busy period, or an instant such that the deadline of the analyzed job of τ a coincides with the deadline of a task τ i s job for the tasks in Set 1. From Eq. (1), the set of instants, Ψ, at which the deadline of a τ a s job coincides with the deadlines of one of the jobs of Set 1 tasks in the busy period, or with that of the task under analysis itself, is: Again, only positive values are taken into account. L corresponds to longest busy period, which is now calculated by adding the contributions of tasks in sets 1, 2, and 3, together with the task under analysis and the blocking that may be caused by lower priority tasks: Each potential critical instant is obtained by subtracting d a from each value in Ψ. Checking all the possible critical instants we can find the critical instant that causes the worst-case response time of the task. Given that there may be several activations of τ a in the busy period, we must analyze them all. If the first activation of τ a occurs at time A after the beginning of the busy period, the completion time of activation p of τ a, w a A (p), can be calculated by adding the worst-case contribution of all tasks, which is: Ψ = ( p 1) J i + d i p 1 L + = J i , i P i = ipc L + J L = B i a C i i P i (24) (2) A A A w a ( p) = Ba + pc a + W i( w a ( p), D ( p) ) + i a ip i where D A (p) is the deadline of activation p, having the first activation of τ a occurred at A: The worst-case response time is calculated by subtracting the activation time from the obtained completion time: For each value of p, we only need to check the values of A within the period, i.e., between and T a (if A was greater than the period, then we would be analyzing another activation with a different value of p). That is, we only need to check the values of Ψ in the subset: It is easily seen from Eq. (26) that if there are no fixed priority tasks, the last of the terms is null, and then the analysis is the same as Spuri s analysis.. Mutual Exclusion Synchronization > P i Baker presents in [2] the Stack Resource Protocol (SRP) for bounding priority inversion in real time systems, independently from the scheduling policy used. The method can be applied to fixed priority or EDF schedulers, for instance. A number called the preemption level is assigned to each task, using the priority or importance of each task: the higher the priority, the higher the preemption level. Shared resources are also assigned a preemption level that is the highest of the preemption levels of all the tasks that may use that resource. And a new scheduling rule is imposed: a task can only get active if its preemption level is strictly higher than the preemption levels of the resources currently locked in the system. With this protocol, in a sin- = W i ( w A a ( p) ) (26) D A ( p) = A J a + ( p 1)T a + d a (27) R A ( p) = w A ( p) A + J a ( p 1)T a (28) Ψ = { Ψ x Ψ ( p 1)T a J a + d a Ψ x < pt a J a + d a } (29) For each element of Ψ*, named Ψ x, the value to check is A(Ψ x ) = Ψ x - [(p-1)t a -J a +d a ]. To calculate the worst-case response time of task τ a we must determine the maximum response times within all the potential critical instants examined: A R a = max ( R a ( p) ) p 1 L J (3) = a , A( Ψ x ) Ψ x Ψ T a 7

8 gle processor a task can be delayed by lower priority tasks only once, during the duration of one critical section. For the worst case analysis we just pick the longest. Spuri presents in [18] a technique to optimize the calculation of blocking times for EDF tasks, based on the fact that not all lower priority tasks may have deadlines that case a preemption effect on the task under analysis. For simplicity, we don t use those results here, but they could be easily incorporated to the analysis. In a fixed priority system, if the preemption level is made equal to the task priorities, the SRP protocol behaves as the priority ceiling protocol [17]. An implementation of this protocol that increases the priority of a task holding a shared resource to its preemption level (i.e., to its priority ceiling) can be made very efficient, because the priority scheduler implicitly verifies the SRP rules; this implementation is the immediate priority ceiling protocol (IPC). Because of the inherent efficiency of IPC we propose using it for synchronization among fixed priority tasks, and also for EDF tasks that need to synchronize with tasks from other priority levels. For synchronization among EDF tasks of the same priority level we will use the SRP with preemption levels inversely proportional to the local deadline D i of each task [2]. It is also possible to use the difference between the deadline and the jitter of each task D i -J i, as suggested by Spuri [18]. For fixed priority tasks, the calculation of the blocking terms only takes into account IPC resources: B i = max( CS kj ) (31) k, ( j i) ( P j P i ) ( Ceil( CS kj ) P i ) where CS kj is the k-th critical section of task j and Ceil(CS kj ) is the priority ceiling of the resource associated with CS kj. Now we need to determine the blocking times for EDF tasks. We will base it on the following lemma: Lemma 1. An EDF task in a system with an EDFwithin-priorities scheduler using the IPC and SRP synchronization protocols is only blocked by at most one critical section from equal or lower priority tasks. Proof. We know from the properties of the SRnd IPC protocols [2] that at most one critical section from each of them can block the task under analysis. Under both protocols, blocking is only possible if the critical section has only started before the task is activated. If one critical section with the IPC protocol has started, it is not possible that an EDF task that may block the task under analysis starts executing, because it does not have enough priority to preempt the critical section. The opposite case, in which an EDF task has entered a critical section that blocks the task under analysis, implies that lower priority tasks, which are the only fixed priority tasks that may block the task under analysis, cannot start their execution because they don t have enough priority to preempt the EDF tasks. Therefore the lemma follows. As a consequence, the blocked-at-most-once property also holds in this mixed synchronization protocol scenario, and the blocking time for an EDF task is obtained as: B i = max( CS kj, CS lm ) (32) k, j ( S j = FP) ( P j < P i ) ( Ceil( CS kj ) P i ) l, ( m i) ( Lev( CS lm ) Lev i ) where Lev i is the preemption level of task i, and Lev(CS lm ) is the preemption level of the resource associated with the critical section CS lm. ipc Finally, B i is obtained as in Eq. (31), but using only the lower priority tasks: B i ipc = max( CS kj ) (33) k, ( j i) ( P j < P i ) ( Ceil( CS kj ) P i ) 6. Example of Analysis In this section we will show an example of a system that uses hierarchical scheduling mixing Fnd EDF tasks, to show how the analysis presented in previous sections can be applied. Consider a simplified robot controller that has been designed with two concurrent tasks scheduled under fixed priorities. The higher priority task takes care of controlling the servomotors of the robot joints. The lower priority task displays the status of the robot on the screen. The timing requirements of these two tasks are shown below. The tasks have no release jitter: Task (ms) C i (ms) d i (ms) T1: Servo_Control 1 T3: Display After the robot controller has been built and tested, the system is extended by adding a new application that processes video images related to the robot environment. This application was developed using an EDF scheduler and contains three concurrent tasks with the requirements shown below. As before, there is no release jitter: Task (ms) C i (ms) d i (ms) T T T23 1 8

9 To ease the integration, the system will be scheduled with a hierarchical scheduler, with a mixture of Fnd EDF tasks. The three image processing tasks will be scheduled under their original EDF scheduler at the same FP level. Because the deadlines are between those of tasks T1 and T3, the priority level is chosen to be between the priorities of those two tasks. Therefore, the priority structure of the system is the one shown in Figure 3. Table 1 shows the results of the analysis. To show how it is done, we will focus on the analysis of tasks T22 and T3, as examples of the analysis of EDF and FP tasks, respectively. Table 1. Results of the analysis Task T1 T21 T22 T23 T3 WC response time For task T3 we use Eq. (17). We only need to check the value for p=1, because the worst-case busy period obtained is smaller than the period: k + 1 w 3 k k w ( 1) 1 3( 1) w ( 1) = k k w 3( 1) w ( 1) For task T22 we first determine the length of the busy period, using Eq. (2). L = + L L L L from which we obtain L=3. Then, the set Ψ (see Eq. (24)) is: Ψ = ( 1, 2, 3, 4) ( 4, 6) ( ) Prio: High (3) Prio: Medium (2) Prio: Low (1) T1 T21 T3 T22 T23 Figure 3. Hierarchical scheduling for the example (34) (3) (36) Since the busy period is 3 ms, we only need to check two activations of task T22. For the first activation (p=1), the set Ψ* (see Eq. (29)) is: and, consequently, the values of A to be checked in Eq. (26), (27), and (28) are: Now we apply Eq. (26) for both values of A. For A= we get: The value obtained after the iteration converges is used in Eq. (28) to obtain the response time, which is 9 ms for this case. Now we do the same for A=: The value obtained is 27, and the response time obtained in this case is 27-=22 ms. We would now repeat the same process for p=2. In this case there is only one value in the set Ψ*=(6), and therefore we only need to check the value A=. The response time value obtained in this case is 1. The maximum of all the response time values obtained is the worst case response time: 22 ms for this task. 7. Conclusions Ψ = ( 4, ) (37) A (, ) (38) w ( 1) min 22 ( 1) = , min ( 1) , The response-time analysis for a system with EDFwithin-priorities scheduling is a combination of the separate response time analyses of EDF and FP tasks. When analyzing a given task, only tasks of the same or higher priority are considered. If the task under analysis has a fixed priority scheduler only, the analysis is the same as for fixed priority tasks only, regardless of whether higher priority tasks are FP or EDF scheduled. If the task under analysis is scheduled under an EDF scheduler together with other tasks at the same priority, the 1 + ( 1) (39) ( 1) ( 1) = + + min , min ( 1) , ( 1) (4) 9

10 response time analysis takes into account the interference both from higher priority tasks, and from the other EDF tasks at its same priority level. In this case, the critical instant is not known, and the set of all potential critical instants must be explored. This makes the analysis of these tasks slower, but in any case the number of times that the analysis must be repeated is a number that is approximately the number of deadlines of equal priority tasks that there may be in one period of the task under analysis, approximately: This number can be significant, but is perfectly feasible in most systems. The analysis presented here is extensible to offset-based analysis techniques using techniques similar to those existing for separate Fnd EDF systems. That extension would enable us the analysis of distributed systems, and is proposed as future work. 8. References T i T a (41) i a = P i [1] M. Aldea Rivas and Michael González Harbour. POSIX- Compatible Application-Defined Scheduling in MaRTE OS Proceedings of 14th Euromicro Conference on Real-Time Systems, Vienna, Austria, IEEE Computer Society Press, pp. 67-7, June 22 [2] Baker T.P., Stack-Based Scheduling of Realtime Processes, Journal of Real-Time Systems, Volume 3, Issue 1 (March 1991), pp [3] A. Bavier, L. Peterson, and D. Moseberger. BERT: A Scheduler for Best Effort and Realtime Tasks. Technical Report TR-87-98, Princeton University, August [4] G. Bernat and A. Burns. Jorvik: A Framework for Effective Scheduling. Technical Report YCS-334, Department of Computer Science, University of York, 21. [] Z. Deng, J.W.S. Liu, L. Zhang, S. Mouna, and A. Frei. An Open environment for Real-Time Applications. Real-Time Systems Journal, 12 (2/3):16-18, May [6] M. González Harbour, M.H. Klein, and J.P. Lehoczky. Fixed Priority Scheduling of Periodic Tasks with Varying Execution Priority. Proceedings of the IEEE Real-Time Systems Symposium, December 1991, pp [7] H. Kaneko, J.A. Stankovic, S. Sen, and K. Ramamritham. Integrated Scheduling of Multimedia and Hard Real-Time Tasks. 17th IEEE Real-Time Systems Symposium, Washington D.C, December [8] M. Klein, T. Ralya, B. Pollak, R. Obenza, and M. González Harbour, A Practitioner's Handbook for Real-Time Systems Analysis. Kluwer Academic Pub., [9] B.W. Lampson and D.R. Redell. Experience with Processes and Monitors in Mesa. Communications of the ACM, Vol. 23, no. 2, February 198. [1]J.P. Lehoczky, Fixed Priority Scheduling of Periodic Task Sets with Arbitrary Deadlines. IEEE Real-Time Systems Symposium, 199. [11]C.L. Liu, and J.W. Layland, Scheduling Algorithms for Multiprogramming in a Hard Real-Time Environment. Journal of the ACM, 2 (1), 1973, pp [12]J.C. Palencia and M. González Harbour Schedulability Analysis for Tasks with Static and Dynamic Offsets. Proceedings of the 19th IEEE Real-Time Systems Symposium, [13]J.C. Palencia Gutiérrez, J. J. Gutiérrez García, and M. González Harbour, Best-Case Analysis for Improving the Worst-Case Schedulability Test for Distributed Hard Real- Time Systems. 1th Euromicro Workshop on Real-Time Systems, Berlin, Germany, June [14]J.C. Palencia and M. González Harbour, Offset-Based Response Time Analysis of Distributed Systems Scheduled under EDF. Euromicro conference on real-time systems, Porto, Portugal, June 23. [1]J.C. Palencia Gutiérrez, J.J. Gutiérrez García, and M. González Harbour, On the Schedulability Analysis for Distributed Hard Real-Time Systems. Proceedings of the 9th Euromicro Workshop on Real-Time Systems, Toledo, June, 1997, ISBN: , pp. 136,143. [16]J. Regehr, J.A. Stankovic, and M. Humphrey. The case for Hierarchical Schedulers with Performance Guarantees, Technical Report: University of Virginia CS-2-7, March 2. [17]L. Sha, R. Rajkumar, and J.P. Lehoczky. Priority Inheritance Protocols: An approach to Real-Time Synchronization. IEEE Trans. on Computers, Sept [18]M. Spuri. Analysis of Deadline Scheduled Real-Time Systems. RR-2772, INRIA, France, [19]M. Spuri. Holistic Analysis of Deadline Scheduled Real- Time Distributed Systems. RR-2873, INRIA, France, [2]K. Tindell, An Extendible Approach for Analysing Fixed Priority Hard Real-Time Tasks. Journal of Real-Time Systems, Vol. 6, No. 2, March [21]K. Tindell, and J. Clark, Holistic Schedulability Analysis for Distributed Hard Real-Time Systems. Microprocessing & Microprogramming, Vol., Nos.2-3, pp , April [22]K. Tindell, Adding Time-Offsets to Schedulability Analysis, Technical Report YCS 221, Dept. of Computer Science, University of York, England, January [23]Y.C. Wang and K.J. Lin, The Implementation of Hierarchical Schedulers in the RED-Linux Scheduling Framework. 12th Euromicro Conference on Real-Time Systems, Stockholm, June 2. 1