Memory Management Variable Storage Storage binding - binds the - - PowerPoint PPT Presentation
Memory Management Variable Storage Storage binding - binds the address attribute of a variable to physical storage n Disregarding object attributes (fields) for now Allocation of space n Static (compile-time or load time) n Stack
n Disregarding object attributes (fields) for now
n Static (compile-time or load time) n Stack (runtime) – aka user/runtime/system stack n Heap (runtime)
4
n Globals (static storage)
u Read-only segment holds translated/native code as well if any
5
n Globals (static storage)
u Read-only segment holds translated/native code as well if any
n Locals (stack storage)
u Allocated/deallocated with function invocations and returns
6
n Globals (static storage) n Locals (stack storage) n Dynamic variables, aka pointer variables (heap storage)
7
n The OS has been told that the file
n OS schedules it for execution (to
n A process has its own address space
OS kernel virtual memory User/Runtime stack To support function execution and local variable storage Shared library region Runtime heap For dynamic (explicit) allocation
Read/write segment For globals (& static locals) Read-only segment For program code and constant global variables Unused/Not Accessible Process Memory (virtual address space) high memory low memory Address 0x0 Address 0xffffffff Executable & Linkable Format (ELF): Linux/GNU
n New, malloc, delete, free n Programmer controls all
n Programmers do nothing, its all automatic n Non-heap objects are implictly allocated and deallocated
n Implicit deallocation of heap objects
n Even for simple data structures
n Purify n But these only work on a running program (particular input
n However it is REQUIRED for managed languages
n Reduce the number of bugs and hard to find programming errors n Reduce program development/debugging cycle
n Not an afterthought or hack
n Part of the runtime that implements memory management
n User program - change (mutate) program data structures
n In processor registers n On the program stack (includes locals/temporaries) n In global variables (e.g., array of statics)
n References to heap data held in these locations n Dynamically allocated data only accessible via roots n A program should not access random locations in heap
n Nodes, cells, objects (interchangeably) n Commonly have header that indicates the type (and thus
n Graph of objects that can be “reached” from roots
u For languages without GC, what is this called?
n An object in the heap is live if
n Most common method: tracing n Regenerate the set of live nodes whenever a request by the
n Start from each root and visit all reachable nodes (via
n Any node not visited is reclaimed
n A record is associated with each node in the heap and all
n Most common method: reference counting
n Alternate example: Distributed systems where processors
n Must be kept up to date as the mutator alters the
n Incremental garbage collection n Stop the world
n Root set for tracing
n Limitations of reference counting
n Memory manager – should not allocate memory!
n User program - change (mutate) program data structures
n In processor registers, on program stack (includes locals/
n References to heap data held in these locations n Dynamically allocated data only accessible via roots
n “Live” objects are those reachable by the roots (all else is
n Most common method: tracing n Regenerate the set of live nodes whenever a request by the
n Start from each root and visit all reachable nodes (via
n Any node not visited is reclaimed
n A record is associated with each node in the heap and all
n Most common method: reference counting
n Alternate example: Distributed systems where processors
n Must be kept up to date as the mutator alters the
Free List Allocation: keep 1+ lists of free chunks that we then fill or break off pieces of to allocate an object
Heap Space in Virtual Memory Object/cell/node header + data (fields)
Heap Space in Virtual Memory
Heap Space in Virtual Memory
Free List 7 2 2 6 6
NULL NULL NULL NULL NULL
6 4 4 4 4 4 4 Roots: a b c d e f g h i j k l h = new LARGE_OBJECT()
Free List 7 2 2 6 6
NULL NULL NULL NULL NULL
6 4 4 4 4 4 4 Roots: a b c d e f g h i j k l h = new LARGE_OBJECT()
Free List 7 2 2 6 6
NULL NULL NULL NULL NULL
6 4 4 4 4 4 4 Roots: a b c d e f g h i j k l h = new LARGE_OBJECT() d = NULL (before)
Free List 7 2 6 6
NULL NULL NULL NULL NULL
6 4 4 4 4 4 4 Roots: a b c d e f g h i j k l h = new LARGE_OBJECT() d = NULL (after)
n Reference count
n If the count goes to 0
n The cell is returned to the free list
n Reference count is set to 1 n Removed from free list
Allocate() { newcell = free_list free_list = free_list->next return newcell } New() { if (free_list) == NULL abort(“Out of Memory”) newcell = allocate() newcell->RC = 1 return newcell } Free(N) { N->next = free_list free_list = N } Delete(T) { T->RC-- if (T->RC ==0) { for U in Children(T) Delete (*U) Free(T) } } Update(R,S) { // we assume R,S are // pointers S->RC++ Delete(*R) *R = S } 1 R R = New(): 1 R 1 R m-1 T S T S AFTER: BEFORE: root root m n n+1 root root Update(R->left,S)
Free(N) { N->next = free_list free_list = N } Update(R,S) { // we assume R,S are // pointers and nulls // are handled correctly S->RC++ Delete(*R) *R = S } Delete(T) { T->RC-- if (T->RC == 0) { for U in Children(T) Delete(*U) Free(T) } } R n S U 1 V 1
next
T 2 Before if in Delete(*(R->right)) Before Update(R->right,NULL) R n S 1 U 1 V 1
next
T 2 free_list free_list
Free(N) { N->next = free_list free_list = N } Delete(T) { T->RC-- if (T->RC == 0) { for U in Children(T) Delete(*U) Free(T) } } R n free_list T 1 After: Update(R->right,NULL) Delete(S->left) R n S U 1 V 1 free_list
next
T 1 Update(R,S) { // we assume R,S are // pointers and nulls // are handled correctly S->RC++ Delete(*R) *R = S }
n Memory management overheads are distributed throughout
n Locality of reference
n Short-lived cells can be reused as soon as they are reclaimed
n High processing cost for each pointer update
n Fragile
n Extra space in each cell to store count
n Cyclic data structures can’t be reclaimed
R n S 2 U 2 V 1 R n S 1 U 2 V 1 Delete(R->right) This cycle is neither reachable nor reclaimable
Free List Allocation: keep 1+ lists of free chunks that we then fill or break off pieces of to allocate an object
n Mark-sweep, Mark-scan n Use reachability (indirection) to find live objects
n Remain unreachable and undetected until storage is
n Sweep all currently unused cells back into the free_list n GC performs a global traversal of all live objects to
New() { if free_list->isEmpty() mark_sweep newcell = allocate() return newcell } mark_sweep() { for R in Roots mark (R) sweep() if free_list->isEmpty() abort(“OutOfMemory”) } mark(N) { if N->mark_bit == 0 N->mark_bit = 1 for M in Children(N) mark(M) } sweep() { N = heap_start while (N < heap_end) { if N->mark_bit == 0 free(N) else N->mark_bit = 0 N+=sizeof(N) } }
The heap graph of objects Root
New() { if free_list->isEmpty() mark_sweep newcell = allocate() return newcell } mark_sweep() { for R in Roots mark (R) sweep() if free_list->isEmpty() abort(“OutOfMemory”) } mark(N) { if N->mark_bit == 0 N->mark_bit = 1 for M in Children(N) mark(M) } sweep() { N = heap_start while (N < heap_end) { if N->mark_bit == 0 free(N) else N->mark_bit = 0 N+=sizeof(N) } }
The heap graph after the marking phase, all unmarked cells are garbage Root
New() { if free_list->isEmpty() mark_sweep newcell = allocate() return newcell } mark_sweep() { for R in Roots mark (R) sweep() if free_list->isEmpty() abort(“OutOfMemory”) } mark(N) { if N->mark_bit == 0 N->mark_bit = 1 for M in Children(N) mark(M) } sweep() { N = heap_start while (N < heap_end) { if N->mark_bit == 0 free(N) else N->mark_bit = 0 N+=sizeof(N) } }
The heap graph after the marking phase, all unmarked cells are garbage Root All of the gray areas are skipped (but considered) during sweeping
New() { if free_list->isEmpty() mark_sweep newcell = allocate() return newcell } mark_sweep() { for R in Roots mark (R) sweep() if free_list->isEmpty() abort(“OutOfMemory”) } mark(N) { if N->mark_bit == 0 N->mark_bit = 1 for M in Children(N) mark(M) } sweep() { N = heap_start while (N < heap_end) { if N->mark_bit == 0 free(N) else N->mark_bit = 0 N+=sizeof(N) } }
The heap graph after the sweeping phase, all unmarked cells are live Root
New() { if free_list->isEmpty() mark_sweep newcell = allocate() return newcell } mark_sweep() { for R in Roots mark (R) sweep() if free_list->isEmpty() abort(“OutOfMemory”) } mark(N) { if N->mark_bit == 0 N->mark_bit = 1 for M in Children(N) mark(M) } sweep() { N = heap_start while (N < heap_end) { if N->mark_bit == 0 free(N) else N->mark_bit = 0 N+=sizeof(N) } }
The heap graph after the sweeping phase, all unmarked cells are live Free list
n Cycles are handled quite normally n No overhead placed on pointer manipulations n Better than (incremental) reference counting
n Start-stop algorithm (aka stop-the-world)
n Asymptotic complexity is proportional to the size of the heap
n Fragments memory (scatters free cells across memory)
n Residency - heap occupancy
n Zero fragmentation n Fast allocation – Increment a pointer into free space n Improved locality
n At least two passes required during compaction
Free List Allocation: keep 1+ lists of free chunks that we then fill or break off pieces of to allocate an object
Bump-Pointer Allocation: increment a pointer to get the next chunk of memory for an object being allocated Free List Allocation: keep 1+ lists of free chunks that we then fill or break off pieces of to allocate an object
n Divide the heap into two semispaces
n The roles of the two semispaces is continuously flipped n Collector copies live data from the old semispace
n Scavengers
n Fast allocation – Increment a pointer into free space
n No fragmentation
n Available heap space is halved n Large copying cost n Locality not always improved
Alloc From Space To Space (Copy Reserve) Semispaces: Alloc From Space To Space (Copy Reserve) Semispaces: From Space To Space (Copy Reserve) Semispaces: GC! Alloc From Space To Space (Copy Reserve) Semispaces: Copied Copy GC From Space To Space (Copy Reserve) Semispaces: Flip GC From Space To Space (Copy Reserve) Semispaces: Alloc From Space To Space (Copy Reserve) Semispaces: Alloc From Space To Space (Copy Reserve) Semispaces:
New(n) { if freeptr+n > top_of_space flip() if freeptr+n > top_of_space abort(“OutOfMemory”) newcell = freeptr freeptr = freeptr+n return newcell } InitGC() { ToSpace = heap_start space_size = heap_size/2 top_of_space = ToSpace+space_size FromSpace = top_of_space+1 freeptr = toSpace } flip() { FromSpace, ToSpace = ToSpace, FromSpace top_of_space = ToSpace+space_size freeptr = ToSpace for R in Roots R=copy(R) } ToSpace FromSpace root
2 1 AKA: the bump pointer
flip() { FromSpace, ToSpace = ToSpace, FromSpace top_of_space = ToSpace+space_size freeptr = ToSpace for R in Roots R=copy(R) } copy(P) if P==NULL || P->is_atomic return P if !forwarded(P) { n = size(P) P’ = freeptr freeptr = freeptr+n fowarding_address(P) = P’ for (i = 0; i<n; i++) P’[i] = copy(P[i]); } return fowarding_address } ToSpace FromSpace root
2 1
A B C D A’ pointer forwarding_address ToSpace FromSpace root
2 1
A B C D A’ ToSpace FromSpace root
2 1
A B C D A’ B’ B’
1 1
flip() { FromSpace, ToSpace = ToSpace, FromSpace top_of_space = ToSpace+space_size freeptr = ToSpace for R in Roots R=copy(R) } copy(P) if P==NULL || P->is_atomic return P if !forwarded(P) { n = size(P) P’ = freeptr freeptr = freeptr+n fowarding_address(P) = P’ for (i = 0; i<n; i++) P’[i] = copy(P[i]); } return fowarding_address } ToSpace FromSpace root
2 1
A B C D A’ pointer forwarding_address ToSpace FromSpace root
2 1
A B C D A’ ToSpace FromSpace root
2 1
A B C D A’ B’ B’
1 1
ToSpace FromSpace root
2 1
A B C D A’ B’
1
C’
. . .
. . .
ToSpace FromSpace root
2 1
A B C D A’ B’
1 2
C’ D’
ToSpace FromSpace root
2 1
A B C D A’ B’
1 2
C’ D’ copy(P) if P==NULL || P->is_atomic return P if !forwarded(P) { n = size(P) P’ = freeptr freeptr = freeptr+n fowarding_address(P) = P’ for (i = 0; i<n; i++) P’[i] = copy(P[i]); } return fowarding_address }
ToSpace FromSpace root
2 1
A B C D A’ B’
1 2
C’ D’ copy(P) if P==NULL || P->is_atomic return P if !forwarded(P) { n = size(P) P’ = freeptr freeptr = freeptr+n fowarding_address(P) = P’ for (i = 0; i<n; i++) P’[i] = copy(P[i]); } return fowarding_address }
ToSpace FromSpace root
2 1
A B C D A’ B’
1 2
C’ D’ copy(P) if P==NULL || P->is_atomic return P if !forwarded(P) { n = size(P) P’ = freeptr freeptr = freeptr+n fowarding_address(P) = P’ for (i = 0; i<n; i++) P’[i] = copy(P[i]); } return fowarding_address } ToSpace A’ B’
1
C’ Cheney's Algorithm (Breadth-First) Move roots, to ToSpace Scan from left to right moving objs in FromSpace to ToSpace (at end) and updating pointers root
n Have lead to its widespread adoption n Active data is compact (not fragmented as in mark-sweep)
n Handles variable-sized objects naturally n No overhead on pointer updates n Allocation is a simple free-space pointer increment n Fragmentation is eliminated
n Required address space is doubled compared with non-
n Touches every page (VM) of the heap regardless of
n Non-copying only n Imprecise / Not type-accurate
n Any thing that looks like a pointer is one
n Pointers that escape across these boundaries are not
n Principle of locality - programs access a relatively small
n GC should ensure that locality is exploited to improve
n Memory hierarchy was developed to exploit the natural
n Long-lived objects are hard to deal with n Young objects (recently allocated) die young
n Large heaps (that can’t be held in memory) degrade perf.
n Exploit the lifetime of objects to make GC and the program’s
n Generations
n Collected at different frequencies
n Using different algorithms on the different regions
n Machine dependent - depend on the speed of the machine n Alternative 1: Number of instructions executed - also
n Alternative 2: Number of bytes allocated in the heap
u In interactive systems, this can be dependent upon user behavior u Language and VM dependent
n Move object to older generation if its survives long enough
n This is where most of the recyclable space will be found n Make this region small so that its collection can be more
C B A S
root set young
C B A S
root set young
R
n Minor collections reclaim shortlived objects
C B A S
root set young
R
n Except perhaps for large or known-to-be-old objects
n Mark/sweep, copying, mark/compact, hybrid n Promotion is copying
n Each requiring collection of those lower/younger
C B A S
root set young
R A F
101
102
103
104
105
n Need to remember old-to-young references n Usually not too many – mutations to old objects are
n Need to remember old-to-young references n Usually not too many – mutations to old objects are
n We don’t need to worry about them if we always collect the
n Catching old-to-young pointers n Code that puts old-generation object into a remembered set
n Check all old objects to see if they point to a nursery object n Will negate any benefit we get from generational GC
n Proportional to the number of pointer stores
n Make old early - too much garbage sitting in OldSpace n Make old late - spend too much time copying objects back
n Pig in the snake problem
n Nursery objects copied upon first minor collection n Mature space(s)
n You should be able to state the cost of each type of GC
n Relatively longlived objects (together make up a large
n Will be copied repeatedly & until space for it is found n Increases traversal cost at every generation n Favors fast advancement of large object clusters
n More generations? n How big should they be? n How can we make things more efficient?
n Generational mark-sweep/compact n Eden: where objects are allocated via bump pointer
n To: half of nursery; From: half of nursery
n Mature space: Mark-sweep with region-based compaction
n Hybrid (region-based) collection: Immix n Partner with operating system: Mapping Collector