The Third International Workshop on Persistence and Java(tm) (PJW3)

1st-3rd September 1998

Sponsored by Sun Microsystems

TITLE: Orthogonal Persistence for Java - A mid-term Report

AUTHOR(S): Mick Jordan and Malcolm Atkinson

ABSTRACT: The experience of applying the principles of orthogonal persistence to the Java programming language is described in the context of the PJama prototype implementation. The model for checkpointing the state of a computation, including live threads, is analyzed and related to a transactional approach. The problem of dealing with state that is external to the PJama environment is explained and the solutions outlined. The difficult problem of system evolution is identified as the major barrier to deploying orthogonal persistence for the Java language.

Full paper available in postscript and pdf format.

TITLE: Evaluating Usability Aspects of PJama based on Source Code Measurements.

AUTHOR(S): Grimstad, S., Sjøberg, D.I.K., Atkinson, M.P. & Welland, R.C.

ABSTRACT: PJama is a system that provides orthogonal persistence de ned by reach-ability with no changes to the Java [13] language. Introduction of persistence into the Java language is expected to give software productivity gains and reduce maintenance costs. A set of hypotheses that investigate these expectations have been defined and tested. The contribution of this paper is two-fold. First, it describes a tool that automatically measures the use of persistence in Java source code given a keywordfile specific to the technology being used. Second, we have tested a set of hypotheses applying this measurement technology. The results indicate that it is possible to have persistence with minimal changes to the source code in PJama. The results also indicate that the number of lines that explicitly use persistence does not grow with the size of the application.

Full paper available in postscript and pdf format.

TITLE: Persistent Java Objects in three-tier architectures.

AUTHOR(S): Almarode, J., Bretl, B., Otis, A., Soucie, M.S. & Schuchardt, B.

ABSTRACT: The 3 tier architecture logically separates the functions of an application into a user interface component, a server business logic component, and a database component. Many application server products, ORBs, and middleware products provide support for building and deploying applications using the 3 tier architecture. In most of these cases a primary role of the middle tier business logic components is to manipulate data stored in and accessed from the 3rd tier. The GemStone/J application server includes a capability for creating, storing, and using persistent Java objects in the middle tier. We argue that the use of persistent Java objects in the middle tier of a 3 tier application offers significant advantages over other approaches.

Full paper available in pdf format.

TITLE: Concurrency - The fly in the ointment?

AUTHOR(S): Blackburn, S.M. & Zigman, J.N.

ABSTRACT: Concurrency is a central pillar of the Java programming language, is implicit in the transactional model of computation adopted by most persistent systems, and has been widely studied in the context of orthogonal persistence. We argue that despite the substantial literature on concurrency control and transaction models for orthogonal persistence, a basic question as to the interaction between concurrency and orthogonal persistence has yet to be adequately addressed. The demands of orthogonality appear to place orthogonal persistence at odds with more general approaches to concurrency control. Given its stated objective of providing a 'complete' computational environment, the future of the orthogonal persistence vision in general, and persistent Java in particular, will depend, to some extent, on the release of this tension through the realization of new approaches to the integration of concurrency and persistence. This paper addresses both strict transactional and more 'open' approaches to managing concurrency in face of persistence, and examines difficulties with each approach. A simple transaction model that relieves some of these difficulties is presented and its limitations briefly examined.

Full paper available in pdf format.

TITLE: Java Finalize Method, Orthogonal Persistence and Transactions.

AUTHOR(S): Zigman, J.N. & Blackburn, S.M.

ABSTRACT: Java is a popular, object oriented language that is runtime type safe. As such, it has been seen as an attractive basis for the implementation of orthogonally persistent systems by several research groups. Transactions are widely used as a means of enforcing consistency of the stable image in the face of concurrency, and have been adopted by most groups developing persistent Java systems. However, Java has a user definable finalize method which provides an asynchronous cleanup mechanism. The strict temporal semantics of transactions and the asynchrony of the finalize method seem at odds. This paper describes this conflict and provides a strategy for resolving the problem.

Full paper available in pdf format.

TITLE: Straightforward Java Persistence through Checkpointing.

AUTHOR(S): Howell, J.

ABSTRACT: Several techniques have been proposed for adding persistence to the Java language environment. This paper describes a system we call icee that works by checkpointing the Java Virtual Machine. We compare the scheme to other persistent Java techniques. Checkpointing offers two unique advantages: first, the implementation is independent of the JVM implementation, and therefore survives JVM updates; second, because checkpointing saves and restores execution state, even threads become persistent entities.

Full paper available in postscript and pdf format.

TITLE: Swizzle-barrier optimization for orthogonal persistence for Java.

AUTHOR(S): Brahnmath, K., Nystrom, N., Hosking, A. & Cutts, Q.

ABSTRACT: 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 actually accessed, let alone used to access their target. Thus, lazy swizzling of arrays makes sense even while other types of objects are eagerly swizzled, in which case every array access must be protected by a swizzle barrier. Many, if not most, of these barriers will occur in the bodies of loops that iterate through the elements of arrays. Here, we describe how to hoist loop-nested swizzle barriers into one inclusive barrier operation that can be performed outside the loop, and which swizzles the subset of array elements accessed in the loop body. Our approach to array swizzle barrier optimization is based on loop induction variable analysis.We have implemented this approach for the PJama prototype of orthogonal persistence for Java. In experiments with several benchmark applications our optimizations reduce the number of swizzle barriers executed by an average of 66%.

Full paper available in postscript and pdf format.

TITLE: Hyper-programming in Java.

AUTHOR(S): Zirintsis, E., Dunstan, V.S., Kirby & Morrison, R.

ABSTRACT: Hyper-programming is a technology only available in persistent systems, since hyper-program source code contains both text and links to persistent objects. A hyper-programming system has already been prototyped in the persistent programming language Napier88. Here we report on the transfer of that technology to an object-oriented platform, Java. The component technologies required for hyper-programming include linguistic reflection, a persistent store, and a browsing mecha-nism, all of which have been reported elsewhere. The topics of discussion here are the additional technologies of: the specification of denotable hyper-links in Java; a mechanism for preserving hyper-links over compilation; a hyper-program editor; and the integration of the editor and the browser with the hyper-programming user inter-face. We describe their design and implementation. In total, these technologies con-stitute a hyper-programming system in Java.

Full paper available in pdf format.

TITLE: Porting a Distributed System to Persistent Java. An Experience Report.

AUTHOR(S): Evans, H & Spence, S.

ABSTRACT: This paper describes the experience of porting a 25,000 line distributed Java [GJS97] program to version 0.3.5.1 of the orthogonally persistent programming environment PJama. The port was performed in two stages. The first stage, changing the source code, took two days. The second stage, ensuring the ported program exhibited a suitable run-time behaviour, took one week. This paper discusses the main changes that were required to move from a distributed system with support for persistence via serialization to one that supported an implementation of orthogonal persistence with support for distributed programming.

Full paper available in postscript and pdf format.

TITLE: Spatio-temporal Access in Persistent Java.

AUTHOR(S): Berman, S., Southern, R., Vasey, A., Ziskind, D. & Freon, P.

ABSTRACT: Persistent programming languages are targetted primarily at application systems involving complex data structures and relationships, as typified by Geographical Information Systems (GIS). The many sophisticated GIS products available today were developed before concepts like persistence and object-orientation had been well-established, and there is an urgent need to construct new GIS technology that can benefit from the advances made in these two areas of Computer Science. This will not only alleviate problems in existing GIS systems caused by the impedance mismatch, but can also expand its capabilities by providing for effective spatio-temporal manipulation of geographic data. The popularity, accessibility and characteristics of Java TM make it a very attractive vehicle for this. In this paper we propose an architecture for spatio-temporal data access in PJama. We describe our prototype implementation of this architecture along with its application in a marine biology project. Initial results indicate that PJama is a viable implementation platform for spatio-temporal GIS. As our prototype nears completion we begin performance evaluation to substantiate this claim and measure the effectiveness of PJama GIS under large, real-world application loads.

Full paper available in postscript and pdf format.

TITLE: Towards Class Evolution in Persistent Java.

AUTHOR(S): Ridgeway, J.V.E. & Wileden, J.C.

ABSTRACT: The appeal of persistent class-oriented programming languages is great. Allowing class definitions to be persistent, in addition to instance data, greatly increases the ease of achieving and maintaining consistency among type definitions and their instances. Persistent class definitions become a serious impediment if they cannot evolve, however, as software systems are constantly evolving. In previous work we demonstrated Jspin, an orthogonal persistence extension for Java that does not require a modified Java Virtual Machine. In this paper we discuss our progress to-wards extending Jspin to allow persistent class definitions and evolution of persistent classes. We believe that we have succeeded in doing this in a way that still allows operation in an applet environment.

Full paper available in postscript and pdf format.

TITLE: The First Experience of Class Evolution Support in PJama.

AUTHOR(S): Dmitriev M.

ABSTRACT: The design and implementation of the initial release of class evolution technology for PJama persistent language is described. This technology supports modifications to individual classes, class hierarchy, and user-defined conversion of data contained in class instances when a modi cation to this class leads to the change of instance format. PJama evolution technology was evaluated on an application of considerable size and proved to be very helpful for a PJama programmer.

Full paper available in postscript and pdf format.