New Competitive Analysis Results of Online List Scheduling Algorithm

by   Rakesh Mohanty, et al.

Online algorithm has been an emerging area of interest for researchers in various domains of computer science. The online m-machine list scheduling problem introduced by Graham has gained theoretical as well as practical significance in the development of competitive analysis as a performance measure for online algorithms. In this paper, we study and explore the performance of Graham's online list scheduling algorithm(LSA) for independent jobs. In the literature, LSA has already been proved to be 2-1/m competitive, where m is the number of machines. We present two new upper bound results on competitive analysis of LSA. We obtain upper bounds on the competitive ratio of 2-2/m and 2-m^2-m+1/m^2 respectively for practically significant two special classes of input job sequences. Our analytical results can motivate the practitioners to design improved competitive online algorithms for the m-machine list scheduling problem by characterization of real life input sequences.



There are no comments yet.


page 1

page 2

page 3

page 4


New Competitive Semi-online Scheduling Algorithms for Small Number of Identical Machines

Design and analysis of constant competitive deterministic semi-online al...

Competitive Analysis of Move-to-Front-or-Middle (MFM) Online List Update Algorithm

The design and analysis of efficient algorithms with the knowledge of cu...

Results on Competitiveness of Online Shortest Remaining Processing Time(SRPT) Scheduling with Special Classes of Inputs

Shortest Remaining Processing Time (SRPT) is a well known preemptive sch...

The Scheduler is Very Powerful in Competitive Analysis of Distributed List Accessing

This work is a continuation of efforts to define and understand competit...

Traveling Repairperson, Unrelated Machines, and Other Stories About Average Completion Times

We present a unified framework for minimizing average completion time fo...

Online List Access with Precedence Constraints

This paper considers a natural generalization of the online list access ...

Learning to Schedule Deadline- and Operator-Sensitive Tasks

The use of semi-autonomous and autonomous robotic assistants to aid in c...
This week in AI

Get the week's most popular data science and artificial intelligence research sent straight to your inbox every Saturday.

1 Preliminaries and Related Work

Here, we present some basic terminologies and notations, which we will use through out the paper. We then highlight scholarly contributions related to online list scheduling setting.

1.1 Basic Teminologies and Notations

  • We specify each independent job and identical machine as and respectively, where machines are represented as and jobs are represented as .

  • Jobs are independent in the sense that jobs can execute in overlapping time slots on different machines.

  • Machines are identical in the sense that the processing time () of any is equal for all machines.

  • Sometime we refer processing time () of as size of .

  • We represent as the completion time of any job .

  • We denote makespan obtain by any online algorithm A for input sequence I as . We have =.

  • A machine is in idle state when it is not executing any job and we represent idle time of the machine as in the timing diagram.

  • Load() of any machine is the sum of processing time of the jobs scheduled on . Suppose, jobs are assigned to , then =. We may further define makespan as =.

  • Non-preemptive scheduling of the jobs means once a job with starts its processing on any at time then it continues with no interruption by taking all together time prior to its completion.

1.2 Related Work

The -machine LS problem has been studied for various setups over the years, see surveys [10-13]. According to our knowledge, the first online scheduling algorithm for multiprocessor systems was proposed by Graham in 1966 popularly known as list scheduling algorithm(LSA) [1]. He considered the non-preemptive scheduling of a list of jobs on identical parallel machines. The goal was to obtain minimum makespan. Algorithm LSA schedules a newly available job to the most lightly loaded machine. The performance of LSA was proved to be at most time worse than the optimum makespan for all job sequences.
Faigle et. al. [5] analyzed the performance of LSA by considering a list of jobs with sizes () respectively and proved that LSA is optimal for . Similarly, for , they considered jobs with sizes () respectively to represent the optimum competitiveness of . They obtained lower bound(LB) on the competitive ratio of for by considering a list of jobs, where jobs are of size unit each, jobs with size unit each and a single job is of size unit.
The first improvement over LSA was provided by Galambos and Woeginger [14] and achieved competitiveness of (), where . Bartal et. al. [15] obtained the upper bound(UB) on the competitive ratio of for a general case of . For , they proved LB of by considering jobs each with size () unit respectively. Bartal et. al. [17] obtained a better LB of for by examining the job sequence consisting of jobs, where jobs each with processing time of unit, jobs with processing time of unit each, jobs are of size unit each, jobs are of size unit each, jobs each with size unit, () jobs are of size unit each, where are positive real values. We now present the summary of all important results for deterministic online scheduling algorithms for identical parallel machines in table 1.

Year and Author(s) Competitive Ratio(s)
1966, Graham [1] for all .
1991, Galambos and Woeginger [14] for .
1992, Bartal et al. [15] (UB) for all , (LB) for .
1996, Karger et al. [16] , for .
1994, Bartal et. al. [17] (LB) for
1994, Chen [18] (LB) for and (LB) for .
1999, Albers [19] , for .
2000, Fleicher and Wahl [20] (UB)
2001, Rudin III [21] (LB) for all .
2003, Rudin III and Chnadrasekharan [22] (LB) for
2008, Englert [23] for
Table 1: Summary of Important Results

1.3 Graham’s Online List Scheduling Algorithm

Here, we present the descriptions of algorithm LSA [1] for independent jobs and provide proof sketch to show its competitiveness results as follows.

   Initially, i=1,
   WHILE a new job arrives DO
           Calculate current load for each machine .
           Number the machines in non-decreasing order of their loads Such that         .
           Assign to .
Algorithm 1 LSA

Theorem 1. Algorithm LSA is ()-competitive for .
Proof: Let us consider a list of jobs(). Each job is available to LSA one by one. The processing time for . Initially, machines() are available with loads . Let the size of the largest job is , where =. We denote the optimal makespan as and makespan obtained by algorithm LSA as for all input sequences I. As per the description of LSA, the scheduling decision time() is constant for each input. Therefore, each time we ignore , while calculating makespan.
Computation of OPT: Optimum offline strategy equally distributes the total load among all -machines. So, the completion time of the job schedule is at least the average of total load incurred on -machines. Therefore, we have
                             .                                         (1)
Suppose OPT schedules only on and assigns rest jobs on machines with equal load sharing among machines and , then we have
                                     .                                             (2)

We now provide the computation for algorithm LSA : Algorithm LSA assigns a new job to the machine with least load to keep a balance in the load incurred on each machine. The worst scenario appears in this case when arrives as the job and prior to that the total load incurred by jobs are equally shared among -machines. So, we have , this compels LSA to schedule the job on i.e the least loaded machine. Therefore, we have

2 New Upper Bound Results on Competitiveness of Algorithm LSA

We obtain improved competitive ratios of the online deterministic LSA by considering two special classes of inputs. In this setting, the performance of LSA is evaluated through the ratio between the makespan obtained by LSA for worst sequence of input jobs arrival to the makespan obtained by OPT. The special classes of input sequences are described as follows.

2.1 Special Classes of Input Job Sequences

Class-(): Here, we consider a list of jobs, where number of jobs are of size unit each and a single job is of size unit.

Class-(): Here, we consider a list of jobs, where number of jobs are of size unit each and a single job is of size unit.

Theorem 2. LSA is ()-competitive for , where .

Let, and be the makespan obtained by OPT and LSA respectively for . We ignore , while scheduling each incoming job.

Computation of LSA: The worst sequence for appears when the input jobs arrive in the non-decreasing order of their processing time. So, in the worst case, jobs arrive one by one starting at time in the following order , where the jobs from to are of size unit each and the job is of size unit. LSA schedules each job upon its availability and before the arrival of the next job. As we are ignoring , so at time , jobs are scheduled on machines in one slot to complete their processing at . Therefore, the first jobs finish at . Now, at , we are left with final two jobs of sizes and respectively and are allocated to machines and . So, the last job finishes at . Therefore, we have

Computation of OPT: Here, the optimum strategy schedules the jobs according to the non-increasing order of job’s size. So, at time , OPT assigns the largest job with size unit to a machine along with jobs of size unit each to rest machines. Subsequently, jobs are assigned and completed at and the last job finishes at . Therefore, we have
From equations (3) and (4) we have
. OPT and LSA perform equivalently for with as it is required to schedule only jobs. Therefore, it is proved that LSA is ()-competitive for , where .

Theorem 3. LSA is ()-competitive for , where .

Let, and denote the makespan of OPT and LSA respectively for . We ignore , while scheduling each incoming job.

Computation of LSA: The worst input job sequence for appears when the largest job available at the end of the input job sequence. Therefore, the sequence holds the worst sequence for where the jobs from to are of size unit each and the job is the largest job with size unit. Initially at time , LSA assigns jobs on machines in one slot and finish them at . Subsequently, jobs are scheduled in slots and are completed at . Now, at , we are left with last two jobs of size unit and unit respectively and the load of each machine is . So, the last job finishes at . Therefore, we have
Computation of OPT: OPT schedules the largest job first. So, at time , the largest job is assigned to along with jobs to remaining machines. In the same fashion, jobs are completed at and the last job finishes at . Therefore, we have
From equations (5) and (6) we have
As we are not considering the single machine case, so we have LSA is ()- competitive for , where .

3 Conclusion and Future Scope

In this paper, we have presented an alternate proof for ()- competitiveness for algorithm LSA for independent jobs. We have studied and analyzed the performance of LSA by characterizing the input sequences into two special classes. We have shown that LSA is ()-competitive for special class() of input sequence, where we have considered jobs with processing times such as unit and unit respectively. We have also shown that LSA is ()-competitive by considering another class() of input sequence with jobs of with sizes such as unit and unit respectively. The competitive ratios achieved by LSA for and input sequence with different number machines are shown in table 2. It can be observed from our analytical results that increase in number of machines does not help LSA to minimize makespan for . However, the performance of LSA can be improved substantially with the increase in number of machines for .

Future Scope. It can be realized that the order of availability of the jobs has strong influence on the performance of LSA. However, the characterization of the input sequence with known total number of jobs and their processing time can help to improve the competitive ratio of LSA. Through input characterization, theoretical input sequences can be mapped to the real-world input sequences. It will be interesting to evaluate the performance of well-known online scheduling algorithms for practical input sequences. The performance of well-known online scheduling algorithms can be improved with better competitive results based on the practical input sequences.

Number of Machines Competitive Ratio for Class-1 Competitive Ratio for Class-2
2 1.0000 1.2500
3 1.3333 1.2222
4 1.5000 1.1875
5 1.6000 1.1600
10 1.8000 1.0900
50 1.9600 1.0196
100 1.9800 1.0099
Table 2: Competitive Ratio of LSA for Different Number of Machines


  • [1] Graham R.L.(1966) ”Bounds for certain multiprocessor anomalies”. Bell System Technical Journal, 45:1563-1581.
  • [2] Borodin A., El-Yaniv R.(1998) ”Online computation and competitive analysis”. Cambridge University Press, Cambridge.
  • [3] Pruhs K., Sgall J. and Torng E.(2004) ”Online scheduling”. Handbook on scheduling: Algorithms, models and performance analysis, CRC Press.
  • [4] Robert E. Tarjan and Sleator.(1985) ”Amortized computational complexity”. SIAM Journal on Algebric and Discrete Methods, 6(2):306-318.
  • [5] Faigle U., Kern W. and Turan G.(1989) ”On the performance of online algorithms for partition problems”. Acta Cybernetica, 9:107-119.
  • [6] Aspnes J., Azar Y., Fiat A., Plotkin S. and Waarts O.(1993) ”Online load balancing with applications to machine scheduling and virtual circuit routing”. ACM STOC: 623-631.
  • [7] Bartal Y., Fiat A. and Rabani Y.(1992) ”Competitive algorithms for distributed data management”. In Proceedings of

    Annual ACM symposium on Theory of Computing

  • [8] Baeza-Yates R.A., Culberson J.C. and Rawlins G.J.E.(1993) ”Searching in the plane”. Information and Computation, 106: 234-252, 1993.
  • [9] Garey M.R. and Jhonson D.S.(1979) ”Computers and Intractability: A Guide to the Theory of NP-Completeness”. Freeman.
  • [10] Graham R.L., Lawer E.L., Lenstra J.K. and Rinnooy kan A.H.(1979) ”Optimization and ap-proximation in deterministic sequencing and scheduling : A Survey”. Annals of Discrete Mathematics, Elsevier, 5: 287-326.
  • [11] Chen B., Potts C.N. and Woeginger G.J.(1998) ”A review of Machine scheduling: Complexity, Algorithms and Approximability”.

    Handbook of Combinatorial Optimization, Kluwer Academic Publishers

    , 3:21-169.
  • [12] Sgall J.(1998) ”Online scheduling: A survey”. Lecture Notes in Computer science, Springer, 1442:196-231.
  • [13] Albers S.(2009) ”Online scheduling: Introduction to Scheduling”, edited by Y. Robert and F. Vivien. CRC Press: 57-84.
  • [14]

    Galambos G. and Woeginger G.J.(1993) ”An online scheduling heuristic with better worst case ratio than Graham’s list scheduling”.

    SIAM Journal of Computing, 22(2):349-355.
  • [15] Bartal Y., Fiat A., Karloff H. and Vohra R.(1992) ”New algorithms for an ancient scheduling problem”. In Proceedings of the ACM Symposium on the Theory of Computing, Victoria, Canada:51-58.
  • [16] Karger D.R., Phillips S.J. and Torng E.(1996) ”A better algorithm for an ancient scheduling problem”. Journal of Algorithms, 20(19):400-430.
  • [17] Y. Bartal Y., Karloff H. and Rabani Y.(1994) ”A better lower bound for online scheduling”. Information Processing Letters, 50:113-116.
  • [18] Chen B., Vliet A.V. and Woeginger G.J. ”New lower and upper bound for online scheduling”. Operation Research Letters, 16:221-230.
  • [19] Albers S.(1999) ”Better bounds for Online scheduling”. SIAM Journal on Computing, 29:459-473.
  • [20] Fleischer R. and Wahl M.(2000) ”Online scheduling revisited”. Journal of Scheduling, 3:343-353.
  • [21] Rudin III J.F.(2001) ”Improved bounds for the online scheduling problem”, Ph.D Thesis. The University of Texas at Dellas.
  • [22] Rudin III J.F. and Chandrasekaran R.(2003) ”Improved bounds for the online scheduling problem”. SIAM Journal of Computing, 32(3): 717-735.
  • [23] Englert M., Ozmen D. and Westermann M.(2008) ”The power of reordering for online minimum makespan scheduling”. In Proceedings Annual IEEE Symposium on Foundations of Computer Science.