NOMADS is a mobile agent system that aims to support strong mobility (i.e., the ability to capture and transfer the full execution state of mobile agents) and safe Java agent execution (i.e., the ability to control resources consumed by agents, facilitating guarantees of quality of service while protecting against denial of service attacks). The NOMADS environment is composed of two parts: an agent execution environment called OASIS and a new Java compatible Virtual Machine (VM) called the AromaVM. The combination of OASIS and the AromaVM aims to provide significant enhancements over today's Java agent environments. Introduction Java is currently the most popular and arguably the most mobility-minded and security-conscious mainstream language for agent development. However, current versions fail to address many of the unique challenges posed by agent software. While few if any requirements for Java mobility, security, and resource management are entirely unique to agent software, typ...

Container technology (e.g., Enterprise Java Beans) was designed for xed network applications. This is unfortunate, because the ability of containers to adapt components transparently (e.g., with persistence and transactions) would be of great advantage in mobile computing.

Transparent persistence promises to integrate programming languages and databases by allowing procedural programs to access persistent data with the same ease as non-persistent data. Transparent persistence is more likely to be adopted if it leverages the performance and transaction management of relational databases. Since creating good relational queries from procedural programs is hard, most practical systems compromise transparency to achieve performance. In this work we demonstrate the practical feasibility of a technique for extracting relational queries from object-oriented programs. A program analysis derives query structure and conditions across methods that access persistent data. The system combines static analysis and runtime query composition to handle procedures that return persistent values. Our prototype Java compiler implements the analysis, and handles recursion and parameterized queries. We evaluate the effectiveness of the optimization on the 007 and TORPEDO benchmarks, showing that automatic optimizations are in some cases as efficient as hand-tuned code. 1.

This paper outlines the design and implementation of the PEVM, a new scalable, high-performance implementation of orthogonal persistence for the Java platform (OPJ). The PEVM is based on the Sun Microsystems Laboratories Virtual Machine for Research, which features an optimizing Just-In-Time compiler, exact generational garbage collection, and fast thread synchronization. The PEVM also uses a new, scalable persistent object store designed to manage 80GB of objects. It is approximately ten times faster than previous OPJ implementations and can run signi cantly larger programs. Despite its greater speed and scalability, the PEVM's implementation is much simpler (e.g., just 43 % of the VM source patches needed by our previous OPJ implementation). This is largely due to the pointer swizzling strategy we chose, the ResearchVM's exact memory management, and simple but e ective mechanisms. For example, we implement some key data structures in the Java programming language since this automatically makes them persistent.

. In the last three years we have been working with persistence and distribution, in particular migration of higher-level objects (such as procedures) between autonomous persistent programs. In this paper we introduce persistence and the suitability of Napier88 --- the persistent system we have used for our experiments --- as an agent language. We then present a few examples of opportunities and many more challenges that exist in the combination of persistence with agents. 1 Introduction The main motivation for this paper is our perception that free variables and persistence have not been properly addressed by the agent research community. Persistence is important because many of the examples presented in the agent literature include local or remote database access. Free variables are also of interest --- and unavoidable in a persistent environment --- because data and code are highly and strongly inter-connected in the persistent store. This paper is based on our experience with pers...

Current RPC mechanisms for persistent languages are either pass by reference --- in which case they do not scale --- or pass by copy --- in which case they duplicate objects and destroy sharing relationships. In this paper we argue that to build very large distributed persistent applications a compromise between these two mechanisms is needed. The ultimate goal of our research is to build a scalable persistent RPC while still maintainingobject sharing, type safety, type completeness and semantics that are readily understood by application programmers. 1 Introduction This research concerns the construction and maintenance of long-lived, large-scale, persistent applications that store and manipulate large quantities of complex inter-related data. An example is a health-care information system managing data for hospitals, patients and doctors, and their relationships with funding and regulatory agencies. These applications can be characterised by two attributes. Persistence. They need t...

Current versions of Java fail to address many of the unique challenges posed by the new generation of distributed applications and mobile agent systems. Aroma is a Java-compatible Virtual Machine (VM) that provides unique features such as the ability to capture the full execution state of the VM or individual thread execution state, and the ability to dynamically control disk, network, and CPU resources. This paper describes the design and implementation of the Aroma VM focusing on the features of the VM that support state capture and resource control. 1.

Transparent persistence promises to integrate programming languages and databases by allowing procedural programs to access persistent data with the same ease as non-persistent data. When the data is stored in a relational database, however, transparent persistence does not naturally leverage the performance benefits of relational query optimization. We present a program analysis that combines the benefits of both approaches by extracting database queries from programs with transparent access to persistent data. The analysis uses a sound abstract interpretation of the original program to approximate the data traversal paths in the program and the conditions under which the paths are used. The resulting paths are then converted into a query, and the program is simplified by removing redundant tests. We study an imperative kernel language with read-only access to persistent data and identify the conditions under which the transformations can be applied. This analysis approach promises to combine the software engineering benefits of transparent data persistence with the performance benefits of database query optimization.

Swizzling refers to the translation of object references from an external, persistent format to an internal, transient format used during application execution. Eager swizzling schemes translate all the references contained by objects as they are made resident. Lazy swizzling schemes defer translation of references until they are loaded from their container. Eager swizzling has the advantage of presenting a uniformly swizzled representation of references to the execution engine, at the cost of up-front translation of references that may never be used. Lazy swizzling avoids this cost, but requires a run-time check that we call a swizzle barrier to detect and convert unswizzled references as they are accessed. Lazy swizzling is most often used in situations where accesses are likely to be sparse and the up-front cost of eager swizzling is prohibitive. For example, large containers, such as arrays, may contain many thousands of references, only a fraction of which are ever actua...

Over the past ten years much research effort has been expended in attempting to build systems which support orthogonal persistence. Such systems allow all data to persist for an arbitrary length of time, possibly longer than the creating program, and support access and manipulation of data in a uniform manner, regardless of how long it persists. Persistent systems are usually based on a persistent store which provides storage for objects. Most existing persistent systems have been developed above conventional architectures and/or operating systems. In this paper we argue that conventional architectures provide an inappropriate base for persistent object systems and that we must look towards new architectures if we are to achieve acceptable performance. The examples given are based on the Monads architecture which provides explicit hardware support for persistence and objects. 1. INTRODUCTION Over the past ten years much research effort has been expended in attempting to build systems w...