Scheduling Stochastically-Executing Soft Real-Time Tasks: A Multiprocessor Approach Without Worst-Case Execution Times

Transcription

1 Scheduling Stochastically-Executing Soft Real-Time Tasks: A Multiprocessor Approach Without Worst-Case Execution Times Alex F. Mills Department of Statistics and Operations Research University of North Carolina James H. Anderson Department of Computer Science University of North Carolina Abstract Wntroduce a scheduling method where stochasticallyexecuting soft real-time tasks are assigned to simple sporadic servers with predetermined execution budgets. We show that using this method, any task system whose average-case total utilization is less than the number of processors can be scheduled so that tardiness is bounded in the average case. The constraint on average-case utilization is extremely mild compared to constraints on worst-case utilization becausn multiprocessor systems, worst-case execution times may be orders of magnitude higher than average-case execution times. Unlikn previous work, the derived tardiness bound depends only on the mean and variance of execution times. For soft realtime systems where bounded tardiness is acceptable, this result eliminates the need for timing analysis to determine worst-case execution times. 1 Introduction The focus of this paper is soft real-time workloads specified as implicit-deadline sporadic task systems. Previous work on scheduling such workloads has focused almost exclusively on allocating processing capacity to jobs based on deterministic worst-case execution times. This is a particular impediment in thmplementation of soft real-time systems, where some tardiness is acceptable and therefore the pessimistic assumption that every job may requirts worst-case execution tims unnecessary. In uniprocessor systems, it is well known that the earliest-deadline-first EDF) scheduling algorithm can schedule any system whose utilization is at most one, without missing any deadlines; therefore, both hard and soft real-time workloads can be scheduled on a uniprocessor without any loss of utilization. In multiprocessor systems, Leontyev and Anderson showed that a number of global scheduling algorithms ensure bounded tardiness without utilization loss [5]; thus, soft real-time workloads for which bounded tardiness is sufficient can be supported by such systems. This result extended an earlier proof by Devi and Anderson that showed the same of the global earliest-deadline-first GEDF) scheduling algorithm [2]. In these results, utilizations are defined by assuming worstcase execution costs. Previous work by Mills and Anderson questioned whether using a deterministic worst-case execution time to compute utilization always makes sensn the realm of soft real-time systems [8]. The actual worst-case execution time of a task may be observed so infrequently that it may not be worth dedicating such a large amount of processing time to that task if bounded tardiness is acceptable. Moreover, timing analysis tools may add additional pessimism to the calculation of worst-case execution times. These problems are exacerbated on a multiprocessor, where the worst-case scenario may be even less likely but even more costly. Mills and Anderson demonstrated that processing capacity could be allocated based on average-case execution times, with the result that the expected mean) tardiness of a task is bounded when the system is scheduled using GEDF 1. Unfortunately, the expected tardiness bound established by them still depends on worst-case execution times. In this paper, we consider the sporadic stochastic task model sporadic interrelease times and stochastic execution times), as in [8]. We show that reliance on worst-case execution times can be avoided by scheduling the sporadic stochastic tasks on a system of simple sporadic servers. Each server is a deterministic soft real-time task, and each server s utilization is on the order of the average-case utilization of its corresponding sporadic stochastic task. Unlikn the previous work, a job in such a system does not necessarily run even when it has the highest priority. Instead, a job may only run when its task s server executes. This is a similar idea to that proposed but not formalized by Calandrino et al. [1], where jobs that did not complete by the time their execution budget ran out could steal from the budget of the next job. Not only do we formalize this concept, but our approach is also more sophisticated, because the server budgets may be replenished more of- 1 The published version of [8] contains a small error in the tardinessbound derivation; a corrected version can be found at unc.edu/ anderson/papers.html.

2 ten than the jobs are released. Hence, an over-running job has enough separation from its successor, it may not be necessary for the over-running job to steal its successor s execution budget, but rather to simply consume the budget of another instance of the server task in thnterim time. In this paper, we derive expected tardiness bounds under this scheduling approach; such bounds were not considered in [1]. In [8], jobs of every task could potentially be affected by a single job with a much longer-than-average execution time. In this paper, because the servers have a limited budget in each period, only jobs of the same task can be affected by such overruns. There are potential disadvantages in this case, but the result is that in both the uniprocessor and multiprocessor cases, sporadic stochastic tasks have bounded expected tardiness. Moreover, unlike our previous work, the expected tardiness bounds do not depend on worst-case execution times in fact, tasks that do not have a worst-case execution time can still be scheduled. The resulting bounds also lead to an interesting decision problem in allocating execution budgets to the servers. Main Contribution. We derive expected tardiness bounds for tasks whose execution costs are defined by a probability distribution, instead of by a deterministic worst-case execution time, under the scenario where those tasks are executed on simple sporadic servers. Our bounds are applicablf the expected total utilization is less than the system s capacity, even if the system is over-utilized in the worst case or does not have a worst case. The tardiness bounds depend on the execution-time distributions only through the mean and variance of execution times, and through other terms that are on the order of the mean execution time, not on the order of worst-case execution time. The result is a significant improvement over the expected tardiness bounds given in [8]. Organization. The remainder of this paper is organized as follows. In Sec. 2, we formally define the notion of a sporadic stochastic task system, show how such a system can be executed on simple sporadic servers, and give examples of the notation that will be used throughout the paper. Sec. 3 consists of a number of technical results that deal with the uncertainty in such a stochastic system. Sections 4 and 5 present tardiness bounds for the uniprocessor and multiprocessor cases, respectively. These tardiness bounds, and their expected counterparts, are the main results of the paper. In Sec. 6, we consider the problem of how to allocate execution budgets to the sporadic servers. This discussion is followed by a complete example in Sec System Model We consider a system τ = {τ 1, τ 2,..., τ n } consisting of n sporadic stochastic tasks. The sporadic stochastic model is as follows. A sporadic stochastic task τ i is specified by its period, p i, and its execution time distribution function G i x), which gives the probability that a job of τ i requires no more than x time units to execute. We require such a distribution to have finite mean and variance. Any of the standard probability distributions used for modeling, such as uniform, exponential, Weibull, etc., have this property. Moreover, in this paper we explicitly do not require these tasks to have a worst-case execution time WCET). We denote the expected, or mean, execution time of τ i as ē i. We denote the jth job of τ i by τ i,j. We denote the actual execution time of τ i,j by X i,j then, X i,j is a random variable that is distributed according to the cdf G i x)). We denote the release time of τ i,j by r i,j and the deadline of τ i,j by d i,j. Throughout this paper, all deadlines are assumed to bmplicit; that is, d i,j = r i,j + p i. The notion of a sporadic stochastic task is a generalization of that of a sporadic task that is widely used in the real-time scheduling literature, where every task requires c i time units to complete. In particular, we can model the deterministic case using our notation by setting { 1 if x c i, G i x) = 0 if x < c i. We say that a system of sporadic stochastic tasks is stable if and only if its total expected utilization, ū sum = τ i τ ē i p i, is strictly less than the number of processors. We assume throughout the paper that τ is stable. Simple Sporadic Servers. Each task τ i τ will run on a unique simple sporadic server T i, which will carefully control the amount of time that τ i is allowed to execute during each of its periods. This will therefore ensure that worst-case execution times do not appear in the tardiness bound. Let T = {T 1, T 2,..., T n } be a system of simple sporadic servers. Each simple sporadic server T i has period p i and execution budget. While p i is the same as the period of τ i, is a deterministic execution budget: it is not related to G i x), the execution time distribution of τ i, except that we require > ē i strict inequality is explicitly required in one of the results we use later in the paper). The budget of T i is replenished whenever T i is eligible and backlogged. T i is eligiblf and only if it has never had its budget replenished or at least p i time units have elapsed sincts last replenishment. T i is backlogged if and only if thers pending work of τ i. We call T i,j the jth instance of T i. The replenishment time of T i,j is denoted by R i,j. The deadline of T i,j, denoted D i,j, is the earliest time at which

3 T i,j+1 could be replenished, which is D i,j = R i,j + p i i.e., server deadlines armplicit). The budget of T i is consumed whenever it has the highest priority according to the scheduling algorithm in use. For example, if the scheduling algorithm is GEDF, then the budget of T i is consumed whenever it has one of the m earliest deadlines. It should be clear that the replenishments of T i do not necessarily correspond to the releases of τ i. In particular, there are at least as many replenishments of T i as there are releases of τ i. From existing results, if we treat R i,j as a release time and D i,j as a deadline, then T = {T 1, T 2,..., T n } is schedulable as a soft real-time system i.e., each job of T i will receive units of execution time within a bounded amount of time from D i,j ) if i p i m. 2.1 Example Task System Fig. 1b) shows example sporadic stochastic tasks τ 1, with period 5.0 and execution cost drawn from some distribution with mean 2.0, and τ 2, with period 3.0 and execution cost drawn from some distribution with mean τ 1,1 is released at time 0.0 and has execution cost 4.0, τ 1,2 is released at time 6.3 and has execution cost 1.5, and τ 1,3 is released at time 11.3 and has execution cost 2.0. τ 2,1 is released at time 0 and has execution cost 0.8 and τ 2,2 is released at time 3.0 and has execution cost 1.7. The schedule is not shown after time Fig. 1a) shows two servers. T 1 corresponds to τ 1. It has period 5.0 the same as τ 1, and budget 3.0 which exceeds ē 1 ). T 2 corresponds to τ 2. It has period 3.0 and budget 1.0. We can verify that T is schedulable by EDF on a uniprocessor because 3/5 + 1/3 1. We will use the example given in Fig. 1 to illustrate sommportant properties of the considered scheduling approach. Initial Replenishment. Both servers are replenished at time 0 because they are both eligible having never been replenished before) and backlogged because both τ 1 and τ 2 release jobs at that time). The deadlines are set to 5 for T 1 ) and 3 for T 2 ). Consumption Rule. The budgets are consumed according to how the server instances of T are scheduled. In the example, T is scheduled using EDF on a uniprocessor. For example, T 2 begins consuming its budget first at time 0 because T 2,1 has a higher priority earlier deadline) than T 1,1. Idleness. T is scheduled without regard for idleness in τ. Although τ 2,1 finishes executing at 0.8, T 2 continues its consumption, even though this means that the processor is idle. In reality, it would be possible to remove this idleness and improve performance; however, to ease the anal- a) T 1 T 2 b) , ,2 1, ,1 2, Execution Suspension Figure 1: Example servers and sporadic stochastic tasks on a uniprocessor. a) For servers T 1 and T 2, denotes replenishment time and denotes deadline; the budget is shaded for each server. T 1 and T 2 are scheduled using EDF. b) For the sporadic stochastic tasks τ 1 and τ 2, denotes release time and denotes deadline; the actual execution times are shaded, while suspensions are shown in white. ysis we will assume that T is scheduled as if the scheduler knows only the release times of τ. Suspension of Jobs. At time 4, the budget of T 1,1 has been consumed, so τ 1,1 suspends its execution. At time 5, T 1 is eligible, so its budget is replenished, even though τ 1,2 has not yet been released. τ 1,1 resumes executing and continues executing until time 7, when it completes. Replenishment Rule. The budget of a server is replenished only when it is eligible and backlogged. Therefore, a replenishment will not necessarily occur at the next server deadline. For example, T 1 becomes eligible for replenishment at time 10 but is not replenished until time 11.3 because no job of τ 1 can execute until that time.

4 2.2 Remaining Work Process We define the remaining work process W i,k to be the amount of work of τ i due to jobs with deadlines at or prior to D i,k that has not completed by the time T i,k has completed. In a deterministic system, each job of τ i would require only the budget of a single job of the server T i ; in the stochastic system, some jobs will run longer and hence some work will be left over to run after T i has been replenished. It is this amount of work that we keep track of in the remaining work process. For example, in Figure 1, W 1,1 = 1 because thers one unit of work of τ 1, specifically the unfinished part of τ 1,1, which has a deadline at or prior to time 5 but which does not complete by the time T 1,1 completes which is time 4). W 1,2 = 0 because all the work of τ 1 with a deadline at or prior to time 10, namely τ 1,1, completes by the time T 1,2 completes at time 9. To maintain consistency in the analysis, although T i,0 is not defined, we will define D i,0 = 0.0 that is, the deadline of the 0th server instancs 0.0, so the server will be eligible for replenishment for the first time at time 0.0). It follows that W i,0 = 0 because no work of τ has a deadline at or before time Relating Tasks and Servers We define two functions that relate job indices to server indices. Let j) = min{k : r i,j R i,k }. That is, j) is the index of the first server instance that replenishes T i at or after the release of τ i,j. An exampls given in Figure 2. Note that in general T i,j) is not necessarily the jth replenishment of T i, because replenishments of T i may occur more frequently than jobs of τ i are released: for example, if τ i,1 requires more than time units to execute, then as soon as T i,1 completes, it will be replenished and T i,2 will begin, because thers pending work for τ i, regardless of whether τ i,2 has been released. We will use the parenthetical function in conjunction with all of our notation relating to server instances. For example, R i,j) is the replenishment time of T i,j). Additionally, let [k] = min{j : R i,k r i,j < D i,k } Because D i,k R i,k = p i, and τ i can only release one job during its period, there can be at most one job index in the set {j : R i,k r i,j < D i,k }, but it might be empty. That is, [k] is thndex of the job of the sporadic stochastic task τ i, if any, that is released at or after the kth replenishment of T i but before D i,k. If no such job exists then τ i,[k] =. An exampls given in Figure 3. Again, τ i,[k] is not necessarily the kth job of τ i. We will use the square-bracket function in conjunction all of our notation relating to jobs. For example, d i,[k] is the deadline of τ i,[k]. A full summary of notation is given in Table 1. T i i T i, j ) r i, j i, j r i, j 1 i, j 1 T i, j 1) Figure 2: Example of the ) function, which associates one server instance with each job.. T i i R i, k T i, k i, [ k ] R i, k 1 D i, k T i, k 1 T i, k 2 R i, k 2 D i, k 1 i,[ k 2] Figure 3: Example of the [ ] function, which associates at most one job with each server instance. Note that τ i,[k+1] = because no job releases in [R i,k+1, D i,k+1 ). Table 1: Summary of Job and Server Notation. Notation τ i,j r i,j d i,j X i,j [k] T i,k R i,k D i,k j) W i,k Definition jth job of τ i release time of τ i,j deadline of τ i,j execution time of τ i,j random variable) index j to job of τ i s.t. R i,k r i,j < D i,k may be empty) budget of server T i kth instance of T i kth replenishment time of T i deadline of T i,k smallest index k such that r i,j R i,k remaining work of τ i when T i,k completes only counted if deadline D i,k )

5 Lemma 1. Any job of τ i with a deadline at most D i,k completes no later than the actual time at which the server instance T i,k+ Wi,k / completes. Proof. Take an arbitrary job τ i,j where d i,j D i,k. Either τ i,j completes by the time T i,k completes, or it does not. If it does, the result is immediate, because T i,k completes before any later job of T i in particular, T i,k+ Wi,k / ). Otherwise, thers some work remaining on τ i,j when T i,k completes. The amount of such work is no more than W i,k, because W i,k by definition includes all work due to jobs of τ i with deadlines at most D i,k that did not complete by the time T i,k completed. Because all work of τ i is completed sequentially, we can guarantee that the remaining work of τ i,j is completed once T i has executed for at least W i,k time units following the completion of T i,k. Because each instance of T i executes for time units when thers pending work of τ i, this means that the remaining work of τ i,j will complete no later than the time when T i,k+ Wi,k / completes. For example, in Figure 1, τ 1,1 has a deadline no later than D 1,1 = 5, and W 1,1 /e 1 = 1. By Lemma 1, τ 1,1 should complete no later than the time that T 1,2 completes, namely time 7. Indeed, we see that this is the case, as τ 1,1 completes at time 6. 3 Analysis of the Remaining Work Process This section consists of technical results that lead to a bound on the expected value of the remaining work process. Lemma 2. The remaining work process satisfies W i,0 = 0 1) W i,k = max{0, W i,k 1 + Y i,k }, for k = 1, 2,... 2) where Y i,k = { X i,[k] if τ i,[k] exists 0 otherwise. Proof. First, observe that prior to the first release, thers clearly no remaining work, so 1) holds. Next, we argue that only one job of τ i, namely τ i,[k], may add to the remaining work that is counted in W i,k but not in W i,k 1. This will justify the addition of Y i,k and not some larger amount) to W i,k 1 in 2). To prove this point, first note that any work that is counted in W i,k but not in W i,k 1 must by definition have a deadlinn D i,k 1, D i,k ]. If D i,k D i,k 1 = p i, then T i,k was replenished at D i,k 1, and clearly only one job of τ i could have been released in D i,k 1, D i,k ], because jobs of τ i have a minimum inter-release time of p i. On the other hand, if D i,k D i,k 1 > p i, then it must have been the case that at D i,k 1, T i was not backlogged; otherwise, it would have been replenished right away. By the same argument, no job of τ i could have been released until at least D i,k p i. Because jobs of τ i have a minimum inter-release time of p i, exactly one job of τ i is released in D i,k 1, D i,k ]. Finally, we justify the subtraction of in 2): it is clear that between the completion of T i,k 1 and the completion of T i,k, at most time units of work is done on τ i namely, the budget T i,k ). However, note that we are subtracting even though we have stated that at most work is done. The case where strictly less than work is done on jobs of τ i is the case where thers strictly less than work remaining to do on those jobs. For this reason, we have applied the max operator, which will ensure that the remaining work never becomes negative. It would be difficult to give a bound on the expected amount of remaining work directly, because Y i,k is sometimes an execution time and sometimes zero, and successive values of Y i,k cannot be assumed to bndependent. In order to solve this problem, we will construct a new process where Y i,k is replaced with a similar term whose values arndependently and identically distributed iid). Define the process Z i,k as follows: Z i,0 = 0 3) Z i,k = max{0, Z i,k 1 + V i,k }, for k = 1, 2,... 4) where V i,k = { X i,[k] U i,k if τ i,[k] exists otherwise, and U i,k is distributed according to the cdf G i x) and is independent of {X i,j, j = 1, 2,...}. The next lemma relates this new process with the remaining work process. Lemma 3. W i,k Z i,k for all i, k. Proof. We have constructed {Z i,k, k = 1, 2,...} so that it is identical to {W i,k, k = 1, 2,...} with the exception that we are adding Y i,k in one case and V i,k in the other. However, we have coupled Y i,k and V i,k so that Y i,k V i,k for all i, k: if τ i,[k] exists then they are both equal to the execution time of τ i,[k]. Otherwise, Y i,k is zero and V i,k is a non-negative random variable. The result then follows by induction on k Note that for all k, V i,k is iid according the cdf G i x). In order for Lemma 3 to hold, it is important that we have a coupling between the values of V i,k and Y i,k ; in other words, when τ i,[k] exists, then Y i,k and V i,k are not only identically distributed, but they have the same value.

6 The key difference between {Z i,k, k = 1, 2,...} and {W i,k, k = 1, 2,...} is thndependence of successive values of V i,k. This property will help us characterize the limiting distribution of {Z i,k, k = 1, 2,...}, and ultimately give an upper bound on its expected value, which will in turn be an upper bound on the expected value of {W i,k, k = 1, 2,...}. Lemma 4. {Z i,k, k = 1, 2,...} has a limit Z i, as k.. Proof. As k increases, the distribution of Z i,k has a limit if and only if E V i,k ) < 0 [6]. This is true because by definition, we required > ē i. Lemma 5. [4, p. 474] Suppose that S n, n = 1, 2,... is drawn independently from a distribution with mean µ S and variance σs 2, and T n, n = 1, 2,... is drawn independently from a distribution with mean µ T and variance σt 2. Assume µ S > µ T. Let W 0 = 0, and W n = max{0, W n 1 + T n S n }. Let W = lim W n be the n limit in distribution) of W n. Then E W ) Lemma 6. E Z i ) σ 2 S + σ2 T 2µ S 1 µ T /µ S ). σ2 i 2e. i ē i) Proof. 4) is an example of Lindley s recursion, which describes the waiting timn a queue: the waiting time of the kth customer is equal to the waiting time of the k 1)st customer, plus the service time of the k 1)st customer, minus the amount of time between the two customers arrivals because the kth customer does not wait before he arrives, while the k 1)st customer does). In other words, if there were a queueing system where service times were {V i,1, V i,2,...} and customers arrived every time units, then the waiting time of the kth customer would be Z i,k. By applying the known upper bound given in Lemma 5 to the limiting distribution of this process, we find the upper bound on the expected value of Z i to be e 1 i σi 2 21 ē i e 1 i ), 5) which after simplifying yields the result note that in applying Lemma 5, σ 2 T = 0 because is a constant). We now use Lemma 4, i.e., the fact that Z i has a limiting distribution. This distribution will bmportant from a theoretical standpoint becaust will allow us to create yet another process, which will still upper-bound W i,k but which behaves like Z i for all k, not just as k. {Z i,k, k = 1, 2,...} is a Markov process becausts future evolution depends on its history only through its present state: Z i,k depends only on Z i,k 1, and V i,k, which is independent of everything else. Therefore, Z i,k does not depend on Z i,k 2, Z i,k 3, etc. Let π i,k x) be the probability density function of Z i,k. The kernel of Z i,k [7, p. 59] is a probability transition function K ) that satisfies π i,k x) = K i x, y)π i,k 1 y)dy 6) As k increases, Z i,k approaches its limit Z i. Z i has probability density function π i x), which does not depend on k. Therefore, π i x) satisfies π i x) = K i x, y)π i y)dy. 7) This leads us to the formulation of a process { Z i,k, k = 1, 2,...}, which has distribution π i x) for all k: Z i,0 is distributed according to the pdf π i x) 8) Z i,k = max{0, Z i,k 1 + V i,k }, for k = 1, 2,... 9) Lemma 7. Z i,k Z i,k, for all i, k. Proof. First, observe that Z i,0 = 0, while Z i,0 is drawn from a non-negative probability distribution π i ). Therefore, Z i,0 Z i,0, so the lemma holds for k = 0. Now, suppose that the lemma holds for some arbitrary k 1, i.e., Z i,k 1 Z i,k 1. We will show that the lemma holds for k. Z i,k = max{0, Z i,k 1 + V i,k } max{0, Z i,k 1 + V i,k } = Z i,k. The result follows by induction. ) Lemma 8. E Zi,k = E Z i ) for all k. Proof. We show that Z i,k has distribution π i ) for all k. The result immediately follows, because Z i has the same distribution. First observe that Zi,0 is drawn from the distribution π i ), by definition, so the claim holds for k = 0. Now, suppose that Zi,k 1 has distribution π i ) for some arbitrary k 1. Then the same holds for k: π i,k x) = K i x, y)π i,k 1 y)dy = K i x, y)π i y)dy = π i x).

7 Here, the first equality is simply a restatement of 6), the second equation is a result of thnductive hypothesis, and the third equation follows from 7). The result follows by induction. By combining Lemmas 3, 6, 7, and 8, we have the following result, which is the main result of this section. Theorem 1. E W i,k ) σ 2 i 2 ē i ). The result of Theorem 1 makes intuitive sense: as the variancn execution times increases, on average there will be more work that spills over into the next instance of T i ; moreover, as the budget gets larger relative to ē i, there would be more room for error to accommodate tasks of τ i that run longer than average. 4 Tardiness Bound: Uniprocessor Case Recall that the main goal of this paper is to give expected tardiness bounds for the tasks of τ. We will now build on our initial result in Lemma 1 and apply the results of the previous section to do so in the uniprocessor case. In the special case where m = 1, T is schedulable using the EDF algorithm such that no instance misses its implicit deadline; that is, no later than p i time units after T i,k is released, it will have been allocated time units on the processor. Lemma 9. When T is scheduled on a uniprocessor using EDF, the completion time of T i, k+wi,k / is no later than D i,k + W i,k / p i. Proof. In the case where W i,k = 0, the lemma simply states that T i,k completes by D i,k, which follows immediately from the optimality of EDF on a uniprocessor. In the case where W i,k > 0, we have R i,k+1 = p i + R i,k because T i is eligible and backlogged, and replenishments of T i continue to occur every p i time units until all remaining work of τ i, including the work in W i,k, is completed. Therefore, R i, k+wi,k / occurs W i,k / p i time units after R i,k does; i.e., at time D i,k + W i,k / 1) p i. Because T is scheduled using EDF, T i, k+wi,k / completes no later than its deadline, which is p i time units later than its replenishment time, i.e., at time D i,k + W i,k / p i. Lemma 10. If τ i,j is tardy, then D i,j) < d i,j + p i. Proof. First note that if τ i,j is tardy, then it must be the case that T i is backlogged throughout [r i,j, d i,j ); otherwise, there would be some timn [r i,j, d i,j ) where T i was not backlogged but τ i,j had not yet finished, which is impossible. Because T i is replenished every p i time units whilt is backlogged, there must be exactly onnstance of T i that receives its replenishment in [r i,j, d i,j ). That instance will be T i,j) in our notation; hence, R i,j) [r i,j, d i,j ) and therefore D i,j) [r i,j + p i, d i,j + p i ). Lemmas 9 and 10 lead to the two main results of this section. One result gives an upper bound on the actual tardiness of a given job; the other gives an upper bound on the expected tardiness of a given job. The first result is an actual tardiness bound, expressed in terms of the remaining work; that is, if we calculate the values of {W i,k, k = 1, 2,...}, which requires knowing the execution times of each job, we can calculate an upper bound on the tardiness of any job τ i,j. Theorem 2. If τ i runs on the server task T i and T is scheduled on a uniprocessor using EDF, then the tardiness of τ i,j is less than ) Wi,j) + 1 p i. Proof. From Lemma 1, we know that any job of τ i with deadlins at most D i,k completes no later than the actual time at which the server job T i,k+ Wi,k / completes. By definition, the deadline of τ i,j is no more than D i,j), which satisfies the requirement to use Lemma 1, and so τ i,j finishes no later than when T i,j)+ Wi,j) / does. Lemma 9 tells us that T i,j)+ Wi,j) / finishes no later than time D i,j) + W i,j) / p i, which by Lemma 10 is less than d i,j + p i + W i,j) / p i, which gives the required tardiness bound. The result of Theorem 2 is not particularly useful in a practical sense unless all execution times are known. However, using the result of Theorem 1, we can obtain the expected value of the tardiness bound. Theorem 3. If τ i runs on the server task T i and T is scheduled on a uniprocessor using EDF, then the expected tardiness of τ i,j is less than σi 2 ) 2 ē i ) + 2 p i. Proof. We simply take the expected value of the tardiness bound given in Theorem 2, using the result of Theorem 1. Hence, the expected tardiness of τ i,j is less than ) ) Wi,j) E + 1 p i ) ) Wi,j) E + 2 p i ) ) E Wi,j) + 2 p i σ 2 ) i = 2 ē i ) + 2 p i.

8 Note that we cannot bring the expected valunside the ceiling operator because the ceiling operator is non-linear, so we must upper bound it by adding one. 5 Tardiness Bound: Multiprocessor Case The same concepts we used in the previous section to give tardiness bounds for τ scheduled on simple sporadic servers on a uniprocessor can be extended to the multiprocessor case. In fact, only Lemma 9, Theorem 2, and Theorem 3 apply specifically to a uniprocessor. In this section, we will fill in the missing pieces necessary to derive a tardiness bound on a multiprocessor. A number of scheduling algorithms, such as GEDF, can schedule T on a multiprocessor with bounded tardiness. Formally, let S be a global scheduling algorithm. Then the task system T can be scheduled using S on a multiprocessor with bounded tardiness if and only if BT, S) = {B 1 T, S), B 2 T, S),..., B n T, S)} such that the tardiness of an arbitrary instance T i,k is at most B i T, S). For example, B i T, GEDF) = e k e min m +, p k T k E max T k U max e k where E max is the set of m 1 tasks with largest execution times, U max is the set of m 1 tasks with largest utilization /p i ), and e min is the smallest execution time of any task note that somewhat tighter bounds for GEDF have been proved [2, 3]). In particular, any algorithm with windowconstrained priorities has bounded tardiness [5]. Lemma 11. When T is scheduled on a multiprocessor using algorithm S, the completion time of T i, k+wi,k / is no later than D i,k + W i,k / p i + B i T, S). Proof. In the case where W i,k = 0, the lemma simply states that T i,k completes by time D i,k + B i T, S), which is true by definition. In the case where W i,k > 0, we have R i,k+1 = p i + R i,k because T i is eligible and backlogged), and successivnstances of T i are released p i time units apart until all the remaining work of τ i, including the work in W i,k, is completed. Therefore, T i, k+wi,k / is released W i,k / p i time units after T i,k is, i.e., at time D i,k + W i,k / 1) p i. Because T is scheduled using an algorithm with bounded tardiness, T i, k+wi,k / completes no later than its deadline plus B i T, S). Sincts deadlins p i time units later than its release time, thnstance completes no later than time D i,k + W i,k / p i + B i T, S). Now that we have proven Lemma 11, which is analogous to Lemma 9, the following two theorems follow immediately their proofs ardentical to those of Theorem 2 and 3, so they are omitted). Theorem 4. If τ i runs on the server task T i and T is scheduled on a multiprocessor using algorithm S, which has bounded tardiness, then the tardiness of τ i,j is less than Wi,j) ) + 1 p i + B i T, S). Theorem 5. If τ i runs on the server task T i and T is scheduled on a multiprocessor using algorithm S, which has bounded tardiness, then the expected tardiness of τ i,j is less than σi 2 ) 2 ē i ) + 2 p i + B i T, S). In the expected tardiness bound of Theorem 5, the term B i T, S) will not include worst-case execution times, because T consists of servers with defined execution budgets {, i = 1, 2,..., n} that depend on ē i. In fact, worstcase execution costs never enter into our analysis. This is a huge practical advantage: even if worst-case execution costs exist which is not required), we do not have to know them in order to compute the tardiness bound. The tardiness bound depends on the distribution of execution times only through mean and variance. 6 Allocation of Server Budgets In this section, we address the selection of server budgets {, i = 1, 2,..., n}, which was deferred earlier in order to emphasize the analysis. We began our derivation by assuming that we were given budgets {, i = 1, 2,..., n} such that ē i < 1 for all i; however, thers certainly not a unique choice of such values. The tardiness bounds given in Theorems 4 and 5 both depend on the values of {, i = 1, 2,..., n} in a nonlinear way. Moreover, if S is an algorithm with window-constrained priorities, as defined in [5], then B i T, S) depends on {, i = 1, 2,..., n} in a way that is nonlinear, because B i T, S) depends on the m 1 or m 2 largest values in {, i = 1, 2,..., n}. For these algorithms thers little hope for finding an optimal choice of {, i = 1, 2,..., n} to minimize the tardiness bound. Hence, we will instead present two heuristic methods to determine values of {, i = 1, 2,..., n} that will give good tardiness bounds. Proportional Execution Heuristic. A simple heuristic for assigning server task execution times uses the proposition that a server s execution budget should be proportional to its assigned sporadic stochastic task s average execution

9 time. To determine the server execution budgets, we simply let = min{p i, αē i } for some 1 < α m ū sum. The first inequality is necessary because we must have > ē i for all i for expected tardiness to be finite, and the second inequality is sufficient to guarantee i /p i m, which is needed for T to be schedulable. The proportional execution heuristic is simple but it does not account for why we even need to have > ē i in the first place variancn execution times. If a certain sporadic stochastic task has little variation in its execution time from one job to the next, its corresponding server task may need to have an execution time that is only slightly larger than what the sporadic stochastic task requires on average; on the other hand, another sporadic stochastic task whose execution times vary wildly from job to job will require a server task with longer execution times in order to have a low tardiness bound. This intuition leads us to the variance-based heuristic. Variance Based Heuristic. To determine server execution budgets, set = min{p i, ē i + βσ i }, with 0 < β m ū sum σ i. i p i Here, the first inequality is necessary because we must have > ē i for all i the expected tardiness to be finite, and the second inequality is sufficient to guarantee i /p i m, which is needed for T to be schedulable. To see why the two different heuristics might be useful for different types of task systems, we examine thmpact of the variability of execution times on the expected tardiness bounds for the uniprocessor case. Specifically, we look at the relationship between the mean and variance of execution times, treating other parameters as if they are constant. If we examine the expected tardiness bound given in Theorem 3, we notice that with the variance-based heuristic, assuming ē i + βσ i p i, the expected tardiness bound given in Theorem 3 is σi 2 ) 2ē i + βσ i )ē i + βσ i ē i ) + 2 p i, which reduces to ) 1 2β ēi σ i + β) + 2 p i. Therefore, if we treat p i as a constant, the size of this bound will be on the order of σi ē i. This ratio is known as the coefficient of variation of the execution times. Table 2: Example Sporadic Stochastic Task System τ. Task p i ē i WCET σi 2 ū i τ τ τ τ τ τ τ On the other hand, with the proportional execution heuristic, assuming αē i p i, we have σi 2 ) 2αē i αē i ē i ) + 2 p i, which reduces to σi 2 ) 2αē p i ; i α 1) hence, if we treat p i as a constant, the size of this bound will be on the order of σ2 i, or the square of the coefficient ē 2 i of variation. This analysis suggests that when the coefficient of variation is less than onndicating low variability in execution times), the proportional execution heuristic is likely to perform better; on the other hand, when the coefficient of variation is more than onndicating high variability in execution times), the variance-based heuristic is likely to perform better. For comparison, an exponential distribution has a coefficient of variation of one. These conclusions fit with our intuition that as variance gets larger, it would be mormportant to includnformation about the variancn determining server budgets. In the multiprocessor case, these results are less clear: B i T, S) will often depend on {, i = 1, 2,..., n} in ways that are hard to analyze. Nonetheless, intuition leads us to believe that it may still be useful to have more than one heuristic for determining {, i = 1, 2,..., n}. 7 Example Consider the task system in Table 2 on a four-core platform. This is the same running example given in [8]. Each task has a worst-case execution time greater than its period, so it would be considered unschedulable by [2, 5]. However, since the total expected utilization is 3.2, which is less than 4.0, and each task s expected utilization is less than one, τ is stable as a sporadic stochastic task system. The results of applying Theorem 5 are shown in Tables 3 and 4 for { } values determined with the proportional execution heuristic and the variance-based heuristic, respectively, with GEDF as the scheduling algorithm for T. These tardiness bounds are clearly superior to those given

10 Table 3: Expected tardiness bounds from this paper and [8] for tasks from Table 2. Server budgets based on proportional execution heuristic with α = 1.25 the largest value possible for T to be schedulable). B it, Expected Expected Task GEDF) Tardiness Tardiness [8] τ τ τ τ τ τ τ Table 4: Expected tardiness bounds from this paper and [8] for tasks from Table 2. Server budgets based on variancebased heuristic with β = 0.59 the largest value possible for T to be schedulable. B it, Expected Expected Task GEDF) Tardiness Tardiness [8] τ τ τ τ τ τ τ in [8], which are also shown in Tables 3 and 4. Under execution budgets assigned by the variance-based heuristic, the task with the largest expected tardiness, τ 6, is guaranteed not to miss its deadline by more than time units on average; in [8], no task in τ could be proved to have an expected tardiness bound of less than time units, plus its worst case execution time. This contrast emphasizes the point that the expected tardiness bounds in [8] are on the order of worst-case execution times, while the expected tardiness bounds given by Theorem 5 are on the order of average execution times. 8 Conclusion We considered a scheduling policy where sporadic stochastic tasks are scheduled on simple sporadic servers, with predetermined execution budgets. We derived expected tardiness bounds for the uniprocessor case assuming severs are scheduled using EDF) and the multiprocessor case assuming that servers are scheduled using a global algorithm with bounded tardiness). The expected tardiness bounds in this paper improve on those given in [8] because they do not depend on worst-case execution costs; indeed, such worst-case execution costs need not even exist. A major implication of this paper for scheduling soft real-time systems is that the parameters needed to schedule the task system and determine a tardiness bound mean and variance of execution times) can be easily estimated from observational data in an unbiased way. This reduces the need to perform timing analysis for tasks where bounded tardiness is acceptable e.g., multimedia decoding). Such tasks can effectively be executed on simple sporadic servers in a predictable way. Future work on scheduling sporadic stochastic tasks is needed to address thssue of dependencies. We assumed that job executions werndependent of one another. This assumption is likely to only be valid for very simple types of tasks. In real systems, complex dependencies such as critical sections may occur. Although extensive research has been done to address dependencies in worstcase analysis, new modeling techniques may be needed to avoid re-introducing worst-case terms e.g., worst-case non-preemptive section lengths) into our analysis. References [1] J. Calandrino, J. H. Anderson, and D. Baumberger. A hybrid real-time scheduling approach for large-scale multicore platforms. In Proceedings of the 19th Euromicro Conference on Real-Time Systems, July [2] U. C. Devi and J. H. Anderson. Tardiness bounds under global EDF scheduling on a multiprocessor. In Proceedings of the 26th IEEE Real-Time Systems Symposium, [3] J. Erickson, S. Baruah, and U. C. Devi. Improved tardiness bounds for global edf. In Proceedings of the EuroMicro Conference on Real-Time Systems ECRTS), [4] D. P. Heyman and M. J. Sobel. Stochastic Models in Operations Research, volume 1. McGraw-Hill, [5] H. Leontyev and J. H. Anderson. Generalized tardiness bounds for global multiprocessor scheduling. In Proceedings of the 28th IEEE Real-Time Systems Symposium, [6] D. V. Lindley. The theory of queues with a single server. Mathematical Proceedings of the Cambridge Philosophical Society, 482), [7] S. Meyn and R. L. Tweedie. Markov Chains and Stochastic Stability. Cambridge University Press, [8] A. F. Mills and J. H. Anderson. A stochastic framework for multiprocessor soft real time scheduling. In Proceedings of the 16th IEEE Real-Time and Embedded Technology and Applications Symposium, 2010.