EFFECTIVE HEURISTICS FOR MAKESPAN MINIMIZATION IN PARALLEL BATCH MACHINES WITH NON-IDENTICAL CAPACITIES AND JOB RELEASE TIMES

. We consider the problem of scheduling a set of n jobs with arbitrary job sizes, processing times and release times on a set of m parallel batch machines with non-identical capacities; the objective is to minimize the makespan. We ﬁrst present an algorithm to compute a lower bound for the optimal makespan. Based on diﬀerent rules of batching the jobs and assigning the batches to the machines, several heuristics are proposed to solve the problem. The performance of the proposed heuristics is evaluated by computational experiments. The proposed heuristics are compared against the lower bound and against each other. Our results show that the one of the proposed algorithms outperforms all the other heuristics.

1. Introduction. Scheduling on batch processing machines (BPMs) has wide applications in many industries, such as semiconductor manufacturing, transportation, steel casting, and food processing. It is originally motivated by the burn-in operation in semiconductor fabrication. Due to the long processing time compared with other operations (120 hours versus 4-5 hours), the burn-in operation is often the bottleneck in the semiconductor production [24]. Hence, scheduling the burn-in operation efficiently is crucial in obtaining high productivity. Different from the classical scheduling model, in batch scheduling, a machine can process a group of jobs at the same time. That is to say, the jobs are grouped into batches and the batches are then scheduled on the machines. The processing time of a batch is equal to the longest processing time of the jobs in that batch [30]. In practical application, the sizes of the jobs are non-identical. The total size of all the jobs in a batch cannot exceed the capacity of the machine that processes the batch.
There are two types of batch scheduling problems: serial-batching (s-batching) and parallel-batching (p-batching). In the former type, the jobs in a batch are processed in serial, while in the latter type the jobs in a batch are processed in parallel. P-batch scheduling is important not only in semiconductor manufacturing [32], but also in other modern manufacturing industries, such as chemical and mineral processing, pharmaceutical and metalworking industries, as well as environmental stress screening chamber fabrication [47].
In this paper, we consider a dynamic p-batch scheduling problem on parallel BPMs, where the machine capacities are non-identical. A set of jobs with nonidentical job sizes and processing times have to be grouped into batches such that the total size of the jobs in the batch cannot exceed the capacity of the machine that processes it. The jobs have non-identical release times. The batches are then scheduled on the machines so as to minimize the makespan. Once a batch is being processed, it cannot be interrupted and no job can be added into or removed from the batch. The problem of minimizing the makespan on a single BPM with nonidentical job sizes and identical release times has been shown to be NP-hard [38]. Therefore, our problem is also NP-hard.
The problem can be resolved by solving two independent subproblems: grouping the jobs into batches and then scheduling the batches on the parallel BPMs. We propose two batching algorithms to group the jobs into batches; i.e., heuristics based on the First-Fit and the Best-Fit rules. Then two heuristics based on the First-Fit and the Best-Fit rules are applied to schedule the batches on the machines. In all, there are four heuristics proposed to solve the problem.
The rest of the paper is organized as follows. In Section 2, we review related work on BPM scheduling problems. Section 3 formally defines the problem. In Section 4, we present a method to compute a lower bound for the optimal makespan. The proposed algorithms are described in Section 5. With elaborate experimental design, the proposed heuristics are compared with the lower bound and against each other in Section 6. Finally, in Section 7, we draw some concluding remarks and give some possible directions for future studies.
2. Literature review. In classical machine scheduling, parallel machine scheduling have been extensively studied over the last three decades [44,48,28]. Jobs with machine eligibility restrictions have also been extensively studied [26]. Ou et al. [33] give a heuristic for inclusive processing set restrictions with worst-case performance ratio at most 4/3. Huo and Leung [16] provide a faster algorithm for a more general case with the same worst-case bound. The difference between our paper and previous studies is that we are scheduling parallel-batch jobs, rather than traditional jobs. Although significant studies have been devoted to batch scheduling problems, we only focus on reviewing those work that have commonalities in their assumptions with ours, especially those of non-identical job sizes.
The earliest study in this area can be traced back to Ikura and Gimple [17], who propose an algorithm to minimize the makespan on a single BPM with identical processing time, unit job size, and dynamic job arrivals. After that, more research has been done on this problem. Uzsoy [38] proves that scheduling jobs with nonidentical job sizes on a single BPM so as to minimize makespan is strongly NP-hard. He then present several heuristics and a branch-and-bound algorithm. Among the heuristics he presented, the First-Fit-Longest-Processing-Time (FFLPT) heuristic shows the best performance. The p-batch scheduling problem can be partitioned into two subproblems; i.e., grouping the jobs into batches and scheduling the batches on the machines. The first subproblem shares some similarities with the bin-packing problem [21]. Dupont and Jolai Ghazvini [12] give two heuristics; i.e., the Best-Fit-Longest-Processing-Time (BFLPT) and the Successive Knapsack (SK). The former heuristic is based on the Best-Fit rule for the bin-packing problem, while the latter constructs a solution batch by batch to minimize the unoccupied space of the batches. According to experimental results, the BFLPT method is better than the SK method. Uzsoy and Yang [40] present several heuristics and a branch-andbound algorithm to minimize the total weighted completion time. For minimizing the makespan on a single BPM, Dupont and Dhaenens-Flipo [11] propose a branch-and-bound algorithm. Zhang et al. [49] are the first ones to give worstcase performance bounds for several heuristics for the makespan minimization on a single BPM. Li et al. [27] develop an approximation algorithm for the general problem with non-identical release times. Tang et al. [37] propose a heuristic algorithm to solve the coordinated scheduling problem of hybrid batch production on a single batching machine and two-stage transportation connecting the production. Fan et al. [13] provide the pseudo-polynomial-time algorithms to solve the bi-criteria scheduling on a single batch machine to minimize two regular scheduling criteria, i.e., the total weighted completion time and the weighted total number of tardy jobs, that are non-decreasing in the job completion times. Recently, metaheuristics, such as simulated annealing (SA) [10], genetic algorithms (GA) [20], ant colony optimization (ACO) [6] and max-min ant system (MMAS) [18] have been applied to solve the p-batch scheduling problem on a single BPM.
Considering that jobs in practice often arrive at different times, Lee and Uzsoy [25] present polynomial and pseudo-polynomial time algorithms for some special cases and heuristics for makespan minimization on a single BPM. Sung and Choung [36] study the same problem and develop several heuristics. For scheduling on a single BPM with job release times, Wang and Uzsoy [42] present a GA combined with dynamic programming to minimize the maximum lateness, while Kruz and Mason [23] propose a heuristic to minimize the total tardiness. By using the features of the problem, Xu et al. [46] give an ACO algorithm to minimize the makespan on a single BPM with job release times and non-identical job sizes.
P-batch problems on parallel machines are also considered because parallel machines are closer to real-world situations. Lee et al. [24] suggest using the Longest-Processing-Time (LPT) algorithm for parallel BPMs with identical job sizes. Uzsoy [39] address the problems of minimizing the makespan, maximum lateness, and total weighted completion time for parallel BPMs with job release times and incompatible job families. To schedule on two identical BPMs with a common deadline, unit processing time and unit setup time, Brucker et al. [3] present a dynamic programming algorithm. Mönch and Almeder [31] develop an ant colony system to minimize the total weighted tardiness (TWT) on parallel BPMs with incompatible families, identical job size and arbitrary job weights. Using the structural properties of the problem, Venkataramana and Srinivasa Raghavan [41] design three ACO-based algorithms to solve the same problem. For the same problem, Almeder and Mönch [1] propose an efficient Variable Neighborhood Search (VNS) method combined with a decomposition heuristic and a local search scheme. Considering the precedence constraints among the jobs, Bilyk et al. [2] provide two metaheuristics to schedule the incompatible jobs with ready times on parallel batch machines for TWT minimization. The VNS-based approach slightly outperforms the one based on greedy randomized adaptive search procedure. Klemmt et al. [22] study the problem of unrelated parallel batch machines with incompatible job families and unequal job ready times. They also propose a mixed integer programming decomposition based on time windows and a VNS-based method to minimize TWT, respectively.
Since job sizes are generally different in many applications, researchers turn their attentions to scheduling jobs with non-identical job sizes. To minimize the makespan, Chang et al. [4] present a SA algorithm for scheduling jobs with nonidentical sizes on parallel BPMs. Damodaran and Chang [8] propose heuristics to minimize the makespan on parallel BPMs. First, two heuristics are applied to batch the jobs; i.e., the FFLPT and BFLPT. Then, the batches are scheduled by either the LPT or the Multifit (MF) rule. Meta-heuristics have also been studied. Kashan et al. [19] propose a hybrid genetic heuristic (HGH) to minimize the makespan on parallel BPMs with arbitrary job sizes. Shao et al. [35] develop a Neural Network (NN) method to solve the problem. Cheng et al. [7] give a polynomial time algorithm to minimize the makespan and total completion time for scheduling on parallel BPMs with non-identical job sizes. Malve and Uzsoy [29] provide an efficient GA for minimizing the maximum lateness on parallel BPMs with dynamic job arrivals. Chen et al. [5] apply an ACO and a GA algorithm to the problem on parallel BPMs with dynamic job arrivals.
The above research on parallel BPMs assume that all machines have the same capacity. In real-world production environments, there are machines that are older models and machines that are newer models. Newer machines usually have larger capacities than the older ones. Moreover, some jobs may have sizes larger than the capacity of the older machines. Thus, it is important to study this scheduling problem with non-identical machine capacities and jobs can only fit in a subset of the machines. To address batch scheduling with non-identical machine capacities, Xu and Bean [45] propose a GA based on random keys encoding (RKGA). Comparing with commercial solver (CPLEX), the RKGA finds a better solution in a reasonable amount of time. Wang and Chou [43] present a metaheuristic based on GA and SA to minimize the makespan, with non-identical job sizes and job release times as well as non-identical machine capacities. Damodaran et al. [9] provide a particle swarm optimization (PSO) algorithm for the problem with non-identical job sizes and machine capacities. The results of the comparative experiment validate the effectiveness and efficiency of the PSO algorithm. However, the problems studied in these three papers are different from ours. Xu and Bean [45] and Wang and Chou [39] both assume that all jobs can fit in any machine. That is, the largest job size is smaller than the smallest machine capacity. In addition, the problem studied in Damodaran et al. [9] assumes that all jobs arrive at time zero. Our problem extends the previous research by involving parallel machines with non-identical capacities, non-identical job sizes and dynamic job arrivals.
We refer the readers to the articles [34], [30], and [32] for an extensive review of the BPM problems.
3. Problem statement and notation. Using the three-field notation proposed in [15], the problem under study can be denoted by P | p−batch, M j (inclusive), s j , r j | C max , where P and p − batch denote parallel p-batching processing machines, M j (inclusive) denotes the machines for processing each job is a subset of the machine set, s j and r j denote the jobs have unequal sizes and unequal arrival times, and C max is the optimization objective, i.e., the makespan. The problem is described as follows: (1) A job set, denoted by J = {1, 2, . . . , n}, is to be grouped in batches, denoted by B k (k = 1, 2, . . . , b), which are then scheduled on a set of m parallel batch machines with non-identical capacities. The number of batches can not be determined until all the jobs have been grouped. Each job j ∈ J (j = 1, 2, . . . , n) has a processing time p j , a size s j and a release time r j .
(2) The machine set is denoted by M = {1, 2, . . . , m}. Each machine i (i = 1, 2, . . . , m) has a capacity denoted by S i . Without loss of generality, we assume that S 1 ≤ S 2 ≤ · · · ≤ S m and the size of each job does not exceed the largest machine capacity S m . The total size of all the jobs in a batch B k cannot exceed the capacity of the machine i where the batch is processed, i.e., j∈B k s j ≤ S i . The completion time of a machine is the completion time of the last batch on the machine.
(3) The batch set generated by grouping the jobs is denoted by B. The processing time of batch B k , denoted by P k , is given by the longest processing time of all the jobs in the batch, i.e., P k = max{p j |j ∈ B k }. The release time of batch B k , denoted by R k , is the latest arrival time of all the jobs in this batch, i.e., R k = max{r j |j ∈ B k }.
(4) After the batch sequence is determined, each batch B k has a start time S k and a completion time C k . If B l is the batch that is processed immediately before The objective is to minimize the makespan C max , which is the maximum of the completion times of all the machines. 4. A lower bound. In this section we propose a method to compute a lower bound for a given instance of the problem. The lower bound will be used to evaluate the performance of our heuristics. Since the problem is strongly NP-hard, it is computationally infeasible to obtain optimal solutions for large-scale instances. This is the reason why a lower bound is needed.
In order to explain our heuristics and the lower bound, it will be more convenient to assume that there are only three machine capacities and four job release times. The generalization to more than three machine capacities and four release times is obvious. Let the three machine capacities be denoted by S 1 , S 2 and S 3 , where S 1 < S 2 < S 3 , and the four job release times be denoted by r 1 , r 2 , r 3 and r 4 , where r 1 < r 2 < r 3 < r 4 . Without loss of generality, we may assume that r 1 = 0. The number of machines whose capacity is S i (i = 1, 2, 3) is denoted by m i . Note that m = J 2 , and compute a lower bound for J 2 as if all these jobs are released at time r 2 . Finally, we merge J 1 into J 2 to obtain J 1 , and compute a lower bound for J 1 as if all these jobs are released at time r 1 . The largest of the four lower bounds is the lower bound for the original problem.
To compute the lower bound for J i , we divide J i into three sets, J 1 , J 2 and Clearly, the length of the optimal schedule for J i is at least the longest processing time of the jobs in J i . So, we let LBB 1 = max{p j | j ∈ J i }. Another lower bound can be computed by scheduling all the jobs in J 3 on a machine in M 3 . Here, we split each job j into p j * s j unit-size and unit processing time jobs. Therefore, we let . Another lower bound can be computed by scheduling all the jobs in J 2 ∪ J 3 on a machine in . The final possibility is to schedule all the jobs in J i on any machine. So, we let LBB 4 = j∈Ji (p j * s j )/(m 1 * S 1 + m 2 * S 2 + m 3 * S 3 ) . The lower bound for the jobs in Shown below is the algorithm to compute the lower bound for J. The algorithm employs a function LBB(·) to compute the minimum length schedule for J i . The function LBB(·) will be shown in the next algorithm.
Algorithm 1. The LB Algorithm 1. According to the job arrival times, divide the job set J into four subsets, denoted by J 1 , J 2 , J 3 and J 4 .
where the release times of J 1 , J 2 , J 3 and J 4 are r 1 , r 2 , r 3 and r 4 , respectively. 2. Let J 4 = J 4 . Call LBB(·) to compute the minimum length schedule for J 4 .
6. The lower bound of the problem is given as follows: where k = arg max{LB 1 + r 1 , LB 2 + r 2 , LB 3 + r 3 , LB 4 + r 4 }. Therefore, the upper bound of the problem, denoted by U B, is given by the following equation.
U B = 2 * LB k + r k (7) Algorithm 2. The LBB Function Input: A job set J Output: The minimum length schedule for J 1. According to the machine capacities, divide the job set J into three subsets, denoted by J 1 , J 2 and J 3 . where Calculate and output the minimum length schedule for J . where 5. Description of the heuristics. There are two steps involved in solving the problem. In the first step, we group all the jobs into batches to obtain a batch set. In the second step, schedule the batch set on the parallel machines. The scheduling is done by conducting a binary search in the interval [LB, U B]. For each value L obtained in the binary search, we check if we can schedule all the batches so that the makespan is at most L. If we are successful, then search the lower half by setting U B to be L; otherwise, search the upper half by setting LB to be L. This process is repeated until U B ≤ LB. The makespan obtained by the heuristic is given by U B.
For the first step, we can apply two heuristics based on the First-Fit [38] and the Best-Fit [14] rules, respectively. The First-Fit rule constructs the batches by first sorting the jobs in descending order of their processing times, and then putting the first job in the sequence into the first batch that can accommodate the job. If no batch can accommodate the job, construct a new batch and put the first job in the new batch. The Best-Fit rule works in the same manner as the First-Fit rule, except that the first job is put into the batch with the smallest unoccupied space. For the second step, the First-Fit rule schedules the batches by first sorting the batches in descending order of their processing times, and then assigning the first batch in the sequence to the first machine that can process it. The Best-Fit rule assigns the first batch to the best fit machine, i.e., the machine with the smallest unoccupied space based on a bound. In all, there are four heuristics by combining the two batching rules and the two scheduling rules. They are denoted by FF, FB, BF, and BB, respectively. Note that the first letter denotes the batching rule and the second letter denotes the scheduling rule. Since the differences between the four heuristics are only in the way of batching the jobs and scheduling the batches, we will describe only the first heuristic, i.e., FF, in detail. The other three heuristics can be obtained by replacing the First-Fit rule by the Best-Fit rule.

The FF heuristic.
To make the heuristic easy to understand, we assume that there are three different machine capacities and four job release times as described in Section 4. The generalization to more than three machine capacities and more than four job release times is easy to see.
The FF heuristic works as follows. First, it computes LB and U B by Algorithm 1 in Section 4. Then, according to the job release times, it divides the job set J into four subsets, denoted by J 1 , J 2 , J 3 , J 4 . The arrival times of the jobs in the subsets are r 1 , r 2 , r 3 , r 4 , respectively, where r 1 < r 2 < r 3 < r 4 . Then, it sets L = (U B + LB)/2, and attempts to schedule the jobs in J so that the makespan is at most L. The scheduling is done step by step. In the first step, it tries to schedule the jobs in J 4 between L and r 4 by the algorithm VIAB (to be described later). The scheduling starts from L and works towards r 4 . VIAB returns a value 1 if J 4 can be scheduled between L and r 4 ; otherwise, it returns 0. If VIAB returns 0, this means that it is impossible to schedule the jobs in J 4 between L and r 4 . In this case it searches the upper half of the range by setting LB to be L. On the other hand, if VIAB returns 1, then it records the completion times T = (T 1 , T 2 , · · · , T m ), where T i is the completion time of machine i. Then it calls VIAB again to see if the jobs in J 3 can be scheduled between T and r 3 . It repeats the same process for J 2 and r 2 , as well as J 1 and r 1 . If VIAB returns 1 in all of these calls, the scheduling is successful and it searches the lower half of the range by setting U B to be L. On the other hand, if VIAB returns 0 in one of these calls, the scheduling is unsuccessful and we set LB to be L.
The algorithm VIAB has three input parameters: X, P and r. X is a set of jobs, P = (P 1 , P 2 , · · · , P m ) is a vector of completion times of the m machines, and r is a release time. VIAB will heuristically decide if we can schedule the jobs in X between P and r. It works as follows. Partition the jobs in X into three subsets Similarly, divide the machines into three sets M 1 , M 2 and M 3 , where the machines in M i , 1 ≤ i ≤ 3, have capacity S i . Sort the jobs in X 1 in descending order of their processing times, and batch them by the First-Fit rule. Sort the batches in descending order of their processing times, and schedule the batches on the machines of M 1 by the First-Fit rule. The scheduling starts from P and works towards r. No job is allowed to complete before r. If there are some batches that cannot be scheduled, then merge the jobs in the unscheduled batches into X 2 . We then proceed to schedule the jobs in X 2 on the machines in M 2 in the same manner as in X 1 . After the jobs in X 2 are scheduled, we proceed to schedule the jobs in X 3 on the machines in M 3 in the same manner as in X 2 . If all the batches can be scheduled on the machines in M 3 ; then we record the completion time of each machine in P and return 1; otherwise, we return 0.
The flow of the proposed heuristic, referred to as the FF algorithm, is described as follows. 13. If U B ≤ LB then stop; else goto Step 3. Algorithm 4. VIAB(X, P, r) 1. According to the machine capacities, divide the job set X into three subsets, denoted by X 1 , X 2 , X 3 , and the machine set into three subsets, denoted by M 1 , M 2 and M 3 . 5.2. The other three heuristics. There is another algorithm of batching the jobs, as well as scheduling the batches, that is based on the Best-Fit rule. Thus, besides FF, there are three other heuristics, depending on whether we use the First-Fit or the Best-Fit rule in Steps 3(b) and 3(d) of the VIAB algorithm. In the FB heuristic, the First-Fit rule is used in Step 3(b) and the Best-Fit rule is used in Step 3(d). In the BF heuristic, the Best-Fit rule is used in Step 3(b) and the First-Fit rule is used in Step 3(d). Finally, in the BB heuristic, the Best-Fit rule is used in both Step 3(b) and Step 3(d).
6. Computational experiments. To evaluate the performance of the four heuristics, a series of computational experiments are performed. As stated in Section 2, the heuristics proposed by Xu and Bean [45] and Wang and Chou [43] do not work for our model, since they assumed that all the jobs fit in all the machines. Additionally, since Damodaran et al. [9] assumed that all the jobs arrived at time zero, their PSO algorithm cannot apply to our problem either. Therefore, our experiments will compare the proposed heuristics to the lower bound as well as against each other. 6.1. Parameter settings. The number of machines is set to be 10; i.e., m = 10. Three machine capacities are chosen; S 1 = 10, S 2 = 25 and S 3 = 65. The larger machine capacity is approximately 2.5 times that of the smaller machine capacity. In real-life applications, the machines with larger capacity are newer and more expensive than machines with smaller capacity. Therefore, the number of machines with larger capacity is usually less than the number of machines with smaller capacity. Hence, we choose five, three, and two machines with capacity S 1 , S 2 and S 3 , respectively. There are six distinct job numbers (n) chosen from 90 to 180, increasing by 18 jobs every time; i.e., n = {90, 108, 126, 144, 162, 180}. For each n, we randomly generate 10 instances. For each instance, we set three groups of jobs, denoted by J 1 , J 2 and J 3 . The jobs in J 1 can be scheduled on all 10 machines, the jobs in J 2 can only be scheduled on five machines and the jobs in J 3 can only be scheduled on two machines. The numbers of jobs in the three groups are chosen to be 2n/3, 2n/9 and n/9, respectively. We choose four different job release times, r 1 = 0, r 2 = 20, r 3 = 40, r 4 = 60. The release time of each job is randomly selected from {0, 20, 40, 60}. After the release times are generated, we partition the jobs according to their arrival times. Each partition is further divided into three subgroups; i.e., J 1 , J 2 , J 3 .
The processing times of the jobs are uniformly distributed in [5,15]. The parameter setting of the job sizes is a key point in the experiment. If the job sizes are generated by uniform distribution, the probability of obtaining a small-size job is the same as that of a large-size job. Consequently, the number of jobs in a batch is relatively small, which makes the problem relatively easy to solve. If there are more small-size jobs than large-size jobs, then the heuristics will be able to assign small-size jobs to machines with larger capacities, which will complicate the process of scheduling. Therefore, in the experiment, the job sizes are generated by Poisson distribution. That is, {s j | j ∈ J 1 } ∼ P (λ 1 ), {s j | j ∈ J 2 } ∼ P (λ 2 ) and {s j | j ∈ J 3 } ∼ P (λ 3 ), where λ l = S l /2 l = 1, 2, 3. Specifically, λ 1 = 5, λ 2 = 12.5 and λ 3 = 32.5. If job j belongs to class l and the size generated is smaller than S l−1 , then we let s j to be S l−1 . Similarly, if it is larger than S l , then we let it be S l . The value assigned to s j is given as follows: where S 0 = 1. Furthermore, since it is desirable to have more small-size jobs than large-size jobs, we randomly select 70% of jobs from the interval (S l−1 , S l /2] and 30% from the interval (S l /2, S l ]. Table 1 shows the parameter setting chosen for the experiment. Experimental results and analysis. Each algorithm is programmed in C++ and executed on a PC with an Intel Core 2 processor and 2G RAM. To compare the algorithms objectively and accurately, we present the results of each instance as well as the average results of each group of 10 instances. We use the relative distance between the solution and the lower bound as the measure of the performance of the heuristic. The percentage of the relative difference between the objective value of algorithm A and the lower bound,, denoted by R A , is computed by where C A max is the makespan obtained by algorithm A and LB is the lower bound of the instance computed by Algorithm 1 in Section 4. The smaller the value of R A , the better the algorithm.
Tables 2 to 7 present the results for different numbers of jobs. In each table, column 1 represents the index number of the instance. Column 2 gives the LB value. Columns 3 to 6 report the percentage of relative difference of the FF, FB, BF and BB algorithms, respectively. The numbers in the last row give the average results of the 10 instances. Table 2 presents the results obtained by the algorithms for instances with 90 jobs. The R values of the BB algorithm are better than the FF, FB and BF algorithms in every instance; it is better than 3% on the average. There are four instances in which BB obtains the same makespan as LB. The FB algorithm is the second best. FF and BF are the worst and their average performances are about the same. Table 3 summarizes the results for instances with 108 jobs. Except a tie in one instance, the R values of the BB algorithm outperform the FF algorithm in every instance, with a wide margin. The R values of the BB algorithm also outperform the FB algorithm, except in three instances. The BB algorithm outperforms the BF algorithm in eight instances, loses in one instance and ties in one instance. However, the average R value of the BB algorithm is better than that of the FB algorithm, which in turn is better than the BF and FF algorithms. Table 4 shows the results for instances with 126 jobs. The R value of the BB algorithm outperforms the FF, FB and FB algorithms in every instance. The R value of the FB algorithm outperforms FF in every instance; with the exception of two instances, it also outperforms BF in every instance. Table 5 gives the results for instances with 144 jobs. The R value of the BB algorithm outperforms the BF and FF algorithms in every instance. With the exception of two instances, the BB algorithm outperforms the FB algorithm in every instance. The BB algorithm has the best average R value, followed by FB, BF and FF. Table 6 presents the results for instances with 162 jobs. The R value of the BB algorithm outperforms the other three algorithms in all instances. The FB algorithm outperforms BF in every instance, with the exception of one instance; it also outperforms FF in every instance, with the exception of two instances. Accordingly, the average R value of BB is the best, followed by FB, BF and FF. Table 7 shows the results for instances with 180 jobs. The R value of the BB algorithm outperforms the FF algorithm in every instance. The BB algorothm beats the FB algorithm in nine instances and loses in one instance. It also beats the BF algorithm in nine instances and ties in one instance. Moreover, the average R value of the BB algorithm over the ten instances is the best. The BF algorithm is the second best algorithm, while the FF algorithm shows the worst performance. Fig. 1 depicts the comparison of the average values of each group of 10 instances for different numbers of jobs. The , ∇, × and + symbols are for the R values of the FF, FB, BF and BB algorithms, respectively. As can be seen from Fig. 1, the performance of the BB algorithm is the best among the four algorithms. The FB and the BF algorithms have more or less the same performance, and both of them are better than the FF algorithm. It can also be observed that the performances of the four algorithms become worse when the number of jobs increases from 90 to 144.  As can be observed from the experimental results, the overall performance of the BB algorithm is better than that of the other three algorithms, which demonstrates the effectiveness and efficiency of the BB algorithm. This is due to the effective mechanisms used by the BB algorithm. That is, the Best-Fit batching approach is better than the First-Fit batching approach. Moreover, it is better to schedule the batches on the machines by the Best-Fit rule than the First-Fit rule.

7.
Conclusions. In this paper, we study the batch scheduling of jobs with nonidentical sizes and release times on machines with non-identical capacities, so as to minimize the makespan. We give a method to compute a lower bound. Based on the First-Fit and the Best-Fit rules used in bin-packing, we present four heuristics to solve the problem. Computational experiment shows that the BB algorithm (which batches the jobs and schedule the batches by the Best-Fit rule) outperforms the other heuristics.
Future research will focus on extending the proposed algorithms to more complex problems, such as the jobs are incompatible, or other constraints. Also, another  interesting direction is to design meta-heuristics with better performance to solve the studied problem. Other optimization objectives such as maximum lateness and mean weighted flow time are unexplored either.