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...

Parallel supercomputers architectures with complex memory hierarchies or distributed memory systems have become very common. Unfortunately, the problems associated with restructuring software to take advantage of these memory systems are not eas-ily solved. This paper presents an overview of some of the mathematical issues behind several of these problems and attempts to give a brief look at some of the potential solutions. 1

Scalability studies of parallel architectures have used scalar metrics to evaluate their performance. Very often, it is difficult to glean the sources of inefficiency resulting from the mismatch between the algorithmic and architectural requirements using such scalar metrics. Low-level performance studies of the hardware are also inadequate for predicting the scalability of the machine on real applications. We propose a top-down approach to scalability study that alleviates some of these problems. We characterize applications in terms of the frequently occurring kernels, and their interaction with the architecture in terms of overheads in the parallel system. An overhead function is associated with the algorithmic characteristics as well as their interaction with the architectural features. We present a simulation platform called SPASM (Simulator for Parallel Architectural Scalability Measurements) that quantifies these overhead functions. SPASM separates the algorithmic overhead into ...

The main objective of this paper is to put forward a software process model for high-performance systems (HPS), and to present a formal framework to describe software design methodologies (SDMs) for those systems. The framework consists of two main parts: the software process activities which characterise the development of HPS, and the components of the SDM (concepts, artifacts, representation and actions) which are essential for any methodology. The framework relates these two parts by identifying generic components of each activity in the software process that can be used to classify and evaluate SDMs for HPS. The framework has been formally specified using the language Z and used to derive formal specifications of SDMs. This is illustrated in the paper by presenting part of the specification of oDM (an occam design method). 1 Introduction The number of software design methodologies (SDMs) currently available is enormous. This means that designers and managers are faced with the d...

Most parallel programming models provide a single generic mode in which processes can exchange information with each other. However, empirical observation of parallel programs suggest that processes share data in a few distinct and specific modes. We argue that such modes should be identified and explicitly supported in parallel languages and their associated models. The paper describes a set of information sharing abstractions that have been identified and implemented in the parallel programming language Charm. It can be seen that using these abstractions leads to improved clarity and expressiveness of user programs. In addition, the specificity provided by these abstractions can be exploited at compile-time and at run-time to provide the user with highly refined performance feedback and intelligent debugging tools. 1 Introduction A typical parallel computation can be characterized as a collection of processes running on multiple processors. Depending on the programming model and lan...

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...

Piggyback query processing is a new technique, described in [24], intended to perform additional useful computation (e.g., database statistics collection) during normal query processing, taking full advantage of data resident in main memory. Different types of beneficial piggybacking have been identified and studied, but how to efficiently integrate piggyback operations with a given user query is still an open issue. In this paper, we propose a technique of multiplegranularity interleaving to efficiently integrate multiple piggyback operations with a given query at different levels of data granularity. We introduce an algebraic notation to capture the main characteristics of data ows in a database management system (DBMS), facilitating the study of piggybacking and enabling the automated integration of piggyback operations and user queries in a DBMS supporting the piggyback method. Various integration techniques are introduced to facilitate multiple-granularity interleaving including merging sh...

Exploiting parallelism for industrial real-time applications has not received much attention compared to scientific applications. The available real-time design methods do not adequately address the issue of parallelism, resulting still in a strong need for low-level tools such as debuggers and monitors. This need illustrates that developing parallel real-time applications is indeed a difficult and tedious task. In this paper we show how problems can be alleviated if an approach is followed that allows for experimentation with designs and implementations. In particular, we discuss a development system that integrates design, implementation, execution, and analysis of real-time applications, putting emphasis on exploitation of parallelism. In the paper we primarily concentrate on the support for application design, as we feel that parallelism should essentially be addressed at this level. Keywords: parallelism, real-time systems, application design, software development experimentation...

This paper presents a graph-theoretic scheme for partitioning and scheduling a computation for efficient parallel execution. The technique parses a graph into a hierarchy of subgraphs known as clans that can be identified as able or unable to support parallel execution. The technique is known as clan-based graph decomposition and will be referred to as CGD. Unlike standard graph partitioning techniques, CGD considers the structure of the entire graph and bases parallelization decisions on this structure. Other partitioning and scheduling techniques generally focus on only a section of the graph like the critical path or a group of tightly connected neighbors to find local optimizations. *This research is sponsored by NSF grant no. CCR-8909253 1. Exploiting Parallelism: Automatic vs. Manual