^{1}

^{2}

In this paper, we consider online scheduling for jobs with arbitrary release times on the parallel uniform machine system. An algorithm with competitive ratio of 7.4641 is addressed, which is better than the best existing result of 12.

For the online scheduling on a system of m uniform parallel machines, denoted by Q_{m}/online/C_{max}, each machine M i ( i = 1 , 2 , ⋯ , m ) has a speed s_{i}, i.e., the time used for finishing a job with size p on M_{i} is p/s_{i}. Without loss of generality, we assume s 1 < s 2 ≤ ⋯ ≤ s m . Cho and Sahni [_{2}/online/C_{max}, Epstein et al. [_{3}/online/C_{max} was considered by Cai and Yang [

G 1 = { ( s , t ) | 1 ≤ t < 1 + 31 6 , s ≥ 3 t 5 + 2 t − 6 t 2 } ,

G 2 = { ( s , t ) | t ≥ 1 + s , s ≥ 1 , t ≥ 1 } .

Aspnes et al. [_{m}/online/C_{max}. They presented a new algorithm with competitive ratio of 8 for the deterministic version, and 5.436 for its randomized variant. Later the previous ratios are improved to 5.828 and 4.311, respectively, by Berman et al. [

The special case s i = 1 ( i = 1 , 2 , ⋯ , m − 1 ) and s m = s ≥ 1 was fisrt considered by Li and Shi [_{m} = 2 and they also developed an algorithm with a better competitive ratio than LS for m ≥ 4 and s_{m} = s ≥ 1. For m ≥ 4 and 1 ≤ s ≤ 2, Cheng et al. [

Motivated by air cargo import terminal problem, a generalization of the Graham’s classical on-line scheduling problem was proposed by Li and Huang [_{j} is given as order with the information of a release time r_{j} and a processing size of p_{j}. More recent results can be found in the research by Li et al. [

Our task is to allocate an order sequence of jobs to m parallel uniform machines which have speeds of s 1 ≤ s 2 ≤ ⋯ ≤ s m in an online fashion, while minimizing the maximum completion time of the machines. An algorithm with worst case performance not bigger than 7.4641 is developed. The result is better than the existing result of 12 in Cheng et al. [

The rest of the paper is organized as follows. In Section 2, some definitions are given. In Section 3, an algorithm R is addressed and its competitive ratio is analyzed.

In this section we will give some definitions.

Definition 1: We have m parallel machines with speeds s 1 , s 2 , ⋯ , s m , respectively. Let L = { J 1 , J 2 , ⋯ , J n } be any list of jobs, where jobs arrives online one by one and each J_{j} has a release time r_{j} and a processing size of p_{j}. Algorithm A is a heuristic algorithm. C max A ( L ) and C max O P T ( L ) denote the makespan of algorithm A and an optimal off-line algorithm, respectively. We refer to

R ( m , A ) = sup L C max A ( L ) C max O P T (L)

as the competitive ratio of algorithm A.

Definition 2: Suppose that J_{j} is the current job with release time r_{j} and size of p_{j}. We say that machine M_{i} has an idle time interval for job J_{j}, if there exists a time interval [ T 1 , T 2 ] satisfying the following two conditions:

1) Machine M_{i} is idle in interval [ T 1 , T 2 ] and a job with release time T_{2} has been assigned to machine M_{i} to start at time T_{2}.

2) T 2 − max [ T 1 , r j ] ≥ p j s i .

It is obvious that if machine M_{i} has an idle time interval for job J_{j}, then we can assign J_{j} to machine M_{i} in the idle interval.

In the following we consider m parallel uniform machines with speeds s 1 , s 2 , ⋯ , s m and a job list L = { J 1 , J 2 , ⋯ , J n } with information (r_{j}, p_{j}) for each job J j ∈ L , where r_{i} and p_{i} represent its release time and processing size, respectively. For convenience, we assume that the sequence of machine speeds is non-decreasing, i.e., s 1 ≤ s 2 ≤ ⋯ ≤ s m . Let

S = { 0 , s 1 , s 2 , ⋯ , s m } ;

Bigsum ( s ) = ∑ s i ∈ S , s i > s s i ;

S i = { 0 , s i , s i + 1 , ⋯ , s m } ; i = 1 , 2 , ⋯ , m , m + 1 ;

Bigsum ( i , s ) = ∑ s i ′ ∈ S , s i ′ > s s i ′ ; i = 1 , 2 , ⋯ , m ,

Bigsum ( s , Δ , L ) = ∑ J j ∈ L , s r j + p j > s Δ p j .

By our definition, S m + 1 = { 0 } .

Now we present the algorithm R by use of the notations given in the former section in the following:

Algorithm R:

Step 0. Let t: = 0, Δ_{t}: = very small positive number.

For i = 1 to m do m_{i}: = Δ_{t}s_{i}, c_{i}: = 2 m_{i}, H_{i} = 0.

L t : = Φ .

Step 1. Let J_{j} be a new job with release time r_{j} and processing size p_{j} given to the algorithm. If there is a machine M_{i} which has an idle time interval for job J_{j}, then we assign J_{j} to machine M_{i} in the idle interval and set L t : = L t ∪ J j .

Step 2. If r j ≥ Δ t or Bigsum ( s , Δ t , ∪ k = 0 t L k ) > Δ t Bigsum ( s ) for some s ∈ S then goto Step 3. Otherwise goto Step 4.

Step 3. (*start a new phase*)

Set Δ: = rΔ_{t}, t: = t + 1, Δ_{t}: = Δ,

For i = 1 to m do m i : = Δ t s i , c i : = c i + ( 2 − 1 / r ) m i .

Set L t : = Φ and Goto Step 2.

Step 4. (*schedule p_{j}*)

k : = min { i | c i + m i > s i r j + p j } ;

Assign J_{j} on machine M_{k}; Set:

c k : = c k − max { 0 , s k r j − H k } − p j ;

H k : = H k + max { 0 , s k r j − H k } + p j .

Set L t : = L t ∪ J j .

The running time of R is mainly in Step 1 and Step 4. In Step 1, at most j-1 times of checking can determine if there is an idle interval for current job J_{j}. In Step 4 at most m times can determine to assign current job J_{j}. Hence the complexity of our algorithm is O(n^{2}).

Now we begin to analyze the performance of algorithm R. The following statement is obvious:

Lemma 1. For a job list L, if C max O P T ( L ) ≤ Δ , then Bigsum ( s , Δ , L ) ≤ Δ Bigsum ( s ) and r_{j} < Δ hold for every s ∈ S and every j ∈ L .

Let L^{l} be the stream of jobs scheduled in phase l. We define L i l to be the stream of jobs that in phase l machine M_{i} passed over or M_{i}_{+1} received, i = 0 , 1 , ⋯ , m (for 1 ≤ i < m , these two conditions are equivalent, for i = 0, only the latter and for i = m only the former applies).

Now the correctness of algorithm R will mean that the stream J m l is empty for every phase l.

Lemma 2. For every i = 0 , 1 , 2 , ⋯ , m and every phase l, we have

∑ t = 0 l Bigsum ( 0 , Δ t , L i t ) ≤ ( ∑ t = 0 l Δ t ) ( ∑ q = i + 1 n s q ) .

Proof: First of all, by the rules of the algorithm, we have

Bigsum ( s , Δ t , ∪ t = 0 l L t ) ≤ Δ l Bigsum ( s ) .

for every phase l and every s ∈ S . Therefore

Bigsum ( s , Δ t , L l ) ≤ Δ l Bigsum ( s ) .

for every phase l and every s ∈ S . Now we prove the claim by induction. For i = 0, it follows simply from the fact that

Bigsum ( 0 , Δ t , L 0 t ) = Bigsum ( 0 , Δ t , L t ) ≤ Δ t Bigsum ( 0 ) = Δ t ∑ q = 1 m s q , ∀ t ≤ l .

For l = 0, L^{0} is empty and hence L i 0 is empty for all i. Thus we have

Bigsum ( 0 , Δ , L i 0 ) = 0 , i = 1 , 2 , ⋯ , m .

This means that it is true for all i.

Now we will show the claim for (i, l) is true under the assumptions that the claim is true for (i−1, l) and (i, l−1). We prove it according to the following two cases:

Case 1. c_{i} > 0. In this case, any job J with release time r and size p satisfying r s i + p ≤ m i = Δ s i in L i − 1 l cannot be passed over machine M_{i} to machine M_{i}_{+1}. Hence we have

L i l = { j | r j s i + p j > Δ l s i , j ∈ L l } .

Thus we have

Bigsum ( 0 , Δ l , L i l ) = Bigsum ( s i , Δ l , L l ) ≤ Δ l Bigsum ( s i ) = Δ l ∑ q = i + 1 m s q .

By the assumption on the claim for (i, l−1), we get

∑ t = 0 l − 1 Bigsum ( 0 , Δ t , L i t ) ≤ ( ∑ t = 0 l − 1 Δ t ) ( ∑ q = i + 1 n s q ) .

Adding up the above two inequality we get the claim for (i, l).

Case 2. c i ≤ 0 . In this case, we consider the sum of job sizes that assigned on machine M_{i} from phase 0 to phase l, which can be expressed as

∑ t = 0 l [ Bigsum ( 0 , Δ t , L i − 1 t ) − Bigsum ( 0 , Δ t , L i t ) ]

Because c i ≤ 0 , H_{i}, the height of machine M_{i} at the end of phase l, is at least

H i ≥ ∑ t = 0 l c i t = 2 Δ 0 s i + ( 2 − 1 r ) Δ 1 s i + ⋯ + ( 2 − 1 r ) Δ l s i = 2 Δ 0 s i + ( 2 Δ 1 − Δ 0 ) s i + ⋯ + ( 2 Δ l − Δ l − 1 ) s i = Δ s l i + s i ∑ t = 0 l Δ t

By the rules of the algorithm, no job has release time greater than Δ_{l}. Thismeans that there is no idle time in time interval [ Δ l , Δ l + ∑ t = 0 l Δ t ] on machineM_{i}. Hence the sum of the job sizes that assigned on machine M_{i} from phase 0 to phase l satisfies:

∑ t = 0 l [ Bigsum ( 0 , Δ t , L i − 1 t ) − Bigsum ( 0 , Δ t , L i t ) ] ≥ s i ∑ t = 0 l Δ t .

By the inductive hypothesis for (i−1, l), we have

∑ t = 0 l Bigsum ( 0 , Δ t ) ≤ ( ∑ q = i m s q ) ( ∑ t = 0 l Δ t ) .

The above two inequalities include the truth of the claim for (i, l).

Lemma 2 show that, for every phase t, we have

Bigsum ( 0 , Δ t , L m t ) = 0 .

This includes that L m t is empty for every phase t.

Theorem 3. The competitive ratio of algorithm R is not greater than 7.4641.

Proof: Suppose that the algorithm ended at phase k. Then the optimal value is at least Δ k − 1 = r k − 1 Δ 0 and the completion time of the algorithm is at most

∑ t = 0 k c i t s i = 2 Δ 0 + ( 2 − 1 r ) Δ 1 + ⋯ + ( 2 − 1 r ) Δ k + Δ k = 2 Δ 0 + ( 2 Δ 1 − Δ 0 ) + ⋯ + ( 2 Δ k − Δ k − 1 ) + Δ k = 2 Δ + k ∑ t = 0 k Δ t = ( 2 r k + ∑ t = 0 k r t ) Δ 0 = ∑ t = 0 k Δ t = ( 2 r k + r k + 1 − 1 r − 1 ) Δ 0 .

Hence the performance ratio is not greater than

( 2 r k + r k + 1 − 1 r − 1 ) / r k − 1 < 2 r + r 2 r − 1 = 3 r + 1 + 1 r − 1 .

It is easy to see that the best value of r is 1 + 3 3 and the performance ratio is 4 + 2 3 ≈ 7.4641 .

In this paper, on-line scheduling problem for jobs with arbitrary release times on uniform machines is considered. We developed an algorithm with the competitive ratio of 7.4641 which is better than existing result of 12. In order to improve the competitive ratio more detailed consideration should be taken in.

The authors would like to express their thanks to the National Natural Science Foundation of China for financially supporting under Grant No.11471110 and the Foundation Grant of Education Department of Hunan (No. 16A126).

The authors declare no conflicts of interest regarding the publication of this paper.

Li, R.H. and Zhou, Y.X. (2019) Better Algorithm for Order On-Line Scheduling on Uniform Machines. International Journal of Intelligence Science, 9, 59-65. https://doi.org/10.4236/ijis.2019.92004