Garbage collection algorithms
Upcoming SlideShare
Loading in...5
×
 

Garbage collection algorithms

on

  • 6,178 views

Presentation about various algorithms used for automatic garbage collection.

Presentation about various algorithms used for automatic garbage collection.

Statistics

Views

Total Views
6,178
Views on SlideShare
6,176
Embed Views
2

Actions

Likes
5
Downloads
178
Comments
0

2 Embeds 2

http://www.linkedin.com 1
https://www.linkedin.com 1

Accessibility

Categories

Upload Details

Uploaded via as Microsoft PowerPoint

Usage Rights

© All Rights Reserved

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Processing…
Post Comment
Edit your comment

Garbage collection algorithms Garbage collection algorithms Presentation Transcript

  • 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
  • Mark-Sweep Collector
    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
  • Mark-Sweep Collector
    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
  • Mark-Compact Collector
    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
  • Mark-Compact Collector
    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)
    Overhead of adjusting all references to the new copy
  • Generational Collector
    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?
  • Generational Collector
    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
  • Generational Collector
    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)
    Overhead of adjusting all references to the new copy