CS 536 Spring 20011 Automatic Memory Management Lecture 24.

Slides:



Advertisements
Similar presentations
Garbage collection David Walker CS 320. Where are we? Last time: A survey of common garbage collection techniques –Manual memory management –Reference.
Advertisements

Dynamic Memory Management
Introduction to Memory Management. 2 General Structure of Run-Time Memory.
CMSC 330: Organization of Programming Languages Memory and Garbage Collection.
Lecture 10: Heap Management CS 540 GMU Spring 2009.
Garbage Collection What is garbage and how can we deal with it?
CMSC 330: Organization of Programming Languages Memory and Garbage Collection.
CSC 213 – Large Scale Programming. Today’s Goals  Consider what new does & how Java works  What are traditional means of managing memory?  Why did.
Garbage Collection Introduction and Overview Christian Schulte Excerpted from presentation by Christian Schulte Programming Systems Lab Universität des.
Prof. Necula CS 164 Lecture 141 Run-time Environments Lecture 8.
Garbage Collection  records not reachable  reclaim to allow reuse  performed by runtime system (support programs linked with the compiled code) (support.
Run-time organization  Data representation  Storage organization: –stack –heap –garbage collection Programming Languages 3 © 2012 David A Watt,
Garbage Collection CSCI 2720 Spring Static vs. Dynamic Allocation Early versions of Fortran –All memory was static C –Mix of static and dynamic.
CS 326 Programming Languages, Concepts and Implementation Instructor: Mircea Nicolescu Lecture 18.
CPSC 388 – Compiler Design and Construction
Ceg860 (Prasad)L9GC1 Memory Management Garbage Collection.
Mark and Sweep Algorithm Reference Counting Memory Related PitFalls
An Efficient Machine-Independent Procedure for Garbage Collection in Various List Structures, Schorr and Waite CACM August 1967, pp Curtis Dunham.
Chapter 8 Runtime Support. How program structures are implemented in a computer memory? The evolution of programming language design has led to the creation.
Memory Management. History Run-time management of dynamic memory is a necessary activity for modern programming languages Lisp of the 1960’s was one of.
CS 1114: Data Structures – memory allocation Prof. Graeme Bailey (notes modified from Noah Snavely, Spring 2009)
CS 61C L07 More Memory Management (1) Garcia, Fall 2004 © UCB Lecturer PSOE Dan Garcia inst.eecs.berkeley.edu/~cs61c CS61C.
Adapted from Prof. Necula CS 169, Berkeley1 Memory Management and Debugging V Software Engineering Lecture 20.
Memory Allocation. Three kinds of memory Fixed memory Stack memory Heap memory.
CS 536 Spring Run-time organization Lecture 19.
CS510 Advanced OS Seminar Class 10 A Methodology for Implementing Highly Concurrent Data Objects by Maurice Herlihy.
Runtime The optimized program is ready to run … What sorts of facilities are available at runtime.
Run time vs. Compile time
Memory Allocation and Garbage Collection. Why Dynamic Memory? We cannot know memory requirements in advance when the program is written. We cannot know.
Age-Oriented Concurrent Garbage Collection Harel Paz, Erez Petrank – Technion, Israel Steve Blackburn – ANU, Australia April 05 Compiler Construction Scotland.
Garbage collection (& Midterm Topics) David Walker COS 320.
Linked lists and memory allocation Prof. Noah Snavely CS1114
Reference Counters Associate a counter with each heap item Whenever a heap item is created, such as by a new or malloc instruction, initialize the counter.
CS61C L07 More Memory Management (1) Garcia, Spring 2008 © UCB Lecturer SOE Dan Garcia inst.eecs.berkeley.edu/~cs61c CS61C.
SEG Advanced Software Design and Reengineering TOPIC L Garbage Collection Algorithms.
CS3012: Formal Languages and Compilers The Runtime Environment After the analysis phases are complete, the compiler must generate executable code. The.
Dynamic Memory Allocation Questions answered in this lecture: When is a stack appropriate? When is a heap? What are best-fit, first-fit, worst-fit, and.
Storage Management. The stack and the heap Dynamic storage allocation refers to allocating space for variables at run time Most modern languages support.
Runtime Environments. Support of Execution  Activation Tree  Control Stack  Scope  Binding of Names –Data object (values in storage) –Environment.
1 Lecture 22 Garbage Collection Mark and Sweep, Stop and Copy, Reference Counting Ras Bodik Shaon Barman Thibaud Hottelier Hack Your Language! CS164: Introduction.
1 Dynamic Memory Allocation –The need –malloc/free –Memory Leaks –Dangling Pointers and Garbage Collection Today’s Material.
11/26/2015IT 3271 Memory Management (Ch 14) n Dynamic memory allocation Language systems provide an important hidden player: Runtime memory manager – Activation.
1 Languages and Compilers (SProg og Oversættere) Heap allocation and Garbage Collection.
Garbage Collection and Memory Management CS 480/680 – Comparative Languages.
University of Washington Wouldn’t it be nice… If we never had to free memory? Do you free objects in Java? 1.
Runtime The optimized program is ready to run … What sorts of facilities are available at runtime.
2/4/20161 GC16/3011 Functional Programming Lecture 20 Garbage Collection Techniques.
CS61C L07 More Memory Management (1) Garcia, Spring 2010 © UCB Lecturer SOE Dan Garcia inst.eecs.berkeley.edu/~cs61c CS61C.
CS412/413 Introduction to Compilers and Translators April 21, 1999 Lecture 30: Garbage collection.
Runtime Environments Chapter 7. Support of Execution  Activation Tree  Control Stack  Scope  Binding of Names –Data object (values in storage) –Environment.
GARBAGE COLLECTION Student: Jack Chang. Introduction Manual memory management Memory bugs Automatic memory management We know... A program can only use.
CSC 533: Programming Languages Spring 2016
Garbage Collection What is garbage and how can we deal with it?
CSC 533: Programming Languages Spring 2015
Storage 18-May-18.
Inst.eecs.berkeley.edu/~cs61c CS61C : Machine Structures Lecture 7 – More Memory Management Lecturer PSOE Dan Garcia
Dynamic Memory Allocation
Storage Management.
Run-time organization
Concepts of programming languages
Automatic Memory Management
Memory Management and Garbage Collection Hal Perkins Autumn 2011
Strategies for automatic memory management
Chapter 12 Memory Management
Lecturer PSOE Dan Garcia
CS703 - Advanced Operating Systems
Garbage collection Programming Language Design and Implementation (4th Edition) by T. Pratt and M. Zelkowitz Prentice Hall, 2001 Section
Inst.eecs.berkeley.edu/~cs61c CS61C : Machine Structures Lecture 7 – More Memory Management Lecturer PSOE Dan Garcia
CSC 533: Programming Languages Spring 2019
Garbage Collection What is garbage and how can we deal with it?
Presentation transcript:

CS 536 Spring Automatic Memory Management Lecture 24

CS 536 Spring Lecture Outline Why Automatic Memory Management? Garbage Collection Three Techniques –Mark and Sweep –Stop and Copy –Reference Counting Reading: Appel, Sections 13.1 – 13.3

CS 536 Spring Manual vs. Automatic Memory Management Manual: –C: malloc()… free() –C++: new… delete Automatic: –Java: new… (hidden) garbage collector

CS 536 Spring Why Automatic Memory Management? Storage management is still a hard problem in modern programming C and C++ programs have many storage bugs –forgetting to free unused memory –dereferencing a dangling pointer –overwriting parts of a data structure by accident –and so on... Storage bugs are hard to find –a bug can lead to a visible effect far away in time and program text from the source

CS 536 Spring Type Safety and Memory Management Some storage bugs can be prevented in a strongly typed language –e.g., you cannot overrun the array limits –e.g., you cannot assign a pointer to Int to a pointer to String Can types prevent errors in programs with manual allocation and deallocation of memory? –No practical solutions exist (it’s hard for the compiler to tell if you are going to use the object that you are freeing). If you want type safety then you must use automatic memory management

CS 536 Spring Automatic Memory Management This is an old problem: –studied since the 1950s for LISP There are several well-known techniques for performing completely automatic memory management Until recently they were unpopular outside the Lisp family of languages –just like type safety used to be unpopular

CS 536 Spring The Basic Idea When an object that takes memory space is created, unused space is automatically allocated –In Java, new objects are created by new X After a while there is no more unused space Some space is occupied by objects that will never be used again This space can be freed to be reused later

CS 536 Spring The Basic Idea (Cont.) How can we tell whether an object will “never be used again”? –in general it is impossible to tell –we will have to use a heuristic to find many (not all) objects that will never be used again Observation: a program can use only the objects that it can find: A x = new A; x = y; –After x = y there is no way to access the newly allocated object

CS 536 Spring Garbage An object x is reachable if and only if: –a register contains a pointer to x, or –another reachable object y contains a pointer to x You can find all reachable objects by starting from registers and following all the pointers An unreachable object can never by referred by the program –these objects are called garbage

CS 536 Spring Tracing Reachable Values in Simple In Simple, the only register is the accumulator –it points to an object –and this object may point to other objects, etc. The stack is more complex –each stack frame contains pointers e.g., method parameters –each stack frame also contains non-pointers e.g., return address –if we know the layout of the frame we can find the pointers in it

CS 536 Spring An Example In Simple we start tracing from acc and stack –they are called the roots Note that B and D are not reachable from acc or the stack Thus we can reuse their storage A BC Frame 1 Frame 2 DEacc SP

CS 536 Spring Elements of Garbage Collection Every garbage collection scheme has the following steps 1.Allocate space as needed for new objects 2.When space runs out: a)Compute what objects might be used again (generally by tracing objects reachable from a set of “root” registers) b)Free the space used by objects not found in (a) Some strategies perform garbage collection before the space actually runs out

CS 536 Spring Mark and Sweep When memory runs out, GC executes two phases –the mark phase: traces reachable objects –the sweep phase: collects garbage objects Every object has an extra bit: the mark bit –reserved for memory management –initially the mark bit is 0 –set to 1 for the reachable objects in the mark phase

CS 536 Spring The Mark Phase let todo = { all roots } while todo   do pick v  todo todo  todo - { v } if mark(v) = 0 then (* v is unmarked yet *) mark(v)  1 let v 1,...,v n be the pointers contained in v todo  todo  {v 1,...,v n } fi od

CS 536 Spring The Sweep Phase The sweep phase scans the heap looking for objects with mark bit 0 –these objects have not been visited in the mark phase –they are garbage Any such object is added to the free list The objects with a mark bit 1 have their mark bit reset to 0

CS 536 Spring The Sweep Phase (Cont.) (* sizeof(p) is the size of block starting at p *) p  bottom of heap while p < top of heap do if mark(p) = 1 then mark(p)  0 else add block p...(p+sizeof(p)-1) to freelist fi p  p + sizeof(p) od

CS 536 Spring Mark and Sweep Example A BCDFrootE free A BCDFrootE free After mark: A BCDFrootE free After sweep:

CS 536 Spring Details While conceptually simple, this algorithm has a number of tricky details –this is typical of GC algorithms A serious problem with the mark phase –it is invoked when we are out of space –yet it needs space to construct the todo list –the size of the todo list is unbounded so we cannot reserve space for it a priori

CS 536 Spring Mark and Sweep: Details The todo list is used as an auxiliary data structure to perform the reachability analysis There is a trick that allows the auxiliary data to be stored in the objects themselves –pointer reversal: when a pointer is followed it is reversed to point to its parent (See Algorithm 13.5 in Appel) Similarly, the free list is stored in the free objects themselves

CS 536 Spring Mark and Sweep. Evaluation Space for a new object is allocated from the new list –a block large enough is picked –an area of the necessary size is allocated from it –the left-over is put back in the free list Mark and sweep can fragment the memory Advantage: objects are not moved during GC –no need to update the pointers to objects –works for languages like C and C++

CS 536 Spring Another Technique: Stop and Copy Memory is organized into two areas –old space: used for allocation –new space: used as a reserve for GC old spacenew space heap pointer The heap pointer points to the next free word in the old space allocation just advances the heap pointer

CS 536 Spring Stop and Copy Garbage Collection Starts when the old space is full Copies all reachable objects from old space into new space –garbage is left behind –after the copy phase the new space uses less space than the old one before the collection After the copy the roles of the old and new spaces are reversed and the program resumes

CS 536 Spring Stop and Copy Garbage Collection. Example A BCDFrootE Before collection: new space ACF root new space After collection: free heap pointer

CS 536 Spring Implementation of Stop and Copy We need to find all the reachable objects, as for mark and sweep As we find a reachable object we copy it into the new space –And we have to fix ALL pointers pointing to it! As we copy an object we store in the old copy a forwarding pointer to the new copy –when we later reach an object with a forwarding pointer we know it was already copied

CS 536 Spring Implementation of Stop and Copy (Cont.) We still have the issue of how to implement the traversal without using extra space The following trick solves the problem: –partition the new space in three contiguous regions copied and scanned scan copied objects whose pointer fields were followed copied objects whose pointer fields were NOT followed empty copied allocstart

CS 536 Spring Stop and Copy. Example (1) A BCDFrootEnew space Before garbage collection

CS 536 Spring Stop and Copy. Example (3) A BCDFroot E Step 1: Copy the objects pointed by roots and set forwarding pointers A scan alloc

CS 536 Spring Stop and Copy. Example (3) A BCDFroot E Step 2: Follow the pointer in the next unscanned object (A) –copy the pointed objects (just C in this case) –fix the pointer in A –set forwarding pointer A scan alloc C

CS 536 Spring Stop and Copy. Example (4) A BCDFroot E Follow the pointer in the next unscanned object (C) –copy the pointed objects (F in this case) A scan alloc CF

CS 536 Spring Stop and Copy. Example (5) A BCDFroot E Follow the pointer in the next unscanned object (F) –the pointed object (A) was already copied. Set the pointer same as the forwading pointer A scan alloc CF

CS 536 Spring Stop and Copy. Example (6) root Since scan caught up with alloc we are done Swap the role of the spaces and resume the program A scan alloc CFnew space

CS 536 Spring The Stop and Copy Algorithm while scan <> alloc do let O be the object at scan pointer for each pointer p contained in O do find O’ that p points to if O’ is without a forwarding pointer copy O’ to new space (update alloc pointer) set 1st word of old O’ to point to the new copy change p to point to the new copy of O’ else set p in O equal to the forwarding pointer fi end for increment scan pointer to the next object od

CS 536 Spring Stop and Copy. Details. As with mark and sweep, we must be able to tell how large is an object when we scan it –and we must also know where are the pointers inside the object We must also copy any objects pointed to by the stack and update pointers in the stack –this can be an expensive operation

CS 536 Spring Stop and Copy. Evaluation Stop and copy is generally believed to be the fastest GC technique Allocation is very cheap –just increment the heap pointer Collection is relatively cheap –especially if there is a lot of garbage –only touch reachable objects But some languages do not allow copying (C, C++)

CS 536 Spring Why Doesn’t C Allow Copying? Garbage collection relies on being able to find all reachable objects –and it needs to find all pointers in an object In C or C++ it is impossible to identify the contents of objects in memory –E.g., how can you tell that a sequence of two memory words is a list cell (with data and next fields) or a binary tree node (with a left and right fields)? –Thus we cannot tell where all the pointers are

CS 536 Spring Conservative Garbage Collection But it is Ok to be conservative: –if a memory word looks like a pointer it is considered a pointer it must be aligned it must point to a valid address in the data segment –all such pointers are followed and we overestimate the reachable objects But we still cannot move objects because we cannot update pointers to them –what if what we thought to be a pointer is actually an account number?

CS 536 Spring Reference Counting Rather that wait for memory to be exhausted, try to collect an object when there are no more pointers to it Store in each object the number of pointers to that object –this is the reference count Each assignment operation has to manipulate the reference count

CS 536 Spring Implementation of Reference Counting new returns an object with a reference count of 1 If x points to an object then let rc(x) point to its reference count Every assignment x = y must be changed: rc(y)  rc(y) + 1 rc(x)  rc(x) - 1 if(rc(x) == 0) then mark x as free x  y

CS 536 Spring Reference Counting. Evaluation Advantages: –easy to implement –collects garbage incrementally without large pauses in the execution Disadvantages: –cannot collect circular structures –manipulating reference counts at each assignment is very slow

CS 536 Spring Garbage Collection. Evaluation Automatic memory management avoids some serious storage bugs But it takes away control from the programmer –e.g., layout of data in memory –e.g., when is memory deallocated Most garbage collection implementation stop the execution during collection –not acceptable in real-time applications

CS 536 Spring Garbage Collection. Evaluation Garbage collection is going to be around for a while Researchers are working on advanced garbage collection algorithms: –concurrent: allow the program to run while the collection is happening –generational: do not scan long-lived objects at every collection –parallel: several collectors working in parallel