Mechanisms for object caching in distributed applications using Java RMI

Remote Method Invocation (RMI), a mechanism to access remote objects in Java‐based distributed applications, uses network communication for each method invocation. Consequently, using RMI in a wide‐area environment can cause poor application performance. One solution to improve performance is to cache the objects such that network communication is not necessary for each method invocation. In this paper, we present mechanisms to transparently add object caching to RMI. These mechanisms are compatible with existing RMI applications and use an event‐based model to support different consistency policies. The mechanisms also include the ability to adaptively select the consistency policy for an object based on its usage pattern. A novel feature of our mechanisms is the use of a ‘reduced object’, which is a partial representation of the RMI object. We experimentally evaluate and demonstrate the benefits of our mechanisms. Copyright © 2006 John Wiley & Sons, Ltd.     

Scalable peer‐to‐peer networking architecture: DIVINE

This paper describes the issues that are involved in designing and implementing a large‐scale cooperative object database server for a collaborative virtual environment. The focus of the paper is about the way to handle the distributing factors and the communication model among nodes within a collaborative virtual environment. Within the system, all objects are decentralized and scattered among three tiers of object databases. By limiting the knowledge and refining the tasks for each server, the network and processor workload can be reduced. The objective of the system is to provide a virtual environment for distributed computing that is k‐fault tolerant and subject to expansion without the interruption of services. Copyright © 2006 John Wiley & Sons, Ltd.     

基于组件应用服务器的对象容错服务

组件应用服务器框架是一种特定形式的分布式对象系统平台,要求成为高可靠性的系统.这里指的可靠性主要是指错误容忍和错误恢复两个特性.本文的主要目标是建立基于分布式对象的组件应用服务器的软件容错服务框架.我们采用一种名叫对象容错服务(OFS)的办法解决对象容错,我们解决的问题包括:对象失效、节点错误、网络隔离和不可预知的通信延迟等.本文介绍了OFS的服务规范,并给出了一个OFS实现的系统结构.     

A measurement-based study of hardware support for object invocation

The object invocation paradigm is attractive for structuring distributed systems. Distributed object-based operating systems view the resources of the system as a collection of objects. Object invocation is the primary mechanism in such systems, and is often used as a yardstick for measuring the system performance. However, existing systems of this flavour exhibit poor performance due to the mismatch between the requirements of the object invocation mechanism and the machine architecture. Through measurements of an existing object-based kernel, we present a breakdown of the costs involved in implementing the object invocation mechanism. The measurements suggest architectural solutions to improve the performance of such systems. We present our preliminary studies towards providing hardware support for the object invocation mechanism.     

CORBA对象的复制技术研究

CORBA是一种当前流行的基于对象技术的中间件平台．CORBA对应用屏蔽了分布式系统的异构性．然而目前许多CORBA系统没有充分地考虑容错问题，而容错是运行在异构环境中的分布式应用的核心问题之一．因此，在最近几年对容错CORBA的研究成为CORBA技术的一个研究热点．本文讨论了对象复制技术的若干问题，提出了基于标准组通信机制的、能够容忍节点故障也能够容忍数值错误的基于选举的主动复制策略．     

Modules,objects and distributed programming: Issues in RPC and remote object invocation

Distributed programming can be greatly simplified by language support for distributed communication, such as that provided by remote procedure call (RPC) or remote object invocation. This paper examines design and implementation issues in these systems, and focuses on the influence of the communication system on a distributed program. To make the discussion concrete, we introduce a single application as implemented in two environments: Modula-2+, an extension of Modula-2 with RPC, and Emerald, an object-based language that supports remote object invocation. We show that small differences in the implementation of the communication system can have a significant impact on how distributed applications are structured.     

Babylon: middleware for distributed,parallel, and mobile Java applications

Babylon is a collection of tools and services that provide a 100% Java‐compatible environment for developing, running and managing parallel, distributed and mobile Java applications. It incorporates features such as object migration, asynchronous method invocation, and remote class loading, while providing an easy‐to‐use interface. Additionally, Babylon enables Java applications to seamlessly create and interact with remote objects, while protecting those objects from other applications by implementing access restrictions and separate namespaces. The implementation of Babylon centers around dynamic proxies, a feature first available in Java 1.3, that allow proxy objects to be created at runtime. Dynamic proxies play a key role in achieving the goals of Babylon. The potential cluster computing benefits of the system are demonstrated with experimental results, which show that sequential Java applications can achieve significant performance benefits from using Babylon to parallelize their work across a cluster of workstations. Copyright © 2008 John Wiley & Sons, Ltd.     

Migrating legacy scientific applications towards CORBA‐based client–server architectures

A distributed object is a reusable, self‐contained piece of software that cooperates with other objects on the same machine or across a network in a plug‐and‐play fashion via a well‐defined interface. The Numerical Propulsion System Simulation (NPSS) attempts to provide a collaborative aircraft engine design and simulation environment based on this concept. Many scientific applications in aerodynamics and solid mechanics are written in Fortran. Refitting this legacy Fortran code with distributed objects can increase code reusability. In this paper, we focus on the novel use of a remote variable scheme to help programmers migrate the Fortran code towards a client–server architecture. This scheme gives the client the capability of accessing variables at the server site and makes it easier for programmers to couple component engine code. Through the operator overloading features in C++, remote variables can be used in much the same way as traditional variables. The remote variable scheme adopts the lazy update approach and the prefetch method. Preliminary performance evaluation shows that communication overhead can be greatly reduced. Copyright © 2001 John Wiley & Sons, Ltd.     

A configurable RMI mechanism for sharing distributed Java objects

Many distributed programming environments have been designed to support distributed shared objects over the Internet. Most of these environments (Java RMI and CORBA, for example), support client-server applications where distributed objects reside on servers, which execute all methods (remote or local) invoked on the objects. Traditional client-server models do not support client-side object caching and the local access it provides. We believe that object caching is critical to distributed applications, especially over the Internet, where latency and bandwidth are highly variable. We have developed a configurable and efficient remote method invocation mechanism that provides the same interface as Java RMI, while extending its functionality so that shared objects can be cached on the accessing nodes. The mechanism, called Javanaise, is based on the caching of clusters, which are groups of interdependent Java objects. We have implemented a prototype consisting of a preprocessor that generates the required proxy classes from the application interfaces and a run-time environment that uses system classes to manage the consistency of cluster replicas cached on client nodes. We describe the motivation for the work, the design choices made for the Javanaise clustering mechanism, the implementation principles for managing Javanaise clusters, and the results from three experiments that compare the performance of Javanaise with Java RMI     

Applications of dynamic proxies in distributed environments

In object‐oriented programming (OOP), proxies are entities that act as an intermediary between client objects and target objects. Dynamic proxies can be used to construct distributed systems that support the open implementation approach and promote code reuse. The OO paradigm supports code reuse through various ways including inheritance, polymorphism and aggregation. In this paper, we adopt a definition of software reuse restricted to reuse of code components and address the question of constructing distributed systems based on dynamic proxies. Different networking techniques and programming paradigms such as Java's Remote Method Invocation (RMI), the Common Object Request Broker Architecture (CORBA) and Java Servlets are used to implement the distributed client/server architecture. Copyright © 2004 John Wiley & Sons, Ltd.     

Dual-Object: 面向对象的并行程序设计

面向对象的并行程序设计提供了类似于共享内存模型对通讯和计算的抽象能力，从而非常适合于大型并行软件系统的开发．但是基于远程对象调用的分布式对象的实现效率一直是面向对象方法在分布式／并行程序设计中得到广泛应用的障碍．本文介绍了并行机ＭＡＮＮＡ上所采用的面向对象的并行程序设计模型——Ｄｕａｌ－Ｏｂｊｅｃｔ模型．该模型通过引入从语义角度出发给出的数据一致特性的描述，在一定程度上解决了实现效率低下的问题．其次，文章通过程序设计实例详细地讨论了基于Ｄｕａｌ－Ｏｂｊｅｃｔ模型的扩展Ｃ＋＋并行程序设计，并给出了部分实际测试结果．     

Jgroup/ARM: a distributed object group platform with autonomous replication management

This paper presents the design and implementation of Jgroup/ARM, a distributed object group platform with autonomous replication management along with a novel measurement‐based assessment technique that is used to validate the fault‐handling capability of Jgroup/ARM. Jgroup extends Java RMI through the group communication paradigm and has been designed specifically for application support in partitionable systems. ARM aims at improving the dependability characteristics of systems through a fault‐treatment mechanism. Hence, ARM focuses on deployment and operational aspects, where the gain in terms of improved dependability is likely to be the greatest. The main objective of ARM is to localize failures and to reconfigure the system according to application‐specific dependability requirements. Combining Jgroup and ARM can significantly reduce the effort necessary for developing, deploying and managing dependable, partition‐aware applications. Jgroup/ARM is evaluated experimentally to validate its fault‐handling capability; the recovery performance of a system deployed in a wide area network is evaluated. In this experiment multiple nearly coincident reachability changes are injected to emulate network partitions separating the service replicas. The results show that Jgroup/ARM is able to recover applications to their initial state in several realistic failure scenarios, including multiple, concurrent network partitionings. Copyright © 2007 John Wiley & Sons, Ltd.     

A review of experiences with reliable multicast

By understanding how real users have employed reliable multicast in real distributed systems, we can develop insight concerning the degree to which this technology has matched expectations. This paper reviews a number of applications with that goal in mind. Our findings point to trade‐offs between the form of reliability used by a system and its scalability and performance. We also find that to reach a broad user community (and a commercially interesting market) the technology must be better integrated with component and object‐oriented systems architectures. Looking closely at these architectures, however, we identify some assumptions about failure handling which make reliable multicast difficult to exploit. Indeed, the major failures of reliable multicast are associated with attempts to position it within object‐oriented systems in ways that focus on transparent recovery from server failures. The broader opportunity appears to involve relatively visible embeddings of these tools into object‐oriented architectures enabling knowledgeable users to make trade‐offs. Fault‐tolerance through transparent server replication may be better viewed as an unachievable holy grail. Copyright © 1999 John Wiley & Sons, Ltd.     

Static Analysis of Object References in RMI-Based Java Software

Distributed applications provide numerous advantages related to software performance, reliability, interoperability, and extensibility. This paper focuses on distributed Java programs built with the help of the remote method invocation (RMI) mechanism. We consider points-to analysis for such applications. Points-to analysis determines the objects pointed to by a reference variable or a reference object field. Such information plays a fundamental role as a prerequisite for many other static analyses. We present the first theoretical definition of points-to analysis for RMI-based Java applications, and we present an algorithm for implementing a flow- and context-insensitive points-to analysis for such applications. We also discuss the use of points-to information for corrupting call graph information, for understanding data dependencies due to remote memory locations, and for identifying opportunities for improving the performance of object serialization at remote calls. The work described in this paper solves one key problem for static analysis of RMI programs and provides a starting point for future work on improving the understanding, testing, verification, and performance of RMI-based software     

Active fault‐tolerant consensus control of Lipschitz nonlinear multiagent systems

This article investigates the active fault‐tolerant consensus problem for Lipschitz nonlinear multiagent systems under detailed balanced directed graph and actuator faults. First, a fault detection filter for each agent is designed, and all agents can be divided into two categories: healthy agents and possibly faulty agents. Second, fully distributed adaptive fault‐tolerant consensus protocols for healthy and possibly faulty agents are proposed to achieve state consensus. Third, based on the fault detection method and fault‐tolerant consensus protocols, active fault‐tolerant consensus algorithms are given. Simulation examples are presented to verify the effectiveness of the proposed active fault‐tolerant algorithms.     

Distributed adaptive fault‐tolerant leader‐following formation control of nonlinear uncertain second‐order multi‐agent systems

This paper presents a distributed integrated fault diagnosis and accommodation scheme for leader‐following formation control of a class of nonlinear uncertain second‐order multi‐agent systems. The fault model under consideration includes both process and actuator faults, which may evolve abruptly or incipiently. The time‐varying leader communicates with a small subset of follower agents, and each follower agent communicates to its directly connected neighbors through a bidirectional network with possibly asymmetric weights. A local fault diagnosis and accommodation component are designed for each agent in the distributed system, which consists of a fault detection and isolation module and a reconfigurable controller module comprised of a baseline controller and two adaptive fault‐tolerant controllers, activated after fault detection and after fault isolation, respectively. By using appropriately the designed Lyapunov functions, the closed‐loop stability and asymptotic convergence properties of the leader‐follower formation are rigorously established under different modes of the fault‐tolerant control system.     

Telerobotic systems design based on real‐time CORBA

A new class of telerobotic applications is making its way into research laboratories, fine arts or science museums, and industrial installations. Virtual laboratories and remote equipment maintenance are examples of these applications, which are built exploiting distributed computing systems and Internet technologies. Distributed computing technologies provide several advantages to telerobotic applications, such as dynamic and multiuser access to remote resources and arbitrary user locations. Nonetheless, building these applications remains a substantial endeavor, especially when performance requirements must be met. The aim of this paper is to investigate how mainstream and advanced features of the CORBA object‐oriented middleware can be put to work to meet the requirements of novel telerobotic applications. We show that Real‐Time CORBA extensions and asynchronous method invocation of CORBA services can be relied upon to meet performance and functional requirements, thereby enabling teleoperation on local area networks. Furthermore, CORBA services for concurrency control and large‐scale data distribution enable geographic‐scale access for robot teleprogramming. Limitations in the currently available implementations of the CORBA standard are also discussed, along with their implications. The effectiveness and suitability for telerobotic applications of several CORBA mechanisms are tested first individually and then by means of a software framework exploiting CORBA services and ensuring component‐based development, software reuse, low development cost, fully portable real‐time and communication support. A comprehensive telerobotic application built based on the framework is described in the paper and evaluated on both local and wide area networks. The application includes a robot manipulator and several sensory subsystems under concurrent access by multiple competing or collaborating operators, one of which is equipped with a multimodal user interface acting as the master device. © 2005 Wiley Periodicals, Inc.     

基于分布对象的同步回调模型的研究与实现

分布对象技术是分布异构环境下软件开发和系统集成的良好解决方案,然而在高性能分布计算领域,传统调用模型在异步特性方面的不足限制了分布对象技术在该领域的应用。因此,本文介绍一种新的基于分布对象的异步回调模型。测试表明,该模型能够有效改善分布对象系统的性能。     

Replication Management in Reliable Real-Time Systems

Building reliable real-time applications on top of commercial off-the-shelf (COTS) components is not a straightforward task. Thus, it is essential to provide a simple and transparent programming model, in order to abstract programmers from the low-level implementation details of distribution and replication. However, the recent trend for incorporating pre-emptive multitasking applications in reliable real-time systems inherently increases its complexity. It is therefore important to provide a transparent programming model, enabling pre-emptive multitasking applications to be implemented without resorting to simultaneously dealing with both system requirements and distribution and replication issues. The distributed embedded architecture using COTS components (DEAR-COTS) architecture has been previously proposed as an architecture to support real-time and reliable distributed computer-controlled systems (DCCS) using COTS components. Within the DEAR-COTS architecture, the hard real-time subsystem provides a framework for the development of reliable real-time applications, which are the core of DCCS applications. This paper presents the proposed framework, and demonstrates how it can be used to support the transparent replication of software components.