Java Remote Method Invocation Research Articles

Masquerading a Networked Embedded Computer as a Remote Object Using an Asynchronous Remote Object Protocol for a System With Small Servers

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.

Agent-Based Data Extraction in Bioinformatics

Bioinformatics is an active and important research discipline in which molecular data is exponentially growing in complex nature. Because of the substantial research in this field, researchers are faced with critical issues such as bandwidth, storage, and complexity in order to retrieve molecular data. It becomes very difficult to conduct research using low computational devices such as Internet of things and sensors. We are employing migration of the agent technique to decrease network traffic and to mitigate the client’s limited resource problem by utilizing server-side resources to perform large-scale computation. Our proposed solution does not necessitate additional storage or processing power on the client’s side which makes it cost effective. In the proposed solution, (i) an agent visits service provider containing biological data, say sequences requested by the client, (ii) agent fetches the required data, and on the server side it will manipulate the data, and (iii) returns along with the required results to its source platform. Thus, it solves the bandwidth, storage, and computational issues without involving the low resources of the client. For the proof of concept, Java Agent Development (JADE) framework is used as an implementation tool and the results are compared with Java Remote Method Invocation (RMI). It is important to note that our findings reveal that our strategy saves the user up to 16.25% of average time with respect to bandwidth. On the other hand, our approach takes 46.82% less time than the other with respect to data that the agent carries. In addition to the previous contributions, our approach acts as a mashup, to collect data in different format from several service providers, and converts it in any required format. Thus, it solves the problem of complexity hidden in the nature of the data to increase the researchers’ productivity.

A parallel implementation of an implicit discontinuous Galerkin finite element scheme for fluid flow problems

The discontinuous Galerkin (DG) method is frequently used in computational fluid dynamics for its stability and high order of accuracy. A disadvantage of the DG method is its high computational demands. The aim of this paper is to weaken this drawback by means of parallelization of the DG algorithm. The computation is performed on a network of computers with distributed memory using the Java Remote Method Invocation, which is included in the Java programming language. The partition of the boundary value problem into n subproblems, which is then solved by n computers separately, is based on the overlapping Schwarz method. On basis of physical nature of the problem, the present paper proposes minimal size of the overlap that allows for only one Schwarz iteration thereby increasing efficiency of parallelization. The scalability and efficiency of the presented parallelization approach is demonstrated on several test problems. In order to stabilize the DG method in presence of shocks, a recently developed technique by Huerta et al. (Int. J. Numer. Meth. Fluids 69(10), 2012, 1614–1632), which introduces discontinuities in basis functions in regions with a shock, is adopted here. A modification of this approach, which lowers the computational and implementational demands, is presented here.

Asynchronous Distributed Object Model Using Java for the Control System of a Synchrotron Radiation Source

A simple distributed object model, called an asynchronous distributed object protocol (ADOP), was designed and implemented as middleware for a control system of a synchrotron radiation source. The ADOP replaces time-constrained parts of the control system that were previously based on the Java Remote Method Invocation (RMI) model. Under RMI’s synchronous communication, when a client executes a remote-method invocation for a device/component to be controlled on a remote server, the client is suspended until the server sends a result back to the client after completing the control sequence. Using the ADOP, even in a multi-client environment, clients are not blocked when they make remote-method invocations with an object parameter/return object that includes short control data associated with the event data, status data, and setting data for the devices/components. The clients can asynchronously receive resultant control data from the remote servers. Performance measurements obtained in experiments demonstrate that the ADOP had an execution time that was 1.4–13.1% of the RMI’s execution time.

Simple Multiplexing Headers for the JRMP Stream Subprotocol

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.

Improving Remote Method Invocation via Method Authorization and Elimination of Registry: An Exploration of Java and Haxe

Service availability in Java RMI (Remote Method Invocation) implementations can easily be compromised in a number of ways. One of the ways is when an attacker controls a directory service and mounts an attack on a RMI client and data. Stubs in a registry can be de- registered or overwritten by the attacker. In addition, he could register his own stubs as proxies to a server implementation. This project focuses on the security pitfalls of using default RMI implementation, namely the lack of access control mechanism to manage server methods (and objects) and limitations of RMI registry. The RMI registry is a weak point that could be exploited. This work addresses this concern by investigating RMI implementation and customizing the behavior to support client/method authorization, authentication and elimination of the need for an RMI registry. The contribution of this work is that it removes inherent vulnerability in RMI, which is due to weak security in RMI registry implementation. In addition, an emerging toolkit, Haxe, for platform-agnostic application development was introduced and its realization of RMI was briefly demonstrated. Haxe exhibits virtually all the features in Java and could be exploited like it. It however presents more promising features for the next generation of applications and services.

BIG DATA TRANSFER FOR TABLET-CLASS MACHINES

Several well-known data transfer protocols are presented in a comparative study to address the issue of big data transfer for tablet-class machines. The data transfer protocols include standard Java and C++, and block-data transfers protocols that use both the Java New IO (NIO) and the Zerocopy libraries, and a block-data C++ transfer protocol. Several experiments are described and results compared against the standard Java IO and C++ (stream-based file transport protocols). The motivation for this study is the development of a client/server big data file transport protocol for tablet-class client machines that rely on the Java Remote Method Invocation (RMI) package for distributed computing.

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.

Enhanced JRMP multiplexing headers under non‐fragmented local area network constraints

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.

P2P-RMI: Transparent Distribution of Remote Java Objects

Java Remote Method Invocation (RMI) is a built-in and easy-to-use framework for the distribution of remote Java objects. Its simplicity and seamless inter-virtual machine communication has made it a valuable tool for distributed services. It nevertheless exhibits certain constraints that practically limit RMI applications to the classical client/server distribution model, and make highly distributed and highly dynamic systems very difficult to build atop RMI. We present an approach that makes Java RMI usable for P2P and similar distribution models. The solution basically consists of three ideas: (1) separate the location of the registry from the remote service object, (2) distribute the registry across a DHT infrastructure, and (3) transparently enhance the built-in communication between RMI servers and clients to allow traversal of NAT and firewall boundaries. Our approach is extremely lightweight, transparent, and requires practically zero configuration.

Transparently increasing RMI fault tolerance

Traditional Remote Procedure Call systems (RPCs) have a single point of failure at the server side. To address this issue, a number of approaches extend RPC syntax and semantic to provide fault tolerance. However, these solutions are neither transparent for the application programmer nor for the client. This paper describes FTRMI, a middleware platform that enhances the Java Remote Method Invocation (JRMI) with strong replica consistency, increasing fault tolerance. FTRMI is completely transparent for the client and does not require recoding on the server side.

Serialization of Distributed Threads in Java

In this paper we present a mechanism for serializing the execution-state of a distributed Java application that is implemented on a conventional Object Request Broker (ORB) architecture such as Java Remote Method Invocation (RMI). To support serialization of distributed execution-state, we developed a byte code transformer and associated management subsystem that adds this functionality to a Java application by extracting execution-state from the application code. An important benefit of our mechanism is its portability. It can transparently be integrated into any legacy Java application. Furthermore, it does require no modifications to the Java Virtual Machine (JVM) or to the underlying ORB. Our serialization mechanism can serve many purposes such as migrating execution-state over the network or storing it on disk. In particular, we describe the implementation of a prototype for repartitioning distributed Java applications at run-time. Proper partitioning of distributed objects over the different machines is critical to the global performance of the distributed application. Methods for partitioning exist, and employ a graph-based model of the application being partitioned. Our mechanism enables then applying these methods at any point in an ongoing distributed computation. In the implementation of the management subsystem, we experienced the problem of losing logical thread identity when the distributed control flow crosses address space boundaries. We solved this well known problem by introducing the generic notion of distributed thread identity in Java programming. Propagation of a globally unique, distributed thread identity provides a uniform mechanism by which all the program's constituent objects involved in a distributed control flow can uniquely refer to that distributed thread as one and the same computational entity

Expressive and Extensible Parameter Passing for Distributed Object Systems

In modern distributed object systems, reference parameters to a remote method are passed according to their runtime type. This design choice limits the expressiveness, readability, and maintainability of distributed applications. Further, to extend the built-in set of parameter passing semantics of a distributed object system, the programmer has to understand and modify the underlying middleware implementation. To address these design shortcomings, this article presents (i) a declarative and extensible approach to remote parameter passing that decouples parameter passing semantics from parameter types, and (ii) a plugin-based framework, DeXteR , which enables the programmer to extend the built-in set of remote parameter passing semantics, without having to understand or modify the underlying middleware implementation. DeXteR treats remote parameter passing as a distributed cross-cutting concern and uses aspect-oriented and generative techniques. DeXteR enables the implementation of different parameter passing semantics as reusable application-level plugins, applicable to application, system, and third-party library classes. The expressiveness, flexibility, and extensibility of the approach is validated by adding several nontrivial remote parameter passing semantics (i.e., copy-restore, lazy, streaming) to Java Remote Method Invocation (RMI) as DeXteR plugins.

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

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

Fine tuning of the multiplexing facilities of Java's Remote Method Invocation

AbstractThe proliferation of a new generation of distributed real‐time embedded systems (DRE) characterized by special restrictions on its storage capacities, its available computation time, and the messages they can send through the network suggests a comprehensive redesign of the current distribution infrastructure in order to tune its performance. In this changing panorama, the paper concerns one of the protocols, Java's Remote Method Protocol (JRMP), used nowadays to interconnect different nodes of a distributed Java system, and explores the cost of integrating an improved protocol‐level multiplexing strategy in the context of an end‐to‐end remote invocation. The new multiplexing strategy helps middleware manage more efficiently unscheduled invocations that appear at runtime generated from a certain client node, especially in cases where preallocation of resources or dimensioning for the worst‐case are techniques not plausible. To this end, the paper examines an alternative based on the definition of a new subprotocol, called ConnectionLess, which offers built‐in multiplexing facilities for distributed Java applications. The performance of the new subprotocol is compared against the three already defined by JRMP (namely SingleOp, Stream, and Multiplex), taking into consideration parameters such as memory consumed in the Java's virtual machine and end‐to‐end response times. Copyright © 2011 John Wiley & Sons, Ltd.

Proactive Task Execution Using Data Sharing and Event Transition among Personal Devices

This paper proposes an intelligent technique for data sharing and event transition among personal devices including smart phones, laptops, and desktops. We implemented the PES (Personal Event Service) system that proactively executes appropriate tasks across multiple devices without explicit user requests by sharing the data used by the user and recognizing user intention based on the observed actions of the user for specific devices. The client module of PES installed on each device monitors the user actions and recognizes the intention of the user. The server provides data sharing and maintenance for clients. The connection between client and server is established by Java RMI (Remote Method Invocation). A series of experiments were performed to evaluate user satisfaction and system accuracy, and the results showed that the PES system can proactively provide appropriate, personalized services with a high degree of satisfaction to the user in an effective and efficient manner.

KAJIAN PERANGKATBANTU KOMPUTASI PARALLEL PADA JARINGAN PC

A Study on Parallel Computation Tools on Networked PCs. Many models for natural phenomena, engineering applications and industries need powerfull computing resources to solve their problems. High Performance Computing resources were introduced by many researchers. This comes in the form of Supercomputers and with operating systems and tools for development such as parallel compiler and its library. However, these resources are expensive for the investation and maintenance, hence people need some alternatives. Many people then introduced parallel distributed computing by using available computing resource such as PCs. Each of these PCs is treated as a processors, hence the cluster of the PC behaves as Multiprocessors Computer. Many tools are developed for such purposes. This paper studies the peformance of the currently popular tools such as Parallel Virta\ual Machine (PVM), Message Passing Interface (MPI), Java Remote Method Invocation (RMI) and Java Common Object Request Broker Architecture (CORBA). Some experiments were conducted on a cluster of PCs, the results show significant speed up. Each of those tools are identified suitable for a certain implementation and programming purposes.

No-Heap remote objects for distributed real-time Java

This article presents an approach to providing real-time support for Java's Remote Method Invocation (RMI) and its integration with the RTSJ memory model in order to leave out garbage collection. A new construct for remote objects, called No-heap Remote object ( NhRo ), is introduced. The use of a NhRo guarantees that memory required to perform a remote invocation (at the server side) does not use heap memory. Thus, the aim is to avoid garbage collection in the remote invocation process, improving predictability and memory isolation of distributed Java-based real-time applications. The article presents the bare model and the main programming patterns that are associated with the NhRo model. Sun RMI implementation has been modified to integrate the NhRo model in both static and dynamic environments.

Dissection of the internal workings of the RMI, possible enhancements and implementing authentication in standard Java RMI

The Java Remote Method Invocation (RMI) is a well-known solution for remote method call. However, the standard Java RMI lacks features like service availability, load sharing, authentication and authorisation of client, data security and asynchronous communication, which are desirable in any enterprise distributed application. To enhance or add any new functionality in the RMI runtime, a detailed study of its internal workings is required. We debug and analyse RMI programs to understand the internal workings of the RMI architecture. We present the components involved and their responsibilities, detailed internal communication process and feasible enhancements at different layers of the RMI architecture. We compare the RMI with other distributed computing technologies like Common Object Request Broker Architecture (CORBA) and web services. We also discuss possible enhancements in the RMI runtime, which could perfect it for a real enterprise application. As a proof of concept, we also discuss the implementation details of providing a client authentication functionality by modifying the RMI runtime. In addition to programmers, this contribution will also help the research community and the RMI runtime providers to enhance the RMI runtime.

Simple Asynchronous Remote Invocations for Distributed Real-Time Java

More and more, the use of real-time distribution middlewares programmed with high-level languages like Java is becoming of interest for industrial systems because this type of infrastructures reduce development efforts required to both design and maintain complex networked applications. In that way towards having better development tools, this paper deals with the very specific issue of the asynchronism from the particular perspective of Java's distributed technologies. It proposes and evaluates an extension to the Java's remote method invocation (RMI) with additional support for asynchronous remote invocations. Such a mechanism makes the transmission of some messages, typically those that do not require any confirmation from the server, much more efficient than synchronous communications, and consequently they optimize and speed up the performance of many industrial networked applications. In more detail, this paper concerns with the model itself and the set of changes it requires within their middleware programming interfaces and inside communication protocols to accommodate the proposed model. The proposal is supported by empirical evidences from a prototype developed as partial proof-of-concept.