Exact Algorithms for Scheduling Problems on Parallel Identical Machines with Conflict Jobs
aa r X i v : . [ c s . D S ] F e b Noname manuscript No. (will be inserted by the editor)
Exact Algorithms for Scheduling Problems on ParallelIdentical Machines with Conflict Jobs
Minh Ho`ang H`a · Dinh Quy Ta · Trung ThanhNguyen*
Received: XXXX/XX/XX / Accepted: XXXX/XX/XX
Abstract
Machine scheduling problems involving conflict jobs can be seen as a constrainedversion of the classical scheduling problem, in which some jobs are conflict in the sense thatthey cannot be proceeded simultaneously on different machines. This conflict constraintnaturally arises in several practical applications and has recently received considerable at-tentions in the research community. In fact, the problem is typically NP -hard (even forapproximation) and most of algorithmic results achieved so far have heavily relied on spe-cial structures of the underlying graph used to model the conflict-job relation. Our focus ison three objective functions: minimizing the makespan, minimizing the weighted summa-tion of the jobs’ completion time, and maximizing the total weights of completed jobs; thefirst two of which have been intensively studied in the literature. For each objective functionconsidered, we present several mixed integer linear programming models and a constraintprogramming model, from which we can solve the problems to optimality using dedicatedsolvers. Binary search-based algorithms are also proposed to solve the makespan problem.The results of numerical experiments performed on randomly generated data sets with up to32 jobs and 6 machines are reported and analysed to verify the performance of the proposedmethods. Keywords
Machine scheduling · conflict job · mixed integer linear programming · constraint programming · binary search. The classical scheduling problem on parallel machines (a.k.a minimum makespan ) dealswith assigning a set of heterogenous jobs, each having a certain processing time, to a finitenumber of identical machines so that the makespan is minimized, where the makespan isdefined as the maximum load over all machines. While this problem has a long and rich
Minh Ho`ang H`a · Trung Thanh NguyenORLab, Faculty of Computer Science, Phenikaa University, Hanoi 12116, VietnamE-mail: [email protected] Quy TaORLab, Faculty of Information Technology, VNU University of Engineering and Technology, Hanoi, Viet-nam history, its constrained versions, where additional requirements for the job assignment areattached, have also flourished in recent years. In this paper we investigate a salient and re-markable constrained variant in which some jobs are conflict in the sense that they cannot beprocessed at the same time (on different machines). For example, let’s consider a scenariowhere there is a set of resources, each with a certain supply, and each job has a specifieddemand (or request) for each resource. A conflict occurs among jobs if their accumulativerequest of a resource does exceed its supply. The conflict constraint has also arisen in manyother real-word applications such as the load balancing in a parallel computation [2], trafficintersection control [5, 11], VLSI and compiler design [46], frequency assignment in cel-lular networks and session management in local area networks [27], resource-constrainedscheduling [20].More recently, several new applications of the conflict constraints are introduced todemonstrate the situations where some jobs cannot be processed simultaneously to ensurethe reliability of systems. In [25], the authors consider a scheduling problem motivated bya joint project with a mobile network operator, who needs to run various computer pro-grams to adjust configuration or some parameters of the network. Each program affects apre-determined group of mobile subscribers. Any two programs that affect two parts of thenetwork which have common elements cannot be executed concurrently, and this can bemodeled by the conflict constraints.Another application can be found in the ROADEF Challenge 2020 named “Grid operation-based outage maintenance planning” proposed by R´eseau de Transport d’ ´Electrict´e (RTE),the electricity transmission system operator of France (see [43]). To guarantee both elec-tricity delivery and supply, RTE must ensure that the grid is correctly maintained. One ofits difficult tasks is to schedule maintenance operations for its electricity lines. In reality,some lines are sometimes too close to each other to carry out corresponding interventionsat the same time. This would significantly weaken the network, and would be dramatic incase another close line is disconnected during the interventions. Therefore, maintenancejobs corresponding to close lines cannot be performed simultaneously to ensure the safetyof the whole power system.A simple and widely-used tool for modeling the conflicts among jobs is to make use ofan arbitrary conflict graph , whose vertices correspond to the jobs, and an edge between twovertices represents the conflict of these two jobs. It is worth noting that one can also considerthe complement of a conflict graph, called compatible (or agreement ) graph, in which thereis an edge between two vertices if the corresponding jobs can be scheduled simultaneously.The presence of the constraint on conflict jobs makes a machine scheduling problem moregeneral and harder to address, but worthy to study. The special case of edgeless graphs (i.e.,graphs with no edges) captures exactly the classical setting where there are no conflict jobs.Beyond conflict graphs, the existing works in the literature have exhibited scenarios whereeach conflict may involve more than two jobs, and the conflict relationships can be expressedby a general structure such as hypergraphs [7]. On the other hand, there has been the casethat the processing of some job must be done before the execution of another job can start,and such a conflict is unable to be represented in terms of (hyper-)graphs [20]. Our focus inthis work is on the scheduling jobs with pairwise conflicts.In the literature, machine scheduling problems involving conflict jobs have been stud-ied under different objectives, including minimum makespan, minimum weighted-sum ofcompletion times, and maximum total weights of completed jobs. The first objective, whichaims to minimize the amount of time needed for processing all jobs, has been well-knownfor decades. The second objective has been an intuitively appealing objective and studiedsince the late 1980s and early 1990s, with a connection to the sum coloring problem [39].
The problem of maximizing the third objective naturally arose as a generalized version ofthe classical
Knapsack problem (KP) [37], where each job is associated with a profit anda weight (or length) that specifies the amount of time that needed to be processed. In thiscontext, every two jobs are conflict and one may not have them all executed on a singlemachine, assuming a deadline T by which the chosen jobs must be finished. We thereforelook for a subset of jobs of maximum total profits that can be scheduled on the machine.From a computational point of view, it is important to observe that the machine schedul-ing problem with each of the three objectives above is NP -hard, even for edgeless graphs,meaning that there are no polynomial time algorithms, unless P = NP . For instance, theminimum makespan problem with two identical machines and an edgeless graph is at leastas hard as the Partition problem [19]. Also, the problem of maximizing total weights ofcompleted jobs on one machine with deadline T is simply the classical Knapsack problemand is thus NP -hard. One can see that the conflict graph plays a major impact on the com-plexity of the corresponding machine scheduling problem. Most of the works so far havebeen therefore concentrated on specific structures of graphs for which one can either estab-lish NP -harness results as well as approximation algorithms, or evenly provide polynomialtime algorithms that solve the problem to optimality. An overview of such results is providedin Section 2.2.Despite various hardness and approximation results achieved for the machine schedul-ing problems with conflict jobs, there has not been much work focusing on developing exactalgorithms for general conflict graphs. Although the drawback of such algorithms lies onits exponential time, they may still be of theoretical interest as well as of a practical pointof view (we refer to a survey [51] by Woeginger for more reasons of studying exact algo-rithms for NP -hard problems). In fact, for some realistic situations, really exact solutionsare more preferred than approximate ones. This motivates us to study in this work potentialapproaches for exactly solving the machine scheduling problems with conflict jobs, which,along with known approximability behaviors, may help understanding better the hardnessand the solvability of the problems. Organization.
The remaining of the paper is structured as follows. In Section 2 we formallyintroduce the problem models that are studied in this paper, followed by a brief overview ofrelated works and our contribution. Section 3 introduces MILP formulations for the prob-lems, while the CP formulations are described in Section 4. The algorithms based on binarysearch for the minimum makespan problem are discussed in Section 5. The performancecomparison of the models is represented by experimental results in Section 6. Finally, Sec-tion 7 concludes our research. n jobs J = { , . . . , | J |} and a set of parallel identical machines M = { , . . . , | M |} . Each job i ∈ J has a processing time (or length) p i ∈ N > and can be pro-cessed on at most one machine, without preemptions, that is, once a machine starts process-ing a job it continues this processing without interruptions until its completion. We call jobsof unit processing time unit-jobs. We denote by p = ( p i ) i ∈ J the vector of job processingtimes. It is assumed that each machine can process at most one job at a time. Some of jobsare conflict (or incompatible) in the sense that they cannot be scheduled simultaneously on different machines. The conflict relation between jobs is modeled in terms of an undirectedgraph G = ( J, E ) , on which each vertex corresponds to a job, and there is an edge connect-ing two vertices i, i ′ if they represent two conflict jobs. In the following we will define anassignment (or schedule) of jobs to machines. It is assumed that time is discrete and everyjob and machine are available for processing at time zero. Definition 1 (Job assignment)
A job assignment (or schedule) is an assignment of timeintervals on the machines to the jobs in such a way that fulfills the following conditions:1. Each job i is assigned an interval of length p i on one machine;2. Every two intervals assigned to the same machine do not intersect;3. For every two conflict jobs, their intervals (on different machines) do not intersect.For a job assignment π , we denote by s i the starting point of an interval on which a job i is processed on a machine. The interval during which job i is processed on a machine is [ s i , s i + p i ] . Formally, the job assignment π can be defined as a one-to-one mapping: π : J → M × [0 , L ] i π ( i ) = ( m i , s i ) , where L = P i ∈ J p i , such that for every two jobs i and i ′ we have [ s i , s i + p i ] ∩ [ s i ′ , s i ′ + p i ′ ] = ∅ if they are conflict or if they are assigned to the same machine, i.e., m i = m i ′ .Our definition of job assignment is quite general as it covers both the cases with andwithout the deadline constraint. In the former case, where there is a deadline T ≤ L , if thereis an allocation π ( i ) with s i ≥ T , it means that job i was not assigned to any machine. Wedenote by Π the set of all possible job assignments π .In what follows, we formally define three machine scheduling problems that are studiedin this paper. Definition 2 (
MinMax ) Given an instance problem I = ( J, M, p, G ) , compute an assign-ment π such that jobs are completely processed on machines and the maximum completiontime over all machines is minimized, that is, min π ∈ Π (cid:26) max i ∈ J { s i + p i } (cid:27) , subject to the conflict constraint. In other words, we seek for a schedule in which the largestendpoint of an interval assigned to a job is as small as possible. Definition 3 (
MinSum ) In this problem each job i ∈ J is associated with a nonnegativeweight (or cost) w i beyond the processing time p i . Denote by w = ( w i ) i ∈ J the vector ofjob weights. Given an instance problem I = ( J, M, p, w, G ) , compute an assignment π thatminimizes the weighted-sum of completion times, i.e. min π ∈ Π (X i ∈ J w i · ( s i + p i ) ) , subject to the conflict constraint.One may assume the number of machines to be infinite, as considered in most of works inthe literature. However, this exactly corresponds to a special case of our model defined hereby setting the number of machines equal to the number of jobs. Definition 4 (
MaxSum ) Similar to
MinSum , we assume that in this problem model there is avector of job profits r = ( r i ) i ∈ J . In addition, there is a deadline T ≤ L , by which jobs needto be finished. Given an instance problem I = ( J, M, p, r, G, T ) , compute an assignment π that maximizes the total weights of completed jobs, that is, max π ∈ Π X i ∈ J,s i + p i ≤ T r i , subject to the conflict constraint.2.2 Relate workThis section aims to provide a review of the literature on the three scheduling problemswith conflict jobs: MinMax , MinSum , and
MaxSum . Basically, adding the conflict constraintmakes the scheduling problem much harder to solve, or even to approximate. Hence, mostof work has paid attention on the special structures of the conflict graphs which can makethe problem tractable or approximable. To be more focused, the review below is separatedfor each considered problem.
MinMax problem . One can see that for the edgeless graph (i.e. graph with no edges) alljobs are not conflict, and
MinMax comes down to the classical minimum makespan, whichis NP -hard. Graham [23, 24] gave a greedy / -approximation algorithm for the problem.Hochbaum and Shmoys [31] presented a polynomial time approximation scheme (PTAS)and this is the best possible result for the problem, as it is strongly NP -hard (using areduction from 3-Partition [19]). Several exact methods have been proposed for solvingthe problem to optimality, including: cutting plane algorithm [45], branch-and-bound algo-rithms [13, 29], branch-and-price algorithm [12]. For the case of general conflict graphs, MinMax with unit jobs was studied under the name mutual exclusion scheduling by Bakerand Coffman [2]. They proved that the problem is NP -hard in the strong sense if the num-ber of machines is at least , but is polynomially solvable for the two-machine case, by con-structing a maximum matching for the complement of the conflict graph. The later positiveresult was extended by Even et al. [16] to the setting where the length of jobs is or . Nev-ertheless, if one allows the job lengths to take values in domain { , , } , then the problembecomes NP -hard [6]. Several other works have considered unit jobs with different struc-tures of the conflict graph [1, 8, 16, 34, 36, 40]. In fact, MinMax is NP -hard for permutationgraphs [34], complements of comparability graphs [40], and for interval graphs [8]. On thepositive side, Baker and Coffman [2] proved an interesting fact that MinMax with unit jobs isequivalent to the so-called | M | - bounded coloring problem , for which polynomial-time al-gorithms exist for trees (or forest) [2], split graphs and complements of interval graphs [40],cographs and bipartite graphs [8], constant treewidth [36], and line graphs [1].Approximability of MinMax has been investigated for special cases of job lengths. Forexample, the case with unit jobs can be expressed as the | M | -Set Cover problem, for which For α ≥ , an α -approximation algorithm for a minimization problem P is a polynomial time algorithmthat can produce a near-optimal solution whose value is at most α times the optimum. A PTAS is a (1 + ǫ ) -approximation algorithm for any fixed constant ǫ ∈ (0 , . We refer to the textbook [50] for more details ofapproximation algorithms. In a δ -bounded coloring problem, one needs to find a minimum coloring of a given graph such that everycolor class contains at most δ vertices. there exists an ( H | M | − / -approximation algorithm [15], where H | M | = ln( | M | )+ Θ (1) ,assuming that | M | is constant. When | M | is part of the input, one cannot approximate theproblem to within a factor of n − ǫ [52], for any ǫ > , unless NP ⊂ DTIME ( n log log n ) .For the case when p i ∈ { , , } , there is a / -approximation algorithm [16] for | M | = 2 . MinSum problem . As mentioned early,
MinSum (in unweighted form with unit jobs) isrelated to the sum coloring problem (SCP) on graphs, which was first studied by Kubicka[39] in her 1989 thesis (and independently by Supowit [49] in the area of VLSI design). Inthis problem, colors are positive integers and the goal is to give to each vertex i of the grapha color p i so that adjacent vertices have different colors. In this context, the sum of colorsgiven to the vertices is exactly the sum of completion times of the corresponding jobs. Theminimum value of this sum is well known as the chromatic sum of the graph. A numberof results have been proposed for SCP (see [35] for a detailed survey). We briefly mentionhere main algorithmic results. For general graphs, Bar-Noy et al. [3] presented an | J | log ( | J | ) -approximation algorithm, and proved that one cannot have an approximation factor betterthan | J | − ǫ , for any ǫ > . In addition, they proved that the problem on line graphs is NP -hard, but can be approximated to a factor of . NP -hardness (or inapproximability) resultshave been also established for planar graphs [26], bipartite graphs and perfect graphs [4],and interval graphs [22]. On the positive side, there is a PTAS for planar graphs [26] (andthis even holds for non-unit jobs), while the approximation factors for bipartite graphs andinterval graphs are, respectively, [41] and . [28]. When jobs are of arbitrary lengths,Gandhi et el. [18] gave improved factors of . for line graphs, and of . for intervalgraphs. Also, Bar-Noy et al. [4] proposed a . -approximation factor for bipartite graphs andan O (log( | N | )) -approximation factor for perfect graphs. Other NP -hardness results can befound in [21, 32, 44]. Kubicka [39] derived a polynomial time algorithm for trees, and thiswas then generalized to graphs of bounded treewidth [33]. Other conflict graph classes ofproper intersection graphs of geometric objects (e.g. rectangles and disks) have been alsostudied in [10].To the best of our knowledge, exact methods for MinSum have been only proposedfor its special case of SCP. The first compact Integer Programming (IP) model was givenin [47], and its computational results together with another exponential-size IP model werethen studied in [17]. Very recently, Delle Donne et al. [14] have designed the first branch-and-price algorithm to solve the SCP, using the column generation technique.
MaxSum problem . As a special case of
MaxSum , the Knapsack problem is known to beweakly NP -hard and admits a PTAS [37]. For the case of unit jobs, the (weighted) MaxSum with T = 1 turns out to be equivalent to the (weighted) Maximum Independent Set, whichcannot be approximated to within a factor of n − ǫ , for any ǫ > , [30]. H`a et al. [25]showed that the problem is polynomially solvable when there are two machines and theconflict graph is bipartite. In terms of exact methods, they formulated two mixed integerlinear programming models to solve the problem in the general graph. We are not aware ofany other work done so far for MaxSum , except [25].
Other work.
We would like to mention that there is a number of articles in the literatureconcerning with scheduling problems of incompatible jobs, in the sense that they cannotbe performed on the same machine (see, for example [9, 38, 42]). This problem is totallydifferent from our problems studied in this paper.
MaxSum problem to optimality with MILP solvers. There are neither MILP nor CP models for the
MinMax and
MinSum problems. The lack of exact methods make the practically compu-tational hardness of the problems be an open question that is interesting to investigate. Tofill these gaps, we take the first step proposing and analysing in this research several math-ematical models and constraint programming models. In particular, we introduce two newmodels, a mixed integer linear programming and a constraint programming, for the
MaxSum problem. We also adapt existing and new models for the remaining problems. Using dedi-cated model solvers, we develop exact algorithms that can solve the problems to optimality.A binary search technique is also used to reduce the size of the MILP models proposedfor the
MinMax problem and to develop a new exact method. The performance of all theseexact methods is investigated on randomly generated problem instances and several usagerecommendations are provided. [ K ] = { , , . . . , K } be the set of positions that a job can be processed on a machine.The cardinality of this set can be determined as K = ⌊ Tp min ⌋ , where p min = min i ∈ J p i . Theformulation denoted by (F1) and uses the following variables: – x imk : binary variables set to if job i is done by machine m at k th position – s i : starting time of job i – z mk : the completion time of a job at k th position by machine m – y l : binary variables ( l = ( i, j ) ∈ C ) used to handle conflict constraint. It is set to if job i is finished before starting time of job j , and set to , otherwise.The MaxSum problem can be formulated as:(F1-
MaxSum ) Maximize X i ∈ J X m ∈ M X k ∈ K r i x imk (1)s.t. s i + p i ≤ T + B (1 − X m ∈ M X k ∈ K x imk ) ∀ i ∈ J (2) X m ∈ M X k ∈ K x imk ≤ ∀ i ∈ J (3) X i ∈ J x imk ≤ ∀ m ∈ M, k ∈ K (4) z m ( k − ≤ z mk ∀ m ∈ M, k ∈ K, k > (5) s i + p i ≤ z mk + B (1 − x imk ) ∀ i ∈ J, m ∈ M, k ∈ K (6) s i ≥ z m ( k − − B (1 − x imk ) ∀ i ∈ J, m ∈ M, k ∈ K (7) s i + p i ≤ s j + By l ∀ l = ( i, j ) ∈ C (8) s j + p j ≤ s i + B (1 − y l ) ∀ l = ( i, j ) ∈ C (9) x imk ∈ { , } ∀ i ∈ J, m ∈ M, k ∈ K (10) y l ∈ { , } ∀ l = ( i, j ) ∈ C (11) s i ∈ R + ∀ i ∈ J (12) z mk ∈ R + ∀ m ∈ M, k ∈ K (13)Objective function (1) is to maximize the number of complete jobs with priorities as highestas possible. Constraints (2) ensure the machine’s capacity when they enforce every job mustbe finished before T . Constraints (3) imply each job is processed on no more than one ma-chine at only one position while constraints (4) make sure that each machine can do at mostonce job at one position. Constraints (5) indicate a job must be complete after its prece-dence. Constraints (6) and (7) express the relationship among z -variables and the others.Conflict constraints are satisfied by constraints (8) and (9). Finally, Constraints (10)-(13)define variables’ domain. In this formulation, B is a very large number and can be estimatedby the summation of the capacity and the execution time of all jobs which have a conflictwith other jobs. The number of variables in (F1) is | J | . | M | . | K | + | J | + | M | . | K | + | C | , andthat of constraints is . | J | + 2 . | M | . | K | + | J | . | M | . | K | + 2 . | C | .The MinSum problem can be modeled as follows:(F1-
MinSum ) Minimize X i ∈ J w i s i (14)s.t. X m ∈ M X k ∈ K x imk = 1 ∀ i ∈ J (15) (4) − (13) Objective function (14) is to minimize the summation of the weighted start processingtime of all the jobs. This objective function is equivalent to the function minimizing theweighted completion time of all jobs. Indeed, the original objective function can be rewrittenas P i ∈ J w i ( s i + p i ) = P i ∈ J w i s i + P i ∈ J w i p i . Because the second term P i ∈ J w i p i is constant, we can remove it from the objective function without changing the optimalsolution. Constraints (15) ensure that each job must be processed at one position on exactlyone machine. Remaining constraints of the model are taken from formulation (F1- MaxSum ).To model the
MinMax problem, we use an additional variable T max representing thecompletion time of the latest job. The problem can be stated as follows:(F1- MinMax ) Minimize T max (16)s.t. T max ≥ p i + s i ∀ i ∈ J (17) (15) , (4) − (13) T max ∈ R + (18)Objective function (16) is to minimize the completion time of the latest job. Constraints (17)imply the relationship of variable T max with other variables in the model. Constraint 18defines the domain of variable T max . – x im : binary variables equal to 1 if job i is done by machine m – s i : starting time of job i – y ij : binary variables equal to 1 if job i is completed before starting time of job j The problem can be stated as:(F2-
MaxSum ) Maximize X i ∈ J X m ∈ M r i x im (19)s.t. s i + p i ≤ T + B (1 − X m ∈ M x im ) ∀ i ∈ J (20) X m ∈ M x im ≤ ∀ i ∈ J (21) s i + p i ≤ s j + B (1 − y ij ) ∀ i, j ∈ J, i = j (22) y ij + y ji ≥ x im + x jm − ∀ i, j ∈ J, i = j, m ∈ M (23) y ij + y ji ≥ ∀ ( i, j ) ∈ C (24) x im ∈ { , } ∀ i ∈ J, m ∈ M (25) s i ∈ R + ∀ i ∈ J (26) y ij ∈ { , } ∀ i, j ∈ J (27)Similarly to (F1), constraints (20) imply capacity requirements. Constraints (21) ensurethat each job is processed on no more than one machine. Constraints (22) express the rela-tionship between variables t and y . Constraints (23) say that if two jobs i and j are processedon the same machine, one job must be completed before starting time of another. They areused to avoid the overlap among jobs processed on the same machine. Conflict constraintsare assured by constraints (24). Constraints (25)-(27) define variables’ domain. Similarly to(F1), B in Constraints (21) and (23) is a very large number and can be estimated by thesummation of the capacity and the execution time of all jobs which have a conflict withother jobs. The number of variables in the formulation (F2) is | J | + | M | . | J | + | J | , whilethe number of constraints is | J | + | J | . | M | + | C | + 2 . | J | .Using this formulation, the MinSum problem can be formulated as:(F2-
MinSum ) Minimize X i ∈ J w i s i (28)s.t. X m ∈ M x im = 1 ∀ i ∈ J (29) (22) − (27) Objective function (28) is to minimize the weighted processing start time of all the jobs.Constraints (29) ensure that each job must be processed on exactly one machine. Remain-ing constraints of the model are taken from formulation (F2-
MaxSum ). The formulationproposed for the third problem is:(F2-
MinMax ) Minimize T max (30)s.t. (17) , (29) , (22) − (27) – s i : non-negative variable representing the start time of job i . – x imt : binary variable equal to one if and only if job i is processed at time t ( t ∈{ , ..., T } ) on machine m . – z i : true if and only if job i is scheduled.The MaxSum problem can be formulated as:(F3-
MaxSum ) Maximize X i ∈ J r i z i (31)s.t. X i ∈ J x imt ≤ ∀ m ∈ M, ∀ t ∈ { , ..., T } (32) X m ∈ M x imt ≤ ∀ i ∈ J, ∀ t ∈ { , ..., T } (33) X m ∈ M X t ∈{ ,...,T } x imt = p i z i ∀ i ∈ J (34) t − s i ≥ B ( X m ∈ M x imt − ∀ t ∈ { , ..., T } , ∀ i ∈ J (35) s i + p i − t − ≥ B ( X m ∈ M x imt − ∀ t ∈ { , ..., T } , ∀ i ∈ J (36) X m ∈ M ( x imt + x jmt ) ≤ i, j ) ∈ C, t ∈ { , ..., T } (37) x imt ∈ { , } ∀ i ∈ J, m ∈ M, t ∈ { , ..., T } (38) s i ∈ R + ∀ i ∈ J (39) z i ∈ { , } ∀ i ∈ J (40)Objective function (31) has the same meaning as functions (1) and (19). Constraints (32)ensure that on each machine and at a time there is at most one job is processed. Constraints(33) imply that at a time, each job is processed on at most one machine. Constraints (34)state that, if job i is scheduled, its total processing time must be equal to p i . The two nextconstraints have the meaning as follows: if a job is processed at time t , its start process-ing time must be less than or equal to t (Constraints 35) and its completion time must belarger or equal to t (Constraints 36). Constraints (37) indicate the conflict requirements. Theremaining constraints define the variables’ domains.In the two remaining problems, parameter T is not defined. However, it is necessaryfor the definition of variables x imt . Here, we estimate it by a trivial upper bound on thecompletion time of the latest job T = P i ∈ J p i .The MinSum problem is formulated as:(F3-
MinSum ) Minimize X i ∈ J w i s i (41)s.t. X m ∈ M X t ∈{ ,...,T } x imt = p i ∀ i ∈ J (42) (32) , (33) , (35) − (40) Constraints (42) state that the total processing time of job i is must be equal to p i . Finally,we can easily model the MinMax problem as follows:(F3-
MinMax ) Minimize T max (43)s.t. (17) , (32) , (33) , (35) − (40) (F1) (F2) (F3) O ( | J | . | M | . | K | + | C | ) O ( | J | + | M | . | J | ) O ( | J | . | M | .T ) O ( | J | . | M | . | K | + | C | ) O ( | J | . | M | + | C | ) O ( | M | .T + | J | T + | C | T ) Table 1: Comparison of three MILP models on their sizeAs can be seen in the table above, the number of constraints and variables in all threeformulations depends on the numbers of jobs | J | and machines | M | of the instance. How-ever, the size of MILP model based on formulation (F2) depends more on the number ofjobs because the numbers of constraints and variables in (F2) quadratically increase with | J | . The number of conflict job pairs | C | has a significant impact on the number of con-straints of all three formulations, but the impact is larger on the first formulation when thenumber of variables in (F1) also depends on | C | . The value of T , which is used to compute | K | , affects the size of formulations (F1) and (F3). In this section, we present constraint programming models for the problems. First, it is worthmentioning that unlike MILP formulations, there is no standard in CP formulation because itstrongly depends on each CP package. In this study, we formulate the models using generickeywords and syntaxes of IBM ILOG CP Optimizer [48]. Our model uses the followingvariables: – Itv i : interval variable that represents the time interval of size p i job i ∈ J is proceeded. – ItvAlt im : optional interval variable that represents the time interval machine m ∈ M proceeds job i ∈ J . – Seq m : sequence variable that represents all working time intervals of machine m ∈ M . The
MaxSum problem can be stated as:(CP-
MaxSum ) Maximize X i ∈ J r i presenceOf ( Itv i ) (44)s.t. alternative ( Itv i , ItvAlt im : m ∈ M ) ∀ i ∈ J (45) endOf ( Itv i ) ≤ T ∀ i ∈ J (46) noOverlap ( Seq m ) ∀ m ∈ M (47) (cid:0) endOf ( Itv i ) ≤ startOf ( Itv j ) (cid:1) OR (cid:0) endOf ( Itv j ) ≤ startOf ( Itv i ) (cid:1) ( i, j ) ∈ C (48)The objective function is represented by (44). Constraints 46) are the capacity con-straints. Next, constraints (47) make sure that jobs processed on each machine are not over-lapped while the conflict constraints are ensured by constraints (48). Here, the no-overlapconstraint noOverlap ( s ) on a sequence variable s states that permutation s defines a chainof non-overlapping intervals, any interval in the chain being constrained to end before thestart of the next interval in the permutation.In MinSum and
MinMax problems, all the jobs must be processed, the variable
Itv i ( i ∈ J ) is therefore not optional. The problems are formulated as follows:(CP- MinSum ) Minimize X i ∈ J w i startOf ( Itv i ) (49)s.t. (45) , (47) , (48) (CP- MinMax ) Minimize max i ∈ J endOf ( Itv i ) (50)s.t. (45) , (47) , (48) MinMax problem
As analysed above, the number of variables and constraints in formulations (F1) and (F3)heavily depends on the completion time of the latest job T . For the MinMax problem withthe min-max objective function, we can perform the binary search to reduce the size of T as presented in Algorithm 1. Let T UB and T LB denote an upper bound and a lowerbound of T . Recall that the upper bound for any instance can be computed as T UB = P i ∈ J p i . As a result, the lower bound T LB can be estimated trivially as T LB = ⌈ T UB m ⌉ .These bounds provide an initial interval for the binary search. The algorithm then iterativelysolves model (F1- MinMax ) or (F3-
MinMax ) with T = T MID representing the middle of thecurrent search interval. If a feasible solution S with the gap returned by MILP solver lessthan a given threshold γ is found, the upper bound is updated to obj ( S ) − , since now it isknown that a solution with objective value obj ( S ) can exist, but it is not known if a solutionwith less completion time exists yet. If no feasible solution is found, the lower bound is set to T MID + 1 , as there cannot exist any solution with the completion time less than T MID + 1 .After the loop, the algorithms simply returns the last solution found. This is sufficient, asthe final iteration of the algorithm already proved that any solution with one less unit of thecompletion time cannot exist.It is worth mentioning that the value of γ has a significant impact on the convergencespeed of the algorithm. If γ is set to a relatively large number, the running time of an iterationwould be quick, but the number of iterations could be very large. On the other hand, if γ is set to a small value, e.g,. γ is set to 0 corresponding to the case where the MILP modelsmentioned in Line 5 of Algorithm 1 are required to be solved to optimality, we can stopthe search process as soon as the problem at an iteration is successfully solved. In this case,the required number of solved MILP models is the least, but the running time required toprocess each iteration could be very large. Therefore, the value of γ needs to be carefullyselected so that we get a good trade-off between the number of required iterations and therunning time spent at each iteration. By experiment, γ is set to 10% in this study. Algorithm 1:
Binary Search Algorithm T UB ← P i ∈ J p i ; T LB ← ⌈ T UB m ⌉ ; while T LB ≤ T UB do T MID = ⌊ ( T UB + T LB ) / ⌋ ; Solve the corresponding formulation (F1-
MinMax ) with K = ⌊ T MID p min ⌋ or(F3- MinMax ) with T = T MID ; if a feasible solution S is found then T UB ← obj ( S ) − ; end else T LB ← T MID + 1 ; end end return S ; In this section, we discuss all our computational experiments with the models and solutionmethods proposed above. All algorithms described in this paper are implemented in C++.The MILP models are solved using CPLEX 12.10.0 and the CP model is solved with CPOptimizer 12.10.0. All the experiments are done on a CPU with AMD Ryzen 7 3700X 3.6Ghz, running on Windows 10. To make ease for the result reproduction, we use a singlethread to solve the models. For a fair comparison, all the methods are managed to run in atime limit of 1 hour on each instance.A total of 432 instances are created using a procedure partly similar to the one proposedin [25]. They are randomly generated with following parameters: – The number of jobs | J | is set to {
16, 24, 32 } – The number of machines | M | is set to {
2, 4, 6 } – For the
MaxSum problem, the capacity T is set to {
10, 20, 40, 80 } . – The priority of each job i is set to a random integer from 1 to 5. – The weight of each job i is set to a random integer from 1 to 5. – Two jobs are consecutively considered as conflict with each other in a random fashionuntil the number of conflict pairs is equal to α.n where α is the conflict rate and setto one of four values { , , , } . This is generated such that conflict jobs of larger α include those of smaller α . – The processing time of each job is a random integer from ⌈ T / ⌉ to ⌊ T / ⌋ (setting 1),from 1 to ⌊ T / ⌋ (setting 2), and from 1 to ⌊ T / ⌋ (setting 3), where T in all three prob- lems is set to {
10, 20, 40, 80 } . We note that, for the MinSum and
MinMax problems, weuse the machine capacity T from the MaxSum to create the processing time of each job.To investigate the impact of the instances’ characteristics on the performance of themodels, we report the average values of comparison criteria for each group of instancesdepending on the number of jobs, the number of machines, the machine capacity, the conflictrate, and the processing time settings. Three main criteria used for the comparison are: therunning time in seconds (Time), the gap between the best lower and upper bounds (Gap),and the number of instances solved to optimality (Opt).6.1 Results for the
MaxSum problemWe compare four formulations: (F1-
MaxSum ), (F2-
MaxSum ), (F3-
MaxSum ), and (CP-
MaxSum )on the instances of
MaxSum problem. The results are presented in Table 2. We can deriveseveral observations as follows: – In overall, CP performs the best when it can solve to optimality 397 over 432 instances,followed by (F3), (F1), and (F2) with 370, 237, and 198 successfully solved instances,respectively. We also note that there are three cases where (F3) can solve more instancesto optimality than (CP): the instances with 16 jobs and those with machine capacityequal to 10 or 20. – The performance of all the formulations tends to decrease when the number of jobsincreases. Formulation (F2) is the most affected. When the number of jobs increasesto 32, the number of successfully solved instances of (F2) is the least. This could beexplained by the fact that the number of variables and constraints of (F2) is a quadraticfunction of the number of jobs. – The performance of (F3) and (CP) is better when the number of machines is small.However, formulation (F2) tends to work better when the number of machines increases.The impact of the number of machines on the performance of (F1) is not really clear. – The machine capacity has less impact on the performance of formulations (F1), (F2),and (CP). But the high values of the capacity lead to significant reduction on the numberof successfully solved instances for formulation (F3). This phenomenon is predictablebecause the number of variables and constraints of (F3) depends on the machine capac-ity. – Although the number of constraints of all formulations increases when the conflict rateincreases, the performance of the four formulations is insensitive with the conflict rate.Except for formulation (F1), when the conflict rate is set to the highest value, the num-ber of successfully solved instances drastically reduces. This could be due to the factthat only in formulation (F1), the number of variables increases when the conflict rateincreases. – Setting 3 of the processing time tends to be easier to solve than the others for the MILPformulations. On tested instances, the performance of CP is insensitive to the processingtime settings.6.2 Results for the
MinSum problemTable 3 reports the results for the
MinSum problem. We derive several observations as fol-lows: Instance F1 F2 F3 CPTime Gap Opt Time Gap Opt Time Gap Opt Time Gap OptNumber of jobs16 1592.5 0.0942 85 495.3 0.0095 130 290.0 0.0019 138 275.816 0.0076 13324 2111.2 0.1498 67 1973.6 0.1939 70 799.3 0.0188 119 197.816 0.0009 13832 2482.1 0.2526 46 2694.7 0.4690 37 1004.9 0.0465 113 500.618 0.0043 126Number of machines2 2194.4 0.2327 64 2198.8 0.4708 59 315.2 0.0014 141 75.931 0.0024 1414 2236.7 0.1536 58 1694.4 0.1419 80 799.4 0.0255 118 366.145 0.0042 1316 1754.7 0.1103 76 1270.4 0.0597 98 979.6 0.0402 111 532.173 0.0062 125Machine capacity10 2288.6 0.2084 42 1943.0 0.2353 53 51.5 0.0000 108 191.127 0.0062 10320 2123.2 0.1408 49 1722.5 0.2166 59 262.6 0.0025 101 415.218 0.0023 9740 1954.1 0.1691 53 1618.4 0.2313 63 823.1 0.0212 90 359.349 0.0051 9880 1881.8 0.1438 54 1601.0 0.2134 62 1655.0 0.0657 71 333.306 0.0035 99Conflict rate1 1920.7 0.1454 52 1860.0 0.2835 55 577.2 0.0066 95 287.626 0.0016 1002 1800.8 0.1388 57 1622.0 0.2497 61 555.7 0.0067 96 409.446 0.0030 974 1754.9 0.1242 61 1422.1 0.1898 66 734.7 0.0137 92 233.812 0.0023 1038 2771.4 0.2537 28 1980.7 0.1735 55 924.6 0.0625 87 368.116 0.0101 97Processing time settings1 2589.3 0.2075 48 2306.3 0.4699 57 911.1 0.0310 114 531.768 0.0046 1262 3071.5 0.2782 25 2181.9 0.1834 63 1057.8 0.0361 112 167.461 0.0006 1383 525.0 0.0109 125 675.3 0.0192 117 125.2 0.0000 144 275.021 0.0076 133Total 2061.9 0.1655 198 1721.2 0.2241 237 698.0 0.0224 370 324.750 0.0043 397
Table 2: Comparison of different formulations for the
MaxSum problem
Instance F1 F2 F3 CPTime Gap Opt Time Gap Opt Time Gap Opt Time Gap OptNumber of jobs16 2821.8 0.3322 32 2015.2 0.1953 68 2942.7 0.5881 28 1566.780 0.3686 8724 3520.5 0.5246 4 3304.3 0.4507 14 3297.1 0.7779 13 2877.710 0.6860 3632 3600.0 0.6824 0 3600.0 0.6427 0 3354.7 0.8130 11 3600.001 0.9591 0Number of machines2 3580.0 0.7094 1 3493.5 0.6320 6 3213.7 0.7323 17 3199.712 0.8320 204 3329.8 0.4902 11 3031.2 0.3984 26 3229.0 0.7347 15 2575.574 0.6370 466 3032.5 0.3397 24 2394.8 0.2583 50 3151.8 0.7082 20 2269.203 0.5447 57Machine capacity10 3241.6 0.5095 12 2963.1 0.4336 21 2452.7 0.4973 36 2715.167 0.6935 2920 3369.0 0.5114 7 2957.1 0.4278 21 3194.7 0.6644 13 2603.880 0.6543 3340 3276.0 0.5202 10 3021.0 0.4375 19 3549.1 0.8387 2 2666.044 0.6575 3280 3369.8 0.5112 7 2951.5 0.4193 21 3596.0 0.9098 1 2740.896 0.6796 29Conflict rate1 3600.0 0.6718 0 3191.4 0.5689 13 3138.8 0.6773 15 2992.671 0.7465 212 3368.6 0.4972 7 2891.9 0.4269 23 3192.4 0.7253 13 2671.296 0.6581 304 2737.2 0.3579 27 2312.7 0.2880 42 3203.4 0.7601 13 1896.029 0.4837 538 3550.5 0.5254 2 3496.7 0.4344 4 3258.0 0.7376 11 3165.990 0.7967 19Processing time settings1 3362.4 0.5313 10 3047.6 0.4622 23 3583.0 0.8852 1 2891.071 0.7552 302 3328.7 0.5061 11 2933.7 0.4036 30 3594.8 0.8449 1 2558.680 0.6115 473 3251.2 0.5018 15 2938.2 0.4229 29 2416.6 0.4517 50 2594.739 0.6470 46Total 3314.1 0.5131 36 2973.2 0.4296 82 3198.2 0.7252 52 2681.497 0.6712 123
Table 3: Comparison of different formulations for the
MinSum problem – In overall, CP still performs the best when it can solve to optimality 123 over 432 in-stances. The worst formulation is (F1). Formulation (F2) overcomes (F3) to become thesecond best formulation in terms of the number of successfully solved instances. Formu-lation (F3) can solve more instances to optimality than (CP) in two cases: the instanceswith 32 jobs and the ones with the third processing time setting. – The performance of all the formulations tends to decrease when the number of jobsincreases. Formulation (F3) can solve 11 instances of 32 jobs to optimality, while threeformulations (F1), (F2), and (CP) fail to close the gaps for all these instances. – Unlike the first problem, the performance of (F1), (F2) and (CP) for the second problemis better when the number of machines increases. The impact of the number of machineson the performance of (F3) is not really clear. – The machine capacity has less impact on the performance of formulations (F1), (F2),and (CP). But the high values of the capacity lead to significant reduction on the numberof successfully solved instances for formulation (F3). This phenomenon is predictablebecause the number of variables and constraints of (F3) depends on the machine capac-ity. This observation is similar to the first problem. – The performance of (F3) is insensitive with the conflict rate for (F3). For three remainingformulations, the instances with conflict rate α = 4 seem to be the easiest. – Setting 3 of the processing time tends to be easier to solve than the two other settings forformulations (F1) and (F3) whose number of variables and constraints rapidly increaseswhen the value of T max is higher. The performance of (F2) and (CP) is insensitive tothe processing time setting.6.3 Results for the MinMax problemWe now compare the exact methods based on the four formulations: (F1-
MinMax ), (F2-
MinMax ), (F3-
MinMax ), and (CP-
MinMax ); and the two methods based on the binary search(F1-BS) and (F3-BS). The obtained results are shown in Table 4 where Columns “Iter” reportthe number of iterations the search is performed in the binary search algorithms.From Table 4, several observations are derived as following: – The binary search algorithms significantly improve the original formulations. The CPformulation is still the best, followed by (F1-BS) and (F3-BS) in terms of the number ofinstances solved to optimality. However, we also observe that (F3-BS) is better then (CP)on instances with one of two characteristics: n = 16 or T = 10 while (F1-BS) performsbetter than (CP) on instances with conflict rate set to 1. Among the three methods basedon the pure MILP formulations, our new model (F3) is the dominant, followed by (F2)and (F1). Although formulation (F1) performs worse than formulation (F3), the F1-based binary search algorithm can solve more instances than the algorithm based on(F3). – The number of jobs increases, the performance of MILP-based methods (including bi-nary searches) decreases. The (CP) model is less dependent on the number of jobs. – Four methods (F3), (CP), (F1-BS), and (F3-BS) can solve more instances with the leastnumber of machines that is equal to 2. The performance of two formulations (F1) and(F2) increases when the number of machines increases. – The performance of (F1) and (F2) is insensitive with the machine capacity. The re-maining methods can solve more instances to optimality when the machine capacity issmaller. – The increase in the number of conflict jobs leads to harder instances for methods (CP),(F1-BS), and (F3-BS). The instances with more conflict jobs require more iterations tosolve for the two binary search methods. The impact of the conflict rate on three pureMILP methods is less clear. Instance F1 F2 F3 CP F1-BS F3-BSTime Gap Opt Time Gap Opt Time Gap Opt Time Gap Opt Time Iter Gap Opt Time Iter Gap OptNumber of jobs16 2333.9 0.2769 51 2146.8 0.2283 60 1204.4 0.1679 100 908.356 0.2025 108 969.6 3.1 0.1611 107 966.948 3.410 0.2281 10924 2990.1 0.3262 31 2556.6 0.2833 45 2316.1 0.4294 56 701.881 0.0893 117 1885.7 2.8 0.0943 80 1995.529 1.958 0.8878 6832 3556.8 0.4837 3 3198.4 0.4378 21 2694.0 0.5517 42 991.753 0.1502 105 2054.2 2.5 0.0788 67 2207.820 1.882 1.1087 60Number of machines2 3600.1 0.6038 0 3600.1 0.5636 0 2165.3 0.4015 65 507.402 0.1079 124 1137.5 2.6 0.0742 100 1631.355 2.313 0.1360 824 3115.8 0.3236 22 2620.9 0.2677 44 2101.5 0.3956 63 1080.833 0.1924 101 1944.2 2.6 0.1047 75 1808.256 2.313 0.7400 766 2164.8 0.1595 63 1680.9 0.1182 82 1947.7 0.3518 70 1013.755 0.1418 105 1827.9 3.3 0.1554 79 1730.686 2.625 1.3487 79Machine capacity10 2991.6 0.3950 20 2746.5 0.3454 29 882.7 0.0819 88 511.508 0.0963 93 1282.0 2.1 0.1128 76 455.089 2.019 0.1439 9720 2914.5 0.3595 22 2593.7 0.3160 32 1860.7 0.3059 55 838.071 0.1496 83 1364.0 2.5 0.1129 72 1513.904 2.435 0.3693 6640 2940.2 0.3519 22 2656.2 0.3078 32 2437.7 0.4914 37 954.645 0.1661 80 1859.1 3.1 0.1188 57 2195.810 2.546 0.9914 4580 2994.7 0.3427 21 2539.3 0.2967 33 3104.9 0.6527 18 1165.095 0.1775 74 2041.0 3.6 0.1010 49 2728.927 2.667 1.4617 29Conflict rate1 3207.9 0.4434 12 3173.3 0.4233 13 1914.0 0.3359 55 634.180 0.0745 89 506.0 2.3 0.0033 96 1438.842 1.833 0.4285 672 2910.2 0.3540 21 2722.3 0.3293 28 1913.7 0.3673 54 622.403 0.0761 90 1023.2 2.7 0.0087 82 1501.743 2.074 0.5299 684 2442.2 0.2518 37 2119.8 0.2204 46 2324.3 0.4015 43 616.228 0.0949 90 1513.2 3.4 0.0210 67 1965.017 2.241 0.6854 528 3280.6 0.4000 15 2520.4 0.2929 39 2133.9 0.4272 46 1596.509 0.3440 61 3503.7 2.9 0.4126 9 1988.128 3.519 1.3225 50Processing time settings1 3099.3 0.3894 21 2779.7 0.3483 36 2833.3 0.5840 34 1275.793 0.2153 94 2040.3 3.1 0.1367 69 2500.681 2.486 1.0661 472 2823.3 0.3202 35 2544.1 0.2792 45 2361.2 0.4472 55 847.179 0.1305 111 1625.5 3.3 0.0784 84 2053.826 2.604 0.9771 673 2958.1 0.3772 29 2578.0 0.3220 45 1019.9 0.1178 109 479.017 0.0964 125 1243.7 2.1 0.1192 101 615.790 2.160 0.1815 123Total 2960.2 0.3623 85 2633.9 0.3165 126 2071.5 0.3830 198 867.330 0.1474 330 1636.5 2.8 0.1114 254 1723.433 2.417 0.7416 237 T a b l e : C o m p a r i s ono f d i ff e r e n t m e t hod s f o r t h e M i n M a x p r ob l e m – F3-based methods can solve more instances with the setting 3 of the processing time.The impact of the processing time settings on the performance of the other methods isnot clear.6.4 Other discussionsWe now discus the hardness of the three problems based on the performance of the algo-rithms. Surprisingly, the min-max objective function which has a non-linear characteris-tic does not make the
MinMax problem the most challenging. Among three problems, the
MinSum problem is the most difficult for the proposed methods, followed by the
MinMax and
MaxSum .In terms of the performance on the three problems, (CP) is in overall the best when it cansolve more instances of all the problems than other methods. Among MILP-based instances,our new formulation (F3) performs better than two existing formulations (F1) and (F2) interms of the number of solved instances.Although (CP) dominates other formulations, we also note that there are a number ofinstances that (CP) cannot solve to optimality while the MILP-based methods can. As can beseen in Table 5, all the formulations can provide optimal solutions on several instances that(CP) cannot close the gaps. More precisely, (F1) and (F2) can solve 2 and 3 instances of the
MinSum problem that are not solved to optimality by (CP). In particular, (F3) can performbetter than (CP) on instances of all problems. Therefore, for the
MaxSum and
MinSum problems, we recommend to use in practice the (CP) and (F3) models for exact methods.For the
MinMax problem, the algorithms based on (CP), (F1-BS), and (F3-BS) could beselected options.
MaxSum MinSum MinMax
F1 0 2 0F2 0 3 0F3 23 30 40F1-BS 10F3-BS 50
Table 5: The number of instances MILP-based methods can solve to optimality while CPcannot
We study in this paper a class of three scheduling problems where some jobs cannot bescheduled concurrently on different machines:
MaxSum , MinSum , and
MinMax . We proposetwo new models based on mixed integer linear programming and constraint programmingfor the
MaxSum problem and adapt these models and two other existing ones for the
MinSum and
MinMax problems. Corresponding solvers are used to solve the models to optimality,leading the first exact methods proposed for the problems. In addition, binary search-basedexact algorithms also are developed for the
MinMax problem. Results of experiments carriedout on instances with up to 32 jobs and 6 machines are reported and analysed. The perfor-mance of new models is clearly better than that of existing models in terms of the number of instances solved to optimality. The binary search algorithms for the MinMax problem alsoshow their effectiveness.The research perspectives are numerous. The MILP formulations could be strengthenwith additional valid inequalities or optimality cuts to develop efficient branch-and-cut al-gorithms. Metaheuristics could also be developed to provide good solutions for larger in-stances in short computation time. Finally, other variants of scheduling problems (e.g., flowshop, job shop) with the conflict constraint are interesting topics for other researches.
Acknowledgment
This work has been supported by Phenikaa University.
References