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

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.

In 1999 Sun Microsystems and IBM introduced a new version of Java's remote method invocation (RMI), called remote method invocation over Internet inter-object request broker (ORB) protocol (RMI over HOP), with the release of JDK1.3. The new RMI API uses a different transport protocol than the original RMI, that is compliant to Common Object Request Broker Architecture's (CORBA) Internet Inter-ORB (IIOP) specification. The original RMI uses the Java remote method protocol (JRMP) as the transport protocol. This paper illustrates that HOP is less efficient in the transmission of data than JRMP in spite of the fact that it uses less TCP packets. The goal is to allow developers to decide when to use JRMP versus RMI over HOP when Java to Java object communications are involved and performance cost is of issue.

The Java Remote Method Invocation (JRMI) specification simplifies the development of distributed Java applications, but provides little support to guarantee reliable, highly-available operation. The Aroma System is middleware that transparently enhances the JRMI model with the mechanisms required for consistent replication of client and server objects. By exploiting novel interception mechanisms, the Aroma System is activated at runtime, with minimal modification to the application and to the JRMI infrastructure. The Aroma System adapts the JRMI model for group communication, and exploits an underlying reliable, totally-ordered multicast protocol to provide strong replica consistency. We describe the architecture of the Aroma System, and discuss the mechanisms required to achieve transparent replication of Java RMI objects and to enforce strong replica consistency.

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.

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

With all our method calls so far, the objects upon which such methods have been invoked have been local. However, in a distributed environment, it is often desirable to be able to invoke methods on remote objects (i.e., on objects located on other systems). RMI (Remote Method Invocation) provides a platform-independent means of doing just this. Under RMI, the networking details required by explicit programming of streams and sockets disappear and the fact that an object is located remotely is almost transparent to the Java programmer. Once a reference to the remote object has been obtained, the methods of that object may be invoked in exactly the same way as those of local objects. Behind the scenes, of course, RMI will be making use of byte streams to transfer data and method invocations, but all of this is handled automatically by the RMI infrastructure. RMI has been a core component of Java from the earliest release of the language, but has undergone some evolutionary changes since its original specification.

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.

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.

In parallel and distributed applications, it is very likely that object‐oriented languages, such as Java and Ruby, and large‐scale semistructured data written in XML will be employed. However, because of their inherent dynamic memory management, parallel and distributed applications must sometimes suspend the execution of all tasks running on the processors. This adversely affects their execution on the parallel and distributed platform. In this paper, we propose a new task scheduling method called CP/MM (Critical Path/Memory Management) which can efficiently schedule tasks for applications requiring memory management. The underlying concept is to consider the cost due to memory management when the task scheduling system allocates ready (executable) coarse‐grain tasks, or macro‐tasks, to processors. We have developed three task scheduling modules, including CP/MM, for a task scheduling system which is implemented on a Java RMI (Remote Method Invocation) communication infrastructure. Our experimental results show that CP/MM can successfully prevent high‐priority macro‐tasks from being affected by the garbage collection arising from memory management, so that CP/MM can efficiently schedule distributed programs whose critical paths are relatively long. Copyright © 2005 John Wiley & Sons, Ltd.

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.

In this paper, an Internet based control software maintenance system is proposed, which enables to remotely monitor and maintain control performance. Heterogonous process variables are processed and transferred over the Internet via Java Remote Method Invocation (RMI) communication infrastructure. An industrial catalytic reactor process simulator with a Proportional-Integral-Derivative (PID) control is used as a case study to illustrate the proposed remote maintenance application.

For years, scientists have dreamed of software programs that, given a very large task, could borrow any kind and number of unused machines available and speed up the job by distributing it around. The need to support some form of adaptive parallelism (AP) is the main property of these programs. As a program may temporarily access machines when their owners do not use them, it is also necessary to return these machines when their owners begin to work again. And as the number of machines allocated to a program expand and contract during its execution, adaptive parallelism allows the program to adjust to this dynamically changing set of machines. For example, a program can start on ten machines, then temporarily use twenty, and finish on five. Numerous projects have attempted to develop such programs. Initial attempts have been undertaken on Local Area Networks (LAN). Most recently, due mainly to the Java language and platform which solve problems such as security, heterogeneity, and portability, several attempts have targeted the Internet. This paper gives a brief overview of some AP systems. Then presents a prototype of an AP system, called ObjectSpace, based on Java Remote Method Invocation (RMI).

When we have multiple users compiling a single message, including shared contents, metadata, policy, and so on, the integrity of the contents created by individual users needs to be maintained in an effective manner. There is an urgent need for new mechanisms in a trusted content-sharing environment to support multiple signers for the same message, which can be dynamically updated with autonomous protection and maintenance mechanisms. In our previous work we identified and compared three different binding mechanisms including monolithic, autonomous, and chained binding mechanisms, using digital signatures. The original work was designed and implemented for digital certificates. In this paper we apply those schemes with extension to the organization-to-organization messaging services that require effective integrity verification and tracking mechanisms at the user-level in the receiving organization in a scalable manner with fine granularity. We implement our ideas in the Java remote method invocation (RMI) platform and discuss the trade-offs of the signature schemes based on our experimental results

Stephen J. Hartley Oxford University Press, New York, 1998, 260 pp. ISBN 0-19-511315-2, $45.00 Concurrent Programming is a thorough treatment of Java multi-threaded programming for both a stand-alone and distributed environment. Designed mostly for students in concurrent or parallel programming classes, the text is also an excellent reference for the practicing professional developing multi-threaded programs or applets. Hartley first provides a complete explanation of the features of Java necessary to write concurrent programs, including topics such as exception handling, interfaces, and packages. He then gives the reader a solid background to write multi-threaded programs and also presents the problems introduced when writing concurrent programs—namely race conditions, mutual exclusion, and deadlock. Hartley also provides several software solutions that do not require the use of common process and thread mechanisms. Once the groundwork is laid for writing concurrent programs, Hartley then takes a different approach than most Java references. Rather than presenting how Java handles mutual exclusion with the synchronized keyword (although it is covered later), he first looks at semaphore-based solutions to classic concurrent problems such as bounded-buffer, readers-writers, and the dining philosophers. Hartley also uses the same approach to develop Java classes for monitors and message passing. This unique approach to introducing concurrency allows the readers to both understand how Java threads are synchronized and how the basic synchronization mechanism can be used to construct more abstract tools such as semaphores. If there is a shortcoming with the text it is with the lack of sufficient coverage of remote method invocation (RMI), although there is a section covering RMI. This is quite understandable as RMI is a fairly recent phenomenon with the Java community. Also, the classes that Hartley provides could easily implement RMI rather than sockets to handle communication. The strengths of the book include its ease in reading, several examples at the end of chapters, a package similar to Xtango that provides algorithm animation, and a supportive web site by the author (see www.mcs.drexel.edu/~shartley/ConcProgJava/index.html ) including compressed source code. As Java becomes more dominant on the server side of multi-tier applications, writing thread-safe concurrent applications becomes even more important. Concurrent Programming is a strong step towards teaching students and professionals such skills. Greg Gagne, Westminster College of Salt Lake City Salt Lake City, Utah