Lecture 10: Heap Management

1
Lecture 10 Heap Management

• CS 540 GMU
• Spring 2009

2
Process Address Space

• Each process has its own address space
• Text section (text segment) contains the
  executable code
• Data section (data segment) contains the global
  variables
• Stack contains temporary data (local variables,
  return addresses..)
• Heap, which contains memory that is dynamically
  allocated at run-time.

stack
heap
data
text
3
Heap Management

• Heap is used to allocate space for dynamic
  objects
• May be managed by the user or by the runtime
  system
• In a perfect world

live dead
not deleted ? ----
deleted ---- ?
4
User Heap Management

• User library manages memory programmer decides
  when and where to allocate and deallocate
• void malloc(longn)
• void free(voidaddr)
• Library calls OS for more pages when necessary
• How does malloc/free work?
• Blocks of unused memory stored on a freelist
• malloc search free list for usable memory block
• free put block onto the head of the freelist

5
User Heap Management

• Drawbacks
• malloc is not free we might have to do a search
  to find a big enough block
• As program runs, the heap fragments, leaving many
  small, unusable pieces
• Have to have a way to reclaim and merge blocks
  when freed.
• Memory management always has a cost. We want to
  minimize costs and, these days, maximize
  reliability

6
User Heap Management

• Pro performance
• Con safety

live dead
not deleted ? memory leak
deleted dangling reference ?
7
Automatic Heap Management

• Garbage collection reclamation of chunks of
  storage holding objects that can no longer be
  accessed by a program
• Originated with Lisp
• New languages tend to have automatic management
• Less error prone but performance penalty
• Assumptions type info is available at runtime
  (how large a block is, where are pointers),
  pointers are always to start of block

8
Automatic Heap Management

• Issues
• How much does this increase the runtime of a
  program?
• Space need to manage free/used space
• Pause time incremental vs. stop the world
• Influences on data locality
• Different types/sizes of objects

9
Locating Garbage
r1
S T A C K
r2
10
Locating Garbage
r1
S T A C K
r2
11
Object reachability

• The set of reachable objects changes as a program
  executes-
• Object allocations
• Parameters return values
• Reference assignments
• Stack-based variables

12
Reference Counting

• Keep a count of pointers to each object
• performance overhead each time the reachable set
  can change
• storage overhead since each object needs a count
  field
• Zero references ? garbage that can be removed
  (applied transitively)
• gt zero references ? not garbage??

13
Reference Counting
0
r1
2
S T A C K
0
2
1
2
2
r2
1
1
0
14
What if r1 is removed?
r1
1
S T A C K
1
1
2
1
r2
1
15
Trace Collecting

• When the heap starts to fill, pause the program
  and reclaim
• Stop the world pauses can be significant
• Lots of versions
• Mark sweep
• Mark compact

16
Mark Sweep

• Basic idea
• maintain a linked list, called the free list,
  that contains all of the heap blocks that can be
  allocated
• if the program requests a heap block but the free
  list is empty, invoke the garbage collector
• starting from the pointers in the stack, data
  area and registers, trace and mark all reachable
  heap blocks
• sweep and collect all unmarked heap blocks,
  putting each one back on the free list (merging
  as appropriate)
• sweep again, unmarking all heap blocks
• First developed by McCarthy in 1960 for Lisp
• detecting what is a pointer is easier said than
  done

17
Mark Sweep

• Issues
• How to detect pointers?
• Need to keep a bit that we can use for the
  algorithm in every object
• In Lisp, the program execution would pause while
  the system did garbage collecting

18
Mark Compact

• Basic idea (Fig 7.27 in text)
• To garbage collect
• Starting from the pointers in the stack, data
  area and registers, find and mark all reachable
  heap blocks
• Scan the marked nodes and compute a new address
  for each, based on where it should be relocated
  to have all of the blocks contiguous
• Move each block to its new location, updating any
  internal pointers into the heap based on step 2.
  Update any program stack variables based on the
  new assignments as well.

19
Generational Collection

• Generational collection
• Idea An object that survives its first round of
  garbage collection is likely to survive later
  (i.e. objects tend to die young)

20
A Generational algorithm

• Memory is divided into N partitions
• New objects are always allocated into partition 0
• When partition 0 fills, it is garbage collected
  (via some technique). Anything that survives is
  moved to partition 1 (leaving 0 empty).
• Keep doing this eventually partition i (gt 0)
  will fill. Once it fills, garbage collect it and
  put surviving elements into partition i1.

21
Generational Garbage Collection