Search

Pretenuring can reduce copying costs in garbage collectors by allocating long-lived objects into regions that the garbage collector will rarely, if ever, collect. We extend previous work on pretenuring as follows: (1) We produce pretenuring advice that is neutral with respect to the garbage collector algorithm and configuration. We thus can and do combine advice from different applications. We find for our benchmarks that predictions using object lifetimes at each allocation site in Java programs are accurate, which simplifies the pretenuring implementation. (2) We gather and apply advice to both applications and Jikes RVM, a compiler and runtime system for Java written in Java. Our results demonstrate that building combined advice into Jikes RVM from different application executions improves performance, regardless of the application Jikes RVM is compiling and executing. This build-time advice thus gives user applications some benefits of pretenuring, without any application profiling. No previous work uses profile feedback to pretenure in the runtime system. (3) We find that application-only advice also consistently improves performance, but that the combination of build-time and application-specific advice is almost always noticeably better. (4) Our same advice improves the performance of generational, Older First, and Beltway collectors, illustrating that it is collector neutral. (5) We include an immortal allocation space in addition to a nursery and older generation, and show that pretenuring to immortal space has substantial benefit. Categories and Subject Descriptors: D.3.4 [Programming Languages]: Processors--Memory management (garbage collection) General Terms: Algorithms, Languages, Performance Additional Key Words and Phrases: Garbage collection, pretenuring, lifetime prediction, profiling ACM Reference Format: Blackburn, S. M., Hertz, M., McKinley, K. S., Moss, J. E. B., and Yang, T., 2007. Profile-based pretenuring. ACM Trans. Program. Lang. Syst. 29, 1, Article 2 (January 2007), 57 pages. DOI = 10.1145/1180475.1180477 http://doi.acm.org/10.1145/1180475.1180477.

Programmers are writing a rapidly growing number of programs in object-oriented languages, such as Java and C#, that require garbage collection. Garbage collection traces and simulation speed up research by enabling deeper understandings of object lifetime behavior and quick exploration and design of new garbage collection algorithms. When generating perfect traces, the brute-force method of computing object lifetimes requires a whole-heap garbage collection at every potential collection point in the program. Because this process is prohibitively expensive, researchers often use granulated traces by collecting only periodically, for example, every 32 KB of allocation. We extend the state of the art for simulating garbage collection algorithms in two ways. First, we develop a systematic methodology for simulation studies of copying garbage collection and present results showing the effects of trace granularity on these simulations. We show that trace granularity often distorts simulated garbage collection results compared with perfect traces. Second, we present and measure the performance of a new algorithm called Merlin for computing object lifetimes. Merlin timestamps objects and later uses the timestamps of dead objects to reconstruct when they died. The Merlin algorithm piggybacks on garbage collections performed by the base system. Experimental results show that Merlin can generate traces over two orders of magnitude faster than the brute-force method which collects after every object allocation. We also use Merlin to produce visualizations of heap behavior that expose new object lifetime behaviors. Categories and Subject Descriptors: D.3.4 [Programming Languages]: Processors Memory management (garbage collection) General Terms: Algorithms, Languages, Performance Additional Key Words and Phrases: Garbage collection, trace design, object lifetime analysis, trace generation

A novel compiler optimization algorithm that matches data locality and parallelism was developed and evaluated against hand-parallelized programs. Optimization was accomplished by using a simple cache model and dependence analysis. The results indicated that existing interprocedural array and dependence analysis can immediately detect user parallelism and that parallel machines can be optimized by using both compiler optimizations and parallel algorithms.

Geoffrey Chaucer's 'Clerk's Tale,' found in 'The Canterbury Tales,' depicts a relationship between a sadistic character and an acquiescent one. Walter and Griselda are characters involved in a relationship that allows a Freudian reading, and many critics offer positive readings of Griselda's character over her despotic husband. The central problem in the tale is its considerable debt to hagiography.

Chaucer's use of the name Flexippe for one of Criseyde's nieces in Book Two of his poem 'Troilus and Criseyde' was an allusion to Meleager in Ovid's 'Metamorphosis' and to the house of Thebes in Statius' 'Thebaid.' Chaucer had Criseyde's prophetic sister, Cassandra, refer to violent and tragic tales from these two Latin poems during the seemingly joyous scene in which Antigone's love song persuades Criseyde to give her affection to Troilus. The dark allusions thus portend the fragility of Criseyde's love for Troilus.

1. INTRODUCTION In object-oriented languages, programmers make extensive use of pointers, type hierarchies, and virtual method invocations to improve code reuse and correctness. These features have a cost. For example, […], Object-oriented programming languages provide many software engineering benefits, but these often come at a performance cost. Object-oriented programs make extensive use of method invocations and pointer dereferences, both of which are potentially costly on modern machines. We show how to use types to produce effective, yet simple, techniques that reduce the costs of these features in Modula-3, a statically typed, object-oriented language. Our compiler performs type-based alias analysis to disambiguate memory references. It uses the results of the type-based alias analysis to eliminate redundant memory references and to replace monomorphic method invocation sites with direct calls. Using limit, static, and running time evaluation, we demonstrate that these techniques are effective, and sometimes perfect for a set of Modula-3 benchmarks. Categories and Subject Descriptors: D.3.4 [Programming Languages]: Processors--compilers; optimization General Terms: Algorithms, Languages, Performance, Measurement Additional Key Words and Phrases: Alias analysis, polymorphism, classes and objects, object orientation, method invocation, redundancy elimination

The information explosion across the Internet and elsewhere offers access to an increasing number of document collections. In order for users to effectively access these collections, information retrieval (IR) systems […]

This article analyzes and quantifies the locality characteristics of numerical loop nests in order to suggest future directions for architecture and software cache optimizations. Since most programs spend the majority […]