1. Compiler construction in4020 – lecture 12 Koen Langendoen Delft University of Technology The Netherlands

2. Summary of lecture 11 (nested) routines activation records routine descriptors code generation for control flow statements conditional expressions: true & false labels case-statement: jump table for-statement: overflow static link dynamic link ret. address parameter i mies parameter i noot static link dynamic link ret. address

3. Quiz 6.30 Why are parameters stacked in the reverse order? That is, why is the last parameter pushed first when calling a routine? working stack parameter n parameter 1... registers dynamic link return address local variables FP SP parameter k parameter 1...

4. Overview: memory management explicit deallocation malloc() + free() implicit deallocation: garbage collection reference counting mark & scan two-space copying

5. Memory management What has a compiler to do with memory management? compiler uses heap-allocated data structures modern languages have automatic data (de)allocation garbage collection part of runtime support system compiler usually assists in identifying pointers

6. Data allocation with explicit deallocation malloc() find free block of requested size mark it in use return a pointer to it. free() mark the block as not in use. #include void *calloc(size_t nmemb, size_t size); void *malloc(size_t size); void free(void *ptr); void *realloc(void *ptr, size_t size);

7. Heap layout SIZESIZE S 0 SIZESIZE S 1 SIZESIZE S 0 SIZESIZE S 1... lowhigh marked free marked in use block chunk in use free pointer to user data

8. Free() PROCEDURE Free (Block pointer): SET Chunk pointer TO Block pointer – Admin size; SET Chunk pointer.free TO True; SIZESIZE S 1 SIZESIZE S 0 SIZESIZE S 1... free SIZESIZE S 0 in use SIZESIZE S 1 free

9. Malloc() SIZESIZE S 1 SIZESIZE S 0 SIZESIZE S 1... free FUNCTION Malloc (Block size) RETURNS a generic pointer: SET Pointer TO Free block of size (Block size); IF pointer /= NULL: RETURN pointer; Coalesce free chunks (); RETURN Free block of size (Block size); SIZESIZE S 0 in use SIZESIZE S 1 free

10. walk chunks from low to high check if chunk is free AND large enough if so, mark chunk in use AND return block pointer SIZESIZE S 0 in use SIZESIZE S 1 free Free block of size (request) SIZESIZE S 1 SIZESIZE S 0 SIZESIZE S 1... free SIZESIZE S 0 block pointer

11. walk chunks from low to high check if chunk is free AND large enough if so, mark chunk in use AND return block pointer SIZESIZE S 0 in use SIZESIZE S 1 free Free block of size (request) walk chunks from low to high check if chunk is free AND large enough if so, mark chunk in use AND return block pointer optimization: split chunk to free unused part SIZESIZE S 1 SIZESIZE S 0 SIZESIZE S 1... free SIZESIZE S 0 SIZESIZE S 1 block pointer

12. Free block of size FUNCTION Free block of size (Block size) RETURNS a generic pointer: SET Chunk ptr TO Heap low; SET Request TO Block size + Admin size; WHILE Chunk ptr < Heap high: IF Chunk ptr.free AND Chunk ptr.size >= Request: Split chunk (Chunk ptr, Request) SET Chunk ptr.free TO False; RETURN Chunk ptr + Admin size; SET Chunk ptr TO Chunk ptr + Chunk ptr.size; RETURN NULL;

13. next SIZESIZE S 0 in use SIZESIZE S 1 free Coalesce free chunks () walk chunks from low to high check if chunk is free if so, coalesce all subsequent free chunks SIZESIZE S 1 SIZESIZE S 0 SIZESIZE S 1... SIZESIZE S 0 SIZESIZE S 1 next

14. Coalesce free chunks PROCEDURE Coalesce free chunks (): SET Chunk ptr TO Heap low; WHILE Chunk ptr < Heap high: IF Chunk ptr.free: SET Next TO Chunk ptr + Chunk ptr.size; WHILE Next < Heap high AND Next.free: SET Next TO Next + Next.size; SET Chunk ptr.size TO Next - Chunk ptr; SET Chunk ptr TO Chunk ptr + Chunk ptr.size;

15. Optimizations free: poor performance (linear search) malloc: irregular performance (coalesce phase) solutions: free lists indexed by size coalesce at free() SIZESIZE S 0 in use SIZESIZE S 1 free SIZESIZE S 1 SIZESIZE S 0 SIZESIZE S 1... SIZESIZE S 0 SIZESIZE S 1 2 log(size)3456 free list use first field as next ptr

16. Malloc() with free lists FUNCTION Malloc (Block size) RETURNS a generic pointer: SET Chunk size TO Block size + Admin size; SET Index TO 2 log(Chunk size); IF Index < 3: SET Index TO 3; IF Index <= 10 AND Free list[Index] /= NULL: SET Pointer TO Free list[Index]; SET Free list[Index].next TO Pointer.next; RETURN Pointer + Admin size; RETURN Free block of size (Block size);

17. Exercise (5 min.) give the pseudo code for free() when using free lists indexed by size.

18. Answers

19. PROCEDURE Free (Block pointer): SET Chunk pointer TO Block pointer – Admin size; SET Index TO 2 log(Chunk pointer.size); IF Index <= 10: SET Chunk pointer.next TO Free list[Index]; SET Free list[Index] TO Chunk pointer; ELSE SET Chunk pointer.free TO True; // Coalesce subsequent free chunks

20. Break

21. Garbage collection memory allocation is explicit (new) memory deallocation is implicit garbage set: all chunks that will no longer be used by the program chunks without incoming pointers chunks that are unreachable from non-heap data

22. Example A C D E F B heap root set

23. Garbage A C D E B heap root set B B E E F

24. Cyclic garbage C E F B heap root set D A garbage? “no-pointers”: NO “not-reachable”: YES

25. Compiler assistance: identifying pointers pointers inside chunks user-defined data structures compiler: generate self-descriptive chunks pointers located outside the heap (root set) global data + stack compiler: generate activation record descriptions

26. Self-descriptive chunks bitmap per data type problem: overhead per chunk / interpretation compiler-generated routine per data type calls GC for each pointer problem: recursion organize data type to start off with n pointers solution: n can be squeezed into chunk admin

27. Reference counting record #pointers to each chunk reclaim when reference count drops to zero 2 2 1 1 2 heap root set AD BE FC 1 0 0 1 1

28. Maintaining reference counts VAR p, q : pointer;... p := q; PROCEDURE Free recursively (Pointer): FOR each field f i of record Pointer: IF Points into the heap (f i ): Decrement f i.ref count; IF f i.ref count = 0: Free recursively (f i ); Free chunk (Pointer); source IF Points into the heap (q): Increment q.ref count; IF Points into the heap (p): Decrement p.ref count; IF p.ref count = 0: Free recursively (p); SET p TO q; target pointer assignment:

29. Mark & scan A C D E F B heap root set mark all reachable chunks scan heap for unmarked chunks that can be freed B E

30. Mark & scan PROCEDURE Mark (Pointer): IF NOT Points into the heap (Pointer): RETURN; SET Pointer.marked TO True; FOR each field f i of record Pointer: Mark (f i ); PROCEDURE Scan (): SET Chunk ptr TO Heap low; WHILE Chunk ptr < Heap high: IF Chunk ptr.marked: SET Chunk ptr.marked TO False; ELSE SET Chunk ptr.free TO True; SET Chunk ptr TO Chunk ptr + Chunk ptr.size;

31. Advanced marking problem: mark() is recursive solution: embed stack in the chunks each chunk records: a count denoting which child pointer is next a pointer to the parent node

32. Advanced marking 2 1 0 S ptrptr ptrptr ptrptr 1 1 0 S ptrptr ptrptr ptrptr free bit mark bit pointer cnt size to parent 0 0 S ptrptr ptrptr ptrptr

33. Advanced marking: pointer reversal avoid additional parent pointer use the n-th child pointer when visiting child n 2 1 0 S ptrptr ptrptr ptrptr 1 1 0 S ptrptr ptrptr ptrptr to parent

34. Two-space copying most chunks have a short live time memory fragmentation must be addressed partition heap in two spaces copy all reachable chunks to consecutive locations fromto

35. Two-space copying most chunks have a short live time memory fragmentation must be addressed partition heap in two spaces copy all reachable chunks to consecutive locations fromtofrom to

36. Copying to to-space copy root set leave forwarding pointers scan to-space for reachable cells in from-space C D E F B from to A C A scan

37. Copying to to-space copy root set leave forwarding pointers scan to-space for reachable cells in from-space C E F B from to A C scan A D

38. Copying to to-space copy root set leave forwarding pointers scan to-space for reachable cells in from-space C E F B from to A C scan A D

39. Copying to to-space copy root set leave forwarding pointers scan to-space for reachable cells in from-space C E B from to A C scan A D F

40. Copying to to-space copy root set leave forwarding pointers scan to-space for reachable cells in from-space C E B from to A C scan A D F

41. Copying to to-space copy root set leave forwarding pointers scan to-space for reachable cells in from-space C E B from to A C scan A D F

42. Copying to to-space copy root set leave forwarding pointers scan to-space for reachable cells in from-space C E B from to A C A D F scan

43. Copying to to-space copy root set leave forwarding pointers scan to-space for reachable cells in from-space from to C A D F scan

44. Summary Memory management explicit deallocation malloc() + free() implicit deallocation: garbage collection reference counting mark & scan two-space copying

45. Homework study sections: 5.2.6 Compaction 5.2.7 Generational garbage collection assignment 2: make Asterix OO deadline June 4 08:59 print handout for last week [blackboard]