A Method for the Buffer Allocation Problem with

The 11th Asia Pacific Industrial Engineering and Management Systems Conference The 14th Asia Pacific Regional Meeting of International Foundation for Production Research Melaka, 7 – 10 December 2010

A Method for the Buffer Allocation Problem with Collision Probability Using Computer Simulation Eishi Chiba † Department of Industrial & Systems Engineering, Hosei University 3-7-2 Kajino-cho, Koganei-shi, 184-8584, Japan Email: [email protected]

Abstract - A manufacturing system for Flat Panel Displays (FPDs) consists of series of equipments, each of which is usually equipped with enough number of buffers to avoid collision between glass substrates. However, they often contain redundant buffers which are not actually used. In order to reduce the production cost, the number of buffers should be minimized. In this paper, assuming a constant inter-arrival time of glass substrates, we present a computer simulation method for computing the collision probability on an in-line system in which each equipment can have any size of buffer. Based on this, we try to find a buffer allocation that achieves the smallest total number of buffers under an arbitrarily specified collision probability. We also present some computational results. Keywords: Buffer allocation, Collision probability, Tact time, In-line machines model, Stochastic model

1. INTRODUCTION Reflecting the increasing demand on Flat Panel Displays (FPDs) such as LCD, plasma display panel, etc., more effective method for their manufacturing is required. The production rate improves with technological advancements such as the rapid enlargement of glass substrates and the miniaturization of patterns. Accordingly, production line has to be modified to accommodate such advancements, and new optimization problems continue to arise. Lately an advanced system called a Crystal Flow has been introduced in the production line of FPDs. It targets a higher level of line control in the next-generation production processes as well as in existing lines. The main flow of FPD process is shown in Fig. 1. Each processing equipment in Fig. 1 is specialized to such operations as cleaning, coater, proximity exposure, developer, etcher, resist remover, etc. All equipments are connected in-line, and there are buffers between equipments. Most of the production lines adopts a simple strategy to feed each glass substrate to the first equipment with a constant inter-arrival time, which is called the tact time. This strategy is simple and enables us to estimate the number of products precisely. However, due to solution foaming, chemicals, heat treating, etc., the processing time at each equipment is uncertain and may vary according to the condition at that time. If a substrate is sent to an

________________________________________ † : Corresponding Author

equipment while it is still processing the current substrate and all buffers of the equipment are occupied, there is no room where the current substrate is placed. This phenomenon is called a collision between substrates. Since the glass substrate is expensive and fragile, the collision should be avoided as much as possible. A collision-like phenomenon is called a blocking in scheduling theory, and is studied as an important factor to determine line efficiency. However, depending on the rule how to handle collisions (blocked calls cleared, blocked calls delayed, etc.), previous work mainly focused on performance measures in the steady state. Moreover, the distributions of the arrival and the processing time were also restricted such as a exponential distribution for mathematical analysis. In this paper, given the number of jobs to be processed in the prescribed time span, we consider as performance measure the probability that there is at least one collision. The number of buffers should be minimized to reduce the production cost, which however increases the collision probability. Thus there is a trade-off between the number of buffers and the collision probability. To consider this trade-off it is important to evaluate the collision probability under a given buffer allocation. The Probability Density Function (pdf) of actual processing time at an equipment is often represented by a bell-like curve such as Fig. 2 (e). The pdf of the normal distribution is also bell-shaped, but it has a weakness that

The 11th Asia Pacific Industrial Engineering and Management Systems Conference The 14th Asia Pacific Regional Meeting of International Foundation for Production Research Melaka, 7 – 10 December 2010

Entrance

Cleaning

Film Deposition

Resist Coating

Etching

Inspection

Development

Exposure

Resist Stripping

Rubbing

Crystal Filling

Exit

and Assembly

Fig. 1. FPD Process Flow

Fig. 2. The pdf of the Erlang distribution : (a) k=1, =1 (exponential distribution); (b) k=2, =2; (c) k=5, =5; (d) k=10, =10; (e) k=30, =30. the pdf takes positive value in the negative domain, which is not true in the pdf of actual processing time. In this paper, we assume that the processing time follows an Erlang distribution. The pdf of the Erlang distribution is defined as follows.

(1) where two parameters k and are a positive integer and a positive real number, respectively. Its expectation and variance are given by k / and k / , respectively. Therefore, under the Erlang distribution, we can realize the expectation and the variance independently by setting parameters and k appropriately. In Fig. 2, five different

pdfs are plotted, where expectations of all cases are the same, but their variances decrease with cases of Fig. 2 (a) ~ (e). Thus the Erlang distribution is flexible enough to represent actual processing times. It was shown in Chiba et al. (2007) that, under no buffer assumption, the collision probability can be approximately expressed by a closed form formula. A computer simulation method for computing the collision probability was also presented in Chiba et al. (2007). In this paper, we present a new buffer allocation problem, which is modeled as a variation of the flow shop scheduling problem. This problem is of great importance to manufactures; however, no literature exists for such problem to the best knowledge of the authors. First, we present a computer simulation method for computing the collision probability on an in-line system in which each equipment has an arbitrary size of buffer. Then, based on the method, we try to obtain a buffer allocation with the smallest total number of buffers that achieves an arbitrarily specified collision probability. The remainder of this paper is organized as follows. In Section 2, we describe a formal model of the production line of FPD. Then we formulate our problem as an optimization problem. In Section 3, we consider how to derive start and finish times of each job at each equipment under infinite buffer space. In Section 4, we present a computer simulation method to evaluate the exact collision probability. In Section 5, based on the simulation method, we present a heuristic method to minimize the total number of buffers. In Section 6, we give some computational results, and confirm that it computes good solutions in realistic computation time. Finally, Section 7 concludes this paper.

The 11th Asia Pacific Industrial Engineering and Management Systems Conference The 14th Asia Pacific Regional Meeting of International Foundation for Production Research Melaka, 7 – 10 December 2010

2. MODEL AND PROBLEM FORMULATION To describe our model, the following notations will be used:  M1, M2, … , Mm: m different equipments in the line.  J1, J2, … , Jn: n jobs to be processed.  Ti(j) (> 0): Processing time of job Ji on equipment Mj.  ttact (> 0): Tact time, i.e., the time difference between the start time instants of Ji and Ji+1 for all 1 i n -1 at the entrance to the line.  bj ( +): the number of buffers in front of equipment Mj. A typical production model is illustrated in Fig. 3. With the same time interval ttact, jobs are successively fed to the line from the entrance. Every job is first processed on equipment M1. It is then automatically transported to the next equipment M2 after being finished on M1. It is assumed for simplicity that the transportation time between equipments is nil. As soon as M2 receives the job and is not busy, it starts processing the job. In this manner, every job is processed on equipments in the order of M1, M2, …, Mm, and then sent to the exit. We assume that the processing time Ti(j) on Mj is a random variable that follows the Erlang distribution with parameters j and kj (but independent of i). Furthermore we assume that all Ti(j) (1 i n-1, 1 j m) are independent of each other. A job Ji waits in a buffer of Mj if Mj is still processing a prior job Jk when the job Ji arrives at Mj. In such case, we assume that the queue scheduling discipline is First-In-First-Out (FIFO). In FIFO queuing, all jobs are processed in the same order of their arrivals to the queue. The maximum length of the queue in front of each Mj is at most the number of buffers bj. (In Fig. 3, b1, b2, and bm are set to 2, 3, and 1, respectively.) The collision occurs if the next job arrives at Mj while Mj is still processing the current job and all buffers of Mj are occupied. The collision probability is the probability that there is at least one collision in the system. A buffer allocation is a mapping Mj z ( +). It is called feasible if the collision probability is less than or

equal to a given value . Then our problem, i.e. Buffer Allocation Problem with Collision Probability is stated as follows: Given the number of jobs n, the number of equipments m, the tact time ttact, parameters of the Erlang distribution for equipments Mj, and (0 1) (specifying the collision probability), minimize the objective function B := (i.e., total number of buffers) over the set of all feasible buffer allocations. An optimal buffer allocation is a feasible buffer allocation that achieves the smallest objective value.

3. SCHEDULING UNDER INFINITE BUFFER SPACE In this section, we assume that the number of buffers bj is infinite for all 1 j m. We introduce the following variables for the definition of a schedule.  sti(j): Time instant when job Ji is started on equipment Mj,  fti(j): Time instant when job Ji is finished on equipment Mj. A schedule is then a mapping Ji →(sti(j), fti(j): 1 j m). Suppose that Ti(j) = ti(j) hold for 1 i n, 1 j m. Then, using the tuple of processing times , we can compute the schedule as below. Ji is started on Mj as soon as Ji is finished on Mj-1 and Ji-1 is finished on Mj. Ji is finished on Mj at the time instant when the processing time ti(j) passes after it is started. We consider that Ji is finished on M0 at the time instant (i - 1) ttact since each job is fed to the line from entrance with ttact interval. Therefore, we obtain the following recursive expressions. sti(j)= max{ fti(j-1), fti-1(j)} (1 i n, 1 j m), (2) (3) Clearly, the time complexity of this method is (mn), as filling each entry requires (1) time. The obtained schedule will be used in the next section in order to check whether a collision occurs.

In-line system Entrance

M1

M2

…

Mm

Fig. 3. In-line system with buffer space.

Exit

The 11th Asia Pacific Industrial Engineering and Management Systems Conference The 14th Asia Pacific Regional Meeting of International Foundation for Production Research Melaka, 7 – 10 December 2010

4. COLLISION CHECKING BY SIMULATION ALGORITHM Given a tuple of processing times , we can compute its schedule as stated in previous section. In this section, using the obtained schedule, we present how to decide whether there is at least one collision. Then, based on it, we describe a simulation algorithm to evaluate the exact collision probability, after introducing the next definition. Definition 1. A subsequence of jobs, i.e., (Jp, Jp+1, … , Jq) for some 2 ≤ p ≤ q ≤ n, is the consecutive waiting sequence on equipment Mj (1 ≤ j ≤ m) if there is a j (1 ≤ j ≤ m) such that ftk(j-1) < ftp-1(j) holds for all k = p, p+1, … , q. A subsequence (Jp, Jp+1, … , Jq) is called a maximal consecutive waiting sequence if it is a consecutive waiting sequence but adding any job (Jp-1 or Jq+1) would destroy that property. A maximal consecutive waiting sequence is called the maximum if its size (i.e., q - p + 1) is the largest. Note that ftk(j-1) < ftp-1(j) means that Mj is still processing Jp-1 when job Jk arrives at Mj from Mj-1. Therefore if there is a maximal consecutive waiting sequence (Jp, Jp+1, … , Jq), then all jobs in the sequence wait in the buffer of Mj. In other words, the collision occurs if its size is smaller than the size q - p + 1 of the maximum consecutive waiting sequence. Based on the above discussion, the following algorithm decides whether a collision occurs, which is written in a style like C. Function COLLISION_CHECK(Mj) Input: Tuple of (fti(j-1), fti(j): 1 ≤ i ≤ n) computed as described in Section 3 (i.e., (2) and (3)), and the number of buffers bj. Question: Is there at least one collision on Mj? 1. i = 1; k = 1; 2. while (k ≤ n) {

3. 4. 5. 6. 7. 8.

if (ftk(j-1) < fti(j)) { if (bj < k - i) return j; // Collision occurs on Mj. else k++; } else i++; } return 0; // Collision doesn't occur on Mj.

Two variables i and k are initialized to one. Then, in each iteration of while loop (line 3 ~ line 6), the i or k is incremented by one. Therefore, the computation time is O(n). In line 4, k - i corresponds to the size of the current consecutive waiting sequence. Lemma

1.

Given a tuple of processing times , we can decide in O(mn) time whether there is at least one collision on some equipments Mj (1 ≤ j ≤ m). Example 1. We consider the schedule on Mj-1 and Mj as shown in Fig. 4, where there are two maximal consecutive waiting sequences on Mj, i.e., (J2, J3, J4, J5) and (J3, J4, J5, J6, J7). Therefore, Mj needs at least five buffers to avoid a collision. In Fig. 4, broken lines depict the comparisons made in line 3 of COLLISION_CHECK(Mj). Using COLLISION_CHECK(Mj), we can evaluate the collision probability as follows. Algorithm SIMULATE Input: The number of jobs n, the number of equipments m, the number of buffers bj for all 1 ≤ j ≤ m, the tact time ttact, parameters of the Erlang distribution for equipments Mj, and a positive integer c (specifying the number of iterations, which is related to the accuracy). Output: The collision probability. Step 1: loop:=1. Step 2: Generate processing times ti(j) (1 ≤ i ≤ n, 1 ≤ j ≤ m) randomly from the Erlang distribution.

Fig. 4. An example of the schedule on Mj-1 and Mj.

The 11th Asia Pacific Industrial Engineering and Management Systems Conference The 14th Asia Pacific Regional Meeting of International Foundation for Production Research Melaka, 7 – 10 December 2010

Step 3: Compute the schedule of n jobs as explained in Section 3 (i.e., (2) and (3)), assuming infinite buffer space. Step 4: Check whether the schedule of Step 3 induces a collision by applying COLLISION_CHECK(Mj) for j = 1, … , m. Let loop := loop + 1. If loop ≤ c, return to Step 2; otherwise go to Step 5. Step 5: Output the obtained collision probability (i.e., (the number of collisions observed in Step 4) / c). Computation time in the loop of Steps 2, 3 and 4 is (mn). Therefore, SIMULATE returns the computed collision probability in (cmn) time.

5. A HEURISTIC METHOD FOR OPTIMAL BUFFER ALLOCATION In this section, we present a heuristic method for the buffer allocation problem. This method is composed of three Stages. Stage 1 computes by simulation a buffer allocation (bj*: 1 ≤ j ≤ m) such that the collision probability is zero (in c iteration of simulation). This will serve as an upper bound on the optimal numbers of buffers. Step 1: loop := 1, bj* = 0 for all 1 ≤ j ≤ m. Step 2: Generate a set of processing times ti(j) (1 ≤ i ≤ n, 1 ≤ j ≤ m) randomly from the Erlang distribution. Step 3: Compute the schedule by the method in Section 3 (i.e., (2) and (3)). If the size of the maximum consecutive waiting sequence on equipment Mj is greater than bj*, update the value of bj* to the size. Step 4: Let loop := loop + 1. If loop ≤ c, return to Step 2; otherwise go to Step 5. Step 5: leftj := 0, rightj := bj* for all 1 ≤ j ≤ m. This algorithm is similar to SIMULATE in Section 4, but is simpler because it records only the maximum size of consecutive waiting sequences observed in Step 3. The leftj and rightj obtained in Step 5 will be used as lower and upper bounds on the optimal size bj of buffers. Stage 2 obtains a feasible buffer allocation bj (1 ≤ j ≤ m). Step 1: Let bj := 0 for 1 ≤ j ≤ m. Step 2: With the current buffer allocation (bj : 1 ≤ j ≤ m), compute the collision probability ' by using SIMULATE of Section 4. In computing ', record the index k of the equipment on which the most collisions occurred. Step 3: If < ' holds for a given collision probability , let leftk := bk, bk := (leftk + rightk)/2, then return to Step 2.

When we add some buffers to an equipment, we take a greedy approach in the sense that it is added in Step 3 to the equipment on which the most collisions occurred. Buffers are only added in Stage 2, which may result in excessive numbers of buffers. To remedy this we then apply Stage 3. Stage 3 adjusts bj (1 ≤ j ≤ m) by binary search to obtain a locally optimal buffer allocation. Step 1: Perform Steps 2 ~ 6 for each 1 ≤ k ≤ m. Step 2: rightk := bk. Step 3: bk := (leftk + rightk) / 2. Step 4: With the buffer allocation (bj : 1 ≤ j ≤ m), compute the collision probability ' by SIMULATE. Step 5: If < ' holds, let leftk := bk + 1; otherwise let rightk := bk - 1. Step 6: If leftk < rightk holds, return to Step 3; otherwise let bk := leftk. The binary search of Steps 2 ~ 6 is justified by the fact that the collision probability is monotonically decreasing with the number of buffers bj. After performing the above three stages, the obtained buffer allocation (bj : 1 ≤ j ≤ m) is clearly feasible, and decreasing any value of bj would destroy the feasibility. Therefore, the obtained buffer allocation is locally optimal. We analyze the time complexity as follows. Stage 1 costs (cmn) time. Step 2 in Stage 2 and Step 4 in Stage 3 cost (cmn), respectively. Other Steps cost (1), respectively. The total number of iterations of Steps 2 ~ 3 in Stage 2 and Steps 3 ~ 6 in Stage 3 is at most log b1* + …+ log bm* = log . Therefore, the total computation time is O(cmn log )= O(cm2n max1 ≤ j ≤ m log bj*).

6. COMPUTATIONAL EXPERIMENT We implemented the simulation algorithm in Section 5 on a Panasonic Let's Note CF-Y5 PC (CPU: Intel Core Duo 1.5GHz, RAM: 1GByte, OS: Microsoft Windows XP Professional). For our computation, the number of jobs is set to n = 100, the number of equipments is set to m = 8, the tact time is set to ttact = 1, and parameters of the Erlang distributions are set so that the expectation and the variance of the processing time on each equipment become equal to 1 and 0.01, respectively (i.e., k = 100, = 100 in (1)). In other words, we consider the uniform case in which every equipment has the same performance. Through all simulations, we use Mersenne Twister as the pseudorandom generator, and the number of iterations is set to c = 10,000. Parameters of the collision probability are set to = 0.00, 0.05, … , 0.30, respectively. The results are shown in Table 1. From Table 1, the buffer allocation is (3, 3, 3, 3, 3, 2, 2, 2) for = 0.05, whose collision probability is 0.0333 (≤ 0.05). Therefore,

The 11th Asia Pacific Industrial Engineering and Management Systems Conference The 14th Asia Pacific Regional Meeting of International Foundation for Production Research Melaka, 7 – 10 December 2010

Table 1. Buffer allocation obtained by our heuristic method.

0.00 0.05 0.10 0.15 0.20 0.25 0.30

b1 5 3 3 2 2 2 2

b2 5 3 3 3 3 2 2

b3 5 3 3 3 2 3 2

b4 4 3 2 2 2 2 2

b5 4 3 2 2 2 2 2

the buffer allocation is feasible. As shown in Table 1, the total number of buffers B decreases with . The CPU time also decreases with . This is because the number of iterations of Steps 2 ~ 3 in Stage 2 and Steps 3 ~ 6 in Stage 3 is large when is small in the computational experiment. The results may indicate that our heuristic method computes a local optimal buffer allocation in realistic computation time.

7. CONCLUSION We presented a heuristic method for the buffer allocation problem under the constraint of a given collision probability. Our method computes a local optimal buffer allocation in realistic computation time. Analyzing our method in more detail, and then applying our method to real manufacturing systems for FPDs remains as our future work.

b6 4 2 2 2 2 2 2

b7 4 2 2 2 2 2 2

b8 3 2 2 2 2 2 2

B 34 21 19 18 17 17 16

CPU time(sec.) 365 264 244 230 226 217 217

Chiba, E., Fujiwara, H., Sekiguchi, Y., Ibaraki, T. (2007) Collision probability in an automated production line under Erlang distribution, In Proceedings of 5th International Conference on Research, Innovation and Vision for the Future (RIVF 2007), 42-49 Kleinrock, L. (1975) Queueing Systems, Volume I: Theory, Wiley Interscience. Pinedo, M. (2002) Scheduling: Theory, Algorithms, and Systems, Prentice-Hall. Crystal Flow HP: http://www.febacs.co.jp/eng/solu tion /crystal.html Mersenne Twister HP: http://www.math.sci.hiroshima -u.ac.jp/~m-mat/MT/emt.html FPD process HP: http://www.screen.co.jp/fpd/process/ index_e.html

REFERENCES Chiba, E., Fujiwara, H., Ibaraki, T. (2007) A new approach to approximate the collision probability in an automated production line, Information Technology Letters, 1-4.

AUTHOR BIOGRAPHIES Eishi Chiba is an Assistant Professor at the Department of Industrial & Systems Engineering, Faculty of Science and Engineering, Hosei University, Japan. He received a Doctoral Degree from the Japan Advanced Institute of Science and Technology (JAIST) in 2006. His main research interests include operations research