1 / 22

Experiments on the Effectiveness of an Automatic Insertion of Memory Reuses into ML-like Programs

Experiments on the Effectiveness of an Automatic Insertion of Memory Reuses into ML-like Programs. Oukseh Lee (Hanyang University) Kwangkeun Yi (Seoul National University). *.

keene
Télécharger la présentation

Experiments on the Effectiveness of an Automatic Insertion of Memory Reuses into ML-like Programs

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. Experiments on the Effectiveness of an Automatic Insertion of Memory Reuses into ML-like Programs Oukseh Lee (Hanyang University) Kwangkeun Yi (Seoul National University)

  2. * Oukseh Lee, Hongseok Yang, and Kwangkeun Yi. Inserting Safe Memory Reuse Commands into ML-like Programs. In Proceedings of the Annual International Static Analysis Symposium, volume 2694 of Lecture Notes in Computer Science, pp. 171-188, San Diego, California, June 2003. Question • Our SAS 2003 paper* presented • an algorithm to replaceallocations by memory reuse (or destructive update); and • some promising yet preliminary experiment numbers. • When and how much is it cost-effective? • Space & time-wise. • Before launching it inside our nML compiler.

  3. Brief Overview of Our Algorithm

  4. l 1 2 3 4 4 1 2 3 5 result fun insert i l = case l of [] => i::[] | h::t => if i<h then i::l else let z = insert i t in free l; h::z Example: insert insert 5 l 6 nil fun insert i l = case l of [] => i::[] | h::t => if i<h then i::l else let z = insert i t in h::z

  5. l result 5 fun insert i l = case l of [] => i::[] | h::t => if i<h then i::l else let z = insert i t in free l; h::z Example: insert insert 5 l 1 1 2 2 3 3 4 4 6 nil fun insert i l = case l of [] => i::[] | h::t => if i<h then i::l else let z = insert i t in h::z fun insert b i l = case l of [] => i::[] | h::t => if i<h then i::l else let z = insert b i t in free l when b; h::z

  6. L Analysis result usage =L.hd[L.tl X1 X1 L.hd L.tl L.hd X2 X2[ L Z X3 Z µ X3 [L.tl L.tl X4 X4[ Z [ X1[X2[L[X4[Z L.hd [ L.tl X =X1[ X2[ X3[ X4 µ X [ L L

  7. Transformation [1/3] fun insert i l = case l of [] => i::[] | h::t => if i<h then i::l else let z = insert i t in h::z fun insert b i l = case l of [] => i::[] | h::t => if i<h then i::l else let z = insert i t in h::z When b=true, the transformed insert function deallocates the cons cells of the input list l excluding those of the result list.

  8. Transformation [2/3] fun insert b i l = case l of [] => i::[] | h::t => if i<h then i::l else let z = insert b i t in h::z b When is it safe to free the tail cells t not in the result z (L.tl\Z)?

  9. Transformation [3/3] fun insert b i l = case l of [] => i::[] | h::t => if i<h then i::l else let z = insert b i t in free l when ; h::z b When is it safe to free the head cell (L.hd)?

  10. Experiments

  11. Analysis & Transformation Cost 1,500~29,000 lines/sec analysis & transformation cost (logarithmic scale) slope=1.46 program size (logarithmic scale)

  12. Reuse Ratio 3.4%~93.9% of allocations are avoided. low reuse ratio due to much sharing.

  13. Memory Peak Reduction 0.0%~71.9% peak reduction much reuse = much peak reduction memory peak reduction 41.9% 8.1% 84.4% 2.6% 10.6% 25.6% memory reuse ratio

  14. Difference in Live Cells sieve 84.3% 56.5% merge 50.0% 49.4% qsort 93.9% 71.9% msort 89.3% 55.0%

  15. Difference in Live Cells queens 4.2% 0.0% kb 3.4% 2.3% nucleic 16.9% 13.8% k-eval 31.5% 9.6%

  16. Difference in Live Cells professor 41.9% 8.1% mirage 84.4% 2.6% life 10.6% 25.6%

  17. GC Time & Runtime Changes -6.9%~90.5% GC-time reduction -7.3%~39.1% runtime reduction in Objective Caml system

  18. 50.0% 76.0% 24.0% 93.9% 63.2% 39.1% 89.3% 59.9% 21.6% High reuse ratio & big GC portion: runtime speedup 16.9% 52.1% 7.2% 50.0% 78.2% 30.0% 93.9% 57.2% 28.2% 89.3% 55.3% 20.7% 16.9% 46.3% 8.8% GC Time & Runtime Changes -6.9%~90.5% GC-time reduction -7.3%~39.1% runtime reduction in Objective Caml system

  19. GC Time & Runtime Changes -6.9%~90.5% GC-time reduction -7.3%~39.1% runtime reduction 4.2% -6.8% -4.7% High reuse ratio & big GC portion: runtime speedup 3.4% -3.6% -7.3% Low reuse ratio: flags overhead 4.2% -8.4% -5.8% 3.4% -9.1% -6.7% in Objective Caml system

  20. GC Time & Runtime Changes -6.9%~90.5% GC-time reduction -7.3%~39.1% runtime reduction 7.2% -5.5% 5.6% -2.6% High reuse ratio & big GC portion: runtime speedup 1.4% -3.8% 1.9% -2.9% Low reuse ratio: flags overhead 4.3% 4.8% Small GC portion: almost no effect 4.2% 0.1% 1.1% -0.9% 1.3% 0.6% in Objective Caml system

  21. GC-time & Runtime Changes much reuse = much GC-time reduction much reuse & big GC-time portion = much runtime reduction GC time reduction runtime reduction memory reuse ratio GC portion x memory reuse ratio

  22. memory peak reduction & GC time speedup high reuse ratio runtime speedup Conclusion transformation result program performance program not much sharing + big GC-time portion

More Related