An Example of Program Analysis: Inserting Safe Memory Re-use Commands into ML-like Programs Oukseh Lee, Hongseok Yang, and Kwangkeun Yi {cookcu; hyang; kwang}@ropas.kaist.ac.kr Research On Program Analysis System, KAIST http://ropas.kaist.ac.kr December 5, 2002 CS520

Motivation (1/2) Thanks to many compilation techniques, ML can produce fast code, but still has the overhead for managing the memory. Garbage collection is usually faster than the manual memory management. Then what is the reason of the memory inefficiency?

Motivation (2/2) Unnecessary allocation in ML programs: 1 2 3 5 6 1 2 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 1 2 3 5 6 1 2 3 4

Our Goal To insert safe memory-reuse commands: 1 2 3 5 6 4 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) 1 2 3 5 6 4

How to Find it? By an accurate but effective program analysis: Individual heap-cell as the unit of analysis. Context pruning at the conditional branches. Keeping sharing information using multi-set formula. Parameterized analysis, so poly-variance at function calls. Deallocation inside a function can be conditioned by extra boolean parameters (called dynamic flags).

Experimental Result

Example: copyright free a? Tree a will not be used later fun copyright a = case a of Leaf => Leaf | Node(a1,a2) => let r = copyright a2 in Node(a1, r) free a?

Key: Precise Separation Tree a will not be used later fun copyright a = case a of Leaf => Leaf | Node(a1,a2) => let r = copyright a2 in Node(a1, r) # all left subtrees # all result trees free a?

Safe Only Under the Assumption Tree a will not be used later fun copyright a = case a of Leaf => Leaf | Node(a1,a2) => let r = copyright a2 in (free a; Node(a1, r)) Tree a has no shared sub-parts X

Passing the Assumption in Run-time Tree a may have shared sub-parts Tree a will not be used later fun copyright [b,bs] a = case a of Leaf => Leaf | Node(a1,a2) => let r = copyright [bÆ:bs,bs] a2 in (free a when b; Node(a1, r))

Input Language

Output Language

First Step Memory-usage analysis: free-commands insertion: Computes the memory-type (abstraction of heap objects) and usage for each expression. free-commands insertion: Inserts free-commands and adds dynamic flags using the result from the memory-usage analysis.

How to Represent a Set of Heap Objects? x x x x let x = ... in ...

A Set of Locations (NO!) Not enough for sharing information. x x y y x = Node(Leaf,Leaf) y = Node(x,x) x = Node(Leaf,Leaf) y = Node(x,Leaf) x y x y

Multi-set Formula Describes a set of locations with sharing information: note:

Memory-Type for a Tree Describes a set of trees: root left right note:

Memory-Type for a Function Describes the behavior of the function. The memory-type of function copyright is: input new result usage

Analysis fun copyright a = case a of Leaf => Leaf | Node(a1,a2) => let r = copyright a2 in Node(a1, r)

Second Step Memory-usage analysis: Computes the memory-type and usage for each expression. free-commands insertion: Inserts free-commands and adds dynamic flags using the result from the memory-usage analysis.

Insertion (1/3) fun copyright [b,bs] a = case a of Leaf => Leaf | Node(a1,a2) => let r = copyright a2 in Node (a1, r) b: it is safe to free the input (excluding the result) bs: the input may have shared sub-parts.

Insertion (2/3) b :bs fun copyright [b,bs] a = case a of Leaf => Leaf | Node(a1,a2) => let r = copyright a2 in Node (a1, r) b :bs

Insertion (3/3) a: fun copyright [b,bs] a = case a of Leaf => Leaf | Node(a1,a2) => let r = copyright [bÆ:bs,bs] a2 in Node (a1, r) b a: true true

Result fun copyright [b,bs] a = case a of Leaf => Leaf | Node(a1,a2) => let r = copyright [bÆ:bs,bs] a2 in (free a when b; Node (a1, r))

Conclusion We present a static analysis and source-level transformation for inserting safe memory-reuse commands. Reuse ratio: 5.2-98.7% Analysis cost: 415-4500 lines/sec Weak for prevalent sharing but enough for usual cases. Plan to apply this analysis to our nML compiler.