ion and Modularity Mechanisms for Concurrent Computing Gul Agha, Svend Frølund, WooYoung Kim, Rajendra Panwar, Anna Patterson, and Daniel Sturman Department of Computer Science 1304 W. Springfield Avenue University of Illinois at Urbana-Champaign Urbana, IL 61801, USA Email: !agha---frolund---wooyoung---raju---annap---sturman?@cs.uiuc.edu 1 Introduction The transition from sequential to parallel and distributed computing has been widely accepted as a major paradigm shift occurring in Computer Science. It has been observed that the sequential programming model is inadequate for parallel and distributed computing. At a conceptual level, one can compare the fundamental intuition between sequential and concurrent computing as follows: ffl The sequential programming model essentially defines a computation as a sequence of instructions which manipulate a global store. The standard abstraction mechanism for sequential programs is procedures. Procedures glue a sequence of instructions; they a...

We describe Hal, a high-level, actor-based language which has served as a test-bed for experimenting with powerful linguistic constructs for parallel and distributed programming. Hal is an architecture independent, concurrent object-oriented language which supports inheritance, synchronization constraints, continuation capture, synchronous and asynchronous message passing, and reflection. The Hal compiler has been used to execute actor programs on a number of shared and distributed memory machines. Hal allows powerful abstractions to be defined and reused. Furthermore, Hal supports the use of synchronization constraints at a fine-grained level and the use of software pipelining. In this paper, we describe the design of Hal, using specific examples to illustrate its features. We then discuss some of the implementation issues in the run-time system.

Hal incorporates a number of high-level language constructs such as the incremental specialization of synchronization constraints to maintain the consistency of actors at run-time, the inheritance of both code and synchronization constraints, and limited reflective capabilities to customize the system with respect to fault tolerance. This paper describes some issues in compiling Hal, and, in particular, three source level transformations used by the compiler for Hal. Two of the transformations translate RPC-style message sending into asynchronous message sending. The third transformation performs code motion to optimize the implementation of replacement behavior. This optimization results in the reduction of object code size as well as execution time. Keywords: Actor, concurrency, synchronization constraint, inheritance, optimization This author is sponsored by a fellowship from Ministry of Education in Korea. y The work described in this paper has been made possible by generous s...

Introduction The increasing performance and decreasing cost of processors and computer networks has continued to fuel an explosion of interest in solving larger problems using concurrent computing. In particular, agent-based programming has emerged as a promising paradigm which may help realize Arti cial Intelligence through distributed problem solving. Agents are persistent and goal directed entities that may move between hosts in response to changes in requirements such as security and eciency, and that would normally be limited in the computational resources they may employ in pursuing their goals. Such resources include processor time, memory, and network bandwidth. A key challenge in concurrent computing is the diculty of programming parallel and distributed architectures. Many models of concurrency are rather low-level. For example, shared variable models often violate data encapsulation, an essential feature for modular software development. A promising approach to add

In this paper we present performance results of several irregular parallel algorithms implemented using a high-level actor language and its runtime kernel. The problems studied require dynamic computation of the placement of objects and may create load imbalance as the computation proceeds thereby requiring dynamic load balancing. We express the algorithms as fine grained computation, which allows us to rearrange objects in various ways and to compose the same algorithm with different partitioning and distribution strategies (PDS's). The PDS's are implemented for specific data structures or algorithm structures and are reusable for different parallel algorithms. We demonstrate how our methodology provides portability of algorithm specification, reusability and ease of expressibility without significantly sacrificing efficiency. 1 Introduction In parallel computing, the set of operations and the partial order in which they may be carried out define an ideal algorithm [10]. This ideal ...

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 partitioning and distribution strategies (PDS's). 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. 1 Introduction In parallel computing, the set of operations and the partial order in which they may be carried out define an ideal algorithm [25]. We use Actors, a form of concurrent objects, to specify ideal algorithms. Actors naturally express an i...