Performance studies of remote method invocation in Java

A simple but effective optimisation for a popular level‐5 protocol called Java's Remote Method Protocol, which is used in a distribution model named RMI (Java's Remote Method Invocation) is presented. The protocol has been enhanced with a simple multiplexing mechanism which offers the possibility of transferring several parallel request–response interactions without opening new transfer control protocol/Internet protocol connections. The temporal overhead and the advantages stemmed from the approach in terms of response‐time are explored in a simple but realistic evaluation scenario: a local area network (LAN) (switched‐Ethernet) infrastructure under the small packet size condition (i.e. when the remote invocation does not have packet fragmentation). Presented results show that the proposed extensions are useful in the LAN scenario under the non‐fragmentation assumption in applications that do not require packet fragmentation.

This article deals with a simple optimization for a level-5 protocol called JRMP (Java's Remote Method Protocol), which is used in a distribution model named Java's RMI (Java's Remote Method Invocation). The main JRMP subprotocol, namely Stream, has been enhanced with a simple and direct multiplexing mechanism that offers the possibility of transferring several parallel request-response interactions without opening new TCP/IP connections. The overhead required to process headers and the advantages stemmed from the approach in terms of response-time are explored on a switched-ethernet benchmark application.

Robot systems are comprised of several elements working together as a whole. The specific task of the robot system determines which elements are required. These reusable, fungible elements can be implemented as components which connect each other via communication channels and well-defined interfaces. The behavior of the components and the manner of interaction among them can be standardized by the Robotic Technology Component (RTC) specification. One promising implementation of the RTC specification called OpenRTM-aist is a software platform assisting to the component-oriented robot system development. In OpenRTM-aist both the specification and the implementation is based on the Common Object Request Broker Architecture (CORBA) and its remote method invocation. The first version of CORBA was released in 1991. In spite of the updates CORBA is getting more and more out of date. Several solutions exist which can replace or extend CORBA. Our ultimate goal is replacing the CORBA and setting up a modern distributed robot system development framework which is based on the original OpenRTM-aist specification. To be the first step of this task in this paper we suggest some practical extensions of the existing OpenRTM-aist robot middleware. These modifications are the adaptation of the Internet Communication Engine (ICE) for inter-component communication and as a new scheme, the introduction of the web application concept. After these structural modifications the resulting system became more powerful, and thanks to the web application concept much more user friendly.

ABSTRACTThe novelty behind this research is to develop enhanced models for real‐time power system monitoring in a platform‐independent and distributed platform. Distributed models for power system applications have been implemented using Remote Method Invocation (RMI), Common object Request Broker Architecture and. NET remoting technologies. The interoperability among the heterogeneous power system clients in a distributed platform has been achieved through XMLization of power system data which provides meaningful solution to the legacy issues associated with power systems. A RMI‐based model for real‐time power system monitoring in a distributed platform had been implemented and discussed in detail. A component model for real‐time power system monitoring has also been proposed and implemented to increase the reusability and scalability of the system. A location transparent model has been developed using Common object Request Broker Architecture with RMI‐Internet Inter‐Orb Protocol for load flow monitoring and the idea is extended to solve real‐time economic load dispatch and dynamic security monitoring. The detailed monitoring on performance of the proposed models has been done with load flow monitoring, dynamic security monitoring and economic load dispatch problems. A. NET remoting architectural model has been developed for real‐time economic load dispatch in a distributed platform. This research paper explores various issues in deploying power system applications in a distributed platform. It will serve the purpose of stimulating interest among power engineers and also will be extremely useful for electric power utilities.

Jackal is a fine-grained distributed shared memory implementation of the Java programming language. Jackal implements Java's memory model and allows multithreaded Java programs to run unmodified on distributed-memory systems.This paper focuses on Jackal's runtime system, which implements a multiple-writer, home-based consistency protocol. Protocol actions are triggered by software access checks that Jackal's compiler inserts before object and array references. We describe optimizations for Jackal's runtime system, which mainly consist of discovering opportunities to dispense with flushing of cached data. We give performance results for different runtime optimizations, and compare their impact with the impact of one compiler optimization. We find that our runtime optimizations are necessary for good Jackal performance, but only in conjunction with the Jackal compiler optimizations described in [24]. As a yardstick, we compare the performance of Java applications run on Jackal with the performance of equivalent applications that use a fast implementation of Java's Remote Method Invocation (RMI) instead of shared memory.

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 remote method invocation (RMI) is a specification for building distributed object-oriented applications. RMI was designed primarily for use in conventional, wired computing environments and provides no mechanisms to allow objects hosted by mobile, wireless-enabled computers to interact with other RMI objects. Mobile devices regularly change their point of connection to the Internet making the task of correctly locating and invoking methods on the hosted RMI server objects difficult. The nature of wireless communication also means that the TCP/IP connections used to access these RMI objects are frequently broken, potentially resulting in data being lost and leaving the two communicating parties in inconsistent states. The paper outlines an architecture that supports such mobile RMI objects and describes an implementation of this architecture and its performance. This architecture provides mobility support in the form of two main components. The first is a session layer component that provides the low-level support services required to maintain transport connections in a mobile environment. The second is an application layer component that uses application-level proxies to address the difficulties of invoking methods on mobile RMI servers.

One of the most attractive aspects of the Common Object Request Broker Architecture (CORBA) lies in its open standard nature. Code that is based only on constructs described in the CORBA specification is portable between object request brokers (ORBs) without depending on any single ORB implementation. However, this portability feature is not completely achieved in real-world applications. This paper discusses CORBA portability issues through our experience in implementing a CORBA object group service (OGS) and porting it on different ORBs. In particular, we discuss some implementation choices we made with Orbix and VisiBroker, and we point out the impact of these choices on the service portability and interoperability. This sheds some light on whether the current CORBA specification is mature enough to be deployed in industrial systems that have requirements regarding portability and interoperability. We also present how new CORBA specifications solve part of the shortcomings mentioned in this paper.

Fine-Grained Parallel and Distributed Spatial Stochastic Simulation of Biological Reactions

There are increasing demands for making multiple sensors/devices accessible over a wireless local area network (WLAN) for measurement, control, and monitoring purposes. Such a system comprises a client, and multiple small embedded computer-based servers deployed in remote places. To apply the advantage of distributed object models, such as Java Remote Method Invocation (RMI), the model cannot work on an embedded computer because it demands sufficient resources, including the processing power of the central processing unit, memory, and an operating system. The model provides synchronous operations using the Transmission Control Protocol/Internet Protocol with heavy overheads, which results in low throughput compared with the lightweight User Datagram Protocol. A simple asynchronous remote object protocol for embedded computers (eASROP) is designed and implemented to enable an embedded computer and its acquired data to masquerade as an RMI-compatible remote object on a server. The client is not blocked after it makes a remote method call to a server, and can continue its job. The client can asynchronously receive a return object that contains status data and control data. The results of performance measurements obtained in experiments demonstrated that for the eASROP on an embedded computer-based server (48 MHz), the extra execution time that the client experienced was 1.67–15.4% of that for the RMI on a personal-computer-based server (3.1 GHz, 4 cores) on a WLAN.

Java's remote method invocation mechanism provides a number of features that extended the functionality of traditional client/server-based distributed systems. However, there are a number of characteristics of the language that influence its utility as a vehicle in which to express lightweight mobile processes. Among these are its highly imperative sequential core, the close coupling of control and state as a consequence of its object model, and the fact that remote method calls are not properly tail-recursive. These features impact the likelihood that Java can easily support process and object mobility for programs which exhibit complex communication and distribution patterns.

In current Java implementations, Remote Method Invocation (RMI) is too slow, especially for high-performance computing. RMI is designed for wide-area and high-latency networks, it is based on a slow object serialization, and it does not support high-performance communication networks. The paper demonstrates that a much faster drop-in RMI and an efficient drop-in serialization can be designed and implemented completely in Java without any native code. Moreover, the re-designed RMI supports non-TCP/IP communication networks, even with heterogeneous transport protocols. We demonstrate that for high-performance computing some of the official serialization's generality can and should be traded for speed. As a by-product, a benchmark collection for RMI is presented. On PCs connected through Ethernet, the better serialization and the improved RMI save a median of 45% (maximum of 71%) of the runtime for some set of arguments. On our Myrinet-based ParaStation network (a cluster of DEC Alphas) we save a median of 85% (maximum of 96%), compared to standard RMI, standard serialization, and Fast Ethernet; a remote method invocation runs as fast as 80 μs round trip time, compared with about 1.5 ms. Copyright © 2000 John Wiley & Sons, Ltd.

Problem statement: This study presents an in-depth analysis of the performance of Software Communications Architecture (SCA) component-based waveform applications in terms of inter-component communications. The main limitation with SCA, in the context of embedded systems, is the additional cost introduced by the use of Object Request Broker (ORB) middleware. The ORB middleware handles the interaction between components and objects in SCA distributed environment. This interaction should be highly efficient, due to the real time nature of SCA systems and transparent to the application programmer. Approach: We can achieve high efficiency in SCA systems by enhancing the Inter-Process Communications (IPC) mechanisms in Operating systems (OS) micro kernels, while we achieve transparency through Interface Definition Language (IDL). Different encoding mechanisms like “External Data Representation (XDR), Network Data Representation (NDR) and Common Data Representation (CDR) facilitate inter-component communication transparently and efficiently”. Marshalling procedures format data from the local machine representation to common network representations. A most common encoding mechanism for Common Object Request Broker Architecture (CORBA) systems is CDR representation. Measurements have been performed with ORBExpress DSP as a CORBA distribution and Open Source SCA Implementation Embedded (OSSIE) for SCA implementation. In order to perform these measurements we proposed two metrics for profiling the ORB that are invocation and marshalling. In addition, we propose three elements of data types to evaluate the performance of ORB middleware that are, Basic, Array and Sequence data types. Results: The CORBA bus is really the part, which brings an overhead to the SCA radio systems. This overhead is due to method invocations that have been carried out by ORB middleware. Conclusion: Performance benchmarks of ORBExpress DSP middleware show that, although using CORBA for inter-component communications introduces delays and overheads, the overall effect can be reduced by sending packets of data instead of basic data type elements.

The classical remote method invocation (RMI) mechanism adopted by several object-based middleware is 'black-box' in nature, and the RMI functionality, i.e., the RMI interaction policy and its configuration, is hard-coded into the application. This RMI nature hinders software development and reuse, forcing the programmer to focus on communication details often marginal to the application being developed. Extending the RMI behavior with extra functionality is also a very difficult job, because added code must be scattered among the entities involved in communications.This situation could be improved by developing the system in several separate layers, confining communications and related matters to specific layers. As demonstrated by recent work on reflective middleware, reflection represents a powerful tool for realizing such a separation and therefore overcoming the problems referred to above. Such an approach improves the separation of concerns between the communication-related algorithms and the functional aspects of an application. However, communications and all related concerns are not managed as a single unit that is separate from the rest of the application, which makes their reuse, extension, and management difficult. As a consequence, communications concerns continue to be scattered across the meta-program, communication mechanisms continue to be black-box in nature, and there is only limited opportunity to adjust communication policies through configuration interfaces.In this paper we examine the issues raised above, and propose a reflective approach specially designed to open up the Java RMI mechanism. Our proposal consists of a new reflective model, called multi-channel reification, that reflects on and reifies communication channels, i.e., it renders communication channels first-class citizens. This model is designed both for developing new communication mechanisms and for extending the behavior of communication mechanisms provided by the underlying system. Our approach is embodied in a framework called mChaRM, which is described in detail in this paper.

An architecture for developing service-oriented and component-based environmental models