Atomic RMI: A Distributed Transactional Memory Framework

This paper presents Atomic RMI, a distributed transactional memory framework that supports the control flow model of execution. Atomic RMI extends Java RMI with distributed transactions that can run on many Java virtual machines located on different network nodes. Our system employs SVA, a fully-pessimistic concurrency control algorithm that provides exclusive access to shared objects and supports rollback and fault tolerance. SVA is capable of achieving a relatively high level of parallelism by interweaving transactions that access the same objects and by making transactions that do not share objects independent of one another. It also allows any operations within transactions, including irrevocable ones, like system calls, and provides an unobtrusive API. Our evaluation shows that in most cases Atomic RMI performs better than fine grained mutual-exclusion and read/write locking mechanisms. Atomic RMI also performs better than an optimistic transactional memory in environments with high contention and a high ratio of write operations, while being competitive otherwise.     

Integrating Java and CORBA: a programmer's perspective

The introduction of Java's proprietary remote method invocation (RMI) with version 1.1 of the Java Development Kit simplified the challenging task of developing distributed object-based systems. RMI provides convenient integration with Java; however, it lacks interoperability with other languages. The Object Management Group's Common Object Request Broker Architecture (CORBA), on the other hand, is a platform- and language-neutral specification for developing distributed object systems. CORBA provides services not covered by RMI, such as managing transactional safety and persistency. We use a small chat room application to describe how a programmer can combine Java RMI's ease of use with CORBA's language neutrality. We start with an implementation based on a set of distributed objects using RMI. We then adapt the example to CORBA or, more specifically, the RMI-over-IIOP (Internet inter-ORB protocol) specification developed by Sun and IBM     

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     

MaDViWorld: a software framework for massively distributed virtual worlds

The MaDViWorld project represents an original attempt to define an appropriate software architecture for supporting massively distributed virtual world systems. A non‐massively distributed virtual world system is typically engineered as a client–server application for which a single server or more rarely a small cluster of servers contain all the world pertinent data and assume the world accessibility, consistency and persistence. On the client side, many of them enable interaction with the other users and the various objects of the world. The main originality of our approach resides in the fact that the server part of the proposed system is no more limited to a few centralized servers, but can be distributed on arbitrarily many of them. Indeed, MaDViWorld, the prototypal software framework already implemented using Java and RMI by our group, allows for creating the rooms of a given world on several machines, each running the server application. It is then possible to connect the rooms by way of simple doors and to populate them with active objects. Finally, avatars managed by the client application visit the rooms and interact with the active objects either directly on the remote host or locally by cloning or transporting them first to the client machine. This paper draws from the experience gained with the development of our first prototype in order to discuss, both at the user's and the vi‐world developer's level, the main software engineering issues related to the implementation of such massively distributed virtual world systems. Copyright © 2002 John Wiley & Sons, Ltd.     

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.     

A simple distributed garbage collector for distributed real-time Java

The use of real-time distribution middleware programmed with high-level languages like Java is becoming of increasing interest in next generation applications. Technology like Java’s Remote Method Invocation (RMI) paves the way towards these new distributed horizons. RMI offers many high-level abstractions useful for distributed application programmers to reduce their development times. One of these abstractions is a distributed garbage collector (DGC) that removes unreachable remote objects from the distributed ecosystem. However, in real-time Java, distributed garbage collection is underspecified and it introduces unbounded indeterminism on end-to-end real-time Java communications. This article analyzes this problem proposing a simple characterization for a predictable real-time distributed garbage collector (RT-DGC). The approach requires support from the middleware infrastructure that implements the abstraction but it also introduces bounded overhead. The article provides insight on the performance that RT-DGC offers to a distributed real-time Java application and the extra overheads due to the intrinsic cost of this abstraction.     

Source Transformation for Concurrency Analysis

Concurrent programming poses a unique set of problems for quality assurance. These difficulties include the complexities of deadlock, livelock and divergence, which can be extremely difficult to detect and debug. A variety of tools have been developed to assist designers and developers of concurrent applications. Some of these tools, such as VeriSoft, are specific to particular implementation languages, such as C++.The Java Remote Method Invocation (Java RMI) package facilitates the implementation of concurrent applications, including those where processes reside on different hosts and communicate over networks. Unfortunately, it does not relieve the developer from the potential pitfalls of controlling concurrent access to remote objects, and may, in fact, make concurrency problems even more difficult to find.This paper presents an approach that allows the VeriSoft state exploration system to be used to analyze Java RMI programs for deadlock, livelock, divergence, and assertion violations. The system works by transforming Java RMI programs into C++ programs where Java syntax, structure, concurrency and memory management are replaced by C++ equivalents and Java RMI communication has been transformed to VeriSoft C++ inter-process communication. We present the details of this transformation and discuss preliminary results for a number of small examples.     

整合SSL协议的Java RMI的研究与设计

Java RMI机制是分布式技术的一种理想解决方案,其目标是使得网络中任意节点上的应用都可以透明的访问存在于网络上的其它节点上的远程对象.但是默认的RMI机制并不提供认证和加密传输,其安全机制还存在一定隐患.介绍了JavaRMI机制的运行机理,详细阐述了整合SSL协议的Java RMI的方案,设计了整合SSL协议的安全RMI接口,并通过实例的设计与运行,验证了其可行性.     

JDCS:实现高性能计算的分布式计算系统

分布对象计算技术提供了充分利用现有网络资源的有效途径。JavaRMI是当前比较成熟的一种分布对象技术,它提供了使用Java对象的简单和直接的方法。该文建立基于JavaRMI方法的适用于高性能计算的分布式计算系统JDCS。在JDCS中由网络上的计算结点构成服务器池,为用户提供高性能的计算服务。实现结果表明该系统可以获得较高的加速比。     

Business Object Modeling, Validation, and Mediation for Integrating Heterogeneous Application Systems

When different business organizations come together to conduct a joint business in a virtual enterprise environment, their application systems need to have a convenient way to specify the services needed from other systems and to transfer data needed by these services. The transferred data needs to be validated and, in some cases, mediated to meet the constraints and data representation requirements of both the source and target application systems. Ideally, the validation and mediation tasks should be done outside of the legacy application systems so that these systems do not have to be modified. In this work, the Business Object Documents (BODs) introduced by the Open Applications Group (OAG) are used for specifying business operations and transferring data among application systems. We use an active object model to model BODs. The model captures not only the data attributes and methods associated with these business objects, but also events and rules for specifying and triggering the enforcement of attribute constraints and inter-attribute constraints and the activation of data mediation operations. The conceptual models of these BODs with their added semantics are used to generate entity classes, converters and skeletal programs needed for enforcing constraints and for converting data. These generated object classes and software components in Java constitute the platform-independent adapters through which heterogeneous application systems inter-operate over CORBA and RMI communication infrastructures. A distributed approach to data validation and mediation is used. It allows the generated code for validation and mediation to be distributed and processed at different sites, thus avoiding the potential network bottleneck of a centralized approach to the validation and mediation of business object documents.     

Java based replicated server objects and their remote method invocations in a distributed environment

A distributed system is said to be fault‐tolerant if it is able to provide important services despite partial failures of the computers or software objects in the system. These systems are needed to support applications such as remote access and control, virtual mobile offices and wide area collaborative systems where there are chances of failures in the network and software objects. Fault‐tolerance is usually achieved by replicating the objects in the system. Traditional distributed applications constructed using Java RMI (remote method invocation) are not fault‐tolerant because of the lack of support of object replication. The objective of the present work is to design a remote method invocation that supports server object replication. To provide a fault‐tolerant service to the remote client objects, server objects are actively replicated. The problems associated with the method invocation in the context of active server object replication are presented and solutions are discussed and implemented. Copyright © 2001 John Wiley & Sons, Ltd.     

Java RMI分布式系统应用研究

RMI是开发Java网络分布式应用系统的一个重要框架,开发人员通过运用RMI框架将更易于分布式系统的开发。该文详细介绍了RMI的运行机制,并对运用RMI框架进行分布式系统的开发步骤进行了阐述,最后给出了RMI技术的具体应用实例和实现方法。     

分布对象平台Java RMI和CORBA的对比研究

文章对开发基于Java的分布式应用程序的两种分布对象技术—————JavaRMI和CORBA的功能和效率进行了对比和分析。CORBA具有良好的语言中立性,定义有功能较强的各种服务,适合于规模较大,需要与其他语言集成的系统,它的缺点是开发过程较为繁琐,Java的一些先进特性无法在远程调用的界面上使用。RMI与Java语言结合得十分紧密,开发方便,支持对象传值,但它不太适合需要异种语言集成的场合。     

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.     

Data Transfer Over the Internet for Real Time Applications

Efficient real time data exchange over the Internet plays a crucial role in the successful application of web-based systems. In this paper, a data transfer mechanism over the Internet is proposed for real time web based applications. The mechanism incorporates the extensible Markup Language (XML) and Hierarchical Data Format (HDF) to provide a flexible and efficient data format. Heterogeneous transfer data is classified into light and heavy data, which are stored using XML and HDF respectively; the HDF data format is then mapped to Java Document Object Model (JDOM) objects in XML in the Java environment. These JDOM data objects are sent across computer networks with the support of the Java Remote Method Invocation (RMI) data transfer infrastructure. Client's defined data priority levels are implemented in RMI, which guides a server to transfer data objects at different priorities. A remote monitoring system for an industrial reactor process simulator is used as a case study to illustrate the proposed data transfer mechanism.     

分布式系统中基于Jini的JavaSpace技术研究

由于要仔细考虑在本地计算中不会出现的很多问题,比如局部实效、等待时延加剧、语言的兼容性等,使得构建分布式系统显得较为困难。Java语言的远程方法调用(RMI)能够解决普遍的分布式计算问题。而JavaSpace技术被设计来解决两大问题:分布式的持久性和分布式算法设计,JavaSpace服务利用RMI及Java语言的串行化特征来实现这一目的。文中对基于Jini的JavaSpace技术进行了详细介绍,深入分析了JavaSpace共享分布式计算模型及其核心技术,介绍了目前JavaSpace技术的各种应用,以在此基础上构建强大的分布式应用系统。     

Java与C/C++的结合

JNI是JDK提供的本地编程接口,它允许Java代码操作其他语言编写的应用程序和库,但调用本地方法的同时也带来了安全问题.CORBA是一个分布式的、面向对象的应用架构规范,它允许对象在异构的、分布式的环境中透明传输,从而也能实现Java与C/C＋ ＋的互操作.本文比较了JNI和CORBA两种方法的优缺点,并将CORBA应用在一个J2EE架构下的项目中,解决了项目中Java与C/C＋ ＋的交互问题.     

Alive and well: Jini technology today

The Jini community is an ongoing experiment in trying to mix open source development techniques with industrial engineering development. The Jini technology is an approach to distributed systems that uses several Java properties. In particular, the Jini environment makes heavy use of Java's ability to move objects, including each object's data and code, from one Java environment to another. The Java environment, with its portable bytecodes, dynamic loading, code verification, and security allows such an approach straightforwardly. The author discusses its core services, discovery protocol, device connection and system enhancement     

QoS customization in distributed object systems

Applications built on networked collections of computers are increasingly using distributed object platforms such as CORBA,Java Remote Method Invocation (RMI), and DCOM to standardize object interactions. With this increased use comes the increased need for enhanced quality of service (QoS) attributes related to fault tolerance, security, and timeliness. This paper describes an architecture called CQoS (configurable QoS) for implementing such enhancements in a transparent, highly customizable, and portable manner. CQoS consists of two parts: application‐ and platform‐dependent interceptors and generic QoS components. The generic QoS components are implemented using Cactus, a system for building highly configurable protocols and services in distributed systems. The CQoS architecture and the interfaces between the different components are described, together with implementations of QoS attributes using Cactus and interceptors for CORBA and Java RMI. Experimental results are given for a test application executing on a Linux cluster using Cactus/J, the Java implementation of Cactus. Compared with other approaches, CQoS emphasizes portability across different distributed object platforms, while the use of Cactus allows custom combinations of fault‐tolerance, security, and timeliness attributes to be realized on a per‐object basis in a straightforward way. Copyright © 2003 John Wiley & Sons, Ltd.     

CORBA,DCOM和Java/RMI技术比较

分布式对象技术主要是在分布式异构环境下建立应用系统框架和对象构件,在应用系统框架的支撑下,开发者可以将软件功能包装为更易管理和使用的对象,这些分布式对象可以跨越不同的软硬件平台进行互操作。现在比较流行的三种重要的分布对象技术,它们是OMG的公对象请求代理体系结构(CORBA),Microsoft的分布式组件对象模型(DCOM),以及JavaSoft的Java/远程方法调用(Java/RMI)。本文将从编程人员以及架构师的角度,分析比较这三种分布对象技术之间的区别以及它们各自的优缺点。