Memory Management

Behind the curtain

Nathan Tenney

WSU Tri-Cities

Memory Management

• Computer operations have been abstracted
  • Stack Frames and recursion
• In C++, it is the programmers responsibility to manage memory
  • New and delete
• Some languages handle memory management for the programmer
• Maintenance of free blocks, and allocation of memory to user programs is usually the purview of an OS component known as a Memory Manager

Overview

• Sequential Fit Algorithms
  • First fit
  • Best fit
  • Worst fit
  • Next fit
• Nonsequential Fit Algorithms
  • Adaptive exact fit
  • Buddy system
• Garbage Collection
  • Mark and sweep
  • Stop and copy

Terms

• External Fragmentation wasted space between memory allocations
  • Can lead to MM not being able to fill a request for memory, even if there is enough free memory for the request
• Internal Fragmentation wasted space inside a memory allocation

Sequential Fit Algorithms

• First fit
  • Allocates the first block of memory large enough to meet the request
• Best fit
  • Allocates the block that is closest in size to the request
• Worst fit
  • Allocates the memory request from the largest block in the free list
• Next fit
  • Allocates the next block in the list that is large enough for the request

Sequential Fit Algorithms

• First fit
  • Most Efficient of the sequential fit algorithms
• Best fit
  • Produces a large amount of fragmentation, and fragments that are too small to be useable
• Worst fit
  • Avoids or Delays the issues brought on by best fit
• Next fit
  • Nearly as fast as first fit, but produces more external fragmentation.

Sequential Fit Algorithms

Adaptive Exact Fit

• Observation: Typically, the sizes of blocks requested by a given program is fairly consistent (may differ from program to program)
• Maintain a size list of blocks based on blocks returned during the last T allocations
• When a request comes in for a block whose size exists in the table, a block is removed from the list
• When a request comes in for a block whose size is not in the table, one of the sequential methods is used
• If a block of size b is not returned in T allocations, that block is removed from the block size list

Adaptive Exact Fit

Binary Buddy System

• Assume that memory consists of $2^m$ storage locations with addresses $0,...,2^m-1$
• Memory locations are organized into blocks whose lengths are powers of 2
• There is also an array avail[] and where $i=0,...,m$ avail[i] is the head pointer for a doubly linked list of blocks of size $2^i$

Binary Buddy System

• Each block of memory (except the entire memory) is associated with a buddy of equal size.
  • The address of the buddy of a block size $2^i$ is found by complementing the $i+1$ bit
  • Example: If memory has 8 locations, the addresses for blocks of size 1 are {000,001,010,011,100,101,110,111}
  • For blocks of size 2, the addresses are {000,010,100,110}
  • For blocks of size 4, the addresses are {000,100}
  • For blocks of size 8, the address is {000}

Binary Buddy System

• If a request comes in to the memory manager for a block of size s, the buddy system returns a block size $\ge s$
  • There are many candidates that fit this condition
• Check avail[] for the block whose size k is the smallest among all $k \ge s$
  • This location should be at avail[k]
  • If avail[k] is empty, then we check $k+1$, and then $k+2$ until a nonempty list is found

Binary Buddy System

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

size of memory = 2^m for some m
avail[i] = -1 for i = 0,...,m-1
avail[m] = first address in memory
reserve(reqSize):
  roundedSize = ceil( lg( reqSize))
  availSize = min(roundedSize,...,m) for which avail[availSize] > -1
  if nosuch availSize exists:
    failure!
  block = avail[availSize]
  detach block from list avail[availSize]
  while (roundedSize < availSize): // While available block is too large, split it
    availSize--
    block = left half of block
    insert buddy of block in list avail[availSize]
  return block

Binary Buddy System

Binary Buddy System

• When a block is reclaimed:
  • Check the availability of the blocks buddy. If it is available, join the two blocks together
  • Continue joining blocks together until a blocks buddy is not available

Binary Buddy System

Garbage Collection

• In C/C++, when we are done with a segment of memory, what should we do?
• How do we do it
• If we don’t, what is the result

Garbage Collection

• Many modern programming languages handle memory management behind the scenes
  • Free’s programmers to think more in terms of the logic of a particular program
• Languages still contain a mechanism to request a memory allocation
• When the program is done with the memory the block is simply abandoned
• a Garbage Collector is invoked when the program is idle or memory resources are fully utilized

Garbage Collection

• Memory heap is viewed as a collection of cells made up of several fields
  • prev/next pointers
  • Marked/unmarked flag
• The Root Set is the set of memory roots for all programs

Garbage Collection

• Garabage collectors job is to determine which memory segments are no longer in use and may be returned to the free pool
• Garbage collection usually consists of two phases
  • Marking phase
  • Reclamation phase
• Phases may be distinct or integrated

Mark and Sweep

• Seperates the two phases
  • Marking
  • Reclamation of space
  • Compaction of space

Mark and Sweep

• Examine each item in the root set
  • Mark the item
  • Follows all references the item has, marking each of those items and following their references
• Once all active items have been marked
  • Scan entire memory, reclaiming all un marked items
  • If an item is marked, unmark it for the next iteration

Mark and Sweep

• What potential issues may arise with the marking step?

Mark and Sweep

sweep():
  for each location from the last to the first:
    if mark(location) is 0:
      insert location in front of availList
    else:
      set mark(location) to 0

Mark and Sweep

• Marking operates similarly to a pre-order tree traversal.
• After reclamation is run, the available cells are intersperced with the cells in use by the program
• Compaction pushes all the available memory together, removing the need for availList
• Compaction also helps when using virtual memory (decreases accesses)
• also helps when the run-time stack and a memory heap are used at the same time

Mark and Sweep

• Problems?
  • The root set needs to be immutable while this process is going on.
  • All working memory is examined, paging may be an issue

Stop and Copy

• Cleaner than the Mark and Sweep method
  • Doesn’t touch garbage…
• Only looks at root set

Stop and Copy

• Heap is divided into two semispaces
• Only one is actively used for memory allocation
• Allocation continues until the allocation pointer reaches the end of the semispace
• All active memory segments are copied to the second semispace
• Second semispace becomes active
• program resumes execution

Stop and Copy

Tri-color Marking

• Working memory is divided up into three sets
  • White – Set containing candidates for recycling
  • Grey – Set of objects reachable by from the root set.
  • Black – Set of objects that can be (cheaply) proven to have no reference in the white set
• Grey set is initialized to the objects in the root set
• All other objects are placed in the white set

Tri-color Marking

• Pick an object from the grey set and blacken it
  • Grey all the white objects that this object references
  • Move object to the black set
• Repeat until grey set is empty
• Invariant – No objects in the black set reference objects in the white set
• Any objects remaining in the white set can be garbage collected

Tri-color Marking

• Can be performed "on the fly"
  • Mark during allocation and mutation
  • Periodically reclaim based on the size of the sets

Tri-color Marking

• Cleaner than the Mark and Sweep method
  • Doesn’t touch garbage…
• Only looks at root set

Garbage Collection

• Do these methods correct the issues identified with memory managemen in C/C++?
• Why/Why not?