Practical comparison of approximation algorithms for scheduling problems

Abstracts

In this paper we consider an experimental study of approximation algorithms for scheduling problems in parallel machines minimizing the average weighted completion time. We implemented approximation algorithms for the following problems: P|r j|sigmaCj, P||sigmaw jCj, P|r j|sigmaw jCj, R||sigmaw jCj and R|r j|sigmaw jCj. We generated more than 1000 tests over more than 200 different instances and present some practical aspects of the implemented algorithms. We also made an experimental comparison on two lower bounds based on the formulations used by the algorithms. The first one is a semidefinite formulation for the problem R||sigmaw jCj and the other one is a linear formulation for the problem R|r j|sigmaw jCj. For all tests, the algorithms obtained very good results. We notice that algorithms using more refined techniques, when compared to algorithms with simple strategies, do not necessary lead to better results. We also present two heuristics, based on approximation algorithms, that generate solutions with better quality in almost all instances considered.

approximation algorithms; practical analysis; scheduling

Neste artigo consideramos um estudo experimental de alguns algoritmos aproximados para problemas de escalonamento em máquinas paralelas onde se deve minimizar o tempo de término ponderado das tarefas. Foram implementados algoritmos aproximados para os seguintes problemas: P|r j|sigmaCj, P||sigmaw jCj, P|r j|sigmaw jCj, R||sigmaw jCj and R|r j|sigmaw jC j . Foram gerados mais de 1000 testes sobre mais de 200 instâncias diferentes e com isso apresentamos aspectos práticos dos algoritmos implementados. Também fizemos um estudo experimental sobre dois limitantes inferiores baseados em formulações usadas pelos algoritmos. A primeira é uma formulação semidefinida para o problema R||sigmaw jCj e a outra é uma formulação linear para o problema R|r j|sigmaw jCj. Em todos os testes os algoritmos obtiveram resultados muito bons. Notamos que algoritmos usando técnicas mais refinadas, quando comparados com algoritmos que usam estratégias simples, não necessariamente geram soluções melhores. Também apresentamos duas heurísticas, baseadas nos algoritmos aproximados, que geram soluções de melhor qualidade em quase todas as instâncias consideradas.

algoritmos de aproximação; análise prática; escalonamento

Practical comparison of approximation algorithms for scheduling problems

Eduardo Candido Xavier^*; Flávio K. Miyazawa

Instituto de Computação Universidade Estadual de Campinas (UNICAMP) Campinas — SP [e-mail] [e-mail]

ABSTRACT

In this paper we consider an experimental study of approximation algorithms for scheduling problems in parallel machines minimizing the average weighted completion time. We implemented approximation algorithms for the following problems: P|r_j|SC_j, P||Sw_jC_j, P|r_j|Sw_jC_j, R||Sw_jC_j and R|r_j|Sw_jC_j. We generated more than 1000 tests over more than 200 different instances and present some practical aspects of the implemented algorithms. We also made an experimental comparison on two lower bounds based on the formulations used by the algorithms. The first one is a semidefinite formulation for the problem R||Sw_jC_j and the other one is a linear formulation for the problem R|r_j|Sw_jC_j. For all tests, the algorithms obtained very good results. We notice that algorithms using more refined techniques, when compared to algorithms with simple strategies, do not necessary lead to better results. We also present two heuristics, based on approximation algorithms, that generate solutions with better quality in almost all instances considered.

Keywords: approximation algorithms; practical analysis; scheduling.

RESUMO

Neste artigo consideramos um estudo experimental de alguns algoritmos aproximados para problemas de escalonamento em máquinas paralelas onde se deve minimizar o tempo de término ponderado das tarefas. Foram implementados algoritmos aproximados para os seguintes problemas: P|r_j|SC_j, P||Sw_jC_j, P|r_j|Sw_jC_j, R||Sw_jC_j and R|r_j|Sw_jC _{j .} Foram gerados mais de 1000 testes sobre mais de 200 instâncias diferentes e com isso apresentamos aspectos práticos dos algoritmos implementados. Também fizemos um estudo experimental sobre dois limitantes inferiores baseados em formulações usadas pelos algoritmos. A primeira é uma formulação semidefinida para o problema R||Sw_jC_j e a outra é uma formulação linear para o problema R|r_j|Sw_jC_j. Em todos os testes os algoritmos obtiveram resultados muito bons. Notamos que algoritmos usando técnicas mais refinadas, quando comparados com algoritmos que usam estratégias simples, não necessariamente geram soluções melhores. Também apresentamos duas heurísticas, baseadas nos algoritmos aproximados, que geram soluções de melhor qualidade em quase todas as instâncias consideradas.

Palavras-chave: algoritmos de aproximação; análise prática; escalonamento.

1. Introduction

In this paper, we consider an experimental study of approximation algorithms for scheduling problems. For all problems considered, a set of jobs must be scheduled, under some restrictions, in a set of machines minimizing the average weighted completion time. All these problems are NP-hard [S97] and we consider polynomial time approximation algorithms. We have implemented some approximation algorithms to schedule jobs on parallel machines and study their computational performance.

Given a polynomial time algorithm A and an instance I for a minimization problem, we denote by A(I) the value of the solution returned by A when applied to the instance I, and we denote by OPT(I) the value of an optimal solution to I. We say that an algorithm A has an approximation factor a, or is an a-approximation, if A(I)/OPT(I) £ a , for all instances I. When the algorithm A is probabilistic and the inequality E[A(I)]/OPT(I) £ a is valid, where E[A(I)] is the expected value of the solution returned by algorithm, we say that A is a probabilistic a-approximation algorithm.

Given a polynomial time algorithm A_e, for fixed e > 0, and an instance I for some problem P, we say that A_e is a polynomial time approximation scheme (PTAS) for a minimization problem if for any e>0 and any instance I we have A_e (I)£ (1+e)OPT(I). If the algorithm is also polynomial time in 1/e we say that Ae is a fully polynomial time approximation scheme (FPTAS).

For all problems considered, we denote by J = {1,...,n} the set of jobs and M={1,...m} the set of machines. For the case where the machines are unrelated, we denote by p_ij the processing time of the job j when executed on machine i. When all machines are identical, we denote this processing time by p_j. For some problems, there is a release date r_j, for each job j, which is a time where the job j cannot be scheduled before. The value w_j is the importance weight of finishing the job j earlier and the completion time of the job is denoted by C_j.

Since we consider several scheduling problems, we use the notation a|b|g, introduced by Graham, Lawler, Lenstra & Rinnooy Kan [GLLR79], to denote each problem. In the following, we detail the terms used in this paper under this notation. The term a corresponds to the machine environment, P for identical machines or R for unrelated machines. The term b tell us some restrictions about jobs, if they have release dates, r_j, if the schedule is preemptive (i.e., jobs can be interrupted and continued later), pmtn, etc. Finally the term g indicates the objective function we want to minimize.

All problems we consider are non-preemptive, although algorithms for preemptive problems are used to find intermediate solutions.

There are many papers describing approximation algorithms for scheduling problems, but few consider practical performance analysis. In [HS01], Hepner & Stein presented an implementation of a PTAS for the problem 1|r_j|SC_j. Savelsbergh et al. [SUW98] also presented an experimental study of approximation algorithms for the problem 1|r_j|Sw_jC_j and a variant of this problem when the average weighted flow time is minimized, i.e. problem 1|r_j|Sw_j(C_j—r_j). Recently, Vredeveld & Hurkens [VH02] presented an experimental comparison of approximation algorithms for the problem R||Sw_jC_j and some dominance relations between linear and quadratic formulations for this problem. Baev et al. [BME02] presented a practical comparison for the problem P|prec|Sw_jC_j where the jobs have precedence constraints. They also show how algorithms for this problem can be used in the scheduling phase in profile-based program compilation. They used some instances extracted from the SPECint95 compiler benchmark and showed that the best solutions are within 5.7% of optimal.

We implemented algorithms for the following problems: P|r_j|SC_j, P||Sw_jC_j, P|r_j|Sw_jC_j, R||Sw_jC_j and R|r_j|Sw_jC_j. For the problem P|r_j|SC_j we implemented the algorithm developed by Phillips et al. [PSW98]. This algorithm is combinatorial and is based on a heuristic for the preemptive case. For the problem P||Sw_jC_j we implemented the algorithm of Kawaguchi & Kyan [KK86], that is based on a list scheduling heuristic. For the problems P|r_j|Sw_jC_j and R|r_j|Sw_jC_j we implemented algorithms of Schulz & Skutella [SS02]. The algorithm for the first problem is combinatorial and the algorithm for the second problem is based on a solution of a linear program. Both algorithms are probabilistic. Finally, for the problem R||Sw_jC_j we implemented the algorithm developed by Skutella [S98] that is based on a solution of a semidefinite program.

We chose to implement these algorithms because they are well known approximation algorithms, with good time complexity and good approximation factors. Also, the set of algorithms chosen, treat problems that have common cases and this permits to compare them. Some problems we consider are particular cases of others. So, implemented algorithms for more general problems are also compared with algorithms for more restricted problems. There are other approximation algorithms for some of these problems like the polynomial time approximation schemes for parallel machines presented by Afrati et al. [Afrati et al., 1999]. These schemes appear to have only theoretical interest, since their running times are given by high degree polynomials. In fact, most of these schemes require an enumeration step that is intolerable in practice.

To our knowledge, this paper is the first to consider a practical comparison of approximation algorithms for scheduling problems with parallel machines and release dates (problems P|r_j|SC_j and R|r_j|Sw_jC_j). We also consider a practical study of two formulations that provide lower bounds for the problem R||Sw_jC_j. Notice that Vredeveld & Hurkens [VH02], also studied these formulations presenting dominance relations among them, but they considered an exponential size linear formulation. In this paper we consider the same formulation with a small modification which leads to a formulation of polynomial size.

All algorithms are implemented in C. For the algorithms that require solutions of linear or quadratic programs we use the Xpress-MP library, of Dash Optimization [D02]. Based on the practical results, we propose a simple modification on the algorithm presented by Schulz & Skutella [SS02] for the problem R|r_j|Sw_jC_j and on the algorithm of Kawaguchi & Kyan [KK86]. In the tests we considered, we show that these heuristics obtain solutions with better quality.

The paper is organized as follows. In section 2 we describe the implemented algorithms and give some insight of how they work. In section 3 we compare two lower bounds for the problem R||Sw_jC_j with different number of machines. In section 4 we present the computational results of the implemented algorithms.

2. Algorithms

In this section we describe the algorithms and the way they are implemented. We do not show how their approximation factors are obtained. The interested reader can find more details about the approximation results of these algorithms in the references.

2.1 Algorithm PSW for the problem P|r_j|SC_j

The algorithm of this section, which we denote by PSW, was developed by Phillips et al. [PSW98]. The algorithm PSW finds a solution in two phases. In the first phase, it obtains an approximate solution for the preemptive version of this problem and in the second phase it uses an algorithm that converts the preemptive schedule to a non-preemptive one. The preemptive version of this problem is already NP-hard, and a solution is generated by a 2-approximation algorithm. The algorithm that converts the preemptive schedule to a non-preemptive one, produces a new schedule that is at most three times worse than the preemptive schedule. This leads to a 6-approximation algorithm for the problem P|r_j|SC_j (see [PSW98]).

The algorithm for the preemptive schedule is based on the following idea: at any time, execute m jobs with the shortest remaining amount of work. The time complexity of the implemented algorithm, which we denote by Preemptive, is O(n(logn + m)).

Once this preemptive schedule is generated, the algorithm generates a list M_i, for each machine i, of jobs ordered by their preemptive completion times. For each machine i, the algorithm PSW generates a non-preemptive schedule with jobs in the order specified by M_i, under the condition that no job starts before its release date. The time complexity of the implemented algorithm is O(nlogn +m) plus the time complexity to generate the preemptive schedule.

2.2 Algorithm KK for the problem P||Sw_jC_j

The algorithm of this section is an extension of the optimal algorithm for the problem 1||Sw_jC_j. The problem 1||Sw_jC_j can be solved optimally with the following algorithm developed by Smith [S56]: order jobs in non-decreasing order of p_j/w_j and schedule the jobs in this order. The approximation algorithm for the parallel machine case is an extension: order jobs in non-decreasing order of p_j/w_j and schedule jobs in this order every time a machine becomes free. Kawaguchi & Kyan [KK86] have shown that this algorithm generates schedules with a factor of of the optimal. The implemented algorithm, which we denote by KK, has time complexity O(nlogn + nlogm).

2.3 Algorithm SZSK for the problem P|r_j|Sw_jC_j

The algorithm SZSK is a probabilistic 2-approximation algorithm and was developed by Schulz & Skutella [SS02]. For each instance, the algorithm SZSK is executed 100 times and the best generated schedule is returned. In our experiments, we observed that more executions leads to very small improvements. The algorithm is related to the linear formulation for a single machine problem presented below. We have variables y_jt, for each job j and for each time interval (t, t+1] that a job can run. We also have variables C_j, that represent the finishing time of job j. The constant T is an upper bound for the completion time of any job. The relaxed linear program, denoted by LPS, is the following:

The linear program (LPS) can be solved using a combinatorial algorithm [SS02]. Suppose we have only one machine that is m times faster than the machines considered. Consider the processing times of the jobs to be m times smaller. Construct a preemptive schedule for this single machine with the new processing times using the following rule: at any time, generate a preemptive schedule on the new single machine by scheduling, among the available jobs, the one with the smallest ratio p_j/w_j. The resulting schedule corresponds to an optimal solution for the formulation. Each variable y_jt receives value 1 if job j is processed during time [t-1,t) in the generated schedule.

Notice that the algorithm Preemptive is easily modified to solve this formulation and can be implemented to run in O(nlogn). After this, we construct a schedule based on probabilistic assignments. We choose for each job j, a variable a_j uniformly distributed from the interval [0,1]. Then, we consider the probabilistic finishing time, i.e., the first time in the schedule where the total amount of work done is p_ja_j. We denote this value by C_j(a_j). The algorithm SZSK attributes each job j uniformly and independently to one of the m machines. For each machine the algorithm schedules jobs in nondecreasing order of values C_j(a_j). The time complexity of the algorithm SZSK is O(nlogn + m).

2.4 Algorithm SK for the problem R||åw_jC_j

The algorithm of this section, which we denote by SK, is a probabilistic 2-approximation algorithm based on a semidefinite formulation. The algorithm was presented by Skutella [S98] and uses a quadratic program. This program has binary variables a_ij, such that a job j is to be processed in machine i, if and only if, a_ij = 1, and variables C_j that represent the finishing time of job j. We also have a function á _i that specifies the execution order of a job pair j,k in machine i. The job j must be processed before k in machine i if w_j/p^ij³ w_k/p_ik . The quadratic program is the following:

Skutella have shown that this formulation is equivalent to the following quadratic formulation:

where a Î Â ^mn is a vector of all variables a_ij lexicographically ordered with respect to the natural order 1,2,...,m of the machines, and then for each machine i, the jobs are ordered according to . The vector c Î Â^mn is given by c_ij = w_jp_ij and D = (d_(ij)(hk)) is a symmetric (mn ´ mn)-matrix given by: (i) 0 if i ¹ j or j = k; (ii) w_jp_ik if i = h and k á_i j; (iii) w_kp_ij if i = h and j

k.

This problem can be solved in polynomial time if, and only if, matrix D is positive semidefinite. This motivates the construction of a new formulation, which we call QSP:

where (D +diag(c)) is positive semidefinite and diag(c) is a diagonal matrix with the vector c.

Given a solution for QSP, each job j is assigned to machine i with probability a_ij and in each machine i the execution order is given by the function . In our implementation, this assignment is performed 100 times and the algorithm returns the best generated schedule. For the special case of identical parallel machines, the optimal solution of the above formulation is given by a_ij = 1/m. In this case, we implemented a combinatorial algorithm attributing each job to a machine with probability 1/m. This combinatorial algorithm is denoted by SK-C. The time complexity of the algorithm is O(nlogn + m) plus the time complexity to solve the semidefinite program QSP.

2.5 Algorithm SZSK2 for R|r_j|åw_jC_j

The algorithm for the problem R|r_j|Sw_jC_j is also a probabilistic algorithm, and was presented by Schulz and Skutella [SS02]. The algorithm, denoted by SZSK2, is based on the solution of a linear formulation and is a generalization of the algorithm SZSK. The formulation uses an upper bound T on the completion time of any job and uses variables C_j, representing the finishing time of each job j, and variables y_ijt that indicates if job j is being executed in machine i at time interval (t,t+1] for each time interval. The formulation has exponential size, but it can be made of polynomial size with a small loss in the objective function, using interval times that increase exponentially in their size. In this case, we have binary variables y_ijl indicating the execution of job j in machine i at interval I_l = ((1+b)^l-1,(1+b)^l]. The size of an interval I_l is denoted by |I_l|. For simplicity, we denote (1+b)^l by b_l. The relaxed formulation, denoted by LPSS, is the following:

The algorithm solves the linear program LPSS and assign each job j to a machine-interval pair (i,I_l) at random with probability (y_ijl|I_l|)/p_ij. The jobs assigned to a machine i are scheduled in non-decreasing order of intervals assignment. If there is more than one job assigned to the same pair (i,I_l), the algorithm schedules them in the order of their values j. For a given e>0, setting b =e/2 this algorithm has a probabilistic (2+e)-approximation factor. As in the algorithm SK, the probabilistic assignment step is executed 100 times and the best generated schedule is returned. The time complexity of this algorithm is O(nmlog_(1+e)T + nlogn) plus the time complexity to solve the linear program LPSS. Since this algorithm is executed with different values of e, we denote by SZSK2e the algorithm SZSK2 with the given value of e. That is, the algorithm SZSK2_0.1 is the algorithm SZSK2 with value of e= 0.1.

2.6 Two Heuristic Algorithms

In this section we present a new algorithm denoted by HE1 for the problem R|r_j|Sw_jC_j. It is a simple modification of the algorithm SZSK2. We also present an extended heuristic of the algorithm KK for the problem P|r_j|Sw_jC_j, denoted by HE2.

In [HP83], Hariri and Potts presented a simple heuristic algorithm for problem 1|r_j|Sw_jC_j used to find an upper bound for a branch and bound algorithm. The algorithm is as follows:

1. Let

   S be the set of all (unsequenced) jobs,

   H=0 and

   k=0 and find

   T=min

   _jÎS{r_j}.

2. Let the set

   S´ = {j| jÎS, r_j£ T} and find a job

   iÎS´ such that

   w_i/p_i = max_{jÎ S´´}{w_j/p_j}.

3. Let

   k = k+1 and sequence job

   i at position

   k; let

   T = T +p_i, H = H+w_iT and

   S = S-{i}.

4. If

   S=Æ, then stop with the sequence generated having

   H as its cost. Otherwise let

   T=max

   {T, min

   _jÎS{r_j}} and go to step 2.

In the algorithm SZSK2, the jobs are assigned to pairs machine-interval and them executed in each machine by the order of interval assignments. In the algorithm HE1, the assignment step is performed as in the algorithm SZSK2, but the jobs assigned to a machine i are scheduled using the algorithm of Hariri and Potts.

The algorithm HE2 is an extended heuristic of algorithm KK: every time a machine becomes free, execute among the available jobs, the one with smallest ratio p_j/w_j. Notice that without the presence of release dates, this algorithm is essentially algorithm KK.

Notice that we cannot guarantee approximation factors for these two heuristics. Since we changed the way the schedules are generated, some properties of the schedule are lost. These properties are essential in the analysis of their approximation factor. To prove that these heuristics have approximation factors is not a trivial step and an entire paper can be devoted to this subject.

3. Study of Two Lower Bounds

In this section we present an experimental comparison of two formulations that provide lower bounds for the implemented algorithms. The first formulation is the semidefinite formulation QSP used in the algorithm SK, and the second is a linear formulation LPSS used in the algorithm SZSK2. For problems that consider jobs with release dates we used the lower bounds provided by the linear program LPSS. For problems without release dates we performed a computational study to determine which formulation gives lower bounds with better quality. We notice that Vredeveld & Hurkens [VH02] proved that the formulation LPSS with unit time interval gives better lower bounds than the formulation QSP. But in this case, the formulation LPSS has exponential size and the time required to solve the instances may be very high. We performed tests with LPSSe and formulation QSP for e Î {0.3,0.1}. In this case, where e>0 in the formulation LPSS, it is not true that LPSS gives better bounds. For the most generic problem R||Sw_jC_j, we consider three cases: R2||Sw_jC_j, R5||Sw_jC_j and R7||Sw_jC_j. We also tried to study the case R10||Sw_jC_j but we could not solve integer instances of this problem in a reasonable amount of time (two hours). We performed five tests with 100 jobs for each case. The processing times of jobs were taken uniformly from the interval [1,100] and w_j was uniformly chosen from the interval [1,10]. We notice that the quality of the lower bound increases using e=0.1 when compared with the solutions with e=0.3, but QSP provides better lower bounds. We tried to solve the instances with the formulation LPSS with smaller values of e, but when e® 0, the number of time intervals increases in such a way that is better to consider unit time intervals. The use of the e>0 in the formulation LPSS is justified since we are comparing lower bounds obtained in polynomial time. We present the results obtained in at most two hours.

The lower bounds of these two formulations are compared with the value of an integer solution, which we obtained from the integral solutions of program QSP. The results of these tests can be seen in Table 1.

We also performed computational tests to compare the lower bounds for the problem P||Sw_jC_j. In this case, we could solve only instances up to 20 jobs with 2 machines, and 15 jobs with 5 machines. The next theorem, proved by Skutella [S98], helps us to understand the hardness to obtain integer solutions for instances of this problem.

Theorem 3.1 For instances of Pm||Sw_jC_j , an optimal vector solution a of the quadratic program QSP is a_ij=1/m for all i,j. This optimum solution is unique if all ratios p_j/w_j, are different and positive.

In all instances, the solution of the quadratic program is exactly the one provided in the theorem. Since the Xpress solver finds the optimal integer solution using a branch and bound tree, the number of nodes is exponential. We could not solve these kind of problems even if we use an upper bound provided by our approximation algorithms. We could solve only instances with 20 jobs for the problem P2||Sw_jC_j and instances with 15 jobs for the problem P5||Sw_jC_j. The results of our tests are presented in Table 2.

In all generated tests, the lower bounds provided by the formulation QSP are better than the lower bounds provided by the formulation LPSS. Also notice that when e=0.1, the difference is not so large. We do not use smaller values of e since the increase in the computational time to solve such formulations is high (more than two hours of computational processing).

4. Practical Analysis of the Implemented Algorithms

In this section we present the results of our tests. Since some problems are particular cases of others, we performed several different tests. Each subsection is reserved for one case. Before presenting the computational results for each problem, we describe the procedure to generate each test. For each test, we generate 100 jobs with processing times uniformly chosen from the interval [1,100] and w_j chosen from the interval [1,10]. When the problem require release dates, the data is generated using the same approach used by Hariri & Potts [HP83]. The release dates are uniformly chosen from the interval [0,E[p]ng]. This simulates the arrival of n jobs from a stable queue according to a Poisson process with parameter g [HS01]. The time in all tables is given in seconds. The ratio in the table corresponds to V/LB, where V is the value found by the algorithm and LB is a lower bound for the optimal solution. We performed tests with 2, 5, 7 and 10 machines. As was done in [HS01], we generated five different instances for each test problem, so the results in each line of the tables corresponds to the mean of five tests. The algorithms were tested on an AMD Athlon 1.2GHz with 800 MB of RAM under Linux 2.4.2-2 kernel.

4.1 Tests for the problem P||Sw_jC_j

In this problem we used the algorithms KK, SZSK, SK-C, SZSK2 and HE1. We do not use the algorithm HE2 here because without the presence of release dates this algorithm generates the same solutions of the algorithm KK. The Table 3 presents the results of these tests. The LB column corresponds to the optimal fractional solution of the quadratic formulation QSP.

The algorithms obtained very good results for all tested instances. The algorithm KK is the most simple and obtained the best results generating solutions with values less than 0.7% of the lower bounds, besides the other algorithms use more advanced ideas. As we can see, the ratio grows when we use more machines. For algorithm KK the increase is very small. For the other ones the growth is more representative. We believe that with more jobs per machine the ratios obtained tends to decrease. This can be seen in graphics 1, 2, 3 and 4. We will describe more about this behavior in the next subsection.

4.2 Tests for the problem P|r_j|SC_j

To solve this problem we used the algorithms PSW, SZSK, SZSK2, HE1 and HE2. Although the algorithm SZSK is the combinatorial version of the algorithm SZSK2 for identical machines, we also included the algorithm SZSK2 in the comparisons. The algorithms SZSK2 and HE1 were executed with parameter e=0.3 and e=0.1. We perform different tests using different values of g to generate the release dates. We used g=0.2, g=0.4 and g=0.6. The LB column has the values of the optimal solutions of the linear program LPSS, with e=0.1. It is interesting to notice that this lower bound may be far away from the optimum, since the value of an optimal integer solution for the program LPSS is already a lower bound for the original problem P|r_j|SC_j. The Tables 4, 5 and 6 present the results obtained for these tests.

The algorithm HE2 generates the best schedules in all tests. Notice that the algorithm HE1 obtain better results when we have few machines and small values of g. The algorithms PSW and HE1 are the second best in all cases. For all tests, the algorithm PSW generates solutions that are at most 12% of the lower bound although its approximation factor is 6. The algorithm SZSK2 obtained better results than the algorithm SZSK for all cases, except when we have big values of g and more machines, as we can see in Table 6. Analyzing the fractional solution of the linear program used by the algorithm SZSK2, we observed that the solver obtained solutions where almost all variables for some machines have null values. Consequently, the generated schedule have some machines that are almost unused. The algorithm SZSK is the combinatorial version of SZSK2, but the jobs are attributed to all machines uniformly. This also explains why the algorithm HE1 when compared to the algorithm PSW, get better results using two machines than 7 and 10 machines. Based on this observation we try to solve the linear program LPSS under the algorithm HE1 with an increase in the number of jobs per machine. Notice that the algorithm HE1 is based on the algorithm SZSK2 and we can expect the same behavior in both algorithms. We performed several tests that can be seen in Tables 7, 8, 9 and 10. The interesting point to note is that when we get a ratio of approximately 60 jobs per machine, the algorithm HE1 produces better schedules. The solution of the linear program has a better attribution when this happens. We also present some graphics (Figures 1, 2, 3 and 4) that summarize these results. As we mentioned in the previous subsection, the algorithms get better results when we use more jobs per machine. This can be easily verified in these graphics. But it is important to note that when we compare the execution time, the algorithm PSW have a much better performance since it is a combinatorial algorithm, and the algorithm HE1 have to solve large linear programs. Notice that we could not solve all instances of the problem with a given e=0.3 in algorithm HE1. For example, in the tests with ten machines we used e=0.8 and the time to solve the corresponding linear program LPSS is very high. With such values, the lower bound provided by the linear program becomes worse and the ratios obtained for these tests are worse than the ones for the previous tests. We believe that the solutions obtained are closer to the optimum and better ratios could be obtained with better lower bounds.

4.3 Tests for the problem P|r_j|Sw_jC_j

For the problem P|r_j|Sw_jC we used the algorithms SZSK, SZSK2 and HE1. Remember that the algorithm SZSK is the combinatorial version of the algorithm SZSK2 for identical machines. The algorithms SZSK2 and HE1 were executed with parameter eÎ{0.1, 0.3} and the tests were produced with release dates generated with parameter gÎ{0.2, 0.4, 0.6}. The Tables 11, 12 and 13 present the results obtained for these tests. The lower bounds (LB) were obtained from the optimal fractional solutions of the linear program of the algorithm SZSK2 with e=0.1. Remember that this lower bound may be far away from the optimum, since the value of an optimal integer solution for the program LPSS is already a lower bound for the original problem P|r_j|Sw_jC.

The behavior of the algorithms is essentially the same in all tests, except that algorithm SZSK has a bad quality performance in the tests with two and five machines. Algorithm SZSK have a worse quality performance than algorithm SZSK2, but it is much faster than it. The algorithm HE1 is the one that produces the best schedules.

4.4 Tests for the problem R||Sw_jC_j

In this problem we use the algorithms SK, SZSK2 and HE1. For the tests in Table 14 we chose p_ij uniformly from the interval [1,100]. In the tests presented in Table 15 the processing times were chosen from different intervals to give the idea that we have machines with different speeds. Using two machines the processing times were chosen from the interval [1,50] for the first machine and from [50,100] for the second machine. Using five machines the processing times were chosen from intervals, [1,20],[20,40],...,[80,100]. Using seven machines the processing times were chosen from intervals, [1,15],[15,30],...,[90,100]. In the tests with ten machines, the processing times were chosen from intervals [1,10],[10,20],...,[90,100]. We use e=0.1 and e=0.3 in the algorithms SZSK2 and HE1. The LB column corresponds to the fractional solution found by the quadratic formulation QSP of the algorithm SK.

We also present another set of tests based on the approach of Vredeveld & Hurkens [VH02]. The instances of the test in Table 16 were generated to give a machine correlation different from the approach described for the tests in Table 15. The instances were generated with each processing time p_ij taken uniformly in [a_i,a_i+10] where a_i is an integer from the uniform distribution in [1,100]. This approach is called Machine Correlation. The instances of the tests in Table 17 were made to give the idea that a job have two favorite machines to execute. For each job j, two machines i_j1 and i_j2 were randomly chosen, where the processing time of j in these two machines is uniformly chosen in [b_j,b_j+4], where b_j is an integer from the uniform distribution in [15,25]. The processing times of j in the other machines were drawn from the uniform distribution in [60,90]. This approach is called Favorite Machines.

As we can see, all algorithms produces schedules very close to the optimal. For all tests, the algorithms produced solutions with values that are at most 3% of the lower bound except for the algorithm SK that generated a solution with value 7% of the lower bound. In general, the algorithm HE1 generates better schedules. Another point, is that although the semidefinite program QSP generates fractional solutions that are closer to the optimal, the algorithm SK generates the worst schedules even if compared with the algorithm SZSK2_0.3.

4.5 Comparison for the problem R|r_j|Sw_jC_j

For the problem R|r_j|Sw_jC_j, we used the algorithms SZSK2 and HE1. The results for these tests are presented in Table 18. The processing times were uniformly chosen from the interval [1,100] and the release dates were generated with g=0.2. The LB is the optimal fractional solution of the linear program LPSS with e=0.1. We emphasize that this lower bound may be far away from the optimal solution, since an optimal integer solution to LPSS is already a relaxation for the problem R|r_j|Sw_jC_j.

We also made another set of tests with instances of type Machine Correlation and instances of type Favorite Machines. The tests can be seen in Tables 19 and 20. The algorithm HE1 obtained the best results in all tests. The hardest instances are for the set Machine Correlation (Table 19), where the algorithm HE1 obtained schedules that are at most 10% of the lower bound and the algorithm SZSK2 obtained schedules that are at most 15% from the lower bound.

5. Conclusion

We present computational results for some approximation algorithms for scheduling problems on parallel machines. As expected, the practical solutions yield ratios that are much better than the approximation factors of the presented algorithms. We also notice that algorithms with more refined techniques do not necessarily lead to better results. In fact, for the problems P||Sw_jC_j and P|r_j|SC_j algorithms PSW and KK obtained the best results even when compared to algorithms with advanced ideas. We also notice that the solutions provided by the algorithm SK is worse than the solutions provided by the algorithm SZSK2 despite the semidefinite program generates fractional solutions with better quality. Finally, we present two heuristics that get better results in almost all cases considered, although for problem P|r_j|SC_j the processing time of algorithm HE1 is much bigger than the processing time of algorithm PSW.

Acknowledgements

This research was partially supported by FAPESP project 01/04412-4, CAPES and CNPq (Proc. 664107/97-4, 470608/01-3, 464114/00-4, 478818/03-3, 300301/98-7).

[D02] Dash Optimization (2002). Xpress-MP Release 13. Xpress-MP Manual.

Recebido em 07/2003; aceito em 06/2004

Received July 2003; accepted June 2004

• [Afrati et al., 1999] Afrati, F.; Bampis, E.; Chekuri, C.; Karger, D.; Kenyon, C.; Khanna, S.; Milis, I.; Queyranne, M.; Skutella, M.; Sviridenko, M. & Stein, C. (1999). Approximation schemes for minimizing average weighted completion time with release dates. Proceedings of the 40^th Annual IEEE Symposium on Foundations of Computer Science (FOCS'99), 32-44.
• [BME02] Baev, I.D.; Meleis, W.M. & Eichenberger, A. (2002). An Experimental Study of Algorithms for Weighted Completion Time Scheduling. Algorithmica, 33, 34-51.
• [GLLR79] Graham, E.L.; Lawler, E.L.; Lenstra, J.K. & Rinnooy Kan, A.H.G. (1979). Optimization and approximation in deterministic sequencing and scheduling: a survey. Annals of Discrete Mathematics, 5, 287-326.
• [HP83] Hariri, A.M.A. & Potts, C.N. (1983). An algorithm for single machine sequencing with release dates to minimize total weighted completion time. Discrete Applied Mathmatics, 5, 99-109.
• [HS01] Hepner, C. & Stein, C. (2001). Implementation of a PTAS for Scheduling with Release Dates. In: 3^rd Workshop on Algorithm Engineering and Experiments (ALENEX 2001) Lecture Notes in Computer Sciense, 2513, 202-215.
• [KK86] Kawaguchi, T. & Kyan, S. (1986). Worst Case Bound of an LRF Schedule for the Mean Weighted FlowTime Problem. SIAM J. Computing, 15(4), 1119-1129.
• [PSW98] Phillips, C.; Stein, C. & Wein, J. (1998). Minimizing Average Completion time in the Presence of Release Dates. Mathematical Programming B, 82, 199-223.
• [SUW98] Savelsbergh, M.W.P.; Uma, R.N. & Wein, J.M. (1998). An experimental study of LP-based approximation algorithms for scheduling problems. Proceedings of the 9th Annual ACM/SIAM Symposium on Discrete Algorithms, 453-462.
• [SS02] Schulz, A.S. & Skutella, M. (2002). Scheduling Unrelated Machines by Randomized Rounding. SIAM Journal on Discrete Mathematics, 15(4), 450-469.
• [S98] Skutella, M. (1998). Semidefinite Relaxations for Parallel Machine Scheduling. Proceedings of the 39^th Annual IEEE Symposium on Foundations of Computer Science (FOCS'98), 472-481.
• [S97] Sipser, M. (1997). Introduction to the Theory of Computation PWS Publishing Company.
• [S56] Smith, W.E. (1956). Various optimizers for single-stage production. Naval Res. Logist. Quart., 3, 58-66.
• [VH02] Vredeveld, T. & Hurkens, C. (2002). Experimental Comparison of Approximation Algorithms for Scheduling Unrelated Paralell Machines. INFORMS Journal on Computing, 14(2), 175-189.

*

Corresponding author / autor para quem as correspondências devem ser encaminhadas

Publication Dates

• Publication in this collection
  20 Sept 2004
• Date of issue
  Aug 2004

History

• Accepted
  June 2004
• Received
  July 2003