Live Webcast 15th Annual Charm++ Workshop

Parallel Object-oriented Simulation Environment (POSE)

POSE is an environment for parallel discrete event simulation comprised of an object-oriented language for modelling complex discrete event systems, new adaptive speculative (optimistic) synchronization strategies, communication libraries tuned to PDES behaviors and load balancers. Adaptive synchronization strategies adapt to the behavior of individual simulation entities without the need for strategy switching mechanisms.

POSE is implemented atop Charm++, a C++-like language for parallel and distributed computing. Entities in a simulation model are represented by posers, which are tiny LPs each with an adaptive protocol tuned to its behavior. The discrete events in the system are asynchronous, possibly remote method invocations on posers.

POSE is designed for scalability of fine-grained general-purpose parallel and distributed large-scale discrete event simulations. It uses the virtualization concept of Charm++ to present a straightforward environment to model complex systems. This environment allows the simulation designer to decompose the system into its natural parallel entities and encourages the decomposition into even smaller entities to ensure a high degree of parallelism through communication/computation overlap. The simulation designer does not need a vast knowledge of parallel computing. POSE addresses the issue of fine granularity of events (vs. synchronization overhead) via novel techniques for modelling entities and performing adaptive optimistic synchronization.

POSE has support for prioritized streaming communication optimizations which improve the way large quantities of small timestamped events are transmitted. In addition, migration of posers is fully supported, and lightweight load balancing strategies have been developed to perform virtual-time-sensitive balancing of load.

POSE also supports various forms of periodic checkpointing and the use of anti-methods which perform reverse computation during rollbacks to avoid state-saving overhead. Both methods can be used simultaneously in a simulation.

POSE uses a general-purpose adaptive synchronization protocol by default, but has a modular design so that different strategies can be plugged into different posers on a per object basis. Though not yet tested, dynamic strategy-switching is straightforward in this context. The modular design of POSE extends to all aspects of the software; different GVT algorithms, load balancing strategies and communication libraries can be added easily.

Projections has been used to visualize and analyze the performance of POSE and to review the design of simulation models. Work is underway to enhance these capabilities.

POSE performs very well for simple simulation benchmarks with linear speedups and low breakeven points. It handles larger problem sizes with exceptional ease. However, we focus primarily on problems that were considered too challenging for optimistic, or even parallel, simulation. With POSE we have been able to obtain modest speedups with communication-intensive simulation applications having extremely small grainsizes (2-6 microseconds on average) and other complexities (such as long paths of dependencies that are challenging to parallelize).

Past work in PDES: Parallel IMPORT

We created a parallel version of the IMPORT discrete event simulation language. Like IMPORT, CharmSim is object-oriented, supports ASK and TELL methods, and contains built-in abstractions for simulation time and simulation entities (ie. objects).

However, unlike IMPORT, CharmSim is intended for parallel discrete event simulation (PDES). In order to support parallel simulation, CharmSim also contains support for:

• Communication between remote objects
• Load balancing
• Coherency control, based on a Time Warp rollback system
• Global Virtual Time, used for storage reclamation and commitment

The CharmSim system consists of a translator and a run-time system built on the Converse/Charm++ parallel programming systems.