Lecture 10 Heap Management by zed18012

VIEWS: 20 PAGES: 21

									Lecture 10: Heap
  Management
   CS 540 GMU
   Spring 2009
    Process Address Space
• Each process has its own
  address space:                           stack

  – Text section (text segment) contains
    the executable code
  – Data section (data segment) contains
    the global variables
  – Stack contains temporary data (local
                                           heap
    variables, return addresses..)
  – Heap, which contains memory that is    data

    dynamically allocated at run-time.     text
         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          ----     
       User Heap Management
User library manages memory; programmer decides when
  and where to allocate and deallocate
• void* malloc(longn)
• void free(void*addr)
• 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
      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
     User Heap Management
• Pro: performance
• Con: safety

                       live         dead
    not deleted                 memory leak
    deleted           dangling       
                     reference
  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
 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
    Locating Garbage
       r1



S
T
A
C
K
                   r2
    Locating Garbage
       r1



S
T
A
C
K
                   r2
         Object reachability
The set of reachable objects changes as a
  program executes-
• Object allocations
• Parameters & return values
• Reference assignments
• Stack-based variables
        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)
• > zero references  not garbage??
    Reference Counting
                       0
          r1       2
      0


                           2
                   1
S     2
T
A
C
K                  2
      1                    r2

               1       0
    What if r1 is removed?
           r1   1




                     1
                1
S      2
T
A
C
K               1
       1              r2
           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
  –…
                      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
            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
              Mark & Compact
Basic idea (Fig 7.27 in text):
• To garbage collect
   1. Starting from the pointers in the stack, data area and
      registers, find and mark all reachable heap blocks
   2. 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
   3. 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.
     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)
      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 (> 0) will
  fill. Once it fills, garbage collect it and put
  surviving elements into partition i+1.
Generational Garbage Collection

								
To top