Concepts of programming languages Chapter 6 Data types Lec. 14 Lecturer: Dr. Emad Nabil

Problems with Pointers 1-Dangling pointers (dangerous) A pointer points to a heap-dynamic variable that has been deallocated 2- Lost heap-dynamic variable memory leakage dangling-pointer Solutions to the Dangling-Pointer Problem Tombstone: extra heap cell that is a pointer to the heap-dynamic variable Locks-and-keys: Pointer values are represented as (key, address) pairs No explicit deallocation of heap-dynamic variables out of the hands of programmers lost heap-dynamic

Heap Management

(eager approach): reclamation is gradual Heap Management A very complex run-time process Single-size cells vs. variable-size cells Two approaches to reclaim garbage reclaim garbage Single-size cells Reference counters (eager approach): reclamation is gradual Mark-sweep (lazy approach) reclamation occurs when the list of available space becomes empty

Reference Counter : Single-size cells Reference counters: maintain a counter in every cell that store the number of pointers currently pointing at the cell. Embedded in the decrement operation for the reference counters, which occurs when a pointer is disconnected from the cell, is a check for a zero value. If the reference counter reaches zero, it means that no program pointers are pointing at the cell, and it has thus become garbage and can be returned to the list of available space. Disadvantages: space required, execution time required. Advantage: efficiency- it is pure incremental, so significant delays in the application execution are avoided

1-Reference Counter : count char * p1 = new char (111); char * p2=p1; 2 111 P1 Dynamic heap variable P2 count 1 222 P1 P1= new char (222); count 1 111 P2 count 1 222 P1 count 1 333 P2= new char (333); P2 count Will be moved to avail_List 0 111

1- Reference Counter : count 2 111 char * p1 = new char (111); P1 char * p2=p1; 2 111 P1 Dynamic heap variable P2 count 0 111 P1 Dynamic heap variable delete p1; P2 Will be moved to avail_List If the reference counter reaches zero, it means that no program pointers are pointing at the cell, and it has thus become garbage and can be returned to the list of available space.

1-Reference Counter // STEP 1 Object a = new Integer (100); Object b = new Integer (99); // Step2 a=b; Possible implementation for reference counter code for a=b; is if (a != b) { if (a != null) if (--a.refCount == 0) heap.release (a); a = b; ++a.refCount; } if (a != b) { if (a != null) --a.refCount; a = b; ++a.refCount; } 

1-Reference Counter – problem public void buidDog() { Dog newDog = new Dog(); Tail newTail = new Tail(); newDog.tail = newTail; newTail.dog = newDog; } Main() { … buidDog(); …. After completing execution of buildDog method the heap will be like this Reference counting does not detect garbage with cyclic references. One of the solution is to use mark and sweep alg.

1-Reference Counter – problem Reference Counting fails to reclaim circular structures Python uses reference counting and offers cycle detection as well.

(eager approach): reclamation is gradual Heap Management reclaim garbage Reference counters (eager approach): reclamation is gradual Mark-sweep (lazy approach) reclamation occurs when the list of available space becomes empty

2-Mark-And-Sweep (Garbage Collection Algorithm) The mark-and-sweep algorithm is called a tracing garbage collector because is traces out the entire collection of objects that are directly or indirectly accessible by the program. The mark-and-sweep algorithm is divided into two phases: Mark phase:  The garbage collector traverses the graph of references from the root nodes and marks each heap object it encounters. Each object has an extra bit: the mark bit – initially the mark bit is 0. It is set to 1 for the reachable objects in the mark phase. Sweep phase: The GC exhaustively 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 of objects that can be reallocated. The objects with a mark bit 1 have their mark bit reset to 0.

2-Mark-And-Sweep (Garbage Collection Algorithm)

In java : GC roots are objects that are themselves referenced by the JVM and thus keep every other object from being garbage-collected.

Once all live objects are marked, memory is exhaustively examined to find all of the unmarked (garbage) objects and reclaim their space

2-The Mark-And-Sweep algorithm can be expressed as follows: for each root variable a mark (a); sweep ();  disadvantage: The program must be halted while garbage collection is being performed. void mark (Object a) if (!a.marked) a.marked = true; for each Object b referenced by a mark (b); void sweep () for each Object a in the heap if (a.marked) a.marked = false else heap.release (a); Once all live objects are marked, memory is exhaustively examined to find all of the unmarked (garbage) objects and reclaim their space

Mark-Sweep: Single-size cells The run-time system allocates storage cells as requested and disconnects pointers from cells as necessary; mark-sweep then begins Every heap cell has an extra bit used by collection algorithm All cells initially set to garbage All pointers traced into heap, and reachable cells marked as not garbage All garbage cells returned to list of available cells Disadvantages: in its original form, it was done too infrequently. When done, it caused significant delays in application execution. Modern mark-sweep algorithms avoid this by doing it more often—called incremental mark-sweep Reading slide

Heap Management variable size cells reclaim garbage variable size cells Mark-sweep (lazy approach) reclamation occurs when the list of variable space becomes empty

Variable-Size Cells Required by most programming languages (different data types and structured data types) In case of fixed size cells, we know the size of the garbage, but in case of the variable cell size(ex: char vs double).. How do we know the size of the cell to be reclaimed.. -Solution: each cell have a field to indicate its size. 2. cells with no pointers. How can you follow a chain? Solution: adding internal pointers to every cell. 3. maintaining a list of available space. (how to choose a slot for an object) Solution: sorting the list according to block size, Ascending. Marked (0|1)? Cell size Cell data pointer