Exploiting prolific types for memory management and optimizations

Shuf, Yefim; Gupta, Manish; Bordawekar, Rajesh; Singh, Jaswinder Pal

doi:10.1145/565816.503300

Cited by 24 publications

(29 citation statements)

References 45 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…These techniques use a variety of types of static and dynamic information that can be obtained without special hardware, such as field access profiles at read barriers [7,8,9], object lifetimes [10], allocation frequencies for each Java class [11], hints provided by the STL container libraries [12], or static access patterns analyzed at the compilation time [13]. Our heuristic approach is unique in the sense that we try to detect objects and fields that cause many cache misses, not just those that are frequently accessed.…”

Section: Related Workmentioning

confidence: 99%

Identifying the sources of cache misses in Java programs without relying on hardware counters

InoueHiroshi

NakataniToshio

2012

SIGPLAN Not.

View full text Add to dashboard Cite

Cache miss stalls are one of the major sources of performance bottlenecks for multicore processors. A Hardware Performance Monitor (HPM) in the processor is useful for locating the cache misses, but is rarely used in the real world for various reasons. It would be better to find a simple approach to locate the sources of cache misses and apply runtime optimizations without relying on an HPM. This paper shows that pointer dereferencing in hot loops is a major source of cache misses in Java programs. Based on this observation, we devised a new approach to identify the instructions and objects that cause frequent cache misses. Our heuristic technique effectively identifies the majority of the cache misses in typical Java programs by matching the hot loops to simple idiomatic code patterns. On average, our technique selected only 2.8% of the load and store instructions generated by the JIT compiler and these instructions accounted for 47% of the L1D cache misses and 49% of the L2 cache misses caused by the JIT-compiled code. To prove the effectiveness of our technique in compiler optimizations, we prototyped object placement optimizations, which align objects in cache lines or collocate paired objects in the same cache line to reduce cache misses. For comparison, we also implemented the same optimizations based on the accurate information obtained from the HPM. Our results showed that our heuristic approach was as effective as the HPMbased approach and achieved comparable performance improvements in the SPECjbb2005 and SPECpower_ssj2008 benchmark programs.

show abstract

Section: Related Workmentioning

confidence: 99%

Identifying the sources of cache misses in Java programs without relying on hardware counters

InoueHiroshi

NakataniToshio

2012

SIGPLAN Not.

View full text Add to dashboard Cite

show abstract

“…Another approach to lifetime classification for heap optimizations is static profiling [4,7,8,13,18,19,23,24]. For instance, a static profiler finds allocation sites for long-lived objects in a generational collector and recompiles the program to allocate these directly to mature generations [7,8,23,24].…”

Section: Related Workmentioning

confidence: 99%

Dynamic object sampling for pretenuring

Jump

Blackburn

McKinley

2004

Proceedings of the 4th International Symposium on Memory Management

View full text Add to dashboard Cite

Many state-of-the-art garbage collectors are generational, collecting the young nursery objects more frequently than old objects. These collectors perform well because young objects tend to die at a higher rate than old ones. However, these collectors do not examine object lifetimes with respect to any particular program or allocation site. This paper introduces low-cost object sampling to dynamically determine lifetimes. The sampler marks an object and records its allocation site every n bytes of allocation. The collector then computes per-site nursery survival rates. Sampling degrades total performance by only 3% on average for sample rates of 256 bytes in Jikes RVM, a rate at which overall lifetime accuracy compares well with sampling every object.An adaptive collector can use this information to tune itself. For example, pretenuring decreases nursery collection work by allocating new, but long-lived, objects directly into the mature space. We introduce a dynamic pretenuring mechanism that detects long-lived allocation sites and pretenures them, given sufficient samples. To react to phase changes, it occasionally backsamples. As with previous online pretenuring, consistent performance improvements on SPECjvm98 benchmarks are difficult to attain since only two combine sufficient allocation load with high nursery survival. Our pretenuring system consistently improves one of these, 213 javac, by 2% to 9% of total time by decreasing collection time by over a factor of two. Sampling and pretenuring overheads slow down all the others. This paper thus provides an efficient sampling mechanism that accurately predicts lifetimes, but leaves open optimization policies that can exploit this information.

show abstract

“…It is an important characteristic of the application behavior. Similar concept is discussed as "prolific types" [15] and a type-based GC is proposed based on it. Yu et al [16] leverage the same property and propose a GC that divides heap space into reuse-space and non-reuse-space, and allocates objects of prolific types into the former where the collection will be triggered more frequently.…”

Section: Blackburn and Mckinleymentioning

confidence: 99%

Cycler: Improve Heap Management for Allocation-Intensive Applications with On-the-Fly Object Reuse

Xiao¹,

Li²

2012

Parallel and Distributed Computing and Systems

View full text Add to dashboard Cite

Tracing garbage collection (GC) identifies dead objects by scanning the object-graph from the root set references. It is proven to be highly efficient and widely used in commercial managed runtime systems for Java, C# and scripting languages. However, tracing GC cannot identify the dead objects before finishing object-graph traversal. Hence the application cannot reuse the space of the dead objects in realtime when the objects are no longer live. Even there are lots of dead objects, the system has to keep allocating new space for new objects until the object-graph is scanned, which has negative impact on both space efficiency, bandwidth efficiency and cache efficiency. The issue becomes serious with allocation-intensive applications. Some prior work tries to improve tracing GC with compilation analysis to identify the dead objects in compilation time. But they can only work with sub-optimal GC algorithm such as mark-sweep, and/or can only discover a small portion of the dead objects. In this paper we propose an algorithm Cycler that can reuse the dead objects in real-time before the object graph scanning. Cycler enhances the existing high-performance tracing GC with reference counting. The novelty of the algorithm is that it does not interfere with the existing optimal tracing GC, so it can effectively improve the overall performance, as long as the runtime overhead of reference counting is well constrained. To control the runtime overhead, Cycler only counts the object references of major types. In this paper, we describe Cycler design and implementation, and also present our evaluations with standard benchmarks.

show abstract

Exploiting prolific types for memory management and optimizations

Cited by 24 publications

References 45 publications

Identifying the sources of cache misses in Java programs without relying on hardware counters

Identifying the sources of cache misses in Java programs without relying on hardware counters

Dynamic object sampling for pretenuring

Cycler: Improve Heap Management for Allocation-Intensive Applications with On-the-Fly Object Reuse

Contact Info

Product

Resources

About