Multi-objective scheduling on two dedicated processors

TL;DR

This paper addresses a complex multi-objective scheduling problem on two dedicated processors by adapting genetic algorithms, proposing three methods, and evaluating their effectiveness with new bounds and quality metrics.

Contribution

It introduces three genetic algorithm-based methods for multi-objective scheduling on two processors, with adapted bounds and metrics for evaluating solution quality.

Findings

The proposed algorithms are effective in solving the problem.

The adapted bounds help evaluate and compare algorithm performance.

NSGA-II performs well in generating high-quality Pareto fronts.

Abstract

We study a multi-objective scheduling problem on two dedicated processors. The aim is to minimize simultaneously the makespan, the total tardiness and the total completion time. This NP-hard problem requires the use of well-adapted methods. For this, we adapted genetic algorithms to multi-objective case. Three methods are presented to solve this problem. The first is aggregative, the second is Pareto and the third is non-dominated sorting genetic algorithm II (NSGA-II). We proposed some adapted lower bounds for each criterion to evaluate the quality of the found results on a large set of instances. Indeed, these bounds also make it possible to determine the dominance of one algorithm over another based on the different results found by each of them. We used two metrics to measure the quality of the Pareto front: the hypervolume indicator (HV) and the number of solutions in the optimal front (ND). The obtained results show the effectiveness of the proposed algorithms.

Equations

$$x_{l,k}=\left\{\begin{array}[]{l l}1&\quad\text{if job $l$ completes before job $k$ starts}\\ 0&\quad\text{else;}\\ \end{array}\right.$$

$$\text{Minimize }\{C_{max},\sum T_j,\sum C_j\}$$

$$C_k\ge C_l+p_k+(x_{l,k}-1).M\forall (l,k)\in (P_1\cup P_{1,2}{)}^2\text{ with }l\ne k$$

$$x_{l,k}+x_{k,l}=1\forall (l,k)\in (P_1\cup P_{1,2}{)}^2\text{ with }l\ne k$$

$$C_k\ge C_l+p_k+(x_{l,k}-1).M\forall (l,k)\in (P_2\cup P_{1,2}{)}^2\text{ with }l\ne k$$

$$x_{l,k}+x_{k,l}=1\forall (l,k)\in (P_2\cup P_{1,2}{)}^2\text{ with }l\ne k$$

$$C_{max}\ge C_j\forall j\in (P_1\cup P_2\cup P_{1,2})$$

$$T_j\ge C_j-d_j\forall j\in (P_1\cup P_2\cup P_{1,2})$$

$$T_j\ge 0\forall j\in (P_1\cup P_2\cup P_{1,2})$$

$$C_j\ge r_j+p_j\forall j\in (P_1\cup P_2\cup P_{1,2})$$

$$x_{k,l}\in \{0,1\}\forall k\ne l\forall (k,l)\in ((P_1\cup P_{1,2}{)}^2\cup (P_2\cup P_{1,2}{)}^2)$$

$$Lb1=min\sum x_{i,j}Cos{t}_{i,j}$$

$$\left\{\begin{array}[]{r c l}$$

\sum_{i}x_{i,j}=1\sum_{j}x_{i,j}=1x_{i,j}\in\left\{0,1\right\}

$$\end{array}\right.$$

$$R(h)=\left\{a\in C/a=(a_1,a_2,..,a_K),0\le a_i\le h_i,\forall 1\le i\le K\right\}$$

$$\underset{h\in C}{\mathrm{Sup}}|\frac{X(h)}{X}-\prod _{i=1}^K{h}_i|$$

$$w_i^r=\frac{U_{r,i}}{U_{r,1}+U_{r,2}+..+U_{r,K}},\forall 1\le r\le X,\forall 1\le i\le K$$

$$H\left(s\right)=w_1^r\ast C(s)+w_2^r\ast TT(s)+w_3^r\ast TC(s)$$

$$C(s)=\left(\frac{C_{max}\left(s\right)-\underset{x\in P}{\min }\left\{C_{max}\left(x\right)\right\}}{\underset{x\in P}{\max }\left\{C_{max}\left(x\right)\right\}-\underset{x\in P}{\min }\left\{C_{max}\left(x\right)\right\}}\right)$$

$$TT(s)=\left(\frac{T\left(s\right)-\underset{x\in P}{\min }\left\{T\left(x\right)\right\}}{\underset{x\in P}{\max }\left\{T\left(x\right)\right\}-\underset{x\in P}{\min }\left\{T\left(x\right)\right\}}\right)$$

$$TC(s)=\left(\frac{C_{time}\left(s\right)-\underset{x\in P}{\min }\left\{C_{time}\left(x\right)\right\}}{\underset{x\in P}{\max }\left\{C_{time}\left(x\right)\right\}-\underset{x\in P}{\min }\left\{C_{time}\left(x\right)\right\}}\right)$$

$$\left\{\begin{array}[]{l l l}fitness_{1}=\frac{2}{9}*C(s)+&\frac{4}{9}*TT(s)+&\frac{3}{9}*TC(s)\\ fitness_{2}=\frac{3}{15}*C(s)+&\frac{7}{15}*TT(s)+&\frac{5}{15}*TC(s)\\ fitness_{3}=\frac{4}{14}*C(s)+&\frac{3}{14}*TT(s)+&\frac{7}{14}*TC(s)\\ fitness_{4}=\frac{5}{13}*C(s)+&\frac{6}{13}*TT(s)+&\frac{2}{13}*TC(s)\\ fitness_{5}=\frac{6}{12}*C(s)+&\frac{2}{12}*TT(s)+&\frac{4}{12}*TC(s)\\ fitness_{6}=\frac{7}{18}*C(s)+&\frac{5}{18}*TT(s)+&\frac{6}{18}*TC(s)\\ fitness_{7}=\frac{1}{3}*C(s)+&\frac{1}{3}*TT(s)+&\frac{1}{3}*TC(s)\\ \end{array}\right.$$

$$H{V}_r=\left(1-\frac{H{V}_{LB}-H{V}_{Algorithm}}{H{V}_{LB}}\right)$$

Full text

K****eywords scheduling  $\cdot$ tasks $\cdot$ dedicated processors $\cdot$ total tardiness $\cdot$ makespan $\cdot$ completion time $\cdot$ lower bound $\cdot$ NSGA-II $\cdot$ Pareto front.

1 Introduction

This work aims at optimizing the computer control systems when these systems have two dedicated processors: the assignment of tasks to these processors is fixed. For this problem, we have three types of tasks. Some tasks must be processed only by the first processor, others by the second processor, and the remaining tasks need simultaneously both processors. This problem represents a practical issue in computer control systems, where a task is performed in several copies on different processors in order to ensure better safety of the system. In production management, we can cite the case where a task requires several operators for its execution.

The contribution of our work is to propose lower bounds for the three studied criteria (makespan, total tardiness and total completion time) and to develop genetic algorithms to solve this problem in the multi-objective case. The lower bounds allow us to assess the quality of the feasible solutions and the genetic algorithms incorporates the optimization part. We implemented our approach by considering aggregative, NSGA-II and Pareto scenarios on a large set of instances. The results show the effectiveness of the implemented algorithms. The studied problem is $P2|fix_{j},r_{j}|C_{max},\sum T_{j},\sum C_{j}$ according the standard ternary notation, where $P2$ denotes two processors; $fix_{j}$ indicates that each task has one or two dedicated processors and the assignment of each task is fixed; $r_{j}$ denotes the release date; $C_{max}$, $\sum T_{j}$ and $\sum C_{j}$ indicates the makespan, the total tardiness and the total completion time respectively.

The next section is a review of existing research related to the studied problem. In Section 3, a mathematical formulation model is proposed, some notations are detailed and the proposed lower bounds for the makespan, total completion time and total tardiness are given. In Section 4, we present the solving approaches. Three methods to solve the considered problem are developed. The first one is aggregative with Uniform Design, the second is Pareto and the third is the NSGA-II. Section 5 deals with the generation of instances, the proposed metrics to measure the quality of the Pareto front, the computational results and the qualitative and quantitative analysis. Finally concluding remarks are given in Section 6.

2 Literature Review

Few studies have dealt with this problem. The most important studies are mentioned in the following paragraphs.

Coffman et al. [11] studied the file transfer problem in the field of computer networks where each computer has a number of different ports for data exchange. File transfer uses a subset of ports, therefore a multiprocessor task on dedicated processors. The boot time of the transfers is also taken into account, then different transfer protocols are proposed, and performance results are demonstrated. Drozdowski [14] cited this paper to describe the actual applications of scheduling problems on dedicated processors.

Craig et al. [12] studied the problem in testing integrated circuits VLSI (very large-scale integration). To test a component of these circuits, several other electronic components are needed simultaneously. The authors addressed the problems in case when the processing times are unitary or arbitrary. A heuristic based on the maximum degree of incompatibility has been proposed to solve these two problems $P|fix_{j},p_{j}=1|C_{max}$ and $P|fix_{j}|C_{max}$ ($p_{j}$ denotes the processing time of task $j$).

These works (Coffman et al. [11] ; Craig et al. [12]), which cover several fields of application, made it possible to form the first theoretical basis for scheduling problems on dedicated processors. This topic has been widely investigated during the past years. The most remarkable work has been devoted to the study of the complexity.

Hoogeveen et al. [18] showed that the problem $P2|fix_{j}|\sum w_{j}C_{j}$ is NP-hard in the strong sense ($w_{j}$ the weight and $C_{j}$ the completion time of task $j$). The preemption of tasks does not make the problem easier. Oguz and Ercan [39] proved that the problem $P2|fix_{j},pmtn|\sum w_{j}C_{j}$ is NP-hard in the strong sense ($pmtn$ allows us the preemption of tasks). Afrati et al. [1] proposed a polynomial time approximation scheme (PTAS) for the problem $Pm|fix_{j},pmtn|\sum C_{j}$ and a second PTAS approximation scheme proposed by Afrati and Milis [2].

Chu [10] proposed a lower bound for the minimization of total tardiness problem; the calculation involves the SRPT priority rule (Shortest Remaining processing Time) for a relaxed problem with preemption. The main idea is that each time the processor becomes available, an unfinished task available with the shortest remaining processing time is set. The execution of a task is interrupted when its remaining processing time is strictly greater than the length of processing task that becomes available.

Leung and Wang [32] proposed a genetic algorithm with multiple fitness functions to conduct research in order to solve a multi-objective problem. The authors applied an experimental design method called Uniform Design to select the weights used with the objective functions and diversify uniformly selected solutions.

Kacem [22] developed two lower bounds for tardiness minimization problem on a single machine with Family Setup Times. The first lower bound is based on Emmons theorem [15] and the SPT rule (Shortest Processing Time), the second is achieved by sorting tasks by processing times and the idea of due dates exchange. Another idea of solving the linear programming problem, was also proposed.

Berrichi et al. [6] studied a bi-objective model of parallel machine problem using reliability models to take into account the service side. Two genetic algorithms were developed to obtain an approximation of the Pareto front: One algorithm that uses the two objectives weighted and NSGA-II algorithm.

Rebai et al. [37] introduced three lower bounds for minimization tardiness problem on one machine to schedule preventive maintenance tasks. The first lower bound is based on the Lagrangian relaxation of mathematical model. The second is obtained by the sum of M costs calculated for M tasks, and the third is an adaptation of the lower bound given by Li[30] for the problem of earliness tardiness minimization with a single due date for each task.

Manaa and Chu [33] proposed a branch-and-bound method to minimize the makespan. In their article, the authors presented a lower bound that has been proven. This method can treat all instances generated up to 30 tasks for the most difficult cases in less than 15 minutes.

Vallada and Ruiz [41] studied the unrelated parallel machine scheduling problem. A genetic algorithm is developed to solve this problem. The proposed method includes a fast local search and a local search enhanced crossover operator. The computational and statistical analysis shows an excellent performance in a comprehensive benchmark set of instances.

Bradstreet [9] introduced the hypervolume indicator (HV) to measure the quality of the Pareto front. The hypervolume is one of the most famous indicator that can reflect the dominance of Pareto fronts.

Alhadi et al. [5] proposed an approximation algorithms to minimize the maximum lateness and makespan on parallel machines. In this paper, the authors presented polynomial time approximation schemes to generate an approximate Pareto Frontier.

Kacem and Dammak [26] studied the problem of bi-objective scheduling of multi-processor tasks on two dedicated processors. The authors adapted the genetic algorithm to solve the problem of minimizing the makespan and the total tardiness for the large size instances. The results found showed the effectiveness of the proposed genetic algorithms and the encouraging quality of the lower bounds constructed in (Manaa and Chu [33]; Kacem and Dammak [24]). For that, we decided to study a new extension of this problem by introducing the total completion time criterion. According the standard ternary notation, the studied problem is $P2|fix_{j},r_{j}|C_{max},\sum T_{j},\sum C_{j}$.

3 Problem statement

In this section, we detail some notations, we propose a mathematical model for our studied problem and we give a lower bounds for the makespan, total completion time and total tardiness criteria.

3.1 Notation

The following fields denote:

• •

$P2$: Two processors.

• •

$fix_{j}$: Each task has one or two dedicated processors and the assignment of each task is fixed.

• •

$r_{j}$: Release date of task $j$.

• •

$C_{max}$: Makespan.

• •

$d_{j}$: Due date of task $j$.

• •

$T_{j}$: Tardiness of task $j$; $T_{j}=max\left\{C_{j}-d_{j};0\right\}$with $C_{j}$ the completion time of task $j$.

• •

$p_{j}$: Processing time of task $j$.

3.2 Mathematical model

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

[TABLE]

$P_{1}$ is a set of jobs requiring the first processor.

$P_{2}$ is a set of jobs requiring the second processor.

$P_{1,2}$ is a set of jobs requiring both processors simultaneously.

$M$ is a constant penalty.

[TABLE]

Subject to:

[TABLE]

[TABLE]

[TABLE]

[TABLE]

[TABLE]

[TABLE]

[TABLE]

[TABLE]

[TABLE]

Equation (1) expresses the three criteria: the makespan, the total tardiness and the total completion time. In the constraints (2) and (4), for each job $k$ sequenced after job $l$ completes, the completion time of job $k$ is greater than or equal to the completion time of job $l$ plus the processing time of job $k$. The constraints (3) and (5) make it possible two jobs to complete one before the second job starts. The constraint (6) ensures that the makespan is greater than or equal to the completion time for each job $j$. The constraints (7)-(9) compute the tardiness. The completion time of job $j$ is greater than or equal to the release date plus the processing time of job $j$. The constraint (10) defines the domain of definition of the parameters of the model.

We study three scheduling problems (makespan, total tardiness and total completion time) on two dedicated processors. To assess the quality of the results found by such a method, we use the following lower bounds.

3.3 Lower bound $LBC$ for problem $P2|fix_{j},r_{j}|C_{max}$

Manaa and Chu [33] proposed two ideas to construct a lower bound for the considered problem:

• •

The idea of dividing the problem into two sub-problems on one processor by relaxing the studied problem.

• •

The idea of Bianco et al. [7] an optimal solution to minimize the makespan for one-processor problem.

The relaxation of the studied problem allows us to obtain two simple problems:

a) Scheduling tasks that necessitate using simultaneously both processors and tasks that require the first processor.

b) Scheduling tasks that require employing simultaneously both processors and tasks that necessitate the second processor.

The optimal solutions of problems (a) and (b) can be found by scheduling tasks according to the order of their release dates.

The lower bound for the studied problem corresponds to the maximum value of the solutions of problems (a) and (b).

3.4 Lower bound $LBTC$ for problem $P2|fix_{j},r_{j}|\sum C_{j}$

In this study, we use and combine three ideas to build a lower bound:

• •

The idea of reducing the problem into two sub-problems on one processor by partitioning the bi-processor tasks.

• •

The idea of dividing the mono- processor tasks into two tasks.

• •

The idea of under-estimating the completion times of the tasks on a single processor (originally proposed by Chu [10]).

The first of this lower bound is to partition the bi- processor tasks into two mono-processor tasks, each of them on one of the processors. We get two independent problems on each processor.

On the first processor$P_{1}$, we consider the $n_{1}$ mono-processor tasks $j_{j}$ with a weight $w_{j}^{1}=1$, and the $n_{12}$ bi- processor sub-tasks $j_{j}$ on processor $P_{1}$ a weight $w_{j}^{1}=w$, with $w\in\left[0,1\right]$.

Similarly, we consider the second processor $P_{2}$ , the $n_{2}$ mono-processor tasks $j_{j}$ with a weight $w_{j}^{2}=1$. However, the bi-processor sub-tasks $j_{j}$ on processor $P_{2}$ a weight $w_{j}^{2}=1-w$. Thus, we obtain a problem on each processor: $P_{1}|fix_{j},r_{j}|\sum w_{j}^{1}C_{j}$ and $P_{2}|fix_{j},r_{j}|\sum w_{j}^{2}C_{j}$.

We consider $w=\frac{1}{2}$. The next step is to divide the mono-processor tasks (with a weight $w_{j}^{1}=1$) in two tasks. We get for each divided task two sub tasks $j_{j1}$ and $j_{j2}$ with release date $r_{j1}=r_{j}$ ; $r_{j2}=r_{j}+\frac{p_{j}}{2}$ and processing time $p_{j1}=p_{j2}=\frac{p_{j}}{2}$.

We divide the weight on for each sub tasks. We are getting $w_{j}^{1}=\frac{1}{2}$ if $\forall j_{j}\in\left\{P_{1};P_{12}\right\}$. From where,

$Lb1=Lb\left(P_{1}|fix_{j},r_{j}|\sum w_{j}^{1}C_{j}\right)=Lb\left(P_{1}|fix_{j},r_{j}|\sum\frac{1}{2}C_{j}\right)+\sum_{\\ j\in P_{1}}{\frac{p_{j}}{4}}$, with $\sum_{\\ j\in P_{1}}{\frac{p_{j}}{4}}$ is a penalty to be added according to Webster formula.

$Lb1=Lb\left(P_{1}|fix_{j},r_{j}|\sum\frac{1}{2}C_{j}\right)+\sum_{\\ j\in P_{1}}{\frac{p_{j}}{4}}=\frac{1}{2}Lb\left(P_{1}|fix_{j},r_{j}|\sum C_{j}\right)+\sum_{\\ j\in P_{1}}{\frac{p_{j}}{4}}$.

We apply the same principle for the problem $P_{2}|fix_{j},r_{j}|\sum w_{j}^{2}C_{j}$. We are getting $Lb2=Lb\left(P_{2}|fix_{j},r_{j}|\sum\frac{1}{2}C_{j}\right)+\sum_{\\ j\in P_{2}}{\frac{p_{j}}{4}}=\frac{1}{2}Lb\left(P_{2}|fix_{j},r_{j}|\sum C_{j}\right)+\sum_{\\ j\in P_{2}}{\frac{p_{j}}{4}}$.

$LBTC=Lb1+Lb2$ is then a lower bound for problem $P2|fix_{j},r_{j}|\sum C_{j}$. The calculation of the lower bounds of completion times for the problem on each processor uses the following theorem for $1|r_{j},pre|\sum C_{j}$.

Theorem 1

*(Chu [10])

Let $C_{\left[i\right]}\left(\sigma\right)$ be the completion time of the task in the $i^{th}$ position of a feasible schedule . $C^{\prime}_{i}$ is the completion time of the task in the $i^{th}$ position of a feasible schedule constructed by the SRPT (Shortest Remaining Processing Time) priority rule. Chu proved that for every feasible schedule $\sigma$, we have: $C_{\left[i\right]}\left(\sigma\right)\geq C^{\prime}_{i}$*

By applying the theorem (Chu [10]), we compute a lower bound on the completion time of each job.

Example : Let us consider the instance in Table 1.

We apply the principle of calculation of the lower bound mentioned above and we get two sub-problems on each processor. On the first processor $P_{1}$, we schedule the tasks $\left\{j_{1},j_{2},j_{3},j_{4}\right\}$. We divide the tasks $\left\{j_{1},j_{2},j_{4}\right\}$ on into two, we get the following tasks: $\left\{j_{11},j_{12},j_{21},j_{22},j_{41},j_{42}\right\}$with the following parameters described in Table 2.

The sequence built by the SRPT rule with preemption gives the solution described in Figure 1.

The total of completion time, giving the following lower bound:

$Lb1=\frac{1}{2}Lb\left(P_{1}|fix_{j},r_{j}|\sum C_{j}\right)+\sum_{\\ j\in P_{1}}{\frac{p_{j}}{4}}=\frac{3+5+6+8+11+14+18}{2}+\frac{3+3+1+1+4+4}{4}=36,5$. Respectively, we calculate the lower bound $Lb2$ for the problem $P_{2}|fix_{j},r_{j}|\sum C_{j}$. Thus, we consider $LBTC=Lb1+Lb2$ as a lower bound for the problem $P2|fix_{j},r_{j}|\sum C_{j}$.

.

3.5 Lower bound $LBTT$ for the problem $P2|fix_{j},r_{j}|\sum T_{j}$

Kacem and Dammak [24] proposed an adapted lower bound for the problem of minimization of total tardiness on two dedicated processors. The authors exploited and combined three ideas to construct this lower bound:

• •

The idea of reducing the problem in two sub-problems on one processor by partitioning the bi-processor tasks.

• •

The idea of under-estimating the completion time of the tasks (initially suggested by Chu [10]).

• •

The idea of calculating the lower bound by assigning the due dates to the reduced completion times (originally proposed in Rebai et al. [37] for another scheduling problem).

The first step of this lower bound is to divide the bi-processor tasks into two mono-processor tasks; each of which is executed on one of the two processors. Consequently, we obtain two independent problems on each processor. On the first processor $P_{1}$, we consider the $n_{1}$ mono-processor tasks $J_{j}$ with a weight $\lambda_{j}^{1}=1$, and the $n_{12}$ bi-processor sub-tasks $J_{j}$ on processor $P_{1}$ having a weight $\lambda_{j}^{1}=\lambda$ with $\lambda\in\left[0,1\right]$.

Similarly, we consider, on the second processor $P_{2}$, the $n_{2}$ mono-processor tasks $J_{j}$ with a weight $\lambda_{j}^{2}=1$ . However, the $n_{12}$ bi-processor sub-tasks $J_{j}$ on the processor $P_{2}$ have a weight $\lambda_{j}^{2}=1-\lambda$. Thus, we obtain a problem on each processor $P_{1}|fix_{j},r_{j}|\sum\lambda_{j}^{1}T_{j}$ and $P_{2}|fix_{j},r_{j}|\sum\lambda_{j}^{2}T_{j}$.

Using the idea of Chu (described in the previous section), we compute a lower bound on the completion time of each task.

The next step of computing the lower bound is based on the idea of assigning the weight and the due date of each task to completion times’ lower bounds. The total tardiness is minimized by the Hungarian algorithm.

Let $Cost_{i,j}$ be the cost of assigning a reduced $C^{\prime}_{i}$ to the task $J_{j}$ supposed to end at the $i^{th}$ position of the schedule. This cost can be calculated according to the following formula: $Cost_{i,j}=\lambda_{j}*max\left\{C^{\prime}_{i}-d_{j};0\right\}$.

This assignment technique, presented by Rebai et al. [37], allows us to elaborate a new lower bound. We apply the Hungarian algorithm to determine, from the assignment matrix $Cost_{i,j}^{P_{1}}$, a lower bound ($Lb1$) to solve the following problem $P_{1}|fix_{j},r_{j}|\sum\lambda_{j}^{1}T_{j}$.

[TABLE]

[TABLE]

Applying the same process, we calculate $Lb2$ for the $P_{2}|fix_{j},r_{j}|\sum\lambda_{j}^{2}T_{j}$ problem. Thus, we consider $LBTT=Lb1+Lb2$ as a lower bound for the problem $P2|fix_{j},r_{j}|\sum T_{j}$.

Optimization of the lower bound $LBTT$

To improve the constructed lower bound, we look for the weights $\lambda_{j}^{*}$, which maximize $LBTT$. The idea is to associate the better weight $\lambda_{j}^{*}$ for each bi-processor task $J_{j}$ which maximizes the tardiness calculated by the Hungarian algorithm. We use the following method to optimize the bound $LBTT$.

• •

For a bi-processor task $J_{j}\in(P_{1,2})$, we calculate the gap $e_{j}*$ between $T_{j^{*}}^{P_{1}}$ and $T_{j^{*}}^{P_{2}}$ (where $T_{j^{*}}^{P_{1}}$ (respectively $T_{j^{*}}^{P_{2}}$) is the tardiness of task $j$ associated to the sub-problem on $P_{1}$ (respectively $P_{2}$) obtained by the Hungarian algorithm).

• •

According to the gap, $e_{j}*$, we increase the $\lambda$ value for a negative gap (and we reduce it respectively for a positive gap).

• •

We apply the Hungarian algorithm to the new matrix and we calculate a new lower bound $LBTT^{\lambda}$.

• •

We repeat this procedure $\forall J_{j}\in(P_{1,2})$.

Next, we present the study of the problem $P_{2}|fix_{j},r_{j}|C_{max},\sum C_{j},\sum T_{j}$.

4 Solving approaches

We adapt a genetic algorithm to the multi-objective case. We propose three methods to solve the considered problem. The first is aggregative, second is Pareto and the third is the NSGA-II.

4.1 The genetic algorithm

To represent the data of the studied problem, we used a standard coding technique. This coding consists in representing an individual with a permutation containing $N$ distinct numbers that correspond to the set $\left\{1,2,3,..,N\right\}$.

To form the diversified initial population, we used a random method to create a feasible sequence and to generate the other individuals of the initial population.

To assess the quality of individuals in a population, we have presented three methods to evaluate the studied problem in a given sequence.

The literature has several selection techniques such as proportional selection by tournament, by rank, random selection, etc (see Karasakal and Silav [27]). For our algorithm, we implemented three selection approaches: the aggregative approach, the Pareto one and NSGA-II.

The process of crossover between two parents leads to the birth of two children. In this case, an exchange position is randomly determined(see Vallada and Ruiz [41]). The first part of the first child is directly obtained from the first parent. The second part is provided by respecting the order of the remaining tasks as they appear in the second parent tasks. The same process is applied to the second child by reversing the parents. For our algorithm, we implemented the one-point crossover, which is a folklore (see Holland [21]).

Several methods of mutation exist in the literature such as the method of permutation, insertion and inversion. In our case, we used the permutation method of swapping two positions of the individual.

4.2 Aggregative approach

To adapt our genetic algorithm to the multi-objective case, we constructed an aggregative selection method that consists in generating weights for each sequence of a given population. To calculate the weights, we used an experimental design method called Uniform Design (Leung and Wang [32]). We choose a new population by a scaling method, which consists in calculating the weighted sum of normalized objective functions. Several combinations of weight are considered for the three objective functions (makespan, total tardiness and completion time). Each combination of these weights transforms the problem into a mono-objective case. Accordingly, the search directions are uniformly dispersed to the Pareto front in the objective space. With multiple fitness functions, we design a selection scheme to maintain the quality and the diversity of the population. This selection scheme consists in applying at every iteration the fitness functions (See Equation 19) and to sort the individuals of the current population in increasing order according to the Scaling method (See Section 4.2.2). The best individuals are selected to form a new population.

In what follows, we will describe the Uniform Design method used for calculating the weight and we will give the formula for the scaling method for the selection of a new population.

4.2.1 Calculation of weight with Uniform Design

The main objective of the Uniform Design is to sample a small set of points from a given set of points, so that the selected points are uniformly dispersed. This method is a branch of statistics that has been used to calculate the weight. As an illustration of the Uniform Design method, the reader could consult Leung and Wang [32].

We consider a unit hyper-cube $C$ in a $K$ dimensions space ($K$ is the number of objectives) and $h$ a point in $C$, Where $h=(h_{1},h_{2},..,h_{K})^{T}$, such that $0\leq h_{i}\leq 1$ $\forall 1\leq i\leq K$.

For any item $h$ from the hyper-cube $C$, we can create a hyper-rectangle $R(h)$ between the center $O$ and $h$, with $O=(0,0,..,0)^{T}$. This hyper-rectangle is described by the following formula:

[TABLE]

We consider a set of $X$ points from $C$, We can associate with each point $h$, a subset of $X$ points that belongs to the hyper-rectangle $R(h)$. Let $X(h)$ be the cardinality of such a sub set and $X(h)/X$ the fraction of the points included in the hyper-cube $C$ and $\prod_{i=1}^{K}h_{i}$ is the fraction of volume value of the hyper-rectangle $R(h)$. The uniform design is to determine $X$ points in $C$ such that the following discrepancy is minimized.

[TABLE]

The authors presented the $X$ points solution calculated using the uniform matrix $U(K,X)\left\{U_{r,i}\right\}_{X*K}$ given by Fang and Li [16]. With $U_{r,i}=(r.\sigma^{i-1}modX)+1$ and $\sigma$ is a parameter that depends on $X$ and $K$.

Now, we consider our problem studied, which consists in optimizing three objectives. In our case, we have $K=3$, we take $X=7$, so $\sigma=3$ (see Leung and Wang [32]). Using the formula $U_{r,i}$ given by Fang and Li[16], we get the following uniform matrix:

U(3,7)\left\{U_{r,i}\right\}_{X*K}=\left(\begin{array}[]{ c c c}2&4&3\\ 3&7&5\\ 4&3&7\\ 5&6&2\\ 6&2&4\\ 7&5&6\\ 1&1&1\\ \end{array}\right)

We consider the weighting vector $W^{r}=(w_{1}^{r},w_{2}^{r},..,w_{K}^{r})^{T}$. The components of this vector are calculated by the following formula:

[TABLE]

4.2.2 Scaling method

We use the weight components vector calculated by using the Uniform Design to build a scaling method that allows us to choose a new population by sorting individuals of the current population in ascending order according to the following formula:

[TABLE]

Such that,

[TABLE]

[TABLE]

[TABLE]

where $w_{i}^{r}$ are the vector components of the weight described in the above section, $s$ is a feasible solution from population $P$ and $C_{max}(x)$, $T(x)$, $C_{time}(x)$, are respectively the makespan, the total tardiness and total completion time of a solution $x\in P$.

By exploiting the uniform matrix, we obtain seven evaluation functions (fitness). The list of functions is given by the following formula:

[TABLE]

Each combination of these weights transforms the problem into a mono-objective case. For each combination, the genetic algorithm is applied simultaneously, the best feasible solutions are selected to form a new population by sorting the individuals of the current population in increasing order of the weighted objective and the population is stored. At the end of this process, such populations are merged and only the non-dominated solutions are kept.

4.3 Pareto approach

We adapt classical genetic algorithm for multi-objective case using the Pareto approach Pareto [36]. For each generation, we transform the population $P$ by crossing the non-dominated solutions and mutating the dominated solutions. Then, we concatenate the current population $P$ and the new individuals created by crossover and mutation(see Alberto and Mateo[3]). The new population is then obtained by keeping all non-dominated solutions. In case the number of non-dominated solutions is less than the population size, we complete the remaining population by the best individuals according to three fairly studied criteria: The one-third of the remaining population by the best individuals according to the makespan criterion and the one-third of the remaining population by the best individuals according to the total tardiness criterion. The best individuals according to the total completion time criterion will complement the rest of the population. In the last generation, only non-dominated solutions are kept.

4.4 NSGA-II algorithm

The NSGA-II algorithm is based on the following principles Deb et al [13]:

• •

With each generation $g$, merging the population of parents $P_{g}$ of size $s$ with the population of children $E_{g}$ of the same size to build a new population $R_{g}=P_{g}\cup E_{g}$ of size $2*s$.

• •

Sort the $R_{g}$ results population according to the non-dominance criterion. This makes it possible to distribute $R_{g}$ in several fronts $\left(F_{1},F_{2},...\right)$. The first fronts contain the best individuals.

• •

Building the new parent population $P_{g+1}$ by adding the $F_{i}$ fronts while the size of $P_{g+1}$ does not exceed $s$. In the case where the size of the new population is less than $s$, the crowding method is applied.

The calculation of the crowding distance of an individual is based on the following principles:

• •

Repeat these steps for all objectives.

• •

Sort the solutions of an objective in ascending order.

• •

Assign infinite distance for the individuals having extreme values (the first and last according to the sorts).

• •

For all other individuals, calculate the normalized difference of the two adjacent solutions. Add the value and calculate the distance of the current individual.

After calculating the crowding distance of $i^{th}$ front $F_{i}$ from $R_{g}$, the list of $F_{i}$ solutions must be sorted in a descending order. The best solution is selected by using the crowded comparison-operator $(\prec_{n})$; between two different rank solutions, we choose the one with the smallest rank, if they have the same rank we choose the solution that has the greatest crowding distance.

5 Numerical results

In this section, we present some experimental results obtained on randomly-generated instances. Then, we analyze these results and we provide some conclusions.

We implemented our genetic algorithm using a $DEVC++$ compiler on an Intel $Core^{TM}$ i3 4005U CPU 1.7 GHz, 1.7 GHz and 4 GB of RAM.

We randomly generated instances by taking into account five types of problems illustrated in Table 3 presented by Manaa and Chu [33]. The parameter $n$ is an integer ($n\in\left\{10,20\right\}$), and [x] corresponds to the integer part of $x$. The variables $n_{1}$, $n_{2}$ and $n_{12}$ respectively represent the number of $P_{1}-tasks$, $P_{2}-tasks$ and $P_{12}-tasks$.

For these five types of problems, Manaa and Chu [33] considered the distribution of the three types of tasks and the number of tasks on each processor (load on the processor).

For $Type4$, the distribution of tasks is balanced ($n_{1}=n_{2}=n_{12}=n$) and the distribution of the load on each processor ($P1:n_{1}+n_{12}=2n$ and $P2:n_{2}+n_{12}=2n$) is therefore balanced.

For $Type1$, the number of tasks $n_{1}$ exceeds that of the two other types ($n_{1}>n_{2}$ and $n_{1}>n_{12}$), while the processor $P1$ is more loaded than $P2$. For $Type5$, the number of tasks $P_{12}$, which requires the use of the two processors, exceeds that of tasks of the other two types ($n_{12}>n_{1}$ and $n_{1}>n_{2}$). But, the distribution of load on the processors is balanced.

For $Type2$, the load on the processors is balanced, which is not the case for $Type3$. The processing times are randomly generated from the set $\left\{0,..,50\right\}$.

The values $r_{j}$ are randomly generated from the set $\left\{0..L\right\}$, with $L$ equal to the integer part of: $\alpha*(s_{1}+s_{2}+s_{12})$, where $\alpha\in\left\{0.5,1,1.5\right\}$ and $s_{1},s_{2}$ and $s_{12}$ are respectively the totals of the processing time of $P_{1}-tasks$, $P_{2}-tasks$ and $P_{12}-tasks$.

The due dates $d_{j}$ are randomly generated from the set $\left\{r_{j}+p_{j},..,r_{j}+p_{j}+L\right\}$.

We consider that the group of instances represents the set of instances having the same parameters $n$, $\alpha$ and $Type$.

For the experimental results, 10 instances of each group are generated and the average values are provided. We fixed the number of generations to $2*Nb$ for each population where $Nb$ is the number of tasks to be processed. Some preliminary tests have motivated our choices.

We used two metrics to measure the quality of the Pareto front: the hypervolume indicator (HV) and the number of solutions in the optimal front (ND). The hypervolume is one of the most popular metrics for multi-objective optimisation problems (Bradstreet [9]). For that, we will use this indicator to measure and compare the performance of aggregative, Pareto and NSGA-II algorithms we propose to solve our studied problem.

To calculate the hypervolume of a set of non-dominated points, we used the program implemented by Fonseca et al. [17]. The hypervolume measure uses a reference point (the worst value in each creteria). In this paper, we use the initial solutions calculated by the proposed methods to determine the reference points.

To compare the performance of the proposed algorithms, we used the HV ratio (denoted by $HV_{r}$). The following formula compute $HV_{r}$ the distance between the solutions and the lower bounds:

[TABLE]

Let a(11, 4, 4), b(3, 3, 10) and c(5, 6, 7) be a set of non-dominated points presented in an orthonormal coordinate system. The coordinates (x, y, z) correspond to criterion 1, criterion 2, and criterion 3, respectively. The hypervolume of the set is the volume of the space covered by points a-c-b. Figure 2 presents an example to illustrate the notion of the hypervolume indicator, for the three objectives.

The remainder of this section is organized as follows. In Sect. 4.1, we will present the numerical results in terms of average computation of time. Sect. 4.2 compares the results of the three proposed approaches.

5.1 Computation time

Tables 4 summarizes the numerical results in terms of average computation of time (second). These results show the importance of distinguishing not only the total number of tasks and the length of the release dates interval, but also the different types of problems. The results also show that instances corresponding to the problem of $Type4$ (with the largest number of tasks compared to other types and the tightest distribution of the release dates with $\alpha=0.5$) are the most difficult to solve.

For the aggregative and NSGA-II methods, our genetic algorithm requires an average of computation time equal to $0.260$ seconds for the type of problem $Type4$ (with $\alpha=0.5$). For the Pareto method, the average of computation time is equal to $0.100$ seconds. The problem of $Type1$ remains the easiest to solve. The numerical results also reveal that the aggregative approach and NSGA-II require an average of computation time more than the Pareto approach.

From Table 5, our genetic algorithm with NSGA-II approach requires an average computation time equal to $0,300$ seconds for the type of problem $Type4$ (with $\alpha=1.5$). In Manaa and Chu [33] the branch-and-bound algorithm to minimize the makespan criterion, needs in average more than $574$ seconds to find the optimal solution. The problem of $Type1$ (having the smallest number of tasks compared to others) requires less computation time compared to other problems. This can be justified by the fact that the processors are loaded with less than the number of bi-processor tasks compared to other cases.

5.2 Solution quality

To compare the three objectives of our Aggregative, Pareto and NSGA algorithms, we use the average quality of the three objectives: $C/LBC$, $TT/LBTT$ and $TC/LBTC$. Furthermore, the number of non-dominated solutions and HV ratio will be used to measure the performance of the three proposed algorithms.

Tables 6, 7 and 8 present the results of the aggregative, Pareto and NSGA-II algorithms for $n=10$. Column 1 indicates the types of problems $(Type$, $\alpha)$ considered in the distribution of the three types of tasks and the number of tasks on each processor. In columns 2, 3 and 4, we present the average quality of the makespan, the total tardiness and the total completion time respectively from instances randomly generated: $(C,TT,TC,ND,HV_{r})$ denote respectively the makespan, the total tardiness, the total completion time, the average number of non-dominated solutions and the HV ratio. $(LBC,LBTT,LBTC)$ denote respectively the lower bounds of makespan, total tardiness and total completion time. Column 5 presents the average number of non-dominated solutions for each problem. Finally, in column 6 we present the results of the HV ratios.

The results for the three approaches listed in Tables 6, 7 and 8 show that the aggregative selection technique is more effective on the makespan criterion for the problems of $Type1$, $Type2$ with($\alpha=0.5$, $\alpha=1$), $Type3$ with($\alpha=0.5$, $\alpha=1$) and $Type5$. For the problems of $Type4$ with ($\alpha=1$, $\alpha=1.5$) Pareto is more efficient.

The quality of the solutions found by the NSGA-II approach is good on total tardiness criterion for the problem of $Type1$ with ($\alpha=0.5$, $\alpha=1$), $Type3$ with ($\alpha=0.5$, $\alpha=1$) and $Type5$. For the problem of $Type2$ with ($\alpha=1.5$, $\alpha=1$), $Type3$ with ($\alpha=1.5$, $\alpha=1$) and $Type4$ with ($\alpha=1.5$, $\alpha=1$) Pareto is more efficient and the results of aggregative selection technique are very bad in this cases.

For the total completion time criterion, the results with NSGA-II algorithm is more efficient. The results with the aggregative approach are close to the lower bounds in some cases and quite far from these lower bounds for the other cases. The results found by the three approaches are close to the lower bounds for the makespan criterion. In some cases, the results of total tardiness are close to the lower bounds with NSGA and Pareto approach.

The graphical representation of the front size described in Figure 3 shows that the space of solutions found by NSGA-II and Pareto technique are the most diverse in many cases containing a significant number of non-dominated solutions (between 2 and 5 solutions). This is justified by the fact that this approach ensures elitism by archiving non-dominated solutions in the evolution from one generation to another. The solution space remains the least diversified with the aggregative approach, but it is most effective for the makespan criterion.

Figure 4 presents the results of the HV ratios for the three proposed algorithms. The results for the three criteria show that the aggregative selection technique is more effective for problems of $Type1$ and $Type5$. For the problems of $Type2$ with ($\alpha=1.5$) and $Type4$ with ($\alpha=1$), the aggregative approach is slightly less efficient.

For the Pareto method, the HV ratio is very bad and strongly decreases with the problem of $Type1$ with ($\alpha=0.5$), $Type2$ with ($\alpha=1$) and $Type4$ with ($\alpha=0.5$). The three techniques are almost identical for the problems of $Type4$ with ($\alpha=1$, $\alpha=1.5$).

Tables 9, 10 and 11 present the results of the three proposed algorithms for $n=20$.

The results for the makespan criterion described in these tables show that the Pareto approach is more effective for the problems of $Type3$ with ($\alpha=0.5$, $\alpha=1$) and the problems of $Type5$ with ($\alpha=1$). For the problem of $Type3$ with ($\alpha=1.5$) and $Type4$ with ($\alpha=1$) NSGA-II is more effective. For other cases, the three techniques are almost identical. For the five types of problems studied with the makespan criterion, the aggregative approaches and Pareto are identical.

The results for the total tardiness criterion described in Tables 9, 10 and 11 show that the Pareto approach is more effective for the problems of $Type1$, $Type3$ with($\alpha=1.5$) and $Type5$ with ($\alpha=1.5$). For the problem of $Type2$ with ($\alpha=0.5$), $Type3$ with ($\alpha=0.5$) and $Type4$ NSGA-II method is the most effective. In other cases, both techniques (NSGA-II and Pareto) are almost identical. The aggregative selection method is less effective for problems of $Type1$ with ($\alpha=1.5$), $Type2$ with ($\alpha=1.5$), $Type3$ with ($\alpha=1.5$) and $Type5$ with ($\alpha=1.5$).

The numerical results of the total completion time criterion show that the Pareto technique is more effective in many cases ($Type1$ with ($\alpha=1$), $Type2$ with ($\alpha=1$) and $Type5$ ). By looking at these numerical values, we conclude that the three approaches are almost identical and the averages values found are very close.

Figure 5 summarizes average number of non-dominated solutions for n =20. The space of solutions found by Pareto technique are the most diverse containing a significant number of non-dominated solutions(between 2 and 10 solutions). The solution space remains the least diversified with the aggregative approach.

Figure 6 presents the results of the HV ratios for the three proposed algorithms (for n=20). The results for the three criteria show that the Pareto technique is more effective for problems of $Type1$ with ($\alpha=1$), $Type2$ with ($\alpha=1.5$), $Type3$ with ($\alpha=0.5$, $\alpha=1$) and $Type5$ with ($\alpha=1$. For the problems of $Type1$ with ($\alpha=1.5$) and $Type4$ with ($\alpha=1.5$), the aggregative approach is more efficient.

For the NSGA method, the HV ratio is very bad and strongly decreases with the problem of $Type2$ with ($\alpha=0.5$) and $Type5$ with ($\alpha=0.5$). The three techniques are almost identical for the problems of $Type2$ with ($\alpha=1$) and $Type4$ with ($\alpha=0.5$).

The results found by three approaches listed in the Table 6-11 are close to the lower bounds for the makespan criterion. In many cases, the results for the total completion time are close to the lower bounds for NSGA-II and Pareto approach. For total tardiness, the results are quite far from lower bounds with the three approaches studied.

6 Conclusions and perspectives

We studied a multi-objective scheduling problem on two dedicated processors to optimize three criteria; the makespan, the total tardiness and the total completion time. In this study, we exploited the lower bound constructed for each criterion, the hypervolume indicator (HV) and the number of solutions in the optimal front (ND) to assess the quality of the solutions found by NSGA-II algorithm, Pareto and aggregative methods proposed for solving the multi-objective problem. To generate the weight for the aggregative approach, we used the method of Uniform Design (proposed by Leung and Wang [32]) to choose a variety of solutions uniformly dispersed.

The results of the studied problems are encouraging and promising for the makespan and the total completion time criteria. Each studied technique (aggregative, Pareto or NSGA-II) has an advantage compared to the others according one criterion. In some cases, Pareto techniques and NSGA-II are almost identical. Therefore, it is interesting to study other extensions of these problems in a future work, like the study of scheduling problem on parallel processors. For example minimizing the makespan for the problem $P2|size_{j},r_{j}|C_{max}$ where $size_{j}$ is the number of processors required by the task $j$. This problem was proved NP-hard in the strong sense in Blazewicz et al. [8]. Therefore, it is interesting to test the proposed methods for scheduling these problems on parallel processors ( Vallada and Ruiz [42]; Venkata et al. [43]).

**Compliance with Ethical Standards

** **Conflict of interest ** The authors declare that they have no conflict of interest.