Mark & Sweep Seminar Softwareentwicklung: Garbage Collection Eva Schartner

Übersicht Grundprinzip Mark & Sweep Stärken/Schwächen Rekursion Umkehrung von Zeigern Lazy Sweeping Mark During Sweep Very Concurrent Garbage Collection

Wie funktioniert Mark & Sweep GC wird erst aufgerufen, wenn allocate zuwenig Speicherplatz findet Normale Berechnung angehalten während M&S Heap durchlaufen um unerreichbare Zellen aufzuspüren Diese werden zum free_pool hinzugefügt

Mark & Sweep Algorithmus Mark_sweep() For R in Roots Mark(R) Sweep() If free_pool is empty Abort since Memory exhausted Free_pool: Implementation frei wählbar Liste: nur Pointer umleiten

2 Phasen: Marking root...Mark bit

2 Phasen: Sweeping...Mark bit root

Stärken und Schwächen Zyklische Datenstrukturen Zeiger Manipulation Unterbrechendes Verfahren Hohe Komplexität Mark: jede aktive Zelle Sweep: jede Zelle Gut ausgelasteter Heap: Thrashing

Rekursion explizit machen Rekursion nicht effizient => Stack gc() = mark_heap() sweep() mark_heap() = mark_stack=empty for R in Roots mark_bit(R) = marked push(R, mark_stack) mark() mark() = while mark_stack not empty N = pop(mark_stack) for M in Children(N) do if mark_bit(*M) == unmarked mark_bit(*M) = mark if not atom(*M) push(*M, mark_stack)

Stack overflow Boehm-Demer-Weis Methode Stack overflow merken Kein Push mehr Neuer Stack mit doppelter Größe Suche nach markierten Knoten mit unmarkierten Kindern Knuth Kurokawa

Zeiger umkehren Deutsch-Schorr-Waite: 3 Phasen Advance Setze mark_bit Linkes Feld von child zeigt auf parent Switch Setze Flag bit von parent Originalwert von links wiederhergestellt Rechtes Feld von child zeigt auf parent Retreat Flag bit gelöscht Originalwert von rechts wiederhergestellt Eine Ebene hinauf root

Lazy Sweeping Während Allokation nach freiem Speicher sucht läuft Sweep Zelle markiert => zurücksetzen Zelle unmarkiert => zurückgeben an Allokation Heap durchwandert => voller GC Durchlauf da Heap voll mutator mutator + sweep mark

Mark During Sweep 2 Generationen mit je eigenen Farben schwarz: aktiv, weiß: garbage grau: Zwischenstufe Marker markiert aktuelle Generation Sweeper löscht vorherige Generation Hoher Overhead für Synchronisation mark N+1 mark N+2 sweep N sweep N+1 mutator

Very Concurrent GC 3 Farben, dargestellt durch epochs Keine Fein-Synchronisation mehr nötig 3 nebenläufige Threads mutator marker Sweeper Hinkt 2 epochs hinterher

Very Concurrent GC int epoch = 2; root_set roots = {}; thread mutator, marker, sweeper; forever{ mutator = New mutator(COLOR(epoch));// Hauptprogramm marker = New marker(COLOR(epoch));// markiert aktive sweeper = New sweeper(COLOR(epoch – 2));// sammelt vorvorige Daten barrier_sync {marker, sweeper}; // aller erreichbaren Daten haben COLOR(epoch) suspend_thread mutator; roots = getRoots(mutator); deleteThreads(mutator, marker, sweeper); epoch++; }

Danke für Ihre Aufmerksamkeit Fragen?