Continuous availability is a critical requirement for an important class of software systems. For these systems, runtime system evolution can mitigate the costs and risks associated with shutting down and restarting the system for an update. We present an architecture-based approach to runtime software evolution and highlight the role of software connectors in supporting runtime change. An initial implementation of a tool suite for supporting the runtime modification of software architectures, called ArchStudio, is presented. 1

We discuss the problem of defining a composition operator in behavior protocols in a way which would reflect false communication of the software components being composed. Here the issue is that the classical way in the ADLs supporting behavior description, such as Wright and TRACTA, is to employ a CSP-like parallel composition which inherently yields only "successful traces", ignoring non-accepted attempts for communication. We show that

We have implemented a prototype compiler called porch that transforms C programs into C programs supporting portable checkpoints. Portable checkpoints capture the state of a computation in a machine-independent format that allows the transfer of computations across binary incompatible machines. We introduce sourceto -source compilation techniques for generating code to save and recover from such portable checkpoints automatically. These techniques instrument a program with code that maps the state of a computation into a machine-independent representation and vice versa. In particular, the following problems are addressed: (1) providing stack environment portability, (2) enabling conversion of complex data types, and (3) rendering pointers portable. Experimental results show that the overhead of checkpointing is reasonably small, even if data representation conversion is required for portability. 1 Introduction This paper presents a source-to-souce compiler technique that transforms s...

Modern mobile computing paradigms have set new challenges for the development of distributed mobile applications and services. Because of the variability which characterizes the context of such environments, it is important that mobile applications are developed so that they can dynamically adapt their extrafunctional behavior, in order to optimize the experience perceived by their users. This paper proposes an approach for developing adaptive, mobile applications. It is argued that this approach eases the development effort by clearly separating the work required for the development of the application logic from that required for enabling its adaptive behavior. It is argued that in addition to mitigating the development complexity, this approach also enables a new generation of distributed applications. The novelty in the latter is that the applications can dynamically and collaboratively adapt in an ad-hoc manner to improve the quality of the services offered to mobile users. 1.

Clusters of workstations are increasingly being viewed as a cost-effective alternative to parallel supercomputers. However, resource management and scheduling on workstations clusters is complicated by the fact that the number of idle workstations available for executing parallel applications is constantly fluctuating. In this paper, we present a case for scheduling parallel applications on non-dedicated workstation clusters using dynamic space-sharing, a policy under which the number of processors allocated to an application can be changed during its execution. We describe an approach that uses application-level checkpointing and data repartitioning for supporting dynamic spacesharing and for handling the dynamic reconfiguration triggered when failure or owner activity is detected on a workstation being used by a parallel application. The performance advantages of dynamic space-sharing are quantified through a simulation study, and experimental results are presented for the overhead o...

The importance of supporting flexible roles and dynamic policies has long been recognized in the CSCW (Computer-Supported Cooperative Work) literature but unfortunately never with a systematic solution. This paper proposes a taxonomy of runtime dynamics in collaborative systems in general and discusses our solution in the COCA framework. Firstly, individual participants can take roles, drop roles, and switch between roles as a collaboration runs, Secondly, a role can be transferred from one participant to another at runtime. Thirdly, session-wide, authorized participants can change the definition of roles and coordination policies on the fly while keeping the mapping between roles and participants. When such changes happen on the fly, the runtime environment of the sites which are potentially affected, including the state information within the computation modules and the communication channels, must be handled properly according to the semantics of the collaboration itself.

NeCoMan middleware customizes dynamic adaptation of point-to-point-based network services in programmable networks, taking into account the properties of the network services involved as well as the reconfiguration semantics. Programmable networks let third parties dynamically reprogram the network elements. By opening the execution environment of routers, firewalls, base stations, and so on, users and service providers can adapt the behavior of these network elements to meet their own needs. Programmable networks are therefore an interesting technology for building adaptive networks as well as for supporting the evolution of networking software. 1 This article focuses on safe runtime adaptation of point-to-point-based network services in programmable networks. Many network services such as compression, fragmentation, reliability, and encryption conform to a point-to-point-based distributed-service model. This model represents a pair of tightly coupled components (not necessarily situated on neighboring nodes) that must cooperate to offer a distributed service. To prevent the runtime addition, replacement, or removal of these network services from jeopardizing a programmable network's correct functioning, the network programmer must coordinate the adaptation of the protocol stacks accommodating the service components. For

Critical infrastructure applications provide services upon which society depends heavily; such applications require survivability in the face of faults that might cause a loss of service. These applications are themselves dependent on distributed information systems for all aspects of their operation and so survivability of the information systems is an important issue. Fault tolerance is a key mechanism by which survivability can be achieved in these information systems. Much of the literature on fault-tolerant distributed systems focuses on local error recovery by masking the effects of faults.We describe a direction for error recovery in the face of catastrophic faults where the effects of the faults cannot be masked using available resources. The goal is to provide continued service that is either an alternate or degraded service by reconfiguring the system rather than masking faults. We outline the requirements for a reconfigurable system architecture and present an error recovery system that enables systematic structuring of error recovery specifications and implementations.

The ability to construct a software system from separate pieces while the system is being used is a feature which has become more prevalent and important in recent years; in fact, the ability to dynamically compose a system has existed in various programming languages and computing systems for some time. We use the term dynamically composed systems to refer to systems with this property. In general, dynamically composed systems suffer a number of problems, not the least of which is the difficulty in ascertaining what pieces comprise a system. Furthermore, the definition of how particular pieces are selected, what a consistent collection of pieces is, and how multiple versions of the same piece are handled when composing a system dynamically is typically ambiguous, and feedback to users or maintainers of the system with respect to these issues is often non-existent or too late. Traditional configuration management tools address such system composition and evolution issues, but only in a s...

Unanticipated software adaptations are becoming increasingly important in the domain of computer networks. Due to the performance and availability requirements of computer networks, these adaptations need to be enforced at runtime (by means of hot-swapping). However for dynamic changes to yield valid systems, a safe state for reconfiguration of the involved software modules must be enforced. This paper presents a method to impose such a safe state for hot-swapping with minimal interference to the rest of the system, and with minimal contribution from the programmer. We believe that a wide range of producer/consumer based systems can take advantage from the presented solution. 1