On a bi-criteria flow shop scheduling problem under constraints of blocking and sequence dependent setup time

Abstract

In this paper, we propose a bi-criteria optimization model for a flow shop scheduling problem with permutation, blocking and sequence dependent setup time. Indeed, these constraints are the most encountered in the industrial field, which demands high command flexibility. The objective is the minimization of two criteria, in our case the makespan and the total tardiness combined in a single objective function with a weighting coefficient for each criterion. To solve this problem, we propose a mixed integer linear programming method and a set of different metaheuristics. The suggested metaheuristics are; the genetic algorithm, the iterated greedy metaheuristic and the iterative local search algorithm. This last algorithm is proposed in two ways of exploration of the neighborhood. To verify the effectiveness of our resolution algorithms, a set of instances with n jobs and m machines is randomly generated from small instances to relatively large size ones. The analysis of the suggested simulation model allowed us to note that the iterative local search algorithm gives good results compared to the iterative greedy algorithm. Moreover, it was found that the weighting parameter plays an essential role in the problem decision making. However, it was established that it is difficult to find a good solution that minimizes both criteria at once, a suitable compromise will be necessary to be adopted using the weighting coefficient.

1 Introduction

The blocking flow shop scheduling problem (BFSP) under constraint sequence-dependent setup time (SDST) is one of the most attractive problems in industrial optimization. The constraint of the blocking is often imposed when the stock is of null capacity between the machines. On the other hand, the setup time is important to be considered, for the execution of a new job, when the machine requires a time of adjustment or cleaning etc. These two constraints are of great industrial importance that can influence the scheduling plan and therefore the proper decision-making. Hence, recent works on the study of single or multi-objective (MO) scheduling problems under one or both of these constraints have been fullfilled. For instance, Nouri and Ladhari (2018) presented a resolution approach using the non sorting genetic algorithm (NSGA) for solving a multi-objective BFSP. Also, we note that in Takano and Nagano (2017), we find a mixed integer linear programming (MILP) formulation and branch and bound (BB) procedures to minimize the makespan for solving BFSP problem under SDST constrainst. The consideration of the two both constraints of the blocking and SDST are recently studied. Indeed, the work Riahi et al. (2018) described an algorithm based on the variable neighborhood descent (VND) to minimize the mono-criterion makespan for the problem SDST/BFSP. Also, in Shao et al. (2018) the water wave optimization algorithm is used to solve the SDST/BFSP problem by minimizing the same criterion. All these last two recent works study the SDST/BFSP scheduling problem by optimizing only one criterion.

In our paper, we continue the investigation in SDST/BFSP scheduling problems by considering a MO optimization issue. The objective will be the minimization of two criteria, the makespan and the total tardiness of the jobs formulated by an objective function with a weighting coefficient for each criterion. We propose a MILP and four algorithms; the genetic algorithm (GA), the iterative greedy (IG) algorithm and the iterative local search (ILS) algorithm with two versions. The model represents therefore a bi-criteria optimization problem for a permutation flow shop scheduling problem (PFSP). This contribution is addressed to solve the MO scheduling problem with n jobs and m machines under both constraints of blocking and setup time. Indeed, these constraints are often encountered in several industrial processes, such as the food industry, the pharmaceutical industry and the petrochemical industry, etc. The review of the literature in Miyata and Nagano (2019) describes the different cases of BFSP scheduling problems. The MO optimization is becoming more and more a preference for current industrial case studies. In this perspective, MO optimization becomes a priority for most managers to solve among others the PFSP problem. We also recall that a review of multi-criteria optimization literature for the PFSP problem is described in (Sun et al. 2011; Yenisey and Yagmahan 2014). The work Xu et al. (2017) presents a MO optimization model for the SDST/PFSP problem minimizing the makespan and total weighted tardiness. Several resolution approaches are proposed to solve such problem, we distinguish three types of fundamental approaches of resolution, the exact methods, the heuristics and the metaheuristics.

Indeed, the exact methods representing the first class of resolutions attract the attention of researchers for its applied mathematical aspect. These models are intended to optimize one or more criteria defined by one or more objective functions. Yu and Seif (2016) provides MILP and a lower bound based on GA for solving a PFSP problem in order to minimize total tardiness and maintenance cost. A mathematical formulation by MILP for PFSP is described in Ta et al. (2018) to minimize the total tardiness. Also, Ronconi and Birgin (2012) presented several MILP models according to different PFSP configuration to minimize the total tardiness and precocity. Moreover, M’Hallah (2014) described a MILP model for the PFSP problem to minimize the same criterion. In (Trabelsi et al. 2012), different types of blocking are studied giving a mathematical model in the form of MILP. Besides, in (Moslehi and Khorasanian 2013) a MILP mathematical formulation and a resolution by the method of BB are proposed to solve BFSP in order to minimize the total completion time. Ronconi (2005) proposed two LB and BB algorithm for the resolution of the BFSP problem to minimize the makespan criterion. Likewise, Tellache and Boudhar (2018), Meziani et al. (2019) presented a complexity study of the PFSP for two machines minimizing the makespan and also developing a set of LB resolution algorithms.

The second class of resolution approach is described by the heuristics based on the priority rules. We note in particular that the algorithm proposed in (Nawaz et al. 1983), is also designated in the scheduling literature by the algorithm (NEH). Later, several extented versions are derived for the PFSP multiple machines. In the work (Pan and Wang 2012), a set of heuristics based on the NEH algorithm is applied to solve the BFSP in order to minimize the makespan. As well as, in (Ribas and Companys 2015), several heuristics are proposed to solve the BFSP aiming to minimize the total flow time. We also note that in (Rossi et al. 2017) a constructive heuristics are described to minimize the total flow time for PFSP. In the recent work (Takano and Nagano 2019), a set of heuristics are also presented in order to solve SDST/BFSP problem.

The third class for PFSP resolution is based on metaheuristics whose objective is usually to improve the initial solutions already obtained by heuristics. Therefore these metaheuristics have a fundamental interest for solving problems with a larger size, especially when the two previous methods are limited. These metaheuristics are applied to solve PFSP scheduling problems under various constraints and optimizing various objectives. Applications are also extended for various case of these problems such as distributed permutation flow shop scheduling problem (DPFSP) as well as no wait permutation flowshop scheduling problem (NWPFSP). Ruiz et al. (2019) proposed IG algorithm minimizing the makespan for DPFSP, Li et al. (2018) proposed the same algorithm for solving SDST/NWPFSP with learning and forgetting effects to minimize the total flow time. Shoaardebili and Fattahi (2015) suggested algorithms based simulated annealing (SA) and NSGA algorithm for MO-PFSP in order to simultaneously minimize the total weighted flow time and the weighted sum of the earliness and tardiness under machine availability constraint. Li and Li (2015) used the ILS algorithm for MO-PFSP to minimize the makespan and the total flow time, as well as Li and Ma (2017) used the discreet artificial bee colony algorithm (ABC) for MO-SDST/PFSP to minimize the same goals. Jiang and Wang (2019) proposed the evolutionary decomposition algorithm (EDA) to minimize the makespan and the consumption energy for MO-SDST/PFSP. In the work Zhang et al. (2019), a hybrid version of the same EDA algorithm is used for solving MO-PFSP problem by minimizing the makespan and the maximum tardiness. Liu et al. (2017) developed the GA algorithm to minimize the energy consumption and tardiness penalty for MO-SDST/PFSP. Rifai et al. (2016) presented an adaptive large neighborhood search algorithm for solving the distributed and re-entrant PFSP to optimize the makespan, total cost and average tardiness. The whale optimization algorithm is used to solve the PFSP problem whose goal is to minimize the makespan (Abdel-Basset et al. 2018). Recently, Newton et al. (2019) used a new version of ILS algorithm to solve the SDST/BFSP with various constraints of blocking to minimize the makespan. In this present paper, we continue the investigations in SDST/BFSP problems by incorporating to the objective functional two criteria that are makespan and total tardiness. We develop a new approach solving problem based on a two-criteria optimization model. Our contribution is therefore to propose a MILP and a set of metaheuristics based on local research for a MO SDST/BFSP problem. To solve this kind of problem, we will develop a new implementation of the ILS algorithm. Indeed, we propose two versions of ILS with a vast exploitation of the neighborhood of the current solution. In the first version $\hbox {ILS}_1$, a set of solution is generated by the procedure of insertion and total shift of the elements of the solution to be explored. In the second version $\hbox {ILS}_2$, a set of neighboring solutions is tested using the procedure of total permutation of the elements of the current sequence. These two versions are compared with two other algorithms, in our case IG and GA. In addition, we propose a set of initialization heuristics based on the priority rules incorporated in our metaheuristics. In our resolution approach, we find that ILS algorithm in its second version gives the best results.

Our paper is organized in the following way. In Sect. 2, we present a description of the model retained for SDST/BFSP bi-objectives. Followed in Sect. 3 by a description of the proposed resolution algorithms. A comparative study is presented in Sect. 4. Section 5 concludes our contribution.

2 Problem statement

2.1 Description of the model SDST/BFSP

The flow shop scheduling problem with permutation, under sequence-dependent setup time and blocking jobs in the machine queue constraints is designated by SDST/BFSP. The complex nature of this problem with the presence of such constraints, pushes business managers to look for mathematical models of simulation for resolution. Indeed, this problem is characterized by a set of jobs $J=\{J_1,J_2,\ldots ,J_n\}$ whose sequence is launched in a cycle of production constituted by a set of serially implanted machines $M=\{M_1,M_2,\ldots ,M_m\}$ forming the processes of jobs production. A job $J_j$ admits a processing time $p_{jl}$ on the machine l, the due time $d_j$, this latter represents the delay time fixed by the customer for each job; any job delivered beyond this date is considered late. The setup time of the job $J_k$ on the machine l which has just processed the job $J_j$ is denoted by $s_{jkl}$, when a job is not preceded by any job on the machine l, the setup time is noted $s_{jjl}$. This constraint is referred in the scheduling problem literature as the sequence dependent setup time (SDST). Another constraint is present in our study, it deals with the blocking of a $J_j$ during its treatment on all concerned machines, knowing that it will be blocked in its machine until the next machine will be available. The departure date of the job $J_j$ on the machine l is designated by $D_{jl}$. This date represents also the start date of processing on the next machine $l+1$. A sequence $\pi =(\pi _1,\ldots ,\pi _n)$ of jobs is processed in the set of machines in the same order, the retained assumptions are those of the classic case of the PFSP problems. Knowing that a machine processes only one job at a given time, the interruption is not allowed, a job $J_j$ has more than one successor and a single predecessor, all the jobs and all the machines are available at the initial moment. Blocking jobs on machines and their setup times will be considered in the used model of this study. The objective is the minimization of two criteria in this case the makesapn and the total tardiness.

We propose a model formed by a combination of two criteria in a single objective function with a weighting coefficient for each criterion. It is worthy to notice that the adopted notation for the scheduling problem is usually represented by the three fields $\alpha |\beta |\gamma$, where the first field $\alpha$ designates the type of problem, the second one $\beta$ stands for the different constraints imposed to the scheduling problem and the third field $\gamma$ represents the nature of the objective function. In our study, the scheduling problem will be noted by $Fm|prmu,SDST,blocking|\mu C_{max}+(1-\mu ) \sum _{j=1}^{n}{T_j}$, such that the parameter $\mu \in [0,1]$ allows to attribute weight to each criterion. Another virtual machine is added at the beginning to all the machines. Similarly, a noted virtual job $\pi _0$ is inserted at the beginning of the sequence, whose processing time on the all machine is zero and the setup times with the other jobs in each machine is equal to the setup times $s_{jjl}$ of the job $J_j$ when it is not preceded by any job. Here, we give a set of equations to determine the parameters needed for the departure date of each job on each machine.

$$\begin{aligned}&s_{\pi _0\pi _jl}=s_{\pi _j\pi _jl},\;\; l=1,\ldots ,m ,\;\; j=1,\ldots ,n \end{aligned}$$

(1)

$$\begin{aligned}&D_{\pi _0l}=0,\;\;l=1,\ldots ,m \end{aligned}$$

(2)

$$\begin{aligned}&D_{\pi _j0}=D_{\pi _{(j-1)}1}+s_{\pi _{(j-1)}\pi _j1},\;\;j=1,\ldots ,n \end{aligned}$$

(3)

$$\begin{aligned}&D_{\pi _jl}=max\{D_{\pi _{(j-1)}(l+1)}+s_{\pi _{(j-1)}\pi _j(l+1)},D_{\pi _j(l-1)}+p_{\pi _jl}\}\nonumber \\&\quad j=1,\ldots ,n,\;\;l=1,\ldots ,m-1 \end{aligned}$$

(4)

$$\begin{aligned}&D_{\pi _jm}=D_{\pi _j(m-1)}+p_{\pi _jm},\;\;j=1,\ldots ,n \end{aligned}$$

(5)

The first Eq. (1) makes it possible to identify the characteristics of the virtual job $\pi _0$ by assigning it the duration of dedicated setup times. The other Eqs. (2)–(5) allow to determine the departure dates of each job on each machine including the added virtual machine at the beginning of the scheduling. Our scheduling model consists of combining two criteria into a single objective function to minimize. The first goal is to minimize the makespan, knowing that the end date of a job on the last machine m is equal to its departure date on this machine in this case $D_{\pi _jm}$, the makespan will be expressed by:

$$\begin{aligned} C_{max}=max\{D_{\pi _jm}\},\;\;j=1,\ldots ,n \end{aligned}$$

(6)

The second considered objective in this study is to minimize the total tardiness of all jobs. For that, we calculate the tardiness of each job by $T_{\pi _j}=max(0,D_{\pi _jm}-d_{\pi _j})$, the total tardiness will be expressed by:

$$\begin{aligned} TT=\sum _{j=1}^{n}{T_{\pi _j}},\;\;j=1,\ldots ,n \end{aligned}$$

(7)

The main objective functional is therefore written in the form of a combination of these two criteria, the first is the makespan $(C_{max})$ and the second is the total tardiness (TT)

$$\begin{aligned} min \;\;f=\mu C_{max}+(1-\mu )TT \end{aligned}$$

(8)

Thus, we give a set of equations allowing the determination of the necessary parameters to evaluate the values of the two criteria fixed for the bi-objective function. Our goal is then to determine an optimal sequence that minimizes the objective function as much as possible across all permutations $\varPi$ during the exploration of the entire neighborhood such as

$$\begin{aligned} f(\pi _*)\leqslant f(\pi _),\;\;\pi \in \varPi \end{aligned}$$

(9)

2.2 Numerical illustration

In order to highlight the proposed model, we present an illustrative example which consider an instance consisting of three jobs and three machines forming our workshop. We represent the processing times of the jobs on the machines by the matrix $[p_{jl}]$ and the inter-job setup times in the different machines by the matrix $[s_{jk1}]$, $[s_{jk2}]$ and $[s_{jk3}]$. The due dates will be expressed for each job such that $d_1=17,\;d_2=14,\;d_3=10$.

$$\begin{aligned}{}[p_{jl}]=\left[ \begin{matrix} 1 &{}\quad 3 &{}\quad 3 \\ 1 &{}\quad 4 &{}\quad 2 \\ 3 &{}\quad 3 &{}\quad 4 \end{matrix} \right] ,\;\; \quad [s_{jk1}]=\left[ \begin{matrix} 1 &{}\quad 1 &{}\quad 2 \\ 4&{}\quad 3 &{}\quad 1 \\ 2 &{}\quad 4 &{}\quad 1 \end{matrix} \right] ,\;\; \quad [s_{jk2}]=\left[ \begin{matrix} 2 &{}\quad 3 &{}\quad 2 \\ 2&{}\quad 2 &{}\quad 3 \\ 2 &{}\quad 3 &{}\quad 3 \end{matrix} \right] ,\;\; \quad [s_{jk3}]=\left[ \begin{matrix} 1 &{}\quad 2 &{}\quad 2 \\ 2&{}\quad 2 &{}\quad 1 \\ 1 &{}\quad 2 &{}\quad 2 \end{matrix} \right] \end{aligned}$$

We want to schedule the sequence $\pi =(3\;2\;1)$, the first step is to determine the setup times of the virtual job $\pi _0$ on the different machines, knowing that this job will precede all the other jobs in the built sequence, according to Eq. (1), knowing that $\pi _1=3,\;\pi _2=2,\;\pi _3=1$ , we can write: $s_{\pi _0\pi _11}=1,\;s_{\pi _0\pi _21}=3,\;s_{\pi _0\pi _31}= 1,\;s_{\pi _0\pi _12}=3,\;s_{\pi _0\pi _22}=2,\;s_{\pi _0\pi _32}=2,\;s_{\pi _0\pi _13}=2,\;s_{\pi _0\pi _23}=2,\;s_{\pi _0\pi _33}=1$. We note that Eq. (2) allows the initialization of computation parameters, so we can write: $D_{\pi _01}=0,\;D_{\pi _02}=0,\;D_{\pi _03}=0$.

With the other Eqs. (3)–(5), we give in detail the departure date of each job of all the machines of our sequence by the following expressions: $D_{\pi _10}=D_{\pi _01}+s_{\pi _0\pi _11}=0+1=1$, $D_{\pi _11}=max\{D_{\pi _02}+s_{\pi _0\pi _12},D_{\pi _10}+p_{\pi _11}\}= max\{0+3,1+3\}=4$, $D_{\pi _12}=max\{D_{\pi _03}+s_{\pi _0\pi _13},D_{\pi _11}+p_{\pi _12}\}= max\{0+2,4+3\}=7$, $D_{\pi _13}=D_{\pi _12}+p_{\pi _13}=7+4=11$; $D_{\pi _20}=D_{\pi _11}+s_{\pi _1\pi _21}=4+4=8$, $D_{\pi _21}=max\{D_{\pi _12}+s_{\pi _1\pi _22},D_{\pi _20}+p_{\pi _21}\}= max\{7+3,8+1\}=10$, $D_{\pi _22}=max\{D_{\pi _13}+s_{\pi _1\pi _23},D_{\pi _21}+p_{\pi _22}\}= max\{11+2,10+4\}=14$, $D_{\pi _23}=D_{\pi _22}+p_{\pi _23}=14+2=16$; $D_{\pi _30}=D_{\pi _21}+s_{\pi _2\pi _31}=10+4=14$, $D_{\pi _31}=max\{D_{\pi _22}+s_{\pi _2\pi _32},D_{\pi _30}+p_{\pi _31}\}= max\{14+2,14+1\}=16$, $D_{\pi _32}=max\{D_{\pi _23}+s_{\pi _2\pi _33},D_{\pi _31}+p_{\pi _32}\}= max\{16+2,16+3\}=19$, $D_{\pi _33}=D_{\pi _32}+p_{\pi _33}=19+3=22$.

Fig. 1

Gantt chart of three jobs on three machines

We can deduce the end dates of the three jobs on the last machine, knowing that $D_{\pi _13}=11,\;\;D_{\pi _23}=16,\;\;D_{\pi _33}=22$ as well as the value of the makespan $C_{max}=22$. For the tardiness of the jobs during the scheduling, it is calculated taking into account the due date imposed for each job, calculating the tardiness of each job, knowing that, $T_3=1,\;\;T_2=2,\;\;T_1=5$, the total tardiness is $TT=1+2+5=8$, with a value of $\mu =0.5$ our objective function is written so $f=0.5\times 22+0.5\times 8=15$. The Gantt chart illustrated in Fig. 1 represents the result of the scheduling in the three machines of the studied example with the blocking and setup dependent time constraints.

3 Resolution methods

We propose two approaches of resolutions for the SDST/BFSP bi-objective scheduling problem. The first is based on a mathematical formulation by a MILP, the second is constituted by a set of heuristics and metaheuristics. For the MILP an objective function is given by a combination of the two criteria and a set of constraints must be satisfied. The second approach is composed of IG, GA and ILS with two versions, intended to solve the problems of relatively large sizes, all the metaheuristics will be initialized by a set of heuristics based on the NEH algorithm.

3.1 Mixed integer linear programming model

We propose here a mathematical formulation in MILP of our bi-objective problem. We give a set of parameters and variables necessary for our model.

$$\begin{aligned} z_{kq}= {\left\{ \begin{array}{ll} 1, &{} \text {if job}\ k\ \text {is at the}\ q\text {-th position in the sequence } \\ 0, &{} \text {otherwise}\\ \end{array}\right. } \end{aligned}$$

$C_{ql}$: the completion time of the q-th position job at machine l.

$D_{ql}$: the departure date of the q-th position job at machine l.

$$\begin{aligned} x_{jkq}= {\left\{ \begin{array}{ll} 1, &{} \text {if the job}\ j\ \text {precedes the job} \ k \text { which is at the}\ q \text {-th position} \\ &{} \text { in the sequence}\\ 0, &{} \text {otherwise}\\ \end{array}\right. } \end{aligned}$$

C max: Makespan

$T_q$: Tardiness of q-th position job

$$\begin{aligned} Minmize\; f=\mu C_{max}+(1-\mu )\displaystyle \sum _{q=1}^{n}{T_q} \end{aligned}$$

(10)

Subject to

$$\begin{aligned}&\displaystyle \sum _{k=1}^{n}{z_{kq}}=1,\; q=1,\ldots ,n \end{aligned}$$

(11)

$$\begin{aligned}&\displaystyle \sum _{q=1}^{n}{z_{kq}}=1,\; k=1,\ldots ,n \end{aligned}$$

(12)

$$\begin{aligned}&\displaystyle \sum _{j=1}^{n}\sum _{k=1}^{n}{x_{jk1}}=0 \end{aligned}$$

(13)

$$\begin{aligned}&\displaystyle \sum _{j=1}^{n}\sum _{k=1}^{n}{x_{jkq}}=1,\; q=2,\ldots ,n \end{aligned}$$

(14)

$$\begin{aligned}&x_{jkq}\geqslant z_{kq}+z_{j(q-1)}-1,\; j=1,\ldots ,n,\; k=1,\ldots ,n,\; q=2,\ldots ,n,(k \ne j)\nonumber \\ \end{aligned}$$

(15)

$$\begin{aligned}&C_{1l}=\displaystyle \sum _{k=1}^{n}s_{kkl}\times {z_{k1}},\; l=1,\ldots ,m \end{aligned}$$

(16)

$$\begin{aligned}&C_{ql}=D_{(q-1)l}+\displaystyle \sum _{j=1}^{n}\sum _{k=1}^{n}s_{jkl}\times {x_{jkq}},\; q=2,\ldots ,n,\; l=1,\ldots ,m \end{aligned}$$

(17)

$$\begin{aligned}&D_{ql}\geqslant C_{q(l+1)},\; q=1,\ldots ,n,\; l=1,\ldots ,m-1 \end{aligned}$$

(18)

$$\begin{aligned}&D_{q1}\geqslant C_{q1}+\displaystyle \sum _{j=1}^{n}p_{j1}\times z_{jq},\; q=1,\ldots ,n \end{aligned}$$

(19)

$$\begin{aligned}&D_{ql}\geqslant C_{q(l-1)}+\displaystyle \sum _{k=1}^{n}p_{kl}\times z_{kq},\; q=1,\ldots ,n,\; l=2,\ldots ,m \end{aligned}$$

(20)

$$\begin{aligned}&T_{q}\geqslant D_{qm}-\sum _{k=1}^{n}z_{kq}\times d_k,\; k=1,\ldots ,n \end{aligned}$$

(21)

$$\begin{aligned}&C_{max}\geqslant D_{nm} \end{aligned}$$

(22)

$$\begin{aligned}&T_q\geqslant 0,\;q=1,\ldots ,n \end{aligned}$$

(23)

$$\begin{aligned}&C_{ql},\; D_{ql}\geqslant 0,\;q=1,\ldots ,n,\; l=1,\ldots ,m \end{aligned}$$

(24)

$$\begin{aligned}&z_{kq}\in \{0,1\},\;x_{jkq}\in \{0,1\},\; j=1,\ldots ,n,\; k=1,\ldots ,n,\; q=1,\ldots ,n \end{aligned}$$

(25)

Equation (10) expresses the two-criteria objective function the makespan and the total tardiness, each having a weighting coefficient. The constraints (11) and (12) make it possible to express that each job occupies a single position and each position is occupied by a single job in the sequence. Constraint (13) expresses that no job precedes the job of the first position in the sequence. The constraint (14) guarantees that only one job will be assigned to the position q in the sequence with a single predecessor except that of the first position. In the constraint (15), for each job k occupying the position q in the sequence is sequenced after the job j occupying the position $q-1$ except for that of the first position. The constraint (16) relates to the first job of the sequence where its completion time of setup depends essentially on setup time $s_{kkl}$ on the machine l. The constraint (17) makes it possible to calculate the completion time of setup of the jobs in the other machines. In addition this is expressed by the summation of the job departure date of the $(q-1)$ position and the setup time with the successor job. The constraints of (18)–(20) make it possible to calculate the departures date of the jobs in the machines by considering the constraint of the blocking. The constraint (18) is applied for all the jobs in the first machine, the constraint (19) is applied for all the jobs in the other machines except the last, the constraint (20) guarantees that the departure date of the jobs of the machine l is greater than or equal to the starting date of the machine $(l-1)$ plus its processing time at the machine l. The constraint (21) expresses that the tardiness of a job is greater than or equal to the difference of the departure date in the last machine and the imposed date due. The constraint (22) expresses that the makespan is greater than or equal to the departure date of the last job in the last machine. The constraints (23) and (24) make it possible to define the domain of variation of the parameters of the model.

3.2 Initialization heuristics

The most important phase in solving metaheuristic optimization problem is the determination of the initial solution. Indeed for our bi-objective minimization problem of SDST/BFSP, we have chosen six rules to build the initial solutions. We propose an adaptation of the NEH algorithm to improve the initial solutions by starting with the sequence obtained by each rule. Here, we give the characteristics of six rules by detailing the properties of each rule.

• $R_1$ : The first rule is based on Johnson’s algorithm (Johnson 1954), it consists in forming two virtual machines $M^{(1)}$ and $M^{(2)}$, dividing the number of machines into two sub assemblies whose respective number of machines is $m_1$ and $m-m_1$, knowing that $m_1=\lfloor m/2\rfloor$, where $\lfloor \cdot \rfloor$ denotes the floor function; the processing times on the two machines are calculated by the following expressions

  $$\begin{aligned} \left\{ \begin{array}{lll} p^{(1)}_j=\displaystyle \sum _{l=1}^{m_1}(p_{jl}+s_{jjl}) \;\; processing\;\; time \;\;in\;\; M^{(1)}\\ \\ p^{(2)}_j=\displaystyle \sum _{l=m_1+1}^{m}(p_{jl}+s_{jjl}) \;\; processing\;\; time \;\;in\;\; M^{(2)}\\ \end{array} \right. \end{aligned}$$

  (26)

  To form the sequence of Johnson, one will determine the subsets $U=\{J_j,\;p^{(1)}_{j}< p^{(2)}_j\}$ and $V=\{Jj,\;p^{(1)}_{j}\geqslant p^{(2)}_{j}\}$, then will classify the jobs of U in increasing order of $p^{(1)}$ on $M^{(1)}$ and the jobs of V in decreasing order of $p^{(2)}$ on $M^{(2)}$. The Johnson sequence is formed by the concatenation of ordered sub sequences UV.

• $R_2$ : The second rule is based on the notion of the longest processing time of job on all machines in flow shop, also called (LPT) by calculating the following expression

  $$\begin{aligned} \zeta ^{(1)}_j=\displaystyle \sum _{l=1}^{m}(p_{jl}+s_{jjl}), \;\;j=1,\ldots ,n \end{aligned}$$

  (27)

  An initial sequence will be determined and the jobs ranked in descending order of $\zeta ^{(1)}_j$.

• $R_3$ : The third rule is based on the rule inspired by the model described in Rajendran and Ziegler (1997) that we adopt for our problem by calculating the following expression

  $$\begin{aligned} \zeta ^{(2)}_j= \displaystyle \sum _{l=1}^{m}(m-l+1)(p_{jl}+s_{jjl}),\;\;j=1,\ldots ,n \end{aligned}$$

  (28)

  An initial sequence is obtained by classifying the jobs in descending order of $\zeta ^{(2)}_j$.

• $R_4$ : The fourth rule is to determine the following expression

  $$\begin{aligned} \begin{aligned} \zeta _j^{(3)}&= \displaystyle \left( \frac{2}{m-1}\right) \times \sum _{l=1}^{m}(m-l)(p_{jl}+s_{jjl})+\sum _{l=1}^{m}(p_{jl}+s_{jjl})\\&\quad j=1,\ldots ,n \end{aligned} \end{aligned}$$

  (29)

  It is inspired by the model treated in (Tasgetiren et al. 2017), it also consists in also arranging the jobs in descending order of $\zeta ^{(3)}_j$, to get the sequence for this rule.

• $R_5$ : The fifth rule is based on the due date, it consists in classifying the jobs in ascending order of their due date $d_j$.

• $R_6$ : The sixth rule and the last one consists in determining the expected advance by calculating for each job the following expression

  $$\begin{aligned} \zeta ^{(4)}_j= max(0,d_j-\sum _{l=1}^{m}(p_{jl}+s_{jjl})),\;\;j=1,\ldots ,n \end{aligned}$$

  (30)

  An initial sequence will be obtained by classifying the jobs in ascending order of $\zeta ^{(4)}_j$.

For the six rules mentioned above, we used the processing times, the setup times, the due dates as well as the number of jobs and the number of machines characterizing our problem. The improvement of these initial solutions is ensured by a adaptive heuristic based on the constructive algorithm NEH which we write $\textit{NEH}\_R_i$, relating respectively to the rules $R_i$, $i= 1,\ldots ,6$. Our heuristic will be described by the Algorithm 1.

The principle of this heuristic is based on two phases, the first phase consists in breaking down the sequence $\pi$ into two sub-sequences $\pi =[\pi ^{(1)}\;\pi ^{(2)}]$, with $\pi ^(1)=(\pi ^{(1)}_1,\pi ^{(1)}_2,\ldots ,\pi ^{(1)}_m)$ and $\pi ^{(2)}=(\pi ^{(2)}_{m+1},\pi ^{(2)}_{m+2},\ldots ,\pi ^{(2)}_n)$ under the hypothesis $m <n$ that we consider satisfied for all our simulated instances. The second phase consists of extracting each job $\pi ^{(2)}_k$ from the sub-sequence $\pi ^{(2)}$ and reinserting it into the different positions of the constructed sub-sequence $\pi =[\pi ^{(1)}\; \pi ^{(2)}_k]$ and retaining the best sequence among all the sequences generated by insertion. This process will be repeated until all jobs are completed. This principle of decomposition and insertion will be repeated until satisfying a stop criterion defined as a limit iteration number $(N\_limite)$. This limit number will be determined according to the size of the studied instance. We choose $N\_limite=30$ for small and medium size instances and $N\_limite = 50$ for relatively large size instances.

For the bi-objective optimization, we note that for the choice of the right solution among all the solutions obtained by the two criteria, will be based on the combination of the two objectives in one that is written in the form of the Eq. (8). We note that in this model the coefficient $\mu \in [0,1]$ is the weighting factor of the criterion chosen by the decision maker when establishing the scheduling strategy. It will be considered variable to give flexibility to the production manager at the level of each batch launched in the production cycle.

3.3 Iterative local search

The first algorithm proposed for solving our problem is the iterative local search algorithm for the bi-objective minimization of the SDST/BFSP. This type of algorithm has been adopted for the resolution of several types of scheduling problems, in particular for PFSP in (Dong et al. 2009, 2013; Xu et al. 2017). The principle of this algorithm is simple, it consists of defining a solution in the neighborhood of the current solution and comparing the objective function value with the current best value of this function. The principle is repeated until it satisfies a stop condition. In our approach, we consider a method which consists in the first phase of defining the set of neighboring solutions $\varGamma ^{(i)},\;i\in \{1,2\}$. Where $\varGamma ^{(i)}$ denotes the set of solutions generated in the perturbation procedure ($Proced\_pert$), by total insertion $(i = 1)$ or total permutation $(i = 2)$, respectively. In the second phase, we choose among the generated solutions the best one, then comparing it with the best current solution. The process will be repeated until the imposed stop will be satisfied.

The description of the steps of this algorithm is described in the Algorithm 2. We consider two types of neighborhoods, the first one is based on the total insertion and the shift on the left and on the right, the second type of neighborhood is based on the total permutation of a job with all the other jobs without repetitions. In the last phase of the algorithm, we highlight the model simulated annealing to better explore the set of solutions. We distinguish in this algorithm two procedures for generating the set of neighborhoods called $Proced\_pert$. This procedure generates the neighborhood by involving the total exploration of the neighborhood of the current solution with two different ways $\hbox {ILS}_1$ and $\hbox {ILS}_2$:

Fig. 2

An example illustrating the total insertion procedure $Proced\_pert$

We consider two types of neighborhoods, the first one is based on the total insertion and the shift on the left and on the right, the second type of neighborhood is based on the total permutation of a job with all the other jobs without repetitions. In the last phase of the algorithm, we highlight the model simulated annealing to better explore the set of solutions. We distinguish in this algorithm two procedures for generating the set of neighborhoods called $Proced\_pert$. This procedure generates the neighborhood by involving the total exploration of the neighborhood of the current solution with two different ways $\hbox {ILS}_1$ and $\hbox {ILS}_2$:

• Procedure $Proced\_pert$ for $\hbox {ILS}_1$: The total insertion disruption procedure is used in the first version of the iterative local search algorithm designated by $\hbox {ILS}_1$.

  Figure 2 shows an implementation example of the total insertion procedure $Proced\_pert$, here we give an example of 4 jobs, starting from a current best sequence $\pi ^*=(\;4\; 3\; 1\; 2)$ which $f(\pi ^*)=246$, knowing that we generating the entire neighborhood by total insertion, we obtain the best sequence $\pi ^*_p=(\;2\; 4\; 3\; 1)$ which $f(\pi ^*_p)=235$, we compare the objective function value of this sequence with the objective function value of the best current sequence. Finally, we get our new best sequence $\pi ^*=(\;2\; 4\; 3\; 1)$. We note that for a sequence of n jobs, we will have $(n-1)^2$ neighboring solutions representing the cardinal of $\varGamma ^{(1)}$.

• Procedure $Proced\_pert$ for $\hbox {ILS}_2$: The total permutation perturbation procedure is used in the second version of the iterative local search algorithm noted $\hbox {ILS}_2$. In this procedure, the total number of permutations without repetition between the different jobs is generated to obtain the set of neighboring solutions noted $\varGamma ^{(2)}$.

  Figure 3 shows an implementation example of the total permutation procedure $Proced\_pert$, here we give an example of 4 jobs, starting from the same best sequence $\pi ^*=(4\; 3 \;1\; 2)$ which $f(\pi ^*)=244$ as before and by generating the whole of the total permutation neighborhood, we obtain the best sequence $\pi ^*_p= (1\; 3 \;4\; 2)$, knowing that $f(\pi ^*_p)=230$. We compare the objective function value of this sequence with the best objective function value of the current sequence, that we find is lower. We obtain our new best sequence $\pi ^*= (1 \;3\; 4\; 2)$ during the exploration of this neighborhood. Finally, we note that for a sequence of n jobs, we will have $\frac{n\times (n-1)}{2}$ neighboring solutions representing the cardinal of $\varGamma ^{(2)}$.

Fig. 3

An example illustrating the total permutation procedure $Proced\_pert$

In this model, the acceptance criterion of the simulated annealing with the parameter $\mathcal{T}$ is also integrated, which depends on the nature and the characteristics of the problem. We give an expression inspired by the model in (Ruiz and Stützle 2007) expressed for several types of flow shop scheduling problems; this expression is given by the following relation

$$\begin{aligned} \mathcal{T}= \lambda \times \frac{\sum _{j=1}^{n}\sum _{l=1}^{m}(p_{jl}+s_{jjl})}{10\times m \times n} \end{aligned}$$

(31)

We use the parameters of the problem, especially the processing times, the setup times, the number of jobs and the number of machines. In addition, for a right calibration of our algorithm, the coefficient $\lambda$ is been varied adequately from 0.5 to 0.9.

3.4 Iterative greedy algorithm

The second proposed algorithm in our approach of resolution is the iterative greedy algorithm (Ying 2008; Pan and Ruiz 2014; Fernandez-Viagas et al. 2018), which we apply with its traditional version. The principle of this algorithm is based on two main phases, the exploration phase of the current neighborhood solution and the local search phase. The exploration phase of the current neighborhood solution is constructed of two sub-phases, the destruction and the construction of the neighboring solution. In the sub-phase of destruction a subset of job is extracted, in the second sub-phase each job of the extracted set is inserted in the different positions of the partial built solution, and we retain the best solution among all the generated solutions. In the local search phase, we use the same model presented in the local search iterative algorithm for setting the temperature parameter of the simulated annealing model. This metaheuristic is one of the most used in several scheduling problems. We apply it to solve our bi-objective problem whose parameters are adopted for our case study. We present in the Algorithm 3 the detailed steps of determination of the solution obtained by the iterative greedy algorithm.

The implementation of this metaheuristic requires two basic settings parameters, the parameter T and the parameter d. For the parameter T, we consider the same adopted model for the iterative local search algorithm which allows a good exploration of the neighborhood of the current solution. For the parameter d, which represents the number of jobs to be extracted in the destruction phase. We propose a simulation study by varying the number of jobs to be extracted in the destruction sub-phase by considering $d=m$ for small and medium instances whose number of jobs $n \in \{20,30,\ldots ,90\}$ and the number of machines $m \in \{5,10\}$, while for large size instances, we consider $n \in \{100, 150,\ldots ,400\}$ and the number of machines $m \in \{10,20\}$, we assume that $d \in \{10,20,\ldots ,50\}$.

In this case, for the chosen neighborhood system, we propose three types of neighborhoods

• The $N_1(\pi )$ random neighborhood permutation: A randomly chosen job swapping position with another randomly selected job in the current sequence to obtain a new job sequence.

• The $N_2(\pi )$ neighborhood by block inversion: A block of job is chosen in the current sequence and all the jobs of this block invert their positions to obtain the new sequence

• The $N_3(\pi )$ shift neighborhood with insertion: A job is selected at random from position p is inserted into a q position drawn randomly in the current sequence, all jobs p and q will be shifted to the left if $p<q$ or right otherwise.

One of the fundamental steps for metaheuristics is the initialization phase, a good starting solution that saves a lot of time in finding the right solution. Our approach first allows us to find an initial sequence using one of the proposed rules, then the second phase is to apply the NEH algorithm which will give the initial solution for our two metaheuristics of resolution which we compare in terms of quality of the founded solution and the speed of convergence to the good optimal solution.

3.5 Genetic algorithm

The metaheuristics based on the genetic algorithm is among the most implemented metaheuristics for scheduling optimization problems. Several versions are applied for mono objective or multi-objective optimization. The Algorithm 4 gives a description of the different stages of the genetic algorithm evolution.

Fig. 4

Crossover and mutation example

The main phases of this metaheuristics are, selection, crossing and mutation. In this algorithm we simulate the behavior of evolution of the genetic code in the human body to arrive at the proper code to each individual. In the Fig. 4, from an initial population, in the selection phase two parents $\hbox {P}_1$, $\hbox {P}_2$ are selected according to a previously defined procedure, subsequently in the crossing phase two children $\hbox {C}_1$, $\hbox {C}_2$ will be generated and each will take part of the code of both parents form its own genetic code. In the mutation phase, a procedure based on local search insertion methods is applied to new individuals. At the end an evaluation of all the individuals is carried out by the objective function and an update of the population is carried out, the process is repeated until satisfying the stopping criterion.

4 Effectiveness of resolution algorithms

4.1 Simulation instances

The most important step in the simulation study by computer tools is the comparative study between different solving approaches. We highlight in our approach a set of heuristics and metaheuristics for the resolution of the bi-objective SDST/BFSP scheduling problem. For this we study, a set of instances that we have classified into two size families, the family of small/medium size and the family of the large one. The classification is based on the number of jobs and the number of machines for each family. For small and medium instances that we consider, the number of machines $m\in \{2,\ldots ,10\}$ and the number of jobs $n \in \{10,\ldots ,90\}$; the processing times $p_{jl}$ are defined in [1, 49] and the setup times $s_{jkl}$ are defined in [1, 10]. For the family of the large size, the number of machines is $m\in \{10,\ldots ,20\}$ and the number of jobs $n\in \{100,150, \ldots ,400\}$; we consider that the processing times $p_{jl}$ belong to [50, 99] and the setup times $s_{jk1}$ belong to [10, 20]. We note that the setup times are much lower than the processing times by not exceeding $25\%$, which actually reflects industrial cases. The due dates for the two families of instances are expressed as function of $p_{jl}$ and $s_{jkl}$ defined by the expression

$$\begin{aligned} d_j= \delta \times \left[ \sum _{l=1}^{m}(p_{jl}+s_{jjl})(1+rand())\right] ,\;\;j=1,\ldots ,n \end{aligned}$$

(32)

where $\delta$ depends on the studied instance family, such that $\delta \in \{2,\ldots ,5\}$. The studied cases cover the maximum of industrial flow shop production types ranging from small size instances to larger ones. A comparative study between the different resolution heuristics and metaheuristics makes it possible to conclude the right approach that we can apply for our problem. This study concerns the two families of instances by varying the necessary parameters for each resolution algorithm. To evaluate their efficiency, we calculate the relative percentage increase (RPI) by the following formula

$$\begin{aligned} RPI= \left( \frac{f-f_{min}}{f_{min}}\right) \times 100 \end{aligned}$$

(33)

This type of analysis requires the evaluation of several instances, to be able to express a good judgment on the effectiveness of the resolution methods. A good calibration to measure the desired performances is necessary, one carries out a set of tests and for each test one retains the average of 10 instances for each test problem. A statistical study is essential tool in this kind of study to validate the correct approach of resolution among all the proposed approaches.

4.2 Comparative study between metaheuristics and MILP

We made a comparative study between the four metaheuristics improved by the NEH algorithm with the exact solution obtained by the MILP. The study is carried out for small instances by varying the weighting parameter $\mu$ for the two criteria of the objective function. We tested four instances, with eleven cases for each problem depending on the value of $\mu$, with total of 44 problems. In the Table 1, we give the results of the simulation of the study in terms of the objective function value.

Table 1 Objective function value of small instances

We can see that the $\hbox {ILS}_2$ algorithm records the best result with a success rate of $90.9\%$ compared to the other three algorithms. In addition, the ILS algorithm with these two versions dominates the other two algorithms. We note that the exact solution has been implemented under the software LINGO 17.3 and that the result is given for the average five instance tested. We limit ourselves to representing the results of a set of small instances including $n\in \{10,15\}$ and $m\in \{3,5\}$. We note that the simulation algorithms are implemented using the Matlab 2014a language and realized on PC with the Intel (R) Core (TM) $\hbox {i}3$ CPU, $\hbox {M}350$, $2.27\hbox {GHz}$, 2.26 GHz and a 6 GB RAM.

4.3 Comparison of heuristics

We present here the second analysis concerning the comparative study between the different heuristics based on the NEH algorithm and on the rules mentioned in the initialization phase. This study shows the difference recorded between the different rules in order to verify the findings retained in the carried out analysis by the metaheuristics. The analysis will be done by calculating the RPI term according to the variation of the weighting criteria coefficient $\mu$, while fixing the number of jobs and the number of machines for each studied problem. We present in Fig. 5 the results of the statistical study represented by the ANOVA diagram concerning the instance $30\times 10$ .We consider 10 replications for each instance by varying the coefficient such that $\mu \in \{0.2,0.3,0.7,0.8\}$, the analysis will be made on median value of RPI.

Fig. 5

Box plot of RPI variation for all used heuristics and for $\mu =0.2$ (top left), $\mu =0.3$ (top right), $\mu =0.7$ (bottom left) and for $\mu =0.8$ (bottom right)

From the four box diagrams of ANOVA, we find that for the case of $\mu =0.2$, the heuristic $\textit{NEH}\_R_6$ gives the best RPI value of $2.25\%$ followed by the heuristic $\textit{NEH}\_R_4$ with a value of $3.11\%$; while the highest value of RPI is $4.77\%$ recorded for $\textit{NEH}\_R_1$. In the case of $\mu =0.3$ the heuristic $\textit{NEH}\_R_6$ gives the best of RPI $2.53\%$ followed by $\textit{NEH}\_R_5$ with a value of RPI $3.25\%$, while the largest value is recorded by $\textit{NEH}\_R_2$. For the two previous cases when privileging the criterion of the total tardiness the heuristic $\textit{NEH}\_R_6$ gives good results compared to other heuristics.

In the case of $\mu =0.7$ the heuristic $NEH\_R_4$ gives the best RPI value of $2.05\%$ followed by the heuristic $\textit{NEH}\_R_1$ with a value of $2.12\%$; while the highest value of RPI is $3.15\%$ recorded for $\textit{NEH}\_R_5$. In the case of $\mu =0.8$ the heuristic $\textit{NEH}\_R_4$ gives the best of RPI $2.95\%$ followed by $\textit{NEH}\_R_1$ with a value of RPI $3.25\%$, while the largest value is recorded by $\textit{NEH}\_R_6$ with a value of $4.05\%$. For the last two treated cases, when privileging the criterion of makespan, the heuristic $\textit{NEH}\_R_4$ give the good results compared to other heuristics.

4.4 Comparison of the suggested metaheuristics

The third analysis concerns the convergence of the proposed metaheuristics in terms of the quality of the solution and the search computation time. A determining factor in the notion of convergence is the CPU running time. We consider the time limit $\tau =\rho \times n \times m$ in seconds where n and m respectively denote the number of jobs and the number of machines characterizing the size of the problem. The coefficient $\rho$ is a correction coefficient that makes it possible to calibrate the implemented algorithm for the resolution of our problem. We consider in the Table 2, the appropriate values of $\rho$ corresponding to the size of the studied problem.

Table 2 Values of the calibration parameter $\rho$ for different instances

We note that these conditions on $\rho$ make it possible to limit the computation time by supposing that the search for good solutions beyond this time becomes heavy and that our algorithms converge towards their good solutions when this time is reached.

Table 3 RPI value of relatively medium instances. Best values are in bold

Table 4 RPI value of relatively large instances. Best values are in bold

To verify the effectiveness of the resolution metaheuristics, we propose a comparative study between the four algorithms of resolutions. The simulation concerns the two problem types according to the size of each category. The algorithms are tested by respecting a convergence time limit according to the size of the instance. We give the results of the value of RPI for an average of ten instances for each type of problem. In the Table 3, we represent the results of the relatively medium instances, we consider that $n\in \{20,30,\ldots ,60\}$ and $m\in \{5,10\}$. From the results, we can see that the algorithm $\hbox {ILS}_2$ is the best algorithm by the four implemented, it records a success rate of $87.5\%$.

In the same way, we continue our analysis and our interpretation of the results concerning relatively large instances. For this category of problems, we study the case of $n\in \{100,200,\ldots ,400\}$ and $m\in \{10,20\}$. We note that this type of instance is often the subject of production batches in flow shop workshops. Such a study is very useful for giving manufacturing managers a best decision-making tool in the efficient management of their machines. The results stored in Table 4 also show the dominance of the $\hbox {ILS}_2$ algorithm with a success rate of $88.63\%$.

The speed of convergence of the algorithms towards their good solutions is of fundamental utility in the analysis of the efficiency of the metaheuristiues. In Fig. 6, we represent the evolution of the objective function value for the four algorithms IG, $\hbox {ILS}_1$, $\hbox {ILS}_2$, and GA as function of the CPU time. In this illustration, we simulate the analysis of the instance $50\times 10$ considered as a relatively medium instance. The plot of the convergence curves is given for a calculation time limit $\tau =250$ s and $\mu \in \{0.2,0.3,0.7,0.8\}$. We choose the four values of $\mu$ in such a way as to favor one of the two criteria, ie the total tardiness with $\mu \in \{0.2,0.3\}$ or the makespan $C_{max}$ with $\mu \in \{0.7,0.8\}$. We note that the $\hbox {ILS}_2$ algorithm converges quickly towards its good solution and remains more efficient compared to other algorithms in the four studied cases.

Fig. 6

Objective function value CPU time for $\mu =0.2$ (top left), $\mu =0.3$ (top right), $\mu =0.7$ (bottom left) and $\mu =0.8$ (bottom right)

We note that the plots of the objective function value are given for the four weighting coefficient values corresponding to the two criteria. We limit ourselves to these cases of simulations that we consider largely sufficient to concertize the comparative study of the convergence of the algorithms.

In this analysis, we also highlight the comparison of the approaches proposed in the single-criteria case. Indeed, when $\mu =0$ the problem studied will be equivalent to $F_m |prmu,SDST,blocking|\sum _{j=1}^{n}{T_j}$, in case $\mu =1$ problem is equivalent to $F_m| prmu,SDST,blocking|C_ {max}$. We notice that the for small instances, the optimal solution given by the MILP for the TT minimization case does not imply a good solution for $C_ {max}$ and vice versa. Similarly, when simulating the relatively large and medium sized instances, this property remains valid. We have recorded the clear dominance of the $\hbox {ILS}_2$ algorithm in the two extreme cases of single-criteria optimization. Despite the intrinsic link between the two criteria in their expressions, a good TT solution does not imply a good $C_{max}$ solution and vice versa. In final observation, we find it is difficult to find a solution that minimizes both criteria at once, a compromise is necessary to favor one of the two criteria using the weighting coefficient. In this vision, the production managers can consider the weighted multi-criteria optimization factor as a powerful tool to find a good compromise to their customers requirements.

5 Conclusion

In this paper, we have presented a mixed integer linear programming method and a set of metaheuristics to solve flow shop scheduling problem with permutation under constraints of blocking and sequence dependent setup time. The suggested problem consists in minimizing an objective functional by a combination of the two criteria: the makespan and the total tardiness each having a weighting coefficient. A comparative study between the various resolution methods is carried out on a set of instances covering small, average and relatively big size instances. To this end, we have varied the number of jobs and the number of machines; also the weighting parameter of our problem has been changed adequately in order to favor one criterion over another. We found in our simulation that the best initial solutions are given by heuristics based on NEH procedure. At the algorithm performance level, we found that the iterative local search algorithm in its second version gives better results compared to the other three algorithms in terms of the quality of the solution and the speed of convergence. Finally, it was established that the value of the objective function is strongly affected by varying the bi-criteria weighting parameter. In addition, we conclude that it is difficult to find a good solution that minimizes both criteria at the same time. Hence, a compromise will be necessary to favor one of the two optimization criteria using the weighting coefficient. In this paper, we have studied a bi-criteria optimization scheduling problem. It well be interesting to extend the work to three or more criteria in the objective function. Also, adding another constraint like the unavailability of the machines remains of a potential interest.