In this section, we discuss some results concerning HRT and SRT schedulability of implicit-deadline sporadic task systems under GEDF, and present several unrestricted global multiprocessor schedulers.
2.1.1
GEDF Schedulability Results
One way to ensure task timing constraints in a SRT system is to treat all deadlines as hard (i.e., set Θi = 0). Perhaps partly because of that, most prior work on GEDF has focused on hard real-time
schedulability tests (Baker, 2003; Baruah, 2007; Baruah and Baker, 2008; Bertogna et al., 2008). If such a test passes, then each task is guaranteed zero tardiness. Unfortunately, ensuring zero tardiness under GEDF may severely restrict system utilization. According to Goossens et al. (2003), an implicit-deadline task systemτ can be guaranteed to meet all deadlines onmprocessors under GEDF if
m≥ U sum(τ)−1 1−max(ui) .
The task set from Example 1.3 in Section 1.5.3 may thus require m ≥ lUsum(τ)−1
1−max(ui)
m
= l1.931−3/4−1m =
⌈3.72⌉= 4 processors in order to meet all job deadlines. Because the total utilization isUsum(τ)≈1.93,
half of the platform’s processing capacity will be unused in this case.
As mentioned earlier in Section 1.5.3, Devi and Anderson (2008b) showed that, for an implicit- deadline task systemτ, bounded deadline tardiness is guaranteed under GEDF and NPGEDF ifUsum(τ)≤
m. That is, for SRT systems, utilization loss can be eliminated. Let
λ=
Usum−1 ifUsum is integral,
⌊Usum⌋ otherwise. Then deadline tardiness for taskTi under GEDF is at most
ei+EL
−min(ei)
m−UL , (2.1)
where EL is the sum of λ largest task WCETs and UL is the sum of λ−1 largest task utilizations. Similar expression were obtained in (Devi and Anderson, 2008b) for NPGEDF and for the case when tasks consist of interleaving preemptive and non-preemptive regions. If tardiness thresholds Θi are specified, then we can calculate tardiness bounds Θ′
i using (2.1) and then verify that Θ′i ≤ Θi holds for each task Ti. Unfortunately, this method cannot be applied if some tardiness thresholds are small because Θ′
i ≥ ei for each Ti ∈ τ. This precludes the analysis of systems with mixed HRT and SRT constraints. Also, (2.1) is applicable only to implicit-deadline task systems.
For constrained- and arbitrary-deadline task systems, several HRT schedulability tests for GEDF have been proposed (Baker, 2003; Baruah, 2007; Baruah and Baker, 2008; Bertogna et al., 2008). All of these tests assume full processor availability and incur some utilization loss in order to guarantee hard deadlines. Unfortunately, no research has been done yet concerning the calculation or verification of tardiness bounds in constrained- and arbitrary-deadline task systems scheduled on multiprocessors.
One can argue that in order to verify pre-defined tardiness thresholds, taskTi’s relative deadline can be set toDi+ Θi, whereDi is the old relative deadline and Θi isTi’s allowed tardiness threshold, and then the HRT schedulability of the modified system can be verified. Though this method is valid for the verification of timing constraints, it changes the relative priority of jobs of different tasks, which may be unacceptable.
Additionally, introducing tardiness thresholds allows a job’s timing constraint to be decoupled from its scheduling priority. For example, an arbitrary-deadline task systemτwith relative deadlines{D1, . . . , Dn} that is not HRT schedulable under GEDF can be SRT schedulable for a different set of relative deadlines
{D′1, . . . , Dn′} and tardiness thresholds {Θ′1, . . . ,Θ′n} such that Di′+ Θ′i = Di for each i. The idea of decoupling priorities and timing constraints is elaborated on in greater detail in Chapter 3.
2.1.2
Unrestricted Global Multiprocessor Scheduling
Unrestricted schedulers allow job priorities to change at runtime. In this section, we briefly present the earliest-deadline-zero-laxity (EDZL), earliest-pseudo-deadline-first (EPDF), PfairPD2, and least-local- remaining-execution-first (Least Local Remaining Execution First (LLREF)) algorithms.
EDZL algorithm. EDZL, which was first proposed by Cho et al. (2002), is a conventional GEDF algorithm with an added “safety rule.” Under EDZL, a job is prioritized by its deadline unless it is in danger of missing its deadline. This moment is detected by calculating the job’s laxity, which is the difference between the current time and the latest time when the job can be scheduled so that it meets its deadline. Jobs with zero laxity are given the highest priority.
Example 2.1. Consider the task set from Example 1.4. An example EDZL schedule for it is shown in Figure 2.1(a). In this schedule, at time 0, all jobs have positive laxity (i.e., if scheduled immediately, each job will complete before its deadline). Therefore, jobs T1,1 and T2,1, which have the smallest absolute deadlines are scheduled. At time 2, job T4,1 has zero laxity (i.e., if scheduled later, then it will miss its deadline). By the zero laxity rule, its priority is raised and T4,1 executes uninterruptedly until its deadline.
In the literature, several schedulability tests have been proposed for EDZL (Cirinei and Baker, 2007; Piao et al., 2006; Wei et al., 2007). It has been shown that EDZL can schedule any task set that is schedu- lable under GEDF (Cho et al., 2002). However, for anyU such thatU ≤mandU > m·(1−1/e), where e is Euler’s number, there exists at least one implicit-deadline task system τ such that Usum(τ) = U
t
0 2 4 6 8 10 12T
3,1T
4,1T
1,1T
1,2T
2,2T
2,1T
1,3T
1,4T
3,2T
3,2 P1 P2T
4,2 (a)t
0 2 4 6 8 10 12 P1 P2 T1,1 T2,1 T1,1 T1,2 T4,1 T4,1 T1,2 T1,3 T1,4 T1,5 T2,2 T3,1 T3,1 T3,1 T3,2 T3,2 T4,1 T4,1 T4,1 T4,1 T4,2 T4,2 T4,2 T1,3 (b) Figure 2.1: Example(a)EDZL and(b)EPDF schedules.that is unschedulable by EDZL (Wei et al., 2007).
EPDF algorithm. Under the EPDF Pfair algorithm (Devi and Anderson, 2008a), task periods and execution times are assumed to be integral, and each taskTiis represented by a sequence of unit-length schedulable entities called subtasks, denoted Tij, where j ≥ 1. Each subtask T
j
i has two attributes associated with it, a release time rji and a deadline dij. The interval [rji, dji) is called the window of Tij. Subtask Tij becomes available for execution at time rij and has higher priority than subtaskTy
x if dji < dy
x. Deadline ties are resolved arbitrarily but consistently.
Example 2.2. In considering EPDF scheduling examples, we assume (for simplicity) that jobs are released in a synchronous periodic fashion, in which caserji =⌊i−ui1⌋andd
j
i =⌈uii⌉(see (Anderson and
Srinivasan, 2004)). Figure 2.1(b) shows an EPDF schedule for the task setτ from Example 1.3. In this schedule, each subtask executes within its respective window, which is shown in bold. Thus, all tasks meet their deadlines.
Allowing early releases can reduce job response times as the following example illustrates.
Example 2.3. Figure 2.2 shows two EPDF schedules of a task T1(3,8). Inset (a) shows a schedule in which early releases are not allowed. In this schedule, each subtask executes within its respective window. The time betweenT1,1’s release and completion is six time units. A schedule in which early releases are allowed is shown in Figure 2.2(b). In this schedule, each subtask executes immediately after its predecessor completes. In this schedule, the response time ofT1,1is three time units.
It has been shown that EPDF correctly schedules any implicit-deadline task system τ (with inte- gral execution times and periods) on m processors if Usum(τ) ≤ 3·m+14 (Devi and Anderson, 2008a).
T1 T1 1 T1 2 T1 3 T1 4 0 2 4 6 8 10 12
t
response time ofT1,1 (a) T1 T1 1 T1 2 T1 3 T1 4 0 2 4 6 8 10 12t
response time ofT1,1 (b)Figure 2.2: EPDF schedules from Example 2.3(a)without and(b)with early releases.
Additionally, EPDF ensures a maximum tardiness bound of q quanta if maxTi∈τ(ui) ≤
q+2 q+3 and Usum(τ)≤m(Devi and Anderson, 2009).
PD2 and LLREF algorithms. PD2 differs from EPDF in that two special tie-breaking rules are used in the event of a deadline tie. As mentioned earlier in Section 1.5.3,PD2is one of the few optimal mul- tiprocessor scheduling algorithms for implicit-deadline task systems. The LLREF scheduling algorithm, which was proposed by Cho et al. (2006), is another example of an optimal multiprocessor scheduler. Unfortunately, it is optimal only for periodic workloads as it requires that the arrival time of every job be knowna priori.