Allocation-phase aware thread scheduling policies to improve garbage collection performance

Past studies have shown that objects are created and then die in phases. Thus, one way to sustain good garbage collection efficiency is to have a large enough heap to allow many allocation phases to complete and most of the objects to die before invoking garbage collection. However, such an operating environment is hard to maintain in large multithreaded applications because most typical time-sharing schedulers are not allocation-phase cognizant; i.e., they often schedule threads in a way that prevents them from completing their allocation phases quickly. Thus, when garbage collection is invoked, most allocation phases have yet to be completed, resulting in poor collection efficiency. We introduce two new scheduling strategies, LARF (lower allocation rate first) and MQRR (memory-quantum round robin) designed to be allocation-phase aware by assigning higher execution priority to threads in computation-oriented phases. The simulation results show thatallthe reductions of the garbage collection time in a generational collector can range from 0%-27% when compare to a round robin scheduler. The reductions of the overall execution time and the average thread turnaround time range from -0.1%-3% and -0.1%-13%, respectively.

[1]  Kathryn S. McKinley,et al.  Age-based garbage collection , 1999, OOPSLA '99.

[2]  Amer Diwan,et al.  The DaCapo benchmarks: java benchmarking development and analysis , 2006, OOPSLA '06.

[3]  Emery D. Berger,et al.  Quantifying the performance of garbage collection vs. explicit memory management , 2005, OOPSLA '05.

[4]  Robert Allen Shaw,et al.  Empirical analysis of a LISP system , 1988 .

[5]  Kenichi Kourai,et al.  Difference of Degradation Schemes among Operating Systems — Experimental analysis for web application servers — , 2005 .

[6]  Chandra Krintz,et al.  Isla Vista Heap Sizing: Using Feedback to Avoid Paging , 2007, International Symposium on Code Generation and Optimization (CGO'07).

[7]  Paul R. Wilson,et al.  Design of the opportunistic garbage collector , 1989, OOPSLA '89.

[8]  Matthias Hauswirth,et al.  Vertical profiling: understanding the behavior of object-priented applications , 2004, OOPSLA.

[9]  Paul R. Wilson,et al.  Uniprocessor Garbage Collection Techniques , 1992, IWMM.

[10]  Emery D. Berger,et al.  CRAMM: virtual memory support for garbage-collected applications , 2006, OSDI '06.

[11]  Mauricio J. Serrano,et al.  Thin locks: featherweight Synchronization for Java , 2004, SIGP.

[12]  Yannis Smaragdakis,et al.  EELRU: simple and effective adaptive page replacement , 1999, SIGMETRICS '99.

[13]  Paul R. Wilson Opportunistic garbage collection , 1988, SIGP.

[14]  Witawas Srisa-an,et al.  AS-GC: An Efficient Generational Garbage Collector for Java Application Servers , 2007, ECOOP.

[15]  Kathryn S. McKinley,et al.  Error-free garbage collection traces: how to cheat and not get caught , 2002, SIGMETRICS '02.

[16]  Witawas Srisa-an,et al.  Investigating throughput degradation behavior of Java application servers: a view from inside a virtual machine , 2006, PPPJ '06.

[17]  Girija J. Narlikar,et al.  Scheduling threads for low space requirement and good locality , 1999, SPAA '99.

[18]  Rafael Dueire Lins,et al.  Garbage collection: algorithms for automatic dynamic memory management , 1996 .

[19]  George C. Necula,et al.  Capriccio: scalable threads for internet services , 2003, SOSP '03.

[20]  Scott Shenker,et al.  Mostly parallel garbage collection , 1991, PLDI '91.

[21]  Andrew W. Appel,et al.  Virtual memory primitives for user programs , 1991, ASPLOS IV.

[22]  William D. Clinger,et al.  Generational garbage collection and the radioactive decay model , 1997, PLDI '97.

[23]  Henry G. Baker,et al.  Infant mortality and generational garbage collection , 1993, SIGP.

[24]  Amer Diwan,et al.  Connectivity-based garbage collection , 2003, OOPSLA '03.

[25]  Kai Li,et al.  Thread scheduling for cache locality , 1996, ASPLOS VII.