Multidisciplinary International Conference on Scheduling : Theory and Applications (MISTA 2009) 10-12 August 2009, Dublin, Ireland

MISTA 2009

An Owner-centric Metric for the Evaluation of Online Job Schedules

Uwe Schwiegelshohn

Abstract The paper presents a metric that is well suited to evaluate online job schedules for massively parallel processors. We point out the disadvantages of commonly used metrics like makespan or machine utilization. We suggest to use the well known total weighted completion time metric with an appropriate selection of job weights and show that this metric exhibits many properties that are similar to the properties of the makespan objective. In addition, it also supports the evaluation of online schedules and allows extensions to consider additional job based system policies. Our performance evaluation of this metric is based on competitive analysis.

1 Background The common notation for theoretical scheduling problems (| | ) was introduced by Graham et al. [1] and describes the elds machine environment (), job characteristics ( ), and objective function ( ). The job characteristics dene the feasibility of a schedule while the objective function discriminates the feasible schedules. The objective function is based upon a metric that allows an ordering of the feasible schedules. In practice, it is not always possible to determine which one of two given feasible schedules is better as many real world problems are multi-criteria problems. Moreover, it is sometimes dicult to nd a metric for some objectives, like, for instance, the requirement of a robust schedule that maintains the same or a similar good objective value if some job characteristics change slightly. Nevertheless, in order to design good scheduling algorithms, we need a metric that represents the practical objectives in a suitable fashion. However, after introducing such a metric, we must prevent that this metric becomes an objective for its own sake. Instead we should repeatedly check whether the metric still satises its original purpose. This is particularly true when new or modied scheduling problems with new machine models or new job characteristics appear. Then we should be careful before transferring an old metric to the new problem. But using an established metric often allows us to apply existing algorithms
Uwe Schwiegelshohn Robotics Research Institute, TU Dortmund University E-mail: uwe.schwiegelshohn@udo.edu

557

Multidisciplinary International Conference on Scheduling : Theory and Applications (MISTA 2009) 10-12 August 2009, Dublin, Ireland

and analysis methods. Therefore, it may be benecial to start with a well known metric to obtain rst hints regarding the structure of good schedules. In this paper, we exemplarily consider a simple but practically relevant job scheduling problem: Scheduling of compute jobs on a massively parallel compute system like a cluster. Such a cluster can usually be expressed with the help of the identical machine model Pm and typically executes its jobs in space sharing mode, that is, it exclusively allocates a certain number of processors (or nodes or cores) to a job. The compute jobs may exhibit dierent forms of parallelism, like rigid and malleable, see the denitions provided by Feitelson et al. [2]. Informally, a rigid job keeps the same machine allocation during its execution while a malleable job can increase or decrease its degree of parallelism depending on the availability of machines. However, the workload of a malleable job may be a function of the actual degree of parallelism. If the workload is invariant of the number of allocated processors, we talk about divisible load scheduling, see Bharadwaj et al. [3]. Typically, many users independently submit their jobs to the cluster of a compute center over time. Therefore, the compute system is not aware of any precedence relation between any two jobs even if there is one. Further, we have an online scenario as the compute system has no knowledge about future job submissions. Finally, the system usually does not know the processing time of the job. It is true that many scheduling systems require users to provide runtime estimates for their jobs. But these estimates are supposed to protect resources (and users) from wasting resource time by faulty jobs as a job is typically aborted once it reaches its estimate. Nevertheless, some scheduling approaches like backlling, see Lifka [4], use these estimates to generate better schedules. However, Lee et al.[5] have shown that these estimates are often very inaccurate eectively producing scheduling problems with some nonclairvoyant character. The evaluation of a schedule requires a metric. This metric must satisfy two main conditions: 1. It must appropriately represent the goals of the resource owner and/or the users. 2. It must allow a quantitative evaluation of the schedule. In the job scheduling scenario, users are interested to receive the (correct) results of jobs as early as possible and to pay as little as possible for the (reliable) execution of their jobs. Note that the exact relationship between response time and cost may not be a linear function. For instance, a user may be eager to receive the result before she leaves work in the evening but if this is not possible, it is sucient that the result is available when she arrives next morning. Moreover, the time and the price criteria are likely to interfere with each other generating a bicriteria optimization problem that requires some form of compromise. The problem of dening an appropriate user-centric metric has been subject of previous research, see Lee and Snavely [6]. On the other hand, resource owners want to receive the largest possible return for providing their resources. To this end, they may assign users to dierent user groups and give dierent priorities to these groups according to the agreed price in case of any resource shortage. In this paper, we do not consider the users but the owners point of view and start with the assumption that there are no user priorities, that is, the price for a unit of consumed processor resources is xed. Hence, the owner is mainly interested in a high system utilization. The utilization of a machine within a given time interval is the ratio of the total compute time used by all jobs to the total available compute time. But utilization is traditionally not the method of choice in theoretical job scheduling problems. Instead, the makespan criterion Cmax is commonly selected. As the makespan

558

Multidisciplinary International Conference on Scheduling : Theory and Applications (MISTA 2009) 10-12 August 2009, Dublin, Ireland

of a schedule is the last completion time of any job in this schedule there is a close x relationship to utilization: x percent reduction in the makespan corresponds to 100% x percent increase in utilization. But note that we must compare dierent intervals to determine this change. In addition to the above mentioned major properties, a suitable metric often also possesses secondary characteristics: 1. It allows an easy evaluation. 2. It supports extensions to more complex criteria dened by the participants within the scenario. An easy evaluation is particularly important in online scheduling problems where the schedule does not really end. For instance, if the scheduling system uses a rule based approach, see, for instance, Franke et al. [7], it must continuously evaluate the schedule in order to determine when to switch to another set of rules. In this case, the metric should reliably describe the most recent part of the schedule. Further, once a suitable solution to the scheduling system has been obtained, participants (owner and users) often tend to look for an even better approximation of their actual goals by incorporating secondary objectives. A suitable metric would allow such an extension without requiring a completely new design process. Unfortunately, the secondary goals are not met by the makespan objective for online schedules of parallel machines. For instance, the last job may have a signicant inuence on the quality of the schedule. Let us assume that a schedule achieves 100% utilization for the last k jobs, that is, the schedule has a minimal makespan and optimal load balance. However, the next job immediately changes this picture: Particularly if this next job has a suciently large processing time the resulting makespan may be as bad as a factor of almost 2 away from the optimum for systems with many processors, see Graham [8] and Fig. 1. Note that in Fig. 1, as in all graphical representations of schedules in this paper, the vertical and horizontal axis denote time and machines, respectively. To support a better intuitive understanding of the gures, we represent a rigid parallel job as single rectangle although the processors need not be allocated in a contiguous fashion. Moreover as the makespan metric is based on the completion time of one job only, it cannot be simply extended to address user groups.

(a)

(b)

(c)

Fig. 1 Online schedules with k jobs (a) and with k + 1 jobs (b); optimal makespan schedule with k + 1 jobs (c)

Alternatively, we can directly use utilization as our objective. In order to avoid the rst problem with the makespan metric, we may select an interval that ends at the

559

Multidisciplinary International Conference on Scheduling : Theory and Applications (MISTA 2009) 10-12 August 2009, Dublin, Ireland

actual time. This is a good approach if we have no information about the processing time of actually running jobs (nonclairvoyant scheduling). However, it does not allow the consideration of processing time estimates. Further, it is not possible to extend the utilization metric in a simple fashion to distinguish the jobs of dierent user groups. In this paper, we present a scheduling objective that is well suited to evaluate online job schedules of massively parallel processors. We start with another objective frequently applied in theoretical scheduling problems: Total completion time. It is the sum of the completion times of all jobs in a schedule S . This objective considers each individual job separately but is biased towards some jobs: Fig. 2 shows that the left schedule has a signicant lower total completion time than the right schedule although the utilization in both schedules is the same. Clearly, the total completion time objective favors sequential jobs over parallel jobs if they have the same processing time. Therefore, a user will benet if he can split his parallel job into many sequential jobs although he requires the same total computation time in both cases. The same is true if he splits a long running job into many short running jobs (with precedence constraints).

Cj = 14
4 1

Cj = 43
4 3

Fig. 2 Total completion time of 2 schedules with a parallel und several sequential jobs

However, we are interested in a metric that does not automatically provide a preferential treatment to short or long, parallel or sequential jobs. In our view, a basic owner-centric objective should primarily be neutral regarding job characteristics. In addition, the objective should enable extensions to consider the policy of the specic system. Therefore, we use the total weighted completion time metric with the resource consumption (processing time times parallelism for rigid jobs) of a job being its weight. This metric guarantees the desired neutrality. Then it is up to the system owner to assure preference of certain jobs by modifying the weights accordingly. This modication may be based on any job characteristic. There are only very few results regarding the performance of simple algorithms with respect to this metric. For sequential jobs, this weight selection is similar to the l2 -norm that has already been subject of several studies, see Bansal and Pruhs [9] or Avidor et al. [10]. Schwiegelshohn and Yahyapour [11] have also used this metric to guarantee fairness in preemptive scheduling of rigid parallel jobs. In this paper, we evaluate this metric for nonclairvoyant sequential and rigid parallel jobs on a machine with parallel identical processors (Pm -model). To this end, we use the competitive analysis, that is, we determine for all input sets the maximal deviation of a generated schedule from the corresponding optimal schedule with respect to this metric. The competitive factor is the largest ratio between these two values, see Section 2. We compare this competitive factor with the corresponding value obtained for the conventional makespan objective.

560

Multidisciplinary International Conference on Scheduling : Theory and Applications (MISTA 2009) 10-12 August 2009, Dublin, Ireland

2 Denitions and Previous Results In our basic scenario, we use the Pm machine environment, that is, all m processors of a parallel machine are identical. Occasionally, we also refer to the single machine environment ( = 1) as a reference. Our jobs are either sequential or rigid ( = sizej ). A rigid parallel job Jj requires the concurrent availability of sizej processors during its whole execution. These sizej processors must be exclusively allocated to job Jj . Further, jobs are submitted over time ( = rj ), that is, job Jj is unknown before its release date rj . Again as a reference, we also discuss problems with all jobs being released at time 0. Contrary to other online problems, we do not demand that all sizej processors are assigned to a job Jj at its submission date. Instead the processorjob allocation is delayed until the required number of processors is actually available. Moreover, we assume that the processing time pj of job Jj becomes only known once the job has nished its execution, that is, we consider nonclairvoyant scheduling ( = ncv ). If all jobs are sequential or released at time 0 the problem notation does not use the constraints = sizej or = rj , respectively. Cj (S ) denotes the completion time of job Jj in schedule S . If the schedule is nonambiguous then we omit S . Our primary schedule objective is the total weighted completion time with the weight of job Jj being its resource consumption pj sizej : = pj sizej Cj . As reference problems we use corresponding problems with the makespan objective Cmax = maxj {Cj } that have extensively been discussed in earlier publications. For a given scheduling algorithm, we determine upper bounds for the ratio
j j

pj sizej Cj (S )

pj sizej Cj (OP T )

with S and OP T being the schedules produced by the algorithm

and the optimal schedule, respectively. This bound is called an approximation factor for deterministic scheduling problems and a competitive factor for online problems. Note that this is a worst case evaluation. An algorithm may perform much better in case of a real workload. Nevertheless, a worst case analysis may provide interesting information about possible bad situations. For the total weighted completion time problem on a single processor 1|| wj Cj wj without release dates, a nondelay scheduling in descending order of the Smith ratio pj generates an optimal schedule. We say that a schedule is nondelay, if no processor is kept idle while a job is waiting, see Pinedo [12]. Therefore, any nondelay schedule is optimal for the 1|ncv | pj Cj problem. This also holds for the corresponding online problem 1|rj , ncv | pj Cj while the problem with arbitrary weights (1|rj | wj Cj ) is NP-hard in the strong sense. Concluding, we can state that the objective pj Cj produces the same results as the makespan objective for single processors. Remember that although the processing time is part of the objective, its knowledge is not required by the algorithm. In the next section, we address machines with parallel identical processors.

3 Parallel Machines and Sequential Jobs The problem Pm ||Cmax is strongly NP-hard for m 3. List scheduling with an ar1 bitrary list order guarantees the approximation factor 2 m , see Graham [8]. This approximation factor is tight for nonclairvoyant scheduling. This result also holds for oine and online problems with rigid parallel jobs, see Graham [13] and Naroska

561

Multidisciplinary International Conference on Scheduling : Theory and Applications (MISTA 2009) 10-12 August 2009, Dublin, Ireland

and Schwiegelshohn [14], respectively. The problem Pm || pj Cj is NP-hard as partition reduces to P 2|| pj Cj . List scheduling with an arbitrary list order guarantees a tight approximation factor of 1+2 2 for this problem, see Kawaguchi and Kyan [15]. Schwiegelshohn and Yahyapour [11] showed a competitive factor of 2 for the problem Pm |rj , sizej , ncv | pj Cj if sizej m 2 holds for all jobs. While this demonstrates the existence of a constant competitive factor for the problem Pm |rj , ncv | pj Cj , the gap between the upper bound 2 and the lower bound section, we close this gap signicantly.
1+ 2 2

is still rather large. In this

Theorem 1 List scheduling has a competitive factor of at most 1.25 for the problem Pm |rj , ncv | pj Cj . Before presenting the proof for this problem, we use a lemma that has already been introduced as Corollary 6 in a publication by Schwiegelshohn and Yahyapour [11]: Lemma 1 Let S and OP T be a legal schedule and the optimal schedule of an arbitrary problem instance Pm |rj | pj Cj with n jobs, respectively. We split an arbitrary job Jk into two jobs Jn+1 and Jn+2 such that 0 < pn+1 < pk , pn+2 = pk pn+1 , rn+1 = rk , and rn+2 = rk + pn+1 hold. Schedule S is derived from schedule S by replacing the execution of job Jk with the execution of job Jn+1 immediately followed by the execution of job Jn+2 . This results in
j j

pj Cj (S )

pj Cj (OP T )

pj Cj (S )

pj Cj (OP T )

Although Lemma 1 always produces legal schedules the resulting schedule need not be nondelay, see the example of Fig. 3 that describes a system with all original jobs being released at time 0. There, splitting of the long job does not yield a nondelay schedule.

(a)

(b)

Fig. 3 Nondelay schedule (a) and schedule after job splitting (b)

We can use Lemma 1 to transform an arbitrary schedule into a target schedule: We split every job Jj if pj > and the splitting does not lead to a nondelay schedule. Due to Lemma 1, it is sucient to consider this type of schedule to determine the competitive factor of nondelay schedules. Finally, we reduce the release dates of each job without changing the schedule until any further reduction would violate the nondelay property of this schedule. As this reduction cannot increase the total completion time of the optimal schedule the ratio
j j

pj Cj (S )

pj Cj (OP T )

cannot decrease. Now, a target schedule

contains short jobs (pj ) and long jobs (pj > ), and has four main properties: 1. The schedule is nondelay.

562

Multidisciplinary International Conference on Scheduling : Theory and Applications (MISTA 2009) 10-12 August 2009, Dublin, Ireland

2. At least one machine is idle at the starting time of every long job. 3. For every long job Jj and every positive value rj < t < rj + pj , there is at least one processor idle at some time instance of the interval [t, t + Cj (S ) rj pj ). 4. All jobs that start in an interval (including the boundaries) without any idle processor have the same release date. If the second property does not hold then we can split a long job at time Cj (S ) pj + . If the third property does not hold then we can split a long job Jj at time t + Cj (S ) rj pj , see Fig. 4. If the fourth property does not hold then we can further reduce the release date of a job. For any target schedule S , we consider a nondelay schedule OP T that starts all long jobs at their release dates. Due to the properties of target schedules, such a schedule always exists: The rst property of schedule S guarantees that for a long job Ji , all processors are busy in the interval [ri , Ci (S ) pi ). Assume that job Ji and a long job Jj with rj < ri are executed on the same processor in schedule S . Then the inequality rj + pj > ri violates the third property of target schedules, see Fig. 5. Therefore, no long job Jj that starts at rj can prevent the next long job on this processor to start at its release date as well. For reasons of convexity, schedule OP T has the minimal total completion time if all short jobs have the same processing time. This can be achieved with an arbitrarily small deviation if is small enough.

Jj

rj

563

Fig. 4 Splitting of a long job in a busy interval

Ji

ri rj

Jj

Fig. 5 Rearranging long jobs in a schedule

Now we describe the proof of Theorem 1:

Multidisciplinary International Conference on Scheduling : Theory and Applications (MISTA 2009) 10-12 August 2009, Dublin, Ireland

Proof We use induction on the number of dierent release dates. Problem Pm ||

1+ 2 2

pj Cj

is the basis of the proof as < 1.25 holds. As hypothesis we assume that Theorem 1 is correct for all problem instances with at most i dierent release dates. Next we consider an arbitrary problem instance with i + 1 dierent release dates and a nondelay target schedule S . Let r be the maximum release date and = {Jj |rj = r} be the set of jobs that are released at time r. Due to the fourth property of target schedules, no job Jj with rj < r starts at time r or later. Let ts (S ) be the last start time of any job in schedule S . The processing time of any job Jj with rj < r, pj > r rj , and is reduced to r rj . This reduction does not decrease the completion time of any job Ji in schedule S while it cannot increase the contribution of jobs in to the total completion time of schedule OP T . Although the ratio
j j

pj Cj (S )

pj Cj (OP T )

may increase or decrease due to this

reduction, the total contribution of all jobs with a smaller release date than r remains bounded by our hypothesis. Now assume a job Jj with rj < r, pj > r rj , and Cj (S ) ts (S ) < pj + rj r. We split this job into one long job with release date rj and processing time r rj and one (long) job with release date r and processing time pj r + rj . Note that in schedule S , this splitting occurs in the interval [r, ts (S )) and does not violate the nondelay property. However, we may have to do some further splitting in order to preserve the third property of target schedules among the jobs of . Therefore, no long job Jj with rj < r can complete after time r in schedule OP T . If some short jobs complete after time r in schedule OP T although they have been submitted before r then we simply split a long job Ji with ri < r and r < Ci (S ) at some time in the interval [r, ts (S )] such that no job Jj completes after time r in schedule OP T . Observe that this splitting reduces the total processor-time product of all jobs submitted before r. To exactly achieve the desired result, we may have to repeat this splitting or to (repeatedly) duplicate the number of machines and all jobs. The latter procedure does not change the ratio
j j

pj Cj (S )

pj Cj (OP T )

With Wr being the total processor-time product of all jobs with a release date smaller than r in the interval [r, ) of schedule S we assume that these jobs completely r occupy the interval [r, r + W m ), see Fig. 6. This can only increase the total completion 4 time contribution of jobs Ji in schedule S . Now, we use the utilization bound 3 1 of Hussein and Schwiegelshohn [16]. This leads to Wr 4 m r.

r (a)

r (b)

Fig. 6 Schedule S (a) and assumed processor occupation (b)

564

Multidisciplinary International Conference on Scheduling : Theory and Applications (MISTA 2009) 10-12 August 2009, Dublin, Ireland

Finally, we can combine the total completion times to obtain the desired result:
j j

pj Cj (S )

pj Cj (OP T )

Jj pj Cj (S ) + Jj pj Cj (OP T ) +

Jj pj Cj (S ) Jj pj Cj (OP T )

<

Jj pj (Cj (S ) 1.25r ) + 1.25r Jj pj (Cj (OP T ) r ) + r

Jj pj Jj pj

+ 1.25 +

Jj pj Cj (OP T )

Jj pj Cj (OP T )

1+ 2 2

Jj pj (Cj (OP T ) r ) + 1.25r Jj pj (Cj (OP T ) r ) + r

Jj pj Jj pj

+ 1.25

Jj pj Cj (OP T )

Jj pj Cj (OP T )

< 1.25
1+ 2 2

The determined competitive factor for the problem Pm |rj , ncv |

pj Cj is 1.25 while

1.207 is a lower bound. Therefore, the gap is small (< 0.05).

4 Parallel Machines and Parallel Jobs In this section, we address rigid parallel jobs that require a xed number of processors during all of their processing time. We use the notation Pm |rj , sizej , ncv | pj sizej Cj to describe the corresponding scheduling problem. Unfortunately, List scheduling with an arbitrary order does not perform very well for this problem contrary to the problem 1 Pm |sizej , ncv |Cmax that guarantees the tight competitive factor 2 m , see Garey [13]. A simple example using only two jobs J1 and J2 with p1 = m, p2 = 1, size1 = 1, and size2 = m shows that the competitive factor of List scheduling may be as bad as m m+2 m , see Fig. 7. As both jobs cannot be executed concurrently, both schedules 2m+ m have the same optimal makespan. But in an online scenario it is better to schedule the parallel job rst as this order oers options for the scheduling of additional jobs (left schedule). In the right schedule, any idle processor in the interval [0, m) can only be utilized by the backlling method [4]. But backlling requires at least an estimate of the processing times. Therefore, the new objective allows to distinguish between these two schedules in an intuitive fashion.

m +1

m +1 m

(a)
Fig. 7 Optimal schedule (a) and bad List schedule (b)

(b)

However, we can guarantee acceptable solutions for the problem Pm |sizej , ncv | pj sizej Cj by sorting the jobs in descending order of their degree of parallelism (sizej ) before applying List scheduling.

565

Multidisciplinary International Conference on Scheduling : Theory and Applications (MISTA 2009) 10-12 August 2009, Dublin, Ireland

Theorem 2 List scheduling in descending order of the sizej value has an approximation factor of 2 for the problem Pm |sizej , ncv | pj sizej Cj . Again we use a well known lemma, see Queyranne [17], before presenting the proof for Theorem 2. Lemma 2 Let S be a nondelay schedule for the problem 1|ncv | pj Cj (S ) =
j

pj Cj . Then we have

1 (( 2

pj )2 +
j j

p2 j ).

Lemma 2 conrms our previous statement that the objective value of nondelay schedules for the problem 1|ncv | pj Cj is independent of the scheduling order. Now, we return to the proof of Theorem 2. Proof Let ts (S ) be the rst time instance at which at most m 2 processors are used. Then no job can start later than ts (S ). Let be the set of all jobs that start at time ts (S ), and let job Ji be the job with the smallest sizej value among all jobs in . Due to List scheduling, there are less than sizei processors idle at any time instance in the interval [0, ts (S )). Next we use several steps to transform schedule S ((a) in Fig.8). 1. We split every job Jj into sizej sequential jobs with the same processing time ((b) in Fig.8). Note that the resulting schedule is not a nondelay schedule anymore. This transformation does not change the objective value of schedule S while the corresponding value of the optimal schedule cannot increase. 2. We apply Lemma 1 until no job that completes before ts (S ) has a larger processing time than ((c) in Fig.8). This may add further jobs to and transforms schedule S into schedule S . 3. We combine all jobs in into a single job Jk with pk =
(
Jj Jj Jj Jj

p2 j pj

and sizek =

pj )2 p2 j

((d) in Fig.8). Note that sizek sizei holds.

Further, we rearrange schedule S such that exactly m sizek processors are used at any time instance before job Jk starts. This rearrangement produces schedule S and results in ts (S ) ts (S ) ((e) in Fig.8). Therefore, the objective value of schedule S cannot decrease while the objective value of the optimal schedule after the transformations ((f) in Fig.8) cannot increase due to reasons of convexity, see Lemma 2. Finally, we must determine the worst case values for pk and sizek as functions of m and ts (S ). Using Lemma 2, this leads to a rather simple numerical optimization problem and produces the approximation factor 2 for 0, pk = 0, and sizek = m 2. The following example shows that the approximation factor is tight for this algorithm. Example 1 Assume a problem instance with 2k + 2 jobs and an even number of processors m: Job J1 with p1 = 1 and size1 = m 1;

566

Multidisciplinary International Conference on Scheduling : Theory and Applications (MISTA 2009) 10-12 August 2009, Dublin, Ireland

ts(S)

(a)

(b)

(c)

ts(S) ts(S)

(d)

(e)

(f)

Fig. 8 Transformation steps of the proof of Theorem 2

Jobs J2 to J2k+1 with pj = 1 and sizej = Job J2k+2 with p2k+2 = 2k.

m 2;

List scheduling produces schedule S and starts jobs J1 and J2k+2 concurrently at time 0. Afterwards jobs J2 to J2k+1 are scheduled one after the other in a nondelay fashion, see the left schedule in Fig. 9. The optimal schedule OP T will schedule jobs J2 to J2k+1 in pairs rst and start jobs J1 and J2k+2 at time k, see the right schedule in Fig. 9. With the help of Lemma 2, this leads to lim
j

pj Cj (S )

m,k

j pj Cj (OP T )

=2

2k

2k

(a)

(b)

Fig. 9 Worst case example for List scheduling in descending order of the sizej parameter

567

Multidisciplinary International Conference on Scheduling : Theory and Applications (MISTA 2009) 10-12 August 2009, Dublin, Ireland

Unfortunately, List scheduling in descending order of the sizej value is not applicable for the problem Pm |rj , sizej , ncv | pj sizej Cj as the nondelay property may lead to a preferred scheduling of sequential jobs and therefore highly parallel jobs may be subject to starvation despite the order of the list. Moreover, there is no algorithm with a constant competitive factor as demonstrated by Theorem 3. Theorem 3 The lower bound of the competitive factor for the problem m+2 m. Pm |rj , sizej , ncv | pj sizej Cj approaches m 2m+ m Proof First, the adversary submits a single job J1 with size1 = 1 at time 0. Eventually, the scheduler must schedule this job to prevent an arbitrarily bad competitive factor. Then the adversary immediately submits a parallel job J2 with size2 = m. Finally, he selects the processing times of both jobs to match the example of Fig. 7 while considering the submission time r2 . In practice however, this result is not really disturbing as there are only few highly parallel jobs in real workloads. If each parallel job uses at most 50% of the processors of a machine then simple List schedule guarantees already a competitive factor of 2, see Schwiegelshohn and Yahyapour [11]. This competitive factor decreases further if the bound on the parallelism of the individual jobs becomes tighter. The new metric has the advantage that we can incorporate preferences of user groups or special jobs by simply multiplying the weight of these jobs with an owner dened constant. Further, it is easy to consider only recently submitted jobs in an online schedule. This enables an online evaluation of the schedule and therefore adaptation of the scheduling strategy.

References
1. Graham, R., Lawler, E., Lenstra, J., Kan, A.R.: Optimization and approximation in deterministic sequencing and scheduling: A survey. Annals of Discrete Mathematics 15, 287326 (1979) 2. Feitelson, D., Rudolph, L., Schwiegelshohn, U., Sevcik, K., Wong, P.: Theory and practice in parallel job scheduling. In: D. Feitelson, L. Rudolph (eds.) IPPS97 Workshop: Job Scheduling Strategies for Parallel Processing, pp. 134. SpringerVerlag, Lecture Notes in Computer Science LNCS 1291 (1997) 3. Bharadwaj, V., Robertazzi, T.G., Ghose, D.: Scheduling Divisible Loads in Parallel and Distributed Systems. IEEE Computer Society Press, Los Alamitos, CA, USA (1996) 4. Lifka, D.: The ANL/IBM SP Scheduling System. In: D. Feitelson, L. Rudolph (eds.) IPPS95 Workshop: Job Scheduling Strategies for Parallel Processing, pp. 295303. SpringerVerlag, Lecture Notes in Computer Science LNCS 949 (1995) 5. Lee, C.B., Schwartzman, Y., Hardy, J., Snavely, A.: Are user runtime estimates inherently inaccurate? In: Proceedings of the 10th Workshop on Job Scheduling Strategies for Parallel Processing, pp. 153161 (2004) 6. Lee, C.B., Snavely, A.E.: Precise and realistic utility functions for user-centric performance analysis of schedulers. In: HPDC 07: Proceedings of the 16th international symposium on High performance distributed computing, pp. 107116 (2007) 7. Franke, C., Homann, F., Lepping, J., Schwiegelshohn, U.: Development of scheduling strategies with genetic fuzzy systems. Applied Soft Computing Journal 8(1), 706721 (2008) 8. Graham, R.L.: Bounds for certain multiprocessor anomalies. Bell System Technical Journal 45, 15631581 (1966) 9. Bansal, N., Pruhs, K.: Server scheduling in the lp norm: a rising tide lifts all boats. In: ACM Symposium on Theory of Computing (STOC), pp. 242250 (2003) 10. Avidor, A., Azar, Y., Sgall, J.: Ancient and new algorithms for load balancing in the p norm. Algorithmica 29(3), 422441 (2001)

568

Multidisciplinary International Conference on Scheduling : Theory and Applications (MISTA 2009) 10-12 August 2009, Dublin, Ireland

11. Schwiegelshohn, U., Yahyapour, R.: Fairness in parallel job scheduling. Journal of Scheduling 3(5), 297320 (2000) 12. Pinedo, M.: Scheduling: Theory, Algorithms, and Systems, second edn. Prentice-Hall, New Jersey (2002) 13. Graham, R.: Bounds on multiprocessor timing anomalies. SIAM Journal of Applied Mathematics 17, 416429 (1969) 14. Naroska, E., Schwiegelshohn, U.: On an online scheduling problem for parallel jobs. Information Processing Letters 81(6), 297304 (2002) 15. Kawaguchi, T., Kyan, S.: Worst case bound of an LRF schedule for the mean weighted ow-time problem. SIAM Journal on Computing 15(4), 11191129 (1986) 16. Hussein, M., Schwiegelshohn, U.: Utilization of nonclairvoyant online schedules. Theoretical Computer Science 362, 238247 (2006) 17. Queyranne, M.: Structure of a simple scheduling polyhedron. Mathematical Programming 58(2), 263285 (1993)

569