General parametric scheme for the online uniform machine scheduling problem with two different speeds

In this paper, we consider the online uniform machine scheduling problem on m processors when speed s i = 1 for i = k +1 , ..., m and s i = s , s > 1 , for i = 1 , ..., k . The objective is to minimize makespan. We propose a parametric scheme with the worst-case performance 2.618 when 1 < s ≤ 2 , and with the asymptotic worst-case performance 12 (1+ s + √ 5 − 2 s + s 2 ) for all s > 1 when the ratio m/k tends to inﬁnity


Introduction and Problem Formulation
We study a classic online uniform machine scheduling problem for m uniform processors (M 1 , . . ., M m ) with speeds (s 1 , ..., s m ) without preemption.The objective is to minimize makespan.Jobs come sequentially one after another, and are immediately assigned to one of the processors.Jobs cannot change their processors afterward.No information about the future jobs is given.On the other hand, the order of the jobs is not connected to their starting time in the schedule.For example, a job that arrives later may start earlier than the current one.We only fix the assignment to the processors.Let us identify a job j with its processing time p j .If job j is scheduled for processor M i , then job processing takes pj si time.An algorithm's quality is measured by its worst-case performance.Denote by F (L A ) the makespan of the schedule created by algorithm A, and denote by F (L opt ) the optimal offline makespan.We say that an algorithm A has the worst-case performance c ∈ R if, for any list of jobs L, F (L A ) ≤ c • F (L opt ).
The online scheduling problem for identical processors without preemption was first investigated by Graham (1969).He showed that the List Scheduling algorithm (LS), assigning the current next job to the least loaded processor, has the worst-case performance (2 − 1 m ).Cho and Sahni (1980) proved the following worst-case performance of the LS for the system of uniform processors.For m = 2, the ratio is at most . In the special case when s 1 = . . .= s m−1 = 1 and s m > 1, they proved the worstcase performance of 3 − 4 m+1 , for m > 2. Li and Shi (1998) proved that the algorithm LS has the least possible worst-case performance for m ≤ 3, and proposed an approximation algorithm for the particular case s i = 1, i = 1, . . ., m − 1, and s m = 2, m ≥ 4. Their algorithm has the worst-case asymptotic performance of 2.8795 for m → ∞.For the case s i = 1, i = 1, . . ., m − 1, and 1 < s m ≤ 2, m ≥ 4, Cheng et al. (2006) designed an algo-rithm with the worst-case performance of 2.45.The case when the number of processors is two was studied in the work of Liu et al. (2009); Angelelli et al. (2008); Wen and Du (1998).
Related models.Some related models have been investigated in the past few years and semi-online algorithms have been studied.This term encompasses algorithms that are essentially online, but some partial information about the input is given to the scheduler in advance.The main motivation behind this approach is the observation that the classic competitive analysis is too pessimistic compared to practical results; in other words, the adversary who may arbitrarily determine the input sequence is too powerful.In practice, the inputs are not completely arbitrary, and it may be reasonable to restrict them.
Semi-online algorithms for scheduling with reassignment to two identical machines were considered in Min et al. (2011).Online algorithms with rearrangements for two related machines were studied in Wang et al. (2012); Cao and Liu (2010); Dosa et al. (2011).There are some related publications studying scheduling subject to eligibility constraints.Online scheduling on two uniform machines subject to eligibility constraints of type GradeOfService (GoS) was first considered in Liu et al. (2009).More recent results for this problem were presented in Lee et al. (2009).
Our contribution.In this paper, we consider the online uniform machine scheduling problem for the case s i = 1 for i = k + 1, ..., m and s i = s, s > 1, for i = 1, ..., k.The objective is to minimize makespan.We present a generalization of the approach proposed by Dolgui et al. (2015).Our parametric scheme has a better worst-case performance than the current known results starting from a big enough m with fixed k and s.We also prove that for the case 1 < s ≤ 2, the worst-case performance of our algorithm is at most of 2.618.The proposed parametric scheme requires only the ratio of the number of all the processors to the number of the fast ones instead of the exact numbers.For the case in which this ratio tends to infinity and the fast processors have the speed s, we obtain the asymptotic worst-case We also propose some algorithms that would help to find parameters for the proposed scheme.In our proofs and statements, we use the ideas of reserved classes and the dynamic lower bound of the optimal solution from Dolgui et al. (2015); Kellerer and Kotov (2013); Kellerer et al. (2015).

Notation and Lower Bounds
Denote the number of processors by m.Let us enumerate the processors with numbers from 1 to m. Denote the i-th processor by M i .Denote by k the number of the processors with a speed s > 1.Let L i,j be the current load for the processor with number i before scheduling job j (with processing time p j at step j).Denote by OM j the optimal makespan after the first j jobs.
Denote by q (j) 1 , . . ., q (j) j the processing times of jobs 1, . . ., j ordered at step j such that q For simplicity, we assume that q (j) y with non-positive indices y are equal to zero.Denote by z the upper integer part of s, i.e. z is a positive integer s.t.
Property 1.The optimal makespan after the first j jobs Proof.Values V (2) j and V (3) j are trivial lower bounds.Let us prove OM j ≥ V (1) j .Consider the k(z − 1) + 1 greatest jobs at step j and denote them by GJ j .WLOG, for j < k(z − 1) + 1, it is possible to add some jobs with zero size.Then, in any scheduling, there are two cases.In the first, some job from GJ j comes to a processor with speed one.It follows that the makespan of such scheduling is at least q (j) (z−1)•k+1 .In the second case, all of jobs come to processors with speed s.Since there are k(z − 1) + 1 jobs in GJ j , there is a processor IM j with speed s, such that at least z jobs are scheduled to it.Thus, the current load of Denote by LB j the maximal value among It is clear that LB j is a lower bound for the optimal makespan OM j .Trivial calculations show LB j−1 ≤ LB j .

Algorithm
Let us construct a parametric algorithm with the worstcase performance B ≥ s.Let m 1 , m 2 , and R be nonnegative integers, such that k + m 1 + m 2 = m, and Divide all processors into three classes.All k processors with speed s are assigned to the class Fast, m 1 processors are assigned to the class Normal, and the remaining m 2 processors are assigned to the class Reserved.By definition, m 2 is an integer multiple of k • (z − 1).Note that the processors with high speed are always assigned to the class Fast.The classes Normal and Reserved are not fixed in advance; we only fix their cardinalities.In other words, processors from these classes may change their classes during the execution of the algorithm.
For the purpose of the algorithm description, we divide the list of Reserved processors into the groups G 1 , . . ., G R .
Every group is an ordered list of (z − 1) • k processors.The processors are numbered from 1 to (z − 1) • k within the group.
Introduce a real number ϕ ∈ [0, 1] and the following classification for the current job at the stage j.The job j with a processing time p j not exceeding ϕ • B • LB j is called small.Otherwise, the job is called big.We say that job j fits into processor i, if L i,j + p j /s i ≤ B • LB j .
Algorithm.Initialize u = 1.Then perform the following points sequentially for each new job j: 1.If job j fits into one of the processors of the Fast or Normal classes, assign it there and go to the next job.2. If u ≤ (z − 1) • k, carry out the following instructions: Assign the current job to the processor with number u in G 1 ; denote this processor by g u .Denote by i the processor from the Normal class with the minimal current load.Swap processors g u and i, i.e. processor i substitutes processor g u in group G 1 (and obtains number u within the group).The processor i moves to the Reserved class.Correspondingly, g u moves to the Normal class.After that increment u := u + 1.
Afterward, set u := 1.Notice that at point 3 we restore the property u ≤ (z − 1) • k if it was violated before.The algorithm can be implemented with complexity O((j + m) • log(m + j)) using some standard data structures, where j is the number of currently processed jobs.
The main idea of the algorithm is to determine a good proportion of m 1 and m 2 in order to guarantee the following conditions: • A small job will fit into a processor from the Fast class or into a processor from the Normal class.• If a big job does not fit into any of the processors from the Fast and Normal classes, it will fit into one of the processors from the Reserved class.Moreover, we also want to minimize B. For this purpose, we introduce the following parametric scheme with parameters m 1 , m 2 , R, B, and ϕ.The first inequality of the scheme will force the first condition to hold.The second inequality of the scheme will force the second condition to hold.

Parametric scheme
As mentioned before, the algorithm is parametric in the terms of m 1 , m 2 , R, B, and ϕ, where m 1 , m 2 , R, and z are non-negative integers, k + m 1 + m 2 = m, z is the upper integer part of s, s + 1 > z ≥ s, and B, ϕ are non-negative real numbers, We further consider only those parameters satisfying the following system: The first inequality in the system enables us to prove Lemma 1.The second inequality allows us to recalculate the dynamic lower bound estimation in Lemma 2. This helps us to prove the worst-case performance B for our algorithm.
The scheme and the algorithm generalize and extend the analysis of Dolgui et al. (2015).As in the latter study, we use the analysis with big and small jobs, a similar lower bound recalculation, as well as the separation of the processors into the Fast, Normal and Reserved classes.
However, there are some major differences.The division into big and small jobs is now parametric in the terms of ϕ.The analysis is modified to work with any speed s and parametric job separation.Two new approaches for the estimation are used.The first uses the Wolfram Mathematica.The second is essentially a numerical approach with a grid parameter search.The algorithm works for any speed s > 1, as well as for any m and k.

Basic properties of the algorithm
Property 2. If job j does not fit into processor i from the Fast class, then L i,j > (B − 1) • LB j .
Proof.This follows from p j /s ≤ LB j by the lower bound V (3) j .Lemma 1.For the next current job j during the algorithm execution, there is a Fast processor i with load Proof.Assume the converse: at step j, all Fast processors have loads greater than (B −1)•LB j , and all Normal processors have loads more than On the other hand, from the first equation from (1), we obtain Corollary 1.If job j is small, then there is a Fast or Normal processor i, such that job j fits into processor i.
The next property proves that the system always has a solution.
Property 3. The system (1) always has a feasible solution with fixed k, m, and s.
Proof.Consider ϕ = 1, R = 0, m 1 = m − k, and m 2 = 0.The only important inequality for this case is Note that if R = 0, the Reserved class will be empty, and only the first point of the algorithm will be executed.
Next we assume that (B, m 1 , m 2 , R, z) is a solution of (1).

Case R ≥ 1
In this section, we suppose that the system (1) has a solution with some R ≥ 1.Consider any such solution.Since groups are constantly renamed during the algorithm, it is useful to give them some stable notation.Denote the groups F 1 , . . ., F R , where F i corresponds to G i in the source numeration(before the algorithm is launched).The only difference is that the numeration F i will not change during the execution of the algorithm.Denote by L r i,j the current load of the processor with index i within group G r , r = 1, . . ., R, before assignment of job j (at iteration j).
Note that for fixed i and r and different j, the value L r i,j may correspond to different processors.Note also that, in general, L x i,j = L y i,j when x = y, because of the correspondence to different groups.
Lemma 2. For each job j, such that point 2 of the algorithm is executed and processor Proof.We proceed by induction.Assume that before the previous assignment to processor h from group F i , the load of that processor h was at most (B − s) • LB j .Then, prove that before the next assignment, the load of h will not exceed (B − s) • LB j .The base holds since initially all loads are zero.From the symmetry, it is sufficient to prove the statement for the first processor from the group F 1 at the moment when it is in G 1 .Denote by t h 1 the iteration in which we executed point 2 of the algorithm for the processor with number u = h, h = 1, . . ., (z − 1) • k in the group G 1 = F 1 .After assignment of big job t h 1 to processor h in group G 1 with the property 1 , we obtain that the new load L is within the following borders: From Property 2 for any processor i from the Fast class, we obtain L i,t h 1 > (B − 1) • LB t h 1 .Thus, from Lemma 1 it follows that there is a processor i from the Normal class, such that L Then, for the processor i mentioned in point 2 of the algorithm, it holds: After the assignment and exchange of processors (but before the group renaming), we obtain: Note that the conditions (2), (3), and ( 4) hold for every iteration t h 1 , where h = 1, . . ., (z − 1) • k.After (z − 1) • k such iterations, we have the group renaming for all G i .Now G 1 is the previous G 2 , i.e.F 2 .Therefore, the conditions mentioned above are respected for G R .
Let t 1 2 be the iteration in which we assign a big job to the processor 1 in the new group G 1 , i.e. immediately after renaming the groups at step t (z−1)•k 1 . Similarly, define t h 2 .Then t 1 2 is big, and p t 1 2 > ϕ • B • LB t 1 2 .We have (z − 1) • k jobs t h 1 , and job t 1 2 with a processing time of at least ϕ • B • LB t 1 1 .Therefore, from the bound V (1) j of Property 1, we obtain ϕ • B • LB t 1 1 < LB t 1 2 .We can proceed similarly for all h, i.e. the following holds: Therefore, combining ( 5) and ( 4) we obtain: Analogously, we obtain ϕ • B • LB t h 2 < LB t h 3 , and so on.As a result, we proceed with a recalculation of the lower bound.After R such recalculations on the iteration for job j, we find that the load of processor 1 in the group F 1 is at most (1−ϕ)•B (ϕ•B) R LB j .To finish the proof, we need to note that from the system (1) we have (1−ϕ)•B (ϕ•B) R ≤ (B − s).
3.4.Particular case R = 0 Lemma 3. In the case R = 0, the algorithm is correct, i.e.only point 1 will be executed.Moreover, then the minimal possible B is equal to max s, 2 + (s−1)•(d−1) s+d−1 , where d = m k ∈ Q is the ratio of the number of all processors to the number of fast ones.