Polynomial-Time Exact Schedulability Tests for Harmonic Real-Time Tasks

Transcription

1 Polynomial-Time Exact Schedulability Tests for Harmonic Real-Time Tasks Vincenzo Bonifaci, Alberto Marchetti-Saccamela, Nicole Megow, Andreas Wiese Istituto di Analisi dei Sistemi ed Informatica Antonio Ruberti (IASI-CNR), Rome, Italy Saienza University of Rome, Italy. Technische Universität Berlin, Germany. Max-Planck-Institut für Informatik, Saarbrücken, Germany. Abstract We study the reemtive scheduling of real-time soradic tasks on a unirocessor. We consider both fixed riority (FP) scheduling as well as dynamic riority scheduling by the Earliest Deadline First (EDF) algorithm. We investigate the roblems of testing schedulability and comuting the resonse time of tasks. Generally these roblems are known to be comutationally intractable for task systems with constrained deadlines. In this aer, we focus on the articular case of task systems with harmonic eriod lengths, meaning that the eriods of the tasks airwise divide each other. This is a secial case of ractical relevance. We resent rovably efficient exact algorithms for constraineddeadline task systems with harmonic eriods. In articular, we rovide an exact olynomial-time algorithm for comuting the resonse time of a task in a system with an arbitrary fixed riority order. This also imlies an exact FP-schedulability test. For dynamic riority scheduling, we show how to test EDFschedulability in olynomial time. Additionally, we give a very simle EDF-schedulability test for the simler case where relative deadlines and eriods are jointly harmonic. I. INTRODUCTION The soradic task model [29] is a widely used formal model for reresenting recurrent real-time task systems. We consider the reemtive unirocessor scheduling of soradic tasks with harmonic eriod lengths, which means that the eriods of the tasks divide each other. Harmonic eriods occur in a number of alications domains [12], [30], [34] and there is exerimental evidence that they may allow a larger rocessor utilization [9], [16], [23]. In this aer, we formally rove that constrained-deadline 1 task systems with harmonic eriods admit olynomial-time exact schedulability tests. Schedulability analysis is used to a riori assess the behavior of a real-time system. Given a set of real-time tasks, schedulability analysis determines whether this set can be guaranteed to always meet the deadlines at runtime. A schedulability test is sufficient if all task sets deemed to be schedulable by the test are in fact schedulable. Similarly, a schedulability test is necessary if all task sets deemed to be unschedulable by the test are in fact unschedulable. Schedulability tests that are both sufficient and necessary are referred to as exact. 1 A constrained-deadline task set is such that the relative deadline of each task does not exceed its eriod length. When each relative deadline is equal to the corresonding eriod length, the task set is called imlicit-deadline. In this aer, we consider both fixed riority and dynamic scheduling. In fixed riority (FP) scheduling an arbitrary riority ordering of all tasks is secified. Jobs are scheduled reemtively according to this order. That is, at the arrival of a job of a higher riority task, any executing job of a lower riority task is reemted. Among all ossible riority orders, some well-studied ones are Rate Monotonic (RM), where tasks are ordered non-decreasingly by their eriod lengths, and Deadline Monotonic (DM), where tasks are ordered nondecreasingly by their relative deadlines. A well-known method to erform schedulability analysis for fixed riority scheduling is to comute the worst-case resonse time of each task. This is known as Resonse-Time Analysis (RTA) [2], [22], [37]. The resonse time of a task is the maximum amount of time that may elase between the arrival of a job of the task and its comletion. Known methods for comuting the resonse time are iterative and not known to be olynomial-time in the inut size. They are tyically unsuitable for large instances [22]. Indeed, it is known that comuting the resonse time for RM-scheduling is NP-hard [13]. Therefore, it is unlikely that exact olynomialtime RTA-based schedulability tests exist. In the case of dynamic scheduling we consider the Earliest Deadline First (EDF) algorithm, which schedules at any time an available job whose absolute deadline is closest, ossibly reemting a running job with later deadline. EDF is an otimal scheduling algorithm for a set of reemtive jobs on a single rocessor [11], [28], meaning that it constructs a feasible schedule (a schedule in which all jobs meet their deadlines) whenever a feasible schedule exists. A well-known method to erform EDF-schedulability analysis is based on the demand bound function [6]: roughly seaking, the total rocessing demand is comuted for certain time intervals and comared with the available rocessing caacity in those intervals. The running time of the test deends on the number of time intervals to be considered; no olynomial-time bound on the comlexity of such an aroach is known. Indeed, the roblem of testing EDF-schedulability has been shown to be conp-hard even in the case of constrained-deadline task sets [15]; therefore, it is unlikely that a olynomial-time exact EDF-schedulability test exists. It is noteworthy that the two above-mentioned intractability 1

2 results (NP-hardness of resonse-time comutation [13] and conp-hardness of testing EDF-schedulability [15]) heavily rely on the fact that the eriod lengths of an instance can have a comlicated algebraic structure. Therefore, for solving the two roblems above exactly, one has to coe with comlex subroblems from the domain of algorithmic number theory. In fact, the two latter results hinge on the NP-hard Directed Diohantine Aroximation roblem [14]. However, in ractical alications the structure of the arising eriod lengths might be much simler than in a ossible theoretical worstcase scenario. Therefore, it is of interest to determine under which conditions olynomial-time exact schedulability tests are ossible. Desite all research effort, only for very secial cases a ositive answer is known. A remarkable result has been obtained by Liu and Layland in 1973 [28], who showed that in the case of imlicit-deadline task systems an exact schedulability test for EDF systems can be easily erformed by verifying whether the total utilization of the task set is less than or equal to 1. The class of task systems with harmonic eriods is aealing from a ractical oint of view, but its ower is not well understood from a theoretical oint of view. In the secific case of n imlicit-deadline tasks with harmonic eriods, it is known 2 that a sufficient condition for RM-schedulability is that the total utilization of the task set is at most 1; whereas for non-harmonic eriods, only a utilization bound of n(2 1/n 1) (which aroaches ln , for large n) yields a sufficient condition [28]. Research effort has been dedicated to extend the result to other system models. For examle, in [23] the utilization bounds of [28] have been generalized using the notion of harmonic chains. In [35] the authors roose to transform the eriods of an imlicit-deadline task set to make them nearly harmonic. However, in the case of harmonic, constrained-deadline task sets, the comlexity of known exact schedulability tests is only seudoolynomial. A. This aer We study reemtive real-time schedulability tests for soradic task sets with constrained deadlines on a unirocessor, under the assumtion that the eriod lengths of the tasks are harmonic, that is, they airwise divide each other. As we already observed, harmonic eriods are relevant in a number of alications, such as avionics (see, for examle, [30]). We show that such task sets admit exact olynomial time tests, thus byassing the reviously discussed comutational hardness results. We first consider fixed riority scheduling. We resent an exact olynomial-time algorithm which comutes the resonse time of a task of a given task set for an arbitrary riority ordering (Section III). A key difficulty when comuting the resonse time is that the inequality for uer bounding the resonse time (see Inequality (2)) might be satisfied only at some isolated oints in time, and such oints may be hard 2 This result seems to be known as folklore, see, for examle, the surveys [4], [25], but it may be attributed to [24]. to find. However, in the case of harmonic eriod lengths we rove that if the inequality holds at time oint t, then it also holds at any time after t that is a multile of some eriod length j (see Figure 1 and Lemma 2). This allows us to find the resonse time with a binary search tye rocedure having an overall comlexity O(n log P ), where P is the largest eriod length. As a corollary, we obtain an exact olynomialtime test that decides whether a set of tasks with harmonic eriod lengths is FP-schedulable under a given ordering. We then consider dynamic scheduling algorithms. Our main result is a olynomial-time algorithm that tests whether the given set of tasks is feasible on one rocessor (Section IV-B). It is known that testing unirocessor feasibility is equivalent to testing whether there is a feasible schedule for the synchronous arrival sequence of jobs [4]. Intuitively, one might want to simulate a suitable scheduling algorithm (such as EDF) in order to verify whether a schedule exists for this job sequence. However, this aroach would be inefficient. Instead, we construct a schedule, secially designed for the synchronous arrival sequence, that can be described comactly. Intuitively, it delays the execution of each job u to a oint where any further delay would cause some job in the system to miss its deadline. We fix the delays of jobs in increasing order of (harmonic) eriod length, and then the delay for each job of the same task is identical. In a sense, the resulting schedule is a reversed RM-schedule (see Figure 2). Even though this strategy might seem counterintuitive, we show that this schedule is otimal, meaning that all jobs meet their deadlines if and only if the task system is feasible. Most imortantly, the schedule can be described comactly and we can construct it (imlicitly) in olynomial time. We round u our results by giving a simler EDFschedulability test for the case that all eriod lengths and relative deadlines of the task system are jointly harmonic (Section IV-A). B. Related work 1) Fixed riority: Many known results for fixed riority systems assume that riorities are either in rate-monotonic riority order or in deadline-monotonic order. If the deadline of each task equals its eriod, then the two orders coincide and the seminal results of Serlin [33] and Liu and Layland [28] showed that for synchronous tasks (i.e., with a common release date), the RM (and DM) ordering is otimal. Liu and Layland [28] also rovided a simle, sufficient, utilizationbased schedulability test for imlicit-deadline tasks. If the task set has constrained deadlines, then it is known that DM is otimal among the family of fixed riority reemtive algorithms for scheduling on a unirocessor [27]. Exact schedulability tests have been roosed by Joseh and Pandya [22] and Audsley et al. [2]. In [24] the authors roose an alternative method of determining exact schedulability conditions, which also allows an average case analysis. A significant research effort has been devoted to imrove the running time of exact schedulability tests or to find good aroximations of the resonse time that allow to derive 2

3 sufficient schedulability tests or to extend known results to more general system models. We refer, for examle, to [3], [7], [8], [10], [19], [36] and references therein. Additionally, olynomial-time aroximation schemes (PTAS) for DMschedulability have been roosed in [17], [31] that in some cases are based on aroximating the resonse time to any degree of accuracy. The ower of harmonic task systems or those that come close to them has been suorted in [9], [16], [23]. The authors of [23] roose the harmonic chain method, which extends the Liu and Layland bounds by determining and exloiting harmonic relationshis among eriods. Their exeriments give evidence that (nearly) harmonic task sets can utilize the rocessor more efficiently than arbitrary task sets. In [19] the authors study schedulability methods that are based on transforming a given task set T into another task set T with harmonic eriods, whose schedulability imlies the schedulability of T. In [32] it is shown that the assumtion of harmonic eriods yields more accurate uer bounds on the resonse times. One result that gives a formal roof of the ower of harmonic eriods is the aforementioned exact RM-schedulability test for imlicit-deadline unirocessor task systems, which requires only to verify that the total utilization of the task set is at most 1. This result is useful also in a multirocessor environment. Consider artitioned RM-scheduling, where the task set is divided into subsets, one for each rocessor, and then RM-scheduling is alied on each individual rocessor. In case of imlicit deadlines, artitioned scheduling can be reduced to a makesan minimization roblem on multile rocessors. Then the above utilization-based test, combined with a PTAS [20] or FPTAS [21] for the makesan minimization roblem, gives nearly exact tests for artitioned multirocessor RM-schedulability. 2) EDF: We already observed that existing results on exact schedulability analysis for EDF need to comute the demand bound function of the task set at several aroriate time intervals. Given the imortance of the roblem, there has been a significant effort in order to reduce the number of time intervals to be checked while guaranteeing a good aroximation of the demand function. Many such sufficient schedulability tests have been roosed; we refer, for examle, to [5], [6], [11], [26], [38] and references therein. Moreover, a fully olynomial-time aroximation scheme has been roosed by Albers and Slomka [1]. However, the running time of known exact algorithms is not satisfactory; for examle, in [38] it has been observed that the significant effort required to erform the exact schedulability test restricts the use of EDF in realistic systems; hence, the EDF algorithm has not been used as widely as the fixed riority algorithms in commercial realtime systems. II. SYSTEM MODEL AND NOTATION We consider a hard real-time system comrising a set T = {τ 1, τ 2,..., τ n } of indeendent real-time soradic tasks, each task consisting of a ossibly infinite sequence of jobs which must be comleted before their deadlines. Jobs of a soradic task τ j may arrive irregularly, but have a minimum inter-arrival time, also known as eriod. Each task τ j is defined by a tule (c j, d j, j ), consisting of a worst-case execution time c j, a eriod j, and a relative deadline d j, with c j d j j (constrained deadlines). We refer to [4] for the recise semantics of the model. We assume that all inut arameters are integral and ositive. We restrict ourselves to task sets with harmonic eriods, which means that for all i, j = 1,..., n, either i j ( i divides j ) or j i ( j divides i ). In our analysis, we will use two further assumtions that come without loss of generality: 1) the execution requirement of each job of task τ j always equals its worst-case execution time; 2) the job sequence is the synchronous arrival sequence (SAS), that is, the i-th job of each task τ j is released at time (i 1) j and due at time (i 1) j + d j. We remark that both assumtions are without loss of generality: the first one, because we only consider redictable scheduling algorithms (in the sense of Ha and Liu [18]); the second one, because it is known (see for examle [4, Lemma 28.9, 28.10]) that the SAS is the worst-case arrival sequence for determining resonse times and EDF-schedulability. The hyereriod P of task set T is defined as the least common multile of the eriod lengths of the tasks in T; since eriods are harmonic, we have P = max n i=1 i. The utilization of a task τ i is the quantity c i / i. The utilization U(T) of task set T is n i=1 c i/ i. If U(T) > 1, then there are job sequences of T that cannot be feasibly scheduled by any algorithm; hence, in the remainder of the aer we will use the assumtion U(T) 1. III. FIXED PRIORITY SCHEDULING Given an arbitrary fixed riority order (a total ordering of all tasks), in this section we assume that the tasks are indexed according to this riority order, that is, a task τ i has higher riority than task τ j if and only if i < j. In a given schedule according to the given riority order, the resonse time of a job is the time that elases between its release time and its comletion time. The resonse time r j of a task τ j is the maximum resonse time that a job of this task may incur. Consider a task system T with a given fixed riority order. Recall that without loss of generality we can consider the synchronous arrival sequence (SAS) of jobs. In the SAS, the resonse time of the first job of task τ j is the largest among all the jobs of τ j [4], [22], [37]. Hence, in order to check whether the given system is feasible, it is sufficient to comute for each task τ j the resonse time, r j, of the first job of τ j in the SAS, and to determine whether r j d j for each j = 1,..., n. It is known that r j is the minimum t > 0 that satisfies the following equality: c j + t c i = t. (1) i<j i 3

4 r n? (k 1) j k j (a 1) j a j??? Fig. 1. An illustration of Lemma 2. Condition (2) is satisfied (resectively, not satisfied) at the blue (res., red) time oints. The condition may or may not be satisfied at the time oints marked by question marks. (Red oints are on the left of r n; blue oints are on the right of r n and are marked by an uward arrow.) In the sequel we also use the following equivalent definition: r j is the minimum t > 0 that satisfies the following inequality: c j + t c i t. (2) i<j i We now show how to comute the resonse time of a task in olynomial time if the eriods are harmonic. Since the resonse time deends only on the schedule of higherriority tasks (see Condition (2)), we can assume without loss of generality that we are interested in the resonse time of the task with lowest riority, task τ n. Firstly, we observe that when eriods are harmonic, the hyereriod of the tasks in T \ {τ n } is certainly not larger than P := max n i=1 i, and thus, the schedule for these tasks is the same in each interval [(q 1)P, qp ) for any q N. When U(T) 1, it is easy to show that the resonse time of τ n is not larger than P c n. We give a short roof for comleteness. Lemma 1. If U(T) 1, then Condition (2) is satisfied with j = n and t = P c n and, therefore, r n P c n. Proof: The left hand side of (2) with j = n and t = P c n can be bounded as follows: c n + P cn c i = c n + c i P c n c i P c n i i n P c n, where the equality uses the fact that eriods are harmonic, the first inequality uses the fact that P/ n 1 and c n 1, and the second inequality uses U(T) 1. The following lemma is crucial for our aroach to comuting the resonse time. It allows to reduce the search to release intervals, that is, the intervals between two consecutive job arrivals of the same task. Informally seaking, the lemma says the following: Suose the resonse time r n lies in the release interval I of some task τ j, and let j be the largest eriod that is less than j. Then Condition (2) is also satisfied for every integer multile of j equal or larger than r n within I. Thus, r n is at most the smallest such multile of j. See Figure 1 for an illustration of the lemma. Lemma 2. Let T be a task system with total utilization at most 1. Assume r n ((q 1) j, q j ] for some q N, and let j be the largest eriod that is less than j. If all eriods are harmonic, then t(a) := a j satisfies Condition (2) for any a N such that t(a) [r n, q j ]. Proof: Consider some time oint t(a) = a j, a N, such that r n a j q j. We need to show that c n + a j c i a j. First, we observe that for all indices i < n with i > j we have that a j / i = r n / i. The reason is that with harmonic eriods and by definition, a j and r n are within the same release interval ((q 1) j, q j ] of task τ j, and thus within the same release interval ((q 1) i, q i ] of any task τ i with i < n and i > j (for a suitable value q ). Furthermore, for all i < n with i j the ratio a j / i is integral since i j. Hence, the left-hand side of inequality (2) evaluated at t(a) equals c n + a j c i = c n + rn c i + a j c i i > j i j c n + i<n = ( c n + i<n rn i rn c i + i<n i j i a j r n i c i ) + (a j r n ) r n + (a j r n ) = a j. c i i<n i j The last inequality holds since by definition inequality (2) is satisfied for t = r n, and due to the utilization bound n i=1 c i/ i 1. The lemma suggests the following algorithm for comuting the resonse time r n. By Lemma 1, we know that r n lies in the interval (LB, UB] with LB = 0 and UB = P c n. Using Lemma 2, we iteratively reduce the search interval (LB, U B]. Beginning with the largest eriod P, we find the least integer a (LB/P, UB/P ] such that Condition (2) is satisfied at a P. By Lemma 2 we can increase LB to (a 1) P and reduce UB to a P. We continue with the longest eriod length that is shorter than P and so on, until the shortest eriod has been considered. At this oint we have UB LB = min n 1 i=1 i and we are able to determine r n exactly. More formally, the descrition is in given in Algorithm 1. Theorem 1. Algorithm 1 correctly comutes the resonse time r n of task τ n in time O(n log n + n log P ). Proof: The correctness of the algorithm hinges on Lemmata 1 and 2. First of all, note that since U(T) 1 then Lemma 1 imlies r n P c n. Then the for loo of the algorithm maintains the invariant that the values of LB c i i 4

5 Algorithm 1 Exact resonse time comutation Inut: A constrained-deadline soradic task system T with harmonic eriods s.t. U(T) 1 and an FP ordering (τ 1, τ 2,..., τ n ) of the tasks. Outut: Resonse time r n. 1: Let π : {1, 2,..., n 1} {1, 2,..., n 1} be a ermutation that orders tasks by non-increasing eriod lengths, i.e., i < j imlies π(i) π(j). 2: LB 0 3: UB c n P 4: for i 1 to n 1 do 5: Use binary search to find the least integer a such that a is in the interval (LB/ π(i), UB/ π(i) ] and satisfies (2). 6: LB (a 1) π(i) 7: UB a π(i) 8: end for 9: r n c n + i<n 10: return r n UB i c i and UB are such that LB < r n UB; more recisely, Condition (2) is guaranteed to be violated for t = LB and to be satisfied for t = UB. This is obviously true when LB is initialized to 0 and, by Lemma 1, when UB = c n P. Then, at each iteration i, LB is udated to a value (a 1) π(i) which does not satisfy (2), due to the minimality of a. Lemma 2, on the other hand, ensures that the udated UB does satisfy Condition (2). Notice also that, at the end of each iteration of the for loo, Condition (2) is satisfied by t = UB and not satisfied by t = LB. Since the eriods are harmonic and thus π(i) always divides UB, the binary search rocedure is successful at each iteration, because UB/ π(i) is always a ossible target value of the binary search. At the end of the for loo, the interval (LB, UB] is such that UB LB = min n 1 i=1 i. Therefore, the terms r n / i and UB/ i are equal for each i < n. This imlies that r n = c n + rn c i = c n + UB c i, which justifies the last ste of the algorithm. Concerning the running time, observe that aart from the initial ordering ste (Ste 1, which requires time O(n log n)), it is dominated by the overall cost of checking Condition (2) in the main loo. Since the cost of checking Condition (2) is O(n), it follows that the overall cost of Algorithm 1 amounts to a number of arithmetic oerations that is bounded by O(n log n + n n T ), where n T denotes the total number of times that Condition (2) is tested. We now show that n T = log(c n P ). First observe that when i = 1 the algorithm erforms a binary search for a multile of P between LB = 0 and UB = c n P. Hence, in the worst case, there are at most log(c n P/P ) = log c n oints to be checked. When i > 1, in the i-th iteration of the main loo the algorithm runs a binary search rocedure which tests integer multiles of the current eriod π(i) on an interval of length at most UB LB = π(i 1). This imlies that condition (2) is tested at most log( π(i 1) / π(i) ) times. Summing across i, we obtain that n n T = log c n + log( π(i 1) / π(i) ) i=2 log c n + log P = log(c n P ). Therefore, the running time of Algorithm 1 is bounded by O(n log n + n log(c n P )) = O(n log n + n log P ) (since c n n P ). To test the schedulability of a given fixed riority order, it suffices to verify whether the resonse time of every task satisfies r i d i. Thus, by Theorem 1 we can simly execute Algorithm 1 for every task. Corollary 1. There is a olynomial time algorithm that, on inut a constrained-deadline harmonic task set T and a fixed riority order, decides whether T is FP-schedulable under the given order on one rocessor. IV. DYNAMIC SCHEDULING EDF-SCHEDULABILITY First, we resent a simle and fast schedulability test for the secial case when deadlines and eriods are jointly harmonic. Then we resent our main result: a olynomial-time algorithm for testing EDF-schedulability of tasks with harmonic eriods. We will need some more job-secific notation: Let i(j) denote the i-th job of task τ j. We denote its arrival date as a i(j) and its absolute deadline as d i(j) := a i(j) + d j. If the task to which a job belongs is clear from the context or irrelevant, then we omit the reference to the task index. Vice versa, we let τ(i) denote the task that released job i; we also say that τ(i) owns job i. A. A test for eriods and deadlines that are jointly harmonic In this subsection we consider task systems in which the deadlines and eriods of the tasks are jointly harmonic, that is, for all x i, x j {d 1,..., d n, 1,..., n }, either x i x j or x j x i. We say such a task system is fully harmonic. Definition 1. Two jobs i and k are a strictly crossing air if a i < a k < d i < d k. Lemma 3. There is no strictly crossing air of jobs in the synchronous arrival sequence of a fully harmonic constraineddeadline task system. Proof: We give a roof by contradiction. Suose there exist two jobs i and k with a i < a k < d i < d k. First observe that the eriods of the tasks owning jobs i and k satisfy τ(k) < τ(i), because otherwise τ(i) τ(k) and thus the arrival of i would coincide with the arrival of k, a contradiction to a i < a k. By the same argument, we see that τ(k) a i, and at a i there is released another job k k of task τ(k) which must have its absolute deadline at or before a k (recall that deadlines are constrained) and thus before d i. Hence, τ(k) d i a i = d τ(i), which imlies τ(k) d i, because τ(k) d τ(i) (eriods and deadlines are jointly harmonic) and τ(k) a i (see above). 5

6 In a synchronous arrival sequence, jobs are released as early as ossible and thus jobs of task τ(k) are released at every integer multile of τ(k) ; in articular, there arrives a job k of task τ(k) at time d i, and thus, k itself must have finished by that time, i.e., dk d i, which gives a contradiction and concludes the roof. Lemma 4. Consider the synchronous arrival sequence of a fully harmonic task system that is not EDF-schedulable, and let τ j be the task with the earliest deadline miss. Then EDF fails at time d j, the absolute deadline of τ j s first job. Proof: Let i(j) be the first job of task τ j that misses its deadline d i in an EDF schedule. Recall that a i is the arrival time of job i. We determine the workload that EDF assigns to the interval [a i, d i ] and which delays the rocessing of i. We first observe that only jobs with an arrival time equal or larger than a i (but before d i ) can contribute to this workload. The reason is that by Lemma 3, jobs arriving before a i have their absolute deadline before a i or after d i, and in both cases they do not delay the execution of i in the EDF schedule. Furthermore, the jobs released after a i with a deadline before d i have, by the same reasoning as in the roof of Lemma 3, a eriod strictly less than j : indeed, if a job k had a k > a i and d k d i, then τ(k) < j, otherwise j τ(k) and the arrival of i would coincide with a k. We conclude that the workload that delays the rocessing of job i in its time window [a i, d i ] is only due to jobs with arrival time a i, and jobs with arrival time in (a i, d i ) that belong to tasks with eriod less than j. In a synchronous arrival sequence, these are exactly the same jobs that delay the first job released by task τ j. Thus, if i(j) fails to comlete, then the first job released by τ j also fails to comlete within its time interval [0, d j ], which concludes the roof. Algorithm 2 EDF-schedulability test for fully harmonic tasks Inut: A task system T with harmonic eriods and deadlines. Outut: YES/NO-decision about T being EDF-schedulable. 1: for τ i T do 2: if τ k T (d i + k d k )/ k c k > d i then 3: return NO 4: end if 5: end for 6: return YES Theorem 2. There is a olynomial-time algorithm that decides whether a fully harmonic constrained-deadline task set is EDFschedulable on one rocessor. Proof: A constrained-deadline task system is EDFschedulable if and only if its synchronous arrival sequence is EDF-schedulable [4, Lemma 28.9]. For such an arrival sequence, Lemma 4 states that it is sufficient to test for each task τ i the deadline of its first occurrence, that is, the time d i. Thus, our algorithm (Algorithm 2) does the following: for i = 1,..., n, test if EDF fails at time d i. By [5, Lemma 4.2] this can be done by evaluating the demand bound function at time t = d i, that is, we check if di + k d k c k d i. (3) τ k T k If all such tests are satisfied, then T is EDF-schedulable; otherwise, we have found a time t by which EDF fails. Regarding the running time, observe that for each i = 1, 2,..., n, Condition (3) can be tested in time linear in the inut size. Therefore, the overall comlexity of the test is quadratic. B. A olynomial-time test for harmonic eriods Consider a task system T with harmonic eriods and arbitrary (but constrained) deadlines. We resent a olynomial time algorithm which tests whether for every job sequence of T a feasible unirocessor schedule exists (and thus whether the task set is EDF-schedulable [11], [28]). Recall from Section II that it is sufficient to verify the schedulability of a synchronous arrival sequence in which all jobs attain their WCETs. Without loss of generality, assume that the tasks in T = {τ 1, τ 2,..., τ n } are sorted nondecreasingly by eriod length, that is, j j for any j, j with j < j. To rove the result we will roceed in three stes. Namely, 1) We define a (non-edf) rocrast schedule S for the synchronous arrival sequence of T; S is imlicitly defined by a sequence of values b 1, b 2,..., b n (one er task). 2) We then resent Algorithm 3, which either constructs S or asserts that T is infeasible; we show that the running time of Algorithm 3 is olynomial in the inut size. 3) Finally, we show that if Algorithm 3 is successful then S is a feasible schedule for the SAS, while if Algorithm 3 fails then T is infeasible (even for EDF). 1) Definition of rocrast schedule S: We define a schedule S for the time interval [0, n ). This is sufficient for describing the full schedule, since we assume the eriod lengths to be harmonic, and thus, n equals the hyereriod of all eriod lengths in the instance. Schedule S is defined by considering tasks in order; we denote by S j, j = 1, 2,..., n, the artial schedule of jobs released by tasks τ 1, τ 2,..., τ j. Algorithm 3 starts from the emty schedule S 0 and, at each iteration j = 1, 2,..., n, defines S j based on S j 1 by secifying how τ j s jobs are scheduled. Namely, at iteration j, the algorithm delays the rocessing of each job of τ j as much as ossible given the execution requirements of all jobs released by shorter-eriod tasks secified by S j 1. We refer to the schedule also as a rocrast schedule. In articular, in a rocrast schedule each job of task τ 1 (the shortest-eriod task) is scheduled for c 1 time units just before its deadline. Jobs of τ j, j = 2,..., n, are scheduled similarly; however, for these jobs we have to 6

7 take into account S j 1 and, in articular, the busy times in which the rocessor is executing jobs of τ 1,..., τ j 1. To define S formally, it is sufficient to secify the time instant at which each job starts execution. In fact, at any oint in time t there can be several ending jobs (i.e., jobs that have started execution but that have not been comleted), each one released by a different task; among this set of jobs, at time t schedule S executes the one released by the task τ i having the least index i. The critical observation is that the time instants in which each job starts execution follow a regular attern. In the following we define a value b j for each task τ j and use it for all jobs released by τ j : job i(j) of τ j, which is released at time a i(j), starts execution at time a i(j) + b j. At time t, S executes job i(j) if t a i(j) + b j, i(j) is not comleted and if no job released by a higher riority (shorter eriod) task is ending. In fact, the resulting schedule can be seen as a fixed riority schedule, where the riorities are assigned to the tasks according to their eriod lengths and the release of each job i(j) is moved to a i(j) + b j. Intuitively, a i(j) + b j is the maximum amount of time by which we may delay the execution of job i(j) without missing its deadline, given the schedule of tasks τ 1,..., τ j 1. For this reason, we call b j the anic offset of task τ j. We give details on how to comute anic offsets later. For illustrative uroses, consider task τ 1 (the shortest eriod task). We have b 1 = d 1 c 1. Clearly, for each job i(1) released by τ 1 we have that a i(1) + b 1 = a i(1) + d 1 c 1 = d i(1) c 1 is the latest oint in time to start i(1), since otherwise the deadline of i(1) would be missed. We define a schedule S 1 for the jobs of τ 1 by executing each job i(1) of τ 1 during the interval [a i(1) + b 1, a i(1) + d 1 ). Definition 2 (Procrast schedule S j ). A schedule is called rocrast schedule S j with anic offsets b 1,..., b j (or only rocrast schedule S j for short) if it satisfies the following roerties: 1) each job i(1) of τ 1 is executed for c 1 time units during the interval [a i(1) + b 1, a i(1) + d 1 ); 2) each job i (j ) of task τ j, j = 2,..., j, is executed for c j time units during the interval [a i (j ) + b j, a i (j ) + d j ) when no job created by some task τ j, j < j, is running; 3) for each job i (j ) of τ j, at each time t [a i (j ) + b j, a i (j ) +d j ) the rocessor is never idle and rocesses a job of a task in {τ 1,..., τ j }. Observe that the anic offsets b 1,..., b j are sufficient to define the rocrast schedule S j for the task set {τ 1,..., τ j }. We let S := S n and we observe that, by 1) and 2) in the above definition, a rocrast schedule is a feasible schedule. Also notice that each job i (j ) of task τ j runs in articular during the interval [a i (j ) + b j, a i (j ) + b j + 1); this fact will be used in the sequel. Examle 1. Consider T = {τ 1, τ 2, τ 3 } with τ 1 = (1, 3, 4), τ 2 = (3, 5, 8), τ 3 = (3, 10, 16). Figure 2 shows the rocrast schedule S 3 ; the anic offsets are b 1 = 2, b 2 = 1, b 3 = 5. τ 1 τ 2 τ Fig. 2. The rocrast schedule for the three tasks of Examle 1. 2) Comutation of anic offsets: We now resent Algorithm 3, which constructs the rocrast schedule S for task set T by comuting anic offsets b 1,..., b n ; if the algorithm does not succeed, then it asserts that T is infeasible. We will also rove that the running time of the algorithm is olynomial. The algorithm sorts tasks by non-decreasing eriod lengths and then comutes S inductively. Namely, it initializes S 0 to be the emty schedule; at each iteration, given a feasible rocrast schedule S j 1 with b 1,..., b j 1, it comutes the anic offset b j to obtain the rocrast schedule S j. We define schedule S 1 by the anic offset b 1 := d 1 c 1. Observe that this is a feasible rocrast schedule. Now consider some integer j 2 and suose there is a feasible rocrast schedule S j 1 for all tasks τ 1,..., τ j 1 satisfying the roerties of Definition 2. By this definition, the busy times of the rocessor are exactly j i [a i(j) +b j, a i(j) +d j ). For finding b j we have to comute the largest value x 0 such that during [x, d j ) the idle time of the rocessor equals exactly c j. Then we set b j := x. If there is no such non-negative value x, then we outut that the task system is infeasible. Algorithm 3 Comutation of Procrast Schedule S Inut: A task system T with harmonic eriods Outut: Procrast Schedule S or assertion that T is infeasible 1: sort tasks T such that n 2: set S 0 to be emty schedule 3: for j 1 to n do 4: if idle time during [0, d j ) is strictly less than c j then 5: return task set T infeasible 6: else 7: comute largest x 0 s.t. S j 1 has exactly c j units of idle time in [x, d j ) 8: b j x 9: Let S j be the rocrast schedule defined by anic offsets b 1,..., b j 10: end if 11: end for 12: S S n 13: return S In reference to Algorithm 3, we now show how to erform the test of Line 4 and how to comute the value x (Line 7) through a olynomial time subroutine that comutes the idle time in S j 1 during the interval [x, d j ) for a given value x. 7

8 Lemma 5. Consider a feasible rocrast schedule S j 1 for tasks {τ 1,..., τ j 1 }, secified by anic offsets b 1,..., b j 1, and a value x 0. The amount of idle time in S j 1 during [x, d j ) can be comuted in olynomial time. Before roving the lemma we show how it allows to comlete the descrition of Algorithm 3. First of all observe that Lemma 5 allows to check whether during [0, d j ) the amount of idle time is at least c j (Line 4 of Algorithm 3). If this is not the case then Algorithm 3 oututs that the system is infeasible and we sto. Otherwise, we use Lemma 5 several times to comute the largest value x 0 such that during [x, d j ) the idle time of the rocessor equals exactly c j (see Line 7 in the descrition of Algorithm 3). We do this with a binary search rocedure. First, we define a lower bound LB := 0 and an uer bound UB := d j. We kee as an invariant that the idle time within [LB, d j ) is at least c j and the idle time within [UB, d j ) is at most c j. In each iteration, we check the idle time within [(UB LB)/2, d j ) using Lemma 5 and udate LB or UB accordingly. Hence, after O(log(d j )) iterations we find the largest value x with the desired roerty. We define the anic offset of task τ j to be b j := x and continue with task τ j+1. The roof of Lemma 5 hinges on the following lemma that comutes in S j 1 the latest oint in time t N before a given time t N such that no jobs are started that will not finish by time t. Note that this is almost but not exactly the same as saying that the rocessor is idle at time t. In articular, it might be the case that t [a i(j) + b j, a i(j) + d j ) for some job i(j) and no other job is ending. Formally, we have the following lemma. Lemma 6. Consider a feasible rocrast schedule S j 1 for tasks {τ 1,..., τ j 1 }, secified by anic offsets b 1,..., b j 1, and a value t N. There is a olynomial time algorithm which comutes the largest value t t such that t / (a i(j ) + b j, a i(j ) + d j ) for each task τ j with j {1,..., j 1} and each job i(j ). Proof: First, we consider the given value t and verify whether t (a i(j )+b j, a i(j )+d j ) for some job i(j ) of some task τ j, j {1,..., j 1}. This can be done in olynomial time because if there is such a job then it has to be the job i(j ) with t [a i(j ), a i(j )+1) and its index i(j ) equals t/ j. Thus, for each task j {1,..., j 1} we consider the job with index t/ j and verify if t (a i(j ) + b j, a i(j ) + d j ). If this is not the case for any j {1,..., j 1}, then we outut t := t and we are done. Consider now the case that t (a i(j ) + b j, a i(j ) + d j ) for some job i(j ). We define t 0 := t and let j (0) be the index of a task such that t 0 (a i(j (0) ) + b j (0), a i(j (0) ) + d j (0)) for some job i(j (0) ). We define t 1 := a i(j (0) ) + b j (0) < t 0. We iterate: If t 1 has the roerty stated in the lemma, that is, t 1 / (a i(j ) + b j, a i(j ) + d j ) for any job of any task τ j with j {1,..., j 1}, then we are done and define t := t 1. (We verify this as described above for value t.) Otherwise there must be a task j (1) such that t 1 (a i(j (1) ) + b j (1), a i(j (1) ) + d j (1)) for some job i(j (1) ) of j (1). In that case j (0) < j (1), since by definition of rocrast schedules at time t 1 a job of task j (0) is executed and during the whole interval [a i(j (1) ) + b j (1), a i(j (1) ) +d j (1)) jobs of tasks having index in {1,..., j (1) } are executed (note that j (0) j (1) since d j j for all tasks τ j ). We iterate this rocedure until we find a value t k with the roerties that we require for t. Similarly as before, we can argue that j (k 1) < j (k ) for all k k and thus at most n iterations are needed. In every iteration we check for each task τ j {τ 1,..., τ j 1 } whether it has a job i(j ) with t i (a i(j ) + b j, a i(j ) + d j ). By the above reasoning, it is sufficient to check this for the job with index t/ j. Thus, the overall running time of this subrocedure is bounded by O(n 2 ). The rocedure is summarized in Algorithm 4. We are now ready to rove Lemma 5. Proof (of Lemma 5): The amount of idle time in [x, d j ] equals the amount of idle time in [0, d j ) minus the amount of idle time in [0, x). Thus, it is sufficient to rovide a olynomial-time routine for comuting the amount of idle time for the interval [0, x) for any value x 0. We do this as follows. Using the rocedure from Lemma 6 we comute the last oint in time x x such that x / (a i(j )+b j, a i(j )+d j ) for each task j {1,..., j 1} and each job i(j ). By definition of rocrast schedules, the rocessor is busy during the interval [x, x). On the other hand, during the interval [0, x ) rocrast executes only those jobs whose deadline is in [0, x ). Given x, we can easily comute for each task j how many jobs of j have their deadline in [0, x ). Hence, we can calculate the total execution time C of jobs i with d i [0, x ). Then, the amount of idle time within [0, x) equals x C. The overall rocedure requires two calls to the rocedure from Lemma 6 whose running time is bounded by O(n 2 ). Thus, the total running time of this rocedure is also bounded by O(n 2 ). 3) Feasibility of the rocrast schedule S (the feasibility test): The feasibility test for a given task system T now is as follows. We consider all tasks τ j T one after the other in order of their indices and run the algorithm for comuting the anic offset b j. If for some j there is no non-negative value b j then we outut that the system T is infeasible. Otherwise, we outut that T is EDF-schedulable. In the following two lemmas we show that both actions are justified. First, we argue that if b j 0 for a given feasible rocrast schedule S j 1 for tasks {τ 1,..., τ j 1 }, then S j is feasible. Secondly, we need to show that if b j < 0 then the worst-case instance is infeasible. Lemma 7. If S j 1, j = 2, 3,..., n, is a feasible rocrast schedule and during [0, d j ) the amount of idle time is at least c j then also S j is a feasible rocrast schedule. Proof: Since the eriod lengths are harmonic, the hyereriod of { 1,..., j } equals j. Since we consider only the synchronous arrival sequence, if the first job of task τ j meets its deadline then all jobs of τ j meet their deadline. The former roerty is ensured due to the definition of b j. In fact, b j x 8

9 Algorithm 4 Comutation of last time oint t before t without started job in rocrast schedule S (Lemma 6) Inut: A rocrast schedule S, secified by anic offsets b 1,..., b j 1 and a value t Outut: largest value t t such that t / (a i(j )+b j, a i(j )+ d j ) for each task j {1,..., j 1} and each job i(j ) 1: if t / (a i(j ) + b j, a i(j ) + d j ) for each task τ j with j {1,..., j 1} and each job i(j ) then 2: t t 3: return t 4: else 5: t 0 t 6: k 0 7: while there is a task τ j with j {1,..., j 1} and a job i(j ) with t k (a i(j ) + b j, a i(j ) + d j ) do 8: t k+1 a i(j ) + b j 9: k k : end while 11: end if 12: t t k 13: return t is executed in the j-th iteration of the main loo of Algorithm 3 only if there are at least c j units of idle time in S j 1. Hence, the schedule S j is feasible. Now we show that if our rocedure does not give a feasible schedule, then no feasible schedule exists. Lemma 8. Given the rocrast schedule S j 1 for the tasks {τ 1,..., τ j 1 } comuted by the above rocedure, if the amount of idle time during the interval [0, d j ) is strictly smaller than c j then task set {τ 1,..., τ j } is infeasible. Proof: We show by induction the following slightly stronger claim. For each j j 1 the comuted schedule S j maximizes the idle time during the interval [0, x) for each x 0 simultaneously. Formally, for each j j 1 and each x 0 there is no feasible schedule for the tasks {τ 1,..., τ j } with strictly more idle time during [0, x) than S j. We show the claim by induction over j. For j = 1 the claim is immediate since we start each job of τ 1 as late as ossible. Now suose that the claim is true for some value j 1 and consider the schedule S j and a value x 0. First assume that there is no job i of τ j such that x [a i, d i ) and assume that there are exactly k jobs i of τ j such that d i x. Then any feasible schedule has to work for k c j units of time on jobs of τ j during [0, x) and thus the claim follows from the induction hyothesis. Now suose that x [a i, d i ) for some job i created by task τ j. Since j j and d j j for each j j we can assume w.l.o.g. that x [0, d j ), i.e., i is the first job created by task τ j. Suose by contradiction that there is some feasible schedule S for tasks {τ1,..., τ j } with strictly more idle time during [0, x) than S j. W.l.o.g. we can assume that in S between the time when i is started and d j the rocessor has no idle time, i.e., intuitively, job i is started as late as ossible in S. Let s denote the time when i is started in S, i.e., executed for the first time, and recall that bj is the resective time in S j (since i is the first job of task τ j ). Observe that S does not have any idle time during [s, dj ). If x min{s, b j } then we have a contradiction to the induction hyothesis as then during [0, x) the schedules S j and S j 1 are identical, in articular they do not execute a job from task τ j, and they maximize the amount of idle time during [0, x) among all feasible schedules for the tasks {τ 1,..., τ j }. Now suose that x > min{s, b j }. If s b j then in articular x > s and also S must have more idle time during [0, s) than S j (using that S does not have any idle time during [s, d j ) [s, x)). However, during [0, s) the schedules S j and S j 1 are identical and do not execute a job from task τ j (since s b j ) which contradicts the induction hyothesis using the same arguments as for the case that x min{s, b j }. The last case is that s > b j, i.e., in S the job i starts later than in S j. Denote by y the amount of idle time during [0, d j ) in S and by y the amount of idle time during [0, d j ) in S j. As during [b j, d j ) there is no idle time in S j we have that y > y. However, if we take the schedule S and remove all jobs from task τ j then we get a schedule S for the tasks {τ 1,..., τ j 1} whose idle time during [0, d j ) equals y + c j. Likewise, the schedule S j 1 has y + c j units of idle time during [0, d j ). The induction hyothesis imlies that y + c j y + c j which imlies that y y, a contradiction. Finally, we show how the above claim imlies the lemma. If in S j 1 the amount of idle time during the interval [0, d j ) is strictly smaller than c j then the latter has to hold for any feasible schedule for the tasks {τ 1,..., τ j 1 }. Thus, there can be no feasible schedule for the tasks {τ 1,..., τ j }. If, after comleting all n iterations, the schedule S (= S n ) is feasible, then the task set T is feasible and therefore EDFschedulable. This yields the following theorem. Theorem 3. There is a olynomial time algorithm that, on inut a constrained-deadline harmonic task set T, decides whether T is EDF-schedulable on one rocessor. Proof: We use Algorithm 3 to comute the rocrast schedule S. If the routine fails then, according to Lemma 8, task set T is infeasible. On the other hand, if the routine is successful, then by Lemma 7 the resulting schedule is feasible and thus T is feasible (and therefore EDF-schedulable). The main loo of Algorithm 3 runs in n iterations and in the j-th iteration the running time is dominated by the O(log d j ) calls to the subroutine of Lemma 5, each having a running time of O(n 2 ). Thus, the overall running time is bounded by O(n 3 log(max n j=1 d j)) = O(n 3 log P ), which is olynomially bounded in the inut length. V. CONCLUSION Two of the most basic roblems in real-time scheduling are comuting the resonse time of a given task system and checking EDF-schedulability on a unirocessor. It is known that both roblems are comutationally hard [13], [15] and 9

10 therefore, it is exected that no efficient algorithm exists. On the other hand, instances that arise in ractice are often very secial, in the sense that their eriod lengths are harmonic. In fact, harmonic eriod lengths allow high utilizations of the rocessors, which make them a natural choice for a system designer. For this imortant secial class of instances, in this aer we resented the first efficient, exact olynomial time algorithms. This rovides evidence that the comutational comlexity of the non-harmonic instances mostly stems from the ossibly comlicated algebraic structures in the eriod lengths. Our results hold only for constrained-deadline task systems. Extending them to arbitrary (unconstrained) task systems is an interesting oen question. Also, it would be interesting to extend our results to the study of exact schedulability tests for other algorithms, such as FPZL (Fixed Priority until Zero Laxity). Another imortant research toic is to extend our results to more general system models, including other arameters such as blocking times caused by shared resources. Finally, we observe that while our schedulability tests for fixed riority and fully harmonic EDF-schedulability are very efficient and alicable to large task sets, it would be interesting to imrove the running time of the EDF-schedulability test for harmonic eriods (Algorithm 3). REFERENCES [1] K. Albers and F. Slomka. An event stream driven aroximation for the analysis of real-time systems. In Proc. 16th Euromicro Conf. on Real-Time Systems, ages IEEE, [2] N. Audsley, A. Burns, M. Richardson, and A. Wellings. Alying new scheduling theory to static riority re-emtive scheduling. Software Engineering Journal, 8(5): , [3] S. K. Baruah. Efficient comutation of resonse time bounds for reemtive unirocessor deadline monotonic scheduling. Real-Time Systems, 47(6): , [4] S. K. Baruah and J. Goossens. Scheduling real-time tasks: Algorithms and comlexity. In J. Y.-T. Leung, editor, Handbook of Scheduling: Algorithms, Models, and Performance Analysis, chater 28. CRC Press, [5] S. K. Baruah, R. R. Howell, and L. E. Rosier. Feasibility roblems for recurring tasks on one rocessor. Theoretical Comut. Sci., 118(1):3 20, [6] S. K. Baruah, L. E. Rosier, and R. R. Howell. Algorithms and comlexity concerning the reemtive scheduling of eriodic, real-time tasks on one rocessor. Real-Time Systems, 2: , [7] E. Bini, G. C. Buttazzo, and G. Buttazzo. Rate monotonic analysis: The hyerbolic bound. IEEE Trans. Comut., 52(7): , [8] E. Bini, T. H. C. Nguyen, P. Richard, and S. K. Baruah. A resonsetime bound in fixed-riority scheduling with arbitrary deadlines. IEEE Trans. Comut., 58(2): , [9] D. Chen, A. K. Mok, and T.-W. Kuo. Utilization bound revisited. IEEE Trans. Comut., 52(3): , [10] R. I. Davis, A. Zabos, and A. Burns. Efficient exact schedulability tests for fixed riority real-time systems. IEEE Trans. Comuters, 57(9): , [11] M. L. Dertouzos. Control robotics: The rocedural control of hysical rocesses. In Proc. IFIP Congress, ages , [12] F. Eisenbrand, K. Kesavan, R. S. Mattikalli, M. Niemeier, A. W. Nordsieck, M. Skutella, J. Verschae, and A. Wiese. Solving an avionics real-time scheduling roblem by advanced IP-methods. In Algorithms ESA 2010, ages Sringer, [13] F. Eisenbrand and T. Rothvoss. Static-riority real-time scheduling: Resonse time comutation is NP-hard. In Proc. IEEE Real-Time Systems Sym., ages IEEE, [14] F. Eisenbrand and T. Rothvoss. New hardness results for diohantine aroximation. In Aroximation, Randomization, and Combinatorial Otimization. Algorithms and Techniques APPROX-RANDOM 2009, ages Sringer, [15] F. Eisenbrand and T. Rothvoss. EDF-schedulability of synchronous eriodic task systems is conp-hard. In Proc. 21st ACM-SIAM Symosium on Discrete Algorithms. SIAM, [16] M. Fan and G. Quan. Harmonic semi-artitioned scheduling for fixedriority real-time tasks on multi-core latform. In Proc. of DATE, ages IEEE, [17] N. Fisher and S. K. Baruah. A fully olynomial-time aroximation scheme for feasibility analysis in static-riority systems with arbitrary relative deadlines. In Proc. 17th Euromicro Conf. on Real-Time Systems, ages IEEE, [18] R. Ha and J. W.-S. Liu. Validating timing constraints in multirocessor and distributed real-time systems. In Proc. 14th Int. Conference on Distributed Comuting Systems, ages , [19] C.-C. Han and H.-Y. Tyan. A better olynomial-time schedulability test for real-time fixed-riority scheduling algorithm. In Proc. IEEE Real- Time Systems Sym., ages IEEE, [20] D. S. Hochbaum and D. B. Shmoys. Using dual aroximation algorithms for scheduling roblems theoretical and ractical results. J. ACM, 34(1): , [21] E. Horowitz and S. Sahni. Exact and aroximate algorithms for scheduling nonidentical rocessors. J. ACM, 23(2): , [22] M. Joseh and P. K. Pandya. Finding resonse times in a real-time system. The Comuter Journal, 29(5): , [23] T.-W. Kuo and A. K. Mok. Load adjustment in adative real-time systems. In Proc. IEEE Real-Time Systems Sym., ages IEEE, [24] J. P. Lehoczky, L. Sha, and Y. Ding. The rate monotonic scheduling algorithm: Exact characterization and average case behavior. In Proc. IEEE Real-Time Systems Sym., ages IEEE, [25] J. P. Lehoczky, L. Sha, J. K. Strosnider, and H. Tokuda. Fixed riority scheduling theory for hard real-time systems. In A. van Tilborg and G. Koob, editors, Foundations of Real-Time Comuting: Scheduling and Resource Management, ages Kluwer Academic, New York, [26] J. Y.-T. Leung and M. L. Merrill. A note on reemtive scheduling of eriodic, real-time tasks. Inf. Process. Lett., 11(3): , [27] J. Y.-T. Leung and J. Whitehead. On the comlexity of fixed-riority scheduling of eriodic, real-time tasks. Perform. Evaluation, 2(4): , [28] C. L. Liu and J. W. Layland. Scheduling algorithms for multirogramming in a hard-real-time environment. J. ACM, 20(1):46 61, [29] A. K. Mok. Fundamental design roblems of distributed systems for the hard real-time environment. PhD thesis, Laboratory for Comuter Science, Massachusetts Institute of Technology, Available as Technical Reort No. MIT/LCS/TR-297. [30] M. S. Mollison, J. P. Erickson, J. H. Anderson, S. K. Baruah, and J. A. Scoredos. Mixed-criticality real-time scheduling for multicore systems. In 10th IEEE International Conference on Comuter and Information Technology, CIT 2010, ages , [31] T. H. C. Nguyen, P. Richard, and E. Bini. Aroximation techniques for resonse-time analysis of static-riority tasks. Real-Time Systems, 43(2): , [32] C. Okwudire, M. van den Heuvel, R. Bril, and J. Lukkien. Exloiting harmonic eriods to imrove linearly aroximated resonse-time uer bounds. In Proc. ETFA, ages 1 4. IEEE, [33] O. Serlin. Scheduling of time critical rocesses. In AFIPS Sring Joint Comuting Conference, ages , [34] L. Sha, T. F. Abdelzaher, K.-E. Årzén, A. Cervin, T. P. Baker, A. Burns, G. C. Buttazzo, M. Caccamo, J. P. Lehoczky, and A. K. Mok. Real time scheduling theory: A historical ersective. Real-Time Systems, 28(2-3): , [35] L. Sha and J. B. Goodenough. Real-time scheduling theory and Ada. IEEE Comuter, 23(4):53 62, [36] M. Sjödin and H. Hansson. Imroved resonse-time analysis calculations. In Proc. IEEE Real-Time Systems Sym., ages IEEE, [37] K. Tindell, A. Burns, and A. J. Wellings. An extendible aroach for analyzing fixed riority hard real-time tasks. Real-Time Systems, 6(2): , [38] F. Zhang and A. Burns. Schedulability analysis for real-time systems with EDF scheduling. IEEE Trans. Comut., 58(9): ,