compiler construction in4020 – lecture 1 2
DESCRIPTION
Compiler construction in4020 – lecture 1 2. Koen Langendoen Delft University of Technology The Netherlands. mies. parameter i. static link dynamic link ret. address. noot. parameter i. static link dynamic link ret. address. Summary of lecture 11. (nested) routine s - PowerPoint PPT PresentationTRANSCRIPT
Compiler constructionin4020 – lecture 12
Koen Langendoen
Delft University of TechnologyThe Netherlands
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
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...
Overview:memory management
• explicit deallocation• malloc() + free()
• implicit deallocation: garbage collection• reference counting
• mark & scan
• two-space copying
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
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 <stdlib.h>
void *calloc(size_t nmemb, size_t size);
void *malloc(size_t size);
void free(void *ptr);
void *realloc(void *ptr, size_t size);
Heap layout
S
I
Z
E
S
0
S
I
Z
E
S
1
S
I
Z
E
S
0
S
I
Z
E
S
1
...
low high
marked
free
marked
in use
blockblock
chunkchunk
in use free
pointer to
user data
Free()
PROCEDURE Free (Block pointer):
SET Chunk pointer TO Block pointer – Admin size;
SET Chunk pointer .free TO True;
S
I
Z
E
S
1
S
I
Z
E
S
0
S
I
Z
E
S
1
...free
S
I
Z
E
S
0
in use
S
I
Z
E
S
1
free
Malloc()
S
I
Z
E
S
1
S
I
Z
E
S
0
S
I
Z
E
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);
S
I
Z
E
S
0
in use
S
I
Z
E
S
1
free
• walk chunks from low to high
• check if chunk is free AND large enough
• if so, mark chunk in use AND return block pointer
S
I
Z
E
S
0
in use
S
I
Z
E
S
1
free
Free block of size (request)
S
I
Z
E
S
1
S
I
Z
E
S
0
S
I
Z
E
S
1
...free
S
I
Z
E
S
0
block pointer
• walk chunks from low to high
• check if chunk is free AND large enough
• if so, mark chunk in use AND return block pointer
S
I
Z
E
S
0
in use
S
I
Z
E
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
S
I
Z
E
S
1
S
I
Z
E
S
0
S
I
Z
E
S
1
...free
S
I
Z
E
S
0
S
I
Z
E
S
1
block pointer
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;
next
S
I
Z
E
S
0
in use
S
I
Z
E
S
1
free
Coalesce free chunks ()
• walk chunks from low to high
• check if chunk is free
• if so, coalesce all subsequent free chunks
S
I
Z
E
S
1
S
I
Z
E
S
0
S
I
Z
E
S
1
...
S
I
Z
E
S
0
S
I
Z
E
S
1
nextnext
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;
Optimizations
free: poor performance (linear search)
malloc: irregular performance (coalesce phase)
solutions:• free lists indexed by size
• coalesce at free()
S
I
Z
E
S
0
in use
S
I
Z
E
S
1
free
S
I
Z
E
S
1
S
I
Z
E
S
0
S
I
Z
E
S
1
...
S
I
Z
E
S
0
S
I
Z
E
S
1
2log(size) 3 4 5 6
free list
use first field
as next ptr
Malloc() with free lists
FUNCTION Malloc (Block size) RETURNS a generic pointer:
SET Chunk size TO Block size + Admin size;
SET Index TO 2log(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);
Exercise (5 min.)
• give the pseudo code for free() when using free lists indexed by size.
Answers
Answers
PROCEDURE Free (Block pointer):
SET Chunk pointer TO Block pointer – Admin size;
SET Index TO 2log(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
Break
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
Example
A
C
D
E
F
B
heap
root set
Garbage
A
C
D
E B
heap
root set
B B E E
F
Cyclic garbage
C
E
F
B
heaproot set
D A
garbage?
• “no-pointers”: NO
• “not-reachable”: YES
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
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
Reference counting
• record #pointers to each chunk
• reclaim when reference count drops to zero
2
2
1
1
2
heaproot set
A D
B E
FC
1
0 0
1 1
Maintaining reference counts
VAR p, q : pointer;
...
p := q;
PROCEDURE Free recursively (Pointer):
FOR each field fi of record Pointer:
IF Points into the heap (fi):
Decrement fi .ref count;
IF fi .ref count = 0:
Free recursively (fi);
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:
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
Mark & scanPROCEDURE Mark (Pointer):
IF NOT Points into the heap (Pointer): RETURN;
SET Pointer .marked TO True;
FOR each field fi of record Pointer:
Mark (fi);
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;
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
Advanced marking
2
1
0
S p
t
r
p
t
r
p
t
r
1
1
0
S p
t
r
p
t
r
p
t
r
free bit
mark bit
pointer cnt
size
to parent
0
0
S p
t
r
p
t
r
Advanced marking:pointer reversal
• avoid additional parent pointer
• use the n-th child pointer when visiting child n
2
1
0
S p
t
r
p
t
r
p
t
r
1
1
0
S p
t
r
p
t
r
p
t
r
to parent
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
from to
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
from tofrom to
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
scanscanscan
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
scanscanscan
A
D
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
scanscan
A
D
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
scanscan
A
D F
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
scanscan
A
D F
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
scanscan
A
D F
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
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
Summary
Memory management
• explicit deallocation• malloc() + free()
• implicit deallocation: garbage collection• reference counting
• mark & scan
• two-space copying
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]