Scribd Logo
Upload

Welcome to Scribd!

  • 17 views

    Garbage Collection Algorithms: by Achinth Anand Gurkhi

    Uploaded by

    Rahul Sheikh
    The document discusses different garbage collection algorithms. It describes reference counting, mark-sweep collection, copying collection, mark-compact collection, and generational collection. Reference counting uses reference counts to determine when to collect objects but cannot handle cyclic references. Mark-sweep and copying algorithms stop all threads to mark reachable objects before collecting. Mark-compact additionally compacts objects after collection. Generational collection uses different algorithms like copying for young objects and mark-compact for old objects to more efficiently collect the majority of short-lived objects.

    Copyright:

    © All Rights Reserved
    Download as PDF, TXT or read online from Scribd
    Flag for inappropriate content

    You might also like

    Garbage Collection Algorithms: by Achinth Anand Gurkhi

    Uploaded by

    Rahul Sheikh
    17 views14 pages
    The document discusses different garbage collection algorithms. It describes reference counting, mark-sweep collection, copying collection, mark-compact collection, and generational collection. Reference counting uses reference counts to determine when to collect objects but cannot handle cyclic references. Mark-sweep and copying algorithms stop all threads to mark reachable objects before collecting. Mark-compact additionally compacts objects after collection. Generational collection uses different algorithms like copying for young objects and mark-compact for old objects to more efficiently collect the majority of short-lived objects.

    Original Description:

    Original Title

    garbagecollectionalgorithms-110218175721-phpapp01

    Copyright

    © © All Rights Reserved

    Available Formats

    PDF, TXT or read online from Scribd

    Did you find this document useful?

    Is this content inappropriate?

    Report this Document
    The document discusses different garbage collection algorithms. It describes reference counting, mark-sweep collection, copying collection, mark-compact collection, and generational collection. Reference counting uses reference counts to determine when to collect objects but cannot handle cyclic references. Mark-sweep and copying algorithms stop all threads to mark reachable objects before collecting. Mark-compact additionally compacts objects after collection. Generational collection uses different algorithms like copying for young objects and mark-compact for old objects to more efficiently collect the majority of short-lived objects.

    Copyright:

    © All Rights Reserved
    Download as PDF, TXT or read online from Scribd
    Flag for inappropriate content
    Download as pdf or txt
    17 views14 pages

    Garbage Collection Algorithms: by Achinth Anand Gurkhi

    Uploaded by

    Rahul Sheikh
    The document discusses different garbage collection algorithms. It describes reference counting, mark-sweep collection, copying collection, mark-compact collection, and generational collection. Reference counting uses reference counts to determine when to collect objects but cannot handle cyclic references. Mark-sweep and copying algorithms stop all threads to mark reachable objects before collecting. Mark-compact additionally compacts objects after collection. Generational collection uses different algorithms like copying for young objects and mark-compact for old objects to more efficiently collect the majority of short-lived objects.

    Copyright:

    © All Rights Reserved
    Download as PDF, TXT or read online from Scribd
    Flag for inappropriate content
    Download as pdf or txt
    of 14

    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

    You might also like