Parallel and Distributed Simulation Techniques

1. Parallel and Distributed Simulation Techniques Achieving speedups in model execution

2. The problem • Generating samples significant to draw conclusions. • Sequential simulation: low performance. Worse when the problem is complex. • SOLUTION: to devote more resources (for instance, multiple processors). • GOAL: achieving speedups to obtain results.

3. Decomposition alternatives • Independent replications • Parallelizing compilers • Distributed functions • Distributed Events • Model decomposition

4. Independent replications • (+) Efficient • (-) Memory constraints • (-) Complex models cannot divided in simpler submodels executing simultaneously

5. Parallel Compilers • (+) Transparent to programmers • (+) Existing code can be reused • (-) Ignores the structure of the problem • (-) Parallelism not being exploited

6. Distributed functions Support tasks to independent processors • (+) Transparent to the user • (+) No synchronization problems • (-) Limited speedup (low degree of parallelism)

7. Distributed Events • Global Event List • When a processor is free, we execute the following event in the list • (+) Speedups • (-) Protocols to preserve consistency • (-) Complex for distributed memory systems • (+) Effective when much global information is shared

8. Model decomposition • The model is divided in components loosely coupled. • They interact through message passing. • (+) Speedups when there is little global information. • (+) Make use of the model paralelism • (-) Synchronization problems

9. Classification of synchronization mechanisms • Time driven simulation: clock advances one tick at a time. Respond to all the events corresponding to that tick. • Event driven simulation: clock is advanced up to the time of simulated message. • Synchronous communication: global clock is used. Every processor: same simulated time. • Aynchronous communication:each processor uses its own clock.

10. Time driven simulation • Time advances in fixed increments (ticks). • Process simulates the events for the tick. Precission: short ticks. • Synchronous communication • Every process must finish with a tick before advancing to the next. • Synchronization phase. • Central/Distributed global clock.

11. Time Driven simulation (cont.) • Asynchronous communication • Higher level of concurrency. • Processor cannot simulate events for a new simulated tick without knowing the previous have finished. • More overhead (synchronization).

12. Event driven simulation • Time advances due to the occurrence of events. • Higher potential speedups. • Synchronous • Global clock: minimum time of the next event. • Centralized or distributed.

13. Event driven simulation (Cont.) • Asynchronous • Local clock: minimum time for the following event. • More independence between processes. • Independent events: simulated in parallel • Improved performance

14. PDES (Parallel Discrete Event Simulation) • Asynchronous simulation, • Event-based. • Logical Processes (represent • physical processes). • Every LP uses a clock, • a local event list, and two • link lists • (one input, one output). • A part of the global state.

15. Causality • Causality Errors. • Cannot occur if we meet the Local Causality Constraint: each/LP processes events in increasing timestamp order. • Sufficient condition (not necessary) to avoid causality errors. • CONSERVATIVE strategies: avoid causality errors. • OPTIMISTIC strategies: errors can occur, and they are fixed.

16. Conservative mechanisms (Chandy/Misra) • When it is safe to process an event? • A message (representing an event) with a timestamp, and NO other with a smaller timestamp can arrive: the event can be processed. While non processed message x in each/input link Clocki = min(input links’ timestamps); Process EVERY message with that timestamp; If the link with smaller timestamp does not have a message to process then Block the Logical Process.

17. Deadlock in pessimist strategies

18. Null Message strategies • Null message from A to B: a “promise” that A will not send a message to B with smaller timestamp than the null message. • Input links can be used to know the minimum future timestamp. • When an event is processed, a Null message is sent with the time of this lower bound. • The receiver computes new output bounds using this as a base, and sends it to the neighbors.

19. Avoiding deadlock • There cannot be cycles in which the increment of the timestamp is 0. • Null messages can be sent on request • Better results can be obtained when you have lookahead of the values of the timestamps.

20. Analysing Pessimist strategies • The degree of lookahead is critical. • Cannot exploit parallelism to the maximum. • Not robust: changes in the application represent changing the lookahead times. • The programmer should provide lookahead information. Optimist: causality errors. Pessimist: reduced performance.