Multi-objective scheduling on two dedicated processors

08/13/2019
by   Adel Kacem, et al.
0

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 multiobjective case. Three methods are presented to solve this problem. The first is aggregative, the second is Pareto and the third is the NSGA-II algorithm. We proposed some adapted lower bounds for each criterion to evaluate the quality of the found results on a large set of instances. The obtained results show the effectiveness of the proposed algorithms.

READ FULL TEXT VIEW PDF
POST COMMENT

Comments

There are no comments yet.

Authors

page 1

page 2

page 3

page 4

12/05/2014

A Portfolio Approach to Algorithm Selection for Discrete Time-Cost Trade-off Problem

It is a known fact that the performance of optimization algorithms for N...
09/10/2020

Multi-Objective Parameter-less Population Pyramid for Solving Industrial Process Planning Problems

Evolutionary methods are effective tools for obtaining high-quality resu...
06/14/2019

An efficient Lagrangian-based heuristic to solve a multi-objective sustainable supply chain problem

Sustainable Supply Chain (SSC) management aims at integrating economic, ...
11/30/2018

Improved Crowding Distance for NSGA-II

Non-dominated sorting genetic algorithm II (NSGA-II) does well in dealin...
01/21/2019

Optimal Task Scheduling Benefits From a Duplicate-Free State-Space

The NP-hard problem of task scheduling with communication delays (P|prec...
06/25/2021

Optimal Checkpointing for Adjoint Multistage Time-Stepping Schemes

We consider checkpointing strategies that minimize the number of recompu...
This week in AI

Get the week's most popular data science and artificial intelligence research sent straight to your inbox every Saturday.

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 according the standard ternary notation.
Few studies have dealt with this problem. The most important studies are mentioned in the following paragraphs.
Coffman et al.[9] 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[12] cited this paper to describe the actual applications of scheduling problems on dedicated processors.
Craig et al.[10]

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

and .
Hoogeveen et al.[15] showed that the problem is NP-hard in the strong sense. The preemption of tasks does not make the problem easier. Oguz and Ercan[35] proved that the problem is NP-hard in the strong sense. Afrati et al[1] proposed a PTAS approximation scheme for the problem and a second PTAS approximation scheme proposed by Afrati and Milis[2].
Chu[8] 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[28] 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[19] 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 [13]

and the SPT rule, 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.[5] 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.[33] 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[26] for the problem of earliness tardiness minimization with a single due date for each task.
Manaa and Chu[29] proposed the method of separation and evaluation 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[37] 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.
Kacem and Dammak[22] 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 [29, 20]. For that, we decided to study a new extension of this problem by adding additional objective.
In the next section, some notations are detailed and the proposed lower bounds for the makespan, total completion time and total tardiness are given. In Section 3, we present the solving approaches. Three methods to solve the considered problem are developed. The one is aggregative with Uniform Design, the second is Pareto and the third is the NSGA-II. Section 4 deals with the generation of instances, the computational results and the qualitative and quantitative analysis. Finally concluding remarks are given in Section 5.

2 Lower bounds

We study three scheduling problems on two dedicated processors. To assess the quality of the results found by such a method, we use the following lower bounds.

2.1 Notation

The following fields denote:

  • : Two processors.

  • : Each task has one or two dedicated processors and the assignment of each task is fixed.

  • : Release date of task .

  • : Makespan.

  • : Tardiness of task ; with the completion time of task .

  • : Due date of task .

2.2 Lower bound for problem

Manaa and Chu [29] 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.[6] 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).

2.3 Lower bound for problem

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

    [8]).

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, we consider the mono-processor tasks with a weight , and the bi- processor sub-tasks on processor a weight , with .
Similarly, we consider the second processor , the mono-processor tasks with a weight . However, the bi-processor sub-tasks on processor a weight . Thus, we obtain a problem on each processor: and .
We consider . The next step is to divide the mono-processor tasks (with a weight ) in two tasks. We get for each divided task two sub tasks and with release date ; and processing time .
We divide the weight on for each sub tasks. We are getting if . From where,
, with is a penalty to be added according to Webster formula.
.
We apply the same principle for the problem . We are getting .
is then a lower bound for problem . The calculation of the lower bounds of completion times for the problem on each processor uses the following theorem for .

Theorem 1

(Chu[8])
Let be the completion time of the task in the position of a feasible schedule . is the completion time of the task in the position of a feasible schedule constructed by the SRPT (Shortest Remaining Processing Time) priority rule. Chu proved that for every feasible schedule , we have:

By applying the theorem (Chu[8]), we compute a lower bound on the completion time of each job. Example : Let us consider the instance in Table 1.

Table 1: Example

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 , we schedule the tasks . We divide the tasks on into two, we get the following tasks: with the following parameters described in Table 2.

Table 2: Results division on

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

Figure 1: SRPT representation on P1

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

(1)

Respectively, we calculate the lower bound for the problem .
Thus, we consider as a lower bound for the problem .
.

2.4 Lower bound for the problem

Kacem and Dammak[20] 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[8]).

  • The idea of calculating the lower bound by assigning the due dates to the reduced completion times (originally proposed in Rebai et al.[33] 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 , we consider the mono-processor tasks with a weight , and the bi-processor sub-tasks on processor having a weight with .
Similarly, we consider, on the second processor , the mono-processor tasks with a weight . However, the bi-processor sub-tasks on the processor have a weight . Thus, we obtain a problem on each processor and .
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 be the cost of assigning a reduced to the task supposed to end at the position of the schedule. This cost can be calculated according to the following formula: .
This assignment technique, presented by Rebai et al.[33], allows us to elaborate a new lower bound. We apply the Hungarian algorithm to determine, from the assignment matrix , a lower bound () to solve the following problem .

(2)
(3)
(4)
(5)

Applying the same process, we calculate for the problem. Thus, we consider as a lower bound for the problem .
Optimization of the lower bound
To improve the constructed lower bound, we look for the weights , which maximize . We use the following method to optimize the bound .

  • For a bi-processor task , we calculate the gap between and tardiness of task according to the associated two sub-problems on the two processors obtained by the Hungarian algorithm.

  • According to the gap, , we increase the 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 .

  • We repeat this procedure for all bi-processor tasks.

Next, we present the study of the problem .

3 Solving approaches

We adapt the 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.

3.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 distinct numbers that correspond to the set .
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[23]). 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[37]). 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[18]).
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.

3.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[28]). 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.
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.

3.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[28]).
We consider a unit hyper-cube in a dimensions space ( is the number of objectives) and a point in , Where , such that .
For any item from the hyper-cube , we can create a hyper-rectangle between the center and , with . This hyper-rectangle is described by the following formula:

(6)

We consider a set of points from , We can associate with each point , a subset of points that belongs to the hyper-rectangle . Let be the cardinality of such a sub set and the fraction of the points included in the hyper-cube and is the fraction of volume value of the hyper-rectangle . The uniform design is to determine points in such that the following discrepancy is minimized.

(7)

The authors presented the points solution calculated using the uniform matrix given by Fang and Li [14]. With and is a parameter that depends on and .
Now, we consider our problem studied, which consists in optimizing three objectives. In our case, we have , we take , so see (Leung and Wang[28]). Using the formula given by Fang and Li[14], we get the following uniform matrix:

We consider the weighting vector

. The components of this vector are calculated by the following formula:

(8)

3.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:

(9)

Such that,

(10)
(11)
(12)

where are the vector components of the weight described in the above section, is a feasible solution from population and , , , are respectively the makespan, the total tardiness and total completion time of a solution .
By exploiting the uniform matrix, we obtain seven evaluation functions (fitness). The list of functions is given by the following formula:

(13)

Each combination of these weights transforms the problem into a mono-objective case. For each combination, the genetic algorithm is applied and the population is stored. At the end of this process, such populations are merged and only the non-dominated solutions are kept.

3.3 Pareto approach

We adapt classical genetic algorithm for multi-objective case using the Pareto approach [32]. For each generation, we transform the population by crossing the non-dominated solutions and mutating the dominated solutions. Then, we concatenate the current population 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.

3.4 NSGA-II algorithm

The NSGA-II algorithm is based on the following principle (Deb et al.[11]):

  • With each generation , merging the population of parents of size with the population of children of the same size to build a new population of size .

  • Sort the results population according to the non-dominance criterion. This makes it possible to distribute in several fronts . The first fronts contain the best individuals.

  • Building the new parent population by adding the fronts while the size of does not exceed . In the case where the size of the new population is less than , 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 front from , the list of solutions must be sorted in a descending order. The best solution is selected by using the crowded comparison-operator ; 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.

4 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 compiler on an Intel i3 4005U CPU 1.7 GHz, 1.7 GHz and 4 GB of RAM.

[/2] [/2] [/2] [/2] [/2] [/2]

Table 3: Problem types

We randomly generated instances by taking into account five types of problems illustrated in Table 3 presented by Manaa and Chu[29]. The parameter is an integer (), and [x] corresponds to the integer part of . The variables , and respectively represent the number of , and .
For these five types of problems, Manaa and Chu[29] considered the distribution of the three types of tasks and the number of tasks on each processor (load on the processor).
For , the distribution of tasks is balanced () and the distribution of the load on each processor ( and ) is therefore balanced.
For , the number of tasks exceeds that of the two other types ( and ), while the processor is more loaded than . For , the number of tasks , which requires the use of the two processors, exceeds that of tasks of the other two types ( and ). But, the distribution of load on the processors is balanced.
For , the load on the processors is balanced, which is not the case for . The processing times are randomly generated from the set .
The values are randomly generated from the set , with equal to the integer part of: , where and and are respectively the totals of the processing time of , and .
The due dates are randomly generated from the set .
We consider that the group of instances represents the set of instances having the same parameters , and .
For the experimental results, 10 instances of each group are generated and the average values are provided. We fixed the number of generations to for each population where is the number of tasks to be processed. Some preliminary tests have motivated our choices.

4.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 type 4 (with the largest number of tasks compared to other types and the tightest distribution of the release dates with ) are the most difficult to solve.

0.086 0.120 0.188 0.135 0.111 0.141 0.098 0.128 0.122


Note: Aggregative GA results with .

0.040 0.055 0.126 0.060 0.059 0.078 0.048 0.073 0.099


Note: Pareto GA results with .

0.072 0.121 0.188 0.128 0.112 0.151 0.104 0.129 0.122


Note: NSGA-II results with .

Table 4: Computation time (in second)

For the aggregative and NSGA-II methods, our genetic algorithm requires an average of computation time equal to seconds for the type of problem (with ). For the Pareto method, the average of computation time is equal to seconds. The problem of 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.

0.152 0.170 0.237 0.186 0.180 0.308 0.139 0.217 0.227


Note: Aggregative GA results with .

0.085 0.125 0.105 0.071 0.120 0.228 0.124 0.161 0.223


Note: Pareto GA results with .

0.152 0.170 0.241 0.186 0.178 0.281 0.140 0.121 0.231


Note: NSGA-II results with .

Table 5: Computation time (in second)

From Table 5, Our genetic algorithm with NSGA-II approach requires an average computation time equal to seconds for the type of problem (with ). In Manaa and Chu[29] the branch-and-bound algorithm to minimize the makespan criterion, needs in average more than seconds to find the optimal solution. The problem of (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.

4.2 Solution quality

Table 6, provides the averages of makespan, total tardiness and total completion time from instances randomly generated. These instances satisfy the same parameters , and . The first column indicates the types of problems , and that denote respectively the makespan, the total tardiness, the total completion time and the number of non-dominated solutions.

Types initial solution Aggregative GA Pareto GA NSGA-II Lower bound
210 929 2771 160 106 1588 25 175 134 1688 23 170 118 1632 43 144 83 1126
309 1019 4365 226 109 2627 28 240 71 2520 29 243 103 2575 47 201 24 2168
385 1285 5856 292 82 3350 28 297 79 3323 21 306 71 3300 29 284 10 2887
263 1494 4288 196 253 2619 23 232 244 2752 22 202 242 2663 24 175 80 1740
362 1605 6655 270 187 4220 32 302 111 4026 33 292 113 4046 26 243 37 3102
523 1676 9484 414 315 6464 29 399 137 5654 32 402 164 5764 19 380 9 4789
292 1747 4766 237 418 2986 23 264 489 3143 29 243 445 3043 35 210 194 1738
402 2070 7325 291 258 4458 24 314 145 4252 33 306 153 4058 31 258 31 3203
525 1971 930 416 364 6659 26 427 112 6249 52 436 201 6315 35 377 18 4967
340 2474 6396 254 581 4127 25 265 414 3827 29 261 577 3939 37 213 299 2317
477 2841 9754 340 557 6639 26 323 229 6049 37 342 313 6025 22 283 44 4530
603 2648 13456 495 510 9050 25 489 367 8862 41 506 442 9120 26 430 32 6831
253 1306 3315 194 259 1975 25 223 258 2008 31 200 229 1932 51 173 221 1233
339 1373 4797 226 90 2663 23 233 78 2536 41 252 81 2678 36 208 28 2091
409 1149 6051 299 125 3679 28 325 81 3433 29 333 58 3569 38 290 9 3072
Table 6: Average values ()

The results for the three approaches listed in Table 6 show that the aggregative selection technique is more effective for the problems of , with(). For the problems of and with (), Pareto is more efficient. For other cases of problems, each technique has an advantage on one or two criteria.
The quality of the solutions found by the NSGA-II approach is good for the problem of with () and with (). The space of solutions found by NSGA-II is the most diverse in many cases containing a significant number of non-dominated 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 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.
For the total completion time criterion, 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 solution space remains the least diversified with the aggregative approach, but it is most effective for the makespan criterion.

Figure 2: Results for the makespan (with n =10)

The graphical representation of the results obtained for the makespan criterion described in Figure 2 shows that the Pareto selection technique is less effective for such problems of and with () . For the problems of and with () NSGA-II is more effective. In other cases, the three techniques are almost identical.

Figure 3: Results for the total tardiness (with n =10)

The results for the total tardiness criterion described in Figure 3, show that the Pareto selection technique is more effective for the problem of with () and with (). In other cases, both techniques NSGA-II and Pareto are almost identical. For the problems of with (), and the aggregative approach is less efficient.

Figure 4: Results for the total completion time (with n =10)

The three techniques are almost identical. For the problems of with () and , the aggregative approach is slightly less efficient.

Types initial solution Aggregative GA Pareto GA NSGA-II Lower bound
459 4687 11971 365 1484 7996 23 376 1283 7766 32 355 1114 6729 20 301 342 4158
673 6089 20427 493 1161 12675 19 473 521 11505 23 489 942 12644 25 409 73 8383
819 5665 24914 617 1236 16554 17 618 849 15894 56 634 940 16403 18 582 21 11720
543 6814 17757 414 2526 12400 25 412 1769 11813 53 431 2193 11919 27 319 759 6250
734 6377 27034 583 2123 19932 22 573 1633 18492 52 569 1879 19212 28 482 133 12227
1010 8200 39710 801 2697 29150 20 783 1858 27821 44 811 2066 27958 30 723 27 18463
614 8128 19334 490 3833 14127 14 461 2656 13615 41 482 3465 13858 18 388 798 6411
847 9783 31231 643 2736 20772 18 592 1619 19863 41 665 2023 19484 20 494 235 12200
1025 9851 40043 811 3122 28309 24 833 1707 27331 59 803 2394 26554 16 701 36 17768
688 10762 26394 547 4810 19011 27 545 4117 18261 17 541 4365 18544 24 403 1107 8650
943 10051 40377 766 3427 31064 26 760 3228 32847 31 691 2634 25813 26 588 168 17036
1220 14008 57961 949 4045 41358 22 975 3871 39914 61 998 3634 39887 32 837 89 25383
518 5265 12921 404 1931 9003 24 403 1362 8366 22 429 1719 8939 20 311 683 4376
662 5948 19576 488 1634 12887 10 440 744 11321 102 491 1157 12877 25 396 175 8096
872 6214 26521 668 1529 18115 23 673 651 16114 66 664 783 16683 21 590 58 11928
Table 7: Average values ()

The results for the three criteria listed in the Table 7 show that the Pareto selection technique is more effective for problems of and with (), and with () and with ().
For the problems of with () and with () NSGA-II method is more effective. For the problem of with () each technique (aggregative, Pareto or NSGA-II) has an advantage over the other on a one criteria. In other cases, Pareto techniques and NSGA-II are almost identical.

Figure 5: Results for the makespan (with n =20)

The graphic representation for the makespan criterion described in Figure 5 shows that NSGA-II method is less effective for the problems of with (). For the problem of with () 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.

Figure 6: Results for the total tardiness (with n =20)

The results for the total tardiness criterion described in Figure 6 show that the Pareto approach is more effective for the problems of with () , with() and with (). For the problem of with () 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 , and with ().

Figure 7: Results for the total completion time (with n =20)

The numerical results of the total completion time criterion show that the Pareto technique is more effective in many cases (see Table 7). By looking at these numerical values, we conclude that the three approaches are almost identical and the averages values found are very close. Figure 7 summarizes the numerical results found in average for the three approaches we investigated for the total completion time criterion. The results found by three approaches 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.

5 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 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[28]) to choose a variety of solutions uniformly dispersed.
The results of the studied problems are encouraging and promising. 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 where is the number of processors required by the task . This problem was proved NP-hard in the strong sense in Blazewicz et al.[7]. Therefore, it is interesting to test the proposed methods for scheduling these problems on parallel processors (Venkata et al.[38].

Compliance with Ethical Standards
Conflict of interest The authors declare that they have no conflict of interest.

References

  • [1] Afrati, F.N., Bampis, E., Chekuri, C., Karger, D.R., Kenyon, C., Khanna, S., Milis, I., Queyranne, M., Sartinutella, M. and Stein, C. and Sviridenko. M. ",. Approximation schemes for minimizing average weighted completion time with release dates. In Symposium on Foundations of Computer Science, pages 32–44.IEEE, 1999.
  • [2] Afrati, F.N. and Milis, I. Designing ptass for min-sum scheduling problems. In Discrete Applied Mathematics 154(4), pages 622–639., 2006.
  • [3] Alberto, I and Mateo, PM A crossover operator that uses Pareto optimality in its definition. In Top 19(1), Springer, pages 67–92., 2011.
  • [4] Allahverdi, A., Aydilek, H. and Aydilek, A. No-wait flowshop scheduling problem with two criteria; total tardiness and makespan. European Journal of Operational Research 269(2), pages 590–601.,2018.
  • [5] Berrichi, A., Amodeo, L., Yalaoui, F., Châtelet, E. and Mezghiche, M. Bi-objective optimization algorithms for joint production and maintenance scheduling: application to the parallel machine problem. Journal of Intelligent Manufacturing 20(4) , pages 389–400., 2007.
  • [6] Bianco, L., Blazewicz, J., Dell’Olmo, P. and Drozdowski, M. Preemptive multiprocessor task scheduling with release times and time windows. Annals of Operations Research 70(1), pages 43–55.,1997.
  • [7] Blazewicz, J., Dell’Olmo, P. and Drozdowski, M. Scheduling multiprocessor tasks on two parallel processors. RAIRO-Operations Research 36(1), pages 37–51.,2002.
  • [8] Chu, C. Scheduling multiprocessor tasks on two parallel processors.A branch and bound algorithm to minimize the total of tardness with different release date. Naval Researech Logistics 39(2), pages 256–283.,1992.
  • [9] Coffman, E.G., Garey, M.R., Johnson, D.S. and LaPaugh, A. S. Scheduling file transfers. SIAM Journal on Computing 14(4), pages 743–780.,1985.
  • [10] Craig, G.L., Kime, C. R. and Saluja, K.K. Test scheduling and control for vlsi built-in self-test. IEEE Transactions on Computers 37(9), pages 1099–1109.,1988.
  • [11] Deb, K., Pratap, A., Agarwal, S. and Meyarivan, T. A fast and elitist multiobjective genetic algorithm: NSGA II.

    IEEE Transactions on Evolutionary Computation 6(2)

    , pages 182–197.,2002.
  • [12] Drozdowski, M. Scheduling multiprocessor tasks an overview. European Journal of Operational Research 94(2), pages 215–230.,1996.
  • [13] Emmons, H. Some New Uniform Design. Operations Research 17(4), pages 701–715.,1969.
  • [14] Fang, K.T and Li, J.K Multi-objective genetic algorithms made easy: selection, sharing and mating restrictions. Hong Kong, Baptist Univ., Hong Kong, Tech. Rep. Math-042, 1994.
  • [15] Hoogeveen, J.A., Van de Velde. S.L. and Veltman, B. Complexity of scheduling multiprocessor tasks with prespecified processors allocations. Discrete Applied Mathematics 55(3), pages 259–272.,1994.
  • [16] Jia, H. Z., Fuh, J. Y., Nee, A. Y. and Zhang, Y. F. Integration of genetic algorithm and Gantt chart for job shop scheduling in distributed manufacturing systems. Computers and Industrial Engineering 53(2), pages 313–320.,2007.
  • [17] Jung, S., Woo, Y. B. and Kim, B. S. Two-stage assembly scheduling problem for processing products with dynamic component-sizes and a setup time. omputers and Industrial Engineering 104, pages 98–113.,2017.
  • [18] Holland, J. Adaptation in Natural and Artifcial Systems. Michigan Press, University of Michigan Press, USA, 1975.
  • [19] Kacem, I. Lower bounds for tardiness minimization on a single machine with family setup times. International Journal of Operations Research 4(1), pages 18–31., 2007.
  • [20] Kacem, A. and Dammak, A. A genetic algorithm to minimize the total of tardiness multiprocessing tasks on two dedicated processors. Control, Decision and Information Technologies, Barcelona, Spain ,IEEE, pages 85–90., 2017.
  • [21] Kacem, A. and Dammak, A. Complexity of scheduling multiprocessor tasks with prespecified processors allocations.Bi-objective scheduling of multi-processor tasks on two dedicated processors. International Conference of the African Federation of Operational Research Societies, Tunisia, 2-4 July., 2018.
  • [22] Kacem, A. and Dammak, A. Bi-objective scheduling on two dedicated processors. European Journal of Industrial Engineering 5, pages 681–700., 2019.
  • [23] Karasakal, Esra and Silav, Ahmet A multi-objective genetic algorithm for a bi-objective facility location problem with partial coverage. Top 24(1), Springer, pages 206–232., 2016.
  • [24] Kramer, A. Scheduling multiprocessor tasks on dedicated processors. Universitat Osnabruck, Allemagne, 1995.
  • [25] Lemesre, J. and Talbi, E. Méthodes exactes pour l’optimisation combinatoire multi-objectif: conception et application. EUniversité des sciences et technologies de Lille, France, 2006.
  • [26] Li, George Single machine earliness and tardiness scheduling. European Journal of Operational Research 96(3), pages 546–558., 1997.
  • [27] Lee, I. S. Minimizing total completion time in the assembly scheduling problem. Computers and Industrial Engineering 122, pages 211–218., 2018.
  • [28] Leung, Y.W. and Wang, Y. Multiobjective Programming Using Uniform Design and Genetic Algorithm. IEEE Transaction on Systems, Man and Cybernetics 30(c), pages 293–303., 2000.
  • [29] Manaa, A. and Chu, C. Scheduling multiprocessor tasks to minimise the makespan on two dedicated processors. European Journal of Industrial Engineering 4(3), pages 265–279., 2010.
  • [30] Moon, C., Kim, J. and Hur, S. Integrated process planning and scheduling with minimizing total tardiness in multi-plants supply chain. Computers and Industrial Engineering 43(1-2), pages 331–349., 2002.
  • [31] Nogueira, B., Maciel, P., Tavares, E., Silva, R. and Andrade, E. Multi-objective optimization of multimedia embedded systems using genetic algorithms and stochastic simulation. Soft Computing 21(14), pages 4141–4158., 2017.
  • [32] Pareto, V. Cours économie politique. Lausane Switzerland, Switzerland, 1896.
  • [33] Rebai, M., Kacem, I. and Adjallah, K. Earliness tardiness minimization on a single machine to schedule preventive maintenance tasks: metaheuristic and exact methods. Journal of Intelligent Manufacturing 23(4), pages 1207–1224., 2010.
  • [34] Mumtaz , K. and Ilknur, K.and and Hakan , T. An integrated multi-criteria decision making methodology for health technology assessment. European Journal of Industrial Engineering 12(4), pages 504–534., 2018.
  • [35] Oguz, C. and Ercan, M.F. A genetic algorithm for hybrid flow-shop scheduling with multiprocessor tasks. Journal of Scheduling 8(4), pages 323–351., 2005.
  • [36] Salmasnia, Ali, Khatami, Mostafa, Kazemzadeh, Reza Baradaran, Zegordi and Seyed Hessameddin Bi-objective single machine scheduling problem with stochastic processing times. Top 23(1), Springer, pages 275–297., 2015.
  • [37] Vallada, E and Ruiz, R.R A genetic algorithm for the unrelated parallel machine scheduling problem with sequence dependent setup times. European Journal of Operational Research 211(3), pages 612–622., 2011.
  • [38] Venkata, P.P., Usha, M. and Viswanath, K.G Order acceptance and scheduling in a parallel machine environment with weighted completion time. European Journal of Industrial Engineering 12(4), pages 535–557., 2018.