Optimized Live Heap Bound Analysis

This paper describes a general approach for optimized live heap space and live heap space-bound analyses for garbage-collected languages. The approach is based on program analysis and transformations and is fully automatic. In our experience, the space-bound analysis generally produces accurate (tight) upper bounds in the presence of partially known input structures. The optimization drastically improves the analysis efficiency. The analyses have been implemented and experimental results confirm their accuracy and efficiency.

[1]  William Pugh,et al.  A practical algorithm for exact array dependence analysis , 1992, CACM.

[2]  William Pugh,et al.  The Omega test: A fast and practical integer programming algorithm for dependence analysis , 1991, Proceedings of the 1991 ACM/IEEE Conference on Supercomputing (Supercomputing '91).

[3]  Patrik Persson.  Live memory analysis for garbage collection in embedded systems , 1999, LCTES '99.

[4]  Gerald J. Sussman,et al.  Structure and interpretation of computer programs , 1985, Proceedings of the IEEE.

[5]  Chang Yun Park,et al.  Predicting program execution times by analyzing static and dynamic program paths , 1993, Real-Time Systems.

[6]  Daniel Le Métayer,et al.  ACE: an automatic complexity evaluator , 1988, TOPL.

[7]  Neil D. Jones.  Proceedings of the 3rd European Symposium on Programming , 1990 .

[8]  Roger Henriksson,et al.  Scheduling Garbage Collection in Embedded Systems , 1998 .

[9]  Torben Æ. Mogensen,et al.  A Backwards Analysis for Compile-time Garbage Collection , 1990, ESOP.

[10]  Philippe Flajolet,et al.  Automatic Average-Case Analysis of Algorithm , 1991, Theor. Comput. Sci..

[11]  Daniel Le Métayer,et al.  Computer-Time Garbage Collection by Sharing Analysis , 1989, FPCA.

[12]  Yanhong A. Liu,et al.  Automatic Accurate Stack Space and Heap Space Analysis for High-Level Languages , 2000 .

[13]  Sharad Malik,et al.  Cache miss equations: a compiler framework for analyzing and tuning memory behavior , 1999, TOPL.

[14]  Peter Altenbernd,et al.  On the false path problem in hard real-time programs , 1996, Proceedings of the Eighth Euromicro Workshop on Real-Time Systems.

[15]  Wei-Ngan Chin,et al.  Cal ulating Sized Types , 2001 .

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

[17]  John Hughes,et al.  Recursion and dynamic data-structures in bounded space: towards embedded ML programming , 1999, ICFP '99.

[18]  Amr Sabry,et al.  Proving the correctness of reactive systems using sized types , 1996, POPL '96.

[19]  Yanhong A. Liu,et al.  Optimizing Ackermann's function by incrementalization , 2003, PPoPP 2003.

[20]  Sang Lyul Min,et al.  Languages, Compilers, and Tools for Embedded Systems , 2001, Lecture Notes in Computer Science.

[21]  Katsuro Inoue,et al.  Analysis of functional programs to detect run-time garbage cells , 1988, TOPL.

[22]  V. T. Rajan,et al.  Java without the coffee breaks: a nonintrusive multiprocessor garbage collector , 2001, PLDI '01.

[23]  Yanhong A. Liu,et al.  Automatic Accurate Cost-Bound Analysis for High-Level Languages , 2001, IEEE Trans. Computers.

[24]  David Thomas,et al.  The Art in Computer Programming , 2001 .

[25]  Ronald L. Rivest,et al.  Introduction to Algorithms , 1990 .

[26]  Martin Hofmann,et al.  Static prediction of heap space usage for first-order functional programs , 2003, POPL '03.

[27]  Joseph E. Stoy.  Proceedings of the fourth international conference on Functional programming languages and computer architecture , 1989 .

[28]  Reinhard Wilhelm,et al.  On Predicting Data Cache Behavior for Real-Time Systems , 1998, LCTES.

[29]  Karl Crary,et al.  Resource bound certification , 2000, POPL '00.

[30]  Mads Rosendahl,et al.  Automatic complexity analysis , 1989, FPCA.

[31]  Yanhong A. Liu,et al.  Automatic Accurate Time-Bound Analysis for High-Level Languages , 1998, LCTES.

[32]  Yanhong A. Liu,et al.  Automatic Accurate Live Memory Analysis for Garbage-Collected Languages , 2001, OM '01.

[33]  In Ryu.  Issues and challenges in developing embedded software for information appliances and telecommunication terminals , 1999, LCTES '99.

[34]  David Sands,et al.  Complexity Analysis for a Lazy Higher-Order Language , 1989, Functional Programming.

[35]  Yanhong A. Liu,et al.  Automatic time-bound analysis for a higher-order language , 2002, PEPM '02.

[36]  Wolf Zimmermann,et al.  The automatic complexity analysis of divide-and-conquer algorithms , 1989 .

[37]  Margaret Martonosi,et al.  Effectiveness of trace sampling for performance debugging tools , 1993, SIGMETRICS '93.