Abstract
The objective of this paper is to minimize both the makespan and the total completion time. Since parallel-machine scheduling which contains the function constraint problem has been a new issue, this paper explored two parallel-machine scheduling problems with function constraint, which refers to the situation that the two machines have a same function but one of the machines has another. We pointed out that the function constraint occurs not only in the manufacturing system but also in the service system. For the makespan problem, we demonstrated that it is NP-hard in the ordinary sense. In addition, we presented a polynomial time heuristic for this problem and have proved its worst-case ratio is not greater than 5/4. Furthermore, we simulated the performance of the algorithm through computational testing. The overall mean percent error of the heuristic is 0.0565%. The results revealed that the proposed algorithm is quite efficient. For the total completion time problem, we have proved that it can be solved in time.
1. Introduction
The scheduling problem studied in this paper was motivated by the manufacturing of the metal processing industry. In the traditional manufacturing, a lathe machine and a milling machine have different functions. Generally speaking, the lathe machine is a tool that rotates a workpiece about an axis of rotation to perform various operations such as cutting, deformation, knurling sanding, and turning. The milling machine is used to cut the plane, while the shape of the forming surface, the spiral groove, or the tooth shape of the gear is milled with a special-shaped milling cutter. During milling, the workpiece is mounted on a table or an indexing head attachment, and the milling cutter performs a cutting motion, supplemented by a table for feeding motion. And now, a 5-axis machining center for milling and turning has all the functions of lathe machine and milling machine. As the company's performance grows rapidly, companies must purchase machines to meet customer needs. While newly purchased machines tend to have more function than older machines, functional alternatives occur between machines. We named this phenomenon as function constraint (e.g., lathe machine versus 5-axis machining centers for milling and turning). The function constraint occurs not only in the manufacturing system but also in the service system. In the service system, the parallel-machine is composed by the employees. The senior staff, the junior employees, and the new employees all have the ability to limit and replace.
Parallel machine in a production environment can be divided into three categories according to the nature of the machine: identical, uniform, and unrelated parallel machines. For decades, the parallel-machine production scheduling problem has been extensively studied under various classical scheduling performance measurement criteria. The makespan and total completion time are the two best important performance measurement criteria. The makespan is also called the maximum completion time or the completion time of the last workpiece on the last machine. The makespan is usually used to measure the utilization of machinery and equipment. If one shortens the makespan and the machine utilization and production efficiency is improved, more flexible time can be reserved to prevent the sudden occurrence of the production line. The completion time refers to the time spent in the system from the time of the workpiece that arrives at the site to its completion, and the total completion time is the sum of the completion time of all the workpieces. Therefore, the total completion time is expected to be minimized. That is, the in-process inventory of the factory is expected to be minimized to reduce the cost of inventory.
Chung et al. [1] explored a two identical parallel-machine scheduling problem with molds constraints. Their objective is to minimize the makespan. For the problem is NP-hard, they give three heuristics and analyze each heuristic has a worst-case performance ratio of 3/2. Computational results revealed that heuristics are efficient even for the large-sized problem. Xu and Yang [2] studied a two parallel-machine scheduling with a periodic availability constraint. Their objective is to minimize the makespan. Because the problem is NP-hard, they present a mathematical programming model to solve it and, next, compare the performance of the longest processing time first (LPT) algorithm with the list scheduling (LS) via computational experiments. Most of the results showed that the LPT is better than the LS. Xu et al. [3] examined a two parallel machine scheduling problem to minimize the makespan. The problem is known as NP-hard. They applied the branch-and-bound method to solve the small-sized problem and presented a Tabu search algorithm for the large-sized problem. Ji and Cheng [4] presented a fully polynomial-time approximation scheme for parallel-machine scheduling under a grade of service provision to minimize makespan consideration. Lee et al. [5] addressed a makespan minimization scheduling problem on identical parallel-machine. They applied the simulated annealing method, and several heuristic algorithms have been proposed to tackle the problem. Computational results demonstrated that the simulated annealing method is efficient and better than the existing methods. Yin et al. [6] explored parallel-machine scheduling of deteriorating jobs with potential machine disruptions. The authors examined two cases of machine disruption (i.e., performing maintenance immediately on the disrupted machine when a disruption occurred and not performing machine maintenance). The nature of the jobs has two types: nonresumable and resumable. They determined the computational complexity status of various cases of the total completion time minimization problem and provided pseudopolynomial-time solution algorithms and fully polynomial-time approximation schemes for them.
Zhao et al. [7] explored a two parallel-machine scheduling problem where one machine is not available in a specified time period. The unavailable time period is fixed and known in advance. They proposed a fully polynomial-time approximation scheme for the total weighted completion time minimization problem and generalized the results to the case with m parallel machine. Kuo and Yang [8] studied parallel-machine scheduling with time-dependent processing time. For the total completion time and the total load problems, they showed that the two problems are polynomially solvable. Gerstl and Mosheiov [9] proposed a general position-dependent processing time model. They considered scheduling problems which combine the option of job rejection and the model on parallel machine. Their objectives are total flow-time and total load. They proved that both problems can be solved in polynomial time in the number of jobs. Huang and Wang [10] stressed parallel-machine scheduling problems with deteriorating jobs. They showed that the total absolute differences in completion time and the total absolute differences in waiting time minimization problems can be solved in polynomial time.
Wang and Wang [11] studied a three-machine permutation flow shop scheduling problem with time-dependent processing times. The objective is to find a sequence that minimizes the makespan. Several dominance properties and a lower bound are derived to speed up the elimination process of a branch-and-bound algorithm. Moreover, two heuristic algorithms are proposed to overcome the inefficiency of the branch-and-bound algorithm. Computational results show that the heuristic algorithm M-NEH performs effectively and efficiently.
For more information, the reader may refer to the concise surveys on this topic by Cheng and Sin [12], Mokotoff [13], Pfund et al. [14], Kravchenko and Werner [15], Kaabi and Harrath [16], and Wang and Li [17].
Parallel-machine scheduling combines the function constraint problem is a new issue. Therefore, this paper explored two parallel-machine scheduling problems with function constraint. The objectives are to minimize the makespan and the total completion time.
The rest of the paper is organized as follows. In Section 2, we introduced the notation and formally formulated our problems. In Section 3, we demonstrated the computational complexity status and presented a heuristic algorithm, worst-case ratio, and computational experiments for the makespan minimization problem. In Section 4, we formulated the total completion time minimization problem as an assignment. In the last section, we concluded the paper and suggested issues for the future research.
2. Problem Formulation
There are jobs in the set . Assume set consists of two classes of job that are the first class jobs and the second class jobs. Let and denote the number of jobs of the first class and the second class, respectively. Let and denote the set of the jobs of the first class and the second class, respectively. That is, , where and . Let denote the processing time of (). Assume there are two parallel machines (), where can process the first class jobs only and can process both of the first class jobs and the second class jobs. Some common assumptions are as follows: (1) all jobs are non-preemptive and available for processing at time zero; (2) each machine can handle at most one job at a time and cannot stand idle until the last job assigned to it has finished processing; and (3) each job can be processed on at most one machine at a time. The objectives are to minimize the makespan and the total completion time. We used “fc” to denote the function constraint relations between the two machines. Following the common scheduling notation, the problems can be described as and , respectively.
3. Minimization of the Makespan
In this section, we confirmed the complexity and presented the worst-case bound for . First, we excluded the case of the sum of processing time in the second class jobs is larger than the sum of processing time in the first class jobs because the first class jobs processed on and the second class jobs processed on are optimal for the abovementioned case. Second, we analyze the complexity of the problem . Third, we presented a heuristic approach and analyze the worst-case bound of the algorithm. Finally, a computational experiment was conducted to evaluate the performance of the proposed algorithm.
3.1. The Heuristic and Worst-Case Bound
The special case of all the jobs belongs to the first class, , and then the problem becomes the classical problem . It is known in advance that is NP-hard in the ordinary sense [18]. Therefore, the following theorem holds.
Theorem 1. Scheduling problem is NP-hard in the ordinary sense.
A simple heuristic approach is described in Algorithm 1.
A simple sort can be done in (e.g., heap sorting). Hence, the complexity of Step 1 is . The complexity of Step 2 is . Overall, the complexity of the algorithm is .
A straightforward result is given as follows.
|
Lemma 1. For the problem , the following holds:(1), where denotes the makespan of the optimal schedule(2), where LB denotes the lower bound of the problem
Theorem 2. For the problem , .
Proof. Assume is the last processed job based on the LPT approach. If , then . Therefore, the following proof processes are under the assumption of .
If , then .
For the case of , assume denotes the starting time of . Since there is no idle time on the machines prior to the time ,Consider the following two cases: and .
When , we haveWhen , based on optimal consideration, we have and each machine cannot arrange two jobs that belong to and whose job’s index is less or equal to . Therefore, is the only job that belongs to and being processed on M2. That is, . Within the optimal sequence, is the only job that belongs to and can be processed on M2. We have . Hence, .
3.2. The Computational Experiments
Although the worst case above seems quite good from the theoretical aspects, 25% errors cannot be accepted from the application dimensions. Therefore, some computational experiments were conducted to evaluate the performance of the LPT approach. The LPT approach was coded in Visual BASIC 6.0 and implemented on a personal computer with Intel core i7 16G CPU. Some test problems for each environment were randomly generated, the details of which are as follows:(1) is equal to 50, 100, 150, 200, 250, 300, 500, and 1000(2) is uniformly distributed over [1, n]. (3) is uniformly distributed over [1, 50], [1, 100], [1, 200], [1, 500], and [1, 1000]
A ratio of is used as an index to evaluate the performance of the LPT approach, where is the solution found by the LPT approach and is the solution found by lower bound. The ratio is computed for 300 test problems in each problem size; hence, 12000 (300 × 8 × 5) test problems are generated for the proposed problem . The computational results are shown in Table 1. The results revealed that the mean percentage errors of the LPT approach are 0.0214, 0.0397, 0.0560, 0.0741, and 0.0905 with five different processing time distribution periods, respectively. From Table 1, we found that the larger the problem the smaller the error percentages and the wider the processing time range the larger the error percentages. The overall mean percent error of the LPT approach is 0.0565%.
4. Minimization of the Total Completion Time
In this section, we showed that the problem can be solved in time. Let denotes the vector of the number of jobs allocated to and , where and . We excluded the case of because it becomes a single machine scheduling problem and the SPT (shortest processing time first) is optimal. Let and denote a job scheduled in the jth position on a machine i and its processing time, respectively. For the convenience, we rename the job sequences processing on and as and , respectively. Then, the total completion time can be calculated as follows:
We rewrite equation (3) aswhere
Assume the position of job that is processing on M1 and M2 is and , respectively. Obviously, the second class of jobs cannot be scheduled at the previous position of . Then, we gave the elements of assignment vector as follows:where
Constraint of the second line at ensures that the second class jobs are not scheduled before the position of under minimization consideration. For a given vector , can be formulated as the following assignment problem:
It is well-known that an assignment problem can be solved in time. For a given vector of , , and , problem can be solved in time. There are possible vectors of , that is, . Hence, problem can be solved in time, since . This implies that the following theorem holds.
Theorem 3. Problem can be solved in time.
Example 1. Assume , , , , , and , and their processing time is listed in Table 2.
The following solution reports were obtained from Lingo 14.0 package. If , then . If , then . Therefore, the optimal solution is 262.
The optimal sequences those scheduling on M1 and M2 are and , respectively.
The Lingo programming code under is listed as follows:
5. Conclusions
This paper explored two parallel-machine scheduling problems with function constraint. We pointed out that the function constraint occurs not only in the manufacturing system but also in the service system. Therefore, this work is meaningful.
In this research, two important and famous classical objectives, the makespan and the total completion time, were studied. For the makespan problem, we demonstrated that it is NP-hard in the ordinary sense. We presented a polynomial time heuristic for this problem and have proved its worst-case ratio is not greater than 5/4. Computational testing of the heuristic was conducted, and the results revealed that the overall mean percent error of the proposed algorithm is 0.0565%. For the total completion time problem, we have proved that it can be solved in time.
Future research may examine other topics such as the total load, total tardiness, and number of tardy jobs or extending the model to the uniform parallel-machine setting or other settings.
Data Availability
No data were used to support this study.
Conflicts of Interest
The authors declare that they have no conflicts of interest.