Edward Mascarenhas

Ariadne : Architecture of a portable threads system supporting thread migration

Threads exhibit a simply expressed and powerful form of concurrency, easily exploitable in applications that run on both uni‐ and multi‐processors, shared‐ and distributed‐memory systems. This paper presents the design and implementation of Ariadne: a layered, C‐based software architecture for multi‐threaded distributed computing on a variety of platforms. Ariadne is a portable user‐space threads system that runs on shared‐ and distributed‐memory multiprocessors. Thread‐migration is supported at the application level in homogeneous environments (e.g., networks of SPARCs and Sequent Symmetrys, Intel hypercubes). Threads may migrate between processes to access remote data, preserving locality of reference for computations with a dynamic data space. Ariadne can be tuned to specific applications through a customization layer. Support is provided for scheduling via a built‐in or application‐specific scheduler, and interfacing with any communications library. Ariadne currently runs on the SPARC (SunOS 4.x and SunOS 5.x), Sequent Symmetry, Intel i860, Silicon Graphics workstation (IRIX), and IBM RS/6000 environments. We present simple performance benchmarks comparing Ariadne to threads libraries in the SunOS 4.x and SunOS 5.x systems.

ParaSol: a multithreaded system for parallel simulation based on mobile threads

ParaSol is a novel multithreaded system for shared-and distributed-memory parallel simulation, designed to support a variety of domain-specific simulation object libraries. We report on the design of the ParaSol kernel, which drives executions based on optimistic and adaptive synchronization protocols. The active-transaction flow methodology we advocate is enabled by an underlying, efficient lightweight process system. Though this process- and object-interaction view is known to both simplify and speed transition from model design to simulation implementation, migratable threads and objects pose many serious challenges to efficient kernel operation. Good solutions to these challenging problems are key to good simulator performance. We present techniques for the support of optimistic parallel simulations, addressing synchronization, state-saving, rollback, inter-process communication, and process scheduling.

Migrant threads on process farms: parallel programming with Ariadne

We present a novel and portable threads-based system for the development of concurrent applications on shared and distributed memory environments. Implementing user-space threads. the Ariadne system is highly effective for medium to coarse grained applications. Sequential programs are readily converted into parallel programs for shared ordistributed memory, with low development effort. We describe basic threads primitives, and constructs for synchronization and computation in concurrent applications. Ariadne flexibly caters to a variety of communication environments, through a simple interface. It supports the development ofcustomized schedulers on shared memory mulliprocessors, and offers a thread migration capability for distributed environments. Scheduling ofcomputations at the thread level offers both taskand data-driven executions. Thread migration is a powerful feature which turns remote memory accesses into local accesses, enables load-balancing and simplifies program development. Ariadne currently runs on the SPARe (SunGS 4.x, SunGS 5.x), Sequent Symmetry, Intel Paragon, Silicon Graphics IRIX, and ffiM RS/6000 environments. We present Ariadnes parallel programming capability through several examples, reporting on performance measurements obtained with each. • Research supponed in pan by NATO-CRG900108, ONR-9310233, and ARO-93G0045.

Process mobility in distributed-memory simulation systems

Our focus is on the novel use of a process-oriented methodology in distributed-memory simulation systems. To the best of our knowledge, the few existing systems which adopt a process-view strictly use message-passing to effect process-interaction in distributed-memory settings. As a result, these systems avoid scenarios in which processes access passive but shared components. This can restrict the manner in which a system is modelled and hinder the phase of distributed model construction. In this paper, we propose an approach which utilizes mobile processes in distributed-memory simulation systems. Mobile processes can move around the system at will, with easy access to remote system components. The approach basically entails the migration of a requesting process with its timestamp to the remote site hosting the requested passive object. Major advantages of this approach include one-time transmission, fixed communication topology, and increased locality of reference. Early results based on lightweight processes show that the mobile process paradigm can be as efficient as the message-passing paradigm.

The CLAM approach to multithreaded communication on shared-memory multiprocessors: design and experiments

We present results on the experimental design and development of a Connectionless, Lightweight, and Multiway (CLAM) communications environment. The system provides efficient and scalable multiprotocol support for distributed applications that use multimodal data. We present motivation behind design decisions for the CLAM system, and describe two simple, but effective scheduling algorithms for the simultaneous support of multiple, threads-based user-space protocols. One algorithm is readily portable to shared-memory multiprocessors, and enables two or more protocols to coexist within an OS-level process. We present experimental results on the performance of both algorithms.

Mobile-Process-Based Parallel Simulation

Our focus is on the novel use of a process-oriented methodology in software systems for parallel simulation on distributed memory. To the best of our knowledge, the few existing systems which adopt a process view strictly use message passing to effect process interaction in distributed-memory settings. As a result, these systems avoid scenarios in which processes directly access passive but shared components. This can restrict the manner in which a system is modeled and hinder the phase of distributed model construction. In this paper, we propose an approach which utilizes mobile processes in distributed-memory simulation systems. The approach entails the migration of a requesting process with its timestamp to the remote site hosting the requested passive object. Major advantages of this approach include one-time transmission, fixed communication topology, and increased locality of reference. Empirical results based on lightweight processes show that the mobile process paradigm can be as efficient as the message-passing paradigm.

DISplay: a system for visual-interaction in distributed simulations

We propose an application-independent visual interaction library (VIL) well suited to distributed simulation. Advantages of this system include ease of use, flexibility, code reuse, and modularity. Our design ideas are manifest, in the DISplay system, a graphical user-interaction and display library which binds to any parallel software system. We provide examples of its interactive use in the the dynamic display of results from sequential queueing simulations, and distributed particle-physics simulations. These examples illustrate synchronization of multiple remote display requests and potential for enhanced parallel simulation. Also presented are provisions for customized user-interaction dialogs-for application-related input, and bi-directional interaction-between user and application.

Checkpoint and recovery methods in the ParaSol simulation system

State-saving operations are a major source of overheads in optimistic and adaptive parallel discreteevent simulations. We present some techniques for saving state in the the context of the PARASOL multithreaded parallel simulation system. In this system, threads are used to implement both logical processes and active transactions which access passive simulation objects. Hence, system state is a combination of thread-state and object-state. We introduce a new save-if-modified method for incremental checkpointing of threads and objects. Because of the PARASOL system’s domain-oriented support, checkpointing is transparent to the user. Application-level objects that are foreign to a domain may be saved via invocations to primitives in the system’s ParaState module.

Minimum cost adaptive synchronization: experiments with the ParaSol system

We present a novel adaptive synchronization algorithm, called the minimum average cost (MAC) algorithm, in the context of the PARASOL parallel simulation system. PARASOL is a multithreaded system for parallel simulation on shared- and distributedmemory environments, designed to support domainspecific Simulation Object Libraries. The proposed MAC algorithm is based on minimizing the cost of synchronization delay and rollback at a process, whenever its simulation driver must decide whether to either proceed optimistically or to delay processing. In the former case the risk is rollback cost, in the event of a straggler’s arrival. In the latter case the risk is unnecessary delay, in the event a late-comer is not a straggler. In addition to the MAC algorithm and an optimal delay computation model, we report on some early experiments comparing the performance of MAC-based adaptive synchronization to optimistic synchronization.

Concurrent and Fail-Safe Replicated Simulations on Heterogeneous Networks: An Introduction to EcliPSE

This paper presents an overview of the ACES parallel software system and, in particular, an introduction to the EcliPSe layer of the system. The ACES system is a fault-tolerant, layered software system for heterogeneous-network based cluster computing. The EcliPSe toolkit, which resides on an upper layer, was constructed specifically for replication-based and domain-decomposition based simulation applications. It is not, however, restricted to simulations and supports any message-passing form of parallel processing. By taking advantage of networks of heterogeneous machines, generally “idle” workstations, EcliPSe programs can achieve supercomputer level performance with little programming effort. This was a motivating factor in EcliPSes design. We present an overview of key application-level features in EcliPSe, a new user interface, support for fault-tolerant simulation, and performance results for three simple but large scale and representative experiments.