Showing papers in "Distributed Systems Engineering in 1998"

DIVE: a scaleable network architecture for distributed virtual environments

Abstract: We introduce the network software architecture of the distributed interactive virtual environment platform. The platform is designed to scale with a large number of simultaneous participants, while ensuring maximum interaction at each site. Scalability is achieved by making extensive use of multicast techniques and by partitioning the virtual space into smaller regions. We also present an application-level backbone that can connect islands of multicast-aware networks together.

Quality-of-service specification in distributed object systems

Abstract: Traditional object-oriented design methods deal with the functional aspects of systems, but they do not address quality-of-service (QoS) aspects, such as reliability, availability, performance, security and timing. However, deciding which QoS properties should be provided by individual system components is an important part of the design process. Different decisions are likely to result in different component implementations and system structures. Thus, decisions about component-level QoS should commonly be made at design time, before the implementation is begun. Since these decisions are an important part of the design process, they should be captured as part of the design. We propose a general quality-of-service specification language, which we call QML. In this paper we show how QML can be used to capture QoS properties as part of designs. In addition, we extend UML, the de facto standard object-oriented modelling language, to support the concepts of QML. QML is designed to integrate with object-oriented features, such as interfaces, classes and inheritance. In particular, it allows specification of QoS properties through refinement of existing QoS specifications. Although we exemplify the use of QML to specify QoS properties within the categories of reliability and performance, QML can be used for specification within any QoS category - QoS categories are user-defined types in QML. Sometimes, QoS characteristics and requirements change dynamically due to changing user preferences, or changes in the environment. For such situations static specification is insufficient. To allow for dynamic systems that change and evolve over time, we provide a QoS specification runtime representation. This representation enables systems to create, manipulate and exchange QoS information, and thereby negotiate and adapt to changing QoS requirements and conditions.

Mobile Objects and Agents (MOA)

Abstract: This paper describes the design and implementation of the Mobile Objects and Agents (MOA) project at the Open Group Research Institute. MOA was designed to support migration, communication and control of agents. It was implemented on top of the Java Virtual Machine, without any modifications to it. The initial project goals were to support communication across agent migration, as a means for collaborative work; and to provide extensive resource control, as a basic support for countering denial of service attacks. In the course of the project we added two further goals: compliance with the Java Beans component model, which provides for additional configurability and customization of agent system and agent applications; and interoperability, which allows cooperation with other agent systems. This paper analyses the architecture of MOA, in particular the support for mobility, naming and locating, communication, and resource management. Object and component models of MOA are discussed and some implementation details described. We summarize the lessons learned while developing and implementing MOA and compare it with related work.

Awareness-based communication management in the MASSIVE systems

Abstract: The MASSIVE-1 and MASSIVE-2 distributed virtual environment systems are based on an explicit model of user communication requirements known as the spatial model of interaction; this model addresses the general issue of managing communication in large space-based systems such as DVEs. The goals of the spatial model are to guide the distribution and presentation of information in a way which facilitates collaboration between participants (based on observed patterns of interaction in real-world environments) and which is also efficient and appropriate. The MASSIVE-1 system emphasized the spatial model's `aura' concept as the basis for a distinct shared service in an otherwise wholly unicast peer-to-peer system. This approach was effective for relatively small systems but could not be extended to make general use of multicast communication (to reduce total bandwidth requirements). The MASSIVE-2 system added the concept of `third-party objects' which support the definition and management of multiple multicast groups for updates and continuous media distribution.

Capacity reservation for multimedia traffic

Abstract: We introduce a new scheduling algorithm for multimedia traffic using capacity reservation. We compare it with other algorithms in the literature. It has been implemented and its worst-case performance has been analysed. It appears to give a noticeably improved quality of service to delay-sensitive traffic.

The Voltan application programming environment for fail-silent processes

Abstract: The Voltan software library for building distributed applications provides the support for (i) a process pair to act as a single Voltan self-checking `fail-silent' process; and (ii) connection management for Voltan process communication. A Voltan fail-silent process is written by the application developer as a single threaded program. The Voltan system replicates this program transparently. The active replication of applications engenders problems when dealing with non-deterministic calculations. This paper outlines the mechanisms deployed by Voltan to deal with non-determinism. The current implementation can achieve a level of performance that is suitable for many real-time applications. The work described in this paper provides a way of solving the challenging problem of constructing fault-tolerant distributed computing systems capable of tolerating Byzantine failures, using general-purpose, low-cost components. The present practice is to employ hardware-based approaches to construct a `fail-silent' node using a self-checking processor pair working in lock-step. However, this approach is very costly in terms of the engineering effort required, and further, as processor speeds increase, keeping a pair in lock-step execution may prove difficult.

Practical delegation for secure distributed object environments

Abstract: In distributed object environments, intermediate objects hide the details of complex system interactions. These intermediate objects receive high level requests from client objects and perform a series of operations on a number of other object services. All requests arriving at the target services appear to be the action of the intermediary rather than the true initiator. The inability to determine the true initiator of a request has a chilling effect on the design of distributed object systems. Delegation is the process whereby a principal in a distributed object environment authorizes another principal to access services and resources on its behalf. Even with the state-of-the-art authentication techniques, delegation is typically implicit and transparent to the remote services, making it difficult for those services to determine whether delegation was authorized by the initiator. We have developed an architectural framework for structuring secure remote method invocations that may involve chains of delegated calls across distributed objects. SDM is a Secure Delegation Model for Java-based distributed object environments. SDM builds upon existing mechanisms, mainly those already established in the Java JDK1.2 security framework, to establish a practical basis for constructing flexible yet secure components and support infrastructure. The framework supports a control API for application developers to specify mechanisms and security policies surrounding simple or cascaded delegation. Delegation may also be disabled and optionally revoked.

SmallTool - a toolkit for realizing shared virtual environments on the Internet

Abstract: With increasing graphics capabilities of computers and higher network communication speed, networked virtual environments have become available to a large number of people While the virtual reality modelling language (VRML) provides users with the ability to exchange 3D data, there is still a lack of appropriate support to realize large-scale multi-user applications on the Internet In this paper we will present SmallTool, a toolkit to support shared virtual environments on the Internet The toolkit consists of a VRML-based parsing and rendering library, a device library, and a network library This paper will focus on the networking architecture, provided by the network library - the distributed worlds transfer and communication protocol (DWTP) DWTP provides an application-independent network architecture to support large-scale multi-user environments on the Internet

DEE: an architecture for distributed virtual environment gaming

Abstract: This paper presents a distributed virtual environment architecture targeted specifically at network games. It outlines the requirements for supporting a game genre known as graphical multi-user dungeons or dimensions, and shows how these requirements can be met by a novel approach to the distribution of the game environment model. An implementation of the architecture is covered, together with the initial conclusions drawn from the implementation process.

The design and performance of MedJava. Experience of developing performance-sensitive distributed applications with Java

Abstract: The Java programming language has gained substantial popularity in the past two years. Java's networking features, along with the growing number of Web browsers that execute Java applets, facilitate Internet programming. Despite the popularity of Java, however, there are many concerns about its efficiency. In particular, networking and computation performance are key concerns when considering the use of Java to develop performance-sensitive distributed applications. This paper makes three contributions to the study of Java for performance-sensitive distributed applications. First, we describe an architecture using Java and the Web to develop MedJava, which is a distributed electronic medical imaging system with stringent networking and computation requirements. Second, we present benchmarks of MedJava image processing and compare the results with the performance of xv , which is an equivalent image processing application written in C. Finally, we present performance benchmarks using Java as a transport interface to exchange large medical images over high-speed ATM networks. For computationally-intensive algorithms like image filtering, Java code that is optimized both manually and with JIT compilers can sometimes compensate for the lack of compile-time optimizations and yield a performance commensurate with equivalently compiled C code. With rigorous compile-time optimizations, however, C compilers still generally generate more efficient code. The advent of highly optimizing Java compilers should make it feasible to use Java for performance-sensitive distributed applications where C and C++ are currently used.

Network control as a distributed object application

Abstract: We describe our experiences and performance figures from an open-switching approach to broadband (ATM) connection management. The control system described is the lowest layer of a general connection management architecture such as TINA or Xbind.

Performance engineering of the Totem group communication system

Abstract: Group communication systems simplify the development of fault-tolerant distributed applications; however, concerns exist about the performance and overheads associated with such systems. This paper presents measurements of the performance of the Totem group communication system, operating on a single local-area network (LAN) and on multiple LANs interconnected by gateways. The Totem system runs in user space with standard commercial off-the-shelf (COTS) software and hardware. For 1 kbyte messages, a throughput of over 5000 messages per second has been measured for Totem on a single LAN, and an aggregate throughput of 10 000 messages per second has been measured for Totem on three LANs. At 2000 messages per second, the message latency is less than 3 ms. The paper also discusses some of what has been learned in engineering a group communication system for high performance.

Building a scalable and efficient component-oriented system using CORBA - an Active Badge system case study

Abstract: This paper presents experience gathered through the implementation of a CORBA-based localization system for an office environment. The localization system simultaneously preserves the fine-grained object-oriented structure of the system and achieves efficient performance. The presented study is a practical lesson concerning the implementation of a scalable, information-dissemination system. The key idea is to represent a large observable collection of objects by a repository that provides access to them both as individual CORBA objects and as data records. The proper use of this duality may have a substantial impact on the overall system performance. The repository is equipped with a scalable notification mechanism built around the concepts of a notification dispatcher and a notification tree. Fundamental features of the proposed solution are illustrated by a performance study and a representative application.

Space-sharing architecture for a three-dimensional virtual community

Abstract: This paper describes our proposal for a new virtual community architecture that employs a technique for dividing and managing virtual space, a message-model, and a space-sharing technique We also describe certain concepts that can be used to apply our architecture to PCs and modems: the pack-delivery method for messages, and an asynchronized-rendering method Finally, we review the results of our experimental service: `CyberCity96'

Context management and its applications to distributed transactions

Abstract: An emerging paradigm that handles multiple loci of control in a system allows multiple program threads to work on the same task, each thread to work on a different task, or a thread to work on multiple tasks for greater design flexibility or due to system constraints such as real-time demands and a high load on tasking. We use the definition of context to capture the notion of logical locus of control. The context of the work being currently executed must be identifiable uniquely by the application, the resource managers and the transaction manager because each context represents different work. in this paper, we define context management by defining a local context manager and its user interface. We then show why the notion of context is required to solve the problems that arise in local and distributed transaction processing due to the emerging paradigm. We present solutions to these problems in transaction processing using the proposed context management.

Construction and management of highly available services in open distributed systems

Abstract: This paper addresses the problem of constructing and managing highly available services for large, open distributed systems. A novel replication protocol is presented that satisfies two fundamental requirements of this environment. First, it hides replication from the service clients and secondly, it facilitates the dynamic reconfiguration of the server group. The protocol has been implemented and tested in the Regis distributed environment. The experimental results indicate that the cost of replication transparency is acceptable.

Connection-information-based connection rerouting for connection-oriented mobile communication networks

Abstract: To date, various connection rerouting methods for connection-oriented mobile networks have been proposed. The previous methods, however, are limited to specific topologies or environments. In this paper, we propose the connection-information-based rerouting widely applicable to various connection-oriented mobile networks. This method requires neither a specific topology nor a complex connection, enables fast rerouting, provides appropriate route optimality, and can be extended easily.