A real-time system is often modelled as a finite collection of independent recurring tasks, each of which generates a potentially infinite sequence of jobs. Every job is characterized by a 3-tuple , i.e., by a release time (), an execution requirement (), and a deadline (), and it is required that a job completes execution between its arrival time and its deadline.
From a theoretical and a practical point of view, we can distinguish (at least) between three kinds of multiprocessor architectures (from less general to more general):
- Identical parallel machines
Platforms on which all the processors are identical, in the sense that they have the same computing power.
- Uniform parallel machines
By contrast, each processor in a uniform parallel machine is characterized by its own computing capacity, a job that is executed on processor of computing capacity for time units completes units of execution.
- Unrelated parallel machines
In unrelated parallel machines, there is an execution rate associated with each job-processor pair, a job that is executed on processor for time units completes units of execution.
In this paper, we consider real-time systems that are modeled by set of jobs and implemented upon a platform comprised of several unrelated processors. We assume that the platform
is fully preemptive: an executing job may be interrupted at any instant in time and have its execution resumed later with no cost or penalty.
allows global inter-processor migration: a job may begin execution on any processor and a preempted job may resume execution on the same processor as, or a different processor from, the one it had been executing on prior to preemption.
forbids job parallelism: each job is executing on at most one processor at each instant in time.
The scheduling algorithm determines which job[s] should be executed at each time-instant. Fixed-Job Priority (FJP) schedulers assign priorities to jobs statically and execute the highest-priority jobs on the available processors. Dynamic Priority (DP) schedulers assign priorities to jobs dynamically (at each instant of time). Popular FJP schedulers include: the Rate Monotonic (RM), the Deadline Monotonic (DM) and the Earliest Deadline First (EDF) [Liu]. Popular DP schedulers include: the Least Laxity First (LLF) and the EDZL [thesisMok, Cho2005Efficient-Real-].
The specified execution requirement of job is actually an upper bound of its actual value, i.e., the worst case execution time (WCET) is provided. The actual execution requirement may vary depending on the input data, and on the system state (caches, memory, etc.). The schedulability analysis, determining whether all the jobs always meet their deadlines, is designed by considering a finite number of (worst-case) scenarios (typically a single scenario) assuming that the scheduler is predictable with the following definition: For a predictable scheduling algorithm, one may determine an upper bound on the completion-times of jobs by analyzing the situation under the assumption that each job executes for an amount equal to the upper bound on its execution requirement; it is guaranteed that the actual completion time of jobs will be no later than this determined value.
Ha and Liu [Ha] ‘showed’ that FJP schedulers are predictable on identical multiprocessor platforms. However, while the result is correct, an argument used in the proof is not. Han and Park studied the predictability of the LLF scheduler for identical multiprocessors [Han2006Predictability-]. To the best of our knowledge a single work addressed heterogeneous architectures, indeed we have showed in [etfaLCJG06] that any FJP schedulers are predictable on uniform multiprocessors.
In this research, we extend and correct [Ha] by considering unrelated multiprocessor platforms and by showing that any FJP schedulers are predictable on these platforms.
The paper is organized as follows. In Section 2 we formally define the task and machine models used, and provide some additional useful definitions. In Section 3 we show that the argument used by Han and Liu [Ha] is incorrect. In Section 4 we correct and extend the Ha and Liu result, we present our main contribution: the predictability of FJP schedulers on unrelated platforms.
2 Model and definitions
We consider multiprocessor platforms composed of unrelated processors: . Execution rates are associated with each job-processor pair, a job that is executed on processor for time units completes units of execution. For each job we assume that the associated set of processors are ordered in a decreasing order of the execution rates relative to the job: . For identical execution rates, the ties are broken arbitrarily, but consistently, such that the set of processors associated with each job is totally ordered. For the processor-job pair if then is said to be an eligible processor for .
Definition 1 (Schedule ).
For any set of jobs and any
set of processors we define the
schedule of system at time-instant as
Definition 2 (Work-conserving algorithm).
An unrelated multiprocessor scheduling algorithm is said to be work-conserving if, at each instant, the algorithm schedules jobs on processors as follows: the highest priority (active) job is scheduled on its fastest (and eligible) processor . The very same rule is then applied to the remaining active jobs on the remaining available processors.
Throughout this paper, denotes a (finite or infinite) set of jobs: . We consider any FJP scheduler and without loss of generality we consider jobs in a decreasing order of priorities ). We suppose that the actual execution time of each job can be any value in the interval and we denote by the job defined as . The associated execution rates of are . Similarly, is the job defined from as follows: . Similarly, the associated execution rates of are . We denote by the set of the highest priority jobs (and its schedule by ). We denote also by the set and by the set (and its schedule by ). Note that the schedule of an ordered set of jobs using a work-conserving and FJP scheduler is unique. Let be the time-instant at which the lowest priority job of begins its execution in the schedule. Similarly, let be the time-instant at which the lowest priority job of completes its execution in the schedule.
Definition 3 (Predictable algorithm).
A scheduling algorithm is said to be predictable if and , for all and for all schedulable sets of jobs.
Definition 4 (Availability of the processors).
For any ordered set of jobs and any set of unrelated processors , we define the availability of the processors of the set of jobs at time-instant as the set of available processors: , where is the schedule of .
3 Proof from Ha and Liu [Ha]
The result we extend in this work is the following:
For any FJP scheduler and identical multiprocessor platform, the start time of every job is predictable, that is, .
We give here the first part of the original (adapted with our notations) proof of Ha and Liu, Theorem 3.1, page 165 of [Ha].
Proof from [Ha].
Clearly, is true for the highest-priority job . Assuming that for , we now prove by contradiction. Suppose . Because we consider a FJP scheduler, every job whose release time is at or earlier than and whose priority is higher than has started by according to the maximal schedule . From the induction hypothesis, we can conclude that every such job has started by in the actual schedule . Because for all , in , the total demand of all jobs with priorities higher than in the maximal schedule is larger than the total time demand of these jobs in the actual schedule . In , a processor is available at for to start; a processor must also be available in at or before on which or a lower-priority job can be scheduled…
The use of the notion of “total demand” used in the original proof is not appropriate considering multiprocessor platforms. Consider, for instance, two set of jobs: and . In the total demands of both job sets are identical (i.e., 6 time units), if we schedule the system using FJP schedulers, e.g., and it is not difficult to see that in the schedule of a processor is available at time 2 while in the schedule of we have to wait till time-instant 3 to have available processor(s).
In this section we prove our main property, the predictability of FJP schedulers on unrelated multiprocessors which is based on the following lemma.
For any schedulable ordered set of jobs (using a FJP and work-conserving scheduler) on an arbitrary set of unrelated processors , we have , for all and all . In other words, at any time-instant the processors available in are also available in . (We consider that the sets of jobs are ordered in the same decreasing order of the priorities, i.e., and .)
The proof is made by induction by (the number of jobs). Our inductive hypothesis is the following: , for all and .
The property is true in the base case since , for all . Indeed, . Moreover and are both scheduled on their fastest (same) processor , but will be executed for the same or a greater amount of time than .
We will show now that , for all .
Since the jobs in have higher priority than , then the scheduling of will not interfere with higher priority jobs which have already been scheduled. Similarly, will not interfere with higher priority jobs of which have already been scheduled. Therefore, we may build the schedule from , such that the jobs , are scheduled at the very same instants and on the very same processors as they were in . Similarly, we may build from .
Note that will contain the same available processors as for all except the time-instants at which is scheduled, and similarly will contain the same available processors as for all except the time-instants at which is scheduled. From the inductive hypothesis we have , we will consider time-instant , from to the completion of (which is actually not after the completion of , see below for a proof), we distinguish between four cases:
: in both situations no processor is available. Therefore, both jobs, and , do not progress and we obtain . The progression of is identical to .
and : if an eligible processor exists, progress on an available processor in not available in , does not progress. Consequently, and the progression of is strictly larger than .
: if an eligible processor exists, and progress on the same processor. Consequently, and the progression of is identical to .
: if the faster processor in and is the same see previous case of the proof (case 3); otherwise progress on a faster processor than , that processor is not available in , consequently a slower processor remains idle in but busy in . Consequently, and the progression of is larger than .
Therefore, we showed that , from to the completion of and that does not complete after . For the time-instant after the completion of the property is trivially true by induction hypothesis. ∎
FJP schedulers are predictable on unrelated platforms.
In the framework of the proof of Lemma 6 we actually showed extra properties which imply that FJP schedulers are predictable on unrelated platforms: (i) completes not after and (ii) can be scheduled either at the very same instants as or may progress during additional time-instants (case (2) of the proof) these instants may precede the time-instant where commences its execution. ∎
Since multiprocessor real-time scheduling theory is a relative new area of research, researchers pay much more attention to uniform platforms (at least nowadays), we find convenient to emphasized the following corollary:
FJP schedulers are predictable on uniform platforms.
We extended and corrected [Ha] by considering unrelated multiprocessor platforms and by showing that any FJP schedulers are predictable. A convenient consequence is the fact that any FJP schedulers are predictable on uniform multiprocessors.
These results constitute a first theoretical foundation in order to design efficient schedulability tests for the scheduling of periodic and sporadic real-time tasks on heterogeneous architectures.