Exact speedup factors and suboptimality for nonpreemptive scheduling
 547 Downloads
Abstract
Fixed priority scheduling is used in many realtime systems; however, both preemptive and nonpreemptive variants (FPP and FPNP) are known to be suboptimal when compared to an optimal uniprocessor scheduling algorithm such as preemptive earliest deadline first (EDFP). In this paper, we investigate the suboptimality of fixed priority nonpreemptive scheduling. Specifically, we derive the exact processor speedup factor required to guarantee the feasibility under FPNP (i.e. schedulability assuming an optimal priority assignment) of any task set that is feasible under EDFP. As a consequence of this work, we also derive a lower bound on the suboptimality of nonpreemptive EDF (EDFNP). As this lower bound matches a recently published upper bound for the same quantity, it closes the exact suboptimality for EDFNP. It is known that neither preemptive, nor nonpreemptive fixed priority scheduling dominates the other, in other words, there are task sets that are feasible on a processor of unit speed under FPP that are not feasible under FPNP and viceversa. Hence comparing these two algorithms, there are nontrivial speedup factors in both directions. We derive the exact speedup factor required to guarantee the FPNP feasibility of any FPP feasible task set. Further, we derive the exact speedup factor required to guarantee FPP feasibility of any constraineddeadline FPNP feasible task set.
Keywords
Realtime Uniprocessor Resource augmentation Speedup factor Suboptimality Nonpreemptive scheduling Preemptive scheduling EDF Fixed priority1 Introduction
Realtime systems are prevalent in a wide variety of application areas including telecommunications, consumer electronics, aerospace systems, automotive electronics, robotics, and medical systems. The functionality of these systems is typically mapped to a set of periodic or sporadic realtime tasks, with each task giving rise to a potentially unbounded sequence of jobs. Timely execution of the tasks and their jobs is supported by the use of realtime scheduling algorithms.
Realtime scheduling algorithms for single processor systems may be classified into two main types: fixed priority and dynamic priority. Fixed priority scheduling is the de facto standard approach used in many applications. Here, a unique static priority is assigned to each task and inherited by all of its jobs. At runtime, the scheduler uses these priorities to determine which job to execute. Earliest Deadline First (EDF) is the most common example of a dynamic priority scheduling algorithm. EDF uses priorities based on the absolute deadline of each job to make scheduling decisions.
Realtime scheduling algorithms may also be classified in terms of when and if preemption is permitted. Thus we have preemptive and nonpreemptive variants of both fixed priority (FPP and FPNP) and EDF (EDFP and EDFNP) scheduling.
There are a number of different ways in which the performance of realtime scheduling algorithms can be compared (Davis 2017). Empirical techniques typically rely on generating a large number of task sets with parameters chosen from some appropriate distributions. The performance of the scheduling algorithms are then compared by determining task set schedulability according to exact or sufficient schedulability tests and plotting a graph of the success ratio, i.e. the proportion of task sets that are deemed schedulable, at different utilization levels. More advanced approaches use a weighted schedulability metric (Bastoni et al. 2010) to illustrate how schedulability varies with a further parameter, for example task set cardinality, or the range of task periods. Similar comparisons may be obtained by using a simulation of each algorithm as a necessary schedulability test, hence showing the proportion of task sets found to be definitely unschedulable due to a deadline miss in the simulation. These empirical approaches tend to focus on the averagecase behaviour over large numbers of task sets rather than highlighting those task sets that are particularly difficult to schedule using one algorithm, but may be easy to schedule using another. Metrics such as breakdown utilisation (Lehoczky et al. 1989) and optimality degree (Bini and Buttazzo 2005) can also be used to examine averagecase performance.
In this paper, we focus on a theoretical method of comparing the worstcase performance of realtime scheduling algorithms based on a resource augmentation metric referred to as the processor speedup factor (Kalyanasundaram and Pruhs 2000). Specifically, we derive bounds on the factor by which the speed of the processor needs to be increased to ensure that any task set that is feasible under some scheduling algorithm \(\mathcal {A}\) is guaranteed to be feasible under another algorithm \(\mathcal {B}\). When \(\mathcal {A}\) is an optimal algorithm, then this speedup factor provides a measure of the suboptimality of algorithm \(\mathcal {B}\). Note, when we refer to a task set as being feasible under a particular scheduling algorithm, if that algorithm uses fixed priorities, then feasibility refers to the task set being schedulable assuming an optimal priority assignment.
In this paper, we use speedup factors to compare fixed priority nonpreemptive scheduling (FPNP) with both fixed priority preemptive (FPP) and Earliest Deadline First (EDFP) scheduling.
Our interest in FPNP scheduling stems from the fact that in modern uniprocessor systems preemption can significantly increase overheads due to a number of factors. These include context switch costs and cache related preemption delays (CRPD) which have to be accounted for in both FPP (Altmeyer et al. 2011, 2012) and EDFP (Lunniss et al. 2013) scheduling. CRPD can have a substantial impact, increasing task execution times by as much as 33% (Bui et al. 2008). One way of reducing or eliminating CRPD is to partition the cache; however, allocating each task a cache partition, which is some fraction of the overall size of the cache, has an impact on the task’s worstcase execution time (WCET) which may be significantly inflated. Such partitioning rarely improves upon schedulability compared to accounting for CRPD and allowing tasks to use the entire cache (Altmeyer et al. 2014, 2016). An alternative method which eliminates CRPD without increasing WCETs is to employ a fully nonpreemptive scheduler. Nonpreemptive scheduling has the additional advantage of reducing memory requirements, as well as improving the dependability of realtime systems (Short 2010). It is however well known that nonpreemptive scheduling can be infeasible at low processor utilization levels due to the long task problem (Short 2010), where some task has a WCET greater than the deadline of another task.
When considering the theoretical optimality of uniprocessor scheduling algorithms (i.e., without accounting for overheads), then EDFP is optimal in the sense that any task set that is feasible on a uniprocessor under some other scheduling algorithm is also feasible using EDFP (Dertouzos 1974). As a result, EDFP dominates other uniprocessor scheduling algorithms such as FPP, FPNP, and EDFNP.
When using fixed priority scheduling, priority assignment has a significant impact on schedulability (Davis et al. 2016). For FPP scheduling, Deadline Monotonic Priority Ordering (DMPO) is optimal for constraineddeadline task sets (Leung and Whitehead 1982). In other words, any constraineddeadline task set that is schedulable under FPP with some other priority ordering is also guaranteed to be schedulable with DMPO. DMPO is not however optimal if task deadlines are arbitrary (Lehoczky 1990) (i.e. may be larger than their periods). In that case, Audsley’s algorithm (Audsley 2001) can be used to provide an optimal priority assignment.
Within the class of nonpreemptive scheduling algorithms, no workconserving algorithm is optimal. This is because in general it is necessary to insert idle time to achieve a feasible schedule (George et al. 1996). EDFNP is however weakly optimal in the sense that if a work conserving nonpreemptive schedule exists for a task set, then EDFNP can schedule it (Jeffay et al. 1991), hence EDFNP dominates FPNP. With FPNP scheduling, DMPO is not optimal for constraineddeadline task sets; however, Audsley’s algorithm (Audsley 2001) can again be applied (George et al. 1996).
1.1 Speedup factors
Davis et al. (2009a) derived the exact suboptimality \(S = 1/\varOmega \) \(\approx 1.76\) of FPP scheduling for constraineddeadline task sets. This exact bound complements the one for implicitdeadline task sets \(S=1/ ln(2)\,\,\approx 1.44\) that may be derived from the famous results of Liu and Layland (1973). Davis et al. (2009b) also derived upper and lower bounds of \(S = 1/\varOmega \) and \(S=2\) on the suboptimality of FPP scheduling for arbitrarydeadline task sets. Davis et al. (2015a) completed the exact characterization of the suboptimality of FPP scheduling by proving that the exact speedup factor required for arbitrarydeadline task sets is in fact \(S=2\). In the same paper, the authors also extended these results to the case where tasks share resources under mutual exclusion according to the stack resource policy (SRP) (Baker 1991) or the deadline floor protocol (DFP) (Burns et al. 2015), thus providing exact speedup factors comparing FPP + SRP to EDF + SRP or EDF + DFP.
Davis et al. (2010) derived upper and lower bounds on the speedup factor required to guarantee that all task sets that are feasible under EDFNP can be scheduled using FPNP. These bounds are \(S = 1/\varOmega \) and \(S=2\) respectively for all three classes of task set (implicit, constrained and arbitrary deadline). von der Bruggen et al. (2015) proved upper bounds of \(S = 1/\varOmega \) for the implicit and constrained deadline cases, thus along with the prior results, showing that these values are exact. Davis et al. (2015a) also completed the exact characterization of the speedup factors required to guarantee schedulability under FPNP of all EDFNP feasible task sets by showing that the exact speedup factor for the arbitrary deadline case is \(S=2\) (the same as in the preemptive case for FPP v. EDFP).
Thekkilakattil et al. (2013, 2015) quantified the suboptimality of EDFNP (with respect to EDFP), bridging between the preemptive and nonpreemptive paradigms. (This result was later extended to the case of global deadline based scheduling (Thekkilakattil et al. 2014)). Abugchem et al. (2015) subsequently provided a tighter upper bound on the suboptimality of EDFNP.
In this paper, we focus on quantifying the suboptimality of uniprocessor FPNP scheduling with respect to an optimal algorithm such as EDFP. As a consequence of this work, we also quantify the exact suboptimality of uniprocessor EDFNP scheduling. Further, we use the speedup factor metric to compare the performance of FPP and FPNP scheduling in both directions, given the lack of any dominance relation between them.
 S1

The exact speedup factor required to guarantee FPNP feasibility of any EDFP feasible task set (i.e. the exact suboptimality of FPNP).
 S2

The exact speedup factor required to guarantee FPNP feasibility for any task set that is FPP feasible.
 S3

The exact speedup factor required to guarantee EDFNP feasibility of any EDFP feasible task set (i.e. the exact suboptimality of EDFNP).
 S4

The exact speedup factor required to guarantee FPP feasibility for any constraineddeadline task set that is FPNP feasible.
Note, where we refer to the exact suboptimality, or exact speedup factor for a nonpreemptive scheduling algorithm compared to a preemptive one, then it is important to clarify precisely what we mean. Since nonpreemptive scheduling suffers from the long task problem (Short 2010), whereby a task set may be trivially unschedulable because the longest execution time \(C_{max}\) of one task exceeds the shortest deadline \(D_{min}\) of another, then assuming freely determined task parameters no finite speedup factor exists. This is the case because \(C_{max}/D_{min}\) can be made arbitrarily large. Instead, in this paper we provide exact speedup factors that are parametric in the ratio \(C_{max}/D_{min}\), and thus hold with this minimal constraint on task parameters such that a finite speedup factor exists. We note that with further information about task set characteristics it may be possible to determine more precise speedup factors with narrower scope, i.e. more constraints on their validity. In the extreme, each individual task set effectively has a precise speedup factor which may be computed by referring to all of the parameters of its component tasks.
In this paper, as in previous work on speedup factors (Davis et al. 2009a, b, 2010, 2015a; Thekkilakattil et al. 2013) we assume that changes in processor speed have a linear effect on the time required to execute each task. Considering a uniprocessor system in more detail, our assumption is that the clock frequency may be changed and that this has a linear effect on the speed of all hardware components (processor, memory etc.) thus producing a linear scaling of execution times. Such behaviour is a reasonable approximation for simple systems.
While the results presented in this paper are mainly theoretical, they may also have practical utility in enabling system designers to quantify the maximum penalty for using FPNP scheduling in terms of the additional processing capacity required as compared to FPP or EDFP. This performance penalty can then be weighed against other factors such as the additional overheads (context switch costs and CRPD) incurred by preemptive scheduling, when considering which algorithm to use. We also consider the speedup factor for FPP scheduling versus FPNP. This speedup factor is indicative of the increase in processor speed that may be necessary in the worstcase to maintain schedulability when making a choice to switch from using FPNP scheduling to FPP.
It is important to note that speedup factors are indicative only of the worstcase performance of one algorithm relative to another, and as such should only be considered for their negative implications. We note that speedup factors can lack the power to discriminate between the performance of different scheduling algorithms and schedulability tests even though their performance may be very different when viewed from the perspective of empirical evaluation (von der Bruggen et al. 2016). The interested reader is referred to recent work by Chen et al. (2017) for a full discussion of the pros and cons of using speedup factors and other resource augmentation metrics.
1.2 Organization
The rest of the paper is organized as follows: the system model is presented in Sect. 2. Section 3 recaps on the schedulability analyses for preemptive and nonpreemptive EDF and fixed priority scheduling. Our main results on suboptimality and speedup factors are presented in Sects. 4 and 5. Section 6 concludes with a summary and a discussion of open problems.
2 System model
In this section we describe the system model, terminology, and notation used in the rest of the paper.
2.1 Task model
We consider the schedulability of a set of sporadic tasks on a uniprocessor system. A task set \(\varGamma \) comprises a static set of n tasks \(\{\tau _1,\tau _2,\ldots \tau _n\)}. Each task \(\tau _i\) is characterized by its minimum interarrival time \(T_i\), bounded worstcase execution time \(C_i\), and relative deadline \(D_i\). Deadlines may be implicit (\(D_i = T_i\)), constrained (\(D_i \le T_i\)), or arbitrary (independent of the task’s period). The longest execution time of any of the tasks is denoted by \(C_{max}=\displaystyle \max _{\forall \tau _i \in \varGamma } C_i\). Similarly, the shortest deadline is denoted by \(D_{min}=\displaystyle \min _{\forall \tau _i \in \varGamma } D_i\). In the case of fixed priority scheduling, we use hp(i) and hep(i) to denote respectively the set of tasks with priorities higher than, and higher than or equal to that of task \(\tau _i\) (thus hep(i) includes task \(\tau _i\), while hp(i) does not). Similarly, we use lp(i) to denote the set of tasks with priorities lower than that of task \(\tau _i\). (Note, we assume that priorities are unique). Further, we use \(B_i\) to denote the longest time for which task \(\tau _i\) may be blocked by a lower priority task that is executing nonpreemptively.
The utilization \(U_i\) of a task \(\tau _i\) is given by \(U_i = \frac{C_i}{T_i}\) and the utilization of the task set is the sum of the utilizations of the individual tasks \(U = \sum _{i=1}^n U_i\).
2.2 Execution time model
To ease readability, and without loss of generality, we assume that the task set of interest is initially executing on a processor of unit speed. Accordingly, we assume that \(C_{i}\) represents the WCET of task \(\tau _i\) on a processor of speed \(S=1\). We assume a linear relationship between execution time and processor speed. The WCET of task \(\tau _{i}\) on a processor of speed S is therefore given by \(C_{i}^S=C_{i}/S\). Conversely, the speed S required to obtain an execution time of \(C_i^S\) is given by \(S= C_{i}/C_{i}^S\). This model allows us to use processor speedup factors and processor speeds interchangeably. In other words, changing the processor speed from \(S=1\) to \(S=x\), is equivalent to speeding up the processor by a factor of x.
2.3 Scheduling model
In this paper, we consider four scheduling algorithms EDFP, EDFNP, FPP, and FPNP. With EDFP, at any given time the ready task with the job that has the earliest absolute deadline is executed by the processor. Similarly, with FPP scheduling, at any given time the processor executes the job of the ready task with the highest priority. By contrast, with EDFNP, whenever a job is released that has an earlier absolute deadline than the currently executing job, instead of preempting the executing job the scheduler blocks the new job until the currently executing job completes. Only at that point is the ready job with the earliest absolute deadline dispatched for execution. Similarly, with FPNP scheduling, whenever a higher priority task is released during the execution of a lower priority task \(\tau _i\), instead of preempting \(\tau _i\) the scheduler blocks the higher priority task until \(\tau _i\) completes its execution. Only at that point is the highest priority ready task dispatched for execution. We note that all four scheduling algorithms are workconserving and so never idle the processor when there is a task ready to execute.
2.4 Schedulability tests and priority assignment
A task set is said to be schedulable with respect to some scheduling algorithm and some system, if all valid sequences of jobs that may be generated by the task set can be scheduled on the system by the scheduling algorithm without any missed deadlines.
A schedulability test is referred to as sufficient, with respect to a scheduling algorithm and system, if all of the task sets that are deemed schedulable according to the test are in fact schedulable on the system under the scheduling algorithm. Similarly, a schedulability test is termed necessary, if all of the task sets that are deemed unschedulable according to the test are in fact unschedulable on the system under the scheduling algorithm. A test that is both sufficient and necessary is referred to as exact.
In fixed priority scheduling, a priority assignment policy P is said to be optimal with respect to some class of task sets (e.g. constraineddeadline), and some class of fixed priority scheduling algorithm (e.g. nonpreemptive) if all task sets in the class that are schedulable under the scheduling algorithm using some other priority ordering policy are also schedulable using the priority assignment determined by policy P.
2.5 Speedup factors
We now provide formal definitions for the terms speedup factor, speedup optimal task set and suboptimality (Davis et al. 2009a, 2015a). Recall that when we use the term feasible, then in the case of fixed priority scheduling, we mean schedulable with an optimal priority assignment.
Definition 1
The exact speedup factor of a scheduling algorithm \(\mathcal {A}\) with respect to a scheduling algorithm \(\mathcal {B}\) is defined as the minimum factor S, \(S\ge 1\), such that any task set that is feasible under algorithm \(\mathcal {B}\) on a processor of unit speed, is guaranteed to become feasible under algorithm \(\mathcal {A}\) on a processor that is S times faster.
Definition 2
A task set is classified as being a speedup optimal task set for the comparison between scheduling algorithms \(\mathcal {A}\) and \(\mathcal {B}\) if it is feasible on a processor of unit speed under algorithm \(\mathcal {B}\) and requires the processor speed to be increased by the exact speedup factor S for the comparison between the two algorithms (see Definition 1) in order to be feasible under algorithm \(\mathcal {A}\).
We note that for a given comparison, there are typically multiple speedupoptimal task sets. This classification is useful, since in deriving the exact speedup factors for a given comparison, we can restrict our attention to the set of speedup optimal task sets, and their properties.
Definition 3
The suboptimality of a scheduling algorithm \(\mathcal {A}\) is defined by its exact speedup factor with respect to an optimal scheduling algorithm.
Definition 4
A scheduling algorithm is said to be optimal if it can schedule every task set that is feasible under some other scheduling algorithm, on a processor of equivalent speed.
The lower the value of suboptimality for a particular scheduling algorithm (i.e. its speedup factor compared to an optimal algorithm), then the closer the algorithm is to being optimal, with a value of \(S=1\) implying optimality. We note that FPP, FPNP, and EDFNP are all suboptimal with respect to an optimal uniprocessor scheduling algorithm such as EDFP, as illustrated in Fig. 1.
In order to derive speedup factors it is often useful to consider scaling the execution times of all tasks until the task set being considered is only just schedulable. Below, we give alternative but equivalent definitions for speedup factor and speedup optimal task set using the concept of a critical scaling factor (Lehoczky et al. 1989).
Definition 5
Definition 6
Let \(\alpha ^\mathcal {A}(\varPsi )\) be the critical scaling factor for task set \(\varPsi \) under scheduling algorithm \(\mathcal {A}\), and similarly \(\alpha ^\mathcal {B}(\varPsi )\) under algorithm \(\mathcal {B}\). Task set \(\varPsi \) is said to be a speedupoptimal task set with respect to the comparison between scheduling algorithm \(\mathcal {A}\) and algorithm \(\mathcal {B}\) if \(\alpha ^\mathcal {B}(\varPsi ) / \alpha ^\mathcal {A}(\varPsi ) = S\), where S is the exact speedup factor for the comparison between the two algorithms.
Determining the exact value of the speedup factor for the comparison between two algorithms \(\mathcal {A}\) and \(\mathcal {B}\) requires both necessary and sufficient conditions to be considered. To satisfy the sufficient condition, an upper bound on the speedup factor can be derived which represents a sufficient increase in processor speed to ensure feasibility under algorithm \(\mathcal {A}\) for any task set that was feasible under algorithm \(\mathcal {B}\). To satisfy the necessary condition, a lower bound on the speedup factor can be determined which represents the increase in processor speed that is necessary to ensure feasibility under algorithm \(\mathcal {A}\) for a specific task set that was feasible under algorithm \(\mathcal {B}\). If the upper and lower bounds on the speedup factor match, then the speedup factor has been precisely determined and is said to be exact.
Finally, we note that the term speedupoptimal can be used to describe a schedulability test.
Definition 7
A schedulability test \(\mathcal {T}\) for algorithm \(\mathcal {A}\) is said to be a speedupoptimal schedulability test for the comparison between algorithm \(\mathcal {A}\) and algorithm \(\mathcal {B}\) if the exact speedup factor obtained when feasibility is determined for algorithm \(\mathcal {A}\) according to test \(\mathcal {T}\) is the same as the exact speedup factor obtained when an exact schedulability test for algorithm \(\mathcal {A}\) is used.
We note that sufficient schedulability tests can be speedupoptimal, even though they are not optimal (i.e. exact) in terms of schedulability. We return to this point in the conclusions.
3 Schedulability analysis
In this section, we recapitulate schedulability analysis for fixed priority and EDF scheduling under both preemptive and nonpreemptive paradigms.
3.1 Fixed priority preemptive scheduling
3.2 Fixed priority nonpreemptive scheduling
This necessary test is used later, in Sect. 5, since an upper bound on the speedup factor for FPP v. FPNP which is valid when a necessary test is used to determine FPNP schedulability is also valid when an exact test is used.
3.3 Preemptive earliest deadline first scheduling
4 Exact suboptimality and speedup factors
In this section, we compare the effectiveness of fixed priority nonpreemptive scheduling (FPNP) with that of preemptive scheduling; both FPP and EDFP. We determine the exact suboptimality of FPNP. Specifically, we derive the exact speedup factor S1 required to guarantee feasibility under FPNP of all EDFP feasible task sets. Further, we derive the exact speedup factor S2 required to guarantee feasibility under FPNP of all FPP feasible task sets. Surprisingly these two speedup factors are the same (S1 = S2). We also derive an exact speedup factor for the case of FPNP v. FPP, when tasks have constrained deadlines. This speedup factor is smaller than the one for the arbitrarydeadline case.
We obtain the exact speedup factors by deriving upper bounds via analysis and lower bounds from example task sets and then showing that they are the same. The example task set we use to provide a lower bound for FPNP v. EDFP also applies to EDFNP v. EDFP, hence we also obtain S3, the exact suboptimality of EDFNP, since our lower bound is the same as the upper bound recently published by Abugchem et al. (2015).
Lemma 1
Proof
We show that the speedup factor in the lemma is enough to ensure schedulability under FPNP according to the sufficient test given by (9) using DMPO, since that suffices to also prove schedulability with an exact test and optimal priority assignment.
Lemma 2
Proof
Follows directly from Lemma 1 and the fact that EDFP can schedule all task sets that are feasible under FPP scheduling (Dertouzos 1974). \(\square \)
Lemma 3
Proof

\(\tau _1\): \(C_1=k1\), \(D_1=k\), \(T_1=k\)

\(\tau _2\): \(C_2=k^2+1\), \(D_2=\infty \), \(T_2=\infty \)
Theorem 1
Proof
Follows from a consideration of the task set in Lemma 3. For the task set to be schedulable under EDFNP also requires that the total execution time of both tasks can be accommodated within the smallest deadline resulting in the same requirement on the speedup factor. Since the lower bound from Lemma 3 matches the upper bound given by Abugchem et al. (2015) the speedup factor is exact. \(\square \)
Lemma 4
Proof
Let \(\varGamma \) be a task set that is schedulable under FPP scheduling on a processor of unit speed using DMPO, which is optimal in the constrained deadline case. We will prove that \(\varGamma \) is schedulable on a processor of speed S under FPNP scheduling using the same priority ordering. We note that this ordering is not necessarily optimal for FPNP scheduling, but nevertheless suffices to prove feasibility.
Let \(W_{i}^P\) be the completion time of the first job of task \(\tau _i\) in the priority leveli busy period under FPP scheduling. Since all tasks are schedulable and have constrained deadlines, then \(W_{i}^P = R_i^P \le D_i\). We consider two cases.
Case 1: \(W_{i}^P \ge D_{min}\)
Theorem 2
Proof
Proof follows from the lower bound given by Lemma 3 and the upper bound given by Lemma 4 which have the same value. \(\square \)
Lemma 5
Proof

\(\tau _i\) with \(i=1,\ldots , k1\): \(C_i=1\), \(D_i=k+1\), \(T_i=k\)

\(\tau _k\): \(C_k=1\), \(D_k=k+1\), \(T_k=k+1\)

\(\tau _{k+1}\): \(C_{k+1}=k^2\), \(D_{k+1}=\infty \), \(T_{k+1}=\infty \)
Under FPNP on a processor of speed \(S \ge 1\) consider the operation of Audsleys OPA algorithm, which is optimal in this case (George et al. 1996). First, task \(\tau _{k+1}\) is assigned the lowest priority as it is trivially schedulable at that priority on a processor of unit speed or higher. There are then two cases to consider^{4}.
Case 1 \(\tau _k\) is assigned the next higher priority level above \(\tau _{k+1}\). In this case, task \(\tau _k\) is subject to blocking due to task \(\tau _{k+1}\) and interference (before it starts to execute) from tasks \(\tau _1\) to \(\tau _{k1}\). Considering the critical instant for task \(\tau _k\), there are two possible scenarios which could result in the task being schedulable. In the first scenario, the first jobs of all tasks except \(\tau _k\) must complete their execution strictly before the second jobs of tasks \(\tau _1\) to \(\tau _{k1}\) are released at time k. This allows task \(\tau _k\) to start executing before time k, thus avoiding interference from the second job of each higher priority task. For this to happen implies the following constraint: \(S > (k^2 + k 1)/k = k + (k1)/k\). Further, task \(\tau _{k}\) must also complete by time \(k+1\), which gives the weaker constraint \(S\ge (k^2 + k)/(k+1)=k\). The alternative scenario is that task \(\tau _k\) does not get to start before the second jobs of tasks \(\tau _{1}\) to \(\tau _{k1}\) are released at time k. In this scenario, for task \(\tau _k\) to be schedulable, the first job of task \(\tau _{k+1}\), the first and second jobs of tasks \(\tau _{1}\) to \(\tau _{k1}\), and the first job of task \(\tau _k\) must complete their execution by time \(k+1\), which leads to the constraint that \(S\ge (k^2+2k1)/(k+1)=k+(k1)/(k+1)\).
Case 2 \(\tau _{k1}\) is assigned the next higher priority level above \(\tau _{k+1}\) (since \(\tau _{1}\) to \(\tau _{k1}\) are identical this is effectively the only other option aside from Case 1 for this priority level). Considering the critical instant for task \(\tau _{k1}\), there are two possible scenarios which could result in the task being schedulable. In the first scenario, the first jobs of all tasks except \(\tau _{k1}\) must complete their execution strictly before the second jobs of tasks \(\tau _1\) to \(\tau _{k2}\) are released at time k. This allows task \(\tau _{k1}\) to start executing before time k, thus avoiding interference from the second job of each higher priority task. As in Case 1, this implies the following constraint: \(S > (k^2 + k 1)/k = k + (k1)/k\). In addition task \(\tau _{k1}\) must also complete by time \(k+1\), which again gives \(S\ge (k^2+k)/(k+1)=k\). The alternative scenario is that the first job of task \(\tau _{k1}\) does not get to start before the second jobs of tasks \(\tau _{1}\) to \(\tau _{k1}\) are released at time k. In this scenario, for task \(\tau _{k1}\) to be schedulable, then the first job of task \(\tau _{k+1}\), the first and second jobs of tasks \(\tau _{1}\) to \(\tau _{k2}\), and the first job of task \(\tau _{k1}\) must complete their execution by time \(k+1\), which leads to the constraint \(S\ge (k^2+2k2)/(k+1)=k+(k2)/(k+1)\).
Theorem 3
Proof
Proof follows from the lower bound given by Lemma 5 and the upper bound given by Lemma 2 which have the same value. \(\square \)
Theorem 4
5 Preemptive versus nonpreemptive fixed priority scheduling
Preemptive and nonpreemptive fixed priority scheduling are incomparable, i.e., there are task sets that FPP can schedule that FPNP cannot and vice versa, hence there are nontrivial speedup factors in both directions between these two scheduling algorithms. These speedup factors allow system designers to determine the increase in processor speed that may be necessary in the worstcase to maintain schedulability when making a choice to switch from using one of these scheduling algorithms to the other.
In this section, we derive upper and lower bounds on the processor speedup factor that guarantees feasibility under FPP for all constrained deadline task sets that are feasible under FPNP on a unit speed procesor, thus deriving exact speedup factor S4. In Sect. 5.1 we derive a lower bound on the speedup factor that guarantees FPP feasibility for constrained and arbitrary deadline task sets that are FPNP feasible. In Sect. 5.2 we derive an upper bound that is valid for arbitrarydeadline task sets. Finally in Sect. 5.3 we derive a tight upper bound that is valid for constraineddeadline task sets. This upper bound matches the lower bound from Sect. 5.1 and is thus exact in the case of constraineddeadline task sets, as noted in Sect. 5.4.
5.1 Lower bound on the speedup factor for FPP v. FPNP
Theorem 5
Proof

\(\tau _1\): \(C_1=2  \sqrt{2}\), \(D_1=1\), \(T_1=1\)

\(\tau _2\): \(C_2=\sqrt{2} 1\), \(D_2=\sqrt{2}\), \(T_2=\infty \)

\(\tau _3\): \(C_3=\sqrt{2} 1\), \(D_3=\sqrt{2}\), \(T_3=\infty \)
Next, consider the same task set scheduled on a processor of speed \(S = \sqrt{2}\) under FPP scheduling, again using DMPO which is optimal in this case. The scaled task execution times are now \(C^S_1=\sqrt{2}  1\), \(C^S_2=(2  \sqrt{2})/2\), and \(C^S_3=(2  \sqrt{2})/2\). The schedule is as illustrated in Fig. 3, again starting with task \(\tau _1\). In this case, the worstcase response time of task \(\tau _3\) is 1. Further, any increase in the execution times of the tasks (i.e. by using a smaller speedup factor) would result in task \(\tau _3\) missing its deadline, due to preemption by the second job of task \(\tau _1\) which is released at time \(t=1\). Hence the speedup factor required by this task set is \(S = \sqrt{2}\). \(\square \)
5.2 Upper bound on the speedup factor for FPP v. FPNP for arbitrarydeadline task sets
Theorem 6
Proof
Since EDFP dominates FPNP and Theorem 2 from (Davis et al. 2009a) states that an upper bound on the speedup factor required to guarantee FPP feasibility of any EDFP feasible task set is \(S = 2\) then such an increase in processor speed must also be sufficient to guarantee FPP feasibility of all FPNP feasible task sets. \(\square \)
5.3 Upper bound on the speedup factor for FPP v. FPNP for constraineddeadline task sets
We next derive an upper bound on the speedup factor required to guarantee feasibility under FPP for all constraineddeadline task sets that are feasible under FPNP. Note, the restriction to constraineddeadline task sets allows us to derive a tighter upper bound than that given in Theorem 6. (We note that any upper bound valid for constraineddeadline task sets also applies to implicitdeadline task sets since the former class includes the latter). The upper bound that we are interested in compares exact schedulability for FPNP assuming optimal priority assignment (OPA) with exact schedulability for FPP again assuming optimal priority assignment (DMPO in this case). Note, since DMPO is not optimal for FPNP the two priority assignments may be different.
We use a weaker condition to derive a sound upper bound on the speedup factor. We compare schedulability according to the necessary test for FPNP scheduling given by (11) assuming optimal priority assignment using Audsley‘s OPA algorithm against an exact test for FPP scheduling assuming the same priority ordering that OPA generates for FPNP scheduling. These relaxations can only increase the speedup factor required, and hence the bound we obtain is also a valid upper bound for the case we are ultimately interested in with exact tests and optimal priority assignment for both scheduling algorithms.
Without loss of generality, we base our proofs on the set Z of all constraineddeadline task sets where each task set \(V \in Z\) has parameters such that it is deemed schedulable using the necessary test for FPNP scheduling and the OPA algorithm for priority assignment, and scaling of the execution times of all tasks in V by any factor \(> 1\) (equivalent to a decrease in processor speed) would cause the task set to become unschedulable. Hence the critical scaling factor \(\alpha ^{FPNP}(V) = 1\) with respect to the necessary test. For ease of reference later, we refer to Z as containing the FPNP critical task sets. Further, also without loss of generality, we assume that the OPA algorithm checks tasks in the reverse of deadline monotonic order and therefore at each priority level from the lowest priority upwards, it assigns the schedulable task with the longest deadline.
 1.
We first derive a number of properties that hold for any task set that is speedup optimal for this problem. These properties are given in Theorem 7 and proved via Lemmas 6, 7, and 8. This eases the burden of proof of the upper bound, since we need only consider speedup optimal task sets with these properties in our subsequent derivation.
 2.
We then make a case distinction, splitting the proof of the upper bound speedup factor into two parts depending on the relative values of three factors A, B, and X. A represents the execution time of the constraining task. Note a constraining task is one that cannot have its execution time increased without a deadline being missed. B and X represent the total execution times of two different categories of interference from higher priority tasks. These categories are explained later. The values are normalised such that \(X + B = 1\). The two cases considered are \(A+X \le 1\) and \(A+X > 1\).
 3.
In the first case (\(A+X \le 1\)) Theorem 8 proves an upper bound on the speedup factor, using the results of Lemmas 9 and 10.
 4.
In the second case (\(A+X > 1\)), the proof is split into two parts. Theorem 9 derives an upper bound on the speedup factor subject to the restriction that there is no task that is part of X that is rereleased during the interval \([1,A+X)\). Theorem 10 covers the case where there is such a task, making use of Lemmas 11 and 12 which prove certain properties of the task set in this case.
 5.
Finally, Theorem 11 combines the results of Theorems 8, 9, and 10 giving an upper bound on the speedup factor that holds in all cases. Theorem 12 completes this section, showing that the speedup factor is exact for constraineddeadline task sets.
Theorem 7
 1.
When the execution times of all of the tasks in the task set are scaled such that it is just schedulable according to an exact test for FPP scheduling, the lowest priority task \(\tau _A\) is the only constraining task. (A constraining task is one that cannot have its execution time increased without missing its deadline).
 2.
Under FPNP scheduling, with the task set scaled such that it is just schedulable according to the necessary test, then the constraining task from FPP scheduling has its lower bound response time equal to its deadline.
 3.
The task \(\tau _L\) at priority level \(n 1\) has an execution time \(C_L > C_A\), where \(C_A\), is the execution time of the lowest priority task.
Lemma 6
For the comparison FPP v. FPNP (assuming that the necessary test and OPA algorithm are used for FPNP, and an exact test and the same priority ordering are used for FPP), let Z be the set of FPNP critical task sets \(V \in Z\). By definition, this set contains at least one task set that is speedupoptimal with respect to the class of task sets with constrained deadlines. Let Y be a subset of Z (i.e. \(Y \subseteq Z\)) such that every task set in Y has a single constraining task under FPP scheduling when scaled such that it is just schedulable according to an exact test, and that task has the lowest priority. The set Y contains at least one speedupoptimal task set.
Proof
We assume (for contradiction) that there is a task set \(S \in Z \setminus Y\) (note \(Z \setminus Y\) contains all of the task sets that are in Z but not in Y) that has an FPP scaling factor \(\alpha ^{FPP}(S)\) strictly smaller than that of any task set in Y. Let \(\tau _i\) be the highest priority constraining task in S. Since \(S \notin Y\) then \(\tau _i \ne \tau _n\). We create a new task set V from S by removing all tasks of lower priority than \(\tau _i\). Since under FPP scheduling, the response time of task \(\tau _i\) and all higher priority tasks is unaffected by the removal of the lower priority tasks, the FPP scaling factor remains the same \(\alpha ^{FPP}(V) = \alpha ^{FPP}(S)\). Further, since removing tasks cannot decrease, but may increase the FPNP scaling factor, it follows that the speedup factor required by task set V is at least as great as that required by task set S. This contradicts the assumption and so there must be at least one speedup optimal task set in Y. \(\square \)
Lemma 7
For the comparison FPP v. FPNP (assuming that the necessary test and OPA algorithm are used for FPNP, and an exact test and the same priority ordering are used for FPP), let Z be redefined as the set Y from Lemma 6, thus every task set in Z now has a single constraining task under FPP scheduling when scaled such that it is just schedulable according to an exact test, and that task has the lowest priority. Further, let Y be redefined as follows: \(Y \subseteq Z\) such that every task set in Y is such that the constraining task under FPP scheduling has its lower bound response time equal to its deadline when scheduled according to FPNP scheduling. The set Y contains at least one speedupoptimal task set.
Proof
We assume (for contradiction) that there is a task set \(S \in Z \setminus Y\) (note \(Z \setminus Y\) contains all of the task sets that are in Z but not in Y) that has an FPP scaling factor \(\alpha ^{FPP}(S)\) strictly smaller than that of any task set in Y. We create a new task set V from S by reducing the deadline of the constraining task for FPP scheduling to its lower bound response time determined under FPNP scheduling (with \(\alpha ^{FPNP}(S) =1\)). Since this has no effect on the scaling factor under FPNP, \(\alpha ^{FPNP}(V) = \alpha ^{FPNP}(S)\) and decreases the scaling factor for FPP i.e. \(\alpha ^{FPP}(V) < \alpha ^{FPP}(S)\), it follows that the speedup factor required by task set V is larger than that required by S. This contradicts the assumption and so there must be at least one speedup optimal task set in Y. \(\square \)
Lemma 8
For the comparison FPP v. FPNP (assuming that the necessary test and OPA algorithm are used for FPNP, and an exact test and the same priority ordering are used for FPP), let Z be redefined as the set Y defined by Lemma 7, thus every task set in Z now has a single constraining task under FPP scheduling when scaled such that it is just schedulable according to an exact test, and that task has the lowest priority. Further, the constraining task has a deadline equal to its lower bound response time under FPNP scheduling. Let Y be redefined as follows: \(Y \subseteq Z\) such that every task set in Y has a task \(\tau _L\) at priority level \(n1\) that has an execution time \(C_L \ge C_A\), where \(C_A\) is the execution time of the lowest priority task. The set Y contains at least one speedupoptimal task set.
Proof
In the following, when considering the processor speedup factor needed to ensure schedulability under FPP we note that it is sufficient to simply ensure schedulability of the constraining task, since by definition, that task is the one that requires the largest scaling factor in order to be schedulable.
In the following proofs, we consider an abstract representation of the schedule for a speedup optimal task set under FPNP and FPP scaled such that it is just schedulable in each case, see Fig. 4. This representation reflects the necessary test for FPNP scheduling given by (11), it is not a schedule as such, but rather it shows the total amount of execution from a number of sources. Execution of the constraining task \(\tau _A\) is represented by A. Since we are interested in an upper bound on the speedup factor we may assume that task \(\tau _A\) which constrains the scaling factor for FPP also constrains the scaling factor for FPNP (if any other task constrained the scaling factor in the FPNP case, then that could only reduce the speedup factor needed). In a FPNP schedule where task \(\tau _A\) takes its lower bound response time [according to the necessary test in (11)] it is the last task to execute and starts at \(W^{NP}_A\). Recall from Theorem 7 that all other tasks have higher priorities than the constraining task \(\tau _A\), and the priority order considered is the same for both FPNP and FPP. We divide execution of the higher priority tasks into two components. Execution of those higher priority tasks which are not released again between the start time \(W^{NP}_A\) of task \(\tau _A\) in the FPNP schedule and its deadline at \(D_A\) are represented by B. Execution of those higher priority tasks which are released again in this interval are represented by X. The latter tasks may cause additional interference under preemptive scheduling.
To ease understanding, we now illustrate this representation using a simple example. Consider a task set comprising three tasks with the following parameters (C, D, T): \(\tau _1\) \((3,7,\infty )\), \(\tau _2\) \((4,7+\epsilon ,7+\epsilon )\), \(\tau _3\) (3, 10, 10). Task \(\tau _3\) has the lowest priority and is the constraining task; its execution is represented by A. Task \(\tau _2\) may be released again between the start time (i.e. 7) and the deadline (i.e. 10) of \(\tau _3\) in a FPNP schedule which starts with synchronous release of all tasks, and so its execution is represented by X. Finally, task \(\tau _2\) may not be rereleased in this interval and its execution is represented by B. This example corresponds to the diagram in Fig. 4a. Note in the proofs that follow X and B may comprise execution from multiple tasks, and thus Fig. 4 is not intended to show a schedule as such, but rather to show in an abstract way the total amount of execution A, B, and X from the different sources.
We can identify two scenarios in which a task set can be scaled under FPP so that it is schedulable. Scenario (i) is illustrated in Fig. 4b. Here the task set is scaled such that all of the execution that completed by \(D_A\) under FPNP scheduling completes by the start time of task \(\tau _A\) at \(W^{NP}_A\) in that schedule. Scenario (ii) is illustrated by Fig. 4c. Here the task set is scaled such that all of the execution released by \(D_A\) completes by \(D_A\). Since it suffices to show that the task set is schedulable in either scenario, we may compute the speedup factors required for each and then take the minimum of them as a valid bound.
In the following, we make a case distinction based on the value of \(A + X\). Theorem 8, supported by Lemmas 9 and 10, covers the case where \(A + X \le 1\). Note that Lemma 9 does not depend on the value of \(A + X\). Theorems 9 and 10, supported by Lemmas 11 and 12, cover the case where \(A + X > 1\).
Lemma 9
Proof
We note from Theorem 7 that the constraining task \(\tau _A\) for FPP scheduling is at the lowest priority, and since the priority order used is the same it is also at the lowest priority under FPNP scheduling. We now derive the speedup factor necessary for schedulability under FPP in scenario (i) described above, as illustrated in Fig. 4b. Consider the interval of length \(W^{NP}_A = 1\). We observe that the amount of interference considered in any interval of length t (not including blocking) is no greater in the preemptive case than in the nonpreemptive case. This can be seen by comparing the summation terms in (4) and (11). Hence provided we can accommodate \(X+B+A=1+A\) in a time interval of length \(X+B=1\) (as illustrated in Fig. 4b) then task \(\tau _A\) must be schedulable under FPP. This leads to a speedup factor of \(S_1 = \frac{1+A}{1}\). \(\square \)
Lemma 10
Proof
We note from Lemma 6 that the constraining task \(\tau _A\) for FPP scheduling is at the lowest priority, and since the priority order used is the same it is also at the lowest priority under FPNP scheduling. We now derive the speedup factors necessary for schedulability under FPP in scenario (ii) described above, as illustrated in Fig. 4c. In this case, we are interested in a speedup factor that is sufficient such that all of the execution released in an interval of length \(D_A = 1 +A\) can be completed in that interval, thus ensuring schedulability for task \(\tau _A\) under FPP. We now make use of the constraint that \(A+X \le 1\). This implies that \(A \le 1\) and hence that the interval from the start of the busy period to \(W^{NP}_A\) is no shorter than the remainder of the interval from \(W^{NP}_A\) to \(D_A\). Since X is the amount of interference released in the interval \([0,W^{NP}_A)\) starting with synchronous release of all the tasks, then the amount of interference released in the interval \([0,D_A)\) cannot exceed 2X. Therefore a speedup factor of \(S_2 = \frac{1+A+X}{1+A}\) is sufficient to ensure schedulability of task \(\tau _A\) under FPP (as illustrated by Fig. 4c). \(\square \)
Theorem 8
Subject to the constraint that \(A + X \le 1\), an upper bound on the speedup factor required such that FPP scheduling, with the same priority ordering as used by FPNP, can schedule any constraineddeadline sporadic task set deemed schedulable according to the necessary test for FPNP is given by \(S=\sqrt{2}\).
Proof
We now consider the case where \(A+X>1\). Theorems 9 and 10 (supported by Lemmas 11 and 12) deal with subcases where (i) there is no task that is part of X rereleased during the interval \([1,A+X)\), and (ii) there is such a task.
Theorem 9
Subject to the constraint that \(A+X>1\), and the restriction that there is no task that is part of X rereleased during the interval \([1,A+X)\), an upper bound on the speedup factor such that FPP scheduling, with the same priority ordering as used by FPNP, can schedule any constraineddeadline sporadic task set deemed schedulable according to the necessary test for FPNP is \(S=\sqrt{2}\).
Proof
Next, in Lemmas 11 and 12 we derive properties which are used in the proof of Theorem 10.
Lemma 11
When schedulability is determined using the necessary test for FPNP combined with the OPA algorithm, the two tasks assigned the lowest priorities cannot have parameters such that both \(D_L > D_A\) and \(C_L > C_A\) where task \(\tau _A\) is at the lowest priority (n) and task \(\tau _L\) is at the priority level immediately above it \((n1)\)
Proof
Lemma 12
In a speedup optimal task set scaled such that it is just schedulable according to the necessary test for FPNP (with optimal priority assignment) that has \(A+X>1\), there cannot be an interfering task \(\tau _H\) (that is part of X) that is rereleased during the interval \([1,A+X)\), unless there is a task \(\tau _L\) with the lowest priority with the exception of the constraining task \(\tau _A\), which is also part of X and has an execution time \(C_L \ge A\).
Proof
From Theorem 7, we know that task \(\tau _L\) must exist and have an execution time \(C_L \ge A\). Further, since \(C_L \ge A\) then from Lemma 11 we know that \(D_L \le D_A\). Since task \(\tau _L\) is either part of B or part of X, we prove the Lemma by showing that \(\tau _L\) is necessarily unschedulable if it is part of B. The unschedulability of \(\tau _L\) in this case contradicts the assumption in the Lemma that the task set is a schedulable speedup optimal task set under FPNP.
We assume (for contradiction) that \(\tau _L\) is part of B and the interfering task \(\tau _H\) (that is part of X) is rereleased during the interval \([1,A+X)\). Considering a FPNP schedule starting with blocking of duration A from task \(\tau _A\), by time \(A+X \ge 1\), interference of at least X has been released along with execution of duration B (that by definition does not repeat in the interval \([1,A+1)\)). The lowest priority of all of these tasks in B and X is \(\tau _L\), which is part of B, hence \(\tau _L\) has not started to execute by time \(A+X\). At time \(t < A+X\), a further release of task \(\tau _H\) occurs. Thus the lower bound response time of \(\tau _L\) according to the necessary test is at least \(A+X+B+C_H\) this is greater than the deadline of \(\tau _A\) (recall that \(D_A=A+X+B\)). Since \(D_L \le D_A\) task \(\tau _L\) is therefore unschedulable. \(\square \)
Theorem 10
Subject to the constraint that \(A+X>1\), if there is a task \(\tau _H\) that is part of X rereleased during the interval \([1,A+X)\), an upper bound on the speedup factor such that FPP scheduling, with the same priority ordering as used by FPNP, can schedule any constraineddeadline sporadic task set deemed schedulable according to the necessary test for FPNP, is \(S= \sqrt{2}\).
Proof
Lemma 12 showed that in any speedup optimal task set with \(A+X>1\) and a task \(\tau _H\) that is part of X rereleased during the interval \([1,A+X)\), there must be a task \(\tau _L\) which has the lowest priority with the exception of \(\tau _A\) that has \(C_L \ge A\) and is also part of X. We now show that this constraint is sufficient to restrict the speedup factor required for schedulability under FPP to at most \(S=\sqrt{2}\).
Let \(\delta \) be the amount of interference from other tasks (not including \(\tau _A\) or \(\tau _L\)) released in an interval of length \(A +\delta \) (i.e. to the start of task \(\tau _L\) when initially subject to blocking of duration A). The lower bound response time of \(\tau _L\) is therefore \(A +\delta +C_L\). (Note since all tasks have constrained deadlines, this is also the minimum possible period for task \(\tau _L\)). In the preemptive case, we will now speed up the processor so that all of the execution released in an interval of length \(A +\delta +C_L\) completes in that interval, thus ensuring the schedulability of task \(\tau _A\). (Since this response time is sufficient for \(\tau _L\) to meet its deadline, it must also be sufficient for \(\tau _A\) as from Lemma 11, we know that \(D_L \le D_A\)). Note that neither \(\tau _A\) nor \(\tau _L\) are rereleased in this interval, thus we are interested only in interference from other tasks.
We note that \(S_1\) given by Lemma 9 is valid for all values of \(A+X\), hence the task set is schedulable under FPP with a speedup factor of either \(S_1\) or \(S_5\), thus we are interested in finding the maximum value of \(min(S_1, S_5)\). In order for a speedup factor greater than \(S=\sqrt{2}\) to be required, we would need a value of \(A > \sqrt{2}1\), otherwise the speedup factor required is restricted by \(S_1\) to be \(\le \sqrt{2}\).
Since \(C_L \ge A\) and \(C_L\) is part of X, then it must be the case that \(\delta \) which is the higher priority interference released in an interval of length \(A+\delta \) is no greater than the higher priority interference released within the interval of length \(X+B=1\) in the worstcase schedule for A (see Fig. 4a), hence \(C_L + \delta \le 1\).
Examining (39), we observe that for any fixed values of \(C_L\) and \(\delta \), \(S_5\) is maximised by employing the smallest possible value of A. Given that the speedup factor required (\(=min(S_1,S_5)\)) is restricted by \(S_1 \le \sqrt{2}\) if \(A \le \sqrt{2}1\) then the speedup factor could only be greater than \(\sqrt{2}\) if the value of \(S_5\) is greater than \(\sqrt{2}\) when \(A=\sqrt{2}1\). We therefore substitute that value for A in (39) and seek the largest value of \(S_5\) by selecting appropriate values of \(C_L\) and \(\delta \). Since \(C_L + \delta \le 1\) we observe that the largest possible value of the ceiling function in (39) is given by \(\lceil (A+1)/A \rceil \). Further, since \(A = \sqrt{2}1\), the maximum value for the ceiling function is 4, and as \(C_L>A>0\), the minimum value of the ceiling function is 2. We now consider the three possible values (4, 3, and 2) for the ceiling function and maximise the value of \(S_5\) via choosing appropriate values of \(C_L\) and \(\delta \) in each case.
Theorem 11
Proof
Follows from Theorems 8, 9, and 10, and the fact that the bound so obtained using a necessary test for FPNP scheduling assuming optimal priority assignment (OPA) compared to an exact test for FPP assuming exactly the same priority ordering that FPNP uses, is also an upper bound for the general case described in the theorem. This is the case since use of a (weaker) exact rather than a necessary test for FPNP cannot increase the speedup factor required. Similarly using a (stronger) optimal priority assignment for FPP scheduling cannot increase the speedup factor required w.r.t. using the same priority ordering as chosen for FPNP scheduling. \(\square \)
5.4 Exact speedup factor for FPP v. FPNP for constraineddeadline task sets
We now put together the results of Sects. 5.1 and 5.3 to give the exact speedup factor for FPP v. FPNP.
Theorem 12
6 Summary and conclusions
The main contribution of this paper is the derivation of resource augmentation bounds for preemptive and nonpreemptive scheduling algorithms on a uniprocessor. Our metric for measuring the relative effectiveness of these scheduling policies is a resource augmentation factor known as the processor speedup factor. The processor speedup factor is defined as the minimum amount by which the processor needs to be speeded up to guarantee schedulability under one algorithm (e.g. FPNP) for any task set that is schedulable under another algorithm (e.g. EDFP).
 S1
 Exact suboptimality of FPNP for tasks with arbitrary deadlines:For task sets with implicit or constraineddeadlines:$$\begin{aligned} S = 2 + \frac{C_{max}}{D_{min}} \end{aligned}$$$$\begin{aligned} \text {Lower Bound } S = 1 + \frac{C_{max}}{D_{min}} \text { Upper Bound } S = 2 + \frac{C_{max}}{D_{min}} \end{aligned}$$
 S2
 Exact speedup factor required for FPNP feasibility of any arbitrary deadline task set that is FPP feasible:For task sets with implicit or constrained deadlines:$$\begin{aligned} S = 2 + \frac{C_{max}}{D_{min}} \end{aligned}$$$$\begin{aligned} S = 1 + \frac{C_{max}}{D_{min}} \end{aligned}$$
 S3
 Exact suboptimality of EDFNP for implicit, constrained or arbitrary deadline task sets:$$\begin{aligned} S = 1 + \frac{C_{max}}{D_{min}} \end{aligned}$$
 S4
 Exact speedup factor required for FPP feasibility of any constrained deadline task set that is FPNP feasible.$$\begin{aligned} S = \sqrt{2} \end{aligned}$$
Tables 1, 2, and 3 summarise the speedup factor results for uniprocessor fixed priority and EDF scheduling algorithms. References next to the speedup factor values refer to prior results, while those without a reference were derived in this paper. Where an exact speedup factor has been derived, then only one value is given (i.e. the upper and lower bounds are equal). Further, where the same value applies to different classes of task set (e.g. with implicit, constrained, or arbitrary deadlines), then again only a single result is shown, with the cell in the table enlarged to cover the different classes.
Speedup factors for FPP v. EDFP and FPNP v. EDFNP

Speedup factors for FPNP v. EDFP and EDFNP v. EDFP

Speedup factors for FPNP v. FPP and FPP v. FPNP

While the speedup factor results derived in this paper are mainly of interest in providing a theoretical comparison focusing on the worstcase behaviour of the different scheduling algorithms, these results also help by providing practical guidance to system designers. For example, the majority of realtime operating systems support fixed priority scheduling, with those mandated for automotive systems by the OSEK (OSEK/VDX 2007) and AUTOSAR (AUTOSAR 2007) standards supporting both FPP and FPNP scheduling. Here, it is interesting to consider the comparison between FPP and FPNP; even though the two scheduling policies are incomparable. The exact speedup factor required for FPNP feasibility of any constrained deadline task set that is FPP feasible is \(S = 1 + \frac{C_{max}}{D_{min}}\) (see Theorem 2). Thus if we have a system where the longest execution time of any task is substantially less than the shortest deadline (\(C_{max} \ll D_{min}\)), we can quantify the small processing speed penalty for using nonpreemptive scheduling. This can then be weighed against the additional overheads (e.g. preemption costs, cache related preemption delays, support for mutually exclusive resource accesses etc.) incurred in using preemptive scheduling. When the processing speed penalty is small, other factors such as the reduced complexity involved in accurately modelling and testing a nonpreemptive system, may also favour FPNP scheduling. When \(C_{max} \gg D_{min}\) then it is clear that the penalty for using fully nonpreemptive scheduling is very high (the long task problem (Short 2010)). In such cases methods that support limited preemption, effectively breaking long tasks into a set of nonpreemptive regions may be preferable. A further avenue for the extension of this work is to systems that support limited preemption (Buttazzo et al. 2013), in particular including final nonpreemptive regions, since that paradigm dominates both FPP and FPNP scheduling (Davis and Bertogna 2012).
We note that it has recently been shown (von der Bruggen et al. 2016) that the results comparing FPP v. EDFP, and FPNP v. EDFNP given in Table 1, which assume optimal priority assignment and exact schedulability tests, continue to hold when Deadline Monotonic priority assignment and simple, sufficient, lineartime schedulability tests are employed for fixed priority scheduling. Thus in these cases, in terms of the speedupfactors required, there is no penalty in using Deadline Monotonic priority assignment^{5} and simple lineartime schedulability tests. Although sufficient in terms of schedulability, these tests are speedupoptimal (see Definition 7) for the comparisons FPP v. EDFP, and FPNP v. EDFNP. The results in this paper show that in the arbitrary deadline case, the speedup factors for FPNP v. EDFNP, and FPNP v. FPP also hold for Deadline Monotonic priority assignment and simple lineartime schedulability tests.
Finally, we caution that it is important to understand that speedup factors are indicative only of the worstcase performance of one algorithm relative to another. We refer the interested reader to recent work (Chen et al. 2017) on the pitfalls of using speedup factors and other resource augmentation bounds for a full discussion of the pros and cons of using this metric.
Footnotes
 1.
Task sets that are schedulable under FPP but not under FPNP are easily constructed, an example of a task set that is schedulable under FPNP but not under FPP is given in Sect. 5.1.
 2.
Without loss of generality, we assume that \(\varDelta \) is the granularity of the processor clock and that \(\varDelta \ll C_k\) for every task \(\tau _k\) even when we increase the processor speed.
 3.
For ease of presentation, and since it does not affect the result, we omit the small reduction in blocking due to the time granularity \(\varDelta \ll 1\).
 4.
Again, for ease of presentation, and since it does not affect the result, we omit the small reduction in blocking due to the time granularity \(\varDelta \ll 1\).
 5.
Recall that Deadline Monotonic priority ordering is not optimal for FPNP, nor for FPP in the arbitrary deadline case.
Notes
Acknowledgements
This work was funded in part by the EPSRC projects MCC (EP/K011626/1) and MCCps (EP/P003664/1), and the INRIA International Chair program. EPSRC Research Data Management: No new primary data was created during this study. This paper solves an open problem presented at RTSOPS (Davis et al. 2015b) and at the Dagstuhl Seminar on Scheduling 16081.
References
 Abugchem F, Short M, Xu D (2015) A note on the suboptimality of nonpreemptive realtime scheduling. IEEE Embed Syst Lett 7(3):69–72. https://doi.org/10.1109/LES.2015.2426657 CrossRefGoogle Scholar
 Altmeyer S, Davis RI, Maiza C (2011) Cache related preemption delay aware response time analysis for fixed priority preemptive systems. In: Realtime systems symposium (RTSS), pp 261–271. https://doi.org/10.1109/RTSS.2011.31
 Altmeyer S, Davis RI, Maiza C (2012) Improved cache related preemption delay aware response time analysis for fixed priority preemptive systems. RealTime Syst 48(5):499–526. https://doi.org/10.1007/s1124101291522 CrossRefzbMATHGoogle Scholar
 Altmeyer S, Douma R, Lunniss W, Davis RI (2014) Evaluation of cache partitioning for hard realtime systems. In: Proceedings Euromicro conference on realtime systems (ECRTS), pp 15–26. https://doi.org/10.1109/ECRTS.2014.11
 Altmeyer S, Douma R, Lunniss W, Davis RI (2016) On the effectiveness of cache partitioning in hard realtime systems. RealTime Syst pp 1–46. https://doi.org/10.1007/s1124101592468
 Audsley N (1991) Optimal priority assignment and feasibility of static priority tasks with arbitrary start times. Dept Computer Science, University of York, Technical Report YCS, p 164Google Scholar
 Audsley NC (2001) On priority asignment in fixed priority scheduling. Inf Process Lett 79(1):39–44. https://doi.org/10.1016/S00200190(00)001654 CrossRefzbMATHGoogle Scholar
 Audsley N, Burns A, Richardson M, Tindell K, Wellings AJ (1993) Applying new scheduling theory to static priority preemptive scheduling. Softw Eng J 8(5):284–292CrossRefGoogle Scholar
 AUTOSAR (2007) Autosar specification of operating system, v4.10. Tech. rep. http://www.autosar.org/
 Baker TP (1991) Stackbased scheduling for realtime processes. RealTime Syst 3(1):67–99. https://doi.org/10.1007/BF00365393 MathSciNetCrossRefGoogle Scholar
 Baruah SK, Mok AK, Rosier LE (1990) Preemptively scheduling hardrealtime sporadic tasks on one processor. In: Proceedings realtime systems symposium (RTSS), pp 182–190. https://doi.org/10.1109/REAL.1990.128746
 Bastoni A, Brandenburg BB, Anderson JH (2010) Cacherelated preemption and migration delays: Empirical approximation and impact on schedulability. In: Proceedings operating systems platforms for embedded realtime applications (OSPERT)Google Scholar
 Bini E, Buttazzo GC (2005) Measuring the performance of schedulability tests. RealTime Syst 30(1–2):129–154. https://doi.org/10.1007/s1124100505079 CrossRefzbMATHGoogle Scholar
 Bril RJ, Lukkien JJ, Verhaegh WF (2009) Worstcase response time analysis of realtime tasks under fixedpriority scheduling with deferred preemption. RealTime Syst 42(1–3):63–119. https://doi.org/10.1007/s112410099071z CrossRefzbMATHGoogle Scholar
 Bui BD, Caccamo M, Sha L, Martinez J (2008) Impact of cache partitioning on multitasking real time embedded systems. In: proceedings RealTime Computing Systems and Applications (RTCSA), pp 101–110, https://doi.org/10.1109/RTCSA.2008.42
 Burns A, Gutierrez M, Aldea Rivas M, Gonzalez Harbour M (2015) A deadlinefloor inheritance protocol for edf scheduled embedded realtime systems with resource sharing. IEEE Trans Comput 64(5):1241–1253. https://doi.org/10.1109/TC.2014.2322619 MathSciNetCrossRefzbMATHGoogle Scholar
 Buttazzo GC, Bertogna M, Yao G (2013) Limited preemptive scheduling for realtime systems. A survey. IEEE Trans Ind Inform 9(1):3–15. https://doi.org/10.1109/TII.2012.2188805 CrossRefGoogle Scholar
 Chen JJ, von der Brggen G, Huang WH, Davis RI (2017) On the pitfalls of resource augmentation factors and utilization bounds in realtime scheduling. In: Proceedings Euromicro conference on realtime systems (ECRTS)Google Scholar
 Davis RI (2017) On the evaluation of schedulability tests for realtime scheduling algorithms. In: Proceedings international workshop on analysis tools and methodologies for embedded and realtime systems (WATERS)Google Scholar
 Davis RI, Bertogna M (2012) Optimal fixed priority scheduling with deferred preemption. In: Proceedings realtime systems symposium (RTSS), pp 39–50, https://doi.org/10.1109/RTSS.2012.57
 Davis RI, Burns A, Bril RJ, Lukkien JJ (2007) Controller area network (can) schedulability analysis: refuted, revisited and revised. RealTime Syst 35(3):239–272. https://doi.org/10.1007/s1124100790127 CrossRefGoogle Scholar
 Davis RI, Rothvoss T, Baruah SK, Burns A (2009a) Exact quantification of the suboptimality of uniprocessor fixed priority preemptive scheduling. RealTime Syst 43(3):211–258. https://doi.org/10.1007/s1124100990794 CrossRefzbMATHGoogle Scholar
 Davis RI, Rothvoss T, Baruah SK, Burns A (2009b) Quantifying the suboptimality of uniprocessor fixed priority preemptive scheduling for sporadic tasksets with arbitrary deadlines. In: Proceedings realtime and network systems (RTNS), pp 23–31Google Scholar
 Davis RI, George L, Courbin P (2010) Quantifying the suboptimality of uniprocessor fixed priority nonpreemptive scheduling. In: Proceedings realtime and network systems (RTNS), pp 1–10Google Scholar
 Davis RI, Burns A, Baruah S, Rothvoss T, George L, Gettings O (2015a) Exact comparison of fixed priority and edf scheduling based on speedup factors for both preemptive and nonpreemptive paradigms. RealTime Syst 51(5):566–601. https://doi.org/10.1007/s1124101592330 CrossRefzbMATHGoogle Scholar
 Davis RI, Gettings O, Thekkilakattil A, Dobrin R, Punnekkat S (2015b) What is the exact speedup factor for fixed priority preemptive versus fixed priority nonpreemptive scheduling? In: Proceedings realtime scheduling open problems seminar (RTSOPS), pp 23–24Google Scholar
 Davis RI, Thekkilakattil A, Gettings O, Dobrin R, Punnekkat S (2015c) Quantifying the exact suboptimality of nonpreemptive scheduling. In: Proceedings realtime systems symposium (RTSS), pp 96–106. https://doi.org/10.1109/RTSS.2015.17
 Davis RI, CucuGrosjean L, Bertogna M, Burns A (2016) A review of priority assignment in realtime systems. J Syst Archit 65:64–82. https://doi.org/10.1016/j.sysarc.2016.04.002, http://www.sciencedirect.com/science/article/pii/S1383762116300200
 Dertouzos ML (1974) Control robotics: the procedural control of physical processes. In: Proceedings IFIP congress, pp 807–813Google Scholar
 George L, Rivierre N, Spuri M (1996) Preemptive and nonpreemptive realtime uniprocessor scheduling. Research report, INRIAGoogle Scholar
 Jeffay K, Stanat DF, Martel CU (1991) On nonpreemptive scheduling of period and sporadic tasks. In: Proceedings realtime systems symposium (RTSS), pp 129–139. https://doi.org/10.1109/REAL.1991.160366
 Joseph M, Pandya P (1986) Finding response times in a realtime system. Comput J 29(5):390–395. https://doi.org/10.1093/comjnl/29.5.390, http://comjnl.oxfordjournals.org/content/29/5/390.abstract, http://comjnl.oxfordjournals.org/content/29/5/390.full.pdf+html
 Kalyanasundaram B, Pruhs K (2000) Speed is as powerful as clairvoyance. J ACM 47(4):617–643. https://doi.org/10.1145/347476.347479 MathSciNetCrossRefzbMATHGoogle Scholar
 Lehoczky JP (1990) Fixed priority scheduling of periodic task sets with arbitrary deadlines. In: Proceedings realtime systems symposium (RTSS), pp 201–209. https://doi.org/10.1109/REAL.1990.128748
 Lehoczky J, Sha L, Ding Y (1989) The rate monotonic scheduling algorithm: exact characterization and average case behavior. In: Proceedings real time systems symposium (RTSS), pp 166–171. https://doi.org/10.1109/REAL.1989.63567
 Leung JYT, Whitehead J (1982) On the complexity of fixedpriority scheduling of periodic, realtime tasks. Perform Eval 2(4):237–250. https://doi.org/10.1016/01665316(82)900244, http://www.sciencedirect.com/science/article/pii/0166531682900244
 Liu CL, Layland JW (1973) Scheduling algorithms for multiprogramming in a hardrealtime environment. J ACM 20(1):46–61. https://doi.org/10.1145/321738.321743 MathSciNetCrossRefzbMATHGoogle Scholar
 Lunniss W, Davis RI, Maiza C, Altmeyer S (2013) Integrating cache related preemption delay analysis into edf scheduling. In: Proceedings realtime and embedded technology and applications symposium (RTAS), pp 75–84. https://doi.org/10.1109/RTAS.2013.6531081
 OSEK/VDX (2007) OSEK/VDX operating system specification, version 2.2.3. Tech. rep. http://www.irisa.fr/alf/downloads/puaut/TPNXT/images/os223.pdf
 Ripoll I, Crespo A, Mok AK (1996) Improvement in feasibility testing for realtime tasks. RealTime Syst 11(1):19–39. https://doi.org/10.1007/BF00365519 CrossRefGoogle Scholar
 Short M (2010) The case for nonpreemptive, deadlinedriven scheduling in realtime embedded systems. In: Proceedings of the world congress on engineering (WCE), pp 399–404Google Scholar
 Spuri M (1996) Analysis of deadline scheduled realtime systems. INRIA Research Report RR2772 .https://hal.inria.fr/inria00073920/document
 Thekkilakattil A, Dobrin R, Punnekkat S (2013) Quantifying the suboptimality of nonpreemptive realtime scheduling. In: Proceedings Euromicro conference on realtime systems (ECRTS), pp 113–122. https://doi.org/10.1109/ECRTS.2013.22
 Thekkilakattil A, Baruah S, Dobrin R, Punnekkat S (2014) The global limited preemptive earliest deadline first feasibility of sporadic realtime tasks. In: Proceedings Euromicro conference on realtime systems (ECRTS), pp 301–310. https://doi.org/10.1109/ECRTS.2014.21
 Thekkilakattil A, Dobrin R, Punnekkat S (2015) The limitedpreemptive feasibility of realtime tasks on uniprocessors. RealTime Syst 51(3):247–273. https://doi.org/10.1007/s1124101592223 CrossRefzbMATHGoogle Scholar
 Tindell K, Burns A, Wellings AJ (1994) An extendible approach for analyzing fixed priority hard realtime tasks. RealTime Syst 6(2):133–151. https://doi.org/10.1007/BF01088593 CrossRefGoogle Scholar
 von der Bruggen G, Chen JJ, Huang WH (2015) Schedulability and optimization analysis for nonpreemptive static priority scheduling based on task utilisation and blocking factors. In: Proceedings Euromicro conference on realtime systems (ECRTS), pp 90–101Google Scholar
 von der Bruggen G, Chen JJ, Davis RI, Huang WH (2016) Exact speedup factors for lineartime schedulability tests for fixedpriority preemptive and nonpreemptive scheduling. Inf Process Lett. https://doi.org/10.1016/j.ipl.2016.08.001, http://www.sciencedirect.com/science/article/pii/S0020019016301090
Copyright information
Open AccessThis article is distributed under the terms of the Creative Commons Attribution 4.0 International License (http://creativecommons.org/licenses/by/4.0/), which permits unrestricted use, distribution, and reproduction in any medium, provided you give appropriate credit to the original author(s) and the source, provide a link to the Creative Commons license, and indicate if changes were made.