Acessibilidade / Reportar erro

Minimizing flowtime subject to optimal makespan on two identical parallel machines

Abstract

We consider the problem of scheduling jobs on two parallel identical machines where an optimal schedule is defined as one that gives the smallest total flowtime (the sum of the completion time of all jobs) among the set of schedules with optimal makespan (the completion time of the latest job). Utilizing an existing optimization algorithm for the minimization of makespan, we propose an algorithm to determine optimal schedules for this problem. We empirically show that the proposed algorithm can quickly find optimal schedules for problems containing a large number of jobs.

Parallel machine scheduling; Hierarchical criteria; Flowtime minimization


MINIMIZING FLOWTIME SUBJECT TO OPTIMAL MAKESPAN ON TWO IDENTICAL PARALLEL MACHINES

Jatinder N. D. Gupta a

Johnny C. Ho b

a Department of Management, Ball State University, Muncie, IN 47306-0350, USA

b Abbott Turner College of Business, Columbus State University, Columbus, GA 31907-5645, USA

Abstract

We consider the problem of scheduling jobs on two parallel identical machines where an optimal schedule is defined as one that gives the smallest total flowtime (the sum of the completion time of all jobs) among the set of schedules with optimal makespan (the completion time of the latest job). Utilizing an existing optimization algorithm for the minimization of makespan, we propose an algorithm to determine optimal schedules for this problem. We empirically show that the proposed algorithm can quickly find optimal schedules for problems containing a large number of jobs.

Keywords: Parallel machine scheduling; Hierarchical criteria; Flowtime minimization

1. Introduction

Consider the following scheduling problem: a set N = {1,2,...,n} of n jobs available at time zero is to be processed on m identical parallel machines. Each job i Î N is to be processed without interruption on one of the m machines with processing time pi. Each machine can process only one job at a time and no job may be processed by more than one machine. Setup time, if any, is included in the processing time. It is desired to minimize the makespan (maximum completion time) as the primary objective and minimize total flow-time (sum of the completion times of all jobs) as the secondary objective. Thus, it is required to find a schedule for which the total flowtime time is minimized, subject to the constraint that no reduction in the total makespan is possible. Both makespan and flowtime performance measures have significant impact on a schedule's cost, since the former generally represents the amount of resources tied to a set of jobs; while the latter is a useful indicator of the amount of work-in-process. Parallel-machine scheduling problems often arise in practice as in the scheduling of jobs to a number of computer processors or the scheduling of jobs to a set of identical lathes.

The need to consider multiple criteria in scheduling is widely recognized. Either a simultaneous or a hierarchical approach can be adopted. For simultaneous optimization, there are two approaches. First, all efficient schedules can be generated, where an efficient schedule is one in which any improvement to the performance with respect to one of the criteria causes a deterioration with respect to one of the other criteria. Second, a single objective function can be constructed, for example by forming a linear combination of the various criteria, which is then optimized. Under a hierarchical approach, the criteria are ranked in order of importance; the first criterion is optimized first, the second criterion is then optimized, subject to achieving the optimum with respect to the first criterion, and so on. Surveys of algorithms and complexity results in this area are given by Chen and Bulfin (1993), Lee and Vairaktarakis (1993) and Nagar, Haddock, and Heragu (1995). Clearly, the above described problem is one of hierarchical multi-criteria scheduling.

Following the three field notation of scheduling problems, we will designate the identical parallel machine problem to minimize makespan subject to minimum total flowtime as a P || Fh ( å Ci/Cmax ) problem where P designates the identical parallel machines, Cmax denotes the maximum completion time (makespan), å Ci represents the total flowtime, and the functional notation Fh ( å Ci/Cmax ) designates that we hierarchically minimize total flowtime subject to minimum makespan.

The P || å Ci problem can be optimally solved using the extension of McNaughton's algorithm (1959). As discussed by Conway et al (1967), this algorithm involves two steps: (1) order all n jobs in smallest processing time (SPT) order; and (2) assign the jobs from the SPT list to the m parallel machines in rotation. On the other hand, as shown by Bruno, Coffman, and Sethi (1974) and Garey and Johnson (1979), P || Cmax problem is known to be NP-hard. In view of the above results, it follows that the P || Fh ( å Ci/Cmax ) problem is also NP-hard.

Little work has been published on parallel machine scheduling under flowtime and makespan performance measure. Eck and Pinedo (1993) consider the problem of finding the minimum makespan schedule among the set of schedules that are optimal with respect to the minimum total flowtime measure. They propose a heuristic method and, for the two-machine case, show that it gives a minimum flowtime schedule with makespan that is guaranteed to be no more than 3.7037% above the makespan of the optimal schedule. Eck and Pinedo's algorithm generates the schedule by arranging the differences according to LPT rule.

This paper proposes an optimization algorithm to minimize total flowtime among the set of makespan-optimal schedules for the two parallel machines problem, represented as a P2 || Fh ( å Ci/Cmax ) problem. The rest of the paper is organized as follows: Section 2 introduces the assumptions and notation used to define and represent the P || Fh ( å Ci/Cmax ) problem. Section 3 discusses the proposed optimization algorithm for the P2 || Fh ( å Ci/Cmax ) problem and provides numerical examples to demonstrate the proposed algorithm. The simulation experiment and computational results are given in Section 4. Finally, we conclude the paper in Section 5 with some fruitful directions for future research.

2. Problem Definition and Representation

The shop environment we consider consists of a set of n jobs to be processed by m parallel identical machines. Each job requires one operation, and each operation can be processed by either one of the available m machines. The objective is to minimize total flowtime subject to minimum total makespan.

Without loss of generality, we assume that the jobs are sorted according to the LPT order and that enough artificial jobs with zero processing time are added to the set of jobs if the total number of jobs n is not an integer multiple of the number of machines m. In other words, we assume that the total number of jobs n is an integer multiple of the number of machines m and that jobs are so numbered that p1³ p2³ ..., ³ pn .The major assumptions used in this paper are listed below:

  • Job's processing time is known and deterministic.

  • Job preemption is not allowed, i.e., once a job starts processing on a machine, it must finish processing on that machine without interruption.

  • All jobs have the same ready time at zero.

  • No precedence relationships among jobs.

  • Each machine can process only one job at a time.

  • Setup time is included in processing time.

We use the following notation in the problem formulation.

Cmax optimal makespan.

Pi processing time for job i

xij a binary variable which has a value of 1 if job i is assigned to machine j and 0 otherwise.

f total flowtime.

qi the weight assigned to job i when computing flowtime.

We now formulate the P || Fh ( å Ci/Cmax ) problem as a following bi-level binary integer programming problem. The first level of the integer programming model finds the optimal makespan, Cmax while the second level of the model minimizes the flowtime subject to the optimal makespan found in the first level.

First Level Integer Program

subject to:

Second Level Integer Program

subject to:

The above problem formulation in relations (1) through (9) is a bi-level non-linear integer program which is very difficult to solve. While it can be simplified for the two-machine case (by defining a binary variable xi = 1 if job i is assigned to machine 1 and 0 otherwise); it still remains a bi-level non-linear integer program. Hence, we need to develop some alternative optimization methods for its solution. In this paper, we develop a lexicographic search based algorithm to solve P2 || Fh ( å Ci/Cmax ) problem

3. The Proposed Optimization Algorithm

Ho and Wong (1995) developed a lexicographic search based algorithm for optimally solving the P2 || Cmax problem. While the computational complexity of this algorithm is exponential, empirical results show that this algorithm is quite efficient in solving the P2 || Cmax problem. Therefore, we modify and extend this algorithm to develop an optimization algorithm for the P2 || Fh ( å Ci/Cmax ) problem.

The development of the optimization algorithm is pursued in two parts. In the first part, we assume that we know the optimal makespan schedule S with makespan value a* where the jobs on each of the two machines are processed in an SPT order giving a total flowtime b. Our first algorithm, obtained by a modification of the TMO algorithm developed by Ho and Wong (1995) finds a schedule with a minimum possible total flowtime given that its makespan is a*. In the second part, we use the TMO algorithm to find a schedule with optimal makespan value and also find a schedule which has a minimum makespan given optimal total flowtime value.

3.1. Solving the P2 || Fh ( å Ci/Cmax = a*) Problem

To describe an optimization algorithm for the P2 || Fh ( å Ci/Cmax = a*) problem, we define the following additional notations.

Sum

the sum of the processing time of all jobs.

restl the sum of the processing time of the set of jobs with indices >l. Ni

the node at level l.

Vi the value of node Ni. Z the current incumbent total flowtime. S " the schedule defined as follows: the path from the root node to the node that generates a* makespan represents the set of jobs assigned to machine 1, the rest of the jobs are assigned to machine 2 where jobs on each machine are in SPT order. b" the total flowtime of schedule S"

For solving the P2 || Fh ( å Ci/Cmax = a*) problem, we use a binary tree to develop a lexicographic search based algorithm. The root node at level 0 has a value of 0. At each level, l = 1, 2,..., n, in the tree, a given job is added to the partial schedule developed at the previous level. Any node at level l takes on one of two possible values as follows. If N i is its parent's left child, which means that job l is assigned to machine 1, then the value of N i is its parent's value plus the processing time of job l. If it is the right child, which indicates job l is assigned to machine 2, then the node has the same value as its parent's. The makespan for machine 1 is denoted by the value of the leaf; while the makespan for the schedule equals to the larger of the makespan of machine 1 and the sum of the processing time of all jobs minus the makespan of machine 1. The paths from the root node to the nodes with makespan a* constitute the set of schedules that need to be evaluated. Following the above reasoning, the steps of the modified TMO algorithm are as follows:

Algorithm M: (Modified TMO Algorithm)

Input:

n even, Pi where p1 ³ p2 ³ ..., ³ pn schedule S with makespan a* and total flowtime b where jobs on each machine in schedule S are processed in an SPT order.

Step 1: Set Z = b and S''= S . Calculate Sum = and restl = for l = 1, 2,..., n –1; and restn = 0. If p1= a*, set S* = S'', and go to step 3; otherwise mark the right child of the root node dead (because of the symmetry between the two machines). Step 2:
  • If there is no living node, go to step 3. (Note that searching starts from the current node through a depth-first searching scheme.)

  • Find the first living node through depth-first search, if it is at level n, then restart Step 2.

  • Expand this node. If it doesn't have a left child, then its left child, N i, is generated; otherwise, its right child, N i, is generated.

  • If N i is its parent's right child, then mark parent dead.

  • If max{Vi ,(Sum – Vi )}= a*and Z < b'', set Z = b''and S* =S'' .

  • If max{Vi ,(Sum – Vi )}= a*, restart Step 2.

  • If Vi>a*, mark N dead and restart Step 2.

  • Let l be the level which N i is on.

  • If Vi +restl < Sum – a*, mark N i dead.

  • Restart Step 2.

Step 3: Stop. The schedule S* yields the minimum total flowtime schedule Z given makespan = a*

The algorithm M described above is designed to determine all schedules with makespan = a*. Hence, it terminates only if p1 = a* (Step 1) or there is no living node (Step 2). Whenever a makespan schedule with makespan = a* is found, algorithm M updates Z and S* if the total flowtime of the optimal makespan schedule is less than Z. To avoid the unnecessary search of nodes, the criteria used in the TMO algorithm to mark dead nodes are also applied in algorithm M.

3.2 Solving the P2 || Fh (Cmax / å Ci) Problem

In our solution to the P2 || Fh ( å Ci/Cmax ) problem, we will need to solve another hierarchical criteria problem of minimizing makespan subject to minimum total flowtime, the P2 || Fh (Cmax / å Ci) problem. From the analysis of the P2 || å Ci problem by Conway, Maxwell, and Miller (1967), it follows that if jobs are arranged in the LPT (longest processing time) order, then, a pair of jobs at sequence positions 2i –1 and 2i are processed on different machines. Therefore, arranging the jobs in the LPT order, Eck and Pinedo (1993) defined an alternative P2 || Cmax problem where the processing time of job i, di= p2i-1 – p2i(equals the difference of the processing times of the pair of jobs at sequence positions 2i –1 and 2i) and the total number of jobs s = n/2. This problem can be optimally solved by the TMO algorithm. Suppose the final solution for this alternative P2 || Cmax problem is p = (p(1),...,p(k))as the assignment of jobs to machine 1 and r = (r((1),..., r(q)) as the assignment of jobs to machine 2. Then, for the original problem, the assignment of jobs to machines 1 and 2 are given by S1= {s2p (r)| r £ k; s2r(r)| r £ q } and S2 = {s2p (r)| r £ k; s2r(r)-1 | r £ q } respectively. Processing the jobs in S1 and S2 in the SPT (shortest processing time) order optimally solves the P2 || Fh (Cmax / å Ci) problem.

3.3 Solving the P2 || Fh ( å Ci/Cmax ) Problem

We now propose an optimization algorithm to optimally solve the P2 || Fh ( å Ci/Cmax ) problem. To do so, we first use the TMO algorithm to find a schedule S with an optimal makespan value a* and a corresponding value of total flowtime b when jobs in S are processed in an SPT order. We then formulate an alternative P2 || Cmax problem to optimally solve the P2 || Fh (Cmax / å Ci) problem. If the optimal makespan value a for the P2 || Fh (Cmax / å Ci) problem equals the optimal makespan value of the unconstrained P2 || Cmax problem, then the solution of the P2 || Fh (Cmax / å Ci) problem is an optimal solution of the P2 || Fh ( å Ci/Cmax ) problem. If not, we use algorithm M developed above to find a minimum total flowtime schedule given an optimal makespan value a*. The steps of the extended TMO algorithm to optimally solve the P2 || Fh ( å Ci/Cmax ) problem, therefore, are as follows:

Algorithm E: (Extended TMO Algorithm)

Input: n even, pi where p1 ³ p2 ³ ..., ³ pn.

Step 1:

Apply the TMO algorithm to find the optimal makespan schedule, S, and arrange the jobs processed on each machine in the SPT order. Let a* and b be the makespan and total flowtime of S, respectively.

Step 2: Create an alternative problem by setting array di (i = 1,2,...,n/2), such that di = p2i-1 – p2i. Sort the di values in the descending order. Apply the TMO algorithm to the alternative problem. Transform the TMO solution into the corresponding schedule S' for the original problem with n jobs, where jobs processed at each machine are processed in an SPT order. Let a and b* be the makespan and total flowtime of S'. If a = a* , set S* =S'and go to Step 4; otherwise enter step 3. Step 3:

Apply algorithm M to the original problem with makespan = a* and schedule S to find the optimal schedule S* with total flowtime Z Enter step 4.

Step 4: Stop. The schedule S* is the minimum total flowtime schedule given the optimal makespan a*.

Step 1 applies the TMO algorithm to determine the optimal makespan, a*. Step 2 constructs an alternative P2 || Cmax problem by creating job processing times (array di) which are equal to differences in processing times among consecutive pairs of jobs in the original problem. It applies the TMO algorithm to the alternative problem and transforms the TMO solution into the corresponding solution for the original problem. The corresponding solution possesses the optimal total flowtime, b*. If the makespans of the schedules obtained in Step 1 and 2 are equal, then the optimal solution is found since the schedule obtained in Step 2 possesses both optimal makespan (a*) and optimal total flowtime (b*). Otherwise, we proceed with Step 3 and apply algorithm M to find a solution with minimum total flowtime with makespan = a*, and update the current best total flowtime if a lower total flowtime is found. Lastly, Step 4 outputs the optimal schedule S* and terminates the proposed algorithm.

3.4 Numerical Examples

Two numerical examples are employed to demonstrate the proposed algorithm. The first example has nine jobs and their processing times are: 37, 16, 44, 39, 11, 29, 25, 50, and 12. Let Si be the sequences of jobs assigned to machine i of schedule S. To solve this problem using the proposed Algorithm E, we first order the jobs in an LPT order and get p1 = 50, p2= 44, p3 = 39, p4 = 37, p5 = 29, p6 = 25, p7 = 16, p8 = 12, p9 = 11, and p10 = 0. Using the TMO algorithm, we find S1 = (J10,J4,J2,J1) , S2 = (J9,J8,J7,J6,J5,J3), a* = 132, and b = 611. We find the processing times of the alternative problem as di = {6, 2, 4, 4, 11} and using the procedure outlined in Section 3.2, we obtain an optimal schedule of the P2 || Fh (Cmax / å Ci) problem as = (J9,J8,J6,J3,J2), = (J10,J7,J5,J4,J1), a =132, and b* = 575. Since a = a*, we set S* =S', and terminate the search as optimal solution has been found. The proposed algorithm returns a total flowtime of 575, which is 6.26% lower than that of the TMO algorithm.

Example 2 consists of ten jobs and their processing times are: 8, 46, 30, 19, 4, 36, 21, 23, 6, and 17. We arrange the jobs in LPT order to p1 = 46, p2= 36, p3 = 30, p4 = 23, p5 = 21, p6 = 19, p7 = 17, p8 = 8, p9 = 6, and p10 = 4. Solving the problem using TMO gives S1= (J4,J2,J1), S2= (J10,J9,J8,J7,J6,J5,J3), a* = 105, and b = 488. We formulate the alternative problem with di = {10, 7, 2, 9, 2} and using the procedure in Section 3.2, we solve the P2 || Fh (Cmax / å Ci) problem to get its optimal solution as = (J9,J8,J5,J4,J1), = (J10,J7,J6,J3,J2), a =106, and b* = 458.

Since a ¹ a*, we use algorithm M to find an optimal solution. The schedules generated by the application of algorithm M are shown in Table 1 and result in an optimal schedule with b* = 460 when makespan a* = 105.

4. Computational Results

A simulation experiment was performed to evaluate the effectiveness of the proposed algorithm by comparing the value of its total flowtime to that found by using the TMO algorithm. The TMO algorithm was selected since it guarantees the optimal makespan, which is a requirement of the problem considered in this paper. In addition, we also compared the optimal values of the total flowtime for the P2 || Fh ( å Ci/Cmax ) and P2 || å Ci problems.

We considered two factors in the simulation study: the number of jobs and the variability of processing times. The number of jobs was set in 16 levels: 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 30, 40, 50, and 100. The processing times were generated from a uniform distribution, U(a,b), and set at three levels: U(1,50), U(1,100) and U(1,200) The uniform distribution was chosen because it is commonly used in the literature. These two factors give a total of 48 sets of problems. For each set of problems, 100 replications are made. Hence, a total of 4,800 problems are solved. All algorithms were programmed in Microsoft FORTRAN running on an Intel Pentium-based microcomputer.

4.1. Effectiveness of the Proposed Algorithm

For each problem, we computed the percentage deviation of the total flowtime obtained using the TMO algorithm from the optimum total flowtime value found by algorithm E. For each set of problems, we report the mean and maximum percent deviations for TMO. Moreover, we tabulate the percentage of the time that the proposed algorithm E outperforms TMO for each set of problems.

Table 2 gives the mean and maximum percent deviations of the total flowtime using the TMO algorithm from the optimal total flowtime. From Table 2, it is clear that as the number of jobs increases, both mean and maximum percent deviations tend to increase. The three largest mean percent deviations occur when n = 100. Moreover, results in Table 2 show that as the variability of processing times decreases, the mean percent deviation figures increase in every case except the following two cases: when n = 9 and from U(1,200) to U(1,100) and n = 100 and from U(1,100) to U(1,50) The averages of the mean percent deviation figures for U(1,50), U(1,100) and U(1,200) are 6.34%, 5.74%, 5.25%, respectively. The maximum percent deviation figures also tend to increase as variability of processing times decreases, though not as pronounced as the mean percent deviation. In summary, results in Table 2 show that the use of proposed algorithm E significantly improves the total flowtime of the minimum makespan schedule obtained by the TMO algorithm.

Table 3 reports the percentage of problems that the proposed algorithm outperforms the TMO. Similar to the conclusions obtained from Table 2, Table 3 shows that as the number of jobs increases or/and variability of processing times decreases, the proposed algorithm E becomes more effective since the percent of problems for which TMO fails to find optimal total flowtime schedules increases. The proposed algorithm E always returns a smaller total flowtime than the TMO when n = 14. On average, the proposed algorithm outperforms the TMO algorithm for U(1,50), U(1,100) and U(1,200) in 96.1%, 93.6%, and 91.3% of the problems, respectively.

4.2. Optimal Flowtimes for the P2 || Fh ( å Ci/Cmax ) and P2 || å Ci Problems

For each problem size and dataset, the mean and maximum percentage deviations of the optimal flowtime value for the P2 || Fh ( å Ci/Cmax ) problem from that for the P2 || å Ci problem are shown in Table 4

In addition, Table 5 shows the percentage of the problems for which this percentage deviation was greater than zero. From these results, it is clear that the total flowtime for the two problems can be quite different. Hence, use of the proposed algorithm E is useful.

4.3 Efficiency of the Proposed Algorithm

For each problem set, Table 6 gives CPU time for the TMO and the proposed algorithms. It shows that the solution of 100 problems in each set, the TMO and proposed algorithms on average require 0.135 and 0.486 seconds, respectively. Nonetheless, the proposed algorithm is very fast and can be used to solve both large and small size problems. For example, the largest set CPU time of the proposed algorithm is just 1.88 seconds when n = 20. One very interesting observation concerning the number of jobs factor is the fact that the CPU time of the proposed algorithm increases as n increases from 9 to 20, then it decreases when n increases from 20 to 30 and increases again when n increases from 30 to 100. This is because when 20 < n < 30, the probability that the proposed algorithm terminates in Step 2, due to the condition that a = a*, becomes very high (almost 100%) and remains stable. Thus, the CPU time therefore goes down. When n > 30, the increase in CPU time is purely due to the increase in the number of jobs. Furthermore, results in Table 6 show a positive correlation between processing time variability and CPU time.

5. Conclusions

This paper considered the two-identical-parallel-machine problem to minimize total flowtime subject to minimum makespan and proposed an optimization algorithm for its solution. Computational results of a simulation study with randomly generated problems show that the proposed optimization algorithm E is quite efficient in optimizing large-sized problems. On the average, for the three cases of processing times variability U(1,50), U(1,100) and U(1,200) the total flowtime value obtained by proposed algorithm E are 6.34%, 5.74%, 5.25% less than those found using the TMO algorithm, respectively. The computational results also indicate that the proposed algorithm, which finds optimal total flowtime, outperforms the TMO in all 48 sets of problems. Furthermore, the proposed algorithm returns a smaller total flowtime than that of TMO in 93.65% of the 4,800 test problems. In terms of CPU time, both algorithms are very efficient, the mean CPU time per set of 100 problems for the proposed and TMO algorithms are 0.486 and 0.135 second, respectively.

Several issues are worthy of future investigations. First, extension of results to the m-identical-parallel-machine case (m > 2) will be worthwhile. Second, the solution of the problem with the reverse hierarchical optimality criteria, namely, the identical-parallel-machine scheduling problem where the primary criterion is the minimization of the total flow-time and the secondary criterion is the minimization of the maximum completion time (makespan) is both interesting and useful. Third, the development of algorithms for other secondary criteria such as the total tardiness subject to the minimum makespan is a fruitful area of research. Finally, extension of our results to more complex machine environments, such as multi-stage flowshop and job-shop problems, is important for application in industry.

  • (1) Bruno, J., Coffman, E.G., & Sethi, R. (1974). Scheduling independent tasks to reduce mean finishing time. Communications of the ACM, 17, 382-387.
  • (2) Chen, C. & Bulfin, R.L. (1993). Complexity of single machine, multi-criteria scheduling problems. European Journal of Operational Research, 70, 115-125.
  • (3) Conway, R.W., Maxwell, W.L., & Miller, L.W. (1967). Theory of Scheduling. Addison Wesley, Reading, MA.
  • (4) Eck, B.T., & Pinedo, M. (1993). On the minimization of the makespan subject to flowtime optimality. Operations Research, 41, 797-800.
  • (5) Garey, M.R. & Johnson, D.S. (1979). Computers and Intractability: A Guide to the Theory of NP-Completeness. Freeman, San Francisco, CA.
  • (6) Ho, J.C., & Wong, J.S. (1995). Makespan minimization for parallel identical processors. Naval Research Logistics, 42, 935-948.
  • (7) Lee, C.-Y. & Vairaktarakis, G.L. (1993). Complexity of single machine hierarchical scheduling: a survey. In: Complexity in Numerical Optimization [edited by P.M. Pardalos], World Scientific Publishing Company, 269-298.
  • (8) McNaughton, R. (1959). Scheduling with deadlines and loss functions, Management Science, 6, 1-12.
  • (9) Nagar, A., Haddock, J., & Heragu S. (1995). Multiple and bicriteria scheduling: A literature survey. European Journal of Operational Research, 81, 88-104.

Publication Dates

  • Publication in this collection
    27 May 2003
  • Date of issue
    June 2000
Sociedade Brasileira de Pesquisa Operacional Rua Mayrink Veiga, 32 - sala 601 - Centro, 20090-050 Rio de Janeiro RJ - Brasil, Tel.: +55 21 2263-0499, Fax: +55 21 2263-0501 - Rio de Janeiro - RJ - Brazil
E-mail: sobrapo@sobrapo.org.br