Distributed data processing is fast becoming a reality. Businesses want to have it for many reasons, and they often must have it in order to stay competitive. While much of the infrastructure for distributed data processing is already in place (e.g., modern network technology), there are a number of issues which still make distributed data processing a complex undertaking: (1) distributed systems can become very large involving thousands of heterogeneous sites including PCs and mainframe server machines � (2) the state of a distributed system changes rapidly because the load of sites varies over time and new sites are added to the system� (3) legacy systems need to be integrated|such legacy systems usually have not been designed for distributed data processing and now need to interact with other (modern) systems in a distributed environment. This paper presents the state of the art of query processing for distributed database and information systems. The paper presents the \textbook " architecture for distributed query processing and a series of techniques that are particularly useful for distributed database systems. These techniques include special join techniques, techniques to exploit intra-query parallelism, techniques to reduce communication costs, and techniques to exploit caching and replication of data. Furthermore, the paper discusses di erent kinds of distributed systems such as client-server, middleware (multi-tier), and heterogeneous database systems and shows how query processing works in these systems. Categories and subject descriptors: E.5 [Data]:Files � H.2.4 [Database Management Systems]: distributed databases, query processing � H.2.5 [Heterogeneous Databases]: data translation General terms: algorithms � performance Additional key words and phrases: query optimization � query execution � client-server databases � middleware � multi-tier architectures � database application systems � wrappers� replication � caching � economic models for query processing � dissemination-based information systems 1

This paper presents a novel interprocedural, flow-sensitive, and context-sensitive pointer analysis algorithm for multithreaded programs that may concurrently update shared pointers. For each pointer and each program point, the algorithm computes a conservative approximation of the memory locations to which that pointer may point. The algorithm correctly handles a full range of constructs in multithreaded programs, including recursive functions, function pointers, structures, arrays, nested structures and arrays, pointer arithmetic, casts between pointer variables of different types, heap and stack allocated memory, shared global variables, and thread-private global variables. We have implemented the algorithm in the SUIF compiler system and used the implementation to analyze a sizable set of multithreaded programs written in the Cilk multithreaded programming language. Our experimental results show that the analysis has good precision and converges quickly for our set of Cilk programs.

Thor is an object-oriented database system designed for use in a heterogeneous distributed environment. It provides highly-reliable and highly-available persistent storage for objects, and supports safe sharing of these objects by applications written in different programming languages. Safe heterogeneous sharing of long-lived objects requires encapsulation: the system must guarantee that applications interact with objects only by invoking methods. Although safety concerns are important, most object-oriented databases forgo safety to avoid paying the associated performance costs. This paper gives an overview of Thor's design and implementation. We focus on two areas that set Thor apart from other objectoriented databases. First, we discuss safe sharing and techniques for ensuring it; we also discuss ways of improving application performance without sacrificing safety. Second, we describe our approach to cache management at client machines, including a novel adaptive prefetching strat...

THOR is a persistent object store that provides a powerful programming model. THOR ensures that persistent objects are accessed only by calling their methods and it supports atomic transactions. The result is a system that allows applications to share objects safely across both space and time. The paper

Java's Remote Method Invocation is an example of a synchronous communication mechanism with a well defined protocol. Many software systems require more flexibility in their communication mechanisms, including asynchronous communication and delayed referencing of objects (Futures). This paper introduces a novel mechanism allowing Java remote objects to use extended communication protocols without changes to the underlying wire or serialisation protocols. These extensions can be utilised by standard remote objects without additional coding changes and can be incorporated with standard Java clients. This paper explores the possibilities of implementing client controlled versus server controlled asynchronous communication and dynamic selection of protocols through the use of a precompiler for the remote object classes. A discussion of the possibility of integrating Futures and Batched Futures, and any required programming abstractions, into this mechanism is conducted. It is prop...

We present an automated run-time optimisation framework that can improve the performance of distributed applications written using Java RMI whilst preserving its semantics.

Abstract. Programmers write programs, expressing plans for machines to execute. When composed so that they may cooperate, plans may instead interfere with each other in unanticipated ways. Plan coordination is the art of simultaneously enabling plans to cooperate, while avoiding hazards of destructive plan interference. For sequential computation within a single machine, object programming supports plan coordination well. For concurrent computation, this paper shows how hard it is to use locking to prevent plans from interfering without also destroying their ability to cooperate. In Internet-scale computing, machines proceed concurrently, interact across barriers of large latencies and partial failure, and encounter each other’s misbehavior. Each dimension presents new plan coordination challenges. This paper explains how the E language addresses these joint challenges by changing only a few concepts of conventional sequential object programming. Several projects are adapting these insights to existing platforms. 1

In a client-server system, it may be possible for the client to corrupt server data through unsafe access methods or programming errors. A common method for protecting the server data is to separate the client and server into distinct protection domains, e.g. Unix processes. Communication between client and server is restricted to a well-defined set of crossdomain calls and results are passed as opaque pointers to server data. Unfortunately, cross-domain calls are expensive and seriously affect the performance of the system. In his work on Batched Futures, Bogle presents a mechanism for batching cross-domain calls, thus amortizing the overhead of the domain crossing across the batch. Bogle showed that the improvement in performance is directly proportional to the average size of a batch (batching factor). This thesis describes two mechanisms that can be used to improve the batching factor: basic value promises and batched control structures. Basic value promises allow the batching of calls that return basic values (e.g. integer, boolean, character and real). Batched control structures allow the batching of simple control flow statements such as if statements, while loops and for loops. Both mechanisms have been implemented in Thor, an object-oriented database system. This thesis presents performance results showing the e#ectiveness of both mechanisms in increasing the performance of cross-domain calls.

This paper is concerned with the impact of languagelevel communication mechanisms on the overall performance of distributed systems. Analytic models are developed of several existing mechanisms, including RPC and several enhancements. Using this modelling, a novel construct, called responsibilities, is synthesized. Analysis of the construct, guiding refinement of the initial design, demonstrates how the mechanism provides an improved impact on system performance compared to previous technology. Keywords distributed systems, performance modelling, programming language constructs 1 Introduction The time performance of the majority of distributed systems is constrained by the cost of communication. Computational elements of such systems are often idle, waiting for requests; or blocked, waiting for results. This paper explores language-level communication mechanisms which minimize these delays and their effects on overall system performance. A new construct is synthesized which merg...

This paper presents a novel interprocedural, ow-sensitive, and context-sensitive pointer analysis algorithm for multithreaded programs that may concurrently update shared pointers. The algorithm is designed to handle programs with structured parallel constructs, including fork-join constructs, parallel loops, and conditionally spawned threads. For each pointer and each program point, the algorithm computes a conservative approximation of the memory locations to which that pointer may point. The algorithm correctly handles a wide range of programming language constructs, including recursive functions, recursively generated parallelism, function pointers, structures, arrays, nested structures and arrays, pointer arithmetic, casts between dierent pointer types, heap and stack allocated memory, shared global variables, and thread-private global variables. We have implemented the algorithm in the SUIF compiler system and used the implementation to analyze a set of multithreaded programs written in the Cilk programming language. Our experimental results show that the analysis has good precision and converges quickly for our set of Cilk programs