garbage collection introduction and overview
Download
Skip this Video
Download Presentation
Garbage Collection Introduction and Overview

Loading in 2 Seconds...

play fullscreen
1 / 61

Garbage Collection Introduction and Overview - PowerPoint PPT Presentation


  • 133 Views
  • Uploaded on

Garbage Collection Introduction and Overview. Christian Schulte Programming Systems Lab Universität des Saarlandes, Germany [email protected] Purpose of Talk. Explaining basic concepts terminology Garbage collection… …is simple …can be explained at a high-level Organization.

loader
I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.
capcha
Download Presentation

PowerPoint Slideshow about 'Garbage Collection Introduction and Overview' - jendayi


An Image/Link below is provided (as is) to download presentation

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.


- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript
garbage collection introduction and overview

Garbage Collection Introduction and Overview

Christian Schulte

Programming Systems Lab

Universität des Saarlandes, Germany

[email protected]

purpose of talk
Purpose of Talk
  • Explaining basic
      • concepts
      • terminology
  • Garbage collection…
      • …is simple
      • …can be explained at a high-level
  • Organization
purpose of talk1
Purpose of Talk
  • Explaining basic
      • concepts
      • terminology

(never to be explained again)

  • Garbage collection…
      • …is simple
      • …can be explained at a high-level
  • Organization
overview
Overview
  • What is garbage collection
      • objects of interest
      • principal notions
      • classic examples with assumptions and properties
  • Discussion
      • software engineering issues
      • typical cost
      • areas of usage
      • why knowledge is profitable
  • Organizational
      • Material
      • Requirements
overview1
Overview
  • What is garbage collection
      • objects of interest
      • principal notions
      • classic examples with assumptions and properties
  • Discussion
      • software engineering issues
      • typical cost
      • areas of usage
      • why knowledge is profitable
  • Organizational
      • Material
      • Requirements
garbage collection
Garbage Collection…

…is concerned with the automatic reclamation of dynamically allocated memory after its last use by a program

garbage collection1
Garbage Collection…
  • dynamically allocated memory

…is concerned with the automatic reclamation of dynamically allocated memory after its last use by a program

garbage collection2
Garbage Collection…
  • dynamically allocated memory
  • last use by a program

…is concerned with the automatic reclamation of dynamically allocated memory after its last use by a program

garbage collection3
Garbage Collection…
  • dynamically allocated memory
  • last use by a program
  • automatic reclamation

…is concerned with the automatic reclamation of dynamically allocated memory after its last use by a program

garbage collection4
Garbage collection…
  • Dynamically allocated memory
  • Last use by a program
  • Examples for automatic reclamation
kinds of memory allocation
Kinds of Memory Allocation

static int i;

void foo(void) {

int j;

int* p = (int*) malloc(…);

}

static allocation
Static Allocation
  • By compiler (in text area)
  • Available through entire runtime
  • Fixed size

static int i;

void foo(void) {

int j;

int* p = (int*) malloc(…);

}

automatic allocation
Automatic Allocation
  • Upon procedure call (on stack)
  • Available during execution of call
  • Fixed size

static int i;

void foo(void) {

int j;

int* p = (int*) malloc(…);

}

dynamic allocation
Dynamic Allocation
  • Dynamically allocated at runtime (on heap)
  • Available until explicitly deallocated
  • Dynamically varying size

static int i;

void foo(void) {

int j;

int* p = (int*) malloc(…);

}

dynamically allocated memory
Dynamically Allocated Memory
  • Also: heap-allocated memory
  • Allocation: malloc, new, …
    • before first usage
  • Deallocation: free, delete, dispose, …
    • after last usage
  • Needed for
    • C++, Java: objects
    • SML: datatypes, procedures
    • anything that outlives procedure call
getting it wrong
Getting it Wrong
  • Forget to free (memory leak)
    • program eventually runs out of memory
    • long running programs: OSs. servers, …
  • Free to early (dangling pointer)
    • lucky: illegal access detected by OS
    • horror: memory reused, in simultaneous use
      • programs can behave arbitrarily
      • crashes might happen much later
  • Estimates of effort
    • Up to 40%! [Rovner, 1985]
nodes and pointers

p

Nodes and Pointers
  • Node n
    • Memory block, cell
  • Pointer p
    • Link to node
    • Node access: *p
  • Children children(n)
    • set of pointers to nodes referred by n

n

mutator
Mutator
  • Abstraction of program
    • introduces new nodes with pointer
    • redirects pointers, creating garbage
shared nodes
Shared Nodes
  • Nodes referred to by several pointers
  • Makes manual deallocation hard
    • local decision impossible
    • respect other pointers to node
  • Cycles instance of sharing
garbage collection5
Garbage collection…
  • Dynamically allocated memory
  • Last use by a program
  • Examples for automatic reclamation
last use by a program
Last Use by a Program
  • Question: When is node M not any longer used by program?
    • Let P be any program not using M
    • New program sketch:

Execute P; Use M;

    • Hence:

M used  P terminates

    • We are doomed: halting problem!
  • So “last use” undecidable!
safe approximation
Safe Approximation
  • Decidable and also simple
  • What means safe?
    • only unused nodes freed
  • What means approximation?
    • some unused nodes might not be freed
  • Idea
    • nodes that can be accessed by mutator
reachable nodes
Reachable Nodes

root

  • Reachable from root set
    • processor registers
    • static variables
    • automatic variables (stack)
  • Reachable from reachable nodes
summary reachable nodes
Summary: Reachable Nodes
  • A node n is reachable, iff
    • n is element of the root set, or
    • n is element of children(m) and m is reachable
  • Reachable node also called “live”
mygarbagecollector
MyGarbageCollector
  • Compute set of reachable nodes
  • Free nodes known to be not reachable
  • Known as mark-sweep
    • in a second…
reachability safe approximation
Reachability: Safe Approximation
  • Safe
    • access to not reachable node impossible
    • depends on language semantics
    • but C/C++? later…
  • Approximation
    • reachable node might never be accessed
    • programmer must know about this!
    • have you been aware of this?
garbage collection6
Garbage collection…
  • Dynamically allocated memory
  • Last use by a program
  • Examples for automatic reclamation
example garbage collectors
Example Garbage Collectors
  • Mark-Sweep
  • Others
      • Mark-Compact
      • Reference Counting
      • Copying
    • skipped here
    • read Chapter 1&2 of [Lins&Jones,96]
the mark sweep collector
The Mark-Sweep Collector
  • Compute reachable nodes: Mark
    • tracing garbage collector
  • Free not reachable nodes: Sweep
  • Run when out of memory: Allocation
  • First used with LISP [McCarthy, 1960]
allocation
Allocation

node* new() {

if (free_pool is empty)

mark_sweep();

allocation1
Allocation

node* new() {

if (free_pool is empty)

mark_sweep();

return allocate();

}

the garbage collector
The Garbage Collector

void mark_sweep() {

for (r in roots)

mark(r);

the garbage collector1
The Garbage Collector

void mark_sweep() {

for (r in roots)

mark(r);

all live nodes marked

recursive marking
Recursive Marking

void mark(node* n) {

if (!is_marked(n)) {

set_mark(n);

}

}

recursive marking1
Recursive Marking

void mark(node* n) {

if (!is_marked(n)) {

set_mark(n);

}

}

nodes reachable from n marked

recursive marking2
Recursive Marking

void mark(node* n) {

if (!is_marked(n)) {

set_mark(n);

for (m in children(n))

mark(m);

}

}

i-th recursion: nodes on path with length i marked

the garbage collector2
The Garbage Collector

void mark_sweep() {

for (r in roots)

mark(r);

sweep();

the garbage collector3
The Garbage Collector

void mark_sweep() {

for (r in roots)

mark(r);

sweep();

all nodes on heap live

the garbage collector4
The Garbage Collector

void mark_sweep() {

for (r in roots)

mark(r);

sweep();

all nodes on heap live

and not marked

eager sweep
Eager Sweep

void sweep() {

node* n = heap_bottom;

while (n < heap_top) {

}

}

eager sweep1
Eager Sweep

void sweep() {

node* n = heap_bottom;

while (n < heap_top) {

if (is_marked(n)) clear_mark(n);

else free(n);

n += sizeof(*n);

}

}

the garbage collector5
The Garbage Collector

void mark_sweep() {

for (r in roots)

mark(r);

sweep();

if (free_pool is empty)

abort(“Memory exhausted”);

}

assumptions
Assumptions
  • Nodes can be marked
  • Size of nodes known
  • Heap contiguous
  • Memory for recursion available
  • Child fields known!
assumptions realistic
Assumptions: Realistic
  • Nodes can be marked
  • Size of nodes known
  • Heap contiguous
  • Memory for recursion available
  • Child fields known
assumptions conservative
Assumptions: Conservative
  • Nodes can be marked
  • Size of nodes known
  • Heap contiguous
  • Memory for recursion available
  • Child fields known
mark sweep properties
Mark-Sweep Properties
  • Covers cycles and sharing
  • Time depends on
    • live nodes (mark)
    • live and garbage nodes (sweep)
  • Computation must be stopped
    • non-interruptible stop/start collector
    • long pause
  • Nodes remain unchanged (as not moved)
  • Heap remains fragmented
implementation
Implementation
  • In your talk…
efficiency analysis
Efficiency Analysis
  • In your talk…
comparison
Comparison
  • In your talk…
application
Application
  • In your talk…
overview2
Overview
  • What is garbage collection
      • objects of interest
      • principal invariant
      • classic examples with assumptions and properties
  • Discussion
      • software engineering issues
      • typical cost
      • areas of usage
      • why knowledge is profitable
  • Organizational
      • Material
      • Requirements
software engineering issues
Software Engineering Issues
  • Design goal in SE:
      • decompose systems
      • in orthogonal components
  • Clashes with letting each component do its memory management
      • liveness is global property
      • leads to “local leaks”
      • lacking power of modern gc methods
typical cost
Typical Cost
  • Early systems (LISP)

up to 40% [Steele,75] [Gabriel,85]

      • “garbage collection is expensive” myth
  • Well engineered system of today

10% of entire runtime [Wilson, 94]

areas of usage
Areas of Usage
  • Programming languages and systems
    • Java, C#, Smalltalk, …
    • SML, Lisp, Scheme, Prolog, …
    • Modula 3, Microsoft .NET
  • Extensions
    • C, C++ (Conservative)
  • Other systems
    • Adobe Photoshop
    • Unix filesystem
    • Many others in [Wilson, 1996]
understanding garbage collection benefits
Understanding Garbage Collection: Benefits
  • Programming garbage collection
    • programming systems
    • operating systems
  • Understand systems with garbage collection (e.g. Java)
    • memory requirements of programs
    • performance aspects of programs
    • interfacing with garbage collection (finalization)
overview3
Overview
  • What is garbage collection
      • objects of interest
      • principal invariant
      • classic examples with assumptions and properties
  • Discussion
      • software engineering issues
      • typical cost
      • areas of usage
      • why knowledge is profitable
  • Organizational
      • Material
      • Requirements
material
Material
  • Garbage Collection. Richard Jones and Rafael Lins, John Wiley & Sons, 1996.
  • Uniprocessor garbage collection techniques. Paul R. Wilson, ACM Computing Surveys. To appear.
      • Extended version of IWMM 92, St. Malo.
organization
Organization
  • Requirements
    • Talk
      • duration 45 min (excluding discussion)
    • Attendance
      • including discussion
    • Written summary
      • 10 pages
      • to be submitted in PDF until Mar 31st, 2002
  • Schedule
      • weekly
      • starting Nov 14th, 2001
      • next on Dec 5th, 2001
topics for you
Topics For You!
  • The classical methods
      • Copying 1. [Brunklaus, Guido Tack]
      • Mark-Sweep 2. [Schulte, Hagen Böhm]
      • Mark-Compact 3. [Schulte, Jens Regenberg]
      • Reference Counting 6. [Brunklaus, Regis Newo]
  • Advanced
      • Generational 4. [Brunklaus, Mirko Jerrentrup]
      • Conservative (C/C++) 5. [Schulte, Stephan Lesch]
      • Incremental & Concurrent 7. [Brunklaus, Uwe Kern]
invariants
Invariants
  • Only nodes with rc zero are freed
  • RC always positive
ad