on the fly garbage collection an exercise in cooperation
play

On-the-Fly Garbage Collection: An Exercise in Cooperation Edsget W. - PowerPoint PPT Presentation

May 01, 2023 β€’324 likes β€’1.55k views

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

  1. The Collector: The Marking Phase 0 1 Root: 1. Shade all roots. 𝑁 is the 𝑗 ← 0 2. nodes count 3. 𝑙 ← 𝑁 in the graph 2 3 4 While 𝑙 > 0 4. 1. < 𝑑 ← color of node # 𝑗 > 5 6 7 2. If 𝑑 == Gray then 1. β€œC1”: <Shade the successors of node # 𝑗 and make node # 𝑗 black> 8 9 10 3. Else 1. 𝑙 ← 𝑙 βˆ’ 1 𝑗 ← 𝑗 + 1 %𝑁 4. 11 12 13 Green simple atomic operations. We will try to break the red. Free list: 14

  2. The Collector: The Marking Phase 0 1 Root: 1. Shade all roots. 𝑁 is the 𝑗 ← 0 2. nodes count 3. 𝑙 ← 𝑁 in the graph 2 3 4 While 𝒍 > 𝟏 4. 1. < 𝒅 ← color of node # 𝒋 > 5 6 7 2. If 𝒅 == Gray then 1. β€œC1”: <Shade the successors of node # 𝒋 and make node # 𝒋 black> 8 9 10 3. Else 1. 𝒍 ← 𝒍 βˆ’ 𝟐 𝒋 ← 𝒋 + 𝟐 %𝑡 4. 11 12 13 Green simple atomic operations. We will try to break the red. Free list: 14

  3. The Collector: The Marking Phase 0 1 Root: 1. Shade all roots. 𝑁 is the 𝑗 ← 0 2. nodes count 3. 𝑙 ← 𝑁 in the graph 2 3 4 While 𝒍 > 𝟏 4. 1. < 𝒅 ← color of node # 𝒋 > 5 6 7 2. If 𝒅 == Gray then 1. β€œC1”: <Shade the successors of node # 𝒋 and make node # 𝒋 black> 8 9 10 3. Else 1. 𝒍 ← 𝒍 βˆ’ 𝟐 𝒋 ← 𝒋 + 𝟐 %𝑡 4. 11 12 13 Green simple atomic operations. We will try to break the red. Free list: 14

  4. The Collector: The Marking Phase 0 1 Root: 1. Shade all roots. 𝑁 is the 𝑗 ← 0 2. nodes count 3. 𝑙 ← 𝑁 in the graph 2 3 4 While 𝒍 > 𝟏 4. 1. < 𝒅 ← color of node # 𝒋 > 5 6 7 2. If 𝒅 == Gray then 1. β€œC1”: <Shade the successors of node # 𝒋 and make node # 𝒋 black> 8 9 10 3. Else 1. 𝒍 ← 𝒍 βˆ’ 𝟐 𝒋 ← 𝒋 + 𝟐 %𝑡 4. 11 12 13 Green simple atomic operations. We will try to break the red. Free list: 14

  5. The Collector: The Marking Phase 0 1 Root: 1. Shade all roots. 𝑁 is the 𝑗 ← 0 2. nodes count 3. 𝑙 ← 𝑁 in the graph 2 3 4 While 𝒍 > 𝟏 4. 1. < 𝒅 ← color of node # 𝒋 > 5 6 7 2. If 𝒅 == Gray then 1. β€œC1”: <Shade the successors of node # 𝒋 and make node # 𝒋 black> 8 9 10 3. Else 1. 𝒍 ← 𝒍 βˆ’ 𝟐 𝒋 ← 𝒋 + 𝟐 %𝑡 4. 11 12 13 Green simple atomic operations. We will try to break the red. Free list: 14

  6. The Collector: The Marking Phase 0 1 Root: 1. Shade all roots. 𝑁 is the 𝑗 ← 0 2. nodes count 3. 𝑙 ← 𝑁 in the graph 2 3 4 While 𝒍 > 𝟏 4. 1. < 𝒅 ← color of node # 𝒋 > 5 6 7 2. If 𝒅 == Gray then 1. β€œC1”: <Shade the successors of node # 𝒋 and make node # 𝒋 black> 8 9 10 3. Else 1. 𝒍 ← 𝒍 βˆ’ 𝟐 𝒋 ← 𝒋 + 𝟐 %𝑡 4. 11 12 13 Green simple atomic operations. We will try to break the red. Free list: 14

  7. The Collector: The Marking Phase 0 1 Root: 1. Shade all roots. 𝑁 is the 𝑗 ← 0 2. nodes count 3. 𝑙 ← 𝑁 in the graph 2 3 4 While 𝑙 > 0 4. 14 1. < 𝑑 ← color of node # 𝑗 > 5 6 7 2. If 𝑑 == Gray then 1. β€œC1”: <Shade the successors of node # 𝑗 and make node # 𝑗 black> 8 9 10 3. Else 1. 𝑙 ← 𝑙 βˆ’ 1 𝑗 ← 𝑗 + 1 %𝑁 4. 11 12 13 Green simple atomic operations. We will try to break the red. Free list: Mutator interleaved!

  8. The Collector: The Marking Phase 0 1 Root: 1. Shade all roots. 𝑁 is the 𝑗 ← 0 2. nodes count 3. 𝑙 ← 𝑁 in the graph 2 3 4 While 𝒍 > 𝟏 4. 14 1. < 𝒅 ← color of node # 𝒋 > 5 6 7 2. If 𝒅 == Gray then 1. β€œC1”: <Shade the successors of node # 𝒋 and make node # 𝒋 black> 8 9 10 3. Else 1. 𝒍 ← 𝒍 βˆ’ 𝟐 𝒋 ← 𝒋 + 𝟐 %𝑡 4. 11 12 13 Green simple atomic operations. We will try to break the red. Free list:

  9. The Collector: The Marking Phase 0 1 Root: 1. Shade all roots. 𝑁 is the 𝑗 ← 0 2. nodes count 3. 𝑙 ← 𝑁 in the graph 2 3 4 While 𝒍 > 𝟏 4. 14 1. < 𝒅 ← color of node # 𝒋 > 5 6 7 2. If 𝒅 == Gray then 1. β€œC1”: <Shade the successors of node # 𝒋 and make node # 𝒋 black> 8 9 10 3. Else 1. 𝒍 ← 𝒍 βˆ’ 𝟐 𝒋 ← 𝒋 + 𝟐 %𝑡 4. 11 12 13 Green simple atomic operations. We will try to break the red. Free list:

  10. The Collector: The Marking Phase 0 1 Root: 1. Shade all roots. 𝑁 is the 𝑗 ← 0 2. nodes count 3. 𝑙 ← 𝑁 in the graph 2 3 4 While 𝒍 > 𝟏 4. 14 1. < 𝒅 ← color of node # 𝒋 > 5 6 7 2. If 𝒅 == Gray then 1. β€œC1”: <Shade the successors of node # 𝒋 and make node # 𝒋 black> 8 9 10 3. Else 1. 𝒍 ← 𝒍 βˆ’ 𝟐 𝒋 ← 𝒋 + 𝟐 %𝑡 4. 11 12 13 Green simple atomic operations. We will try to break the red. Free list:

  11. The Collector: The Marking Phase 0 1 Root: 1. Shade all roots. 𝑁 is the 𝑗 ← 0 2. nodes count 3. 𝑙 ← 𝑁 in the graph 2 3 4 While 𝒍 > 𝟏 4. 14 1. < 𝒅 ← color of node # 𝒋 > 5 6 7 2. If 𝒅 == Gray then 1. β€œC1”: <Shade the successors of node # 𝒋 and make node # 𝒋 black> 8 9 10 3. Else 1. 𝒍 ← 𝒍 βˆ’ 𝟐 𝒋 ← 𝒋 + 𝟐 %𝑡 4. 11 12 13 Green simple atomic operations. We will try to break the red. Free list:

  12. The Collector: The Marking Phase 0 1 Root: 1. Shade all roots. 𝑁 is the 𝑗 ← 0 2. nodes count 3. 𝑙 ← 𝑁 in the graph 2 3 4 While 𝒍 > 𝟏 4. 14 1. < 𝒅 ← color of node # 𝒋 > 5 6 7 2. If 𝒅 == Gray then 1. β€œC1”: <Shade the successors of node # 𝒋 and make node # 𝒋 black> 8 9 10 3. Else 1. 𝒍 ← 𝒍 βˆ’ 𝟐 𝒋 ← 𝒋 + 𝟐 %𝑡 4. 11 12 13 Green simple atomic operations. We will try to break the red. Free list:

  13. The Collector: The Marking Phase 0 1 Root: 1. Shade all roots. 𝑁 is the 𝑗 ← 0 2. nodes count 3. 𝑙 ← 𝑁 in the graph 2 3 4 While 𝒍 > 𝟏 4. 14 1. < 𝒅 ← color of node # 𝒋 > 5 6 7 2. If 𝒅 == Gray then 1. β€œC1”: <Shade the successors of node # 𝒋 and make node # 𝒋 black> 8 9 10 3. Else 1. 𝒍 ← 𝒍 βˆ’ 𝟐 𝒋 ← 𝒋 + 𝟐 %𝑡 4. 11 12 13 Green simple atomic operations. We will try to break the red. Free list:

  14. The Collector: The Marking Phase 0 1 Root: 1. Shade all roots. 𝑁 is the 𝑗 ← 0 2. nodes count 3. 𝑙 ← 𝑁 in the graph 2 3 4 While 𝒍 > 𝟏 4. 14 1. < 𝒅 ← color of node # 𝒋 > 5 6 7 2. If 𝒅 == Gray then 1. β€œC1”: <Shade the successors of node # 𝒋 and make node # 𝒋 black> 8 9 10 3. Else 1. 𝒍 ← 𝒍 βˆ’ 𝟐 𝒋 ← 𝒋 + 𝟐 %𝑡 4. 11 12 13 Green simple atomic operations. We will try to break the red. Free list:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  32. The Collector: The Marking Phase (2) 0 1 Root: 1. Shade all roots. 𝑗 ← 0 2. 3. 𝑙 ← 𝑁 2 3 4 While 𝑙 > 0 4. 14 1. < 𝑑 ← color of node # 𝑗 > 6 7 2. If 𝑑 == Gray then 1. β€œC1”: <Shade the successors of node # 𝑗 and make node # 𝑗 black> 8 3. Else 1. 𝑙 ← 𝑙 βˆ’ 1 𝑗 ← 𝑗 + 1 %𝑁 4. 11 12 13 Green simple atomic operations. We will try to break the red. 5 9 10 Free list:

  33. The Collector: The Marking Phase (2) 0 1 Root: 1. Shade all roots. 𝑗 ← 0 2. 3. 𝑙 ← 𝑁 2 3 4 While 𝑙 > 0 4. 14 1. < 𝑑 ← color of node # 𝑗 > 6 7 2. If 𝑑 == Gray then 1. β€œC1”: <Shade the successors of node # 𝑗 and make node # 𝑗 black> 8 3. Else 1. 𝑙 ← 𝑙 βˆ’ 1 𝑗 ← 𝑗 + 1 %𝑁 4. 11 12 13 Green simple atomic operations. We will try to break the red. 5 9 10 Free list:

  34. The Collector: The Marking Phase (2) 0 1 Root: 1. Shade all roots. 𝑗 ← 0 2. 3. 𝑙 ← 𝑁 2 3 4 While 𝒍 > 𝟏 4. 14 1. < 𝒅 ← color of node # 𝒋 > 6 7 2. If 𝒅 == Gray then 1. β€œC1”: <Shade the successors of node # 𝒋 and make node # 𝒋 black> 8 3. Else 1. 𝒍 ← 𝒍 βˆ’ 𝟐 𝒋 ← 𝒋 + 𝟐 %𝑡 4. 11 12 13 Green simple atomic operations. We will try to break the red. 5 9 10 Free list:

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

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

  37. Proof for Correction Criteria 2 β€’ Reminder for CC2: β€œAppending a garbage node to the free list is the collector’s only modification of the shape of data structure”. β€’ The marking phase doesn’t change the data structure. β€’ Prove the rest by showing that the following invariant holds after the marking phase completes: – β€œA white node with a number β‰₯ 𝑗 is garbage”

  38. Proof for Correction Criteria 2 – cont ’ β€’ For the first iteration ( 𝑗 = 0 ), this derives from the following observations: β€’ The marking phase terminates when there is no gray node. β€’ The absence of gray nodes is stable once reached. β€’ At the end of the appending phase, there is no black nodes.

  39. Proof for Correction Criteria 2 – cont ’ β€’ For the other iterations ( 𝑗 > 0 ), this derives from the following observations: – There are 2 ways to violate the invariance: β€’ Making a non-garbage node white. β€’ Making a (white) garbage node into non-garbage. – The mutator β€’ doesn’t convert nodes to white. β€’ don’t deal with to white garbage nodes. – The collector β€’ For the 𝑗 -th iteration, only the 𝑗 -th node may change the color.

  40. Proof for Correction Criteria 1 β€’ Reminder for CC1: β€œEvery garbage node is eventually appended to the free list”. β€’ First we need to prove that both phases terminates correctly. – The marking phase terminates because the quantity 𝒍 + 𝑡 βˆ— 𝒀 , where π‘Œ is non-black nodes, decreases by at least 1 for each iteration. – The appending phase terminate obviously, and the mutator cannot change the color of the nodes.

  41. Proof for Correction Criteria 1 – cont ’ β€’ At the beginning of the appending phase, the nodes can be partitioned into 3 sets: – The set of reachable nodes β€’ They are black – The set of white garbage nodes β€’ Will be appended to the free list in the first appending phase to come – The set of black garbage node β€’ Will be appended to the free list in the next appending phase to come

  42. THE SECOND COARSE-GRAINED SOLUTION

  43. The BUGGY Proposal β€’ An attempt to break M1 into 2 atomic operations: – <Redirect an outgoing edge of a reachable node towards an already reachable one> – <Shade the new target> β€’ Shading must be the first in order to keep P1! β€’ A bug was found by Stenning & Woodger.

  44. The BUGGY Proposal - Demo 0 Root: β€’ An attempt to break M1 into 2 atomic 1 2 operations: – <Redirect an outgoing edge of a reachable Free list: 3 node towards an already reachable one> – <Shade the new target> β€’ Shading must be the first in order to keep P1!

  45. The BUGGY Proposal - Demo 0 Root: β€’ An attempt to break M1 into 2 atomic 1 2 operations: – <Redirect an outgoing edge of a reachable Free list: 3 node towards an already reachable one> – <Shade the new target> β€’ Shading must be the Mutator first in order to keep P1!

  46. The BUGGY Proposal - Demo 0 Root: β€’ An attempt to break M1 into 2 atomic 1 2 operations: – <Redirect an outgoing edge of a reachable Free list: 3 node towards an already reachable one> – <Shade the new target> β€’ Shading must be the Collector – Marking Phase first in order to keep P1!

  47. The BUGGY Proposal - Demo 0 Root: β€’ An attempt to break M1 into 2 atomic 1 2 operations: – <Redirect an outgoing edge of a reachable Free list: 3 node towards an already reachable one> – <Shade the new target> β€’ Shading must be the Collector – Appending Phase first in order to keep P1!

  48. The BUGGY Proposal - Demo 0 Root: β€’ An attempt to break M1 into 2 atomic 1 2 operations: – <Redirect an outgoing edge of a reachable Free list: 3 node towards an already reachable one> – <Shade the new target> β€’ Shading must be the Collector – Marking Phase first in order to keep P1!

  49. The BUGGY Proposal - Demo 0 Root: β€’ An attempt to break M1 into 2 atomic 1 2 operations: – <Redirect an outgoing edge of a reachable Free list: 3 node towards an already reachable one> – <Shade the new target> β€’ Shading must be the Mutator first in order to keep P1!

  50. The BUGGY Proposal - Demo 0 Root: β€’ An attempt to break M1 into 2 atomic 1 2 operations: – <Redirect an outgoing edge of a reachable Free list: 3 node towards an already reachable one> – <Shade the new target> β€’ Shading must be the Mutator first in order to keep P1!

  51. The BUGGY Proposal - Demo 0 Root: β€’ An attempt to break M1 into 2 atomic 1 2 operations: – <Redirect an outgoing edge of a reachable Free list: 3 node towards an already reachable one> – <Shade the new target> β€’ Shading must be the Collector – Marking Phase first in order to keep P1!

  52. The BUGGY Proposal - Demo 0 Root: β€’ An attempt to break M1 into 2 atomic 2 operations: – <Redirect an outgoing edge of a reachable 1 Free list: 3 node towards an already reachable one> A Reachable Node in The Free List! – <Shade the new target> β€’ Shading must be the Collector – Appending Phase first in order to keep P1!

  53. The BUGGY Proposal - Reply 0 Root: β€’ An attempt to break M1 into 2 atomic 1 2 operations: – <Redirect an outgoing edge of a reachable Free list: 3 node towards an already reachable one> – <Shade the new target> β€’ Shading must be the first in order to keep P1!

  54. The BUGGY Proposal - Reply 0 Root: β€’ An attempt to break M1 into 2 atomic 1 2 operations: – <Redirect an outgoing edge of a reachable Free list: 3 node towards an already reachable one> – <Shade the new target> β€’ Shading must be the Mutator first in order to keep P1!

  55. The BUGGY Proposal - Reply 0 Root: β€’ An attempt to break M1 into 2 atomic 1 2 operations: – <Redirect an outgoing edge of a reachable Free list: 3 node towards an already reachable one> – <Shade the new target> β€’ Shading must be the Collector – Marking Phase first in order to keep P1!

  56. The BUGGY Proposal - Reply 0 Root: β€’ An attempt to break M1 into 2 atomic 1 2 operations: – <Redirect an outgoing edge of a reachable Free list: 3 node towards an already reachable one> – <Shade the new target> β€’ Shading must be the Collector – Appending Phase first in order to keep P1!

  57. The BUGGY Proposal - Reply 0 Root: β€’ An attempt to break M1 into 2 atomic 1 2 operations: – <Redirect an outgoing edge of a reachable Free list: 3 node towards an already reachable one> – <Shade the new target> β€’ Shading must be the Collector – Marking Phase first in order to keep P1!

  58. The BUGGY Proposal - Reply 0 Root: β€’ An attempt to break M1 into 2 atomic 1 2 operations: – <Redirect an outgoing edge of a reachable Free list: 3 node towards an already reachable one> P1 is now violated!!! – <Shade the new target> β€’ Shading must be the Mutator first in order to keep P1!

  59. The BUGGY Proposal - Reply 0 Root: β€’ An attempt to break M1 into 2 atomic 1 2 operations: – <Redirect an outgoing edge of a reachable Free list: 3 node towards an already reachable one> P1 is now violated!!! – <Shade the new target> β€’ Shading must be the Mutator first in order to keep P1!

  60. The BUGGY Proposal - Reply 0 Root: β€’ An attempt to break M1 into 2 atomic 1 2 operations: – <Redirect an outgoing edge of a reachable Free list: 3 node towards an already reachable one> P1 is now violated!!! – <Shade the new target> β€’ Shading must be the Collector – Marking Phase first in order to keep P1!

  61. The BUGGY Proposal - Reply 0 Root: β€’ An attempt to break M1 into 2 atomic 2 operations: – <Redirect an outgoing edge of a reachable 1 Free list: 3 node towards an already reachable one> P1 is now violated!!! – <Shade the new target> β€’ Shading must be the Collector – Appending Phase first in order to keep P1!

  62. The BUGGY Proposal - Reply 0 Root: β€’ An attempt to break M1 into 2 atomic 2 operations: – <Redirect an outgoing The new idea – replacing the edge of a reachable 1 Free list: 3 node towards an already invariant P1 by weaker invariants. reachable one> P1 is now violated!!! – <Shade the new target> β€’ Shading must be the Collector – Appending Phase first in order to keep P1!

  63. New Invariant: P2 0 1 Root: β€’ Propagation path: A path of consisting solely 2 3 4 of edges with white targets, and starting 5 6 7 from a gray node. β€’ P2: β€œFor each white 8 9 10 reachable node, there exists a propagation 11 12 13 path leading to it” Free list: 14

  64. New Invariant: P3 β€’ P3: β€œOnly the last edge placed by the mutator may lead from a black node to a white one”

  65. The New Algorithm 0 1 β€’ The collector remains Root: the same! β€’ The mutator’s new 2 3 4 operation is the 5 6 7 following M2: – <Shade the target of the 8 9 10 previously redirected edge, and redirect an outgoing edge of a 11 12 13 reachable node towards a reachable node> Free list: 14

  66. The New Algorithm 0 1 β€’ The collector remains Root: the same! β€’ The mutator’s new 2 3 4 14 operation is the 5 6 7 following M2: – <Shade the target of the 8 9 10 previously redirected edge, and redirect an outgoing edge of a 11 12 13 reachable node towards a reachable node> Free list: Mutator interleaved!

Download Presentation
Download Policy: The content available on the website is offered to you 'AS IS' for your personal information and use only. It cannot be commercialized, licensed, or distributed on other websites without prior consent from the author. To download a presentation, simply click this link. If you encounter any difficulties during the download process, it's possible that the publisher has removed the file from their server.

Recommend

FOX Garbage Collection FOX / GC Example 1 ex1: garbage at end let x = (1, 2) , y = let tmp =

FOX Garbage Collection FOX / GC Example 1 ex1: garbage at end let x = (1, 2) , y = let tmp =

FOX Garbage Collection FOX / GC Example 1 ex1: garbage at end let x = (1, 2) , y = let tmp = (10, 20) in tmp[0] + tmp[1] , p0 = x[0] + y , p1 = x[1] + y in (p0, p1) ebp 0x00 0x04 0x08 0x0c 0x10 0x14 0x18 0x1c 0x20 0x24 esi

1.36k views β€’ 122 slides
Garbage Collection Last time Compiling Object-Oriented Languages Today

Garbage Collection Last time Compiling Object-Oriented Languages Today

Garbage Collection Last time Compiling Object-Oriented Languages Today Motivation behind garbage collection Garbage collection basics Garbage collection performance Specific example of using GC in C++

400 views β€’ 15 slides
Garbage Collection Akim Demaille, Etienne Renault, Roland Levillain June 4, 2019 TYLA Garbage

Garbage Collection Akim Demaille, Etienne Renault, Roland Levillain June 4, 2019 TYLA Garbage

Garbage Collection Akim Demaille, Etienne Renault, Roland Levillain June 4, 2019 TYLA Garbage Collection June 4, 2019 1 / 35 Table of contents Motivations and Definitions 1 Reference Counting Garbage Collection 2 Mark and Sweep Garbage

1.21k views β€’ 95 slides
Uniprocessor Garbage Collection Techniques Presented by: Shiri Dori Shai Erera Outline

Uniprocessor Garbage Collection Techniques Presented by: Shiri Dori Shai Erera Outline

Uniprocessor Garbage Collection Techniques Presented by: Shiri Dori Shai Erera Outline What is Garbage Collection Basic Garbage Collection Techniques Advanced Techniques Incremental Garbage Collection Generational Garbage

660 views β€’ 61 slides
Garbage Collection Jan Midtgaard Michael I. Schwartzbach Aarhus University The Garbage

Garbage Collection Jan Midtgaard Michael I. Schwartzbach Aarhus University The Garbage

Compilation 2010 Garbage Collection Jan Midtgaard Michael I. Schwartzbach Aarhus University The Garbage Collector A garbage collector is part of the runtime system It reclaims heap-allocated records (objects) that are no longer in use

959 views β€’ 56 slides
Generational Generational Garbage Collection Garbage Collection Mirko Jerrentrup,

Generational Generational Garbage Collection Garbage Collection Mirko Jerrentrup,

Generational Generational Garbage Collection Garbage Collection Mirko Jerrentrup, Jerrentrup@interactive-software.de Overview Overview motivation at a glance issues problems and limitations conclusion Motivation

635 views β€’ 42 slides
Garbage Collection for a calculus with indices Luis Francisco Ziliani Departamento de

Garbage Collection for a calculus with indices Luis Francisco Ziliani Departamento de

Motivation Different approachs for implementing -calculus Adding garbage collection to Summary Garbage Collection for a calculus with indices Luis Francisco Ziliani Departamento de Computacin Facultad de Ciencias Exactas y Naturales

1.12k views β€’ 84 slides
Improving Flow Analyses via CFA Abstract Garbage Collection and Counting Matthew Might Olin

Improving Flow Analyses via CFA Abstract Garbage Collection and Counting Matthew Might Olin

Improving Flow Analyses via CFA Abstract Garbage Collection and Counting Matthew Might Olin Shivers Georgia Institute of Technology Northeastern University ICFP 2006 1 The Big Idea The Process 1. Add garbage collection to a

1.09k views β€’ 83 slides
GARBAGE BAGE CO COLLECTIO LLECTION: N: @EvaAndreasson, @Cloudera AGENDA Garbage

GARBAGE BAGE CO COLLECTIO LLECTION: N: @EvaAndreasson, @Cloudera AGENDA Garbage

GARBAGE BAGE CO COLLECTIO LLECTION: N: @EvaAndreasson, @Cloudera AGENDA Garbage Collection (101) The Good The Bad The Ugly The Challenge! 2 GARBAGE COLLECTION &quot;When you have to shoot, shoot - don't talk!&quot; 3

372 views β€’ 34 slides
Incremental Garbage Collection Part II Roland Schatz Incremental Garbage Collection p.1/22

Incremental Garbage Collection Part II Roland Schatz Incremental Garbage Collection p.1/22

Incremental Garbage Collection Part II Roland Schatz Incremental Garbage Collection p.1/22 Baker Disadvantages not concurrent Incremental Garbage Collection p.2/22 Baker Disadvantages not concurrent not even threadsafe

1.49k views β€’ 93 slides
Myths and Realities: The Performance Impact of Garbage Collection Presented by: Tapasya Patki

Myths and Realities: The Performance Impact of Garbage Collection Presented by: Tapasya Patki

Myths and Realities: The Performance Impact of Garbage Collection Presented by: Tapasya Patki February 17, 2011 Authors Motivation: Cost-Benefit Analysis Motivation: To GC or not to GC Explicit Memory Management or Garbage Collection? Can GC

465 views β€’ 23 slides
Distributed Garbage Collection for General Graphs Basic Approaches to Garbage Collection

Distributed Garbage Collection for General Graphs Basic Approaches to Garbage Collection

Distributed Garbage Collection for General Graphs Basic Approaches to Garbage Collection The Brownbridge Collector SWP Collector

1.16k views β€’ 88 slides
Practical Fully Relocating Garbage Collection in LLVM Philip Reames, Sanjoy Das Azul Systems

Practical Fully Relocating Garbage Collection in LLVM Philip Reames, Sanjoy Das Azul Systems

Practical Fully Relocating Garbage Collection in LLVM Philip Reames, Sanjoy Das Azul Systems Oct 28, 2014 This is a talk about how LLVM can better support garbage collection. It is not about how write an LLVM based compiler for a garbage

980 views β€’ 79 slides
Bounding Pause Times in a Regional Garbage Collector Felix S Klock II Thesis Advisor: Will

Bounding Pause Times in a Regional Garbage Collector Felix S Klock II Thesis Advisor: Will

Bounding Pause Times in a Regional Garbage Collector Felix S Klock II Thesis Advisor: Will Clinger 1 1 What is Garbage Collection? Automated reclamation of unreachable storage (Tracing) Garbage collection Mutator : Main application apart

1.13k views β€’ 99 slides
Limits of Parallel Marking Garbage Collection ...how parallel can a GC become? Dr. Fridtjof

Limits of Parallel Marking Garbage Collection ...how parallel can a GC become? Dr. Fridtjof

Limits of Parallel Marking Garbage Collection ...how parallel can a GC become? Dr. Fridtjof Siebert CTO, aicas ISMM 2008, Tucson, 7. June 2008 Limits of Parallel Marking Garbage Collection Introduction Parallel Hardware is becoming the norm

807 views β€’ 33 slides
Exploiting Generational Garbage Collection Using Data Remnants to Improve Memory Analysis and

Exploiting Generational Garbage Collection Using Data Remnants to Improve Memory Analysis and

Exploiting Generational Garbage Collection Using Data Remnants to Improve Memory Analysis and Digital Forensics Adam Pridgen 1 1 Rice University, Houston, TX, USA January 18, 2017 Pridgen Exploiting Generational Garbage Collection 1 Outline

1.33k views β€’ 77 slides
Balanced Group Labeled Graphs M. Joglekar N. Shah A.A. Diwan Department of Computer Science and

Balanced Group Labeled Graphs M. Joglekar N. Shah A.A. Diwan Department of Computer Science and

Introduction Results Summary Balanced Group Labeled Graphs M. Joglekar N. Shah A.A. Diwan Department of Computer Science and Engineering Indian Institute of Technology, Bombay ICRTGC-2010 A.A.Diwan Balanced Group Labeled Graphs

886 views β€’ 67 slides
Chromatic Symmetric Functions with respect to Complete Graphs Sof a Mart nez Alberga

Chromatic Symmetric Functions with respect to Complete Graphs Sof a Mart nez Alberga

Chromatic Symmetric Functions with respect to Complete Graphs Sof a Mart nez Alberga in collaboration with J. Kazdan, L. Kr oll, O. Melnyk, and A. Tenenbaum University of California, Riverside smart040@ucr.edu January 26, 2019

762 views β€’ 55 slides
Enabling the Production of High-Quality English Glosses of Every Word in the Hebrew Bible Drayton

Enabling the Production of High-Quality English Glosses of Every Word in the Hebrew Bible Drayton

Enabling the Production of High-Quality English Glosses of Every Word in the Hebrew Bible Drayton Benner President | Miklal Software Solutions PhD Candidate | Northwest Semitic Philology | University of Chicago DraytonBenner@MiklalSoftware.com

304 views β€’ 13 slides
Advanced AIA Issues for Patent Claim Construction: Best Practices Absent Clear Court Guidance

Advanced AIA Issues for Patent Claim Construction: Best Practices Absent Clear Court Guidance

Presenting a live 90-minute webinar with interactive Q&amp;A Advanced AIA Issues for Patent Claim Construction: Best Practices Absent Clear Court Guidance WEDNESDAY, APRIL 23, 2014 1pm Eastern | 12pm Central | 11am Mountain |

1.54k views β€’ 108 slides
Combined Properties 6 Table Cover 472 Meadowland Drive, Unit #5 Phone: Website: Option 1

Combined Properties 6 Table Cover 472 Meadowland Drive, Unit #5 Phone: Website: Option 1

Combined Properties 6 Table Cover 472 Meadowland Drive, Unit #5 Phone: Website: Option 1 South Burlington, VT 05403 1-800-655-7311 www.projectgraphics.com 12 30 29 72 Combined Properties 6 Table Cover 472 Meadowland

527 views β€’ 8 slides
Consider a line ST with its line bisector below. U S T O From the definition of a line

Consider a line ST with its line bisector below. U S T O From the definition of a line

D AY 66 P ROPERTIES OF BISECTED LINE I NTRODUCTION A farm owner may want to construct a path that passes exactly through the middle of his farm so enable access to various parts of the farm. The problem will be how to identify a line that

291 views β€’ 9 slides
PLAN PLAN Introduction Making the most of Styles The power of Outline Captivating Captions

PLAN PLAN Introduction Making the most of Styles The power of Outline Captivating Captions

T H E I N S T I T U T E O F O P T O M E T RY The Institute of Optometry is unique in being an independent self-financing charity dedicated to the promotion of clinical excellence, research, and education in optometry. Roberson (1989) 1

501 views β€’ 12 slides
= where q 2 0 E r is the conductor charge; n is the number of subconductors in one 0

= where q 2 0 E r is the conductor charge; n is the number of subconductors in one 0

Efficiency of the Use of Power Transmission with Increased Surge Impedance Loading Prof. G.A. Evdokunin Midwest ISO - Expanding Edge Seminar, St. Paul, MN September 16, 2004 AC Overhead Transmission Line Design Choosing The transition to the

580 views β€’ 19 slides

More recommend