Parallel Discrete Event Simulation of Manufacturing Systems using PARSEC

1. Parallel Discrete Event Simulationof Manufacturing Systemsusing PARSEC Ye ZHANG, Wentong CAI & Stephen J. TURNER School of Applied Science, Nanyang Technological University, Singapore 639798 ASSJTurner@ntu.edu.sg

2. Structure of the Talk • Introduction & Research Aims • PARSEC Simulation Language • Manufacturing Simulation • Setup Rule • Implementation using PARSEC • Performance Results • Overhead Comparison • Speed Up • Conclusions and Future Work • POMSim

3. Introduction • Parallel Discrete Event Simulation (PDES) Languages • A number of PDES languages have been developed in recent years, e.g. PARSEC, TeD, APOSTLE. • Most of these languages are general purpose languages and lack features to support special models, such as those found in manufacturing simulation. • Semiconductor Manufacturing Simulation • Our study focuses on the simulation of wafer fabrication processes. • One feature that complicates the simulation is the implementation of dispatching and setup rules to determine the scheduling of products.

4. Research Aims • Research Aims • The aim of this paper is to study how such scheduling rules may be implemented in a general purpose parallel simulation language, such as PARSEC. • PARSEC was chosen for its availability, simplicity and efficient event scheduling mechanism. • The performance of different implementation alternatives of a wafer fabrication simulation are compared. • A further aim is to determine what features should be provided in a parallel simulation language designed specifically for manufacturing simulation.

5. PARSEC Simulation Language • Buffered Message Passing • Developed at UCLA, PARSEC separates the simulation model from the underlying simulation protocol (e.g. sequential, parallel conservative, parallel optimistic). • Simulation entities communicate with each other using buffered message passing and guards. message Request {int count;} Entity E0: send Request {2} to E1 after T; Entity E1: receive (Request req) when (req.count <= units) { … … } or timeout in (delay_time); guard

6. Manufacturing Simulation • Semiconductor Manufacturing • The wafer fabrication simulation model is based on the Sematech Data Modeling Standard (DMS). • Wafer fabrication is described by a product route consisting of a number of processing steps. • Each step specifies a machine set, where each machine set consists of a number of identical machines. • Machines may have a setup that can be changed and may be used in different steps. • In each step, a free machine with matching setup will be chosen where possible.

7. Scheduling Rules • Setup Rule • This is implemented by a guard in the receive clause for the LotArrive message which calls setuprule: • Lot processing is delayed until setuprule returns 1. int setuprule(LOT lot, int curTime) { ... ... if ( numfreemachine() != 0 ) { if ( matchingsetup(lot) ) return 1; else if ( (curTime - lot.simClock) >= MAXWAIT ) return 1; else return 0; else return 0; }

8. Implementation using PARSEC • Design Issues • How are machine sets mapped to PARSEC entities? • How is simulation time advanced so that the setup of the machine is changed when MAXWAIT is reached? • Implementation Alternatives • Versions 1, 2 and 3: each machine set is mapped to its own PARSEC entity. • Versions 4, 5 and 6: multiple machine sets are mapped to a single PARSEC entity using partitioning that aims to balance the workload and maximize lookahead. • PARSEC maps entities to physical processors using a round robin policy.

9. Implementation using PARSEC • Advancing Simulation Time • Versions 1 & 4: use timeout(1) to advance simulation time when no receive clause is enabled (note that we cannot use timeout(MAXWAIT) as a lot may already have spent some time in the message buffer). • Versions 2 & 5: use a Sync message in addition to the LotArrive message to schedule a TimeOut message that is received when the setup should be changed. • Versions 3 & 6: use a user-defined lot queue to hold the waiting lots instead of PARSEC’s message buffer, together with a TimeOut message (note that the lots are now received without a guard and the setuprule is applied to the lots in the internal queue)

10. Performance Results • Simulation Experiments • A number of experiments were carried out to compare the performance of the different implementation alternatives. • The dataset used is provided by Sematech and comes from an actual manufacturing system. • Experiments were carried out on a 4-CPU (250 MHz) Sun Enterprise 3000. • For the parallel execution, the conservative null-message protocol was used. • Spin-loops were used to investigate the effect of the granularity of event processing on performance.

11. Version Event Execution Over- Percentage Time Time head % (secs) (secs) (secs) 1 0.156 26.18 26.02 99 2 0.198 2.44 2.242 91 3 0.150 5.40 5.25 97 4/4 Partitions 0.120 10.11 9.98 99 4/8 Partitions 0.117 9.92 9.80 99 4/16 Partitions 0.118 12.38 12.26 99 5/4 Partitions 0.164 5.20 5.03 97 5/8 Partitions 0.154 3.12 2.97 95 5/16 Partitions 0.162 3.04 2.88 95 6/4 Partitions 0.130 5.29 5.16 98 6/8 Partitions 0.112 5.37 5.26 98 6/16 Partitions 0.120 6.40 6.28 98 Overhead Comparison sequential, spin loop = 0

12. Speed Up of Version 1

13. Speed Up of Version 2

14. Speed Up of Version 3

15. Conclusions and Future Work • Conclusions • The different implementation versions have different degrees of impact on the performance. • The versions using user-defined TimeOut messages give better results than the versions using timeout(1). • For the versions that map multiple machine sets to a single PARSEC entity, using 8 partitions generally gives the best performance. • Future Work • To develop extensions to PARSEC for the easy specification of dispatching and setup rules. • POMSim - a Parallel Object-oriented Manufacturing Simulation Language.