We survey parallel programming models and languages using 6 criteria [:] should be easy to program, have a software development methodology, be architecture-independent, be easy to understand, guranatee performance, and provide info about the cost of programs. ... We consider programming models in 6 categories, depending on the level of abstraction they provide.

Lightweight threads are becoming increasingly useful in supporting parallelism and asynchronous control structures in applications and language implementations. However, lightweight thread packages traditionally support only shared memory synchronization and communication primitives, limiting their use in distributed memory environments. We introduce the design of a runtime interface, called Chant, that supports lightweight threads with the capability of communication using both point-to-point and remote service request primitives, built from standard message passing libraries. This is accomplished by extending the POSIX pthreads interface with global thread identifiers, global thread operations, and message passing primitives. This paper introduces the Chant interface and describes the runtime issues in providing an efficient, portable implementation of such an interface. In particular, we present performance results of the initial portion of our runtime system: point-to-point message passing among threads. We examine the issue of thread scheduling in the presence of polling for messages, and measure the overhead incurred when using this interface as opposed to using the underlying communication layer directly. Weshow that our design can accommodate various polling methods, depending on the level of support present in the underlying thread system, and imposes little overhead in point-to-point message passing over the existing communication layer.

Wehaverecently introduced a new language, called Opus, which provides a set of Fortran language extensions that allow for integrated support of task and data parallelism. It also provides shared data abstractions (SDAs) as a method for communication and synchronization among these tasks. In this paper, we rst provide a brief description of the language features and then focus on both the language-dependent and language-independent parts of the runtime system that support the language. The language-independent portion of the runtime system supports lightweight threads across multiple address spaces, and is built upon existing lightweight thread and communication systems. The language-dependent portion of the runtime system supports conditional invocation of SDA methods and distributed SDA argument handling. 1

We have recently introduced a set of Fortran language extensions that allow for integrated support of task and data parallelism, and provide for shared data abstractions (SDAs) as a method for communication and synchronization among these tasks. In this paper we discuss the design and implementation issues of the runtime system necessary to support these extensions, and discuss the underlying requirements for such a system. To test the feasibility of this approach, we implement a prototype of the runtime system and use this to support an abstract multidisciplinary optimization (MDO) problem for aircraft design. We give initial results and discuss future plans. 1 Introduction Most of the recent research effort in parallel languages and compilers has concentrated on specification and exploitation of data parallelism in scientific codes. However, there are a large number of scientific and engineering codes which exhibit multiple levels of parallelism. Multidisciplinary applications are a...

This paper describes issues concerning the design of an optimistic parallel discrete event simulation system that executes in environments that impose real-time constraints on the simulator's execution. Two key problems must be addressed by such a system. First the timing characteristics of the parallel simulator must be sufficiently predictable to allow one to guarantee that real-time deadlines for completing simulation computations will be met. Second, the optimistic computation must be able to interact with its surrounding environment with as little latency as possible, necessitating rapid commitment of I/O operations. To address the first question, we show that optimistic simulators that never send incorrect messages (sometimes called "aggressiveno -risk" simulators) provide sufficient predictability to allow traditional schedulability analysis techniques commonly used in realtime systems to be applied. We show that incremental state saving techniques introduce sufficient unpredic...

Multiprocessors have been accepted as vehicles for improved computing speeds, cost/performance, and enhanced reliability or availability. However, the added performance requirements of user programs and functional capabilities of parallel hardware introduce new challenges to operating system design and implementation. This paper reviews research and commercial developments in multiprocessor operating system kernels from the late 1970's to the early 1990's. The paper first discusses some common operating system structuring techniques and examines the advantages and disadvantages of using each technique. It then identifies some of the major design goals and key issues in multiprocessor operating systems. Issues and solution approaches are illustrated by review of a variety of research or commercial multiprocessor operating system kernels. College of Computing Georgia Institute of Technology Atlanta, Georgia 30332--0280 Contents 1 Introduction 1 2 Structuring an Operating System 4 2....

This paper describes current research in real time operating systems. Due to its importance to real-time systems, we begin this survey with a brief summary of relevant results in realtime scheduling and synchronization. Real-time operating systems are described in terms of the primitives and constructs offered to application programs. In addition, the effects of underlying computer architectures on real-time operating systems are discussed, followed by a description of benchmarks and evaluation methods for real-time systems. College of Computing Georgia Institute of Technology Atlanta, Georgia 30332--0280 Readers' comments and suggestions for improvement are solicited. Please direct them to kaushik@cc.gatech.edu. 1 Functionality and Characteristics of Real-time Systems The embedded computer hardware of modern robots and industrial control systems is becoming increasingly complex. Typically, it consists of many interconnected computers operating at multiple levels of control or sup...

The implementation of operating system functions can significantly affect the performance of parallel programs. Our research concerns the customization of operating system functionality for different target hardware to improve the performance of application programs. In this paper, we describe our experience with a reconfigurable, multiprocessor Mach cthreads package on a 32-node KSR-1 supercomputer. Sample static and dynamic configurations address the exchange and on-line adaptation of threads schedulers, and the on-line adaptation of threads synchronization constructs. Experimental results are demonstrated with two different parallel application programs, (1) a parallel branch-and-bound application and (2) the runtime kernel of a Time Warp discrete event simulator. The lightweight threads package has been ported to several target architectures, including Sparcstations, a 32-node GP1000 BBN Butterfly, SGI multiprocessors, and the 32-node Kendall Square Supercomputer. College of Comp...

Data- and task-parallelism are two important parallel programming models. Object-oriented paradigm in parallelism provides a good way of abstracting out various aspects of computations and computing resources. Using an object-oriented language like C++, one can compose data and control representations into a single active object. We propose a thread model of parallelism that addresses both data and task parallelism. Computation and communication can be overlapped by suspending a thread of computation which is waiting for an event and running an eligible thread of computation in its place. Threads naturally subsume taskparallelism. Threads are encapsulated into thread objects may be grouped into rope objects [22, 20], that span the parallel machine domain, for collective computation and communication. Thus data-parallelism can be supported. Since rope objects are parallel objects, they can be customized, interestingly, in a serial or a parallel manner. Spatial transparency of objects is...

Parallel direct execution simulation is an important tool for performance and scalability analysis of large message passing parallel programs executing on top of a virtual computer. However, detailed simulation of message-passing codes requires a great deal of computation. We are therefore interested in pursuing implementation techniques which can decrease this cost. One idea is to implement the application virtual processes as lightweight threads rather than traditional Unix processes, reducing both on-processor communication costs and context-switching costs. In this paper we describe an initial implementation of a threadbased parallel direct execution simulator. We discuss the advantages of such an approach and present preliminary results that indicate a signi�cant improvement over the process-based approach.