universite saad dahlab de blida - Université Saad Dahlab de Blida

Transcription

Ordonnancement dans les ateliers. Cours donné par le Dr. DERBALA Ali
3. Minimizing Mean Flowtime And Weignted Mean Flowtime.
Consider the problem of minimizing F . Adopt the following notation :
p i[j] : processing time of the j th job in sequence on the i th machine
Fi[j] : flowtime of the j th job in sequence on the i th machine
ni : number of jobs processed by the i th machine, then the objective function is :
n
n
1 m i
1 m i
F = ∑ ∑ Fi[ j] = ∑ ∑ ( n i − j + 1) p i[ j] .
n
n
i =1 j=1
i =1 j=1
An algorithm 5.3 is given for Minimizing F with parallel machines[Bak74].
Except for ties, this algorithm will produce a unique schedule.
ID
A
*) This algorithm is a dispatching procedure, so that scheduling decisions can be implemented
in the order that they are made. It can be extended to the case of arrival pattern of jobs.
BL
*) No direct algorithm has been developed for constructing an optimal schedule when F w is
E
the criterion.
D
Dynamic programming formulations are possible, but the « curse of dimensionality » renders
B
the procedure impractical for problems of even moderate size. Any optimal solution must
LA
have WSPT job orderings at each machine. A lower bound on the optimum of
F w can be
computed, as shown by Eastman, Even and Isaacs[Eas64]. Let
D
A
H
B(1) : the minimal value of F w for the given job set if there were only one machine
( obtained via WSPT)
D
B(n) : the minimal value of F w for the given job set if there were n machines ( obtained by
B(m) =
SA
A
assigning each job to a different machine ) then a lower bound for m machines (1 ≤ m ≤ n) is
1
[ ( m - 1 ) B(1) + 2 B (n) ] ;
2m
SI
TE
B = Max {B(m), B(1)} is also a valid lower bound and may be better.
A procedure denoted Hm is given.
In the case where the machines are identical, the second subscript can be omitted from pij
ER
and
IV
p ij = pi. One could renumber the n jobs in order of increasing processing-time :
N
p 1 ≤ p 2 ≤ ...≤ pn .Then one could number the machines and simply assign jobs in rotation :
U
Job
Machine
1 2 ...
m
M+1 m + 2 ... 2m
1
m
1
Parallel processor scheduling
2 ...
113
2
... m
2m + 1 ......
1
The rule would simply be that each time a machine finished a job, it would be assigned, from
among those jobs waiting, the job with the shortest processing time. This rule minimizes the
mean flow time, mean waiting time, and mean lateness.
Interchange of jobs in equivalent positions in sequence on different machines has no effect on
the mean flow time. However, this shortest processing time rule does not necessarily
minimize the maximum flow time and the mean number of jobs in the shop[Con67].
∑Cj
BL
Problem P //
ID
A
3.1 . Identical Processors[Bla94]
In the case of identical processor and equal ready times, preemptions are not profitable from
E
the viewpoint of the value of the mean flow time [McN59]. Thus we consider only non-
D
∑ C j , one might expect that,
B
preemptive schedules. When analyzing the nature of criterion
LA
as in the case of one processor, by assigning tasks in non-decreasing order of their processing
times the mean flow time will be minimizing. A proper generalization of this simple rule
H
∑ C j [Con67]. It is as follows.
A
leads to an optimization algorithm for P //
D
Algorithm 11. SPT rule for problem P //
∑ C j [Con67].
ER
SI
TE
SA
A
D
begin
Order tasks on list L in non-decreasing order of their processing times ;
while L ≠ ∅ do
begin
Take the m first tasks from the list ( if any ) and assign theses tasks arbitrarily to the
m different processors ;
Remove the assigned tasks from list L ;
end ;
Process tasks assigned to each processor in SPT order ;
end ;
___________________________________________________________________________
IV
The complexity of the algorithm is O(nlogn).
N
Introducing different ready times makes the problem strongly NP-hard even for the case of
U
one processor[Len77]. Also if we introduce different weights, the 2-processor problem
without release times, P2 //
∑ w j C j , is already NP-hard[Bru74].
114
Problem P / pi = 1 ; ri ; di /
∑ C j [Bru95]
The same results and algorithm of the Problem P / pi = 1 ; ri ; di / Cmax hold when the
∑ C j [see part 2, makespan criterion].
Problems P / pi = 1 /
∑ wi C j
and P / pi = 1 ; pmtn /
∑ w i C j [Bru95]
A
objective function is
∑ w i C i by scheduling the jobs in order
of non-increasing weights wi. An optimal schedule for P / pi = 1 / ∑ wi Ci is optimal even if
BL
I
D
We get an optimal schedule for problem P / pi = 1 /
preemption is allowed.
E
∑ w i C i , there exists an optimal schedule without preemption.
D
For P / pmtn /
H
∑Cj
A
Problem P / prec /
∑ w i Ci
LA
P2 / / ∑ w i C i ; P2 / pmtn, ri / ∑ w i C i and P2 / pmtn /
B
The following problems are NP-hard :
D
Let us pass to the case of dependent tasks. Here, P / out-tree, pj = 1 /
∑Cj
is strongly
A
D
adaptation of Hu’s algorithm to the out-tree case, and P / prec, pj = 1 /
∑ C j is solved by an
SA
NP-hard
[Len78]. In the case of arbitrary processing times recent results by Du et al [Du91] indicate
TE
that even simplest precedence constraints result in computational hardness of the problem.
SI
That is problem P2 / chains /
∑Cj
is already NP-hard in the strong sense. It was also
ER
proved in [Du91] that preemption cannot reduce the mean weighted flow time for a set of
∑ C j is also NP-hard in the strong
IV
chains. This implies that the problem P2 / chains, pmtn /
N
sense. No approximation algorithms for these problems are evaluated from their worst-case
U
behavior.
Problem P / pj = 1; out-tree /
∑ C j [Pin95]
The special case of precedence constraints of out-tree and all processing times equal to one
can be solved in polynomial time. The CP ( critical path ) rule is the highest level first rule .
It is optimal for P / pi = 1; out-tree /
∑ C j . The CP rule is, not necessarily optimal for in-
trees.
115
Problem P / pj = 1; Mj /
∑ C j [Pin95]
Another problem that is of practical interest arises when job j is only allowed to be processed
on subset Mj of the m machines in parallel is P / pi = 1 ; Mj /
∑Cj
problem. Assume that
the set Mj is nested ( see 211. ).
Under these conditions, the least flexible job first ( LFJ ) rule is of importance. The LFJ rule
A
selects, every time a machine is freed, the job that can be processed on the smallest number of
ID
machines, that is the least flexible job. Ties may be broken arbitrary.
∑Cj
when the Mj sets are nested [Pin95].
D
E
The LFJ rule is optimal for P / pi = 1 ; Mj /
BL
If the set Mj sets are nested, the LFJ rule is optimal.
B
3.2. Uniform and Unrelated Processors
LA
Scheduling dependent tasks on uniform or unrelated processors is NP-hard problem in
general. No approximations algorithms have been investigated either. On the other hand, in
D
∑Cj
D
Problem Q //
A
H
the case of independent tasks, preemption may be worth-while.
A
Let us start with uniform processors and non-preemptive schedules. In this case the flow time
SA
has to take into account processor speed ; so the flow time of task Ti[k] processed in the k
TE
1
position on processor Pi is defined as F i[ k ] =
bi
ki
∑
p i[ j ] .
j =1
SI
mi
ER
Let us denote by ni the number of tasks processed on processor Pi . Thus, n =
U
N
IV
1
The mean flow time is then given by F =
n
th
∑
i =1
m
∑
i =1
1
bi
ni .
ni
∑
k =1
( n i − k + 1) p i[ k ] .
The numerator of this formula is the sums of n terms each of which is the product of a
processing time and one of the following coefficients :
1
1
1 1
1
1
1
1
1
n1 , ( n1 − 1) , ...,
n 2 ,...,
(n2 − 1) ,...,
nm ,
(nm − 1) ,. .,
,
, ...,
.
b1
b1
b1 b2
b2
b2
bm
bm
bm
116
It is shown in [Con67] that such a sum is minimized by matching n smallest coefficients in
non-decreasing order with processing times in non-increasing order. This rule is an O(nlogn)
implementation given by Horowitz and Sahni[Hor76]
Assume that i1, i2,..., ir is the sequence of jobs to be processed on machine Mj. Then the
contribution of these jobs on machine Mj in the objective function is given by :
p
p
p
r
r -1
1
i
+ i
+....+ i
1 s
2 s
r s
j
j
j
To find an optimal distribution of jobs to machines we may proceed as follows. Let
k
, then schedule job i on machine Mj as the k-th last job because we assume
sj
B
If ti =
E
1 1
1 2 2
2 3 3
3
,
, ... ,
, ,
, ... ,
, ,
, ... ,
, ....}.
s1 s 2
s m s1 s 2
s m s1 s 2
sm
D
{
BL
I
t1 , t2 , ..., tn be a non-decreasing sequence of the n smallest numbers in the set
D
non-decreasing processing requirements pi.
A
This implies that in an optimal schedule the jobs on machine Mj are sequenced according to
LA
p1 ≥ p2 ≥ ... ≥ pn . These ideas lead to the following algorithm in which, for j = 1,..., m, we
H
denote by Πj the sequence of jobs currently scheduled at machine Mj.
A
___________________________________________________________________________
For j = 1 to m do
1
; END;
sj
SA
Begin Πj : = ∅ ; wj =
∑Cj
A
D
D
Algorithm 12 . Problem Q //
TE
For i : = 1 to n do
Begin
Find the largest index j with wj =
min
υ =1,.., m
1
sυ
ER
SI
Πj : = i ο Πj ;
1
wj : = wj +
sj
N
IV
END
___________________________________________________________________________
Each w-value can be calculated in O(logm ) time if we use a priority queue. Thus, the overall
U
complexity is O(nlogm) if the pi -values are sorted. Otherwise, we have a total complexity of
O(nlogn) if n > m.
Next we will consider the preemptive version of this problem.
117
Problem Q / pmtn /
∑Cj
In the case of preemptive scheduling, it is possible to show that there exists an optimal
schedule for Q / pmtn /
∑Cj
in which Cj ≤ C k if pj < pk. The following algorithm has
been proposed by Gonzales[Gon77].
Algorithm 13. Algorithm by Gonzalez for Q / pmtn /
∑Cj
[Gon77].
LA
B
D
E
BL
ID
A
Begin
Order processors in non-increasing order of their processing speed factors ;
Order tasks in non-decreasing order of their standard processing times ;
for j = 1 to n do
begin
Schedule task Tj to be completed as early as possible, preemptive when necessary ;
-- tasks will create a staircase pattern « jumping » to a faster processor
-- whenever a shorter task has been finished
end ;
end ;
___________________________________________________________________________
H
The complexity of this algorithm is O(n logn + m n ).
A
In [Pin95], the SRPT-FM rule is considered. It is the Shortest remaining processing time on
D
the fastest machine first rule. This rule assigns at any time the job with the shortest remaining
D
processing time among the remaining jobs to the fastest machine ; the job with the second
SA
A
shortest remaining processing time to the second fastest machine, and so on. It usually
requires a number of preemptions equal to the number of remaining jobs. There exists an
optimal schedule for
∑Cj
in which Cj ≤ C k if pj < pk.
TE
Q / pmtn /
∑ C j [Pin95].
ER
SI
SRPT-FM rule yields an optimal schedule for Q / pmtn /
∑Cj
IV
Problem R / /
U
N
An approach to the solution of this problem is based on the observation that task
Tj ∈ { T1, .., Tn } processed on Processor Pi ∈ { P1, .., Pm } as the last task contributes its
processing time pij to F . The same task processed in the last but one position contributes 2 pij
and so on[Bru74] This reasoning allows one to construct an ( m n ) x n matrix Q presenting
118
contributions of particular tasks processed in different positions on different processors to the
value of F . The problem is to choose n elements from matrix Q such that
-- Exactly one element is taken from each column,
-- at most one element is taken from each row,
-- the sum of selects elements is minimum.
It is a variant of the assignment problem which may be solved using Branch and Bound
method. It can be solved in O(n3) time [Bru74].
∑Cj
is still an open problem.
A
The complexity of problem R / pmtn /
ID
3.3. Complexity Results
BL
We summarize scheduling problems complexity with jobs to be processed on parallel
Complexity
Author(s) and date
D
Problems polynomially
E
machines and flow time and mean flow time criteria. .
A
Bruno et al ( 1974)
SA
ER
Problems NP-hard
∑ wi Ci
IV
Gonzalez ( 1977) .
D
O(n logn + m n )
O(n3)
P2 / pmtn ; ri /
//
A
D
∑Cj
∑Cj
P2 / /
McNaughton(1959)
polynomial
SI
TE
R//
Simons ( 1983)
O(nlogn)
∑ wi Ci
P / pi = 1/ pmtn / ∑ wi Ci
P / pi = 1/
Q / pmtn /
O(n3 log log n)
LA
∑Cj
H
P / pi = 1 ; ri ; di rational /
B
Solvable
∑ Ci
N
∑ wi Ci
P2 / prec ; pi / ∑ Ci
Author(s)
Bruno et al ( 1974)
Due et al ( 1988)
Bruno et al ( 1974)
U
P2 / pmtn /
Lenstra & Rinnooy Kan ( 1978)
119
4. Minimizing Due Date Involving Criteria
41. Identical processors ( Bla94 )
Single processor problems with due dates that allow for simple algorithms usually have as
objective the maximum lateness ; for example, 1 // Lmax ; 1 / prmp / Lmax ; 1 / rj , prmp / Lmax.
However, single machine problems with the sum of the tardinesses or the sum of the weighted
tardiness as objectives are NP-hard in most cases. P m // Lmax is not as easy as 1 // Lmax.
Consider the special case where all jobs have due date 0. Finding a schedule with a minimum
Lmax is equivalent to the P m // Cmax problem and is a problem NP-hard [Pin95].
We concentrate on minimization of Lmax criterion. In this case, the general rule should be to
A
schedule tasks according to their earliest due dates. This simple rule of Jackson [Jac55]
ID
produces optimal schedules under very restricted assumptions only. In other cases more
BL
sophisticated algorithms are necessary, or the problems are NP-hard.
E
Problem P // Lmax
D
We consider nonpreemptive scheduling of independent tasks. Taking into account simple
B
transformations between scheduling problems and the relation-ship between the Cmax and Lmax
LA
criteria, all the problems that are NP-hard under the Cmax criterion remain NP-hard under Lmax
H
criterion. Hence, for example, P 2 // Lmax is NP-hard. On the other hand, unit processing
A
times of tasks made the problem easy, and P / pj = 1, rj / Lmax can be solved in polynomial
D
time by an application of EDD rule [Bla77] It can be solved by an extension of the single
D
processor algorithm[Gar81]. Unfortunately very little is known about the worst-case behavior
Problem P / pmtn / Lmax
SA
A
of approximation algorithms for the NP-hard problems in question.
TE
The preemptive mode of processing makes the solution of the scheduling problem much
easier.
ER
SI
~
The fundamental approach in that area is testing feasibility of problem P / pmtn, rj , d j / - via
the network flow approach [Hor74]. Using this approach repetitively, one can then solve the
N
IV
original problem P / pmtn / Lmax by changing due dates ( deadlines ) according to a binary
search procedure. Finding a feasible flow pattern corresponds to constructing a feasible
U
schedule and this test can be made in O(n3) time.
A schedule is constructed on the basis of flow values on arcs between interval and task nodes.
In the next step a binary search can be conducted on the optimal value of Lmax , with each trial
120
value of Lmax including deadlines which are checked for feasibility by means of the above
network flow computation. This procedure can be implemented to solve problem
P / pmtn, rj /Lmax in O( n3 min { n2, log n + log max {pj }} time [Lab84]
Problem P / pmtn ; ri / Lmax
This problem may be reduced to a maximum flow problem in a network[Bru95]. There exists
n
a schedule respecting all time windows if and only if the maximum flow has the value
∑ pi .
A
i =1
and
∑ xiK
BL
D
n
r −1
∑ xiK = pi for i = 1,..,n
K =1
E
job Ji is processed in the time interval IK and we have
ID
If this is the case, the flow xiK on the arc ( Ji , JK )corresponds with the time period in which
≤ m TK for K = 1,..., r - 1.
B
i =1
LA
To solve P / pmtn; ri / Lmax , we apply binary search on different-values.
n max p j .
j = 1,...n
A
H
We assume di ≤ n max p j , which implies - n max p j ≤ Lmax ≤
j = 1,...n
j = 1,...n
D
This yields an algorithm which approximates the solution value with absolute error ε in at
Problem P / pi = 1 ; ri / Lmax
SA
A
D
most O( n3 ( log n + log(1/ε) + log ( max p j ) ) steps.
j = 1,...n
It is convenient to assume that the jobs are indexed in such a way that
r1 ≤ r2 ≤ ... ≤ rn .
TE
The problem has an easy solution if all release times ri are integer. In this case, we get an
SI
optimal schedule by scheduling available jobs in order of non-decreasing due date.
ER
More specifically, if at the current time t not all machines are occupied and there is an
unscheduled job Ji with ri ≤ t, we schedule such a job with smallest due date.
IV
Technical details are given by the following algorithm in which K counts the number of
U
N
machines occupied immediately after Step 7 at current time t, m is the number of machines,
M is the set of unscheduled jobs available at time t, and j is a counter for the number of
scheduled jobs.
Algorithm 14. Algorithm for P / pi = 1; ri integer / Lmax[Bru95]
1. j : = 1 ; K : = 1 ;
121
A
H
LA
B
D
E
BL
I
D
A
2. WHILE j ≤ n Do
BEGIN
3.
t : = r j ; M : = { Ji / r i ≤ t } ;
4.
WHILE M ≠∅ Do
BEGIN
5.
Find job Ji in M with the smallest due date ;
6.
M : = M \ { Ji } ;
7.
Schedule Ji at time t ;
8.
j : = j + 1;
9.
IF K + 1 ≤ m THEN K : = K + 1 ;
ELSE
BEGIN
10.
t:=t+1;
11.
K:=1;
12.
M : = M ∪ { Ji / r i ≤ t } ;
END;
END ;
END ;
A
Problem P / prec, pj = 1 / Lmax
D
D
The algorithm runs in O ( n log n ) time if a priority queue data structure is used for M.
SA
Let us now pass to dependent tasks. A general approach in this case consists in assigning
modified due dates to tasks, depending on the number and due dates of their successors.
SI
T
E
The way in which modified due dates are calculated depends on the parameters of the
problem. When scheduling nonpreemptable tasks on a multiple processor system only unit
ER
processing times can results in polynomial time scheduling algorithms. Let us star with in-tree
precedence constraints and assume that if Ti < Tj
then i > j. The following algorithm
U
N
IV
minimizes Lmax where isucc(j) denotes the immediate successor of Tj [Bru76b].
Algorithm 15. Algorithm by Brucker for P / in-tree, pj = 1 / Lmax [Bru76b]
begin
d*1 = 1 - d1 ;
for k = 2 step 1 until n do
begin
Calculate modified due dates of Tk according to the formula
d*k : = max { 1 + d*isucc(k), 1 - dk } ;
end ;
Schedule tasks in nonincreasing order of their modified due dates subject to precedence
constraints ;
end ;
___________________________________________________________________________
122
This algorithm can be implemented to run in O(nlogn) time. Surprisingly out-tree precedence
constraints result in the NP-hardness of the problem [Bru77]
However, when we limit ourselves to two processors, a different way of computing modified
due dates can be proposed which allows one to solve the problem in O( n2 ) time [Gar76].
In the algorithm below g(k, d*i ) is the number of successors of Tk having modified due dates
D
A
not greater than d*i.
SA
A
D
D
A
H
LA
B
D
E
BL
I
Algorithm 16. Algorithm by Garey and Johnson for problem P2/ prec, pj = 1/ Lmax[Gar76]
begin
Z:=T
while Z ≠ ∅ do
begin
Choose Tk ∈k Z which is not yet assigned a modified due date and all of whose
successors have been assigned modified due dates ;
Calculate a modified due date of Tk as :
1

d*k : = min { dk , min { ( d*i -  g ( k , d *i  ) / Ti ∈ succ( T ) }} ;
2

Z : = Z - { Tk } ;
end ;
Schedule tasks in nondecreasing order of their modified due dates subject to precedence constraints ; r
end ;
___________________________________________________________________________
For m > 2 this algorithm may not lead to optimal schedules. However, the algorithm can be
generalized to cover the case of different ready times too, but the running time is then O(n3)
SI
TE
[Gar77] and this is as much as we can get in non-preemptive scheduling.
Problem P / pmtn, prec / Lmax
IV
ER
Preemptions allow one to solve problems with arbitrary processing times. In Law82b]
algorithms have been presented that are preemptive counter-parts of Algorithms 15 ( by
N
Brucker[Bru76b] ) and 16 ( by Garey and Johnson[Gar76] ) and the one presented by Garey
U
and Johnson[Gar77] for non-preemptive scheduling and unit-length tasks.
Hence problems P / pmtn, in-tree / Lmax , P 2 / pmtn, prec / Lmax and P2/ pmtn, prec, rj / Lmax
are solvable in polynomial time. Algorithms for these problems employ essentially the same
techniques for dealing with precedence constraints as the corresponding algorithms for unitlength tasks. The algorithms are more complex.
123
4.2. Uniform and Unrelated Processors
Problem Q // Lmax
We see that non-preemptive scheduling to minimize Lmax is in general a hard problem. Only
A
for the problem Q / pj = 1/ Lmax a polynomial time optimization algorithm is known. This
BL
I
D
problem can be solved via a transportation problem formulation , where now Cijk = k / bi - dj .
Problem Q / pmtn / Lmax
E
This problem is one of the few parallel machine problems with a due-date related objective
D
that can be solved in polynomial time.
LA
B
Finding a feasible schedule with all jobs completing their processing before these deadlines is
equivalent to solving the problem Qm / rj, prmp / Cmax. Reverse the direction of time in the
due-date problem. The deadlines in the original problem play the role of release dates in the
A
H
reverse problem, which is then equivalent to Qm / rj, prmp / Cmax. f applying the LRPT-FM
D
rule backwards results in a feasible schedule with all the jobs in the original problem starting
at a time larger than or equal to zero, then there exists a schedule for Qm / prmp / Lmax with
A
D
Lmax < z. To find the minimum Lmax a simple search has to be done to determine the
SA
appropriate minimum of value of z. This problem can be formulated as a network flow
problem that can be solved in polynomial time.
TE
We will consider uniform processors first. One of the most interesting algorithms in that area
has been presented for problem Q / pmtn, rj / Lmax by Federgruen and Groenevelt[ Fed86].
ER
SI
It is a generalization of the network flow approach to the feasibility testing of problem
~
P / pmtn, rj , d j / -described above. The feasibility testing procedure for problem
IV
~
Q/ pmtn, rj , d j / - uses tripartite network formulation of the scheduling problem, where the
N
first set of nodes corresponds to tasks, the second corresponds to processors-interval (period)
U
combination and the third corresponds to interval nodes.
Finding a feasible flow with value
n
∑ p j in such a network corresponds to a construction of
j =1
~
a feasible schedule for Q/ pmtn, rj , d j / - . This can be done in O(mn3) time.
124
Problem Q/ pmtn, ri / Lmax
Again we consider the problem of finding a schedule with the property that each job i is
processed in the time window [ ri , di ] defined by a release time ri and a deadline di of job i.
We call such a schedule feasible with respect to the time windows [ ri , di ]. In the second
step, we apply binary search to solve the general problem. As above, we solve the feasibility
problem by reducing it to a network flow problem. The same condition for the existence of
the feasible schedule is established.
Because a maximal flow in the expanded network can be calculated in O( m n3 ) steps, a
feasible check can be done with the same complexity.
This yields an ε-approximation
algorithm with complexity O( m n3 ( log n + log(1/ε) + log ( max p j ) ).
j = 1,...n
A
Problem Q/ pmtn, prec / Lmax
ID
In case of precedence constraints, Q2 / pmtn, prec / Lmax and Q2 / pmtn, rj / Lmax can be
BL
solved in O( n2) and O(n6 ) time, respectively, by the algorithm of [Law82b].
E
Problem R/ pmtn / Lmax
D
As far as unrelated processors are concerned, problem R/ pmtn / Lmax can be solved by a
B
linear programming formulation, where xkij denotes the amount of Tj processed on Pi in time
LA
interval [ dk-1 + Lmax, dk + Lmax] and where due dates are assumed to be ordered d1 <d2 <...< dn.
H
Thus, we have the following formulation :
m
to
∑ pij xij (1) ≤
D
subject
i =1
n
j = 1, 2, ..., n
A
dk - dk-1 , j = k, k+1,...,n, k = 2,3,..,n
SA
∑ pij xij ( k ) ≤
d1 + Lmax ,
D
i =1
m
A
minimize Lmax
TE
∑ pij xij (1) ≤
d1 + Lmax,
i = 1, 2, ..., m
n
∑ pij xij ( k ) ≤
dk - dk-1 , i = 1, 2, ...,m, k = 2,3,..,n
j=k
U
N
IV
ER
SI
j =1
m
j
∑ ∑ xij ( k ) = 1
,
i = 1k = 1
125
j = 1, 2, ..., n.
Solving the LP problem we obtain n matrices T(k) = [ t(k)*ij ] , k = 1, 2, .., n ; then an optimal
solution is constructed by an application of Algorithm 10 for R / pmtn/ Cmax to each matrix
separately.
When precedence constraints forma uni-connected activity network, can also be solved via
the same modification of the LP problem as described for the Cmax criterion[Slo78].
43. Complexity Results
We summarize scheduling problems complexity with jobs to be processed on parallel
machines.
Author(s) and date
Q / pmtn / Lmax
O(n logn + mn)
Labetoulle et al (1984)
Q / pmtn; ri / Lmax
O(mn3 ( log n+ log(1/ε)
Federgruen & Gronevelt ( 1986)
solvable
E
+ log(maxpi)
A
Complexity
BL
ID
Problems polynomially
Linear programming
Lawler & Labetoulle ( 1978)
P / intree ; pi = 1 / Lmax
O( n )
Brucker et al (1977)
B
D
R / pmtn; ri / Lmax
LA
Momma(1982)
O(nlog7)
Garey & Johnson(1976)
H
P 2 / prec, pi = 1 / Lmax
P 2 / prec, pi = 1; ri / Lmax O(n3 logm)
O(n2)
Problems NP-hard
Lawler ( 1982 )
Lawler ( 1982 )
Lawler ( 1982 )
Author(s)
Brucker & al ( 1977)
TE
P / outtree ; pi = 1 / Lmax
SA
Q2 / prec; pmtn ; ri / Lmax O(n6)
A
Q2 / prec; pmtn / Lmax
D
O(n2)
A
D
P / intree ; pmtn / Lmax
Garey & Johnson(1977)
ER
SI
5. Open Problems : [ Sch99]
In a recent paper, Schuurman and Woeginger [Sch99] discuss what they consider to be the
most vexing open questions in the area of polynomial time approximation algorithms for
IV
NP-hard deterministic machine scheduling problems. They summarize what is known on
N
these problems, discuss related results and they provide pointers for literature.
U
We consider only scheduling problems that are NP-hard. A distinction is made between
positive results, which establish the existence of some approximation algorithm, and negative
126
results, which disprove the existence of certain approximation results under the assumption
P ≠ NP. They define Positive results and negative results.
A standard way of dealing with NP-hard problems is not to search for an optimal solution, but
to go for near-optimal solutions. An algorithm that return near-optimal solutions is called an
approximation algorithm. If it does this in polynomial time, then it is called a polynomial time
approximation algorithm.
An approximation algorithm that always returns a near-optimal solution with cost at most a
factor ρ above the optimal cost ( where ρ > 1 is some fixed real number ) is called a
ρ-approximation algorithm, and the value ρ is called the worst-case performance guarantee.
A
A family of ( 1 + ε ) -approximation algorithms over all ε > 0 with polynomial running times
BL
ID
is called a polynomial time approximation scheme or PTAS, for short. If the time complexity
of a PTAS is also polynomially bounded in 1 / ε, then it is called a fully polynomial time
approximation scheme or FPTAS.
E
FPTAS is essentially the strongest possible polynomial time approximation result that we can
D
derive for an NP-hard problem.
B
Positive results in the area of approximation concern the design and analysis of such
LA
polynomial time approximation algorithms and schemes. For every hard problem, we would
H
like to know whether it possesses a polynomial time approximation algorithm with constant
A
worst-case performance guarantee, or a PTAS, or even an FPTAS. Negative(
D
inapproximatively ) results disprove the existence of good approximation algorithms under
A
D
the assumption P ≠ NP.
Two kind of algorithms exist. The “ compound algorithms ”, which selects the best schedule
SA
produced by two or more methods and the “ improvement algorithms ” , which iteratively
improve schedules produced by a single method.
SI
TE
Four open problems deal with the makespan criterion, in parallel machine environments.
ER
Open problem 1. Design a polynomial time approximation algorithm for P/ prec/ Cmax or for
P / prec, pj = 1 / Cmax with worst-case performance 2 - δ ( in fact, even an algorithm whose
N
IV
time complexity is exponential in m might be interesting). Provide a 4/3 + δ
inapproximability result for P / prec / Cmax
U
Design a PTAS for problem P 2 / prec / Cmax . Design a PTAS ( or even an FPTAS ) for
problem P3/ prec, pj = 1 / Cmax .
127
Open problem 2. Design a polynomial time approximation algorithm for Q/ prec/ Cmax with
constant performance guarantee ( i.e. independent of the number of machines ), or prove a
non-constant lower bound under the assumption P ≠ NP ( i.e. a bound that tends to infinity as
m goes to infinity ) .
Open problem 3. For P / prec, pj = 1, c = 1/ Cmax , improve the performance guarantee to 7/3 δ or improve the improve the inapproximability bound to 5/4 +δ.
For P∞ / prec, pj = 1, c = 1/ Cmax, improve the performance guarantee to 4/3 - δ or improve the
D
A
inapproximability bound to 7/6 + δ.
BL
I
Decide whether there exists a polynomial time approximation algorithm with constant
performance guarantee for P∞ / prec, pj = 1, c = 1/ Cmax.
E
Decide whether there exists a polynomial time approximation algorithm with constant
B
D
performance guarantee for P∞ / prec, cjk / Cmax.
LA
Open problem 4. Design a polynomial time approximation algorithm for R // Cmax with worst-
U
N
IV
ER
SI
TE
SA
A
D
D
A
H
case performance of 2 - δ or provide a 3/2 + δ inapproximability result for R // Cmax .
128

universite saad dahlab de blida - Université Saad Dahlab de Blida

Transcription

Documents pareils

Invitation MBT course BEFR.pub

Major Adjective comparison Student Answer key

PROJET DU

Yoga, gymnastique et coach sportif

Unité 4 Leçon 11

Separability

Pre-University Grade 12 Short Course Descriptions

General Education Component and a Specific

Online Non-Preemptive Scheduling to Optimize Max Stretch on a

Another new proof of the theorem that every integral rational

CAULFIELD JUNIOR COLLEGE 2015

(NON-DETERMINISTIC) MULTIVALUED DECISION DIAGRAMS