Profile-guided proactive garbage collection for locality optimization

Chen, Wen-ke; Bhansali, Sanjay; Chilimbi, Trishul; Gao, Xiaofeng; Chuang, Weihaw

doi:10.1145/1133981.1134021

Cited by 39 publications

(12 citation statements)

References 26 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

“…Chen et al use garbage collection as a proactive technique to improve the locality of objects [Chen et al 2006], i.e., they trigger garbage collection when the locality should be improved. The run-time analysis is similar to the one of Chilimbi, however it is enabled only during short sampling intervals.…”

Section: Object Colocationmentioning

confidence: 99%

Automatic feedback-directed object fusing

Wimmer

Mössenbösck

2010

ACM Trans. Archit. Code Optim.

View full text Add to dashboard Cite

Object fusing is an optimization that embeds certain referenced objects into their referencing object. The order of objects on the heap is changed in such a way that objects that are accessed together are placed next to each other in memory. Their offset is then fixed, i.e., the objects are colocated, allowing field loads to be replaced by address arithmetic. Array fusing specifically optimizes arrays, which are frequently used for the implementation of dynamic data structures. Therefore, the length of arrays often varies, and fields referencing such arrays have to be changed. An efficient code pattern detects these changes and allows the optimized access of such fields.We integrated these optimizations into Sun Microsystems' Java HotSpot TM VM. The analysis is performed automatically at run time, requires no actions on the part of the programmer, and supports dynamic class loading. To safely eliminate a field load, the colocation of the object that holds the field and the object that is referenced by the field must be guaranteed. Two preconditions must be satisfied: the objects must be allocated at the same time, and the field must not be overwritten later. These preconditions are checked by the just-in-time compiler to avoid an interprocedural data-flow analysis. The garbage collector ensures that groups of colocated objects are not split by copying groups as a whole. The evaluation shows that the dynamic approach successfully identifies and optimizes frequently accessed fields for several benchmarks with a low compilation and analysis overhead. It leads to a speedup of up to 76% for simple benchmarks and up to 6% for complex workloads.

show abstract

“…Some approaches target scientific computation with loops and arrays [11,12,21], others focus on objectoriented programs with objects, virtual method calls, and pointers [8,16,19,31,51,58]. What these papers have in common is that all report significant improvements, yet none of the techniques have been adopted in practice.…”

Section: Profile-directed Layouts (Pd)mentioning

confidence: 99%

Data layouts for object-oriented programs

HirzelMartin¹

2007

SIGMETRICS Perform. Eval. Rev.

View full text Add to dashboard Cite

Object-oriented programs rely heavily on objects and pointers, making them vulnerable to slowdowns from cache and TLB misses. The cache and TLB behavior depends on the data layout of objects in memory. There are many possible data layouts with different impacts on performance, but it is not known which perform better. This paper presents a novel framework for evaluating data layouts. The framework both makes implementing many layouts easy, and enables performance measurements of real programs using a product Java virtual machine on stock hardware. This is achieved by sorting objects during copying garbage collection; outside of garbage collection, program performance is solely determined by the data layout that the sort key implements. This paper surveys and evaluates 10 common data layouts with 32 realistic benchmark programs running on 3 different hardware configurations. The results confirm the importance of data layouts for program performance, and show that almost all layouts yield the best performance for some programs and the worst performance for others.

show abstract

Profile-guided proactive garbage collection for locality optimization

Cited by 39 publications

References 26 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

Automatic feedback-directed object fusing

Data layouts for object-oriented programs

Contact Info

Product

Resources

About