Scheduling equal-length jobs with arbitrary sizes on uniform parallel batch machines

Lemma 1

[12] If J has divisible job sizes, then any set of jobs from J that individually do not exceed s j and that in total sum to at least s j must contain a subset that sums exactly to s j , where s j denotes the size of job j .

Lemma 2

If OPT ≤ T , Assignment A will generate a feasible schedule in O ( m + n log n ) time for Q ∣ s j (divisible), p j = p , p - batch , K i ∣ C max whose makespan is at most T.

Proof

We need to prove that if OPT ≤ T , then U m = ∅ when Assignment A terminates. Thus, a feasible schedule will be generated.

Let Σ ∗ be an optimal schedule. Let Σ be the schedule generated by Assignment A. Let k i ∗ denote the number of batches processed on machine M i in Σ ∗ . Let k i denote the number of actually generated (i.e., non-empty) batches processed on machine M i in Σ .

Label the batches on M 1 in Σ in increasing order of their start times as B 1 , B 2 , … , B k 1 . Label the batches on M 2 in Σ in increasing order of their start times as B k 1 + 1 , B k 1 + 2 , … , B k 1 + k 2 . Repeat this label process for the batches on the other machines. Finally, label the batches on M m in Σ in increasing order of their start times as B k 1 + k 2 + ⋯ + k m − 1 + 1 , … , B k 1 + k 2 + ⋯ + k m − 1 + k m . Accordingly, label the batches in Σ ∗ on the corresponding positions as B 1 ∗ , B 2 ∗ , … , B k 1 + k 2 + ⋯ + k m − 1 + k m ∗ . Since OPT ≤ T , some batches among B 1 ∗ , B 2 ∗ , … , B k 1 + k 2 + ⋯ + k m − 1 + k m ∗ may be empty.

We will modify Σ ∗ in such a way that batches B 1 ∗ , B 2 ∗ , … , B k 1 + k 2 + ⋯ + k m − 1 + k m ∗ become B 1 , B 2 , … , B k 1 + k 2 + ⋯ + k m − 1 + k m one by one. In the end, Σ ∗ is modified into Σ . It follows that U m = ∅ when Assignment A terminates.

For simplicity of notation, assume for the moment that batch B 1 consists of jobs 1 , 2 … , n ′ such that s 1 ≥ s 2 ≥ ⋯ ≥ s n ′ . Consider batch B 1 ∗ . Suppose that B 1 ∗ contains jobs 1 , 2 … , h , but does not contain job h + 1 , where h + 1 ≤ n ′ . Let B ∗ denote the batch containing job h + 1 in Σ ∗ ( B ∗ may be processed on a machine other than M 1 ). Let A denote the set of jobs in B 1 ∗ but not in B 1 . By Step 2(ii) of Assignment A, each job in A has size at most s h + 1 . Now, by Lemma 1, either the total size of the jobs in A is less than s h + 1 or some subset of those jobs sums exactly to s h + 1 . In either case, we can exchange the corresponding jobs in B 1 ∗ and job h + 1 in B ∗ , such that job h + 1 appears in (modified) B 1 ∗ . Repeat the process until batch B 1 appears in (modified) Σ ∗ .

Repeat the aforementioned process to modify batches B 2 ∗ , B 3 ∗ , … , B k 1 + k 2 + ⋯ + k m − 1 + k m ∗ in order until Σ ∗ becomes Σ . Hence, Assignment A will generate a feasible schedule whose makespan is at most T .

It remains to offer an implementation of Assignment A, which gives the required time complexity. Clearly, the overall running time of the procedure is dominated by Step 2(ii). Note that we handle an empty batch on M i only when the first job in U i (which has the largest size among the jobs in U i ) cannot be accommodated in any non-empty batches on M i . If an empty batch is handled, at least one job will be filled in it. It follows that ∑ i = 1 m k i ≤ n .

Each iteration of Step 2(ii) can be executed by a naive quadratic time implementation. Also, there are easy implementations such that each iteration of Step 2(ii) can be executed in sub-quadratic time, leading to an overall running time O ( m n log n ) of Assignment A. However, Step 2(ii) behaves very much like the First Fit algorithm for the bin-packing problem [7,35], in that it assigns the jobs depending predominantly on the order of the batches in the original left to right sequence. We can adapt a binary tree data structure used for the First Fit algorithm [35] to execute (all iterations of) Step 2(ii) in sub-quadratic time, thus leading to an overall running time O ( m + n log n ) of Assignment A.

Precisely, in the i -iteration of Step 2(ii), we will construct a binary tree of depth O ( log k i ) with k i leaves corresponding to the actually generated batches B k 1 + k 2 + ⋯ + k i − 1 + 1 , … , B k 1 + k 2 + ⋯ + k i − 1 + k i on M i , in sequence from left to right. The k i leaves are labeled with the unused capacities of the corresponding actually generated batches on M i . Each internal node is labeled with the larger of the labels of its (at most) two sons, and hence the largest unused capacity over all the actually generated batches corresponding to the leaves which descend from that node.

The tree is constructed incrementally, which is different from [35]. Let leaves denote the number of its current leaves. Initially, l e a v e s = 1 and the tree consists of only one leaf whose label is K i . It grows in two phases, but the second phase may possibly not exist. Moreover, the tree grows new leaves only in the first phase. In the second phase, the labels of the nodes may decrease, but no new leaf will appear.

In the first phase, we scan U i and every job encountered must be assigned to M i . The first phase ends when U i = ∅ , or l e a v e s = min { n , ⌊ T ⋅ v i / p ⌋ } but the first job in U i cannot be filled into a non-empty batch on M i without exceeding K i . Only in the latter case, the second phase begins. In the second phase, we stop scanning U i . Instead, we do a binary search in U i to find the largest job which can be filled into a non-empty batch on M i without exceeding K i (ties broken in favor of the first such job in U i ). Assign this job to such a batch that is started earliest and delete it from U i . We repeat the process until any job in U i cannot be filled into a non-empty batch on M i without exceeding K i , and the second phase ends.

Below, let us illustrate the implementation details.

In the first phase, we scan U i from the first job to the last job. For each job encountered, we check the label of the tree root. There are two different cases to consider:

Case 1. The label of the root is not less than the size of the job.

In this case, the job can be filled into a batch on M i which corresponds to a leaf of the tree, without exceeding K i . To assign the job, we traverse the tree, from the root to a leaf, by always taking the leftmost node whose label is not less than the size of the job. Fill the job into the batch corresponding to the destination leaf.

The path from the tree root to the destination leaf is an updating path. Update the labels of the nodes on the updating path as follows. First, let the label of the destination leaf be equal to its value minus the size of the job. Then, proceed back up the updating path and relabel the label of each internal node with the larger of the labels of its (at most) two sons. Keep l e a v e s unchanged. Delete this job from U i .

Case 2. The label of the root is less than the size of the job.

In this case, the job cannot be filled into a non-empty batch on M i without exceeding K i . There are two different cases to consider:

Subcase 2.1. l e a v e s < min { n , ⌊ T ⋅ v i / p ⌋ } .

We fill this job into an empty batch which starts earliest on M i . Delete this job from U i . If the tree has no node of degree one, then insert a new node as the tree root whose left son is the old root. Insert a new leaf u in the tree as the right son of the lowest node w of degree one. Leaf u corresponds to the batch accommodating the job and its label is K i minus the size of the job. If u is not on the same depth as all the other leaves, then insert several new nodes w 1 , w 2 , … , w b on the edge ⟨ w , u ⟩ such that leaf u is on the same depth as all the other leaves. Node w 1 is the right son of w , while node w a + 1 is the left son of w a , a = 1 , 2 , … , b − 1 , and leaf u becomes the left son of w b . The path from the tree root to u is an updating path. Update the labels of the nodes back up the updating path such that each internal node is labeled with the larger of the labels of its (at most) two sons. Let l e a v e s = l e a v e s + 1 .

Subcase 2.2. l e a v e s = min { n , ⌊ T ⋅ v i / p ⌋ } .

It indicates that the first phase ends, and we have to enter the second phase.

Constructing the binary tree used in the i -iteration can be done in O ( k i log k i ) time, since the tree has only k i leaves and its depth is O ( log k i ) . Using the tree, in the first phase, we can assign a job in Q i into a batch on M i (Case 1 and Subcase 2.1) in O ( log k i ) time. Since ∑ i = 1 m k i ≤ n , constructing the binary trees in all m iterations can be accomplished in O ( m + n log n ) time. Assigning jobs into batches in the first phase in all m iterations can also be accomplished in O ( m + n log n ) time. (Each machine has to be checked once, though some machines may process no batches at all.)

In the second phase, using a binary search in U i instead of scanning it, we find the largest job in U i whose size is not larger than the label of the root (ties broken in favor of the first such job in U i ). Assign this job into a non-empty batch on M i without exceeding K i via the constructed binary tree (as described in Case 1), and delete it from U i . We update the labels of the tree accordingly. Repeat this process until any job in U i has a size larger than the label of the root, indicating that no job can be filled into a non-empty batch on M i without exceeding K i . The second phase ends.

Assigning each job to a batch in the second phase can be done in O ( log n ) time. Assigning jobs into batches in the second phase in all m iterations can be accomplished in O ( n log n ) time.

Hence, the time complexity of Assignment A is O ( m + n log n ) .□

Example 1

Here is an example to illustrate how the binary tree grows. Fix a particular machine M i . In U i , there are six jobs of size 8, six jobs of size 4, two jobs of size 2 and two jobs of size 1, sorted in non-increasing order of their sizes. The job sizes form a divisible sequence. Let K i = 13 and min { n , ⌊ T ⋅ v i / p ⌋ } = 3 . Each of the first three jobs in U i will be filled into an empty batch. For ease of explanation, during the illustration we will not delete the assigned jobs from U i . The state of the binary tree after the first three jobs of size 8 are assigned is shown in Figure 1. The assigned jobs (represented by their sizes) are provided at the leaves of the tree, and the labels of all the nodes are also provided.

Theorem 1

There is an exact algorithm (the binary search together with Assignment A or Assignment A1) for Q ∣ s j (divisible), p j = p , p -batch , K i ∣ C max that runs in O ( m n log m + n log n ⋅ log ( m n ) ) time.

Proof

The correctness of the algorithm follows from the aforementioned analysis. Procedure Assignment A (or Assignment A1) runs in O ( m + n log n ) time for any given value of T . Since there are O ( log ( m n ) ) iterations to determine OPT , the whole algorithm runs in O ( m n log m + n log n ⋅ log ( m n ) ) time. (The first term comes from the sorting procedure performed once at the beginning.)□

Lemma 3

If OPT ≤ T , Assignment B will generate a schedule allowing one-job-overfull batches in O ( m + n ) time for Q ∣ s j , p j = p , p -batch , K i ∣ C max whose makespan is at most T .

Theorem 2

There is a 2-approximation algorithm for Q ∣ s j , p j = p , p -batch , K i ∣ C max that runs in O ( m n log m + n log ( m n ) ) time.

Proof

The binary search equipped with Assignment B will return a schedule allowing one-job-overfull batches for Q ∣ s j , p j = p , p -batch , K i ∣ C max whose makespan is at most OPT . In the last step of the algorithm, for each one-job-overfull batch in the schedule, we open a new batch for the last packed job in it and process the new batch immediately after it on the same machine. Therefore, the final schedule has makespan at most 2 OPT .□