Rajendra Panwar

A Linguistic Framework for Dynamic Composition of Dependability Protocols

We present a language framework for describing dependable systems which emphasizes modularity and composition. Dependability and functionality aspects of an application may be described separately providing a separation of design concerns. Futhermore, the dependability protocols of an application may be constructed bottom-up as simple protocols that are composed into more complex protocols. Composition makes it easier to reason about dependability and supports the construction of general reusable dependability schemes. A significant aspect of our language framework is that dependability protocols may be loaded into a running application and installed dynamically. Dynamic installation makes it possible to impose additional dependability protocols on a server as clients with new dependability demands are integrated into a system. Similarly, if a given dependability protocol is only necessary during some critical phase of execution, it may be installed during that period only.

Abstraction and modularity mechanisms for concurrent computing

The Actor model programming language concept, which provides basic building blocks for a wide variety of computational structures, is reviewed. The Actor model unifies objects and concurrency. Actors are autonomous, distributed, concurrently executing objects that can send each other messages asynchronously. The Actor models communication abstractions and object-oriented design are discussed. Three mechanisms for developing modular and reusable components for concurrent systems are also discussed. The mechanism are synchronizers, modular specifications of resource management policies, and protocol customization of dependability.<<ETX>>

Distributed Execution of Actor Programs

A number of programming language models, including actors, provide inherent concurrency. We are developing high-level language constructs using actors and studying their implementation on multiprocessor architectures. This report describes our experience with programming in actors by means of a specific example of scientific computation. We also discuss work in progress on compilation technology for efficient program execution on multiprocessors.

A methodology for programming scalable architectures

Abstract In scalable concurrent architectures, the performance of a parallel algorithm depends on the resource management policies used. Such policies determine, for example, how data is partitioned and distributed and how processes are scheduled. In particular, the performance of a parallel algorithm obtained by using a particular policy can be affected by increasing the size of the architecture or the input. In order to support scalability, we are developing a methodology for modular specification of partition and distribution strategies (PDSs). As a consequence, a PDS may be changed without modifying the code specifying the logic of a parallel algorithm. We illustrate our methodology for parallel algorithms that use dynamic data structures.

An Actor-Based Framework for Heterogeneous Computing Systems

This paper discusses a framework for supporting heterogeneous computing systems (HCS). HCS are physically distributed, potentially complex and evolving systems. HCS consist of a number of computers and interconnections which may have differing language and system support, and sometimes distinct computational (architectural) models. By providing a large number of computational resources to the user, HCS have the potential to allow highly eficient execution of ultra largescale applications. The paper provides a framework for addressing some of the significant problems in interoperability and resource management which result from the heterogeneity in HCS. It represents ideas and ongoing research in the area.

Parallel implementations of irregular problems using high-level actor language

We present our experience in implementing several irregular problems using a high-level actor language. The problems studied require dynamic computation of object placement and may result in load imbalance as the computation proceeds, thereby requiring dynamic load balancing. The algorithms are expressed as fine-grained computations providing maximal flexibility in adapting the computation load to arbitrary parallel architectures. Such an algorithm may be composed of different partitioning and distribution strategies (PDSs) to result in different performance characteristics. The PDSs are implemented for specific data structures or algorithms and are reusable for different parallel algorithms. We demonstrate how our methodology provides portability of algorithm specification, reusability and ease of expressibility.

Efficient compilation of concurrent call/return communication in actor-based programming languages

Concurrent call/return communication (CCRC) allows programmers to conveniently express a communication pattern where a sender invokes a remote operation and uses the result to continue its computation. The blocking semantics requires context switching for efficient utilization of computation resource. We present a compilation technique which allows programmers to use CCRC with the cost of non-blocking asynchronous communication plus minimum context switch cost. The technique transforms CCRCs into non-blocking asynchronous sends and encapsulates continuations into separate objects. A data flow analysis is used to guarantee that only necessary context is cached in continuation objects.