In the last 30 days

• Open/close An introduction to snapshot algorithms in distributed computing

  A D Kshemkalyani et al 1995 Distrib. Syst. Engng. 2 224 Tag this article

  Article References Full text PDF (807 KB)

  Recording on-the-fly global states of distributed executions is an important paradigm when one is interested in analysing, testing, or verifying properties associated with these executions. Since Chandy and Lamport`s (1985) seminal paper on this topic, this problem is called the snapshot problem. Unfortunately, the lack of both a globally shared memory and a global clock in a distributed system, added to the fact that transfer delays in these systems are finite but unpredictable, makes this problem non-trivial. This paper first discusses issues which have to be addressed to compute distributed snapshots in a consistent way. Then several algorithms which determine on-the-fly such snapshots are presented for several types of networks (according to the properties of their communication channels, namely, FIFO, non-FIFO, and causal delivery).

• Open/close A comparison of DQDB and FDDI for the interconnection of LANs

  R Ahmad and F Halsall 1994 Distrib. Syst. Engng. 1 127 Tag this article

  Article References Full text PDF (454 KB)

  The paper identifies the design issues that must be considered when interconnecting IEEE 802 LANs through either DQDB or FDDI backbone subnetworks using MAC bridges. A series of simulation results are presented that compare the performance of both subnetwork types for various types of LAN traffic, backbone subnetwork sizes (physical coverage and number of LANs) and other performance-critical parameters. The paper concludes with some guidelines to be followed to achieve an optimal performance to meet specific application requirements.

• Open/close A software architectural design method for large-scale distributed information systems

  Hassan Gomaa et al 1996 Distrib. Syst. Engng. 3 162 Tag this article

  Article References Full text PDF (347 KB)

  This paper describes a software architectural design method for large-scale distributed information systems. The method, which is part of an integrated design and performance evaluation method, addresses the design of client/server software architectures, where the servers need to cooperate with each other to service client requests. The goal of this software architecture is to provide a concurrent message based design that is highly configurable. The method is illustrated by applying it to the design of a complex software system, the Earth Observing System Data and Information System (EOSDIS) Core System.

• Open/close Design and implementation of a support platform for distributed mobile computing

  A Schill and S Kummel 1995 Distrib. Syst. Engng. 2 128 Tag this article

  Article References Full text PDF (1.36 MB)

  With the rapid development of mobile computer systems and mobile communication infrastructures, a broad field of distributed mobile computing is enabled. The paper first discusses these developments in closer detail and summarizes the resulting requirements concerning adequate software support. An application scenario of the service engineering area illustrates specific aspects including bandwidth and location management, dynamic configuration, resource heterogeneity, disconnection, and security. Based on these considerations, a generic software support platform for distributed mobile computing is derived. It addresses several of these aspects by providing application-independent and reusable support services. In particular, it offers a framework for organizing distributed mobile applications into manageable domains, it equips mobile stations with enhanced functionality for location, resource and bandwidth management, and it uses industry standard RPC communication facilities for enhanced portability. The design, implementation and use of the support platform is illustrated based on a specific part of the application, a mobile multimedia e-mail system. Experiences and implementation aspects in this context are particularly emphasized.

• Open/close Scalability evaluation of a distributed agent system

  Anne-Louise Burness et al 1999 Distrib. Syst. Engng. 6 129 Tag this article

  Article References Full text PDF (177 KB)

  The use of new computing paradigms is intended to ease the design of complex systems. However, the non-functional aspects of a system, including performance, reliability and scalability, remain significant issues. It is hard to detect and correct many scalability problems through system testing alone - especially when the problems are rooted in the higher levels of the system design. Late corrections to the system can have serious implications for the clarity of the design and code.

  We have analysed the design of a system of multiple near-identical, `reactive' agents for scalability. We believe that the approach taken is readily applicable to many object oriented systems, and may form the basis of a rigorous design methodology. It is a simple, yet scientific extension to current design techniques using message sequence charts, enabling design options to be compared quantitatively rather than qualitatively. Our experience suggests that such analysis should be used to consider the effect of artificial intelligence, to ensure that autonomous behaviour has an overall beneficial effect for system performance.

• Open/close Capacity reservation for multimedia traffic

  Miranda Mowbray et al 1998 Distrib. Syst. Engng. 5 12 Tag this article

  Article References Full text PDF (96 KB)

  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.

• Open/close GEM: a generalized event monitoring language for distributed systems

  Masoud Mansouri-Samani and Morris Sloman 1997 Distrib. Syst. Engng. 4 96 Tag this article

  Article References Full text PDF (303 KB)

  Event-based monitoring is critical for managing and debugging networks and distributed systems. This paper presents GEM - an interpreted generalized event monitoring language. It allows high-level, abstract events to be specified in terms of combinations of lower-level events from different nodes in a loosely coupled distributed system. Event monitoring components can thus be distributed within the system to perform filtering, correlation and notification of events close to where they occur and thus reduce network traffic. GEM is a declarative rule-based language in which the notion of real time has been closely integrated and various temporal constraints can be specified for event composition. The paper discusses the effect of communication delays on composite event detection and presents a tree-based solution for dealing with out-of-order event arrivals at event monitors.

• Open/close Distributed operating systems anno 1992. What have we learned so far?

  A S Tanenbaum 1993 Distrib. Syst. Engng. 1 3 Tag this article

  Article References Full text PDF (656 KB)

  Research on distributed systems has been going on for over a decade. Perhaps it is time to sit back and take stock. What have we learned in this time? The author presents one viewpoint of what is important in the field. The topics covered include system structure, communication, and distributed shared memory. The paper concludes by discussing some open issues for future research.

• Open/close Virtual memory support for distributed computing environments using a shared data object model

  F Huang et al 1995 Distrib. Syst. Engng. 2 202 Tag this article

  Article References Full text PDF (842 KB)

  Conventional storage management systems provide one interface for accessing memory segments and another for accessing secondary storage objects. This hinders application programming and affects overall system performance due to mandatory data copying and user/kernel boundary crossings, which in the microkernel case may involve context switches. Memory-mapping techniques may be used to provide programmers with a unified view of the storage system. This paper extends such techniques to support a shared data object model for distributed computing environments in which good support for coherence and synchronization is essential. The approach is based on a microkernel, typed memory objects, and integrated coherence control. A microkernel architecture is used to support multiple coherence protocols and the addition of new protocols. Memory objects are typed and applications can choose the most suitable protocols for different types of object to avoid protocol mismatch. Low-level coherence control is integrated with high-level concurrency control so that the number of messages required to maintain memory coherence is reduced and system-wide synchronization is realized without severely impacting the system performance. These features together contribute a novel approach to the support for flexible coherence under application control.

• Open/close Meeting the real-time synchronization requirements of multimedia in open distributed processing

  G Coulson and G S Blair 1994 Distrib. Syst. Engng. 1 135 Tag this article

  Article References Full text PDF (943 KB)

  Distributed systems has been an area of intense activity over the past ten years. The subject is entering a stage of maturity with work now focusing on standards for open distributed processing (ODP). Recently, however, a number of new challenges have emerged for distributed systems. Among these challenges, distributed systems are increasingly having to support multimedia services, and this has raised a number of issues for distributed systems designers. One of the most important issues in this area is that of synchronization. Multimedia applications require sophisticated support for synchronization both to coordinate multimedia presentations and to maintain timing relationships between a number of real-time data transmissions. Current distributed system architectures do not support such services. The paper discusses the problem of incorporating support for synchronization in open distributed system architectures. It is argued that support must be provided for synchronization both in the invocation mechanism and in the form of new services called streams and synchronization managers. The proposals are compared to related work in the field.