Regis is a programming environment aimed at supporting the development and execution of parallel and distributed programs. It embodies a constructive approach to the development of programs based on separating program structure from communication and computation. The emphasis is on constructing programs from multiple parallel computational components which cooperate to achieve the overall goal. The environment is designed to easily accommodate multiple communication mechanisms and primitives. Both the computational and communication elements of Regis programs are programmed in the Object Oriented programming language C++. The elements are combined into parallel and distributed programs using the configuration language Darwin. The paper describes programming in Regis through a set of small example programs. Keywords parallel programming, distributed programming, inter-process communication, parallel programming language, software development environment. 1. Introduction The Regis en...

The usual way of installing a new version of a software system is to shut down the running program and then install the new version. This necessitates a sometimes unacceptable delay during which service is denied to the users of the software. An on-line software replacement system replaces parts of the software while it is in execution, thus eliminating the shutdown. While a number of implementations of on-line version change systems have been described in the literature, little investigation has been done on its theoretical aspects. In this paper, we describe a formal framework for studying on-line software version change. We give a general definition of validity of an on-line change, show that it is in general undecidable and then develop sufficient conditions for ensuring validity for a procedural language. Keywords--- On-line software version change, validity of change, process, state, reachable state, data flow analysis, functional enhancement I. Introduction It is now well kno...

Adaptive software that can react to changes in the execution environment or user requirements by switching algorithms at runtime is powerful yet difficult to implement, especially in distributed systems. This paper describes a software architecture for constructing such adaptive software and a graceful adaptation protocol that allows adaptations to be made in a coordinated manner across hosts transparently to the application. A realization of the architecture based on Cactus, a system for constructing highly configurable distributed services and protocols, is also presented. The approach is illustrated by outlining examples of adaptive components from a group communication service.

Applications requiring concurrency or access to specialized hardware are naturally written as distributed applications, where each software component (module) can execute on a different machine, and modules interact via bindings. In order to make changes to very long-running applications or those that must be continuously available, we must dynamically change the application. Dynamic reconfiguration of a distributed application is the act of changing the configuration of the application as it executes. Examples of configuration changes are replacing a module, moving a module to another machine, and adding or removing modules from the application. The most challenging aspect of dynamic reconfiguration is that an application in execution has state information, both within the modules and within the communication channels between modules. This state information may need to be transferred from the old configuration to the new in order to reach an application state compatible with the new c...

In order to help programmers achieve greater leverage of emerging reconfiguration mechanisms, we are studying notations for users to express reconfiguration plans. These plans direct how a running distributed application would be changed, based upon recognition of events from either the application itself or its environment. Our work to date in this area is embodied in a simple system called Clipper. Based upon C++, Clipper provides a way for programmers to express plans, that are then used to automatically generate the run time mechanisms needed to validly reflect the programmer's rules for change in the the application. This paper presents a description of our language in its current form, along with requirements that led up to it. 1 Introduction Reconfiguration of an executing distributed application entails mapping one application state to another. The mapping may be applied to implement a planned upgrade, to recover from a fault condition, or to adjust performance in the applicat...

what constitutes an "acceptable" behavior of such a process. We capture this notion in our definition of the validity of an on-line change. We define an on-line change to be valid if some time after the change, the process reaches a reachable state of the new program version. Thus, validity ensures that following a change, the process starts behaving like the new version of the program after a "transition period". We first consider validity of on-line changes to programs written in sequential procedure based languages. For this purpose, a very simple model in which procedures and functions are not allowed is first considered. State is modelled as a mapping from variable names to values. For this model, we show that it is undecidable to find whether or not a given on-line change is valid. This result has important consequences. It means that computable necessary and sufficient conditions for validity of change can not be obtained. Undecidability in this simple model also

This report presents a new, automatic technique to assess whether replacing a component of a software system by a purportedly compatible component may change the behavior of the system. The technique operates before integrating the new component into the system or running system tests, permitting quicker and cheaper identification of problems. It takes into account the system’s use of the component, because a particular component upgrade may be desirable in one context but undesirable in another. No formal specifications are required, permitting detection of problems due either to errors in the component or to errors in the system. Both external and internal behaviors can be compared, enabling detection of problems that are not immediately reflected in the output. The technique generates an operational abstraction for the old component in the context of the system, and one for the new component in the context of its test suite. An operational abstraction is a set of program properties that generalizes over observed run-time behavior. Modeling a system as divided into modules, and taking into account the control and data flow between the modules, we formulate a logical condition to guarantee that the system’s behavior is preserved across a component replacement. If automated logical comparison indicates that the new component does not make all the guarantees that the old one did, then

this paper, we describe a system for on-line software version change for software written in the C language. When the change is initiated by the user, the system instantiates a new process with the new version of the software, transfers state from the old process to the new one at an appropriate time, and transfers the control to the new process. The user sees a minimal delay in this switchover

Abstract. Modern systems must be adaptable | to changing requirements, bug- xes, new technologies and recon guration. For critical applications this must be possible at run-time; for complex applications it should be limitable to major sub-divisions of the system. The DRASTIC architecture addresses these goals by exploiting object persistence and distributed systems implementation techniques. It enables run-time changes of types, implementations, and the system con guration. This is based on a novel architectural abstraction of locality for evolution, called the `zone'. Contracts between zones automatically limit the visibility of such changes between zones. We present work in progress on DRASTIC's computational model and run-time system, illustrating support for software evolution and highlighting key features of our current implementation. A slightly shorter version of this paper appears in the ECOOP'97 conference proceedings. This document contains more information on the DRASTIC implementation details and related work.

The computing community needs distributed systems to satisfy its need for harnessing more computers solving more problems more quickly. Yet is still hard for programmers to write programs for such systems. Recently, configuration languages have emerged which have the aim of making distributed programming easier, more robust and more flexible. So far, each of these is confined to a small user community, and there is a wide range of features and facilities offered. In this paper, we consider the basic responsibilities of configuration languages and then look at four sample languages in detail. These are Darwin, Durra, PCL and Polylith. The study starts with simple static configuration programming and proceeds to dynamic programming and change management. The producer consumer example is used throughout, and the comparative code fragments shown are a novel feature of the paper. From the results of the comparison we deduce a ten-point scheme of criteria for evaluating a language in terms o...