Task assignment in heterogeneous multiprocessor platforms

Transcription

1 Task assignment in heterogeneous multiprocessor platforms Sanjoy K. Baruah Shelby Funk The University of North Carolina Abstract In the partitioned approach to scheduling periodic tasks upon multiprocessors, each task is assigned to a specific processor and all jobs generated by a task are required to execute upon the processor to which the task is assigned. In this paper, the partitioning of periodic task systems upon uniform multiprocessors multiprocessor platforms in which different processors have different computing capacities is considered. Partitioning of periodic task systems requires solving the bin-packing problem, which is known to be intractable (NP-hard in the strong sense). Sufficient utilization-based feasibility conditions that run in polynomial time are derived for ensuring that a periodic task system can be successfully scheduled upon such a uniform multiprocessor platform. 1 Introduction In hard-real-time systems, jobs have deadlines associated with them, and it is imperative for the correctness of the application that all jobs complete by their deadlines. In multiprocessor realtime systems, there are several processors available upon which these jobs may execute: all the processors have exactly the same computing capacity in identical multiprocessors, while different processors may have different speeds or computing capacities in uniform multiprocessors. A periodic real-time task T is characterized by an execution requirement e and a period p, and generates an infinite sequence of jobs with successive jobs arriving exactly p time units apart, and Supported in part by the National Science Foundation (Grant Nos. CCR , CCR , CCR , and ITR ). 1

2 each job needing to execute for e units by a deadline that is p time units after its arrival time. A sporadic real-time task is similar, except that the period parameter now specifies the minimum, rather than exact, temporal separation between the arrival of successive jobs. A periodic/ sporadic task system consists of several periodic/ sporadic tasks. We restrict our attention in this paper to preemptive scheduling i.e., we assume that it is permitted to preempt a currently executing job, and resume its execution later, with no cost or penalty. Different preemptive multiprocessor scheduling algorithms for scheduling systems of periodic/ sporadic tasks may restrict the processors upon which particular jobs may execute: partitioned scheduling algorithms require that all the jobs generated by a particular task execute upon the same processor, while global scheduling algorithms permit different jobs of the same task to execute upon different processors (or indeed, allow a job which has been preempted while executing upon a processor to resume execution upon the same or a different processor). Global scheduling algorithms are predicated upon the assumption that it is relatively inexpensive to migrate the state associated with a periodic task (or an executing job) from one processor in the platform to another during run time. If this assumption is not valid, then the partitioned approach to multiprocessor scheduling is preferred. In this approach, the tasks comprising the task system are partitioned among the various processors comprising the multiprocessor platform prior to run-time; at run-time, all the tasks assigned to a single processor are scheduled upon that processor using some uniprocessor scheduling algorithm. This research. In previous work [3], we have studied the global scheduling of real-time systems comprised of periodic and sporadic tasks upon uniform multiprocessors. We obtained utilizationbased conditions for determining whether a given system τ of sporadic and periodic tasks is successfully scheduled upon any specified uniform multiprocessor system using the Earliest-Deadline first scheduling algorithm (EDF). In this paper, we study the partitioned approach to scheduling systems of periodic and sporadic tasks upon uniform multiprocessor platforms. In order to completely specify a partitioned scheduling scheme, we must specify two separate algorithms (i) the task assignment algorithm 2

3 that determines which processor each task be assigned to, and (ii) the (uniprocessor) scheduling algorithm that executes on each processor and schedules the tasks assigned to the processor. Once again, EDF is our choice for the scheduling algorithm given the known optimality of EDF upon preemptive uniprocessors, this is clearly the best scheduling algorithm that could be used to schedule the individual processors once tasks have been assigned (provided that no additional constraints are placed upon the system design see Section 9 for a discussion). The choice of a task assignment algorithm for partitioning the tasks among the available processors is not quite as clear even in the simpler case of identical multiprocessors, optimal task assignment requires solving the bin-packing problem which is known to be NP-complete in the strong sense (and hence unlikely to be solved efficiently). Hence, this paper focuses mainly upon the partitioning problem. Among our contributions here are the following. We prove in Section 3 that the global and partitioned approaches to EDF scheduling on uniform multiprocessors are incomparable, in the sense that there are uniform multiprocessor real-time systems that can be scheduled using global EDF but not partitioned EDF, and there are (different) uniform multiprocessor real-time systems that can be scheduled using global EDF but not partitioned EDF. Hence, it behooves us to study both kinds of EDF scheduling algorithms, since different ones are more suitable for different systems. However, the problem of determining an optimal partitioning of a given collection of periodic tasks on a specified uniform multiprocessor platform is intractable NP-hard in the strong sense (Theorem 1). This intractability result motivates the search for approximation algorithms. Accordingly in Section 4, we extend approximate bin-packing algorithms to develop a polynomial-time approximation scheme (PTAS) for task assignment on uniform multiprocessors. This PTAS allows the system designer to trade system computing capacity for speed of analysis there is a parameter δ with value between 0 and 1 that the system designer gets to choose, with the tradeoff that the partitioning algorithm runs faster for smaller δ but can guarantee to use only a fraction δ of the computing capacity of the platform. While this approximation algorithm is shown to run in polynomial time for a fixed value of 3

4 δ, its run-time may still be unacceptably high particularly for on-line situations. Hence we propose an alternate partitioning algorithm (in Section 5) and associated utilization-based feasibility test (in Section 7) which, while merely sufficient (rather than exact), has more desirable run-time behavior for on-line situations in the sense that much of the analysis can be done during system design time (instead of during run-time). We provide in-depth analysis of this new feasibility test its run-time complexity, its error bound, etc., and illustrate its working by means of a detailed example (Section 8). In Section 9, we place this research in a larger context of research being conducted at the University of North Carolina and elsewhere, into the uniform multiprocessor scheduling of systems of periodic and sporadic real-time tasks. 2 Model; definitions For the remainder of this paper, we will, unless explicity stated otherwise, assume that π = (s 1, s 2,..., s m ) denotes an arbitrary uniform multiprocessor platform with m processors of speeds s 1, s 2,..., s m respectively, with s 1 s 2 s 3 s m. We use the notation S(π) to denote the cumulative computing capacity of all of π s processors: S(π) def = m i=1 s i. The quantity λ(π) is defined as follows: λ(π) = m max i=1 ( m j=i+1 s ) j s i (1) Periodic task systems. A periodic/ sporadic real-time task T = (e, p) is characterized by the two parameters execution requirement e and period p, with the interpretation that the task generates an infinite sequence of jobs of execution requirement at most e units each, with successive jobs being generated exactly/ at least p time units apart, and each job has a deadline p time units after its arrival time. A system τ = {T 1,..., T n } of periodic or sporadic tasks is comprised of several such tasks, with each task T i having execution requirement e i and period p i. We refer to the quantity e i /p i as the utilization of task T i ; for system τ, U sum (τ) def = T i τ (e i/p i ) is referred to as the cumulative utilization (or simply utilization) of τ, and U max (τ) def = max Ti τ (e i /p i ) is referred to as the largest utilization in τ. 4

5 We will refer to a (uniform multiprocessor platform, periodic/ sporadic task system) ordered pair as a uniform multiprocessor system; when clear from context, we may simply refer to it as a system. The condition, derived in [3], for guaranteeing that periodic/ sporadic task system τ is successfully scheduled to meet all deadlines upon uniform multiprocessor platform π using the global EDF scheduling algorithm is S(π) U sum (τ) + U max (τ) λ(π). (2) That is, the cumulative computing capacity of the uniform multiprocessor platform must exceed the cumulative utilization of the task system by at least the product of the platform s λ-parameter and the task system s largest utilization. 3 Incomparability By requiring that all jobs of each task execute upon exactly one processor, the partitioned approach to scheduling places further restrictions upon the permissible schedules than does the global approach. One may at first therefore assume that global EDF upon uniform multiprocessors is at least as powerful as partitioned EDF, in the sense that any task system schedulable by partitioned EDF upon a given uniform multiprocessor platform will also be successfully scheduled upon the same platform using global EDF. In fact, this turns out to not be true: as we show below, there are periodic/ sporadic task systems that can be scheduled using partitioned EDF, but not global EDF, upon a given uniform multiprocessor platform, and there are (other) periodic/ sporadic task systems that can be scheduled using global EDF, but not partitioned EDF, upon specified uniform multiprocessor platforms. These results motivate us to further study both the global and the partitioned approaches, since it is provably the case that neither one is strictly superior to the other. Lemma 1 There are uniform multiprocessor systems that can be scheduled using global EDF that cannot be scheduled using partitioning. 5

6 Proof: Consider the uniform multiprocessor platform π consisting of 4 processors of computing capacities (8U 4ɛ), (4U 2ɛ), (2U ɛ), and (2U ɛ) respectively, where U is an arbitrary positive number and ɛ is a very small positive number U. For this platform, it can be verified that S(π) = (8U 4ɛ) + (4U 2ɛ) + (2U ɛ) + (2U ɛ) = 16U 8ɛ ( ) and λ(π) = max 2U ɛ = 1 2U ɛ, (2U ɛ)+(2u ɛ) 4U 2ɛ, (2U ɛ)+(2u ɛ)+(4u 2ɛ) 8U 4ɛ Consider now the periodic task system τ comprised of 13 identical tasks, each of utilization U; it may be verified that U sum (τ) = 13U and U max (τ) = U By the EDF-schedulability test of [3] (Equation 2 above), it follows that τ is successfully scheduled upon π by global EDF, since S(π) λ(π) U max (τ) = (16U 8ɛ) 1 U = 15U 8ɛ 13U However, the 13 tasks in τ cannot be partitioned among the 4 processors of π; the fastest processor can handle only 7 tasks, the next-fastest, 3, and the remaining two, one each, for a total of 12 tasks. Lemma 2 There are uniform multiprocessor systems that can be scheduled using partitioning that cannot be scheduled using global EDF. Proof: Let U, D denote positive real numbers. Consider the uniform multiprocessor platform π consisting of 2 processors of computing capacities 2U and U respectively, and the periodic task system τ = {T 1 = (4UD, 2D), T 2 = T 3 = ( UD 2, D)}. Task system τ is successfully scheduled upon π 6

7 using partitioned EDF: simply assign T 1 to the faster processor and the other 2 tasks to the slower processor. To see that global EDF may miss deadlines while scheduling τ, consider the situation when jobs of all three tasks arrive simultaneous (without loss of generality, at time instant zero). The jobs of T 2 and T 3 have earlier deadlines, and are therefore scheduled first. It is straightforward to observe that this will result in the job of T 1 missing its deadline. 4 An approximation algorithm for task assignment Given a uniform multiprocessor platform π = (s 1, s 2,..., s m ) and a periodic/ sporadic task system τ = {T 1 = (e 1, p i ), T 2 = (e 2, p 2 ),..., T n = (e n, p n )}, we wish to determine whether the tasks in τ can be partitioned among the m processors in π such that all the tasks assigned to each processor are schedulable upon that processor using the uniprocessor EDF scheduling algorithm. Unfortunately, this problem is easily shown to be intractable: Theorem 1 Determining whether a uniform multiprocessor system can be successfully scheduled using partitioned EDF is NP-complete in the strong sense. Proof Sketch: Reduce the bin-packing problem to the problem of partitioning on identical multiprocessors. Since identical processors are a special case of the more general uniform multiprocessors, this implies that the more general problem is NP-hard in the strong sense as well. The intractability result (Theorem 1 above) makes it highly unlikely that we will be able to design an algorithm that runs in polynomial time and solves this problem exactly. If we are willing to settle for an approximate solution, however, we show in this section that it is possible to solve the problem in polynomial time. More specifically, we will use results proved by Hochbaum and Shmoys [4, 5] to design a polynomial-time algorithm that, for any uniform multiprocessor system (π, τ) makes the following performance guarantee: For any constant δ of our choosing satisfying 0 < δ < 1, if τ is schedulable using partitioned EDF upon a platform π which consists of the same number of processors as 7

8 π and in which each processor is at least δ times as fast as the corresponding processor in π (i.e., if π = (δs 1, δs 2,..., δs m )), then our algorithm will successfully schedule τ upon π. In other words, if we are willing to waste a fraction (1 δ) of each processor s computing capacity in π and imagine that we instead have a platform in which each processor is only δ times as fast as its actual speed, then our algorithm successfully schedules τ on π provided τ is schedulable using partitioned EDF upon this (imaginary) slower platform. Although our algorithm s performance is approximate in that it may incorrectly fail to schedule task systems that are not schedulable upon π but are schedulable upon π, its deviation from optimality is bounded in the following sense: Any τ that turns out to not be schedulable upon π cannot, by very definition, be successfully scheduled upon π by any algorithm. By choosing the constant δ to be close enough to unity, we can reduce the likelihood that an arbitrary task system falls in this category, at a cost of increased run-time complexity of the algorithm. Bin-packing with variable bin sizes. The problem of bin-packing with variable bin sizes can be formulated as follows: Given a collection of n items of size p 1, p 2,..., p n respectively, can these items be packed into m bins of capacity b 1, b 2,..., b m respectively? I.e., can a given multiset of positive real numbers p 1, p 2,..., p n be partitioned into m multisets of size b 1, b 2,..., b m respectively? 1 A PTAS for bin-packing with variable bin sizes. Since bin-packing with variable bin sizes is a generalization of the bin-packing problem, it, too, is NP-hard in the strong sense. Hochbaum and Shmoys [4, 5] presented a polynomial-time approximation scheme (PTAS) for solving the problem of bin-packing with variable bin-sizes. That is, they proposed a family of algorithms {A ɛ }, ɛ R +, such that each algorithm A ɛ has run-time polynomial in the size of its input (but not in 1/ɛ), and behaves as follows: When given input items of size p 1, p 2,..., p n and bins of capacity b 1, b 2,..., b m, if the items can indeed be packed in the bins, then A ɛ produces a partition of p 1, p 2,..., p n 1 The terminology variable bin sizes is somewhat confusing in that one may expect that the sizes of the bins are variables (permitted to vary). However, this terminology seems to be the accepted standard in the literature and we have chosen to retain it rather than add to the confusion by introducing yet another term for this concept. 8

9 into m multisets of size (1+ɛ) b 1, (1+ɛ) b 2,..., (1+ɛ) b m respectively (i.e., each bin may be over-filled by a fraction ɛ such a packing of the items into the bins is called an ɛ-relaxed packing; if A ɛ fails to produce an ɛ-relaxed packing, then no (actual) packing of p 1, p 2,..., p n into the bins of capacity b 1, b 2,..., b m is possible. That is, A ɛ runs in time polynomial in the size of the input (although not in 1/ɛ) and provides an ɛ-relaxed packing whenever the input has a feasible packing. The run-time complexity of the Hochbaum-Shmoys algorithm [4, 5] is O((2m(n/ɛ 2 ) (2/ɛ2 +3) ) 2/ɛ 2 ). A PTAS for partitioning. Suppose that we are given the specifications of a uniform multiprocessor platform π = (s 1, s 2,..., s m ), a periodic/ sporadic task system τ = {T 1 = (e 1, p 1 ), T 2 = (e 2, p 2 ),..., T n = (e n, p n )}, and a constant δ < 1. Let ɛ p i b i j def = ( 1 δ 1) def = e i /p i, for 1 i n def = δ s j, for 1 j m If the n items of size p 1,..., p n can be packed into bins of capacity b 1, b 2,..., b m, then the algorithm A ɛ of Hochbaum and Shmoys described above produces a partition of p 1, p 2,..., p n into m multisets of size (1 + ɛ) b 1, (1 + ɛ) b 2,..., (1 + ɛ) b m respectively. Since (1 + ɛ) b j = (1 + ( 1 δ 1)) (δ s j) = s j, a partitioning of the tasks in τ among the m processors can be directly obtained from this partition if b i is assigned to the j th bin by A ɛ, then simply assign task T i to the j th processor. On the other hand, if algorithm A ɛ fails to produce such an ɛ-relaxed partition then it must be the case that the tasks in τ cannot be partitioned among m processors of computing capacity (δs 1, δs 2,..., δs m ). Thus, we can use the PTAS of Hochbaum and Shmoys described in Section 4 above to design an algorithm that determines in time polynomial in n and m a partitioning of the tasks in τ upon the processors of π such that each partition can be scheduled to meet all deadlines upon 9

10 its processor using the preemptive uniprocessor EDF scheduling algorithm, provided that such a partitioning of the tasks of τ among m processors of speed (δs 1, δs 2,... δs m ) is possible. 5 The FFD-EDF scheduling algorithm In Section 4 above, we described a PTAS for partitioning the n tasks of a periodic/ sporadic task system τ among the m processors of a uniform multiprocessor platform π, which for any constant δ < 1 is guaranteed to produce a successful partitioning provided that the tasks of τ can be partitioned (by an optimal partitioning algorithm) among processors of speed δ times as fast as the processors in π. This PTAS resolves the important theoretical question of whether an approximate solution to the problem of determining partitioned EDF schedulability can be determine in [ polynomial time. ( ) ] δ 2 However, it can be verified that the run-time expression for this algorithm contains δ in the exponent. Hence for reasonable values of δ, this run-time may be unacceptably high. (For example, choosing δ = 0.9 corresponding to a effective utilization of 90% of each processor s capacity would yield an exponent of , i.e., 813. Clearly, this is unreasonable for even small values of n.) Due to these considerations, it behooves us to consider alternative approaches to partitioning periodic/ sporadic task systems upon uniform multiprocessor platforms, despite the polynomial-time behavior of the approach of Hochbaum and Shmoys. The approach we have adopted, and describe in the remainder of this paper, uses the first-fit-decreasing (FFD) bin-packing heuristic to partition the tasks among the processors, and then uses uniprocessor EDF to schedule the individual processors. First-fit decreasing task assignment. We have chosen to consider the First Fit Decreasing (FFD) bin-packing algorithm for assigning tasks onto processors. The FFD task assignment algorithm (Figure 1) considers tasks in non-increasing order of their utilizations, and processors in non-increasing order of their computing capacities. When a task is considered, it is assigned to the first processor considered upon which it will fit. Let gap(j) denote the amount of remaining capacity available on s i. Therefore, each task T i is assigned to processor s j, where j is the smallest-indexed 10

11 FFD task assignment (τ, π) Let τ = {T 1, T 2,..., T n } denote the tasks, with ei p i ei+1 p i+1 for all i Let π = {s 1, s 2,..., s m } denote the processors, with s j s j+1 for all j 1. for j 1 to m do gap(j) := s j 2. for i 1 to n do 3. Let j o denote the smallest index such that gap(j o ) e i /p i 4. If no such j o exists declare τ FFD-infeasible on π; return 5. Assign T i to processor j o 6. gap(j o ) := gap(j o ) e i /p i 7. end do Figure 1: The FFD task-assignment algorithm. processor with gap(j) e i /p i. If no processors have large enough gap to fit T i, then τ is said to be FFD-infeasible on π. Otherwise, the FFD partitioning algorithm can assign each task of τ to some processor of π without overloading any processors and τ is said to be FFD-feasible on π. The run-time computational complexity of FFD task assignment is O(n log n) (for sorting the tasks in non-increasing order of utilizations) + O(m log m) (for sorting the processors in non-increasing order of capacities) + O(n m) (for doing the actual assignment of tasks to processors), for an overall computational complexity of O(n (log n + m)) for most reasonable combinations of values of n and m. Our use of FFD for task partitioning upon uniform multiprocessor platforms represents a scheduling application of the FFD bin packing algorithm. While the FFD algorithm has been studied in detail for identical bins, less attention has been paid to this algorithm for the variable bin packing problem. The FFD algorithm is known to be a superior bin-packing algorithm for identical bins (e.g., it has the best known competitive ratio when identical bin sizes are considered [6]); therefore, we opted to explore partition scheduling on uniform multiprocessors using FFD to determine the partitioning scheme. 11

12 6 The utilization bound function The utilization bound function of a multiprocessor platform generalizes the utilization bound concept as defined for uniprocessors. The utilization bound of a scheduling algorithm is defined to be the largest utilization such that all periodic (sporadic) task systems with cumulative utilization no larger than this bound are guaranteed schedulable by that algorithm, and there are task systems with cumulative utilization larger than this bound by an arbitrarily small amount that the algorithm fails to schedule. For example, it is known [7] that any periodic task system τ is schedulable upon a single preemptive processor of unit computing capacity using the rate monotonic scheduling algorithm provided U sum (τ) is at most ln , and by EDF provided U sum (τ) at most one; it is also known that there are task systems with utilization (ln 2 + ɛ) that the rate-monotonic algorithm fails to schedule, and task systems with utilization (1 + ɛ) that EDF fails to schedule, for arbitrarily small positive ɛ. Therefore, the utilization bound of rate-monotonic scheduling upon a preemptive uniprocessor is ln 2, and the utilization bound of EDF upon a preemptive uniprocessor is 1. Upon multiprocessor platforms, it has been shown that tighter utilization bounds can be obtained if a priori knowledge of the largest possible utilization of any individual task is known. For instance, it can be shown that the utilization bound of any partition-based algorithm cannot exceed ((m + 1)/2) upon m unit-capacity processors; however, if it is known that no individual task s utilization exceeds U, then a somewhat better bound of 1 + m 1/U 1 + 1/U was proven by Lopez et al. [8]. In the case of global EDF scheduling upon m unit-capacity multiprocessors, the corresponding bound, proven in [9] is m (m 1) U in both cases, the utilization bound increases with decreasing U, and asymptotically approaches m (i.e., the platform capacity) as U 0. We refer to these bounds as utilization bound functions. Definition 1 (Utilization bound function U π (a)) With respect to any scheduling algorithm A, the utilization bound function U π for uniform multiprocessor platform π is a function from 12

13 the real numbers to the real numbers [0, S(π)] with the interpretation that for all real numbers a, any periodic/ sporadic task system τ satisfying U max (τ) a and U sum (τ) U π (a) is successfully scheduled upon π by algorithm A, and there is some task system τ with U max (τ ) a and U sum (τ ) = (U π (a) + ɛ) that is not successfully scheduled upon π by Algorithm A, where ɛ is an arbitrarily small positive number. (That is, a sufficient condition for a periodic/ sporadic task system τ with to be successfully scheduled upon π by algorithm A is that U sum (τ) U π (U max (τ)) ; furthermore, for all a there is some task system with largest utilization equal to a and cumulative utilization larger than U π (a) by an arbitrarily small amount, which is not successfully scheduled by algorithm A on platform π.) If for a particular scheduling algorithm A the associated utilization bound function U π (U) is efficiently determined for any π and any U, then we can easily obtain an efficient utilization-based schedulability test for scheduling algorithm A: to determine whether task system τ is successfully scheduled upon a given platform π by that particular algorithm, simply compute U sum (τ) and U max (τ) this can be done in time linear in the number of tasks in τ and ensure that U sum (τ) U π (U max (τ)). If U π is difficult to compute, an alternative would be to compute an upper bound function for U π a function f such that f(a) U π (a) for all a R +, since U sum (τ) f(u max (τ)) would then also be a sufficient test for determining whether τ is successfully scheduled upon π by algorithm A. (Of course, the closer function f is to function U π, the better this sufficient 13

14 schedulability test is, in the sense that it is less likely to reject as unschedulable task systems that are in fact schedulable.) 7 The utilization bound function of FFD-EDF With respect to FFD-EDF upon uniform multiprocessors, we do not yet have an efficient algorithm for computing the function U π from the specifications of uniform multiprocessor platform π. Rather, in the remainder of this paper we describe an algorithm that, for any given π, precomputes an upper bound on U π (a) for all a in the range (0, S(π)]. While this precomputation is not particularly efficient our algorithm takes time exponential in the number of processors in π notice that the precomputation algorithm needs to be run only once, when the uniform multiprocessor platform is being synthesized. Our vision is that such an upper bound on the utilization bound function will be precomputed and made available with any uniform multiprocessor platform that may be used for partitioned scheduling, in much the same manner that other information about the platform the individual processor speeds, interprocessor migration costs, voltage information, etc., is made available. If this is done, then performing a sufficient schedulability analysis test for task system τ reduces to the linear-time computation of U sum (τ) and U max (τ), followed by table lookup to determine whether the condition U sum (τ) f(u max (τ)) is satisfied. Figure 4 illustrates a utilization bound for the uniform multiprocessor π = (2.5, 2, 1.5, 1). Given any task system τ, if (U max (τ), U(τ)) is below the line shown in the graph (after a minor adjustment), then τ is FFD-EDF-feasible on π. This example is discussed in more detail in Section 8. Our approach in the remainder of this section is as follows. We begin by exploring properties of task systems that are successfully scheduled by the FFD-EDF scheduling algorithm. Based on insights gained from this exploration, we modify the problem slightly so as to greatly reduce the size of the search space. Finally, we present an approximation algorithm for the utilization bound of the modified problem. Consider the FFD task-assignment of any task system τ that is FFD-EDF-infeasible on π. Since we are trying to determine a lower bound on the utilization of infeasible tasks, we are most concerned with the first task that cannot be scheduled. We observe the following about the FFD 14

15 task-assignment of τ prior to attempting to assign the first unschedulable task to a processor. Observation 1 Let τ = {T 1, T 2,..., T n } be any task system that is FFD-EDF-infeasible on π. Assume the tasks of τ are indexed so that u i u i+1 for 1 i < n and let T k be the first task of τ that can not fit on any processor. Thus, τ = {T 1, T 2,..., T k 1 } is FFD-EDF-feasible on π. Let gap(j) denote the gap on the j th processor after the FFD task-assignment of τ. Then for all i, 1 i k, u i > max{gap(j) 1 j m}. (3) Proof Sketch: Since T k can not fit on any of the processors u k must be strictly greater than g. The result follows since FFD sorts tasks according to utilization. This important property is the basis of our approximation algorithm. Based on this observation, we convert any FFD-EDF-infeasible task system τ to another task set τ with a very specific structure this structure can be exploited to find a bound for U π. We call such a task system modular on π. Definition 2 (modular on π) Let π = (s 1,..., s m ) denote an m-processor uniform multiprocessor and let τ = {T 1, T 2,..., T n } denote a task system. Then τ is said to be modular on π if the tasks of τ have at most m + 1 distinct utilizations u 1, u 2,..., u m+1 and there exists a partitioning of the tasks in τ among the m processors of π that satisfies the following properties. 1. For all T i, T j τ \{T n }, if T i and T j are both partitioned onto the k th processor then u i = u j and we denote this utilization u k, 2. for all k m, there are s k /u k tasks of utilization u k partitioned onto the k th processor, and 3. T n fits on the processor with the largest gap. (I.e., u n = u m+1 = max{s j mod u j 1 j m}. This implies that for all j m, u j > u m+1 ).) 15

16 Task systems that are modular on π can be represented by an m-tuple; the m-tuple (u 1, u 2,..., u m) is a valid representation of a modular task system on π if u i > max{s j mod u j 1 j m}. By the 3 rd property in Definition 2 above, the utilization of T n (the task with the smallest utilization) is max{s i mod u i 1 i m}. Therefore, ModUtil(u 1, u 2,..., u m ), the utilization of the modular task system (u 1, u 2,..., u m ), is given by the following equation: ModUtil(u 1, u 2,..., u m ) = S(π) m i=1 (s i mod u i ) + max 1 i m {s i mod u i }. (4) The partition described in the definition of modular task systems (Definition 2 above) might not be produced by the FFD task-partitioning algorithm, since it is not required that u j > u j+1 for all j. Nevertheless, modular task systems are important to us because they are so nicely structured. For small m, the modular tasks systems can be exhaustively searched to approximate a utilization bound. Below we show that we can use modular task systems to find a bound for U π (a). Notice that Property 3 of the modular task system definition bears a close resemblance to Equation 3 (our observation about infeasible task systems). Taking note of this similarity, we can find a modular task system τ that corresponds to any FFD-EDF-infeasible task system τ by first reducing the utilization of τ appropriately until the task system is just about feasible, and then averaging the feasible task system to make it modular on π. Both these steps are described in more detail below. Definition 3 (feasible reduction) Let τ = {T 1, T 2,..., T n } denote a task system that is FFD-EDF- -infeasible on π. Assume the tasks of τ are indexed so that u i u i+1 for all 1 i < n and let T k be the task of τ upon which the FFD task-assignment algorithm reports failure. Let gap(j) denote the gap on the j th processor after performing the FFD task-partitioning algorithm on the first (k 1) tasks of τ and let g def = max{gap(j) 1 j m}. Then τ is an FFD-EDF-feasible reduction of τ if the following holds. If g = 0, τ = {T 1, T 2,..., T k 1 }, otherwise τ = {T 1, T 2,..., T k 1, T g }, where T g is any task with utilization equal to g. 16

17 Thus, the FFD-EDF-feasible reduction of τ relates Equation 3, our observation about infeasible task systems, to Property 3 of modular task systems. However, the FFD-EDF-feasible reduction of τ may not be a modular task system since tasks on the same processor do not necessarily have the same utilization. The following lemma demonstrates how any FFD-EDF-feasible reduction τ can be averaged into a modular task system on π. We restrict our attention to those task systems whose total utilization is strictly less than S(π) because we are exploring these systems to find U π. Since we know that no partitioning algorithm is optimal on multiprocessors, it must be the case that U π < S(π). Therefore, we can ignore any FFD-EDF-feasible reduction whose utilization equals S(π) without reducing the accuracy of our analysis. Lemma 3 Let π = (s 1, s 2,..., s m ) denote a uniform multiprocessor and let τ = {T 1, T 2,..., T n } be a feasible reduction of some FFD-EDF-infeasible task system on π with U(τ) < S(π). Assume that T n has the minimum utilization of the tasks in τ. Consider the FFD task-assignment of τ \ {T n }. Let U i denote the total utilization of the tasks assigned to the i th processor and let n i denote the number of tasks. Thus, u i def = U i /n i is the average utilization of the tasks of τ \ {T n } assigned to the i th processor of π. Then the m-tuple (u 1, u 2,..., u m) is a valid representation of a modular task system. Moreover, any modular task system represented by (u 1, u 2,..., u m) satisfies the following properties. 1. U(τ) = U(τ ), and 2. U max (τ) max 1 i m u i. Proof: We first show that (u 1, u 2,..., u m) is a valid representation of a modular task system on π i.e., u i > max{s j mod u j 1 j m} for all 1 i m. Since U(τ) < S(π) and τ is an FFD-EDF-feasible reduction on π, the utilization of T n must be strictly less than the utilization of any other task in τ. Therefore, for any i, u n must be smaller than u i = U i/n i (since the mean of a set is at least as large as the smallest value in the set). Furthermore, T n fits exactly into the 17

18 largest gap after performing the FFD task-partitioning algorithm on {T 1, T 2,..., T n 1 }. Therefore, u n = max{s i U i 1 i n}. This shows that for any u i, u i > s i U i = s i n i u i 0 (5) i.e., the gap on the i th processor is (s i mod u i ). Thus, u i > u n = max{s j mod u j 1 j m} for all 1 i m, so (u 1, u 2,..., u m) is a valid representation of a modular task system on π. We now show the two conditions hold. Consider any i, 1 i m. The modular partitioning of τ assigns s i /u i tasks to the i th processor. By Equation 5, s i/u i = n i. Therefore, the total utilization of these tasks on the i th processor is n i u i = U i. Thus, U(τ ) = ModUtil(u 1, u 2,..., u m) = n i=1 (n i u i) + max 1 i m {s i mod u i} = U i + u n = U(τ). Thus, Condition 1 holds. Also, u i must be between u 1 and u n (the maximum and minimum utilizations of tasks in τ) because it is the mean of values in the range [u n, u 1 ]. Therefore, Condition 2 must hold. Lemma 3 demonstrates that any FFD-EDF-feasible reduction can be modularized without changing the total utilization or increasing the maximum utilization. As Theorem 2 states, these modular task systems can be used to find a bound for U π (a). Theorem 2 Let π = (s 1, s 2,..., s m ) be any uniform multiprocessor and let M π (a) def = min{u(τ) τ is modular on π and U max (τ) a}. (6) Then U π (a) M π (a) for all a (0, s 1 ]. Proof: By Lemma 3 M π (a) min{u(τ) τ is an FFD-EDF-feasible reduction on π and U max (τ) a}. Since every task system τ that is FFD-EDF-infeasible on π has an FFD-EDF-feasible reduction τ with U(τ ) < U(τ) and U max (τ ) = U max (τ), M π (a) min{u(τ) τ is FFD-EDF-infeasible on π and U max (τ) a} = U π (a). 18

19 Therefore, any task system τ with U(τ) M π (a) and U max (τ) a is FFD-EDF-feasible on π. Because modular task systems have a limited number of distinct utilizations and they have such a rigid structure, for small values of m we can approximate M π (a) by doing a thorough search of valid m-tuples (u 1, u 2,..., u m ) with u i (0, s i ]. Since this is a continuous region, we can not search every possibility within this range. Instead, we allow the utilizations to be chosen from a finite set V. Figure 2 illustrates the approximation algorithm which considers all the valid utilization combinations in the set V m (the set of m-tuples of elements in V ). The function MinUtilGraph(π, V ) finds the graph of M π (a) for a (0, s 1 ]. It calls the function MinUtilLeqA(π, V, a), which returns the value of M π (a) for a specific value of a. Of course, the values in V must be chosen carefully to ensure the approximation is within a reasonable margin of the actual bound. In particular, given any ɛ > 0 we want to find V so that for all a (0, s 1 ], MinUtilLeqA(π, V, a) M π (a) ɛ. Assume that opt= (u 1, u 2,..., u m ) is a modular system with maximum utilization a and U(opt) = M π (a). We wish to choose V so as to ensure MinUtilLeqA(π, V ) will consider some m-tuple (u 1, u 2,..., u m) with maximum utilization no more than a and ModUtil(u i, u 2,..., u m) ModUtil(opt) ɛ. To do this analysis, we need to consider the function (s i mod x) more carefully. Figure 3 illustrates the graph of y = (6 mod x). Notice that y decreases as x increases until x divides 6, at which point (6 mod x) = 0. Once x increases beyond this point, y jumps up to the line y = x and the process repeats. Thus, this graph is a series of straight lines with slope ( n) between the points (6/(n + 1), 6/(n + 1)) and (6/n, 0). The graph of (s i mod x) follows this general pattern for every value s i. We wish to choose V ɛ to ensure that for any two consecutive points x 1 and x 2 and for any x between these two points, (s i mod x) (s i mod x 2 ) < ɛ/(m + 1). (7) Clearly, V ɛ must contain the following set of jump points J π (ɛ) def = 1 i m { si n 1 n s } i(m + 1), n N. (8) ɛ These are all the points where, for some i m, the graph of (s i mod x) suffers a discontinuity. 19

20 function MinUtilGraph(π, V ) % π = (s 1, s 2,..., s m ) is the uniform multiprocessor % V = {v 1, v 2,..., v k } is the set of allowable utilizations in decreasing order U = S(π) while U max > v k % min util is the minimum total utilization % min a is the minimum of the set {U max (τ) U(τ) = U and U max (τ) U max } (min util, min a) =MinUtilLeqA(π, V, U max ) if min util > U draw a line from (U max, U) to (min a, U) U max = min a; U = min util function MinUtilLeqA(π, V, U max ) % uses a recursive function to find the minimum feasible utilization min util = S(π); min a = s 1 % global variables for the recursion for (u 1 in V ) and (u 1 U max )) % call ConsiderNextProc recursively ConsiderNextProc(2, (s 1 mod u 1 ), (s 1 mod u 1 ), u 1 ) return (min util, min a) function ConsiderNextProc(proc,, max gap, gap sum, min util) % there are two exit conditions proc = m + 1 or none of the current tasks fit on proc if ((proc = m + 1) or ((s proc < min util) and ((s proc < max gap) or (max gap = 0)))) util = proc 1 i=1 s i gap sum + max gap a = max{s i 1 i < proc} if ((util < min util) or ((util = min util) and (a < min a))) min util = util; min a = a return % the exit conditions are not yet, consider next processor (proc + 1) for (u proc in V ) and (u proc max{u max, s proc })) ConsiderNextProc(proc + 1, max{max gap, (s proc mod u proc )}, (gap sum + (s proc mod u proc )), min{min util, u proc }) Figure 2: Approximating the minimum utilization bound of modular task systems. 20

21 3 y x Figure 3: The graph of y = 6 mod x In addition, V ɛ must contain points that are close enough to one another to ensure Inequality 7 is satisfied. Recall that the slope of (s i mod x) between (s i /(n + 1), s i /(n + 1)) and (s i /n, 0) is ( n) = s i /x. Clearly, this slope is steepest when s i is maximized and x is minimized i.e., the steepest slope is ( s 1 /(ɛ/(m + 1)) ). Thus, the distance between consecutive points of V ɛ should be no greater than ((ɛ/(m + 1))/ s 1 (m + 1)/ɛ ) ɛ 2 /(s 1 (m + 1) 2 ), so V ɛ should also contain the following points K π (ɛ) def = { ɛ m n ɛ 2 s 1 (m + 1) 2 0 n ( ) s1 (m + 1) 2, n N} ɛ (9) With these points included in V ɛ, the following theorem holds. Theorem 3 Let π = (s 1, s 2,..., s m ) be any uniform multiprocessor. Then for any ɛ, there exists a set V ɛ such that MinUtilLeqA(π, V ɛ, a) M π (a) + ɛ for all a > 0. Moreover, V ɛ = O((m s 1 /ɛ) 2 ). Proof: Let V ɛ = J π (ɛ) K π (ɛ). The first set in V ɛ contains points of the form s i /n in between ɛ/(m + 1) and s 1. The second set is all points that are ɛ 2 /(s 1 (m + 1) 2 ) distance apart in the same range. Notice that V ɛ = S(π) (m + 1)/ɛ + ((m + 1) s 1 /ɛ) 2 = O((m s 1 /ɛ) 2 ). Let (u 1, u 2,..., u m ) be a modular task system with ModUtil(u 1, u 2,..., u m ) = opt. For each i, 1 i m, let u i = min{v V v u i }. We will prove the theorem by showing that 21

22 ModUtilMin(pi,V) ModUtil(u 1, u 2,..., u n) opt + ɛ. We consider two cases depending on the def value of u min = min{u i 1 i n}. Case 1 : u min < ɛ/(m + 1). Recall all processor gaps are smaller than u min. Therefore, ModUtil(u 1, u 2,..., u n ) S(π) (m 1) u min S(π) (m 1) ɛ/(m + 1) > S(π) ɛ. Therefore, MinUtilLeqA(π, V ɛ, a) cannot be greater than M π (a) + ɛ. Case 2 : u min ɛ/(m + 1). Let M = max{s i mod u i 1 i m} and let M = max{s i mod u i 1 i m}. We begin by showing that (u 1, u 2,..., u n) is a valid modular task system i.e., that u i > M for all i. If this condition holds, then ModUtilMin evaluates the utilization of (u 1, u 2,..., u n). Hence, the function can not return a value greater than ModUtil(u 1, u 2,..., u n). Since u j u j and u j > M for all j m, it suffices to show that M M. We do this by showing that (s i mod u i ) (s i mod u i ) for all i m. Consider any i m. If u i = s i /n for some n N then u i V ɛ. Therefore, u i = u i and (s i mod u i ) = (s i mod u i ). Now assume s i /(n + 1) < u i < s i /n for some n N. Since J π (ɛ) V ɛ, it must be the case that s i /(n + 1) < u i s i /n. Therefore, (s i mod x) is decreasing between u i and u i, so (s i mod u i ) (s i mod u i ). Since this holds for all i m, we have shown M M. Thus, (u 1, u 2,..., u m) is a valid modular task system so ModUtilMin(π, V ɛ ) ModUtil(u 1, u 2,..., u m). It remains to show that ModUtil(u 1, u 2,..., u n) opt + ɛ. By our choice of V ɛ, we know that 0 (s i mod u i ) (s i mod u i ) ɛ/(m + 1) for all i m. We will now show that the maximum 22

23 gaps of each system differ by no more than ɛ/(m + 1). Assume that (s l mod u l ) = M. Then M M = max 1 i m {s i s l mod u i} max 1 i m {s i mod u i } = mod u l max 1 i m {s i mod u i } s l mod u l s l mod u l ɛ/(m + 1). Pulling this all together, we have MinModUtil(pi,V) S(π) S(π) ModUtil(u 1, u 2,..., u m) = m S(π) (s i mod u i) + M i=1 m ((s i mod u i ) ɛ/(m + 1)) + M i=1 m (s i mod u i ) + (m ɛ)/(m + 1) + (M + ɛ/(m + 1) = i=1 m S(π) (s i mod u i ) + M + ɛ = i=1 opt + ɛ Corollary 1 Let π be any uniform multiprocessor. For any ɛ > 0, let V ɛ be the set specified in Theorem 3. Let τ be any task system with U(τ) MinUtilLeqA(π, V ɛ, U max (τ)) ɛ. Then τ is FFD-EDF-schedulable on π. The subroutine MinUtilLeqA examines all valid modular task systems whose task utilizations are in V ɛ. Thus the complexity of this subroutine is O( V ɛ m ). The algorithm MinUtilGraph calls MinUtilLeqA at most V ɛ times. Therefore, the complexity of MinModUtil is O( V ɛ m+1 ) = O((m s 1 /ɛ) 2(m+1) ). 23

24 7 M π (a) a 8 Example Figure 4: The graph of M π (a) for π = (2.5, 2, 1.5, 1) with error bound ɛ = 0.1. Figure 4 illustrates the graph that results from executing MinUtilGraph on the uniform multiprocessor π = (2.5, 2, 1.5, 1) with a maximum error of ɛ = 0.1. For a (1, 2.5], the value of MinUtilGraph(π, V ɛ ) returns the value 4.5. By Theorem M π (a) 4.5 for all a (1, 2.5]. Thus, if τ is a task system with U max (τ) (1, 2.5] and U(τ) 4.4, τ is FFD-EDF-feasible on π. As a approaches 0, the value returned by MinUtilGraph(π, V ɛ ) approaches S(π) in a near-linear fashion. This is because when a is very small, the gaps on each processor must also be very small (recall that the gaps are smaller than the task utilizations). In this example V ɛ = 611. Notice this is much smaller than the estimate (m s 1 /ɛ) 2 = 10, 000, which is a worst case estimate. The size of V ɛ depends primarily on m, s 1 and ɛ. The other processor speeds s i, i > 1 also influence V ɛ slightly. See [1] for an exact formulation of this set. 9 Context and Conclusions Because scheduling algorithms typically execute upon the same processor(s) as the real-time task system being scheduled, it is important that the scheduling algorithms themselves not have prohibitively complex runtime behavior. The overhead of both computing the priorities of jobs and of 24

25 global scheduling restricted migration partitioned this research static fixed dynamic Table 1: A classification of algorithms for scheduling periodic task systems upon identical multiprocessor platforms. Priority-assignment constraints are on the x axis, and migration constraints are on the y axis. In general, increasing distance from the origin may imply greater generality. migrating jobs to different processors has a performance cost at run time. To alleviate this cost, system designers often choose to place constraints upon the manner in which job priorities are defined, and also on the amount of job migration that is permitted. Under the assumption that job preemption is permitted (regardless of whether it incurs a cost or not), we have chosen to distinguish among three different categories of uniform multiprocessor scheduling algorithms based upon the freedom with which priorities may be assigned: static priority schemes, fixed priority schemes, and dynamic priority schemes. In static priority schemes, all jobs of a given task have the same priority. In fixed priority schemes, different jobs of the same task may have different priorities, but the priority of a job remains fixed. In dynamic priority schemes, jobs may change priority over time. We also distinguish among three different categories of algorithms based on the amount of interprocessor migration permitted partitioned scheduling algorithms, restricted migration algorithms, and global scheduling algorithms. These two axes of classification are orthogonal to one another in the sense that restricting an algorithm along one axis does not restrict freedom along the other. Thus, there are 3 3 = 9 different categories of scheduling algorithms according to these classifications; these nine categories are shown in Table 1. While the corners of Table 1 represent extremes (e.g., forbidding migrations entirely versus permitting arbitrary migrations, or fixing priorities of entire tasks all at once versus permitting arbitrary variation in each job s priority) the middle choices (i.e., fixed priority, and restricted migrations) represent reasonable mediums. The focus of this paper has therefore been the bottom cell of the cen- 25

26 tral column of Table 1. For the class of partitioned, fixed-priority scheduling algorithms that populate this cell, we have proven that feasibility-analysis is intractable (NP-hard in the strong sense) in general, and have also shown that partitioned fixed-priority scheduling is incomparable with restricted migration fixed-priority scheduling. We have presented Algorithm FFD-EDF, a partitioned fixed-priority scheduling algorithm. We have developed an algorithm that maps any a to its associated bound M π (a). Once this graph has been determined for a given uniform multiprocessor, a feasibility test can be performed in linear time by checking whether a task M π (U max (τ)) U(τ). In prior work [2], we found a similar feasibility test for the fixed-priority global scheduling algorithms. In the future, we plan to examine the third cell of the fixed-priority column fixed priority, restricted migration algorithms. References [1] Baruah, S. K., and Funk, S. Task assignment in heterogenous multiprocessor platforms. Tech. rep., Department of Computer Science, University of North Carolina at Chapel Hill, [2] Funk, S., and Baruah, S. Characteristics of EDF schedulability on uniform multiprocessors. In Proceedings of the Euromicro Conference on Real-time Systems (Porto, Portugal, 2003), IEEE Computer Society Press. [3] Funk, S., Goossens, J., and Baruah, S. On-line scheduling on uniform multiprocessors. In Proceedings of the IEEE Real-Time Systems Symposium (December 2001), IEEE Computer Society Press, pp [4] Hochbaum, D. S., and Shmoys, D. B. Using dual approximation algorithms for scheduling problems: Theoretical and practical results. Journal of the ACM 34, 1 (Jan. 1987), [5] Hochbaum, D. S., and Shmoys, D. B. A polynomial time approximation scheme for scheduling on uniform processors using the dual approximation approach. SIAM Journal on Computing 17, 3 (June 1988), [6] Johnson, D. S. Near-optimal Bin Packing Algorithms. PhD thesis, Department of Mathematics, Massachusetts Institute of Technology, [7] Liu, C., and Layland, J. Scheduling algorithms for multiprogramming in a hard real-time environment. Journal of the ACM 20, 1 (1973),