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.
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).
Comparing the preemptive and nonpreemptive paradigms, EDFP dominates EDFNP; however, the same is not true with fixed priorities, FPP does not dominate FPNP. Instead, they are incomparable. In other words, task sets exist that are feasible under FPNP that are not feasible under FPP and viceversa^{Footnote 1}. This lack of any dominance relationship means that when fixed priorities are used, some systems are easier to schedule preemptively, while others are easier to schedule nonpreemptively. (Optimality for fixed priority scheduling requires limited preemption with final nonpreemptive regions (Davis and Bertogna 2012); consideration of that more complex model is however beyond the scope of this paper). Figure 1 shows the dominance relationships between preemptive and nonpreemptive fixed priority and EDF scheduling algorithms.
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.
The main contributions of this paper are in determining for uniprocessor systems:
 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.
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.
System model
In this section we describe the system model, terminology, and notation used in the rest of the paper.
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\).
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.
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.
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.
Audsleys Optimal Priority Assignment (OPA) algorithm (Audsley 1991, 2001) (reproduced in Algorithm 1) is an optimal priority assignment algorithm for arbitrarydeadline sporadic task sets in both the preemptive and nonpreemptive case.
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
Let \(\varPsi \) be some arbitrary task set, now assume that \(\alpha ^\mathcal {A}(\varPsi )\) is the critical scaling factor, that is the maximum factor by which the execution times of all of the tasks in \(\varPsi \) can be scaled, such that the task set is schedulable under algorithm \(\mathcal {A}\) on a processor of unit speed. Similarly, \(\alpha ^\mathcal {B}(\varPsi )\) for algorithm \(\mathcal {B}\). The exact speedup factor S for algorithm \(\mathcal {A}\) compared to algorithm \(\mathcal {B}\) is given by:
where \(\varPsi \) ranges over all task sets.
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.
Schedulability analysis
In this section, we recapitulate schedulability analysis for fixed priority and EDF scheduling under both preemptive and nonpreemptive paradigms.
Fixed priority preemptive scheduling
The schedulability of a set of arbitrarydeadline sporadic tasks under FPP can be determined using response time analysis (Tindell et al. 1994; Lehoczky 1990). Response time analysis involves calculating the worstcase response time \(R^P_i\) of each task \(\tau _i\) and comparing it to its deadline \(D_i\). To determine schedulability, the analysis must check each job of task \(\tau _i\) in the longest priority leveli busy period. This busy period starts with a critical instant corresponding to the synchronous arrival of a job of task \(\tau _i\) and jobs of all higher priority tasks. Jobs of these tasks are then rereleased as soon as possible. The length of the priority leveli busy period is given by the solution to the following recurrence relation:
The number of jobs of task \(\tau _i\) in the busy period is given by \(Q_i^P = \lceil \frac{A_i^P}{T_i} \rceil \). The completion time \(W^P_i(q)\) of job q of task \(\tau _i\) relative to the start of the busy period is given by the following recurrence relation:
Iteration starts with \(W^P_i(q) = (q+1) C_i\) and ends either on convergence or when \(W^P_i(q)  qT_i > D_i\) in which case the job and therefore the task is unschedulable. Assuming that all \(Q_i^P\) jobs in the busy period are schedulable, then the worstcase response time of the task is given by:
For task sets with constrained deadlines, only the response time of the first job in the busy period need be checked, leading to a simpler exact test (Audsley et al. 1993; Joseph and Pandya 1986), based on the following recurrence relation:
Iteration starts with \(R^P_i = C_i\) and ends either on convergence or when \(R^P_i > D_i\) in which case the task is unschedulable.
Fixed priority nonpreemptive scheduling
Determining exact schedulability of a task \(\tau _i\) under FPNP also requires checking all of the jobs of task \(\tau _i\) within a priority leveli busy period (Bril et al. 2009). In this case, the busy period starts with an interval of blocking and so its length is given by the solution to the following recurrence relation:
where \(B_i\) is the blocking factor:
and \(\varDelta \) is the time granularity^{Footnote 2}.
The number of jobs of task \(\tau _i\) in the busy period is given by \(Q_i^{NP} = \lceil \frac{A_i^{NP}}{T_i} \rceil \). The start time \(W^{NP}_i(q)\) of job q of task \(\tau _i\) relative to the start of the busy period is given by the following recurrence relation:
Iteration starts with \(W^{NP}_i(q) = B_i+ qC_i\) and ends either on convergence or when \(W^{NP}_i(q) + C_i  qT_i > D_i\) in which case the job and therefore the task is unschedulable. Assuming that all \(Q_i^{NP}\) jobs in the busy period are schedulable, then the worstcase response time of the task is given by:
Note, in the above formulation we use a ceiling function with \( + \varDelta \), rather than the alternative of a floor function \(+ 1\), since this assists in the proofs given later in the paper. The two formulations are however equivalent.
We make use of the following sufficient schedulability tests for each task \(\tau _i\) under FPNP. The first is based on a linear equation (Davis et al. 2010):
The second, which is only applicable to constraineddeadline task sets is based on a recurrence relation (Davis et al. 2007):
where \(W^{NP}_i\) is an upper bound on the longest time from release to the start of any job of task \(\tau _i\).
Finally, we also make use of a necessary test. This test is valid for task sets with arbitrary deadlines. It simply checks schedulability of the first job in the busy period, if this job is found to miss its deadline, then the task is unschedulable; however, if the job is found to meet its deadline, the task may or may not be schedulable, since subsequent jobs in the busy period may or may not meet their deadlines. Thus the test is necessary but not sufficient.
\(R^{NP}_i\) given by (11) provides a lower bound response time.
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.
Preemptive earliest deadline first scheduling
A task set is schedulable under preemptive EDF if and only if in every time interval, the total processor demand requested by the task set is no greater than the length of the interval (Baruah et al. 1990). A task set is EDFP feasible if and only if:
where
and \(A^P_n\) is the length of the longest busy period, given by (1) (Ripoll et al. 1996; Spuri 1996).
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
An upper bound on the speedup factor required such that FPNP, using optimal priority assignment, can schedule any arbitrarydeadline sporadic task set that is feasible under EDFP is given by:
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.
Comparing (9) and (13) and assuming DMPO we observe the following.
Note in (14) \(2D_i\) is a value we have chosen for convenience since the inequality is then useful later in the proof. From (9), (14), and the fact that \(B_i \le C_{max}\) then schedulability under FPNP is assured on a processor of speed S provided that for every task \(\tau _i\):
Since the task set is schedulable under EDFP on a processor of unit speed, then it follows from (12) that \(\sum _{\forall \tau _k \in \varGamma } DBF_k(2D_i) \le 2D_i\). Substituting into (15) and rearranging, we have:
Substituting \(D_{min}\) for \(D_i\) gives an upper bound on the speedup factor required. \(\square \)
Lemma 2
An upper bound on the speedup factor required such that FPNP, using optimal priority assignment, can schedule any arbitrarydeadline sporadic task set that is feasible under FPP scheduling is given by:
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
A lower bound on the speedup factor required such that FPNP, using optimal priority assignment, can schedule any implicit, constrained, or arbitrarydeadline sporadic task set that is feasible under EDFP (or FPP) is given by:
Proof
Consider the following task set, where k is an integer and \(k > 1\):

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

\(\tau _2\): \(C_2=k^2+1\), \(D_2=\infty \), \(T_2=\infty \)
We note that the task set is trivially schedulable on a processor of unit speed using either EDFP or FPP. For the task set to be schedulable with FPNP effectively requires that the execution time of both tasks^{Footnote 3} (i.e. \(k^2 + k\)) can be accommodated within the smallest deadline \(D_1=k\).
Hence we have \(S\ge (k^2 + k)/k\) \(=k+1\). Since \(\frac{C_{max}}{D_{min}}=k + \frac{1}{k}\) we obtain:
and so as \(k\rightarrow \infty \) we have a lower bound of:
\(\square \)
Theorem 1
The exact suboptimality (S3) of EDFNP, i.e, the exact speedup factor required such that EDFNP can schedule any implicit, constrained, or arbitrarydeadline sporadic task set that is feasible under EDFP, is given by:
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
An upper bound on the speedup factor required such that FPNP scheduling, using optimal priority assignment, can schedule any constraineddeadline sporadic task set that is feasible under FPP scheduling is given by:
Note this Lemma does not apply to arbitrarydeadline tasks sets.
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}\)
Let \(E_{i}^P(t)\) equate to \(C_i\) plus the maximum amount of interference from tasks of higher priority than \(\tau _i\) released in an interval of length t:
From (4), it follows that \(E_{i}^P(W^P_{i})= W^P_{i} = R^P_{i}\) where \(R^P_{i}\) is the exact response time of task \(\tau _i\) under FPP scheduling.
Let \(E_{i}^{NP}(t)\) be the maximum amount of interference from tasks of higher priority than \(\tau _i\) released in an interval of length t including any releases at the end of the interval:
From the sufficient test for constraineddeadline task sets under FPNP scheduling (10) we have \(E_{i}^{NP}(W^{NP}_{i})+C_{max}+C_i=W_{i}^{NP}+C_i\) where \(W_{i}^{NP}\) is an upper bound on the time from the release of a job of task \(\tau _i\) until it starts to execute under FPNP scheduling, and \(W_{i}^{NP}+C_i\) is an upper bound on the task’s response time.
From (16) and (17), observe that \(\forall x \ge \varDelta \) and \(\forall t \ge x\), the following inequality holds:
To ensure schedulability under FPNP scheduling, we speed up the processor by some factor \(S \ge 1\) such that the latest completion time of task \(\tau _i\) under FPNP scheduling is no greater than \(W^P_{i}\) the completion time under FPP scheduling on a processor of unit speed. It follows that the start time of \(\tau _i\) must be at the latest \(W_{i}^P  \frac{C_i}{S}\). An upper bound on the interference from higher priority tasks in an interval of this length is given by \(E_{i}^{NP}(W_{i}^P  \frac{C_i}{S})\). To complete task \(\tau _i\) by \(W^P_{i}\) the processor must be able to complete execution of the interference \(E_{i}^{NP}(W_{i}^P  \frac{C_i}{S})\), task \(\tau _i\) itself i.e. \(C_i\), and the maximum amount of blocking \(C_{max}\). Schedulability under FPNP is therefore ensured provided that:
On the faster processor of speed S the execution time of \(\tau _i\) cannot be less than the time granularity (\(\frac{C_i}{S} \ge \varDelta \)). It follows from (18) that \(E_{i}^{NP}(W_{i}^P  \frac{C_i}{S}) + C_i \le E_{i}^P(W_{i}^P)\). Since \(E_{i}^P(W_{i}^P) = W_{i}^P\), we can substitute \(W_{i}^P\) into (19) in place of \(E_{i}^{NP}(W_{i}^P  \frac{C_i}{S}) + C_i\) again giving an inequality which is sufficient to ensure schedulability under FPNP. Rearranging we have:
From the assumption of this case (Case 1) \(W_{i}^P \ge D_{min}\) and hence the task set is guaranteed to be schedulable on a processor of speed S, where:
Case 2: \(W_{i}^P < D_{min}\)
Since deadlines are constrained, there are no tasks with periods that are less than \(D_{min}\), and so under FPP scheduling on a processor of unit speed, we have:
In this case, to ensure schedulability under FPNP on a processor of speed S, we simply require that task \(\tau _i\) completes before \(D_{min}\), hence we require that:
where S is the processor speed.
Following the same logic as in Case 1, we observe that \(E_{i}^{NP}(D_{min}  \frac{C_i}{S}) + C_i \le E_{i}^P(W_{i}^P) = W_{i}^P\). Since in this case (Case 2) \(W_{i}^P < D_{min}\) substituting into (23) and rearranging we obtain the speed S at which the task set is guaranteed to be schedulable:
\(\square \)
Theorem 2
The exact speedup factor required such that FPNP, using optimal priority assignment, can schedule any implicit, or constraineddeadline sporadic task set that is feasible under FPP scheduling is given by:
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
A lower bound on the speedup factor required such that FPNP scheduling, using optimal priority assignment, can schedule any arbitrarydeadline sporadic task set that is feasible under FPP scheduling is given by:
Proof
Consider the following task set:

\(\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 \)
This task set is trivially schedulable on a processor of unit speed under FPP. In the priority order given, then for \(j = 1\) to k, task \(\tau _j\) has a response time of j. Further, task \(\tau _{k+1}\) executes in the one spare unit of execution time in each Least Common Multiple \(k(k+1)\) of the periods of tasks \(\tau _1\) to \(\tau _k\) and therefore has a worstcase response time of \(k^3(k+1)\).
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^{Footnote 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)\).
Considering both Case 1 and Case 2, then the minimum speed necessary for FPNP schedulability is \(S \ge (k^2 + 2k 2)/(k+1) = k + (k2)/(k+1)\). Since \(C_{max}/D_{min} = k^2 /(k+1)\) we obtain:
As \(k\rightarrow \infty \) this gives a lower bound of \(S = 2 + \frac{C_{max}}{D_{min}}\) for the speedup factor. \(\square \)
Theorem 3
The exact speedup factor (S2) required such that FPNP scheduling, using optimal priority assignment, can schedule any arbitrarydeadline sporadic task set that is feasible under FPP scheduling is given by:
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 \)
From Theorems 2 and 3, it is interesting to note that when comparing FPNP against FPP scheduling, then the relaxation from constraineddeadline task sets to the general case of arbitrarydeadline tasks results in an increase in the exact speedup factor required from
Theorem 4
The exact suboptimality (S1) of FPNP i.e. the exact speedup factor required such that FPNP scheduling, using optimal priority assignment, can schedule any arbitrarydeadline sporadic task set that is feasible under EDFP is given by:
Proof
Lemma 1 shows that the speedup factor in the theorem is a valid upper bound. Lemma 5 and the fact that EDFP dominates FPP shows that it is also a valid lower bound and hence exact for arbitrarydeadline task sets. \(\square \)
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.
Lower bound on the speedup factor for FPP v. FPNP
Theorem 5
A lower bound on the speedup factor required such that FPP scheduling, using optimal priority assignment, can schedule any constrained deadline sporadic task set that is feasible under FPNP scheduling is given by:
Proof
Consider the following task set scheduled on a processor of unit speed under FPNP scheduling.

\(\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 \)
This task set is schedulable with DMPO under FPNP as evidenced by the exact schedulability test embodied in (8). The response times of the three tasks are as follows: \(R_1 = 1  \varDelta \), \(R_2 = \sqrt{2}  \varDelta \), \(R_3 = \sqrt{2}\). Note, that in each case we need only examine the response time of the first job. For task \(\tau _1\), the priority level1 busy period is of length 1 and so includes only one job of the task, while tasks \(\tau _2\) and \(\tau _3\) have infinite periods and so only give rise to a single job. The schedule starting with task \(\tau _1\) is illustrated in Fig. 2.
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 \)
Upper bound on the speedup factor for FPP v. FPNP for arbitrarydeadline task sets
Theorem 6
An upper bound on the speedup factor required such that FPP scheduling, using optimal priority assignment, can schedule any arbitrary deadline sporadic task set that is feasible under FPNP scheduling is given by:
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 \)
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.
Proof of the upper bound on the speedup factor required to guarantee feasibility under FPP for all constraineddeadline task sets that are feasible under FPNP requires a number of steps. Below we outline these steps and the theorems and lemmas involved.

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
For the comparison between 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) there exists a speedup optimal task set \(\varGamma \) that exhibits the highest speedup factor of any constraineddeadline sporadic task set which has the following properties under FPP scheduling.

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.
Proof
Follows from Lemmas 6, 7, and 8, given below \(\square \)
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
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 a speedup factor strictly greater than that of any task set in Y. By the assumption for contradiction, task set S has a task \(\tau _L\) at priority level \(n1\) that has an execution time \(C_L < C_A\). (Note speedup optimal task sets must trivially have at least two tasks; otherwise the speedup factor would be 1). The lower bound response time of task \(\tau _L\) is given by:
where HP(L) is the set of higher priority tasks excluding both \(\tau _L\) and \(\tau _A, W_L^{NP}\) in the solution obtained on convergence, and thus:
As \(\tau _L\) is deemed schedulable by the necessary test for FPNP, and has a constrained deadline, then \(R^{NP}_L \le D_L \le T_L\). Comparing (25) and (26) with (33) and (34) which give the lower bound response time \(R^{NP}_A\) of task \(\tau _A\), we observe that since \(C_L < C_A\) then it follows that \(R^{NP}_L \ge R^{NP}_A\). From Lemma 7 we have \(R^{NP}_A=D_A\) thus it follows that \(T_L \ge D_L \ge R^{NP}_L \ge R^{NP}_A = D_A\), and hence task \(\tau _A\) can only be subject to interference from one job of task \(\tau _L\) before its deadline. We therefore form a new task set V from S by removing task \(\tau _L\) and increasing the execution time of task \(\tau _A\) by \(C_L\). This has no effect on the response time of \(\tau _A\) under FPP scheduling, so \(\alpha ^{FPP}(V) = \alpha ^{FPP}(S)\); however, the scaling factor permitted according to the necessary test for FPNP scheduling either stays the same or increases hence \(\alpha ^{FPNP}(V) \ge \alpha ^{FPNP}(S)\). This can be seen by considering that the start time of \(\tau _A\) is reduced by at least \(C_L\), while its execution time is increased by exactly \(C_L\). It follows that the speedup factor required by task set V is at least as great as that required by S. Repeated application of this process, which removes a task each time, must eventually result in a task set \(V \in Y\) (Note reduction to one task is not possible since such a task set cannot be speedup optimal). This contradicts the assumption and so there must be at least one speedup optimal task set in Y. \(\square \)
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.
For ease of presentation and to simplify the formulae involved, in the following (and in Fig. 4), we normalise the execution times such that \(W^{NP}_A =1\), and thus \(D_A =1+A\).
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
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:
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
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:
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
As the task set is schedulable under FPP if it is schedulable in either scenario (i) or (ii), then the speedup factor required is given by the minimum of \(S_1\) given by Lemma 9 and \(S_2\) given by Lemma 10. Since \(S_1\) is monotonically increasing in A and \(S_2\) is monotonically decreasing in A (recall that by definition \(0 \le X \le 1\)), then the minimum is obtained when they are equal:
Expanding and rearranging, we have: \(X=A^2+A\) subject to the constraint that \(A+X \le 1\). The speedup factor is therefore maximised by setting \(A+X = 1\). This results in the quadratic equation \( A^2+2A1 = 0\). The positive solution of which is \(A=\sqrt{2}1\), substituting in (27) we have \(S=\sqrt{2}\). \(\square \)
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
By the assumption in the Theorem, there is no interference released during the interval \([1,A+X)\), hence the total execution released in \([0,A+X)\) is \(A+X+B=1+A\). Therefore speeding the processor up by the following factor is enough to ensure the schedulability of task \(\tau _A\) under FPP (as illustrated by Fig. 4b):
Alternatively, by definition the maximum amount of interference released in the interval [0, 1) from tasks that are rereleased at some point in \([0,A+1)\) is X. Since there are no rereleases in \([1,A+X)\) and the interval \([A+X, A+1)\) is no greater than 1 in length, then it follows that at most interference of 2X is released in \([0,A+1)\). Thus if we speed the processor up such that execution of \(A+X+1\) can be accomplished in an interval of length \(A+1\), then task \(\tau _A\) is also guaranteed to be schedulable under FPP (as illustrated by Fig. 4c). Hence we have:
Note that \(S_4\) is the same as \(S_2\) given in (28).
Again, as the task set is schedulable under FPP if the processor is speeded up by a factor of either \(S_3\) or \(S_4\), then the speedup factor required is given by the minimum of them. We observe that for any fixed value of X, then both \(S_3\) and \(S_4\) are maximised by selecting the minimum value of A. Since we have the constraint that \(A+X>1\), then we may obtain upper bounds for both scaling factors by substituting in \(A=1X\). Since \(S_3\) is a monotonically decreasing function of X and \(S_4\) is a monotonically increasing function of X, then the maximum value for the minimum of \(S_3\) and \(S_4\) is obtained when \(S_3=S_4\). Thus we have:
and hence either \(X=2  \sqrt{2}\) or \(X=2 + \sqrt{2}\). Since the speedup factors \(S_3\) and \(S_4\) cannot be negative, we may disregard the larger value for X, thus the solution is given by \(X=2  \sqrt{2}\), \(A=\sqrt{2}1\), and \(S=\sqrt{2}\). \(\square \)
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
We assume (for contradiction) that \(D_L > D_A\) and \(C_L > C_A\). Since \(\tau _A\) is deemed schedulable at the lowest priority, it follows that:
where HP(L) is the set of higher priority tasks excluding both \(\tau _L\) and \(\tau _A\), and \(W^{NP}_A\) is the solution obtained on convergence.
Now consider what happens if the priorities of the two tasks are swapped and task \(\tau _L\) is now at the lowest priority. Its lower bound response time is determined as follows:
with the solution \(W^{NP}_L\) obtained on convergence, and thus:
As \(\tau _A\) is deemed schedulable at the lowest priority, it must be the case that from (33) \(W^{NP}_A \le D_A \le T_A\). Considering the two fixed point iterations (35) and (33), and that \(C_L > C_A\) (i.e. \(C_L \ge C_A + \varDelta \)) and \(W^{NP}_A \le T_A\), then \(W^{NP}_L\) in (35) must converge to a value that is no greater than \(W^{NP}_A  C_L + C_A\). This implies that the ceiling function in the final term of (35) is 1. It follows that \(W^{NP}_L + C_L \le W^{NP}_A + C_A\) and hence \(R^{NP}_L \le R^{NP}_A\). Since \(D_L > D_A\) then task \(\tau _L\) is schedulable when assigned the lowest priority. As the OPA algorithm checks tasks in reverse deadline monotonic order (i.e. task \(\tau _L\) before task \(\tau _A\)) the priority assignment with \(\tau _L\) at a higher priority than \(\tau _A\) can never be obtained; task \(\tau _L\) would have been assigned the lowest priority. \(\square \)
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.
Since \(\delta \) is the maximum amount of interference (not including \(\tau _L\) or \(\tau _A\)) released in an interval of length \(A+\delta \) starting with synchronous release of all tasks, then in any interval of length t, the amount of interference is upper bounded by:
Thus the total amount of execution released in an interval of length \(A +\delta +C_L\) is upper bounded by:
Hence the speedup factor required to guarantee schedulability of task \(\tau _A\) under FPP is upper bounded by:
We will now employ a number of constraints to show that the speedup factor does not exceed \(S=\sqrt{2}\).
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.
Ceiling = 4: For the ceiling function to return 4, it must be the case that \(C_L>2A+2\delta >2(\sqrt{2}1)+2\delta \). Further, since \(C_L+\delta \le 1\) we have: \(1\delta >2(\sqrt{2}1)+2\delta \) and therefore \(\delta <(32\sqrt{2})/3\). For any fixed value of the ceiling function, then \(S_5\) is maximised by choosing the largest possible value of \(\delta \). Hence when the ceiling function returns 4, \(S_5\) is upper bounded by selecting \(\delta =(32\sqrt{2})/3\). We therefore obtain:
Ceiling = 3: For the ceiling function to return 3, it must be the case that \(2A+2\delta \ge C_L>A+\delta >\sqrt{2}1+\delta \). Further, since \(C_L+\delta \le 1\) we have: \(1\delta >\sqrt{2}1+\delta \) and therefore \(\delta <(2\sqrt{2})/2\). Since for any fixed value for the ceiling function, \(S_5\) is maximised by choosing the largest possible value of \(\delta \), \(S_5\) is upper bounded in this case by selecting \(\delta =(2\sqrt{2})/2\). We therefore obtain:
Ceiling = 2: For the ceiling function to return 2, it must be the case that \(A+\delta \ge C_L>A\). Further, since \(C_L+\delta \le 1\) we have: \(1\delta >\sqrt{2}1 \) and hence \(\delta <2\sqrt{2}\). Again, for any fixed value for the ceiling function, \(S_5\) is maximised by choosing the largest possible value of \(\delta \). Hence \(S_5\) is upper bounded in this case by selecting \(\delta =2\sqrt{2}\). We therefore obtain:
We have shown, for all three possible values of the ceiling function, that the speedup factor \(S_5\) with \(A = \sqrt{2}1\) is upper bounded by at most \(\sqrt{2}\). Since this bounds the maximum value that \(S_5\) can take for any value of \(A > \sqrt{2}1\) and the value of \(S_1 \le \sqrt{2}\) when \(A \le \sqrt{2}1\), it follows that the maximum value of \(min(S_1, S_5)\) is \(\sqrt{2}\). \(\square \)
Theorem 11
An upper bound on the speedup factor that guarantees FPP feasibility of all constraineddeadline FPNP feasible task sets is given by:
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 \)
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
The exact speedup factor that guarantees FPP feasibility of all constraineddeadline FPNP feasible task sets is given by:
Proof
Follows from the upper bound given in Theorem 11 and the lower bound of the same value given in Theorem 5. \(\square \)
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).
Specifically, we derived the following exact suboptimality and speedup factor results:
 S1 :

Exact suboptimality of FPNP for tasks with arbitrary deadlines:
$$\begin{aligned} S = 2 + \frac{C_{max}}{D_{min}} \end{aligned}$$For task sets with implicit or constraineddeadlines:
$$\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:
$$\begin{aligned} S = 2 + \frac{C_{max}}{D_{min}} \end{aligned}$$For task sets with implicit or constrained deadlines:
$$\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.
The major remaining open problems involve tightening the upper and lower bounds where exact values are not yet known. These include determining the exact suboptimality of FPNP for the case of implicit and constrained deadline task sets, and determining the exact speedup factor required for FPP feasibility of any task set that is FPNP feasible for the implicit, and arbitrary deadline cases.
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^{Footnote 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.
Notes
 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.
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
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
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 164
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
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–292
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
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)
Bini E, Buttazzo GC (2005) Measuring the performance of schedulability tests. RealTime Syst 30(1–2):129–154. https://doi.org/10.1007/s1124100505079
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
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
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
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)
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)
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
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
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–31
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–10
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
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–24
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–813
George L, Rivierre N, Spuri M (1996) Preemptive and nonpreemptive realtime uniprocessor scheduling. Research report, INRIA
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
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
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
Short M (2010) The case for nonpreemptive, deadlinedriven scheduling in realtime embedded systems. In: Proceedings of the world congress on engineering (WCE), pp 399–404
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
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
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–101
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
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.
Author information
Affiliations
Corresponding author
Additional information
Preliminary publication: This paper extends initial research into speedup factors for preemptive versus nonpreemptive uniprocessor scheduling published in RTSS 2015 (Davis et al. 2015c). The main extension is the proof of the exact speedup factor required to guarantee the FPP feasibility of any FPNP feasible constraineddeadline task set.
Rights and permissions
Open Access This 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.
About this article
Cite this article
Davis, R.I., Thekkilakattil, A., Gettings, O. et al. Exact speedup factors and suboptimality for nonpreemptive scheduling. RealTime Syst 54, 208–246 (2018). https://doi.org/10.1007/s1124101792943
Published:
Issue Date:
Keywords
 Realtime
 Uniprocessor
 Resource augmentation
 Speedup factor
 Suboptimality
 Nonpreemptive scheduling
 Preemptive scheduling
 EDF
 Fixed priority