1 / 121

On-the-Fly Garbage Collection: An Exercise in Cooperation

On-the-Fly Garbage Collection: An Exercise in Cooperation. Edsget W. Dijkstra , Leslie Lamport , A.J. Martin and E.F.M. Steffens Communications of the ACM, 1978 Presented by Almog Benin 25/5/2014. Outline of talk. Introduction Problem formulation The first coarse-grained solution

nau
Download Presentation

On-the-Fly Garbage Collection: An Exercise in Cooperation

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. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. On-the-Fly Garbage Collection: An Exercise in Cooperation Edsget W. Dijkstra, Leslie Lamport, A.J. Martin and E.F.M. Steffens Communications of the ACM, 1978 Presented by Almog Benin 25/5/2014

  2. Outline of talk • Introduction • Problem formulation • The first coarse-grained solution • The second coarse-grained solution • The fine-grained solution • Related work • Conclusions • My own conclusions

  3. introduction

  4. Dynamic Memory • Operations: • Allocate (malloc) • Release (free) • The programmer is responsible for releasing the memory

  5. Garbage Collector (Mark & Sweep) 0 1 Root: • Responsible for determining which data is not in use (garbage) • Generally, consists of 2 phases: • Marking phase • Appending phase (Sweeping phase) 2 3 4 5 6 7 8 9 10 11 12 13 Free list: 14

  6. Garbage Collector – cont’ 0 1 Root: • Responsible for determining which data is not in use (garbage) • Generally, consists of 2 phases: • Marking phase • Appending phase(Sweeping phase) 2 3 4 5 6 7 8 9 10 11 12 13 Free list: 14

  7. Garbage Collector – cont’ 0 1 Root: • Responsible for determining which data is not in use (garbage) • Generally, consists of 2 phases: • Marking phase • Appending phase(Sweeping phase) 2 3 4 6 7 8 11 12 13 Free list: 14 5 9 10

  8. Motivation • Sequential garbage collection: • Suspend all threads • Execute garbage collection • Resume all threads • Thread suspension may not be suitable to some applications: • Real Time • User experience • Can we maintain the garbage collection in a separated thread?

  9. The Challenge - Why it’s a problem? 0 Root: • Node #2 is always reachable! • The collector observes nodes one at a time. 1 2 Free list: 3

  10. The Challenge - Why it’s a problem? 0 Root: • Node #2 is always reachable! • The collector observes nodes one at a time. 1 2 Free list: 3 The Program

  11. The Challenge - Why it’s a problem? 0 Root: • Node #2 is always reachable! • The collector observes nodes one at a time. 1 2 Free list: 3 The Program

  12. The Challenge - Why it’s a problem? 0 Root: • Node #2 is always reachable! • The collector observes nodes one at a time. 1 2 Free list: 3 Now the collector observes node #0 and its successors.

  13. The Challenge - Why it’s a problem? 0 Root: • Node #2 is always reachable! • The collector observes nodes one at a time. 1 2 Free list: 3 The Program

  14. The Challenge - Why it’s a problem? 0 Root: • Node #2 is always reachable! • The collector observes nodes one at a time. 1 2 Free list: 3 The Program

  15. The Challenge - Why it’s a problem? 0 Root: • Node #2 is always reachable! • The collector observes nodes one at a time. • The collector may not notice that node #2 is reachable! 1 2 Free list: 3 Now the collector observes node #1 and its successors.

  16. Concurrent Garbage Collector • Collecting the garbage concurrently to the computation proper. • Mutator thread • Collector thread • We set the following constraints: • Minimal synchronization • Minimal overhead for the mutator • Collect the garbage “regardless” of the mutator activity

  17. Granularity – The Grain of Action • We use <….> to denote an atomic operation. • Coarse-grained solution uses large atomic operations. • Fine-grained solution uses small atomic operations.

  18. Problem Formulation

  19. The Threads • Mutator thread(s) • Represents the computation proper. • Collector thread • Responsible of identifying and recycling the not-used memory.

  20. Memory Abstraction 0 1 Root: • Directed graph of constant nodes (but varying edges). • Each node represents a memory block. • Each node may have 2 outgoing edges (for the relation “point to”). 2 3 4 5 6 7 8 9 10 11 12 13 Free list: 14

  21. Memory Abstraction – cont’ 0 1 Root: • Root nodes – a fixed set of nodes that cannot be garbage. • Reachable node – a node that is reachable from at least one root node. • Data structure – the residual sub-graph of the reachable nodes. • Garbage nodes – nodes that are not reachable but are not in the free list. • Free list – a list of nodes found to be garbage. 2 3 4 5 6 7 8 9 10 11 12 13 Free list: 14

  22. Action Types 1: Redirects R->R. 2: Redirects R->NR. 3: Add R->R. 4: Add R->NR. 5:delete 0 1 Root: • Redirecting an outgoing edge of a reachable node towards an already reachable one. • Redirecting an outgoing edge of a reachable node towards a not yet reachable one without outgoing edges. 2 3 4 5 6 7 8 9 10 11 12 13 Free list: 14

  23. Action Types – cont’ 1: Redirects R->R. 2: Redirects R->NR. 3: Add R->R. 4: Add R->NR. 5:delete 0 1 Root: • Adding an edge pointing from a reachable node towards an already reachable one. • Adding an edge pointing from a reachable node towards a not yet reachable one without outgoing edges. • Removing an outgoing edge of a reachable node. 2 3 4 5 6 7 8 9 10 11 12 13 Free list: 14

  24. First Simplification 1: Redirects R->R. 2: Redirects R->NR. 3: Add R->R. 4: Add R->NR. 5:delete 0 1 NIL Root: • Use special root node called “NIL”. • Pointing to such node represents a missing edge. • Allows us to reduce the action types: • Action type 3 & 5 can be translated to type 1. • Action type 4 can be translated to type 2. 2 3 4 5 6 7 8 9 10 11 12 13 Free list: 14

  25. Second Simplification 1: Redirects R->R. 2: Redirects R->NR. 3: Add R->R. 4: Add R->NR. 5:delete 0 1 S NIL Root: • Introducing (some) special root nodes and linking to them NIL and all of the free nodes. • Making the nodes of the free list as part of the data structure. • Allows us to reduce the action types: • Action type 2 can be translated to two actions of type 1. 2 3 4 5 6 7 8 9 10 11 12 13 Free list: 14

  26. Second Simplification 1: Redirects R->R. 2: Redirects R->NR. 3: Add R->R. 4: Add R->NR. 5:delete 0 1 S NIL Root: • Introducing (some) special root nodes and linking to them NIL and all of the free nodes. • Making the nodes of the free list as part of the data structure. • Allows us to reduce the action types: • Action type 2 can be translated to two actions of type 1. 2 3 4 5 6 7 8 9 10 11 12 13 Free list: 14

  27. Second Simplification 1: Redirects R->R. 2: Redirects R->NR. 3: Add R->R. 4: Add R->NR. 5:delete 0 1 S NIL Root: • Introducing (some) special root nodes and linking to them NIL and all of the free nodes. • Making the nodes of the free list as part of the data structure. • Allows us to reduce the action types: • Action type 2 can be translated to two actions of type 1. 2 3 4 5 6 7 8 9 10 11 12 13 Free list: 14

  28. The Resulting Formulation • There are 2 thread types: • Mutator(s): • “Redirect an outgoing edge of a reachable node towards an already reachable one” (Action type 1) • Collector: • Marking phase: “Mark all reachable nodes” • Appending phase: “Append all unmarked nodes to the free list an clear the marking from all nodes” • For simplifying the description, we hide the new edges\nodes from the subsequent slides.

  29. Correctness Criteria • CC1: Every garbage node is eventually appended to the free list. • CC2: Appending a garbage node to the free list is the collector’s only modification of the shape of the data structure.

  30. The first coarse-grained solution

  31. Using Colors for marking • 2 Basic colors: • White: Not found to be reachable yet. • Black: Found to be reachable. • The monotonicity invariant “P1”: • “No edge points from a black node to a white one” • Need an intermediate color: • Gray

  32. The Mutator 0 1 Root: • The “Shade” operation on a node: • If the node is white, make it gray. • Otherwise (gray\black), leave it unchanged. • The mutator operation “M1”: • <Redirect an outgoing edge of a reachable node towards an already reachable one, and shade the new target> 2 3 4 5 6 7 8 9 10 11 12 13 Free list: 14

  33. The Mutator 0 1 Root: • The “Shade” operation on a node: • If the node is white, make it gray. • Otherwise (gray\black), leave it unchanged. • The mutator operation “M1”: • <Redirect an outgoing edge of a reachable node towards an already reachable one, and shade the new target> 2 3 4 5 6 7 8 9 10 11 12 13 Free list: 14

  34. The Collector: The Marking Phase is the nodes count in the graph 0 1 Root: • Shade all roots. • While • < color of node #> • If Gray then • “C1”: <Shade the successors of node # and make node # black> • Else Green simple atomic operations. We will try to break the red. 2 3 4 5 6 7 8 9 10 11 12 13 Free list: 14

  35. The Collector: The Marking Phase is the nodes count in the graph 0 1 Root: • Shade all roots. • While • < color of node #> • If Gray then • “C1”: <Shade the successors of node # and make node # black> • Else Green simple atomic operations. We will try to break the red. 2 3 4 5 6 7 8 9 10 11 12 13 Free list: 14

  36. The Collector: The Marking Phase is the nodes count in the graph 0 1 Root: • Shade all roots. • While • < color of node #> • If Gray then • “C1”: <Shade the successors of node # and make node # black> • Else Green simple atomic operations. We will try to break the red. 2 3 4 5 6 7 8 9 10 11 12 13 Free list: 14

  37. The Collector: The Marking Phase is the nodes count in the graph 0 1 Root: • Shade all roots. • While • < color of node #> • If Gray then • “C1”: <Shade the successors of node # and make node # black> • Else Green simple atomic operations. We will try to break the red. 2 3 4 5 6 7 8 9 10 11 12 13 Free list: 14

  38. The Collector: The Marking Phase is the nodes count in the graph 0 1 Root: • Shade all roots. • While • < color of node #> • If Gray then • “C1”: <Shade the successors of node # and make node # black> • Else Green simple atomic operations. We will try to break the red. 2 3 4 5 6 7 8 9 10 11 12 13 Free list: 14

  39. The Collector: The Marking Phase is the nodes count in the graph 0 1 Root: • Shade all roots. • While • < color of node #> • If Gray then • “C1”: <Shade the successors of node # and make node # black> • Else Green simple atomic operations. We will try to break the red. 2 3 4 5 6 7 8 9 10 11 12 13 Free list: 14

  40. The Collector: The Marking Phase is the nodes count in the graph 0 1 Root: • Shade all roots. • While • < color of node #> • If Gray then • “C1”: <Shade the successors of node # and make node # black> • Else Green simple atomic operations. We will try to break the red. 2 3 4 5 6 7 8 9 10 11 12 13 Free list: 14

  41. The Collector: The Marking Phase is the nodes count in the graph 0 1 Root: • Shade all roots. • While • < color of node #> • If Gray then • “C1”: <Shade the successors of node # and make node # black> • Else Green simple atomic operations. We will try to break the red. 2 3 4 14 5 6 7 8 9 10 11 12 13 Mutator interleaved! Free list:

  42. The Collector: The Marking Phase is the nodes count in the graph 0 1 Root: • Shade all roots. • While • < color of node #> • If Gray then • “C1”: <Shade the successors of node # and make node # black> • Else Green simple atomic operations. We will try to break the red. 2 3 4 14 5 6 7 8 9 10 11 12 13 Free list:

  43. The Collector: The Marking Phase is the nodes count in the graph 0 1 Root: • Shade all roots. • While • < color of node #> • If Gray then • “C1”: <Shade the successors of node # and make node # black> • Else Green simple atomic operations. We will try to break the red. 2 3 4 14 5 6 7 8 9 10 11 12 13 Free list:

  44. The Collector: The Marking Phase is the nodes count in the graph 0 1 Root: • Shade all roots. • While • < color of node #> • If Gray then • “C1”: <Shade the successors of node # and make node # black> • Else Green simple atomic operations. We will try to break the red. 2 3 4 14 5 6 7 8 9 10 11 12 13 Free list:

  45. The Collector: The Marking Phase is the nodes count in the graph 0 1 Root: • Shade all roots. • While • < color of node #> • If Gray then • “C1”: <Shade the successors of node # and make node # black> • Else Green simple atomic operations. We will try to break the red. 2 3 4 14 5 6 7 8 9 10 11 12 13 Free list:

  46. The Collector: The Marking Phase is the nodes count in the graph 0 1 Root: • Shade all roots. • While • < color of node #> • If Gray then • “C1”: <Shade the successors of node # and make node # black> • Else Green simple atomic operations. We will try to break the red. 2 3 4 14 5 6 7 8 9 10 11 12 13 Free list:

  47. The Collector: The Marking Phase is the nodes count in the graph 0 1 Root: • Shade all roots. • While • < color of node #> • If Gray then • “C1”: <Shade the successors of node # and make node # black> • Else Green simple atomic operations. We will try to break the red. 2 3 4 14 5 6 7 8 9 10 11 12 13 Free list:

  48. The Collector: The Marking Phase is the nodes count in the graph 0 1 Root: • Shade all roots. • While • < color of node #> • If Gray then • “C1”: <Shade the successors of node # and make node # black> • Else Green simple atomic operations. We will try to break the red. 2 3 4 14 5 6 7 8 9 10 11 12 13 Free list:

  49. The Collector: The Appending Phase 0 1 Root: • While • < color of node #> • If WHITE then • <Append node # to the free list> • Else if BLACK then • <make node # white> Green simple atomic operations. We will try to break the red. 2 3 4 14 5 6 7 8 9 10 11 12 13 Free list:

  50. The Collector: The Appending Phase 0 1 Root: • While • < color of node #> • If WHITE then • <Append node # to the free list> • Else if BLACK then • <make node # white> Green simple atomic operations. We will try to break the red. 2 3 4 14 5 6 7 8 9 10 11 12 13 Free list:

More Related