Batch Scheduling on Two-Machine Flowshop with Machine-Dependent Setup Times

Abstract

We study a batch scheduling problem on a 2-machine flowshop. We assume unit processing time jobs, batch availability, and machine-dependent setup times. The objective is to find a job allocation to batches of integer size and a batch schedule that minimize makespan. We introduce a very efficient closed form solution for the problem.

1. Introduction

The recent survey paper “A Survey on Scheduling Problems with Setup Times and Costs” [1], classifies batch scheduling problems into those with batching and nonbatching considerations, with sequence-independent and sequence-dependent setup times, and according to the machine environment and the objective function. The survey contains approximately 300 references, a clear indication of the importance and relevance of this topic.

In this paper we study batch scheduling problems on a 2-machine flowshop. The objective function is minimum makespan. The underlying assumptions in the model studied are as follows.

(i)Batch  availability: all the jobs are completed when the last job of the batch is completed (and then the entire batch is available for processing on the second machine, or for delivery to customers).(ii)Nonanticipatory  setups: setups on the second machine may be performed only after processing of the batch on the first machine has been completed.(iii)Batch  consistency: batch formation is identical on both machines.(iv)Machine-dependent  setup  times: machine 1 and machine 2 have different setup times (which are identical for all batches).

The 2-machine flow-shop under the above assumptions was shown to be strongly NP-hard by Cheng et al. [2], and Glass et al. [3]. We focus, however, on an important special case, which is shown to have an elegant closed form solution. Specifically, we assume unit processing time jobs. This setting is known to have various applications, and in the manufacturing context, for example, it reflects the common systems in which sequences of identical items are produced. Scheduling with unit jobs has been studied extensively in many scheduling contexts. Batch scheduling on flowshops with unit processing time jobs have been studied by Mosheiov and Oron [4, 5], Ng and Kovalyov [6], and Mosheiov, et al. [7].

In all the above papers, the authors consider identical (i.e., machine-independent) setup times. Our study, as mentioned, focuses on machine-dependent setups. Scheduling problems containing machine-dependent setups exist in numerous real-life applications, and have been extensively studied in various contexts. It appears, however, that a model assuming both unit jobs and machine-dependent setups is considered in this paper for the first time. Possible applications for such a setting, when similar or identical operations, are performed on the jobs on the different machines, but an additional operation requiring constant time must be performed on one of the machines (or different constant time operations are performed on the different machines). These operations may be viewed as batching operations, where all jobs of a given batch undergo some type of process which is performed in constant time, independent of the number of jobs in the batch. Such operations may include special loading or recording of arriving batches on the first machine, initial quality assurance, or special preparation of batches prior to processing. Constant time operations on the last machine include, again, preparation of batches for shipment and dispatching of batches (stamping, spray painting), quality assurance procedures (random testing of a fixed number of items or batching procedures such as scanning), or administrative operations which may include paperwork, recording of data, and so forth.

We distinguish between the following two (similar but nonsymmetric) cases: (𝑖) the setup on the first machine is larger than the setup on the second machine, and, (𝑖𝑖) the setup on the first machine is smaller than the setup on the second machine. For both cases, we show that the makespan minimization problem is solved efficiently in 𝑂(√𝑛) time, where n is the number of jobs. It is important to note that the existing algorithms solve a special case of the problem studied in this paper, namely, when 𝑠₁=𝑠₂, in 𝑂(𝑛) time. Thus, the algorithm presented in this paper reduces the computational effort required to obtain an optimal solution even if the problem is more complex. It should be noted that both the existing algorithms and the current solution procedure are not polynomial in the problem input size. Since we consider unit processing time jobs, the input consists of three values (𝑂(1)), the number of jobs, and the setup time on each of the two machines. Thus, even a procedure requiring 𝑂(√𝑛) time is exponential in the input size. Nevertheless, we doubt that there is a way to express the optimal solution to this problem more efficiently.

It should be noted that a first step in the solution consists of solving the “relaxed version” in which integrality of the batch sizes is not required (see below). This, in fact, is a lot streaming problem, as it consists of splitting given jobs into sublots in order to allow their overlapping processing on the two successive machines of the flowshop. Chen and Steiner [8, 9], and Liu [10] addressed lot streaming problems on flow-shops with batches of integer size. Vickson [11] addressed lot streaming of a flow-shop with machine-dependent setup times. However, to the best of our knowledge, the model considered in this paper (assuming machine-dependent setups, and requiring integrality of batch sizes), has not been studied before.

In Section 2, we present the notation and formulation of the problem. The optimal solution is provided in Section 3 (and the appendix). Section 4 contains concluding remarks and ideas for future research.

2. Formulation

𝑛 independent jobs are available for processing on a 2-machine flowshop at time zero. 𝑝_𝑖𝑗 denotes the processing time of job  𝑗(𝑗=1,2,…,𝑛) on machine 𝑖(𝑖=1,2). We assume unit processing times, therefore 𝑝_𝑖𝑗=1 for 𝑗=1,2,…,𝑛 and for i = 1,2. The scheduler's task is to partition jobs into batches (i.e., find their optimal number and size), and to schedule the batches so as to minimize makespan.

Prior to processing a new batch, an (integer) machine dependent setup time, 𝑠_𝑖,𝑖=1,2, is incurred. As mentioned above, setups are assumed to be nonanticipatory. For a given allocation to batches, let 𝑘 denote the number of batches, and let 𝑛_𝑗 denote the size of the 𝑗th batch. The total processing time of batch 𝑗 is clearly equal to its size. We assume (see above) batch-availability and batch consistency. 𝐶_𝑗 denotes the completion time of batch 𝑗, which is the completion time of all the jobs contained in batch 𝑗. Using the conventional three field notation, the problem studied in this paper is 𝐹2/𝑠-𝑏𝑎𝑡𝑐ℎ,𝑝_𝑖𝑗=1,𝑠_𝑖/𝐶_max.

Comment 1. A standard assumption is that all input parameters are nonnegative integers, implying in our case that both the (identical) processing times and the (machine-dependent) setups are integers. One can assume that after appropriate scaling all processing times have unit time, but clearly the setups do not necessarily remain integers. Thus, we do allow and investigate the case of noninteger setup times; see Comment 3 in Section 3 and Comment A.1 in the appendix. (Note that the computational effort for this more general case remains  𝑂(√𝑛) through the use of the proposed algorithm.)

3. A Closed Form Solution for 𝐹2/𝑝_𝑖𝑗=1,𝑠_𝑖/𝐶_max

We focus here on the case that the setup time on the first machine is smaller, that is 𝑠₁<𝑠₂. (The case 𝑠₁>𝑠₂, although not completely symmetric, is similar and its analysis appears in the appendix. The case of machine independent setups, that is, when 𝑠₁=𝑠₂, is studied in [4, 6].) For convenience we begin by solving the relaxed version of the problem (denoted by  𝑃_𝑅), in which batch sizes are allowed to have noninteger values.

First, we introduce a lower bound on the optimal makespan for a given number of batches, k. As in the classical 2-machine flow-shop problem, a lower bound is obtained when no idle time is incurred between consecutive batches on the second machine. Given the unavoidable idle time prior to the processing of the first batch on the second machine, we obtain

LB=𝑠₁+𝑛₁+𝑘𝑠₂+𝑛. (3.1)

A schedule attaining this lower bound must contain no idle time between consecutive jobs on the second machine. A necessary and sufficient condition for no idle time is the following: 𝑛_𝑗+1≤𝑛₁+𝑗(𝑠₂−𝑠₁),𝑗=1,…,𝑘−1. This is true since the completion time of batch 𝑗+1 on the first machine (=(𝑗+1)𝑠₁+𝑛₁+𝑛₂+⋯+𝑛_𝑗+1) cannot exceed the completion time of batch 𝑗 on the second machine (=𝑠₁+𝑛₁+𝑗𝑠₂+𝑛₁+𝑛₂+⋯+𝑛_𝑗). One schedule satisfying these conditions consists of batch sizes obtained by the following set of equalities: 𝑛_𝑗+1=𝑛₁+𝑗(𝑠₂−𝑠₁),𝑗=1,…,𝑘−1. The resulting schedule consists of the following sequence of increasing batch sizes: 𝑛_𝑗+1=𝑛_𝑗+(𝑠₂−𝑠₁),𝑗=1,…,𝑘−1. Given the fact that ∑^𝑘_𝑗=1𝑛_𝑗=𝑛, we easily obtain that

𝑛₁=𝑛𝑘−𝑘−12(𝑠₂−𝑠₁),𝑛_𝑗+1=𝑛_𝑗+(𝑠₂−𝑠₁),𝑗=1,…,𝑘−1. (3.2) The above schedule has a makespan value which is equal to the lower bound, and is therefore optimal for problem 𝑃_𝑅 and a given k value.

The makespan value of the above schedule is

𝐶_max(𝑘)=𝑠₁+𝑛𝑘−𝑘−12(𝑠₂−𝑠₁)+𝑘𝑠₂𝑛+𝑛=𝑘+𝑛+𝑘+12(𝑠₁+𝑠₂). (3.3) Note that (3.3) is a strictly convex function in k  and the unique minimum is given by

𝑘^∗=2𝑛𝑠₁+𝑠₂. (3.4) Recall that k denotes the optimal (integer) number of batches, and therefore, due to the convexity of(3.3)

𝑘=⌈𝑘^∗⌉or𝑘=⌊𝑘^∗⌋. (3.5) Both 𝑘=⌈𝑘^∗⌉ and 𝑘=⌊𝑘^∗⌋ should be considered.

We conclude that an optimal solution for the relaxed version of the problem (𝑃_𝑅) is given by (3.4), (3.5), and (3.2).

We now consider the original problem, where batch sizes are restricted to be integers, denoted by𝑃_INT. A lower bound on the optimal solution is

LB(𝑘)=⌈𝑠₁+𝑛𝑘−𝑘−12(𝑠₂−𝑠₁)+𝑛+𝑘𝑠₂⌉=𝑠₁𝑛+⌈𝑘−𝑘−12(𝑠₂−𝑠₁)⌉+𝑛+𝑘𝑠₂. (3.6) (Note that as defined above 𝑛₁  is the size of the first batch of the solution of relaxed version. In the special case that 𝑛₁=𝑛/𝑘−((𝑘−1)/2)(𝑠₂−𝑠₁) is integer, then, clearly, the “ceiling” is redundant, and the lower bound is identical to the makespan value given in (3.3).)

The lower bound given in (3.6) is the smallest integer which is larger than or equal to the makespan value for problem  𝑃_𝑅. Any schedule that consists of batches of integer size yielding this makespan is clearly optimal.

If 𝑛₁ (given in (3.2) is integer, then clearly all batches are integers and the solution for problem 𝑃_𝑅 is optimal for the original problem, 𝑃_INT. For the general case, where 𝑛₁ is not necessarily integer, let Δ=𝑛₁−⌊𝑛₁⌋(=𝑛_𝑖−⌊𝑛_𝑖⌋,𝑖=1,…,𝑘).

Since 𝑛=∑^𝑘_𝑖=1𝑛_𝑖=∑^𝑘_𝑖=1(⌊𝑛_𝑖⌋+Δ)=∑^𝑘_𝑖=1⌊𝑛_𝑖⌋+𝑘Δ, we obtain that 𝑘Δ is an integer (strictly smaller than k). Based on the solution for problem 𝑃_𝑅, we construct a solution for problem 𝑃_INT by rounding down the size of 𝑙 batches and rounding up the size of the remaining 𝑘−𝑙 batches, where 𝑙=(1−Δ)𝑘. One option is to round up the size of the first 𝑘−𝑙 batches, and round down the size of the last l batches. The resulting job allocation to batches is ⌈𝑛₁⌉,⌈𝑛₂⌉,…,⌈𝑛_𝑘−𝑙⌉,⌊𝑛_{𝑘−𝑙+1}⌋,⌊𝑛_{𝑘−𝑙+2}⌋,…,⌊𝑛_𝑘⌋. It is easily verified that in the above schedule: (𝑖) the idle time prior to batch 1 on machine 2 is 𝑠₁+⌈𝑛₁⌉=𝑠₁+⌈𝑛/𝑘−((𝑘−1)/2)(𝑠₂−𝑠₁)⌉, and (𝑖𝑖) there is no idle time between consecutive batches on machine 2. Thus, the makespan value of this schedule is

𝐶_max(𝑘)=𝑠₁𝑛+⌈𝑘−𝑘−12(𝑠₂−𝑠₁)⌉+𝑛+𝑘𝑠₂. (3.7) Note that the above value for the makespan is identical to the lower bound for problem 𝑃_INT given in (3.6). We conclude that for any value of 𝑘, the above schedule is optimal.

Comment 2. It is worth mentioning that the optimal solution is not unique, and other rounding procedures may lead to other optimal schedules. One alternative example consists of rounding down the first l batches and rounding up the last 𝑘−𝑙 batches.
The resulting job allocation to batches is ⌊𝑛₁⌋,⌊𝑛₂⌋,…,⌊𝑛_𝑙⌋,⌈𝑛_𝑙+1⌉,⌈𝑛_𝑙+2⌉,…,⌈𝑛_𝑘⌉.
In this case, it is easily verified that (𝑖) there is no idle time between consecutive batches on machine 2 for 𝑗=1,2,…,𝑙, (𝑖𝑖) there exists 1 unit of idle time between batches 𝑙 and 𝑙+1, and (𝑖𝑖𝑖) there is no idle time between consecutive batches on machine 2 for 𝑗=𝑙+1,…,𝑘. The makespan value of this schedule (clearly, given that 𝑛₁ is not integer) is 𝐶_max(𝑘)=⌊𝑛₁⌋+𝑠₁+𝑛+𝑘𝑠₂𝑛+1=⌊𝑘−𝑘−12(𝑠₂−𝑠₁)⌋+𝑠₁+𝑛+𝑘𝑠₂+1. (3.8) This value for the makespan is identical to the value given in (3.7), implying that this schedule is optimal as well.

It remains to find the optimal number of batches, 𝑘. Note that due to the integrality of 𝑠₁ and 𝑠₂, the makespan function (3.7) can be slightly modified as follows:

𝐶_max(𝑘)=𝑠₁𝑛+⌈𝑘−𝑘−12(𝑠₂−𝑠₁)⌉+𝑛+𝑘𝑠₂=⌈𝑠₁+𝑛𝑘−𝑘−12(𝑠₂−𝑠₁)+𝑛+𝑘𝑠₂⌉. (3.9) It follows that the 𝑘 value minimizing (3.7) also minimizes (3.9). Hence the optimal k value for the relaxed version given in (3.4) and (3.5) is optimal for the integer version. We denote the latter by 𝑘^opt. A formal algorithm is provided in Algorithm 3.1.

Algorithm 3.1 (flowshop_makespan_𝑠₁<𝑠₂). Input: 𝑛,𝑠₁,𝑠₂.Step 1 (Optimal number of batches). Calculate 𝑘₁=⌈𝑘^∗⌉and 𝑘₂=⌊𝑘^∗⌋ (from (3.4) and (3.5).
If 𝐶_max(𝑘₁)≤𝐶_max(𝑘₂) (in (3.7), then 𝑘^opt=𝑘₁; otherwise 𝑘^opt=𝑘₂.Step 2 (Optimal batches). 𝑛₁=𝑛𝑘^opt−𝑘^opt−12(𝑠₂−𝑠₁),𝑛_𝑗+1=𝑛_𝑗+(𝑠₂−𝑠₁),𝑗=1,…,𝑘^opt−1 (3.10) (from (3.2).Step 3 (Rounding). Calculate the non-integer part of the batch size,Δ=𝑛₁−⌊𝑛₁⌋.
Calculate the number of batches to be rounded down, 𝑙=(1−Δ)𝑘^opt. 
An optimal integer allocation to batches is ⌈𝑛₁⌉,⌈𝑛₂⌉,…,⌈𝑛_𝑘^opt_−𝑙⌉,⌊𝑛_𝑘^opt_−𝑙+1⌋,⌊𝑛_𝑘^opt_−𝑙+2⌋,…,⌊𝑛_𝑘^opt⌋.

Running Time
It is easily verified that the algorithm is performed in 𝑂(√𝑛) time. While the calculation of the optimal number of batches and the optimal makespan are performed in constant time, Step 2 of the algorithm requires calculating the batch sizes. Since the number of batches is 𝑂(√𝑛), the computational effort required is 𝑂(√𝑛). Step 3 can easily be performed in 𝑂(√𝑛) time, and consequently, the total running time Algorithm 3.1is 𝑂(√𝑛).

The use of Algorithm 3.1 is demonstrated in the following example.

Example 3.2. Assume 𝑛=80, and 𝑠₁=2, 𝑠₂=3. In Step 1 we calculate 𝑘^∗=5.66, and 𝑘^opt=6, (the associate optimal makespan value is 111). In Step 2 we obtain the batch sizes (for the relaxed problem): 𝑛₁=10.833,𝑛₂=11.833,𝑛₃=12.833,𝑛₄=13.833,𝑛₅=14.833, and 𝑛₆=15.833. The rounding procedure (Step 3) leads to the following optimal sequence of batch sizes: 𝑛₁=11,𝑛₂=12,𝑛₃=13,𝑛₄=14,𝑛₅=15, and 𝑛₆=15; see Figure 1. The makespan as a function of the number of batches (both for the relaxed and for the integer versions) is presented in Figure 2.

Figure 1 

Optimal schedule of a 2-machine flowshop (Example 3.2: 𝑛=80,𝑠1<𝑠2,𝑠1=2,𝑠2=3).

Figure 2 

Makespan as a function of the number of batches for the relaxed and the integer versions (Example 3.2: 𝑛=80,𝑠1<𝑠2,𝑠1=2,𝑠2=3).

Comment 3. Consider the interesting generalization to the case of non-integer setup times. In this case, the optimal k value for (3.7) may be different from that of (3.3), (e.g., if 𝑛=80, 𝑠₁=2.1 and 𝑠₂=2.2, we obtain 𝑘^∗=6.099, implying that the optimal 𝑘 value for the relaxed problem is either 6 or 7, however, the optimal 𝑘 value for the integer version is 5.) It appears that in this general case (non-integer setups), a closed form expression for the optimal 𝑘 value does not seem to exist, and a search must be performed. Clearly, a search over all possible 𝑘 values (1 through n) guarantees an optimal solution. However, a limited search appears to be sufficient, due to the fact that the smallest batch 𝑛₁ must be nonnegative. From (3.2) we obtain 𝑛₁=𝑛/𝑘−((𝑘−1)/2)(𝑠₂−𝑠₁)≥0. Consequently, 1/2−1/4+2𝑛/(𝑠₂−𝑠₁)≤𝑘≤1/2+1/4+2𝑛/(𝑠₂−𝑠₁). The first term is strictly negative (recall that 𝑠₂>𝑠₁), implying that k is an integer in the range 1,…,𝑚, where 1𝑚=⌊2+14+2𝑛𝑠₂−𝑠₁⌋. (3.11) We conclude that despite the need to consider a range of possible values for the number of batches, k, the computational effort required for solving the problem with non-integer setup times remains 𝑂(√𝑛).

Comment 4. It is easily verified that the algorithm proposed in this section generalizes the algorithm introduced in Mosheiov and Oron [4], for the case of machine-independent setups. When substituting 𝑠₁=𝑠₂=𝑠 in the expressions along the above algorithm, we obtain the optimal solution for this special case. In particular, substituting 𝑠₁=𝑠₂=𝑠 in Step 2 leads to “equal allocation” to batches (using the terminology of [4]), and the rounding procedure, that is, rounding up the size of the first 𝑘−𝑙 batches and rounding down the size of the remaining 𝑙 batches generates an optimal integer solution.

4. Conclusion

We study a new version of makespan minimization on a 2-machine flowshop. We consider unit time jobs which may be grouped into batches. The setup times are assumed to be machine-dependent. We introduce an elegant closed form solution for two different cases.

A challenging extension is to the setting of an m-machine flowshop (𝑚≥3). Another interesting question refers to a 2-machine jobshop setting. Although not published yet, both problems appear to have similar properties and structures and may have closed form solutions for the number of batches and their sizes. The m-machine jobshop case is known to be strongly NP-hard even with no setups [12]. Thus, future research dealing with this extension may focus either on an introduction of heuristics/approximations or on developing exact (pseudopolynomial) solution algorithms.

Appendix

The Case 𝑠₁>𝑠₂

As mentioned, the analysis of the case 𝑠₁>𝑠₂ is similar to that of the case 𝑠₁<𝑠₂. Again, we focus first on the relaxed version. It is easily verified that lower bound (3.1) for a given number of batches k, still holds. As in the previous case, a schedule attaining this lower bound must have no idle time between consecutive jobs on the second machine. The conditions 𝑛_𝑗+1≤𝑛₁+𝑗(𝑠₂−𝑠₁),𝑗=1,…,𝑘−1are still valid, and since 𝑠₁>𝑠₂, these could be written as 𝑛_𝑗+1≤𝑛₁−𝑗(𝑠₁−𝑠₂),𝑗=1,…,𝑘−1. A schedule based on equalities clearly satisfies these conditions, leading, again, to a constant difference between the size of consecutive batches: 𝑛_𝑗+1=𝑛_𝑗−(𝑠₁−𝑠₂),𝑗=1,…,𝑘−1. Since the total size of all the batches is n, we obtain the following schedule of decreasing batch sizes:

𝑛₁=𝑛𝑘+𝑘−12(𝑠₁−𝑠₂),𝑛_𝑗+1=𝑛_𝑗−(𝑠₁−𝑠₂),𝑗=1,…,𝑘−1. (A.1)

Note that the resulting schedule is identical to the one obtained for the case 𝑠₁<𝑠₂, in a reversed order: the largest batch becomes first, the second-to-largest second, and so forth. This schedule has a makespan value identical to the lower bound (3.1), and is therefore optimal for the relaxed problem and a given k value.

The makespan value is given by

𝐶_max(𝑘)=𝑠₁+𝑛𝑘+𝑘−12(𝑠₁−𝑠₂)+𝑘𝑠₂𝑛+𝑛=𝑘+𝑛+𝑘+12(𝑠₁+𝑠₂). (A.2) (Note that (A.2) is identical to the makespan value (3.3) obtained earlier.) Since the function (A.2) is strictly convex, the optimal (integer) k-value is obtained by a simple differentiation and rounding to one of the two nearest integers (see (3.4) and (3.5). Given this optimal solution for the relaxed problem, we consider again the integer version. We suggest the rounding procedure introduced earlier, that is, round up the first k-l batches, and round down the remaining l batches (where 𝑙=(1−Δ)𝑘, and Δ=𝑛₁−⌊𝑛₁⌋). This schedule of integer batch sizes is optimal since its makespan value (given by (3.7) is identical to the lower bound (3.6). Our last argument refers to the optimal number of integer batches. As in the previous case, due to the integrality of 𝑠₁ and 𝑠₂, the (integer) makespan value is given by

𝐶_max(𝑘)=⌈𝑠₁+𝑛𝑘+𝑘−12(𝑠₁−𝑠₂)+𝑛+𝑘𝑠₂⌉, (A.3) which is minimized by the same k value that minimizes the objective of the relaxed version (A.2). Hence the optimal number of batches is given, as before, by (3.4) and (3.5).

We conclude that an optimal solution for the case 𝑠₁>𝑠₂ is obtained by a very similar (constant time) algorithm to the one introduced for the case 𝑠₁<𝑠₂. (Step 2 is slightly different due to the fact that the sequence of batch sizes is decreasing.) For the sake of briefness, we omit the formal algorithm.

Example A.1. We replace the values of s₁ and s₂ in Example 3.2: n  =  80, s₁  =  3, s₂  =  2. The optimal number of batches (Step 1) remains 6. In Step 2 we obtain the batch sizes (for the relaxed problem): n₁  =  15.833, n₂  =  14.833, n₃  =  13.833, n₄  =  12.833, n₅  =  11.833, and n₆  =  10.833. (Note that this sequence is the reversed sequence obtained for the relaxed problem in Example 3.2.) An optimal integer solution (Step 3) consists of the following sequence of batch sizes: n₁ = 16, n₂ = 15, n₃ = 14, n₄ = 13, n₅ = 12, n₆ = 10; see Figure 3.

Figure 3 

Optimal schedule of a 2-machine flowshop (Example A.1: 𝑛=80,𝑠1>𝑠2,𝑠1=3,𝑠2=2).

Comment A.1. In the case where the setup times are not necessarily integers, finding the optimal number of batches requires a search. Using the fact that the size of the smallest batch (now 𝑛_𝑘=𝑛/𝑘−((𝑘−1)/2)(𝑠₁−𝑠₂)) must be non-negative, we obtain (as in the previous case) the following upper bound on k: 𝑚=⌊1/2+1/4+2𝑛/(𝑠₁−𝑠₂)⌋. Since the search is limited to the integers in the interval [1,m], the total running time in this case becomes 𝑂(√𝑛).