Lightweight threads have an important role to play in parallel systems: they can be used to exploit shared-memory parallelism, to mask communication and I/O latencies, to implement remote memory access, and to support task-parallel and irregular applications. In this paper, we address the question of how to integrate threads and communication in high-performance distributed-memory systems. We propose an approach based on global pointer and remote service request mechanisms, and explain how these mechanisms support dynamic communication structures, asynchronous messaging, dynamic thread creation and destruction, and a global memory model via interprocessor references. We also explain how these mechanisms can be implemented in various environments. Our global pointer and remote service request mechanisms have been incorporated in a runtime system called Nexus that is used as a compiler target for parallel languages and as a substrate for higher-level communication libraries. We report th...

The concept of design patterns has recently emerged as a new paradigm in the context of object-oriented design methodology. Similar ideas are being explored in other areas of computing. In the parallel computing domain, design patterns describe recurring parallel computing problems and their solution strategies. Starting with the late 1980's, several pattern-based systems have been built for facilitating parallel application development. However, most of these systems use patterns in ad hoc manners, thus lacking a generic or standard model for using and intermixing di#erent patterns. This substantially hampers the usability of such systems. Lack of flexibility and extensibility are some of the other major concerns associated with most of these systems. In this paper, we propose a generic (i.e., pattern- and application-independent) model for realizing and using parallel design patterns. The term architectural skeleton is used to represent the application independent, reusable set of attributes associated with a pattern. The model can provide most of the functionalities of low level message passing libraries, such as PVM or MPI, plus the benefits of the patterns. This results in tremendous flexibility to the user. It turns out that the model is an ideal candidate for object-oriented style of design and implementation. It is currently implemented as a C++ template-library without requiring any language extension. The generic model, together with the object-oriented and library-based approach, facilitates extensibility.

In many concurrent programming languages programs are difficult to extend and modify. This is because changes in a concurrent program (either through modification or extension) require re-implementation of some or all components. This paper presents the design of a concurrent object-oriented programming language based upon separate specifications of computations and interactions of programs. Separate specification of computations and interactions allows each to be separately modified and extended. We show that separation also facilitates extension of other language composition mechanisms such as class, inheritance, and template in order to define concurrent program abstractions. The resulting language supports extensibility and modifiability of concurrent programs as well as reusability of specifications of computations and interactions. 1

. In many concurrent programming languages, concurrent programs are difficult to extend and modify: small changes in a concurrent program may require re-implementations of a large number of its components. In this paper a novel concurrent program composition mechanism is presented in which implementations of computations and synchronizations are completely separated. Separation of implementations facilitates extensions and modifications of programs by allowing one to change implementations of both computations and synchronizations. The paper also describes a concurrent programming model and a programming language that support the proposed approach. 1 Introduction Complex software systems are evolutionary in general. They change during the initial development stage, and often after they have been deployed. These changes may occur due to changes in the requirements, in the hardware configuration, and/or in the execution environment. Programming languages must support methodologies that ...

This paper briefly describes our approach for supporting evolutionary software design. We show that designs of software systems are more amenable to changes if specifications of components and interactions among components are completely separated. The separation allows one to limit the scope of indirect changes. Further, we model interactions among components in terms of relationships which not only capture interactions but also form the basis for detecting the scope of changes and for applying corrective changes

There is significant interest in concurrent programming due to widespread availability of parallel and distributed systems. The design and implementation of concurrent programs for the parallel and distributed systems has proven to be extremely difficult. Concurrent programs are difficult to design, implement, and maintain because changes in a concurrent program (through addition of new components or modification of existing components) requires re-implementation of some or all components. Also, it is difficult to reuse specifications of components and interactions. Concurrent object-oriented programming languages show promise in alleviating the modularity and extensibility problems. Concurrent objects form a natural basis for modeling entities of applications. Further, extensibility is naturally supported through the notion of inheritance. Many object-oriented programming languages [3, 5, 1, 2] have been proposed that extend a sequential object-oriented programm