A framework for remotely monitoring and maintaining control software over the Internet

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.

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.

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.

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

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.

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.

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

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.

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

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.

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.