Garbage collection algorithms

Garbage Collection Algorithms
By Achinth Anand Gurkhi

What is Garbage Collection?
Garbage Collection is the process by which unused objects are deleted to reclaim memory space
Invented by John McCarthy around 1959 to solve problems in Lisp
It is used in Lisp, Smalltalk, Eiffel, Haskell, ML, Schema, Modula-3, Java and .NET

GC Algorithms
Reference Counting
Mark-Sweep Collector
Copying Collector
Mark-Compact Collector
Generational Collector

Reference Counting
Needs help from compiler and the program to maintain a reference count
Compiler adds code to increment/decrement reference count when the object is referenced/dereferenced
If reference count is zero it is garbage collected and reference count of all objects it references is decremented by one
Used by ANSI C++ library classes like string

Reference Counting
Advantages:
Garbage collection can be immediate
Disadvantages:
Cannot handle cyclic references
Need extra memory for the reference counter
Incrementing and decrementing reference counts every time a reference is created or destroyed can significantly impede performance. Example: array processing

All application threads are stopped
Mark: from the roots (objects referenced directly) every referenced object is visited and marked
Sweep: entire heap is scanned and all unmarked objects are collected. Next all marked objects are reset

Advantages:
Can handle cyclic references
No burden on the compiler or the application
Disadvantages
As entire heap is scanned, pauses would be longer
If heap is paged can have performance issues
Causes heap fragmentation which could lead of out of memory errors

Copying Collector
The heap is divided into two equal spaces
One contains active data and the other is inactive
When the active half gets full, the world is stopped, live objects are moved to the inactive half and then the active half is cleared
For the next cycle, roles are reversed, the inactive half becomes the active half

Copying Collector
Advantages:
Only live objects are visited, garbage objects are not visited
Data compaction is achieved which reduces cost of object allocation and out of memory errors
Disadvantages:
Requires twice the heap size than other collectors
Overhead of copying objects from one space to another
Overhead of adjusting all references to the new copy
Long lived objects are copied back and forth on every collection

All application threads are stopped
Mark: from the roots (objects referenced directly) every referenced object is visited and marked
Compact: entire heap is scanned and all unmarked objects are collected. Next all marked objects compacted at the bottom of the heap and then the flags are reset

Advantages:
Compaction is achieved
Without the hassle of long lived objects being copied back and forth
Without the need for double the heap size
Disadvantages
Overhead of copying objects (for compaction)

98% of the objects die young
Copying Collectors perform well with short-lived objects
Mark-Compact Collectors perform well with long-lived objects
Can we use different GC algorithms based on object’s age?

The heap is divided into generations (usually 2 or 3)
Objects are created in the young generation (gen 0)
When memory is needed, a GC of gen 0 is performed & live objects are moved to the next generation (gen 1) & dead objects are collected (Copying Collector). If enough memory is now available GC is stopped
Else the next older generation (gen 1) is collected. This goes on till enough memory is released or till the last (oldest) generation is reached.
The last generation (old objects) uses Mark-Compact Collector algorithm

Advantages:
GC cycles are small as all objects are not collected
Only old objects are copied from one generation to another
Entire heap is not scanned
Disadvantages
Overhead of copying objects (for compaction)

Garbage collection algorithms

by achinth

Accessibility

Categories

Upload Details

Usage Rights

Statistics

Garbage collection algorithms Presentation Transcript