Communication support for distributed collaborative applications

The development of distributed, multimedia, collaborative applications requires the resolution of communication issues such as concurrency control and temporal and causal synchronization of traffic over related data streams. Existing transport and/or session-layer protocols do not include the desired support for multistream, multipoint communication. In this paper, we propose new communication abstractions and mechanisms that facilitate the implementation of the necessary coordination and concurrency control semantics in a collaborative application. We propose a protocol suite called themultiflow conversation protocol (MCP) for the realization of these abstractions and describe its prototype implementation in an internetwork of workstations. The paper also describes our experience with the prototype and results of a performance evaluation.     

A support platform for distributed multimedia applications

Abstract

Considerable progress has been made in the development of technologies to support distributed multimedia computing, such that there is now a wide range of pilot applications under development. The design of support systems which help in the development of multimedia applications is therefore an emerging area of research. This paper discusses the requirements of distributed multimedia applications with respect to their support environments. A number of experimental systems are then described which intend to provide the necessary facilities for multimedia applications. Particular focus is placed on the Lancaster system which provides multimedia support for open distributed systems.     

Synchronization support and group-membership services for reliable distributed multimedia applications

We describe a collection of algorithms designed to support reliable synchronization and group membership services for distributed multimedia applications. In particular, we consider those applications that require interactivity, isochronous rendering of multimedia data, and high reliability. We show that the algorithms we propose (i) provide reliable support for the synchronization of multimedia data streams, despite the occurrence of possible communication failures, (ii) maintain a consistent view of the relative group membership of all the nonfaulty application components, (iii) guarantee time-bounded delay of component failure detection and join, and (iv) meet effectively possible scalability requirements of the applications.     

Programming languages for distributed applications

Much progress has been made in distributed computing in the areas of distribution structure, open computing, fault tolerance, and security. Yet, writing distributed applications remains difficult because the programmer has to manage models of these areas explicitly. A major challenge is to integrate the four models into a coherent development platform. Such a platform should make it possible to cleanly separate an application’s functionality from the other four concerns. Concurrent constraint programming, an evolution of concurrent logic programming, has both the expressiveness and the formal foundation needed to attempt this integration. As a first step, we have designed and built a platform that separates an application’s functionality from its distribution structure. We have prototyped several collaborative tools with this platform, including a shared graphic editor whose design is presented in detail. The platform efficiently implements Distributed Oz, which extends the Oz language with constructs to express the distribution structure and with basic primitives for open computing, failure detection and handling, and resource control. Oz appears to the programmer as a concurrent object-oriented language with dataflow synchronization. Oz is based on a higher-order, state-aware, concurrent constraint computation model. Seif Haridi, Ph.D.: He received his Ph.D. in computer science in 1981 from the Royal Institute of Technology, Sweden. After spending 18 months at IBM T. J. Watson Research Center, he moved to the Swedish Institute of Computer Science (SICS) to form a research lab on logic programming and parallel systems. Dr. Haridi is currently the research director of the Swedish Institute of Computer Science. He has been an active researcher in the area of logic and constraint programming and parallel processing since the beginning of the eighties. His earlier work includes contributions to the design of SICStus Prolog, various parallel Prolog systems and a class of scalable cache-coherent multiprocessors known as Cache-Only Memory Architecture (COMA). During the nineties most of his work focused on the design of multiparadigm programming systems based on Concurrent Constraint Programming (CCP). Currently, he is interested in programming systems and software methodology for distributed and agent-based applications. Peter Van Roy, Ph.D.: He obtained an engineering degree from the Vrije Universiteit Brussel (1983), Masters and Ph.D. degrees from the University of California at Berkeley (1984, 1990), and the Habilitation à Diriger des Recherches from Paris VII Denis Diderot (1996). He has made major contributions to logic language implementation. His research showed for the first time that Prolog can be implemented with the same execution efficiency as C. He was principal developer or codeveloper of Aquarius Prolog, Wild_Life, Logical State Threads, and FractaSketch. He joined the Oz project in 1994 and is currently working on Distributed Oz. His research interests are motivated by the desire to provide increased expressivity and efficiency to application developers. Per Brand: He is a researcher at the Swedish Institute of Computer Science. He has previously worked on the design and implementation of OR-parallel Prolog (the Aurora project) and optimized compilation techniques for Concurrent Constraint Programming Languages (in particular, AKL). He has been a member of the Distributed Oz design team since the project began. His research interests are focused on techniques, languages, and methodology for distributed programming. Christian Schulte: He studied computer science at the University of Karlsruhe, Germany, from 1987 to 1992 where he received his diploma. Since 1992 he has been a member of the Programming Systems Lab at DFKI. He is one of the principal designers of Oz. His research interests include design, implementation, and application of concurrent and distributed programming languages as well as constraint programming.     

Generic windowing support for extensible stream processing systems

Stream processing applications process high volume, continuous feeds from live data sources, employ data‐in‐motion analytics to analyze these feeds, and produce near real‐time insights with low latency. One of the fundamental characteristics of such applications is the on‐the‐fly nature of the computation, which does not require access to disk resident data. Stream processing applications store the most recent history of streams in memory and use it to perform the necessary modeling and analysis tasks. This recent history is often managed using windows. All data stream management systems provide some form of windowing functionality. Windowing makes it possible to implement streaming versions of the traditionally blocking relational operators, such as streaming aggregations, joins, and sorts, as well as any other analytic operator that requires keeping the most recent tuples as state, such as time series analysis operators and signal processing operators. In this paper, we provide a categorization of different window types and policies employed in stream processing applications and give detailed operational semantics for various window configurations. We describe an extensibility mechanism that makes it possible to integrate windowing support into user‐defined operators, enabling consistent syntax and semantics across system‐provided and third‐party toolkits of streaming operators. We describe the design and implementation of a runtime windowing library that significantly simplifies the construction of window‐based operators by decoupling the handling of window policies and operator logic from each other. We present our experience using the windowing library to implement a relational operators toolkit and compare the efficacy of the solution to an earlier implementation that did not employ a common windowing library. Copyright © 2013 John Wiley & Sons, Ltd.     

Network-aware support for mobile distributed teams

An experiment evaluated network-aware support to increase understanding of the factors that are important for successful teamwork in mobile geographically dispersed teams of first responders. Participants performed a simulated search and rescue team task and were equipped with a digitized map and real-time situation updates on the location of other participants in a simulated disaster area. The connection to a server, however, was made deliberately error-prone, leading to occasional losses of network connections. Consequently, participants were not provided with real-time situation updates. To deal with this problem we equipped team members with a network-aware application that signaled network loss to them and adapted the graphical representation of the location of fellow team members accordingly to the quality of location information present. The experiment revealed that presenting complete and reliable geospatial information improves teamwork. Teams connected to a server over a fast and reliable link showed superior performance over teams with no network connection whatsoever to a server. The present study failed, however, to demonstrate the added value of network-aware support when teams had to collaborate in the presence of an unreliable communications infrastructure. Although participants indicated a slight preference for the network-aware application over a condition without support signaling network loss, no differences were observed in team process and outcome measures.     

Clock synchronization for distributed media applications

Current video wall technology relies on custom processing hardware to drive the individual display channels. This hardware is both expensive to design and to maintain. Given that modern off‐the‐shelf computers have a significant amount of computing power, future video displays can be driven with this hardware at a lower cost. By using mass‐produced computers and a standard commercial operating system, the benefits of economies of scale can be brought to the custom video wall market. This paper describes a Windows library that provides the synchronized timing support necessary to drive a video wall with consumer hardware. The goal is to provide a key building block for the media software that will process the incoming video stream. This library exports several interfaces to the host software and provides support for synchronized timers, a synchronized clock, and reliable multicast messaging. The library uses common Windows APIs and protocols for maximum interoperability and portability. Through empirical testing, we are able to show that synchronization between any two machines in the system can be maintained to within 12 ms when run on Windows XP SP2. This synchronization is also shown to be consistent even when there is a heavy load on the processor. As a result, this library will successfully allow a commercial video wall to be driven from media software running on consumer hardware and software. Copyright © 2007 John Wiley & Sons, Ltd.     

Full autonomic repair for distributed applications

Grid or cloud environments leverage the need for self‐repair solutions that resist and repair their own failures, something not yet ensured by existing solutions. In this paper, we describe the JADE Autonomic Repair System for legacy applications deployed in a grid or cloud environment. JADE is based on three main design principles. First, legacy applications are wrapped with Java objects, obtaining a uniform set of management operations over the heterogeneous legacy management capabilities. Second, to gain full autonomy, we adopt a replicated design combined with a recursive approach that makes JADE appear to JADE as any distributed application it manages and repairs. Finally, to scale, we rely on tiling the distributed environment and structuring our repair system per tile. To our knowledge, our repair system is the only one that is designed to scale and is fully autonomic, repairing not only the failures of the managed system but also its own. Our repair system has been tested in various realistic scenarios. Copyright © 2013 John Wiley & Sons, Ltd.     

An environment for prototyping distributed applications

Designing a distributed application is an extremely complex task. Proper facilities for prototyping distributed applications can be useful in evaluating a design, and also in understanding the effect of different parameters on the performance of an application. We describe a language for prototyping distributed applications, that supports different communication primitives with specified delay, and provides primitives to aid debugging and evaluation. Our environment for executing distributed programs supports heterogeneous computation in which processes can execute on different hardware. Different source languages can be used for coding different modules of the processes. The system has a centralized control and monitoring facility which is based on the Suntools window system.     

Segue: support for distributed graphical interfaces

The authors describe their experiences developing Segue, an interface tool for supporting application programs that manipulate tree-like data structures. This semantic domain, although restrictive, includes a number of important application programs, such as structured editors, incremental compilers, and file system managers. The user interface tools described here support the Distributed Ada Programming Support Environment (DAPSE). The authors discuss the structure of Segue, present the R2D unparsing system, and examine tree-to-tree mappings. They then present three Segue user interfaces: an Ada editor, an Ada library manager, and the Gift interface specification tool     

Multiserver support for large-scale distributed virtual environments

CyberWalk is a distributed virtual walkthrough system that we have developed. It allows users at different geographical locations to share information and interact within a shared virtual environment (VE) via a local network or through the Internet. In this paper, we illustrate that as the number of users exploring the VE increases, the server will quickly become the bottleneck. To enable good performance, CyberWalk utilizes multiple servers and employs an adaptive region partitioning technique to dynamically partition the whole VE into regions. All objects within each region will be managed by one server. Under normal circumstances, when a viewer is exploring a region, the server of that region will be responsible for serving all requests from the viewer. When a viewer is crossing the boundary of two or more regions, the servers of all the regions involved will be serving requests from the viewer since the viewer might be able to view objects within all these regions. This is analogous to evaluating a database query using a parallel database server, which could improve the performance of serving a viewer's request tremendously. We evaluate the performance of this multiserver architecture of CyberWalk via a detail simulation model.     

Supporting interactive presentation for distributed multimedia applications

In this paper we present IMP, a platform to support the authoring and run-time management of interactive multimedia applications in distributed environments. The multi-level platform model encourages slot-in extensibility to cater for the evolving environment. We illustrate with our prototype platform built above the Cambridge multimedia environment. The authoring model emphasises reusability, tailorability and use of environment features in a uniform way. We have shown the validity of our approach by constructing a variety of application types.     

Late join algorithms for distributed interactive applications

Distributed interactive applications such as shared whiteboards and multiplayer games often support dynamic groups where users may join and leave at any time. A participant joining an ongoing session has missed the data that have previously been exchanged by the other session members. It is therefore necessary to initialize the application instance of the latecomer with the current state. In this paper, we propose a late join algorithm for distributed interactive applications that provides such an initialization of applications. The algorithm is scalable and robust and can be easily adapted to the needs of different applications by means of late join policies. The behavior of the late join algorithm and the impact of design alternatives are investigated in detail by means of an extensive simulation study. This study also shows that an improper handling of the late join problem can cause very high application and network load.     

Component-based APIs for versioning and distributed applications

Operating system application programming interfaces (APIs) are typically monolithic procedural interfaces that address a single machine's requirements. This design limits evolutionary development and complicates application development for distributed systems. Current APIs tend to be large, rigid, and focus on a single host machine. Component-based APIs could solve these problems through strong versioning capabilities and support for distributed applications. Ideally, obsolete API calls should be deleted, and calls with modified semantics (but unmodified parameters and return values) would remain the same. However, since the OS must continue to support legacy applications, obsolete calls cannot be deleted, and new call semantics are best introduced through new calls. In addition, typical OS APIs do not adequately address the needs of distributed applications: they have support for intermachine communication but lack high-level support for accessing remote OS resources. The primary omission is a uniform method for naming remote resources, such as windows, files, and synchronization objects     

The MPE toolkit for supporting distributed applications

This paper presents a toolkit for supporting the execution of coarse-grain, parallel (distributed) applications under the MOSIX multicomputer operating system. These tools use standard UNIX System V process control and message-passing facilities, as well as the dynamic process migration mechanisms of MOSIX. The MPE tools can be used to modify sequential applications that were originally written for execution in a uniprocessor environment, to run efficiently in a distributed environment, consisting of several loosely coupled independent computers that communicate by messages. After presenting the MPE tools, the paper gives examples of several sequential algorithms that have been modified for execution in such a distributed multicomputer, as well as the resulting execution speed-ups that were obtained.     

Agent and multi-agent applications to support distributed communities of practice: a short review

This paper concerns the relationship between agents or multi-agent systems and distributed communities of practice. It presents a review of a number of agent and multi-agent applications with features that could contribute to supporting distributed communities of practice. The association is promising because of features like autonomy, pro-activity, flexibility or ability to integrate systems that characterize agents and multi-agent systems. Furthermore, such an association is a step towards building mixed communities of humans and artificial agents. To understand how agents and multi-agent systems could answer some of the needs of distributed communities of practice, we organize the analyzed applications into five different categories defined by considering the main activities of a community, namely: Individual Participation, Synchronous Interactions, Asynchronous Interactions, Publishing and Community Cultivation. Such a classification helps us identify the relevant features of the current technology and determine some that should be further developed, e.g. to support community coordination or gather information related to virtual communities. For each application we selected, we present its main approach and point out its potential interest.     

Generic lifecycle support in the ALMA environment

ALMA is an environment kernel supporting the elaboration, analysis, documentation, and maintenance of the various products developed during an entire software lifecycle. Its central component is an environment database in which properties about software objects and relations are collected. Two kinds of tools are provided: high-level tools and syntax-directed tools. A basic feature of the ALMA kernel is its genericity. Tools of the first kind are parameterized on software lifecycle models while tools of the second kind are parameterized on formalisms. Versions of specific models and formalisms are generated by a meta-environment, which also generates the environment database structure tailored to the desired lifecycle model. The database support meta-system and the instatiated database support systems it generates are emphasized, including the architectural design decisions made and the mechanisms introduced for achieving parameterization on lifecycle models     

Agent-based management of support systems for distributed brainstorming

In this paper, we describe the design and the management of an agent-based system that supports distributed brainstorming activities. The support system is a highly coordinated IoT application composed of many locally installed interface devices, multimedia communication functions, and cloud functions that process application logic and store meeting data. The system is designed to support a variety of brainstorming sessions, so its functionalities must be modifiable and enable the system to be adapted to different environments and user requirements without any loss of performance. System accessibility should be also ensured from any location for any user. These constraints require a flexible and usable support system.We further discuss the aspects of flexibility and usability that are important in a support system for distributed brainstorming, from which we propose a conceptual schema for flexible and usable support systems. To realize this schema, we present a resource-oriented architecture that can modify the brainstorming support system’s structure and functions. Flexibility is achieved thanks to an agent-based system that manages resources and operates on them according to users’ requests.We also describe the system architecture, which is organized around a set of channels dedicated to different services proposed to the users. We present in detail a video channel that ensures user awareness during synchronized activities. We then conduct several experiments verifying the usability of important channels in the architecture and present the results of these experiments.Finally, we discuss experimental scenarios that show how the system owes its adaptability to management based on an agent organization that supports distributed brainstorming and other activities.