1. Introduction
Parallel machine scheduling systems have been extensively applied in various production and manufacturing industries [
1]. In parallel machine scheduling, it generally contains two decision issues, i.e., sequencing and job assignment [
2,
3]. Various optimization objectives, including the makespan and the total completion time, have been well addressed in previous studies [
4,
5,
6,
7]. In addition to the above classical objectives, workload balance between the machines together with the corresponding operators is also a major aspect of decision making in manufacturing industry [
8,
9,
10]. It contributes to reducing the idleness and work-in-process and removing bottlenecks [
8,
11]. Minimum imbalance is actually beneficial for minimizing the inventory of finished goods [
12].
The solutions with the classical minimum objective of the makespan or the total completion time may induce the workload balance between the parallel machines to a large extent. However, the above solutions cannot guarantee their optimality when we aim to minimize the imbalance of workloads between the machines. Therefore, some previous works have investigated other specific criteria to measure the workload imbalance, such as the Average Relative Percentage of Imbalance (
) [
12], Total Imbalance (
) [
13] and even Total Workload [
14].
In this work, we introduce the workload smoothness index (
) to the identical parallel machine scheduling problem. The index of
was introduced by Moodie and Young [
15] to measure the balance level of workloads between the neighboring workstations in an assembly line environment. To our best knowledge, this is the first study to introduce
as an optimization objective into parallel machine scheduling problems. We observe that
may generate a better solution in terms of the workload balance between the parallel machines, comparing with
,
and some other measurements. We first present the formulae of the above indices and then give two examples to illustrate their performance difference. The indices are given by
,
and
, where
is the maximum workload or the makespan,
is the workload of machine
i, and
is the set of machines. In Example 1, there are
jobs
to be processed on
parallel machines. The corresponding processing times of the jobs are 1, 2, 3, 6 and 8, respectively. For both problems
and
, all the three solutions shown in
Figure 1a–c are optimal with the minimum objective value of
and
, respectively. For problem
, however, only the two solutions in
Figure 1b,c are optimal with the minimum objective value of
. For the considered problem
in this work, we observe that only solution
Figure 1b is optimal with the corresponding objective value of
, while the other two solutions in
Figure 1a,c are of the objective values of
and
, respectively. That is, the job assignment in
Figure 1b has the best workload balance among the three solutions.
In the above example, we find that the solution in
Figure 1b is also the only optimal schedule for problem
where
. The following Example 2, however, reveals that index
also better guarantees workload balance than
. In Example 2, there are
jobs with processing times 15, 9, 9, 7, 6, and 5 to be processed on
machines.
Figure 2 reports two optimal solutions to problem
, while the solution in
Figure 2a outperforms that in
Figure 2b for problem
. The corresponding values of
are equal to
and
, respectively. That is, the solution in
Figure 2a has better workload balance than that in
Figure 2b.
By the above two examples, we believe that although the smoothness index () is currently used in assembly line processing systems in previous studies, it is the most feasible index to measure the workload balance in identical parallel machine scheduling compared with other existing criteria. Motivated by this, we investigate the identical parallel machine scheduling problem with the objective of minimizing the workload smoothness index, i.e., the problem. The main contributions of this study are as follows.
- (1)
We introduce smoothness index to identical parallel machine scheduling and prove the NP-hardness of the considered problem.
- (2)
A mathematical model with a minimizing smoothness index is established, and both upper and lower bounds are provided.
- (3)
To quickly find high-quality feasible solutions, an efficient genetic algorithm and an improved list scheduling algorithm are proposed. Numerical experiments show that the proposed genetic algorithm can output high-quality feasible solutions for small-scale instances. For large-scale instances, the proposed improved list scheduling algorithm outperforms the list scheduling algorithm based on LPT, SPT, and RPT rules. Please refer to
Section 6 for specific details.
The remainder of this paper is organized as follows.
Section 2 reviews previous studies on the parallel machine workload balancing problem and smoothness index in the assembly line environment.
Section 3 builds a mathematical model for the considered problem and linearizes its objective function. We prove the NP-hardness of the
problem and present both upper and lower bounds in
Section 4.
Section 5 proposes a genetic algorithm and an improved list scheduling algorithm to solve the considered problem. We also conduct numerical experiments to evaluate the performance of proposed heuristic algorithms in
Section 6. Finally,
Section 7 concludes this work.
3. Problem Statement and Mathematical Model
3.1. Problem Statement
There are n jobs with positive processing times to be processed on m identical parallel machines. All the jobs are released at time 0, and the objective is to minimize the workload smoothness index, i.e., minimizing , where is the maximum workload of the machine and is the workload of machine i. The value of is exactly the total processing time of the jobs assigned to machine i in any processing schedule. Adopting the classical three-notation method, we denote the considered problem as .
The problem under consideration is based on the following fundamental assumptions.
- (1)
Each machine can only process one job at a time;
- (2)
The setup time of processing any job on each machine is negligible;
- (3)
All the machines are available for processing jobs from time 0.
Below, we first present basic parameters and decision variables and then establish one mathematical model for problem . We further linearize the objective function and thus provide an equivalent linear programming model.
3.1.1. Input Parameters
: set of machines indexed by i, i.e., ;
: set of jobs indexed by j, i.e., ;
: the processing time of job ;
: the given maximum workload limitation of machines.
3.1.2. Decision Variables
: a binary variable equal to 1 if job is processed on machine and 0 otherwise;
: a binary variable equal to 1 if jobs and are processed on machine and 0 otherwise;
: the workload of machine .
3.2. Mathematical Model
The objective is to minimize the
, as shown in Formula (1).
subject to
Constraint (2) guarantees that each job can only be processed in a machine. Constraint (3) calculates the workload of machine . Constraint (4) ensures that the workload of each machine cannot exceed the maximum workload constraint. Constraints (5) and (6) give the ranges of the variables, where is the set of positive real numbers.
3.3. Objective Function Linearization
In model [P1], the objective function is non-linear. To transform the model into a linear programming and then solve it via CPLEX or other commercial solvers, we linearize the objective function in this subsection.
Theorem 1. For problem , minimizing is equivalent to minimizing Proof. Azizoǧlu and İmat [
27] have proved that minimizing
is equivalent to minimizing
Furthermore, since
,
is a constant. Therefore, minimizing
is equivalent to minimizing Equation (
8). The proof is completed. □
According to Theorem 1, mathematical model
[P1] can be reformulated as below
subject to Constraints (2)–(6) and the following Constraints (9)–(11).
Constraints (9) and (10) give the processing sequence of jobs on each machine. Constraint (11) gives the range of the variables. Since [P2] is a linear programming model, we can directly adopt some commercial solver such as CPLEX to solve it.
6. Numerical Experiments
CPLEX is a common commercial solver for finding exact solutions of linear programming models. Hence, we select the optimal solution obtained by CPLEX solver as the benchmark to evaluate the performance of
,
,
,
and
algorithms in small-scale numerical experiments. Notice that in this work, we first apply CPLEX to solve a mixed-integer linear programming model
[P2] to obtain the value of
(
). Then, the optimal objective value of model
[P1] can be obtained by Formula (1). To reveal the performance difference between the above heuristic algorithms, we define a relative error
in small-scale numerical experiments, where
represents the objective value of the solution obtained by the corresponding algorithm. In small-scale instances,
measures the relative error between the objective value of each heuristic algorithm and that of CPLEX. In large-scale instances, we define
(please refer to the
Section 6.2) to measure the relative error between the objective value of each heuristic algorithm and that of
. All the numerical experiments are conducted on a PC with AMD Ryzen 7 4800U, 1.80 GHz processors.
In the numerical experiments, we set the parameters of the genetic algorithm with good performance through repeated experiments. The relevant parameters of the algorithm in numerical experiments are as follows:
The number of the population size and iterations are 200 and 100, respectively;
The probability of crossover and mutation are 0.6 and 0.4, respectively.
In addition, since the maximum workload of any optimal solution cannot exceed
(please refer to
Section 5.1.3), for brevity, we set the maximum workload constant to be
.
6.1. Small Job Instances ()
We first present numerical experiment results for small job input instances, in which the processing time of each job is a positive real number between 5 and 10. For each combination
, we generate three instances with the random seed, and the numerical results in
Table 1 are the average objective value of the solutions to the three instances by the corresponding algorithms.
In
Table 1, we observe that the relative error between each of the two proposed heuristic algorithms, i.e.,
and
, and the exact solution is less than 1% in all the small job instances. For the other three previous algorithms, i.e.,
,
and
, their average relative errors are equal to 6.90%, 4.27% and 12.46%, respectively. From the “
” column, we observe that the performance of the list algorithm based on the LPT rule is better than that based on SPT and RPT rules. Nevertheless, the list algorithm based on the SPT rule holds the worst performance compared to other list algorithms. There is no significant trend where the relative errors of the tested algorithms increase with the number of either jobs or machines. Specifically, considering that the number of jobs is an integer multiple of that of machines (e.g., the second and fifth combinations), the list scheduling algorithm can output higher-quality feasible solutions. In addition, the average relative errors of
and
are about 90.40% and 100.00% smaller than that of
, respectively. We thereby can conclude that (1)
outperforms
in small-scale numerical experiments; and (2) the two proposed heuristic algorithms perform much better than the other three list algorithms.
6.2. Large Job Instances ()
Below, we further test the performance of the proposed two heuristic algorithms together with the previous list scheduling algorithms with large job input instances. Especially, we consider two scenarios with regard to the variation range of the processing times of jobs, i.e.,
or
. Similar to the case of small job input instances, three instances are generated for each combination
, and the average results are reported in
Table 2 and
Table 3, where the running time is in seconds. Notice that in large-scale instances, CPLEX fails to output even feasible solutions within 7200 s for most instances. Due to the better performance of the list algorithm based on the LPT rule compared to that based on SPT and RPT rules in solving small job instances, we set the value of
as the benchmark obtained by
, i.e.,
.
Table 2 and
Table 3 report the experimental results of
,
,
and
. Similar to the small job setting, the results of large job instances in
Table 2 and
Table 3 indicate that
and
outperform again the other three list algorithms on average in terms of solution quality.
produces the best solutions for all the test instances, while
and
output the best schedules for only a part of the instances. Moreover,
Table 2 and
Table 3 report that the average performance of
is worse than
for the test instances.
For the solution quality, we observe by
Table 2 and
Table 3 that the objective value of the solution obtained by any of the heuristic algorithms increases proportionally in the number of machines, while the number of jobs has no significant impact on the objective value. Moreover, when the job processing time is scaled in
, the average performance of
is even better than that of
. That is to say, compared to small-scale numerical experiments,
lost its power to solve large-scale instances. Similarly, due to the limitations of given iterations and population size, the average performance of the designed genetic algorithm in solving large-scale numerical instances also shows a downward trend. From
Table 2 and
Table 3, we can know that the solution quality of
is generally inferior to that of
. This is mainly due to the inability of the designed genetic algorithm to fully utilize its performance in solving large job instances under the given chromosome population size and the number of iterations. Moreover, for some combinations where the number of jobs is an integer multiple of the number of machines, the performance of
is inferior to that of
due to the limitations of the given population size and iterations. Considering the running time, all the heuristic algorithms require running time proportional to the job scale. Meanwhile, the average running time consumed by
is significantly less than that of
. Actually, the running time of
is much larger than that of the other four heuristic algorithms.
In summary, we conclude the following. (1) In general, both and outperform the previous list scheduling algorithms. (2) For large-scale instances, can output the best solutions for all the instances within one second. (3) In large-scale numerical experiments, the list scheduling algorithm based on the LPT rule lost its power to solve the considered problem.
7. Conclusions
In this work, we study an identical parallel machine scheduling problem, aiming at minimizing the workload smoothness index or the workload imbalance between the parallel machines. We first prove the NP-hardness of the considered problem, and we prove its theoretical upper and lower bounds. An efficient genetic algorithm and an improved list scheduling algorithm are further proposed to solve the problem. Numerical results show the following: (1) the list scheduling algorithm based on the LPT rule performs better than that based on SPT and RPT rules in dealing with parallel machine scheduling problems to minimize workload imbalance; and (2) the designed genetic algorithm can output high-quality feasible solutions in solving small-scale instances (i.e., ), while the improved list scheduling algorithm has better performance in solving large-scale instances (i.e., ).
In practice, the parallel machines may be non-identical or have job-dependent processing capabilities. Thus, one future topic is to extend the considered problem to the scenario with either uniform or unrelated machines. Another interesting research aspect is to introduce the concept of the job family into the considered problem, where jobs belong to different families and each machine can only process a partial family of the jobs. Finally, it is common that jobs are of uncertain processing times in practice, while the established model in this work is unable to handle the scenario with this uncertainty. Therefore, it is meaningful to extend our study to the scenario with uncertin processing times of jobs.