By Topic

Configurable Distributed Systems, 1996. Proceedings., Third International Conference on

Date 6-8 May 1996

Filter Results

Displaying Results 1 - 25 of 30
  • Proceedings of International Conference on Configurable Distributed Systems

    Save to Project icon | Request Permissions | PDF file iconPDF (199 KB)  
    Freely Available from IEEE
  • Abstractions and implementations for architectural connections

    Page(s): 2 - 10
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (964 KB)  

    The architecture of a software system shows how the system is realized by a collection of components together with the interactions among these components. Conventional design focuses the components, but the properties of the system depend critically on the character of the interactions. Although software designers have good informal abstractions for these interactions, these abstractions are poorly supported by the available languages and tools. As a result, the choice of interaction is often defaulted or made implicitly rather than deliberately chosen. Further, interactions are usually programmed in terms of underlying mechanisms rather than the designers natural abstractions. UniCon supports a rich selection of abstractions for the connectors that mediate interactions among components. Connector implementation presents special challenges. The "compiler" must produce and integrate not only the object code for components, but also a variety of other run-time products. The definition of a connector requires many connector-specific kinds of information in the compiler, graphical editor, and associated tools. Extending the set of connectors supported by UniCon requires this information to be provided by the connector designer and automatically integrated in the compiler. The paper describes the role of connector abstractions in software design, the connector abstractions currently supported by UniCon, and implementation issues associated with supporting an open-ended collection of connectors. View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Connectors in configuration programming languages: are they necessary?

    Page(s): 11 - 18
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (784 KB)  

    Configuration programming is the process whereby components written in any conventional programming language can be bound together to form a dynamic system, often suitable for execution on distributed hardware. Among the specialised languages that exist for configuration programming there is currently a debate over the importance of recognising the connections between components as being as important as the components themselves. The paper lays out the pros and cons of the debate, outlining in the process the properties and roles of connectors. By means of experiments we show how connectors influence the way configurations are programmed and also how some of the effects can be simulated. The examples are given in Darwin, UNICON and WRIGHT and reference is also made to the status of other current configuration languages. View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Data handles and virtual connections: high-level support for anonymous reconfiguration

    Page(s): 19 - 26
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (863 KB)  

    Data handles and virtual connections are presented as a solution to the problem of supporting application-driven reconfiguration without sacrificing the separation of communication and computation. The solution supports anonymous reconfiguration, meaning that the module performing the reconfiguration and the modules affected by the reconfiguration need not be aware of each other's presence in the system. The solution allows modules to reconfigure the system within the limits of a specified communication structure while retaining support for dynamic end-user reconfiguration. The work is presented in the context of I/O abstraction, a programming model that defines the communication structure of a distributed system in terms of connections among narrow data interfaces of encapsulated modules. I/O abstraction supports dynamic end-user reconfiguration of distributed applications by separating the communication structure from the module definitions. View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Dynamic configuration management in the Guide object-oriented distributed system

    Page(s): 28 - 35
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (804 KB)  

    The configuration management service is the part of system management which provides support for dynamic reconfiguration that allows addition and removal of components without stopping the whole system. The paper presents an efficient algorithm which realizes a difficult compromise between four important criterion: correctness and system consistency, performance and global overhead of the system, support for a large class of applications which will survive system changes, and reducing the required mechanisms for algorithm implementation. View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Practical description of configurations for distributed systems management

    Page(s): 36 - 43
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (913 KB)  

    As distributed systems grow larger and more complex, the problem of managing them becomes more serious and automated assistance becomes essential. Automated management services need to become a standard part of distributed systems but in order for them to be of any value they must be general enough to adapt to the needs of any organization, without sacrificing practical usability. That challenge is partially addressed with a proposal for automated configuration management based upon descriptions of configuration states. The proposed model is very general, yet the language and algorithms that are introduced are designed to be very practical. Experimental application of this approach to a real-life configuration problem is presented, with comparison to the existing solution that is in production use. View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Implementing interactive configuration management for distributed systems

    Page(s): 44 - 51
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (1291 KB)  

    The paper describes an environment for interactive configuration management of software for distributed applications and services. Configuration management involves creating the components which form a distributed system; allocating these components to physical nodes and binding the interfaces of the components to each other or to existing services. Components and their required and provided interfaces are represented and accessible in the system-wide domain structure. We describe a graphical configuration environment, based on the Darwin configuration language which is used to create the required configurations and maintain the configuration structure as part of the overall systems management infrastructure. The paper describes a simple example to show how a system can be initially constructed and subsequently reconfigured at run-time without shutting down the system. View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Agent-based configuration management of distributed applications

    Page(s): 52 - 59
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (740 KB)  

    Mobile agents provide a new paradigm for distributed computation. Their unique properties appear well suited to the configuration management of large and complex distributed applications. After outlining our concept of configuration management, we describe a basic agent infrastructure and its extensions for configuration management of distributed applications. Then we consider aspects of concurrent agents and discuss the advantages of the agent based approach through an example. View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Maintaining node consistency in the face of dynamic change

    Page(s): 62 - 69
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (824 KB)  

    With the increasing demand for long running and highly available distributed services, interest in systems which can undergo dynamic reconfiguration has risen. However for dynamic change to yield valid systems, change actions must be carried out such that the consistency of the software modules making up the system is not breached. This can be ensured if the subset of the system which is to undergo change is in a state amenable to reconfiguration. This paper presents an algorithm which imposes a safe state over the part of the system undergoing change. The algorithm suits a particular class of transactional systems and places special emphasis on minimising the interference to the rest of the system and reducing the programmer contribution necessary for achieving this safe state. View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • On-line maintenance with on-the-fly software replacement

    Page(s): 70 - 80
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (1114 KB)  

    At Philips Research Laboratories Aachen we have found a way to reconfigure software in embedded systems like, for example, switches or set top boxes. The goal of the reconfiguration is to repair software faults and to update software functionality. This should be done on-the-fly without decreasing the system's availability which means during the on-going operation of the system. The developed approach is based on available distributed operating system technology (Chorus) and on a widely used family of programming languages (C/C++). It does not require changes in the operating system nor in the development system. All needed adaptations are done in the application. However, it was our goal to keep the development of the application functionality separated from the creation of the replaceability. An application is made replaceable through some systematic changes which can be done automatically. Some additional effort is still needed. This paper describes the mechanisms developed for that purpose. As a reconfiguration unit we have chosen a Chorus actor which is a kind of a multi-threaded process. We describe how to make such a process replaceable. Finally, we give some performance figures to show the efficiency of the implemented algorithms. View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • A model for dynamic configuration which preserves application integrity

    Page(s): 81 - 88
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (908 KB)  

    Our approach to dynamic configuration is based on building a model of reconfigurable applications. The model documents applications according to the configuration paradigm and for each component, captures structural constraints and behavioural information. The model presents change administrators with an abstract interface to dynamic configuration management. Change is initiated by submitting a version descriptor to the configuration manager; much of the low-level and error-prone activities of dynamic configuration are automated. Synchronisation of dynamic configuration with the application and management of persistent state are fundamental to preserving an application's integrity. We present our synchronisation mechanism, which adopts atomic operations for both intra- and inter-component computation. The problems of persistent state management are simplified by our synchronisation model. We also expose the difficulties and propose solutions for managing composite components and components whose operations are constrained. View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Building reconfiguration primitives into the law of a system

    Page(s): 89 - 97
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (778 KB)  

    Given a certain class C of reconfigurations, deemed to be potentially important for a given system, we define a reconfiguration suite Sc to be a set of primitive operations that satisfy the following conditions: any reconfiguration in C can be carried out by a sequence of primitives from Sc. The correctness of Sc should be independent of the functionality of the system, and invariant of its reconfigurations (for a given set of possible configurations of the system at hand). We describe a mechanism for implementing such reconfiguration suites, for a system that operates under law-governed interaction (LGI), currently supported by an experimental toolkit called Moses. LGI is a mode of interaction between the members of a given group (or system) of agents, which is governed by an explicit and strictly enforced set of rules, called the law of this group. The existence of such a law under LGI provides us with an architectural model of the system, which can be made to include the definition of reconfiguration suites. View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Models for computational steering

    Page(s): 100 - 107
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (1022 KB)  

    This paper describes a conceptual model for computational program steering. By exploiting previous results attained in program monitoring, debugging, and configuration, the abstractions and mechanisms derived from this model are shown suitable for both algorithmic and human interactive steering. A characterization of existing systems for computational steering using the model's abstractions demonstrate such generality. The model is illustrated through its use for steering a large-scale scientific code. Mechanisms for computational steering derived from the model are presented that include sensors, probes, and actuators. View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Fast concurrent dynamic linking for an adaptive operating system

    Page(s): 108 - 115
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (913 KB)  

    The need for customizable and application-specific operating systems has been recognized for many years. A customizable operating system is one that can adapt to some particular circumstance to gain some functional or performance benefits. Microkernels have attempted to address this problem, but suffer performance degradation due to the cost of inter-process protection barriers. Commercial operating systems that can efficiently adapt themselves to changing circumstances have failed to appear, in part due to the difficulty of providing an interface that is efficient to invoke, provides a protection barrier, and can be dynamically reconfigured. Providing such a safe, efficient, and dynamic interface in a concurrent operating system requires an effective concurrency control mechanism to prevent conflicts between system components proposing to execute specialized components, and those components responsible for dynamically replacing specialized components. We outline our basic approach to specialization of operating systems, and detail our dynamic replacement mechanism and its concurrency control features. View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • It's your choice-on the design and implementation of a flexible metalevel architecture

    Page(s): 116 - 122
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (723 KB)  

    Traditional configurable operating systems typically provide a fixed and limited set of functionality. We propose a metalevel architecture, where application-defined objects can choose from a rich selection of possible configurations and are therefore able to dynamically change the way in which they are executed to the configuration that suits best. This allows applications to adapt operating system behaviour to even unanticipated requirements during run-time. A distributed application which processes multimedia data serves as an example to illustrate the concepts described. View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • A family of design patterns for flexibly configuring network services in distributed systems

    Page(s): 124 - 135
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (1312 KB)  

    This paper describes a family of design patterns that enhance the flexibility and extensibility of communication software by permitting network services to evolve independently of the strategies used to passively initialize the services. The paper makes three contributions to the study and development of configurable distributed systems. First, it identifies five orthogonal dimensions of passive service initialization: service advertisement, endpoint listening, service handler creation, passive connection establishment, and service handler activation. Second the paper illustrates how a family of design patterns have been used to build a communication software framework that supports flexible configuration of different strategies for each of these five dimensions. Third, the paper demonstrates how design patterns and frameworks are being used successfully to develop configurable large-scale production distributed systems. View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • The design and implementation of a framework for configurable software

    Page(s): 136 - 143
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (1047 KB)  

    Software systems are typically composed of numerous components, each of which is responsible for a different function. Different implementations of a component may be possible, with each implementation tailored for a specific set of applications or environments. Being able to reconfigure software systems to make use of these different implementations with the minimum of effect on existing users and applications is desirable. Configurable software systems are also important for a number of other reasons: additional components or modifications to those currently available, may be required. For example, new versions of software components may be necessary due to the discovery of design flaws in a component; a RPC which provider unreliable message delivery may be suitable for an application in a local area network, but if the application is to be used in a wide area network, a different RPC implementation, which guarantees message delivery, may be necessary. Therefore, software is often required to be configurable, enabling modifications to occur with minimal effect on existing users. To allow this configurability, components should only be available through interfaces that are clearly separated from their implementations, allowing users to be isolated from any implementation changes. Object-oriented programming techniques offer a good basis upon which this separation can be provided. This paper describes a model for constructing configurable software based upon this separation, and illustrates this with a software development system. View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • A uniform approach to configuration and communication in distributed systems

    Page(s): 144 - 151
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (677 KB)  

    This paper describes the design and implementation of extensions to the Regis distributed programming platform which add protocol stacks to communication endpoints. Although the initial goal was to extend Regis to support multiple transport protocols, groupcast and multimedia communication, the dynamic nature of the protocol framework allowed new approaches to the design of communication protocol software. Transient protocol layers provide support for binding establishment and connection management in a manner which is largely transparent to the user of the endpoint. The paper describes this approach through examples and shows how it leads to greater efficiency and a greater degree of code reuse. View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • The Unstoppable Orchestra: a responsive distributed application

    Page(s): 154 - 160
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (704 KB)  

    Responsiveness, the ability to provide real-time behavior even in the presence of faults, is becoming one of the most sought after properties in distributed computing systems. We present a framework for "high-performance responsive computing" in networked systems whose current implementation works on a network of five NeXTSTEP (Mach 2.5)-based HP workstations. "The Unstoppable Orchestra" is a demonstration program which runs in our environment. This application simulates a real orchestra consisting of musicians playing different instrumental parts of a classical masterpiece. However instead of real musicians our orchestra consists of computers equipped with speakers. In contrast to the real orchestra, where a sudden disappearance of, for example, a flautist can hardly be hidden, in our orchestra one "musician" can take over his neighbour's part, ensuring uninterrupted performance. We discuss the design issues behind the "Unstoppable Orchestra" and show how our programming framework supports synchronization and reconfiguration of responsive applications. View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • A replication protocol to support dynamically configurable groups of servers

    Page(s): 161 - 168
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (901 KB)  

    The paper addresses the problem of dynamic configuration management of highly available services. In particular, we are concerned with services that are provided by a group of actively replicated servers and are used by a large, rapidly changing set of clients. In this system model, we propose a replication management protocol to facilitate the dynamic configuration management of the server group, while maintaining service state consistency. We argue about the correctness of the protocol and report on initial implementation results. View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Using application specific knowledge for configuring object replicas

    Page(s): 169 - 176
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (964 KB)  

    In distributed systems, object replication is used to improve the availability and performance of applications in the presence of failures. When determining the configuration of a replicated object (i.e., number and location of replicas), a number of often conflicting factors need to be considered, e.g., the availability and performance requirements of the object. However, application specific knowledge about the objects, such as any inter-dependencies, is typically not accounted for. In many applications this information can effect an object's availability. Distributed systems which support replication typically give users only basic control over the configuration of a replicated object, such as the number or location of individual replicas. Expressing application specific knowledge is not possible. We have designed and implemented a replication sub-system allowing applications to control these aspects of replication. This system allows the efficient replication of an arbitrary number of objects with arbitrary inter-dependencies. View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Supporting distributed application management in Sampa

    Page(s): 177 - 184
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (826 KB)  

    The paper presents the architecture and base services of Sampa, a System for Availability Management of Process-based Applications. The system has been designed to support the management of fault-tolerant DCE-based distributed programs according to user provided and application-specific availability specifications. Sampa is supposed to detect and automatically react to faults such as node crashes, network partitions, process crashes and hang-ups. We focus on the design of its base services-the monitoring, reliable group communication and checkpointing facilities and show how they can be used for managing a generic replicated service. View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Abstraction and composition techniques for reconfiguration of large-scale complex applications

    Page(s): 186 - 193
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (987 KB)  

    Complex distributed applications are often developed incrementally while they are in active use. Programming and runtime environments must allow software designers to make these changes easily and efficiently. This must be provided within the appropriate framework for modeling, analysis and correct execution that is essential for complex applications. The key to supporting reconfiguration of large-scale applications is providing efficient abstraction and composition mechanisms. By separating specification of well-defined components from the component interaction and composition behavior, we allow designers to implement easily replaceable components and changeable interaction behavior. The abstraction mechanism simplifies development of large-scale reconfigurable applications by hiding implementation details. The facility also includes automatic analytical tools for checking consistency, reachability and dependency in the behavior of interacting components. These tools are essential for development and runtime support of large-scale and reconfigurable decentralized applications. View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Aster: a CORBA-based software interconnection system supporting distributed system customization

    Page(s): 194 - 201
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (852 KB)  

    The paper introduces the Aster distributed composition-based programming system that is aimed at easing the development of distributed runtime systems, customized to the application needs, in a CORBA-based environment. Our approach is based on high-level customization: given the specification of application requirements using the Aster composition language, a distributed runtime system, customized for meeting these requirements is built. Furthermore, the fact that the Aster system is based on the CORBA standard for distributed computing enhances the potential of re-use of both application-level and system-level software. View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Distributed interoperable virtual environments

    Page(s): 202 - 209
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (1190 KB)  

    The paper exhibits the use of existing software bus technology in interconnecting virtual-reality environment (VE) software. Interoperability and application construction from heterogeneous modules are well-explored topics of distributed systems. A joint project using the Polylith software bus from the University of Maryland and VE software from the UNC graphics lab has shown the utility of composing existing applications as opposed to making extensive individual modifications. The paper claims only a unique application of these methods to a new client area. Multi-user VE walkthroughs (software navigators) are an exciting new area in graphics software but we see that with the rapid development of graphics technology, next-generation applications (including multiuser systems) are commonly redesigned from the ground up. Here we see an excellent opportunity to examine module reusability, with proven software, in a new application area. We hope our experiments will likely lead to conclusions about VE programming abstractions and produce development methods for making easily interoperable next-generation VE applications. View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.