Bytecode Instrumentation as an Aid in Understanding the Behavior of Java Persistent Stores 1

Transcription

1 Bytecode Instrumentation as an Aid in Understanding the Behavior of Java Persistent Stores 1 Han Bok Lee and Benjamin G Zorn Department of Computer Science University of Colorado, Boulder ABSTRACT In this paper, we describe the use of BIT (Bytecode Instrumenting Tool) as an aid in understanding the behavior of persistent Java programs and evaluating the implementation of Java persistent stores BIT is a set of Java classes that allow a user to build customized tools to instrument Java Virtual Machine (JVM) bytecodes We built a customized tool using BIT to instrument Object Design Inc s Persistent Store Engine (PSE) for Java to generate behavior traces of important events in persistent store applications These traces, in turn, can be used to better understand the behavior of Java persistent stores and investigate alternative implementations 1 INTRODUCTION In recent years, Java has generated tremendous interest in the software community, and many academic researchers as well as commercial software developers have shown interest in using Java to access and implement database systems The POSSE (Persistent Object SyStem Evaluation) project at the University of Colorado seeks to design, implement, and evaluate alternative implementation methods for persistent object systems 2 In this paper, we describe a tool that provides executable editing capability on Java class files as an aid in understanding the behavior of persistent Java programs and evaluating the implementation of Java persistent stores It is often important for software developers and researchers to be able to measure and understand both the static structure and dynamic behavior of a program Such information is used to identify critical pieces of code; for debugging purposes; to evaluate 1 This work was supported in part by the National Science Foundation under grant IRI For more information about the POSSE project, visit our WWW page at:

2 and compare the performance of different software or hardware implementations such as branch prediction, cache replacement, and instruction scheduling; in support of profiledriven optimizations; and in generating instruction and data traces To measure and observe the dynamic behavior of Java programs, we built BIT (Lee 1997), which is a new set of Java library classes that allow the user to insert calls to analysis methods in Java Virtual Machine (JVM) bytecodes BIT works on JVM bytecodes and therefore requires no source code Because some existing Java persistent stores, such as Object Design Inc s Persistent Store Engine (PSE) for Java (Object Design Inc 1997), are available only in the form of class files, the ability of BIT to work on JVM bytecodes is an important advantage The Java programming language (Gosling et al 1996) offers new and exciting opportunities for adding long-term data management because of its popularity, objectoriented model, single-inheritance, automatic storage management, and absence of explicit pointer manipulation It should not come as a surprise, therefore, that there are already several projects that add persistence to the Java programming language such as JavaSPIN (Wileden et al 1996), PJava (Atkinson et al 1996), and PSE for Java Because the Java programming language is relatively new and the behavior of Java programs, including that of Java persistent stores, is not well understood and documented, we are using BIT to generate traces for important persistent store events These traces could then be used in comparing the behavior of Java persistent stores with persistent stores of other programming languages, in optimizing current implementations of Java persistence, and in understanding the behavior of Java programs that employ persistent stores 2 RELATED WORK There are many tools that employ instrumented program-based techniques to carry out different tasks These tasks range from emulation and tracing to optimization (Larus and Schnarr 1995) Tools in this category include QPT (Larus and Ball 1994), Pixie (Smith 1991), Epoxie (Wall 1992), MPTRACE (Eggers et al 1990), ATUM (Agarwal et al 1986), and PROTEUS (Brewer et al 1991) There are limitations to these tools, however, since they are designed for a specific task and are difficult if not impossible to modify to meet users changing needs It would be difficult, for example, 2

3 for a user to modify a customized tool to obtain more or less detailed information about a trace than what is already provided There is another group of tools, sometimes called binary editing or executable editing tools, which have different design goals and offer a library of routines for modifying executable files Using these meta-tools users can then design and build their own customized instrumentation tools to meet their needs The tools in this group include OM (Srivastava and Wall 1993), EEL (Larus and Schnarr 1995), ATOM (Srivastava and Eustace 1994), and Etch (Bershad et al 1997) These tools operate on object codes for a variety of operating systems and architectures, but none of them work on JVM class files BIT follows ATOM s design by providing a set of classes that users can employ to build their own program analysis tools for JVM bytecodes Several papers have been written about adding persistence to Java such as (Moss and Hosking 1996), (Atkinson et al 1996), (Wileden et al 1996), (Jordan 1996), and (Printezis 1996) All but (Printezis 1996) discuss the design issues involved in adding persistence to Java (Printezis 1996) describes a simple disk garbage collector used in PJava (Atkinson et al 1996) and reports on its performance However, there is no related work on either the behavior or the performance measurement of persistence stores for Java that is not specific to their disk garbage collector Object Design Inc s PSE is a persistent storage engine for Java, and it provides persistent storage for Java objects PSE for Java is freely available to the public and is distributed as a collection of class files PSE provides an application programming interface (API) that allows a program to manipulate databases, to navigate among persistent objects, and to work with transactions The idea of post-processing a class file to perform some tasks is not new PSE itself uses the technique of post-processing to enable a Java class to be persistent, and Cattell et al have devised a post-processing technique as well (Moss and Hosking 1996) 3 BUILDING A CUSTOMIZED TOOL We are building a customized tool using BIT that inserts calls to the analysis methods before each of the specific method calls in PSE Our initial instrumentation efforts are concentrating on identifying the important persistent store events that take 3

4 PSE createroot() basic block instructions basic block call before createroot Analysis Routines start analysis return routine call after a basic block start analysis return Figure 1 Instrumenting PSE PSE (class files) PSE Programs BIT (class files) Instrumentation Code (Java file) Instrumented PSE (class files) Analysis Output Analysis Code (Java file) PSE Program s Output Figure 2 PSE Instrumentation Using BIT 4

5 place in PSE For instance, our instrumentation adds calls to the analysis methods before createroot() and getroot() create and obtain a database root, respectively; before begin(), commit(), and abort() in the Transaction class that deal with transactions; and so on This process is illustrated in Figure 1, which shows PSE as a collection of methods that are viewed as collections of basic blocks and instructions Calls to analysis methods can be inserted anywhere in PSE using BIT The analysis methods, in turn, generate traces to a file when programs that use instrumented PSE for Java are run Figure 2 illustrates this process One can examine this file afterward to study the dynamic behavior of programs that use PSE for Java The details of the trace format are described in the following section 4 INSTRUMENTATION GOALS Binary or executable instrumentation is a widely used technique in measuring an application s behavior Profilers such as HiProf (Garvin 1997) are built using this technique HiProf is a hierarchical profiler for the Win32 architecture This technique is also used in debugging tools such as Purify (Hastings and Joyce 1992), which detects memory access errors Our project, which also uses an executable instrumentation technique, has two major goals: to measure the behavior of Java persistent stores and to produce trace files using the POSSE Trace File Format (PTFF) (Klauser, Wolf, and Zorn 1997) The Java persistent store information that we want to capture includes static information about the structure of the persistent store (eg, size of objects, number of objects, and number of connections from an object, etc) and dynamic information about the time-varying behavior of the store (eg, how the structure changes, how the size changes, what parts are accessed frequently, etc) This information is useful for many purposes For the application programmer, it can be used to tune a particular application to remove bottlenecks and to debug applications that are not performing correctly Implementation developers and researchers can use this information to evaluate the performance of different implementation algorithms (eg, garbage collection, object representation, etc), to compare the performance of different algorithms based on a 5

6 consistent collection of traces, and to compare the behaviors of persistent stores in different programming languages With respect to the POSSE project, we are particularly interested in evaluating the performance of alternative persistent store implementations in an experimental setting To accomplish this goal, we have developed a common trace file format, PTFF, which can be used to capture database structure and application behavior (Klauser, Wolf, and Zorn 1997) We have used PTFF to study the performance of alternative garbage collection implementations in persistent stores Specifically, we have studied partition selection policies for partition-based garbage collection (Cook, Wolf, and Zorn 1994) and semi-automatic garbage collection rate selection (Cook, Klauser, Wolf, and Zorn 1996) PTFF traces can be used for a variety of activities, including simulation of ODBMS implementations (Cook, Wolf, and Zorn 1993) and object database visualization The MaStA I/O Trace Format (Scheuerl et al 1995) is another format in which I/O events taken from real and simulated database systems can be recorded The MaStA format differs from PTFF in that it represents a trace of page-level operations that can be used to study the relative costs of different I/O devices PTFF files contain events that reflect information about the structure of the database, such as when objects are created and deleted, and how objects are interconnected It also contains information about when objects in the database are accessed, such as when data or pointers in the database are read or written PRODUCING PTFF OUTPUT In our initial instrumentation of PSE for Java, we have attempted to collect the information necessary to generate a PTFF trace from the operations performed by PSE for Java Some of the events defined in PTFF correspond nicely to APIs in PSE for Java but some of them do not Table 1 summarizes this mapping One interesting issue with respect to this mapping relates to the issue of the separation of primitive data from objects PTFF contains data read and write events that represent reads and writes of primitive data (eg, characters or integers) In PSE for Java, all data is conceptually represented by pointers to objects, and as a result, there are no data read and write events that correspond to those available in PTFF 6

7 Table 1 Mapping from PTFF Events to PSE for Java Operations PTFF Event PSE for Java API Comments Create Object N/A There is no one to one correspondence between the PSE API and the PTFF event We infer object creations based on a sequence of API calls in PSE Destroy Object ObjectStoredestroy() Edge Write Persistentdirty() and others This is only approximation since in PSE for Java, calling dirty() on a persistent object prepares its contents to be modified and saved, but there is no guarantee that it will always happen Edge Read Persistentfetch() Set Root Get Root DatabasecreateRoot() and DatabasesetRoot() DatabasegetRoot() Another issue regarding the mapping between PTFF events and PSE for Java APIs is that PTFF does not record transactions As a result, traces should not be written to a file until a transaction is committed in PSE for Java Applications Table 2 Event Counts for PSE Sample Applications PTFF Create Destroy Edge Edge Read Set Root Get Root Event Object Object Write People Pcount OSDraw rep Table 2 summarizes the event counts we have measured in the sample applications provided with PSE for Java While these applications are very small, our 3 This program requires user input For the purpose of this statistics, the following operations were performed: new, draw two lines, save, close, open, and exit 7

8 measurements demonstrate that the instrumentation is capable of gathering the information described We plan to gather and/or implement more complex PSE for Java applications in the future 5 SUMMARY We described BIT and its use as an aid in understanding the behavior of persistent Java programs A tool written using BIT that generates PTFF traces for important persistent store events was discussed This customized tool can be used to measure the behavior of programs that use PSE for Java, and we explained how this information can be used in tuning storage management algorithms, in debugging, and in understanding typical usage of PSE for Java PTFF was discussed and the benefits of using it were also outlined PTFF is a common format that allows sharing data easy among researchers and also allows use of third party tools that operate on files using PTFF We are currently working on generating traces in PTFF as well as taking transactions in PSE into account when generating traces Once we have sufficient data, we should be able to verify our above mentioned claims Furthermore, work on Java persistent stores other than PSE for Java is also in order so that we can confirm our experiences with PSE for Java Finally, by building a real world application that uses PSE for Java and analyzing it, we would get a better understanding about more typical behavior of PSE for Java ACKNOWLEDGEMENTS This work was supported in part by the National Science Foundation under grant IRI REFERENCES Anant Agarwal, Richard L Sites and Mark Horowitz ATUM: A New Technique for Capturing Address Traces Using Microcode Proceedings of the 13th International Symposium on Computer Architecture, pages , June 1986 MP Atkinson, MJ Jordan, L Daynès, and S Spence Design Issues for Persistent Java: a type-safe, object-oriented, orthogonally persistent system Proceedings of the 7 th International Conference on Persistent Object Systems, May

9 Brian Bershad et al Etch Overview Eric A Brewer, Chrysanthos N Dellarocas, Adrian Colbrook and William E Weihl PROTEUS: A High- Performance Parallel-Architecture Simulator Massachusetts Institute of Technology technical report MIT/LCS/TR-516, 1991 Jonathan E Cook, Alexander L Wolf, and Benjamin G Zorn The design of a simulation system for persistent object storage management Technical Report CU-CS , Department of Computer Science, University of Colorado, Boulder, CO, March 1993 Jonathan E Cook, Alexander L Wolf, and Benjamin G Zorn Partition selection policies in object database garbage collection In Proceedings of the ACM SIGMOD International Conference on the Management of Data, pages , Minneapolis, MN, March 1994 Jonathan E Cook, Alexander L Wolf, and Benjamin G Zorn A highly effective partition selection policy for object database garbage collection To appear in IEEE Transactions on Knowledge and Data Engineering Jonathan E Cook, Artur W Klauser, Alexander L Wolf, and Benjamin G Zorn Semi-automatic, selfadaptive control of garbage collection rates in object databases In Proceedings of the ACM SIGMOD International Conference on the Management of Data, pages , Montreal, Canada, June 1996 Susan J Eggers, David R Keppel, Eric J Koldinger, and Henry M Levy Techniques for Efficient Inline Tracing on a Shared-Memory Multiprocessor SIGMETRICS Conference on Measurement and modeling of Computer Systems, vol 8, no 1, May 1990 Janel Garvin HiProf Advanced Code Performance Analysis Through Hierarchical Profiling James Gosling, Bill Joy, and Guy Steele The Java Language Specification Addison-Wesley, 1996 Reed Hastings and Bob Joyce Purify: Fast Detection of Memory Leaks and Access Errors Proceedings of the Winter USENIX Conference, Pages , January 1992 Mick Jordan Early Experiences with Persistent Java First International Workshop on Persistence and Java September 1996 Artur Klauser, Alexander Wolf, and Benjamin Zorn POSSE Trace File Format Working document University of Colorado at Boulder 1997 James R Larus and Thomas Ball Rewriting Executable Files to Measure Program Behavior Software, Practice and Experience, vol 24, no 2, pages , February 1994 James R Larus and Eric Schnarr EEL: Machine-Independent Executable Editing In Proceedings of the SIGPLAN 95 Conference on Programming Language Design and Implementation (PLDI), pages , June 1995 Han B Lee BIT: Bytecode Instrumenting Tool MS thesis, University of Colorado at Boulder, Boulder, CO, July 1997 J Eliot B Moss and Tony L Hosking Approaches to Adding Persistence to Java First International Workshop on Persistence and Java September 1996 Object Design Inc ObjectStore PSE and PSE Pro for Java Release 11 Documentation 9

10 Tony Printezis Disk Garbage Collection Strategies for Persistent Java First International Workshop on Persistence and Java September 1996 Scheuerl, SJG, Connor, RCH, Morrison, R, Munro, DS & Moss, JEB The MaStA I/O Trace Format University of St Andrews Technical Report CS/95/4, 1995 Michael D Smith Tracing with Pixie Memo from Center for Integrated Systems, Stanford Univ, April 1991 Amitabh Srivastava and Alan Eustace ATOM A System for Building Customized Program Analysis Tools In Proceedings of the SIGPLAN 94 Conference on Programming Language Design and Implementation (PLDI), pages , June 1994 Amitabh Srivastava and David Wall A Practical System for Intermodule Code Optimization at Link-Time Journal of Programming Languages, vol 1, no 1, pages 1-18, March 1993 David W Wall Systems for Late Code modification In Robert Giegerich and Susan L Graham, eds, Code Generation Concepts, Tools, Techniques, pages , Springer-Verlag, 1992 Jack C Wileden, Alan Kaplan, Geir A Myrestrand, and John VE Ridgway Our SPIN on Persistent Java: The JavaSPIN Approach First International Workshop on Persistence and Java September