Friday, 8 November – 15:30-17:00 – Ballroom 6C

Session A

Tools

Chair: Allen Wirfs-Brock
Instantiations

Software Tools are now important part of application development, and they involve sophisticated software technologies that rival those of the languages and systems themselves. The first paper presents a framework for visualizing and observing the dynamic behavior of the storage heap, adaptable to a variety of garbage-collected as well as non-garbage collected languages. The second paper presents a technique for computing the access rights requirements by using a context sensitive, flow sensitive, interprocedural data flow analysis for the Java 2 security architecture. The third paper describes the language-specific "make" technology for Java, and demonstrates that the algorithm used therein is superior to conventional dependency tracking tools employed in Unix systems.

GCspy: An Adaptable Heap Visualisation Framework

Tony Printezis
University of Glasgow
Richard Jones
University of Kent

GCspy is an architectural framework for the collection, transmission, storage and replay of memory management behaviour. It makes new contributions to the understanding of the dynamic memory behaviour of programming languages (and especially object-oriented languages that make heavy demands on the performance of memory managers). GCspy's architecture allows easy incorporation into any memory management system: it is not limited to garbage-collected languages. It requires only small changes to the system in which it is incorporated but provides a simple to use yet powerful data-gathering API. GCspy scales to allow very large heaps to be visualised effectively and efficiently. It allows already-running, local or remote, systems to be visualised and those systems to run at full speed outside the points at which data is gathered. GCspy's visualisation tool presents this information in a number of novel ways.

Deep understanding of program behaviour is essential to the design of the next generation of garbage collectors and explicit allocators. Until now no satisfactory tools have been available to assist the implementer in gaining an understanding of heap behaviour. GCspy has been demonstrated to be a practical solution to this dilemma. It has been used to analyse production Java virtual machines running applications of realistic size. Its use has revealed important insights into the interaction between application program and JVM and has led to the development of better garbage collectors.

Access Rights Analysis for Java

Larry Koved
IBM T. J. Watson Research Center
Marco Pistoia
IBM T. J. Watson Research Center
Aaron Kershenbaum
IBM T. J. Watson Research Center

Java 2 has a security architecture that protects systems from unauthorized access by mobile or statically configured code. The problem is in manually determining the set of security access rights required to execute a library or application. The commonly used strategy is to execute the code, note authorization failures, allocate additional access rights, and test again. This process iterates until the code successfully runs for the test cases in hand. Test cases usually do not cover all paths through the code, so failures can occur in deployed systems. Conversely, a broad set of access rights is allocated to the code to prevent authorization failures from occurring. However, this often leads to a violation of the "principle of least privilege." This paper presents a technique for computing the access rights requirements by using a context sensitive, flow sensitive, interprocedural data flow analysis. By using this analysis, we compute at each program point the set of access rights required by the code. We model features such as multi-threading, implicitly defined security policies, the semantics of the Permission.implies method and generation of a security policy description. We implemented the algorithms and present the results of our analysis on a set of programs. While the analysis techniques described in this paper are in the context of Java code, the basic techniques are applicable to access rights analysis issues in non-Java-based systems.

Language-Specific Make Technology for the Java Programming Language

Mikhail Dmitriev
Sun Microsystems Laboratories

Keeping consistent the code of a Java application (code is consistent if all of the project classes can be recompiled together without errors) prevents late linking errors, and thus may significantly improve development turnaround time. In this paper we describe a language-specific make (smart recompilation) technology for Java, that guarantees consistency of the project code, and at the same time reduces the number of source code recompilations to the minimum. After project code consistency is initially assured by complete recompilation, the information extracted from the binary classes is stored in the so-called project database. Whenever the source code for some class C is changed, its recompiled binary is compared to the old version of C preserved in the project database. As a result, we find a minimum subset of classes that depend on C and may be affected by the particular change made to it. They are recompiled in turn, and absence of compilation errors at this phase guarantees the consistency of the new project code. To determine which dependent classes to recompile, we categorize all source incompatible changes, and for each category establish a criterion for finding the smallest possible subset of dependent classes.