We present the design and implementation of a new garbage collection framework that significantly generalizes existing copying collectors. The Beltway framework exploits and separates object age and incrementality. It groups objects in one or more increments on queues called belts, collects belts independently, and collects increments on a belt in first-in-first-out order. We show that Beltway configurations, selected by command line options, act and perform the same as semi-space, generational, and older-first collectors, and encompass all previous copying collectors of which we are aware.

In this chapter we present a study of the SPEC JVM98 benchmark suite at a dynamic platform-independent level. The results presented describe the inuence of class library code, the relative importance of various methods in the suite, as well as the sizes of the local variable, parameter and operand stacks. We also examine the dynamic bytecode instruction usage frequencies, and discuss their relevance. The inuence of the choice of Java source to bytecode compiler is shown to be relatively insigni cant at present.

Java program execution times vary greatly with different garbage collection algorithms. Until now, it has not been possible to determine the best GC algorithm for a particular program without exhaustively profiling that program for all available GC algorithms. This paper presents a new approach. We use machine learning techniques to build a prediction model that, given a single profile run of a previously unseen Java program, can predict a good GC algorithm for that program. We implement this technique in Jikes RVM and test it on several standard benchmark suites. Our technique achieves 5 % speedup in overall execution time (averaged across all test programs for all heap sizes) compared with selecting the default GC algorithm in every trial. We present further experiments to show that an oracle predictor could achieve an average 17 % speedup on the same experiments. In addition, we provide evidence to suggest that GC behaviour is sometimes independent of program inputs. These observations lead us to propose that intelligent selection of GC algorithms is suitably straightforward, efficient and effective to merit further exploration regarding its potential inclusion in the general Java software deployment process. Categories and Subject Descriptors D.3.4 [Programming Languages]: Processors—Memory management (garbage collection)

We argue that garbage collection should be more closely tied to object demographics. We show that this behaviour is sufficiently distinctive to make exploitation feasible and describe a novel GC framework that exploits object lifetime analysis yet tolerates imprecision. We argue for future collectors based on combinations of approximate analyses and dynamic sampling.

In this paper we seek to provide a foundation for the study of the level of use of object-oriented techniques in Java programs in general, and scientific applications in particular. Specifically, we focus on the use of small methods, and the frequency with which they are called, since this forms the basis for the study of method inlining, an important optimisation technique. We compare the Grande...

In this paper we seek to provide a foundation for the study of the level of use of objectoriented techniques in Java programs in general, and scientific applications in particular. In particular we investigate the profiles of Java programs from a number of perspectives, including the use of class library methods, the size of methods called, the mode of invoke instruction used and the polymorphicity of call sites. We also present a categorisation of the nature of small-sized methods used in Java programs. We compare the Java Grande and SPEC JVM98 benchmark suites, and note a significant difference in the nature and composition of these suites, with the programs from the Java Grande suite demonstrating a less object-oriented approach. key words: Benchmark suites, Java Virtual Machine, dynamic profiling 1.

this paper. In order to propose a mechanism to efficiently perform garbage collection within the DJP context we have to better understand the behavior of the garbage collection process in real life situations and this lead us the the following research question: Are there any general features of the dynamic memory allocation behavior of the Java programs? One way to provide an answer to this question is to study the distribution of dynamic allocated Java objects according to their lifetime, type, and size, and to evaluate issues, e.g., time and memory performance, related to specific garbage collection algorithms, such as reference counting and incremental garbage collection. If general patterns of dynamic allocation of the Java objects exist the following two question are to be addressed: How are the general dynamic memory allocation features to be exploited by a garbage collector? What is the support needed from the DJP architecture for garbage collection tailored to the general pattern of dynamic memory allocation? To provide answers to the previously stated research questions we implemented two garbage collectors for the Kaffe JVM and studied the dynamic allocation pattern of Java objects, e.g., age, size, and type distribution, based on the SPEC98jvm set One can also try to extrapolate/use results on the allocation behavior for other languages like Lisp, C, or C++, but due to Java specific features they may be inaccurate, e.g., C/C++ allows for pointer arithmetic which imply that only conservative garbage collection can be used, restriction that does not apply for Java

JavaScript is widely used in web-based applications and is increasingly popular with developers. So-called browser wars in recent years have focused on JavaScript performance, specifically claiming comparative results based on benchmark suites such as SunSpider and V8. In this paper we evaluate the behavior of JavaScript web applications from commercial web sites and compare this behavior with the benchmarks. We measure two specific areas of JavaScript runtime behavior: 1) functions and code and 2) events and handlers. We find that the benchmarks are not representative of many real web sites and that conclusions reached from measuring the benchmarks may be misleading. Specific common behaviors of real web sites that are underemphasized in the benchmarks include event-driven execution, instruction mix similarity, cold-code dominance, and the prevalence of short functions. We hope our results will convince the JavaScript community to develop and adopt benchmarks that are more representative of real web applications. 1

JavaScript is widely used in web-based applications and is increasing popular with developers. So-called ”browser wars ” in recent years have focused on JavaScript performance, specifically claiming comparative results based on benchmark suites such as SunSpider and V8. In this paper we evaluate the behavior of JavaScript web applications from commercial websites and compare this behavior with the benchmarks. We measure three specific areas of JavaScript runtime behavior: 1) functions and code; 2) heap-allocated objects and data; 3) events and handlers. We find that the benchmarks are not representative of many real websites and that conclusions reached from measuring the benchmarks may be misleading. Specific examples of such misleading conclusions include the following: that web applications have many loops, that non-string objects in web applications are extremely short-lived, and that web applications handle few events. We hope our results will convince the JavaScript community to develop and adopt benchmarks that are more representative of real web applications. To reduce the total length of the paper, we have chosen to shrink our figures substantially, and we recommend that an interested reader view the document in color, preferably with the ability to enlarge the figures as needed. Our intent of including this much raw data is to allow interested readers an opportunity to draw their own conclusions. 2 1

JavaScript is widely used in web-based applications and is increasing popular with developers. So-called browser wars in recent years have focused on Java-Script performance, specifically claiming comparative results based on benchmark suites such as Sun-Spider and V8. In this paper we evaluate the behavior of JavaScript web applications from commercial web sites and compare this behavior with the benchmarks. We measure two specific areas of JavaScript runtime behavior: 1) functions and code and 2) events and handlers. We find that the benchmarks are not representative of many real web sites and that conclusions reached from measuring the benchmarks may be misleading. Specific common behaviors of real web sites that are underemphasized in the benchmarks include event-driven execution, instruction mix similarity, cold-code dominance, and the prevalence of short functions. We hope our results will convince the JavaScript community to develop and adopt benchmarks that are more representative of real web applications. 1