Semi-Online Scheduling on Two Machines with GoS Levels and Partial Information of Processing Time

Abstract

This paper investigates semi-online scheduling problems on two parallel machines under a grade of service (GoS) provision subject to minimize the makespan. We consider three different semi-online versions with knowing the total processing time of the jobs with higher GoS level, knowing the total processing time of the jobs with lower GoS level, or knowing both in advance. Respectively, for the three semi-online versions, we develop algorithms with competitive ratios of 3/2, 20/13, and 4/3 which are shown to be optimal.

1. Introduction

Scheduling problem under a grade of service provision was first proposed by Hwang et al. [1]. The jobs should be assigned irrevocably to machines as soon as they arrive. Each job and machine are labeled with the GoS levels. A job can be processed by a particular machine if and only if the GoS level of the job is not less than that of the machine. In practice, the scheduling with GoS eligibility constraints is widely used. For more details, please refer to [1–3].

For the offline scheduling on m machines under a grade of service provision, Hwang et al. [1] presented an lg-lpt algorithm which has a tight bound of 5/4 for two machines and 2 − 1/(m − 1) for m (m ≥ 3) machines. Ji and Cheng [4] gave an fptas for this problem. However, Woeginger [5] gave two simpler fptass for the same problem. For the online version, Jiang [6] proved a lower bound of 2 for the case with two levels of GoS and presented an online algorithm with a competitive ratio of 2.52. Zhang et al. [7] improved the result and showed an algorithm with a competitive ratio of 1 + (m ² − m)/(m ² − sm + s ²) ≤ 7/3.

For m = 2, Park et al. [8] presented an optimal algorithm with a competitive ratio of 5/3. However, there are many papers focusing on the semi-online scheduling on two machines under GoS [8–13]. As the total processing time of all jobs is known, Park et al. [8] gave an optimal algorithm with a competitive ratio of 3/2. When the largest processing time of all jobs is known, Wu et al. [12] presented an optimal algorithm with a competitive ratio of $(\sqrt{\mathrm{5}}+\mathrm{1})/\mathrm{2}$. In the same paper, Wu et al. [12] gave an optimal algorithm with a competitive ratio of 3/2 when the optimal value of the instance is known. For the processing times bounded in an interval, Liu et al. [9] gave a competitive algorithm under some conditions and Zhang et al. [13] improved the result and gave an optimal algorithm for different intervals. In this paper, we focus on the semi-online scheduling problem where only partial information of the total processing time is known. The semi-online versions concerned in our paper are listed as follows.

•   sum · higher: the total processing time of all jobs with higher GoS level is known in advance.
•   sum · lower: the total processing time of all jobs with lower GoS level is known in advance.

We use P2 · GoS | s | C _max⁡ to denote the semi-online problem with information s, where s ∈ {sum · higher, sum · lower}. Moreover, we use P2 · GoS | s1&s2 | C _max⁡ to denote the semi-online problem where both information s1 and information s2 are available in advance.

Our results indicate that competitive ratios of three algorithms are better than 5/3 of the online version [8]. When knowing sum · higher in advance, the competitive ratio is the same as the optimal algorithm [8] presented for the semi-online problem where the total processing time of all jobs is known. For designing algorithm, the results indicate that knowing sum · higher&sum · lower is more useful than sum · higher or sum · lower. Moreover, knowing sum · higher is more useful than sum · lower. However, knowing sum · lower is better than knowing the largest processing time of all jobs [12].

The rest of this paper is organized as follows: in Section 2, we give some basic definitions. In Sections 3–5, we prove lower bounds and present algorithms for the three semi-online problems, respectively.

2. Basic Definitions

We are given two machines and a series of jobs arriving online which are to be scheduled irrevocably at the time of their arrivals. The arrival of a new job occurs only after the current job is scheduled. We denote by the set J = 1,…, n the set of all job indices arranged in the order of arrival. The jth arriving job is referred to as job J _j. We denote each job by J _j = (p _j, g _j). The GoS assigned to job J _j is denoted by g _j, which is 1 if the job must be processed only by the first machine and 2 if it may be processed by either of the two; p _j is the processing time of job J _j; p _j and g _j are not known until the arrival of job J _j. Let T ₁ = ∑_gj=1 p _j and T ₂ = ∑_gj=2 p _j.

The scheduled can be seen as the partition of J into two subsets, denoted by (S ₁, S ₂), where S ₁ and S ₂ contain job indices assigned to the first and second machine, respectively. Let t(S) = Σ_Jj∈S p _j for an arbitrary subset S of J. Then the maximum of t(S ₁) and t(S ₂), denoted by max⁡{t(S ₁), t(S ₂)}, is the makespan of the scheduled (S ₁, S ₂). The problem is to minimize max⁡{t(S ₁), t(S ₂)}.

The minimum makespan obtained by an optimal offline algorithm is denoted by C _opt. The makespan generated by algorithm A is denoted by C _A. The competitive ratio of A is defined to be the maximum C _A/C _opt.

3. Optimal Algorithm for P2 · GoS | sum · higher | C _max⁡

In this section, we prove a lower bound of competitive ratio and present an optimal algorithm for the semi-online version as T ₁ is known in advance.

3.1. Lower Bound of Competitive Ratio

Theorem 1 —

Any semi-online algorithm for P2 · GoS | sum · higher | C _max⁡ has a competitive ratio of at least 3/2.

Proof —

The theorem will be proved by adversary method. Let T ₁ = 1 be known in advance. The first job is J ₁ = (1,1). J ₁ must be scheduled on the first machine. Then, we generate job J ₂ = (1,2). If job J ₂ = (1,2) is scheduled on the first machine, and there is no job arriving after, we have C _A/C _opt = 2 > 3/2. Otherwise, job J ₂ is scheduled on the second machine, and we generate job J ₃ = (2,2). No matter which machine that job J ₃ is scheduled on, we have C _A = 3. Since the optimal algorithm will scheduled job J ₁ and job J ₂ on the first machine and scheduled job J ₃ on the second machine. Hence, C _A/C _opt = 3/2. The proof is completed.

3.2. Optimal Semi-Online Algorithm GoS-TH

Since we know T ₁ in advance and all the jobs with g _j = 1 must be scheduled on the first machine, we can regard them as one job; that is, J ₀ = (T ₁, 1). We scheduled job J ₀ on the first machine at first and do not need to care about the job with g _j = 1 later.

At the arrival of each job, H is updated to become a half of the total processing time of the jobs which include the jobs with GoS = 2 and job J ₀;  P is updated to become the maximum processing time. We define P ^j, S ₁ ^j, S ₂ ^j, and H ^j to be P, S ₁, S ₂, and H after we scheduled job J _j. Then, clearly the optimum makespan C _opt ≥ L = max⁡(T, P). Combined with the online algorithm presented by Park et al. [8], we propose Algorithm GoS-TH.

Algorithm  GoS-TH

1. Scheduled J ₀ to the first machine and t(S ₁ ⁰) = T ₁.

2. Let p _j = 0 for all the jobs with g _j = 1.

3. Suppose that the incoming job is J _j and g _j = 1; assign job J _j to the first machine.

4. Suppose the incoming job is J _j and g _j = 2. H _j = H _j−1 + p _j/2, P _j = max⁡(P _j−1, p _j), and L _j = max⁡(T _j, P _j).

   • (4.1)
     If t(S ₂ ^j) + p _j ≤ (3/2)L _j, scheduled it to the second machine.
   • (4.2)
     If t(S ₂ ^j) + p _j > (3/2)L _j, scheduled it to the first machine.

Theorem 2 —

The competitive ratio of Algorithm GoS-TH is 3/2 for P2 · GoS | sum · higher | C _max⁡.

Proof —

Suppose that Theorem 2 is false. There must exist an instance with the least number of jobs to make C _GoS-TH > (3/2)C _opt. The makespan is not determined until the arrival of job J _n. Therefore,  

$$\begin{array}{c}{C}_{GoS\text{-}TH}=\max \left\{t\left(S_{\mathrm{1}}^n\right),t\left(S_{\mathrm{2}}^n\right)\right\}>\frac{\mathrm{3}}{\mathrm{2}}{C}_{\text{opt}},\\ \max \{t\left(S_{\mathrm{1}}^{n-\mathrm{1}}\right),t\left(S_{\mathrm{2}}^{n-\mathrm{1}}\right)\}\le \frac{\mathrm{3}}{\mathrm{2}}{C}_{\text{opt}}.\end{array}$$ (1)

If g _n = 1, based on Algorithm GoS-TH, we have t(S ₁ ⁿ) = t(S ₁ ⁿ⁻¹) and t(S ₂ ⁿ) = t(S ₂ ⁿ⁻¹). Due to the fact that max⁡{t(S ₁ ⁿ⁻¹), t(S ₂ ⁿ⁻¹)} ≤ (3/2)C _opt, we just need to prove Theorem 2 is true when g _n = 2.

If g _n = 2, when it is scheduled on the second machine, we have C _GoS-TH = t(S ₂ ⁿ) = t(S ₂ ⁿ⁻¹) + p _n ≤ (3/2)C _opt. This is contradicting with inequality (1). Otherwise, job J _n is scheduled on the first machine, which leads to t(S ₂ ⁿ⁻¹) + p _n > (3/2)L _n ≥ (3/2)H _n; combined with (t(S ₂ ⁿ⁻¹) + p _n + t(S ₁ ⁿ⁻¹))/2 = H _n, we get that t(S ₁ ⁿ⁻¹) < (1/2)L _n ≤ (1/2)C _opt. Since p _n ≤ C _opt, we have t(S ₁ ⁿ⁻¹) + p _n < (3/2)C _opt, which also contradicted with inequality (1). The proof is completed.

4. Optimal Algorithm for P2 · GoS | sum · lower | C _max⁡

In this section, we prove a lower bound of competitive ratio and present an optimal algorithm for the semi-online version as T ₂ is known in advance.

4.1. Lower Bound of Competitive Ratio

Theorem 3 —

Any semi-online algorithm for P2 · GoS | sum · lower | C _max⁡ has a competitive ratio of at least 20/13.

Proof —

We will construct a job sequence with T ₂ = 26 to make an arbitrary algorithm A behave poorly. We begin with jobs J ₁ = (1,2) and J ₂ = (1,2). We discuss the following three cases.

Case   1 (J ₁ and J ₂ are scheduled on the first machine). We continue to generate jobs J ₃ = (12,2) and J ₄ = (12,2). If job J ₃ and job J ₄ are scheduled on the second machine, we have t(S ₂) = 24; thus, C _A/C _opt = 24/14 > 20/13. Otherwise, if job J ₃ or job J ₄ is scheduled on the first machine or both of them are scheduled on the first machine, we further generate job J ₅ = (26,1). We will have t(S ₁) ≥ 40. Since optimal algorithm will scheduled jobs J ₁, J ₂, J ₃, and J ₄ on the second machine and scheduled job J ₅ on the first machine, we have C _A/C _opt ≥ 20/13.

Case  2 (J ₁ or J ₂ is scheduled on the first machine). We continue to generate job J ₃ = (2,2). Then we discuss the following two subcases.

Subcase   2.1 (job J ₃ is scheduled on the first machine). We continue to generate jobs J ₄ = (11,2) and J ₅ = (11,2). If job J ₄ and job J ₅ are scheduled on the second machine, we have t(S ₂) = 23 and t(S ₁) = 2, which lead to C _A/C _opt = 23/13 > 20/13. Otherwise, if job J ₄ or job J ₅ is scheduled on the first machine or both of them are scheduled on the first machine, we further generate job J ₆ = (26,1) which leads to C _A/C _opt ≥ 20/13.

Subcase   2.2 (J ₃ is scheduled on the second machine). We generate job J ₄ = (5,2). If job J ₄ is scheduled on the second machine, we generate job J ₅ = (13,2). If job J ₅ is scheduled on the second machine, we have t(S ₂) = 21. Since the optimal algorithm will scheduled jobs J ₁, J ₂, J ₃, and J ₄ on the first machine and scheduled job J ₅ on the second machine, we have C _A/C _opt = 21/13 > 20/13. If job J ₅ is scheduled on the first machine, we generate job J ₆ = (26,1) which leads to C _A/C _opt ≥ 20/13.

Otherwise, if job J ₄ is scheduled on the first machine, we generate job J ₅ = (8,2). If job J ₅ is scheduled on the first machine, we generate job J ₆ = (26,1) which leads to C _A/C _opt ≥ 20/13. If job J ₅ is scheduled on the second machine, we generate job J ₆ = (9,2). If job J ₆ is scheduled on the second machine, we have t(S ₂) = 20 and C _opt = 13; thus, C _A/C _opt = 20/13. If J ₆ is scheduled on the first machine, we generate job J ₇ = (26,1) and have t(S ₁) = 40 and C _opt = 26, which also lead to C _A/C _opt = 20/13.

Case   3 (J ₁ and J ₂ are scheduled on the second machine). We continue to generate job J ₃ = (2,2). Then we discuss the following two subcases.

Subcase   3.1 (job J ₃ is scheduled on the second machine). We generate jobs J ₄ = (3,2) and J ₅ = (3,2). If job J ₄ or job J ₅ is scheduled on the second machine or both of them are scheduled on the second machine, we further generate job J ₆ = (1,2). If job J ₆ is scheduled on the second machine, we generate job J ₇ = (14,2). If job J ₇ is scheduled on the second machine, we have t(S ₂) = 22. Since the optimal algorithm will scheduled jobs J ₁, J ₂, J ₃, J ₄, J ₅, and J ₆ on the first machine and scheduled job J ₇ on the second machine, we have C _A/C _opt ≥ 22/14 > 20/13. Otherwise, job J ₇ is scheduled on the first machine, and then we generate job J ₈ = (26,1) and have t(S ₁) ≥ 40 and C _opt = 26; hence, C _A/C _opt > 20/13. If job J ₆ is scheduled on the first machine, we generate job J ₇ = (13,2). If job J ₇ is scheduled on the second machine, we have t(S ₂) ≥ 20 and C _opt = 13, hence, we also have C _A/C _opt > 20/13. Otherwise, job J ₇ is scheduled on the first machine, and then we generate job J ₈ = (26,1). We have C _A/C _opt > 20/13.

If job J ₄ and job J ₅ are scheduled on the first machine, we generate jobs J ₆ = (8,2) and J ₇ = (8,2). If job J ₆ or job J ₇ is scheduled on the first machine or both of them are scheduled on the first machine, we further generate job J ₈ = (26,1). We have C _A/C _opt > 20/13. Otherwise, if job J ₆ and job J ₇ are scheduled on the second machine, we have t(S ₂) = 20 and C _opt = 13, which lead to C _A/C _opt = 20/13.

Subcase   3.2 (job J ₃ is scheduled on the first machine). We generate job J ₄ = (2,2). If job J ₄ is scheduled on the first machine, we generate jobs J ₅ = (10,2) and J ₆ = (10,2). If job J ₅ and job J ₆ are scheduled on the second machine, we have t(S ₂) = 22 and C _opt = 13; thus, C _A/C _opt = 22/13 > 20/13. Otherwise, if job J ₅ or job J ₆ is scheduled on the first machine or both of them are scheduled on the first machine, we further generate job J ₇ = (26,1) and have t(S ₁) ≥ 40; thus, C _A/C _opt = 20/13.

Otherwise, if job J ₄ is scheduled on the second machine, we generate job J ₅ = (4,2). If job J ₅ is scheduled on the second machine, we generate job J ₆ = (13,2). If job J ₆ is scheduled on the second machine, we have t(S ₂) = 21 and C _opt = 13; hence, C _A/C _opt = 20/13. If job J ₆ is scheduled on the first machine, we generate job J ₇ = (26,1) and have t(S ₁) ≥ 41; thus, C _A/C _opt = 41/26 > 20/13.

Therefore, job J ₅ is scheduled on the first machine. Then we generate jobs J ₆ = (8,2) and J ₇ = (8,2). If job J ₆ or job J ₇ is scheduled on the first machine or both of them are scheduled on the first machine, we further generate job J ₈ = (26,1). We will have t(S ₁) ≥ 40 and C _opt = 26; hence, C _A/C _opt > 20/13. Otherwise, if job J ₆ and job J ₇ are scheduled on the second machine, we have t(S ₂) = 20 and C _opt = 13; also, we have C _A/C _opt = 20/13. The proof is completed.

4.2. Optimal Semi-Online Algorithm GoS-TL

In this subsection, we design an optimal algorithm with a competitive ratio of 20/13. Let x ₁ and x ₂ be the jobs with g _j = 2 assigned to the first and second machine, respectively, where t(x ₁) + t(x ₂) = T ₂. We define x ₁ ^j and x ₂ ^j to be x ₁ and x ₂ after we scheduled job J _j. Then, we propose Algorithm GoS-TL.

Algorithm  GoS-TL

1. Suppose that the incoming job is J _j and g _j = 1; assign job J _j to the first machine.

2. Suppose that the incoming job is J _j and g _j = 2.

   • (2.1)
     (Stopping criterion 1). If (3/13)T ₂ ≤ t(x ₁ ^j−1) + p _j ≤ (7/13)T ₂, scheduled job J _j and all the remaining jobs with GoS = 1 to the first machine, and then scheduled all the remaining jobs with GoS = 2 to the second machine. Stop.
   • (2.2)
     (Stopping criterion 2). If (6/13)T ₂ ≤ t(x ₂ ^j−1) + p _j ≤ (10/13)T ₂, scheduled job J _j to the second machine and scheduled all the remaining jobs to the first machine. Stop.
   • (2.3)
     (Stopping criterion 3). If t(x ₂ ^j−1) > 10/13, scheduled job J _j and the remaining jobs to the first machine. Stop.
   • (2.4)
     If t(x ₂ ^j−1) ≤ (7/26)T ₂ and (7/13)T ₂ ≤ t(x ₂ ^j−1) + p _j < (6/13)T ₂, scheduled job J _j to the first machine. Continue.
   • (2.5)
     Otherwise, scheduled job J _j to the second machine. Continue.

Lemma 4 —

If (6/13)T ₂ ≤ t(x ₂) ≤ (10/13)T ₂, then C _GoS-TL ≤ (20/13)C _opt.

Proof —

Since C _opt ≥ (1/2)T ₂, we have t(S ₂) = t(x ₂) ≤ (10/13)T ₂ ≤ (20/13)C _opt. Then, we only need to prove that t(S ₁) ≤ (20/13)C _opt. We discuss it by the following two cases.

Case   1 (T ₁ ≥ T ₂). In this case, we have t(S ₁) = t(x ₁) + T ₁ and T ₁ ≥ (T ₁ + T ₂)/2. Since (6/13)T ₂ ≤ t(x ₂) ≤ (10/13)T ₂, we have t(x ₁) ≤ (7/13)T ₂. Combined with C _opt ≥ T ₁, we have

$$\begin{array}{c}\frac{C_{GoS\text{-}TL}}{C_{\text{opt}}}\le \frac{\left(\mathrm{7}/\mathrm{13}\right)T_{\mathrm{2}}+T_{\mathrm{1}}}{T_{\mathrm{1}}}\le \frac{\left(\mathrm{7}/\mathrm{13}\right)T_{\mathrm{1}}+T_{\mathrm{1}}}{T_{\mathrm{1}}}=\frac{\mathrm{20}}{\mathrm{13}}.\end{array}$$ (2)

Case   2 (T ₁ < T ₂). In this case, we have T ₁ < (T ₁ + T ₂)/2, which leads to C _opt ≥ (T ₁ + T ₂)/2. Then, we have

$$\begin{array}{c}\frac{C_{GoS\text{-}TL}}{C_{\text{opt}}}\le \frac{\left(\mathrm{14}/\mathrm{13}\right)T_{\mathrm{2}}+\mathrm{2}{T}_{\mathrm{1}}}{T_{\mathrm{1}}+T_{\mathrm{2}}}.\end{array}$$ (3)

Since ((14/13)T ₂ + 2T ₁)/(T ₁ + T ₂) is increasing function of the variation of T ₁, thus, we have

$$\begin{array}{c}\frac{C_{GoS\text{-}TL}}{C_{\text{opt}}}\le \frac{\left(\mathrm{14}/\mathrm{13}\right)T_{\mathrm{2}}+\mathrm{2}{T}_{\mathrm{1}}}{T_{\mathrm{1}}+T_{\mathrm{2}}}<\frac{\left(\mathrm{14}/\mathrm{13}\right)T_{\mathrm{2}}+\mathrm{2}{T}_{\mathrm{2}}}{T_{\mathrm{2}}+T_{\mathrm{2}}}=\frac{\mathrm{20}}{\mathrm{13}}.\end{array}$$ (4)

The proof is completed.

Based on Lemma 4, we straightforwardly have Corollary 5.

Corollary 5 —

(1) If t(x ₁) ≤ (7/13)T ₂, then t(S ₁) ≤ (20/13)C _opt; (2) if t(x ₂) ≤ (10/13)T ₂, then t(S ₂) ≤ (20/13)C _opt.

Lemma 6 —

t(x ₁) ≤ (7/13)T ₂.

Proof —

Since Algorithm GoS-TL will only scheduled a job with g _j = 2 to the first machine only when t(x ₁ ^j−1) + p _j ≤ (7/13)T ₂, the lemma can directly be got from the Algorithm GoS-TL. The proof is completed.

By using Corollary 5 and Lemma 6, we can obtain the following corollary.

Corollary 7 —

If t(x ₂) ≤ (10/13)T ₂, then C _GoS-TL ≤ (20/13)C _opt.

Based on Lemma 6 and Corollary 7, if we prove t(S ₂) ≤ (20/13)C _opt will hold when t(x ₂) > (10/13)T ₂, then we can prove that Algorithm GoS-TL is (20/13)-competitive.

Lemma 8 —

If job J _j is scheduled on the second machine by Algorithm GoS-TL where t(x ₂ ^j−1) + p _j > (10/13)T ₂ and t(x ₂ ^j−1)≤(7/26)T ₂, then t(S ₂)<(20/13)C _opt.

Proof —

If t(x ₂ ^j−1) + p _j > (10/13)T ₂ and t(x ₂ ^j−1) ≤ (7/13)T ₂, we have p _j > (1/2)T ₂. Then we have C _opt ≥ p _j > (1/2)T ₂. If job J _j is scheduled on the second machine, Algorithm GoS-TL will scheduled the remaining jobs on the first machine. Thus,

$$\begin{array}{c}\frac{t\left(S_{\mathrm{2}}^j\right)}{C_{\text{opt}}}\le \frac{t\left(S_{\mathrm{2}}^j\right)}{p_j}=\frac{t\left(x_{\mathrm{2}}^{j-\mathrm{1}}\right)+p_j}{p_j}.\end{array}$$ (5)

Since (t(x ₂ ^j−1) + p _j)/p _j is decreasing function of the variation of p _j and increasing function of variation of t(x ₂ ^j−1), we have

$$\begin{array}{c}\frac{t\left(S_{\mathrm{2}}^j\right)}{C_{\text{opt}}}\le \frac{t\left(x_{\mathrm{2}}^{j-\mathrm{1}}\right)+p_j}{p_j}<\frac{\left(\mathrm{7}/\mathrm{26}\right)T_{\mathrm{2}}+\left(\mathrm{1}/\mathrm{2}\right)T_{\mathrm{2}}}{\left(\mathrm{1}/\mathrm{2}\right)T_{\mathrm{2}}}=\frac{\mathrm{20}}{\mathrm{13}}.\end{array}$$ (6)

The proof is completed.

Lemma 9 —

If (6/13)T ₂ ≤ t(x ₂ ^j−1) ≤ (10/13)T ₂, then t(S ₂) > (10/13)T ₂ will never happen.

Proof —

If (6/13)T ₂ ≤ t(x ₂ ^j−1)≤(10/13)T ₂, Algorithm GoS-TL will scheduled the remaining jobs on the first machine, so t(S ₂) = t(x ₂ ^j−1)≤(10/13)T ₂. The proof is completed.

Lemma 10 —

If job J _j is scheduled on the second machine by Algorithm GoS-TL where (7/26)T ₂ < t(x ₂ ^j−1)<(6/13)T ₂ and t(x ₂ ^j)>(10/13)T ₂, then t(S ₂) = t(x ₂ ^j)<(20/13)C _opt.

Proof —

Let J _w be the job that is scheduled on the second machine by Algorithm GoS-TL which satisfies t(x ₂ ^w−1) ≤ 7/13 and (7/26)T ₂ < t(x ₂ ^w−1) + p _w < (6/13)T ₂. Since J _w is scheduled on the second machine by Algorithm GoS-TL and (7/26)T ₂ < t(x ₂ ^w−1) + p _w < (6/13)T ₂, we have t(x ₁ ^w−1) + p _w > (7/13)T ₂; otherwise, Algorithm GoS-TL will scheduled job J _w on the first machine. Moreover, t(x ₁ ^w−1) < (3/13)T ₂ must hold which leads to p _w > (4/13)T ₂. This further implies that t(x ₂ ^w−1) < (2/13)T ₂ since t(x ₂ ^w−1) + p _w < (6/13)T ₂.

If t(x ₁ ^w−1) = 0, then p _w > (7/13)T ₂ which leads to t(x ₂ ^w) > (6/13)T ₂; this is contradicting with the definition of job J _w. Therefore, we have t(x ₁ ^w−1) > 0. Based on step (2.4) of Algorithm GoS-TL, the processing time of the job that is assigned to x ₁ ^w−1 is larger than (3/26)T ₂ since t(x ₂ ^w−1) < (2/13)T ₂. Combined with t(x ₁ ^w−1) < (3/13)T ₂, we know there is only one job in x ₁ ^w−1, call it job J _v. Since job J _v, job J _w, and t(x ₂ ^w−1) need to satisfy

$$\begin{array}{c}{p}_v+p_w>\frac{\mathrm{7}}{\mathrm{13}}{T}_{\mathrm{2}},\\ p_v+t\left(x_{\mathrm{2}}^{w-\mathrm{1}}\right)>\frac{\mathrm{7}}{\mathrm{26}}{T}_{\mathrm{2}},\\ \frac{\mathrm{7}}{\mathrm{26}}{T}_{\mathrm{2}}<t\left(x_{\mathrm{2}}^{w-\mathrm{1}}\right)+p_w<\frac{\mathrm{6}}{\mathrm{13}}{T}_{\mathrm{2}},\end{array}$$ (7)

we can get p _v > (9/52)T ₂, which implies that t(S ₂) < (43/52)T ₂.

Since there is no job with g _j = 2 that will scheduled on the first machine between job J _v and J _j by Algorithm GoS-TL, combined with job J _j being scheduled on the second machine, we have p _v + p _j > (7/13)T ₂. Since p _j > (4/13)T ₂, p _v, p _w, and p _j must satisfy

$$\begin{array}{c}{p}_v+p_w>\frac{\mathrm{7}}{\mathrm{13}}{T}_{\mathrm{2}},\\ p_v+p_j>\frac{\mathrm{7}}{\mathrm{13}}{T}_{\mathrm{2}},\\ p_w+p_j\ge \frac{\mathrm{9}}{\mathrm{13}}{T}_{\mathrm{2}},\end{array}$$ (8)

which implies that C _opt > (7/13)T ₂, hence,

$$\begin{array}{c}\frac{t\left(S_{\mathrm{2}}\right)}{C_{\text{opt}}}<\frac{\left(\mathrm{43}/\mathrm{52}\right)T_{\mathrm{2}}}{\left(\mathrm{7}/\mathrm{13}\right)T_{\mathrm{2}}}=\frac{\mathrm{20}}{\mathrm{13}}.\end{array}$$ (9)

The proof is completed.

Based on Lemma 4 to Lemma 10 and Corollary 5 to Corollary 7, we have the following theorem naturally.

Theorem 11 —

The competitive ratio of Algorithm GoS-TL is 20/13 for P2 · GoS | sum · lower | C _max⁡.

5. Optimal Algorithm for P2 · GoS | sum · high&sum · lower | C _max

In this section, we show a lower bound of competitive ratio and present an optimal algorithm for the semi-online version as T ₁ and T ₂ are known in advance.

5.1. Lower Bound of Competitive Ratio

Theorem 12 —

Any semi-online algorithm for P2 · GoS | sum · high&sum · lower | C _max⁡ has a competitive ratio of at least 4/3.

Proof —

The theorem will be proved by adversary method. Let T ₁ = 1/3 and T ₂ = 5/3 be known in advance. The first job is J ₁ = (1/3, 1). Job J ₁ must be scheduled on the first machine. Then job J ₂ = (1/3, 2) arrives. If job J ₂ is scheduled on the second machine, we further generate jobs J ₃ = (1,2) and J ₄ = (1/3, 2). In this situation, we have C _A ≥ 4/3 and C _opt = 1 since the optimal algorithm will scheduled jobs J ₁, J ₂, and J ₄ on the first machine and scheduled job J ₃ on the second machine. Thus, we have C _A/C _opt ≥ 4/3. Otherwise, if job J ₂ is scheduled on the first machine, then we further generate jobs J ₃ = (2/3, 2) and J ₄ = (2/3, 2). In this situation, we also have C _A ≥ 4/3 and C _opt = 1 since the optimal algorithm will scheduled jobs J ₁ and J ₃ on the first machine and scheduled jobs J ₂ and J ₃ on the second machine. The proof is completed.

5.2. Optimal Semi-Online Algorithm GoS-TB

In this subsection, we design an optimal algorithm with a competitive ratio of 4/3. Since we know T ₁ in advance and all the jobs with g _j = 1 must be scheduled on the first machine, therefore, we can regard them as one job, that is, J ₀ = (T ₁, 1). We scheduled job J ₀ on the first machine at first and do not need to care about the job with g _j = 1 later. We present Algorithm GoS-TB as follows.

Algorithm GoS-TB

1. Scheduled J ₀ to the first machine and t(S ₁ ⁰) = T ₁.

2. Let p _j = 0 for all the jobs with g _j = 1.

3. Suppose that the incoming job is J _j and g _j = 1; assign job J _j to the first machine.

4. Suppose that the incoming job is J _j and g _j = 2.

   • (4.1)
     If t(S ₁) + p _j ≤ (2/3)(T ₁ + T ₂), scheduled it to the first machine.
   • (4.2)
     (Stopping criterion). Suppose t(S ₁) + p _j > (2/3)(T ₁ + T ₂).
     • (4.2.1)
       If t(S ₁ ^j−1) > (1/3)(T ₁ + T ₂), scheduled job J _j and the remaining jobs with GoS = 2 on the second machine and scheduled the remaining jobs with GoS = 1 to the first machine. Stop.
     • (4.2.2)
       If t(S ₁ ^j−1) ≤ (1/3)(T ₁ + T ₂), scheduled job J _j to the second machine, and scheduled the remaining jobs to the first machine. Stop.

Theorem 13 —

The competitive ratio of Algorithm GoS-TH is 4/3 for P2 · GoS | sum · high&sum · lower | C _max⁡.

Proof —

Since the job with g _j = 1 is scheduled at first and we do not need to care about them after that. We focus on the jobs with g _j = 2.

Assume job J _j is the first job with g _j = 2 to make t(S ₁) + p _j > (2/3)(T ₁ + T ₂). We prove it by the following two cases.

Case   1 (t(S ₁ ^j−1)>(1/3)(T ₁ + T ₂)). In this case, Algorithm GoS-TB schedules job J _j and the remaining jobs with GoS = 2 on the second machine. Therefore, t(S ₁) ≤ (2/3)(T ₁ + T ₂) and t(S ₂) ≤ T ₁ + T ₂ − t(S ₁) < (2/3)(T ₁ + T ₂). Since C _opt ≥ (1/2)(T ₁ + T ₂), we have C _GoS-TH = max⁡{t(S ₁), t(S ₂)} ≤ (2/3)(T ₁ + T ₂) ≤ (4/3)C _opt.

Case   2 (t(S ₁ ^j−1)≤(1/3)(T ₁ + T ₂)). In this case, we have p _j > (1/3)(T ₁ + T ₂). Algorithm GoS-TH will only scheduled job J _j on the second machine and scheduled the remaining jobs on the first machine. If p _j ≥ (1/2)(T ₁ + T ₂), we have C _opt = p _j and t(S ₁) ≤ p _j = t(S ₂). Therefore, C _GoS-TH = C _opt. Otherwise, (1/3)(T ₁ + T ₂) < p _j < (1/2)(T ₁ + T ₂), which leads to t(S ₁) ≤ T ₁ + T ₂ − t(S ₂) < (2/3)(T ₁ + T ₂). Hence, we have C _GoS-TH = max⁡{t(S ₁), t(S ₂)} ≤ (2/3)(T ₁ + T ₂) ≤ (4/3)C _opt. The proof is completed.

Conflict of Interests

The authors declare that there is no conflict of interests regarding the publication of this paper.