A Heuristic Approach to 𝑛×𝑚 Flow Shop Scheduling Problem in Which Processing Times Are Associated with Their Respective Probabilities with No-Idle Constraint

Abstract

This paper is an attempt to study general 𝑛×𝑚 flow shop scheduling problem in which processing time of jobs is associated with probabilities under no-idle constraint. The objective of this paper is to develop a heuristic algorithm to 𝑛×𝑚 flowshop scheduling so that no machine remains idle during working for any given sequence of jobs. The proposed algorithm is simple, and easy to understand and provides an important tool in many practical situations for minimizing the expected hiring cost of the machines for a fixed sequence of job processing. A numerical illustration is also given to justify the proposed algorithm.

1. Introduction

In flow shop scheduling problems, the objective is to obtain a sequence of jobs which when processed on the machines will optimize some well-defined criteria. Every job will go on these machines in a fixed order of machines. The research into flow shop problems has drawn a great attention in the last decades with the aim to increase the effectiveness of industrial production. Johnson [1] gave procedure for finding the optimal schedule for 𝑛-jobs, two-machine flow-shop problem with minimization of the makespan (i.e., total elapsed time) as the objective. Ignall and Scharge [2] applied Branch and Bound technique for obtaining a sequence which minimizes the total flow time. In addition Adiri and Pohoryles [3] elucidated no-idle scheduling to minimize the sum of completion time. Rajendran and Chaudhuri [4] have given conditions to obtain a sequence which minimizes total flow time subject to minimum makespan in a two-stage flow shop problem. Szwarc [5], Yoshida and Hitomi [6], Anup [7], and so forth, derived the optimal algorithm for two/three or multistage flow shop problems taking into account the various constraints and criteria. Singh et al. [8] associated probabilities with processing time and setup time in their studies. Later, Gupta et al. [9] and Gupta and Singh [10] studied 𝑛×2 general flow shop problem to minimize rental cost under a predefined rental policy in which the probabilities have been associated with processing time on each machine and other scheduling problems by considering various parameters like transportation, idle/waiting operator, and so forth. Narain and Bagga [11–13] studied the flow shop problem with the objective being total rental cost. The total rental cost is minimized when idle time on all the machines is zero.

Under the no-idle situation, machines work continuously without any break; that is, machines should not remain idle once they start processing the first job. The no-idle situation arises in real life world, when machines have to be hired to complete an assignment. Minimization of the total expected hiring cost of the machines would be the objective in these type of situations. The total expected hiring cost of the machines will be at a minimum when idle times on the machines are minimum. Hence, the total expected hiring cost of the machines will be minimum when the idle times of all the machines are zero and under no-idle situation each machine is to be hired for time that is equal to the sum of processing times of all the jobs on it. We are extending the study done by Gupta Deepak including the concept of no-idle scheduling by associating probabilities to the processing time of the jobs. The present paper is an attempt to study the nm general flow shop scheduling with an objective to develop a heuristic algorithm such that no machine remains idle.

2. Practical Situation

Many applied and experimental situations exist in our day-to-day working in factories and industrial production concerns, and so forth, in which different jobs are processed on various machines in a fixed order. For example, in a foundry workshop, the drawing of iron round, cutting, heating, forging, machining, finishing, and packing of finished articles have a fixed order of processing that cannot be altered. Various practical situations also occur in real life when one has got the assignments but does not have one’s own machine or does not have enough money or does not want to take risk of investing huge amount of money to purchase machine. Under such circumstances, the machine has to be taken on rent in order to complete the assignments. Hiring of machines is an affordable and quick solution in various production, which is presently constrained by the availability of limited funds due to the recent global economic recession. Hiring enables saving working capital, gives option for having the equipment, and allows upgradation to new technology.

3. Notations and Definitions

The various notations used throughout the paper are as follows: 𝑆: given fixed sequence of jobs, 𝑀_𝑗: machine 𝑗, 𝑗=1,2,3,…,𝑚, 𝑎_𝑖,𝑗: processing time of 𝑖th job on machine 𝑀_𝑗, 𝑝_𝑖,𝑗: probability associated to the processing time 𝑎_𝑖,𝑗, 𝐴_𝑖,𝑗: expected processing time of 𝑖th job on machine 𝑀_𝑗, 𝑡_𝑖,𝑗(𝑆): completion time of 𝑖th job of sequence 𝑆 on machine 𝑀_𝑗, 𝐼_𝑖,𝑗(𝑆): idle time of machine 𝑀_𝑗 for 𝑖th job in the sequence 𝑆, 𝐼^𝐼_𝑖,𝑗(𝑆): idle time of machine 𝑀_𝑗 for 𝑖th job in the sequence 𝑆 when machine 𝑀_𝑗 starts at latest time 𝐿_𝑗.

Definition 1. Completion time of 𝑖th job on machine 𝑀_𝑗 is denoted by 𝑡_𝑖,𝑗 and is defined as 𝑡_𝑖,𝑗=max𝑡_{𝑖−1,𝑗},𝑡_{𝑖,𝑗−1}+𝑎_𝑖,𝑗×𝑝_𝑖,𝑗for𝑡𝑗≥2,=max_{𝑖−1,𝑗},𝑡_{𝑖,𝑗−1}+𝐴_𝑖,𝑗, (1) where 𝐴_𝑖,𝑗= expected processing time of 𝑖th job on machine 𝑗.

Definition 2. Completion time of 𝑖th job on machine 𝑀_𝑗 when 𝑀_𝑗 starts processing jobs at time 𝐿_𝑗 is denoted by 𝑡^𝐼_𝑖,𝑗 and is defined as 𝑡^𝑖_𝑖,𝑗=𝐿_𝐽^𝐼_𝐾=1𝐴_𝐾,𝑗=^𝐼_𝐾=1𝐼_𝑘,𝑗+^𝐼_𝐾=1𝐴_𝑘,𝑗,𝐼_𝑖,𝑗=max𝑡_{𝑖,𝑗−1}−𝑡_{𝑖−1,𝑗},0for𝑗≥2. (2) Also, 𝑡^𝑖_𝑖,𝑗=max𝑡_𝑖,𝑗,𝑡^𝑖_{𝑖−1,𝑗}+𝐴_𝑖,𝑗. (3)

Theorem 3. The time at which machine 𝑀_𝑟 should be taken on rent (or starts processing jobs) to have zero idle time on 𝑀_𝑟 is 𝐻_𝑟=max_{1≤𝑘≤𝑛}𝑌_𝑘,𝑟=2,3,…,𝑚 (4) where 𝑌_𝑘=𝑡^𝑙_{()𝑘,𝑟−1}−^𝑘−1_𝑖=1𝑝_𝑖,𝑟𝑋𝑎_𝑖𝑟for𝑌𝑘>1,_𝑘=𝑡^𝑙_{𝑘,𝑟−𝐼}−^𝑘−1_𝑖=1𝐴_𝑖𝑟,𝑌₁=𝑡^𝑙_()1,𝑟−1. (5)

Proof. Proof is based on mathematical induction. It will be shown that if machine 𝑀_𝑟 starts processing jobs at time 𝐻_𝑟, then the idle time of 𝑀_𝑟 is zero as For 𝑟=2, 𝐻₂=max_{1≤𝑘≤𝑛}{𝑌_𝑘} Let 𝑌_𝑞=max_{1≤𝑘≤𝑛}{𝑌_𝑘} Therefore, 𝑌_𝑞≥𝑌_𝑘 for 𝑘=1,2,3,…,𝑛. For 𝑘=1,𝑌_𝑞≥𝑌₁ Which implies 𝐻₂≥𝑡^𝑙_(1,1) or 𝑡^𝑙_()1,1≤𝐻₂. (6)From (6), if machine 𝑀₂ is taken on rent at time 𝐻₂, then it will start processing the first job without waiting. Therefore, idle time of machine 𝑀₂ for first job is zero when it starts processing jobs at time 𝐻₂ as 𝑌_𝑞≥𝑌_𝑘for𝑘=2,3,…,𝑛.  𝑌_𝑞±∑^𝑘−1_𝑖=1𝐴_𝑖,2≥𝑌_𝑘+∑^𝑘−1_𝑖=1𝐴_𝑖,2 that is 𝐻₂+∑^𝑘−1_𝑖=1𝐴_𝑖,2≥𝑡^𝑙_(𝑘,1)−∑^𝑘−1_𝑖=1𝐴_𝑖,2+∑^𝑘−1_𝑖=1𝐴_𝑖,2 that is 𝑡^𝑙_(𝑘−1,2)≥𝑡^𝑙_(𝑘,1) or 𝑡^𝑙_()𝑘,1≤𝑡^𝑙_()𝑘−1,2for𝑘=2,3,…,𝑛. (7) Therefore, 𝐼^𝑙_(𝑘,2)=max[𝑡^𝑙_(𝑘,1)−𝑡^𝑙_(𝑘−1,2),0].  From (7),  𝐼^𝑙_(𝑘,2)=0for𝑘=2,3,…,𝑛. Therefore, the result holds for 𝑟=2. Let the result hold for 𝑟=5. Now we will also show that the result is also true for 𝑟=𝑠+1. But  𝐻_𝑠+1=max_{1≤𝑘≤𝑛}{𝑌_𝑘}. Let 𝑌_𝑡=max_{1≤𝑘≤𝑛}{𝑌_𝑘}. Therefore, 𝑌_𝑡≥𝑌₁, that is, 𝐻_𝑠+1≥𝑡^𝑙_(𝑠,1)𝑡^𝑙_()𝑠,1≤𝐻_𝑠+1. (8)From (8), if machine 𝑀_𝑠+1 is taken on rent at time 𝐻_𝑠+1, then it will start processing the first job without waiting. Therefore, idle time of machine 𝑀_𝑠+1 for the first job is zero when it starts processing jobs at time 𝐻_𝑠+1. For 𝑘=2,3,…,𝑛. 𝑌_𝑡≥𝑌_𝑘 which implies 𝑌_𝑡+∑^𝑘−1_𝑖=1𝐴_𝑖,𝑠+1≥𝑌_𝑘+∑^𝑘−1_𝑖=1𝐴_𝑖,𝑠+1 𝐻_𝑠+1+∑^𝑘−1_𝑖=1𝐴_{(𝑖,𝑠+1)}≥𝑡^𝑙_(𝑘,𝑠)−∑^𝑘−1_𝑖=1𝐴_𝑖,𝑠+1+∑^𝑘−1_𝑖=1𝐴_𝑖,𝑠+1 which implies  𝑡^𝑙_{(𝑘−1,𝑠+1)}≥𝑡^𝑙_(𝑘,𝑠)𝑡^𝑙_()𝑘,𝑠≤𝑡^𝑙_{()𝑘−1,𝑠+1}for𝑘=2,3,…,𝑛. (9) Therefore, 𝐼^𝑙_{(𝑘,𝑠+1)}=max[𝑡^𝑙_(𝑘,𝑠)−𝑡^𝑙_{(𝑘−1,𝑠+1)},0] From (9), 𝐼^𝑙_{(𝑘,𝑠+1)}=0 for 𝑘=2,3,…,𝑛. Therefore, the result is true for 𝑟=𝑠+1 also.

Assumptions. (1) No machine processes more than one job at a time.(2) Preemption of jobs is not allowed.(3) Machines never breakdown during the scheduling process.(4) Each job is processed through each of the machines once and only once.(5) All the jobs and the machines are available at the beginning of the processing.(6) Jobs are independent of each other.

4. Algorithm

The algorithm given in this paper provides the procedure to determine the times at which machines should be hired so that the idle time becomes zero, minimizing total expected hiring cost under the given policy.

Step 1. Calculate the expected processing time 𝐴_𝑖,𝑗=𝑎_𝑖,𝑗×𝑝_𝑖,𝑗; for all 𝑖,𝑗=1,2,3,…,𝑚.

Step 2. For the fixed given sequence 𝑆, prepare the in-out table for the machine pair (𝑀_𝑗,𝑀_𝑗+1), 𝑗=1,2,3,…,𝑚−1 as two-machine flow shop sequence problem.

Step 3. Compute 𝐾_𝑗+1 for the machine pair (𝑀_𝑗,𝑀_𝑗+1) by the formula 𝐾_𝑗+1=𝑡_𝑛,𝑗+1−^𝑛_𝑖=1𝐴_𝑖,𝑗+1,𝑗=1,2,3,…,𝑚−1. (10)

Step 4. Calculate latest time 𝐿_𝑗 for the machine pair (𝑀_𝑗,𝑀_𝑗+1) by the formula 𝐻_𝑗=𝐻_𝑗−1+𝐾_𝑗𝐻;𝑗=3,4,5…𝑚−1,₂=𝐾₂,𝐻₁=0. (11)

Step 5. Prepare the in-out table for the machines with latest times 𝐿_𝑗; the idle time is zero for all machines.

5. Fuzzy Logic Engine

The calculations have been done using C++ program by using different values of processing times and probabilities (Algorithm 1). Based on the results, fuzzy logic engine has been formed in MATLAB fuzzy logic toolbox. The fuzzy logic rule base is based on the results generated from the C++ program. The membership function values and fuzzy rules are formed on the base of data generated from C++ program. Figure 1 shows the fuzzy logic system which consists of two inputs: processing time and probability and three output variables namely, 𝐻₂, 𝐻₃, and 𝐻₄. Figure 2 illustrates the membership functions for input processing time. Figure 3 illustrates the membership functions for input probability. Figure 4 illustrates the membership functions for output 𝐻₃. Figure 5 illustrates firing of the rule base.

#include<stdio.h> #include<conio.h>   // *************** variable declaration ***************// static int job_machine[5][4]; //to store jobs time for machines float job_prob[5][4]; // to tore jobs probability for machine float exp_pro_time[5][4]; // to store expacted processing time float m1m2[5][4],m2m3[5][4],m3m4[5][4]; float k2,k3,k4; float h1,h2,h3,h4; // ************** end variable declaration **************// void get_job_machine() //function to get jobs time and probabiity for machine {int i,j;/* int arr[5][4]={10,40,5,20,25,30,20,40, 20,20,20,10, 30,5,25,40, 20,30,20,20}; float arr2[5][4]={0.2,0.1,0.2,0.4,0.2,0.1,0.2,0.1, 0.1,0.3,0.2,0.3, 0.3,0.4,0.2,0.1, 0.2,0.1,0.2,0.1, };  for(i=0;i<5;i++) { for(j=0;j<4;j++) { job_machine[i][j]=arr[i][j]; job_prob[i][j]=arr2[i][j];} } */printf(“∖nEnter 5 Jobs Time & Probability for 4 Machines: "); for (i=0;i<5;i++ ){for(j=0;j<4;j++){printf(“∖n∖n Enter Job [ %d ] Time for Machine [ %d ]: ",i+1,j+1);scanf(“%d”,&job_machine[i][j]); printf(“∖n∖n Enter Job [ %d ] Probability for Machine [ %d ]: ",i+1,j+1); scanf(“%f",&job_prob[i][j]);}}} // end of get_job_marchine function// void put_job_machine() //function to show jobs time and probabiity for machine {int i,j; printf(“∖n∖t Machine1∖t Machine2∖t Machine3∖t Machine4∖n"); printf(“∖nJobs∖tTime∖tProb.∖tTime∖tProb.∖tTime∖tProb.∖tTime∖tProb."); for(i=0;i<5;i++) {printf(“∖n∖n[ %d ]",i+1); for(j=0;j<4;j++){printf(“∖t%d∖t%.1f",job_machine[i][j],job_prob[i][j]);}}} // end of Put_job_marchine function// void get_exp_pro_time() // function to calculatig expected processing time {int i,j;for(i=0;i<5;i++) {for(j=0;j<4;j++){exp_pro_time[i][j]=job_machine[i][j]*job_prob[i][j];}}} // end of get_exp_pro_time function// void put_exp_pro_time() // function to showing expected processing time {int i,j; printf(“⧵n∖nExpected Proessing Time: -"); printf(“⧵n⧵nJobs⧵t Machine1∖t Machine2⧵t Machine3⧵t Machine4⧵n");for(i=0;i<5;i++) {printf(“⧵n⧵n[ %d ]",i+1);for(j=0;j<4;j++) {printf(“∖t∖t%.1f",exp_pro_time[i][j]);}}} // end of Put_exp_pro_time function// void get_in_out_table() // function to calculating In Out Table for maching {int i;float p1,p2;// Machine m1-m2p1=0.0;p2=0.0;for(i=0;i<5;i++) {m1m2[i][0]=p1;m1m2[i][1]=exp_pro_time[i][0]+p1;p1=m1m2[i][1]; if(p2>p1)m1m2[i][2]=p2;elsem1m2[i][2]=p1; m1m2[i][3]=m1m2[i][2]+exp_pro_time[i][1];p2=m1m2[i][3];} // Machine m2-m3p1=0.0;p2=0.0;for(i=0;i<5;i++) {m2m3[i][0]=p1;m2m3[i][1]=exp_pro_time[i][1]+p1; p1=m2m3[i][1];if(p2>p1)m2m3[i][2]=p2; elsem2m3[i][2]=p1;m2m3[i][3]=m2m3[i][2]+exp_pro_time[i][2]; p2=m2m3[i][3];} // Machine m3-m4p1=0.0;p2=0.0;for(i=0;i<5;i++) {m3m4[i][0]=p1;m3m4[i][1]=exp_pro_time[i][2]+p1; p1=m3m4[i][1];if(p2>p1)m3m4[i][2]=p2; elsem3m4[i][2]=p1;m3m4[i][3]=m3m4[i][2]+exp_pro_time[i][3]; p2=m3m4[i][3];}} // end of get_in_out_table function// void put_in_out_table() // function to showing In Out Table for maching {int i,j; printf(“∖n∖nIn-Out Table: -"); printf(“∖n∖nJobs M1-M2 M2-M3 M3-M4∖n"); for(i=0;i<5;i++) {printf(“∖n∖n%d ",i+1);for(j=0;j<4;j++) {if(j==1 ‖ j==3) printf(“-");else printf(“ "); printf(“%4.1f",m1m2[i][j]);if(j==3) printf(“ %c",179);} for(j=0;j<4;j++) {if(j==1 ‖ j==3) printf(“-");else printf(“ "); printf(“%4.1f",m2m3[i][j]);if(j==3) printf(“ %c",179);}for(j=0;j<4;j++) {if(j==1 ‖ j==3) printf(“-");else printf(“ "); printf(“%4.1f",m3m4[i][j]);if(j==3) printf(“ %c",179);}}} // end of Put_in_out_table function// void final() {int i;float sum=0.0;for(i=0;i<5;i++)sum=sum+exp_pro_time[i][1]; k2=m1m2[4][3]-sum;sum=0.0; for(i=0;i<5;i++)sum=sum+exp_pro_time[i][2];k3=m2m3[4][3]-sum; sum=0;for(i=0;i<5;i++)sum=sum+exp_pro_time[i][3];k4=m3m4[4][3]-sum; h1=0;h2=k2;h3=h2+k3;h4=h3+k4; printf(“∖n∖nK2∖tK3∖tK4∖tH1∖tH2∖tH3∖tH4"); printf(“∖n∖n%.1f∖t%.1f∖t%.1f∖t%.1f∖t%.1f∖t%.1f∖t%.1f",k2,k3,k4,h1,h2,h3,h4);} void main() {clrscr();getch();get_job_machine();put_job_machine();getch(); get_exp_pro_time();put_exp_pro_time();getch();get_in_out_table(); put_in_out_table();getch();final();getch();}

Algorithm 1 

C++ program for given problem.

Figure 1 

Figure 2 

Figure 3 

Figure 4 

Figure 5 

5.1. Surfaces

The control surface for output 𝐻₂ is shown in Figure 6. The control surface for output 𝐻₃ is shown in Figure 7. The control surface for output 𝐻₄ is shown in Figure 8.

Figure 6 

Figure 7 

Figure 8 

6. Numerical Illustration

Consider a 5-job, 4-machine sequencing problem whose processing times with their corresponding probabilities given in the Table 1.

Table 1 

The machines with processing time and corresponding probabilities.

Here, our objective is to obtain the latest time of the machines so that no machine remains idle.

Expected processing times are given in Table 2.

Table 2 

Expected processing times.

For the pair (𝑀₁,𝑀₂), the in-out table is shown in Table 3 as 𝐾₂=𝑡_𝑛,2−⁵_𝑖=1𝐴_𝑖,2=49−34=15. (12)𝐻₂=𝐾₂=15 units and also we have 𝐻₁=0.

Table 3 

The in-out table for machines 𝑀₁ and 𝑀₂.

For the pair (𝑀₂,𝑀₃), the in-out table is shown in Table 4 as 𝐾₃=𝑡_5,3−⁵_𝑖=1𝐴_𝑖,3𝐻=35−21=14,₃=𝐻₂+𝐾₃=15+14=29. (13) For the pair (𝑀₃,𝑀₄) the in-out table is shown in Table 5 as 𝐾₄=𝑡_5,4−⁵_𝑖=1𝐴_𝑖,4𝐻=2,₄=𝐻₃+𝐾₄=29+2=31. (14) The in-out table for the machines with idle time zero is shown in Table 6.

Table 4 

The in-out table for machines 𝑀₂ and 𝑀₃.

Table 5 

The in-out table for machines 𝑀₃ and 𝑀₄.

Table 6 

In-out table.

Hence, we conclude that no machine remains idle.

7. Conclusion

The proposed algorithm provides the latest time at which processing of jobs on second, thired, and so on 𝑚th machine must be started such that these machines work continuously without any break until the last job is completed on them. The first machine has no idle time and, hence, works continuously; that is, the proposed algorithm helps the decision makers in determining the best latest time at which machines should be hired for a given set of jobs so as to minimize the total expected hiring cost with no-idle constraint. The study may be extended by introducing concepts of independent setup time, transportation time, job block criteria, and nonavailability constraints of machines for a certain interval of time.