Remote Method Invocation Research Articles

Authentication of Internet-Based Distributed Computing Resources in Chemistry

The evolution of the World Wide Web from a model allowing only the public and open exchange of information on the global Internet via simple HTML-based pages to one involving the additional development of Intranets or Extranets with secure interactive client-server processes is discussed. These client-server processes can be customized on the client browser by the use of embedded applications such as Java Applets that allow the client to communicate with other remote applications or databases via a distributed computing architecture. We show1 how software authentication using digital object signing procedures in conjunction with X.509 certificates was used to develop three authenticated distributed chemical applications. COS (Chemical Object Store) is a database application based on Java Remote Method Invocation, MoldaNet invokes Java3D to create a molecular visualization tool, and JSpec delivers analytical spectral data. We argue that such authentication of chemical resources on the Internet provides one...

Java‐Based Coupling for Parallel Predictive‐Adaptive Domain Decomposition

Adaptive domain decomposition exemplifies the problem of integrating heterogeneous software components with intermediate coupling granularity. This paper describes an experiment where a data‐parallel (HPF) client interfaces with a sequential computation server through Java. We show that seamless integration of data‐parallelism is possible, but requires most of the tools from the Java palette: Java Native Interface (JNI), Remote Method Invocation (RMI), callbacks and threads.

Large‐scale parallel geophysical algorithms in Java: A feasibility study

The Java programming language is object‐oriented and offers language elements to express thread‐based parallelism and synchronization without additional system libraries. Data exchange between processors is easy because of its ability to force remote execution of subprograms via the integrated Remote Method Invocation (RMI). This allows parallel processing steps to be programmed on the application level, namely in the Java environment itself. Additionally, this parallelism is hardware independent—programs run immediately, without recompilation, on any major platform.

Practical delegation for secure distributed object environments

In distributed object environments, intermediate objects hide the details of complex system interactions. These intermediate objects receive high level requests from client objects and perform a series of operations on a number of other object services. All requests arriving at the target services appear to be the action of the intermediary rather than the true initiator. The inability to determine the true initiator of a request has a chilling effect on the design of distributed object systems. Delegation is the process whereby a principal in a distributed object environment authorizes another principal to access services and resources on its behalf. Even with the state-of-the-art authentication techniques, delegation is typically implicit and transparent to the remote services, making it difficult for those services to determine whether delegation was authorized by the initiator. We have developed an architectural framework for structuring secure remote method invocations that may involve chains of delegated calls across distributed objects. SDM is a Secure Delegation Model for Java-based distributed object environments. SDM builds upon existing mechanisms, mainly those already established in the Java JDK1.2 security framework, to establish a practical basis for constructing flexible yet secure components and support infrastructure. The framework supports a control API for application developers to specify mechanisms and security policies surrounding simple or cascaded delegation. Delegation may also be disabled and optionally revoked.

Reflective remote method invocation

Remote method invocation (RMI) is available in the current Java language design and implementation, providing the much-needed capability of allowing objects running in different Java processes to collaborate using a variation on the popular remote procedure call (RPC). Although RMI provides features which are desirable for high-performance distributed computing, its design and implementation are deficient in key areas of importance to the high-performance computing community in general. This paper addresses the key deficiencies of RMI and how these deficiencies affect the design and implementation of distributed object applications. Reflective RMI (RRMI) is an open RMI implementation which makes better use of the object-oriented features of Java. RRMI is so-called reflective because it directly employs the reflection capabilities of the current Java language to invoke methods remotely. RRMI makes use of the dynamic class loader (a class called NetClassLoader) to allow client/server applications to be built for high-performance computing systems without having all of the .class files present on all nodes in a parallel computation. Among other features discussed are support for asynchronous remote method invocations with deferred reply and exception semantics. © 1998 John Wiley & Sons, Ltd.

JSPICE: a component-based distributed Java front-end for SPICE

The design and implementation of a component-based distributed Java front-end for the Berkeley SPICE circuit-simulation program is described. The front-end is designed as a client–server application implemented via the Remote Method Invocation (RMI) API. A graphical user-interface is implemented on the client-side, which has multiple components for command and control, graphing, text-editing and communication with the server. JavaBeans API is used as the underlying component model. On the server side, the native SPICE code (in C language) is converted into a dynamic library and is interfaced with the Java Server code using Java Native Interface (JNI) API. Implementation issues related to modifications in the SPICE code enabling multiple invocations as a shared object, efficient input/output of simulation data from the Java code, waveform compression and extraction for display on the client-side, real-time transfer of SPICE generated runtime messages from the server to client etc. are discussed. Benchmark results comparing the performance of file input using various Java I/O classes are presented. © 1998 John Wiley & Sons, Ltd.

Remote procedure calls and Java Remote Method Invocation

Remote procedure call systems have been around since around 1984 when they were first proposed (A.D. Birrell and B.J. Nelson, 1984). During the intervening 15 years, numerous evolutionary improvements have occurred in the basic RPC system, leading to improved systems-such as NCS (T.H. Dineen et al., 1987)-that offer programmers more functionality or greater simplicity. The Common Object Request Broker Architecture from the Object Management Group and Microsoft's Distributed Common Object Model are this evolutionary process's latest outgrowths. With the introduction of Java Developer's Kit release 1.1, a third alternative for creating distributed applications has emerged. The Java Remote Method Invocation system has many of the same features of other RPC systems, letting an object running in one Java virtual machine make a method call on an object running in another, perhaps on a different physical machine. On the surface, the RMI system is just another RPC mechanism, much like Corba and DCOM. But on closer inspection, RMI represents a very different evolutionary progression, one that results in a system that differs not just in detail but in the very set of assumptions made about the distributed systems in which it operates. These differences lead to differences in the programming model, capabilities, and the way the mechanisms interact with the code that implements and built the distributed systems.

Optimal multimedia transport on the Internet

Delivering events in a distributed system needs special attention in cases with large numbers of receivers. With traditional solutions, an event producer needs to know all of his event consumers. To deliver an event, the producer has to issue a remote method invocation on a consumer. Alternatively, the consumers periodically have to poll the producer for new events. Both solutions are inefficient; they require the implementation of registration logic, and do not address partial failure adequately. The most efficient approach consists of pushing the event onto the wire just once and all interested remote listeners automatically pick up the event while it passes by. We have developed a quality of service framework where applications only pay for services they need: programmers can request qualities of service such as reliable multicast, virtual synchrony, encrypted communication and a protocol composition framework that extends to incorporate yet unsupported communication protocols and qualities of service. This paper presents the real time wide area network dissemination architecture protocol (RWANDA) which overcomes synchronous limitations by providing an asynchronous group communication model where applications only pay for the required quality of service (QoS) such as multicast, virtual synchrony and encrypted communication. In RWANDA, information sources use channels to disseminate information to a potentially large and changing set of channel subscribers. RWANDA is a Java architecture and it recognises the differing media characteristics and transport requirements of multimedia by providing a protocol composition framework that extends to incorporate yet unsupported communication protocols, qualities of service and optimised multimedia stacks. RWANDA provides an asynchronous foundation necessary for developing large-scale wide-area network continuous media applications.1998 Academic Press

Java/DSM: A platform for heterogeneous computing

In this paper we describe a system for programming heterogeneous computing environments based upon Java and software distributed shared memory (DSM). Compared with existing approaches for heterogeneous computing, our system transparently handles both the hardware differences and the distributed nature of the system. It is therefore much easier to program. Java is a good candidate for heterogeneous programming because of its portability. Java provides the remote method invocation (RMI) mechanism for distributed computing. However, our early experience with RMI showed that the programmer must expend significant effort on such problems as data replication and the optimization of the remote interface to improve communication efficiency. Furthermore, the need for reference marshaling is not completely eliminated by RMI's effort to facilitate the sharing of linked structures between machines. A DSM system provides a shared memory abstraction over a group of physically distributed machines. It automatically handles data communication between machines and eliminates the need for the programmer to write message-passing code. A multithreaded Java program written for a single machine will require fewer changes to run on a Java/DSM combination than with RMI. We have been implementing a JDK-1.0.2 based parallel Java Virtual Machine on the TreadMarks DSM system. Our implementation includes a distributed garbage collector and supports the Java API with very few changes. In this paper we describe our motivation and the implementation, and report our early experience with programming under both RMI and DSM. © 1997 John Wiley & Sons, Ltd.

Java/DSM: A platform for heterogeneous computing

In this paper we describe a system for programming heterogeneous computing environments based upon Java and software distributed shared memory (DSM). Compared with existing approaches for heterogeneous computing, our system transparently handles both the hardware differences and the distributed nature of the system. It is therefore much easier to program. Java is a good candidate for heterogeneous programming because of its portability. Java provides the remote method invocation (RMI) mechanism for distributed computing. However, our early experience with RMI showed that the programmer must expend significant effort on such problems as data replication and the optimization of the remote interface to improve communication efficiency. Furthermore, the need for reference marshaling is not completely eliminated by RMI's effort to facilitate the sharing of linked structures between machines. A DSM system provides a shared memory abstraction over a group of physically distributed machines. It automatically handles data communication between machines and eliminates the need for the programmer to write message-passing code. A multithreaded Java program written for a single machine will require fewer changes to run on a Java/DSM combination than with RMI. We have been implementing a JDK-1.0.2 based parallel Java Virtual Machine on the TreadMarks DSM system. Our implementation includes a distributed garbage collector and supports the Java API with very few changes. In this paper we describe our motivation and the implementation, and report our early experience with programming under both RMI and DSM. © 1997 John Wiley & Sons, Ltd.

Asynchronous Remote Method Invocation (ARMI) mechanism for Java

In the recent past, Java has emerged as a powerful and easy to use language for net-centric computing. Simplicity, object-oriented features, the presence of threads and architecture independence are the main reasons for the popularity of Java. Despite having built-in threads in the language, the bare Java execution model does not support remote object invocations. RMI (remote method invocation) is an interface specified by Sun Microsystems for the purpose of native Java–client and Java–server communication. Although RMI is simple to use, it is not desirable in many applications due to its synchronous nature. In this paper, we describe ARMI (asynchronous RMI), a mechanism which is built on top of RMI and allows concurrent execution of local and remote computations. This paper presents the salient features and implementation details of ARMI. Two experiments performed with ARMI along with performance comparisons to RMI are also explained. © 1997 John Wiley & Sons, Ltd.

Asynchronous Remote Method Invocation (ARMI) mechanism for Java

In the recent past, Java has emerged as a powerful and easy to use language for net-centric computing. Simplicity, object-oriented features, the presence of threads and architecture independence are the main reasons for the popularity of Java. Despite having built-in threads in the language, the bare Java execution model does not support remote object invocations. RMI (remote method invocation) is an interface specified by Sun Microsystems for the purpose of native Java–client and Java–server communication. Although RMI is simple to use, it is not desirable in many applications due to its synchronous nature. In this paper, we describe ARMI (asynchronous RMI), a mechanism which is built on top of RMI and allows concurrent execution of local and remote computations. This paper presents the salient features and implementation details of ARMI. Two experiments performed with ARMI along with performance comparisons to RMI are also explained. © 1997 John Wiley & Sons, Ltd.

Adaptive parallelism

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).

Java-centric distributed computing

The Java language and platform provide a base for distributed computing that changes several conventional assumptions. In particular, the Java Virtual Machine allows a group of Java-enabled machines to be treated as a homogeneous group rather than a heterogeneous group, despite possible differences in the machine architectures and underlying operating systems. Java also makes it possible to safely and dynamically load code in a running Java process. Together, these features allow a system to invoke methods on remote objects, which can move code associated with language-level objects from the calling process to the process called and vice versa. Combining these qualities with a language-centric design not only significantly simplifies traditional RPC systems, it adds functionality that was previously not possible. We designed Java Remote Method Invocation (RMI) to support pure-Java distributed objects in a seamless manner. RMI allows calls to be made between Java objects in different virtual machines, even on different physical machines.

Distributed C++

Distributed C++ (DC++) is a language in which to write parallel applications on loosely coupled distributed systems. Its key idea is to extend the C++ class into three categories: vanilla C++ classes, classes that act as communication and synchronization gateways between abstract processors, and classes whose instances may be passed by value between abstract processors via gateways. Value classes are deep copied and preserve structure sharing. DC++ marshals arguments when value classes are used in remote method invocations. An important result of making the three categories syntactically identical is that member function invocation of gateways looks identical to vanilla member function invocation. Therefore, gateways may be redistributed without program modification. Concurrency is achieved by creating multiple abstract processors and starting multiple threads of control operating within these abstract processors. DC++ transparently supports multitasking so that the number of actual processors may be changed without program modification. DC++ provides support for concurrency (threads), communication and synchronization (explicit ports, remote method invocation, and futures), and locality (domains). DC++ is designed to run on the Mayfly Distributed Processing System. It also runs on homogeneous workstations (HP Series 9000, Model 300/400/800/700) using BSD sockets or Mach ports for communication.