Subject: C431 JGSI Review Resent-Date: Thu, 30 Sep 1999 23:19:57 -0400 Resent-From: Geoffrey Fox Resent-To: p_gcf@npac.syr.edu Date: Wed, 22 Sep 1999 09:49:01 -0700 From: "Michael O. Neary" To: gcf@npac.syr.edu a) Overall Recommendation: accept b) Comments to the authors: The paper presents Ajents, a software infrastructure geared to support parallel and distributed Java applications. It is written entirely in Java, thus making it highly portable, and does not modify the language so that specific compilers/preprocessors are not needed. Instead, the design is based on a set of Java class libraries. The paper is easy to understand and well written. The research presented is technically sound and introduces some novel features that distinguishes it from other such systems. For instance, the ability to dynamically create remote objects in Ajents is a big help for programmers, who previously had to statically deploy remote objects before they could invoke remote methods. Also, the asynchronous RMI feature is a big improvement, since it is now possible to overlap communication and computation, thus potentially increasing the performance of an application. Perhaps the most impressive feature of Ajents is its object migration capability. This seems particularly useful in heterogeneous network environments where individual users might reclaim the full use of their workstations at any time, making the retreat of a distributed application running in the background necessary. Ajents permits this kind of graceful retreat without the high cost of losing all previous work. The loss of work is restricted to only the very last remote method invocation, since it is not easily possible to save the state of the currently executing method. The main downside of the authors' choice to provide class libraries is that the standard RMI interface cannot be used with Ajents. Instead, the user must make all RMI calls through the corresponding Ajents methods, which seem slightly less intuitive than plain RMI (the programmer must keep track of remote objects and address them differently, and must provide method names and arguments as parameters to the Ajents.rmi()/Ajents.armi() methods). In light of the additional features gained by Ajents this seems a small price to pay. The authors give performance numbers for their system which indicate that the overhead of using Ajents is mostly negligible. Compared to standard RMI, there seems to be some overhead when small objects are sent as parameters. This seems to go away as object sizes increase, probably due to the fact that the cost of sending large objects is dominated by object serialization. The speedup figures for a simple matrix multiply application are within normal range, thus demonstrating the general usefulness of using Ajents. The cost of migrating an object again increases with object size, which can be attributed to object serialization. However, the overhead can be heavy, which can be prohibitive for some applications, particularly fine-grained ones with a short overall running time. The authors state in their discussion that the system is best suited for coarse-grained applications which run for long periods of time. It would be nice to see how Ajents performs with more applications, perhaps a set of benchmarks with different characteristics. The single matrix multiply benchmark may not be enough to convince some people to use this system. The checkpoint consistency problem mentioned by the authors seems to be difficult and definitely needs looking into. Finally, the authors should update some of their references in the related work section, especially since some of the work was superseded at ACM Java Grande. For example, the Javelin global computing infrastructure now has a successor, Javelin++, which switches from applets to applications and also has remote class loading and (in a limited way) remote object creation capabilities. In addition, the Bayanihan infrastructure is a notable contender in this field. Also, the authors should take note of some recent work at UC Santa Barbara by Murat Karaorman on Active Objects/Active RMI. This work also supports asynchronous RMI and remote object creation, although it does not provide object migration. Active Objects uses a modified RMI stub compiler to achieve its objectives. Here is the complete reference: "Active-RMI: Active Remote Method Invocation System for Distributed Computing Using Active Java Objects." In TOOLS USA '98 Proceedings(August 3-7,1998, Santa Barbara, California.) Copyright 1998 IEEE. pp.414-427.