Thomas Negeli | Reference Counting I Folie 1 / 20 Seminar Garbage Collection | WS2005 Reference Counting I Negeli Thomas ( / 521) Student an der Johannes Kepler Universität Linz, Österreich Präsentation für: Seminar Garbage Collection WS

Thomas Negeli | Reference Counting I Folie 2 / 20 Seminar Garbage Collection | WS2005 Invariante: RC = 0 Zelle ist unbenutzt Zeiger auf Zelle vom Heap oder vom Stack setzen inkrement des RC Zeiger löschen dekrement des RC Algorithmus 1 - Anforderung von Speicher: /** Speicherzelle anlegen */ MemoryCell New() { if (free_list == null) /** Abbruch, kein Speicher * mehr frei */ System.exit(1); newCell = allocate(); newCell.rc = 1; //ReferenceCount return newCell; } /** Speicher anfordern */ MemoryCell allocate() { newCell = free_list.pop(); free_list = free_list.next; return newCell; } free_list: Menge an freien Speicherzellen newCell: einfache freie Speicherzelle allocate(): liefert eine neue freie Speicherzelle new(): verwaltet Referenzzähler und Speicherplatz

Thomas Negeli | Reference Counting I Folie 3 / 20 Seminar Garbage Collection | WS2005 Algorithmus 2 – Überschreiben von Zellen: /** Update von Objekten */ void Update(MemoryCell r, MemoryCell s) { delete(r); s.rc++; r = s; } /** Löschen von Referenzen */ void delete(MemoryCell t) { t.rc--; if(t.rc == 0) { if (t.next != null) delete(t); free(t); } /** Speicher freigeben */ void free(MemoryCell t) { t.next = free_list; free_list = t; } Update(r,s) überschreibt r mit s delete(t) löscht rekursiv alle Kinder von t free(t) gibt den Speicher von t frei

Thomas Negeli | Reference Counting I Folie 4 / 20 Seminar Garbage Collection | WS2005 Stärken und Schwächen des Reference Counting VorteileNachteile Einfache Handhabung der Algorithmen Speicherverwaltung und Programmausführung laufen verschränkt ab bietet sich für Echtzeitsysteme an Problem: Rekursivität von Algorithmus 2 durch Löschen der Kinder Aufwand zur Aufrechterhaltung der Invariante Werte in alter und neuer Zelle justieren Räumliche Lokalität der Referenzen Zelle ohne Zugriff auf andere Zellen im Heap zurückfordern (Kinder bilden Ausnahme) Problem: ev. Cache Miss bzw. Page Fault Studien belegen: wenige Zellen sind shared, viele existieren nur kurzzeitig Algorithmus 1 und 2 erlauben sofortige Wiederverwendung Weniger Page Faults, Cache Misses als Tracing Strategien leicht abgeänderte Kopie : Zeiger ausborgen (Glasgow Haskell compiler) finalisation actions Starke Kopplung an das Speicher- management des Benutzerprogrammes bzw. Compilers Zerbrechliche Strategie Extra Speicherplatz in jeder Zelle Maximaler RC Wert = Anzahl der Pointer Problem mit zyklischen Datenstrukturen

Thomas Negeli | Reference Counting I Folie 5 / 20 Seminar Garbage Collection | WS2005 Löschen des Zeigers von R nach S macht den Teilbaum S, T, U unzugänglich Freigabe aufgrund der RC Werte nicht möglich Lösung: Reference Counting bis Heap voll ist Anschließend Tracing: * Alle Counts auf 0 setzen * inkrementieren jeder aktiven Zelle in der Markierungsphase * unmarkierte Zellen löschen Kleinere Count Felder möglich, Tracing verwaltet maximale Zählerstände

Thomas Negeli | Reference Counting I Folie 6 / 20 Seminar Garbage Collection | WS2005 Problem: rekursives Löschen der Kinder eines Knotens in der delete(…) Methode Strategien überlegen um Rekursivität zu entfernen, da Löschaufwand vom Subgraph abhängt Algorithmus – Weizenbaums lazy freeing: /** Speicherzelle anlegen */ MemoryCell New() { if (free_list == null) /** Abbruch, kein Speicher * mehr frei */ System.exit(1); newCell = allocate(); if(newCell.next != null) delete(newCell); newCell.rc = 1; //ReferenceCount return newCell; } Problem nur teilweise gelöst: Schneller bei kaskadierten Freigaben. Problem wurde nur verschoben, eventuell Verschwendung von Speicherplatz. delete(t) = if (t.rc==1) { t.rc = free_list free_list = t } else decrementRC(t) Löschen der Kinder erfolgt nicht mehr bei der Freigabe der Zelle, sondern bei der Anforderung von neuem Speicher. RC Feld dient nun der Verkettung der freien Zellen t ist ein Zeiger auf ein Heap Element. Zeiger speichert den Count Wert, nicht die Zelle.

Thomas Negeli | Reference Counting I Folie 7 / 20 Seminar Garbage Collection | WS2005 Verwaltungsaufwand macht RC unattraktiv gegenüber Tracing Strategien (scheinbar) Überschreiben von Zeigern erfordert einigen Aufwand Sogar Unterprogrammaufrufe erfordern Justierungen Caches werden oft mit nicht benötigten Daten gefüllt Daten werden verändert und müssen wieder zurückgeschrieben werden obwohl wieder der Ausgangszustand hergestellt wurde Lösung: Unnötige Veränderung der Count Werte nach Möglichkeit vermeiden (aufschieben) Manuell, bei Wissen über Unterprogramme, kein Problem, jedoch aufwändig Optimierung durch Compiler (Anpassungen nötig) Besser: Verwaltung zur Laufzeit durch z.B. Deutsch-Bobrow Algorithmus

Thomas Negeli | Reference Counting I Folie 8 / 20 Seminar Garbage Collection | WS2005 Studien haben gezeigt: Hauptteil von Zeigermanipulationen erfolgt im Stack. Andere Operationen haben einen Anteil von 1% Operationen auf lokale Variablen optimieren Kein RC für lokale Variablen einfache Zuweisungen bei Manipulationen möglich, Update weniger komplex Count Werte bedeuten jetzt Referenzen von anderen Heap Objekten Keine Freigabe wenn RC = 0, einfügen in eine Zero Count Table (ZCT) Algorithmus 5 – nach Deutsch-Bobrow /** Update von Objekten */ void Update(MemoryCell r, MemoryCell s) { delete(r); s.rc++; ZCT.remove(s); r = s; } /** Löschen von Referenzen */ void delete(MemoryCell t) { t.decrementRC(); if (t.rc==0) { ZCT.put(t); }

Thomas Negeli | Reference Counting I Folie 9 / 20 Seminar Garbage Collection | WS2005 Aufräumen des Speichers in 3 Stufen: 1.Alle Elemente der ZCT mit Referenzen aus dem Stack werden markiert 2.Alle nicht markierten Elemente entfernen 3.Alle Markierungen entfernen Algorithmus 6 – Aufräumen des Speichers void reconcile() { /** markieren der Elemente */ for(i=0; i<stack.getSize(); i++) { stack.getElem(i).incrementRC(); } /** unreferenzierte Zellen * löschen */ for(i=0; i<ZCT.getSize(); i++) { cell = ZCT.getElement(i); if (cell.rc == 0) { if (cell.next!=null) delete(cell); free(cell); } /** Markierungen entfernen */ for(i=0; i<stack.getSize(); i++) { stack.getElem(i).decrementRC(); }

Thomas Negeli | Reference Counting I Folie 10 / 20 Seminar Garbage Collection | WS2005 Algorithmus 7 – größter gemeinsamer Teiler /** Größter gemeinsamer Teiler * Bedingung: x >= y >= 0 */ int gcd(int x, int y) { if (y == 0) return x; t = x-y; if (x>t) return gcd(y,t); else return gcd(t,y); } Getroffene Konventionen: Alle Objekte werden am Heap abgelegt Ausdrücke werden als Graph dargestellt dessen Knoten Objekte am Heap sind Der System Stack enthält Zeiger auf Heap Objekte Atomare Objekte werden mit ihrem Wert bezeichnet

Thomas Negeli | Reference Counting I Folie 11 / 20 Seminar Garbage Collection | WS2005 Algorithmus 7 – größter gemeinsamer Teiler /** Größter gemeinsamer Teiler * Bedingung: x >= y >= 0 */ int gcd(int x, int y) { if (y == 0) return x; t = x-y; if (x>t) return gcd(y,t); else return gcd(t,y); } Getroffene Konventionen: Alle Objekte werden am Heap abgelegt Ausdrücke werden als Graph dargestellt dessen Knoten Objekte am Heap sind Der System Stack enthält Zeiger auf Heap Objekte Atomare Objekte werden mit ihrem Wert bezeichnet

Thomas Negeli | Reference Counting I Folie 12 / 20 Seminar Garbage Collection | WS2005 Algorithmus 7 – größter gemeinsamer Teiler /** Größter gemeinsamer Teiler * Bedingung: x >= y >= 0 */ int gcd(int x, int y) { if (y == 0) return x; t = x-y; if (x>t) return gcd(y,t); else return gcd(t,y); } Getroffene Konventionen: Alle Objekte werden am Heap abgelegt Ausdrücke werden als Graph dargestellt dessen Knoten Objekte am Heap sind Der System Stack enthält Zeiger auf Heap Objekte Atomare Objekte werden mit ihrem Wert bezeichnet Update(right(R),6) Update(left(R),B)

Thomas Negeli | Reference Counting I Folie 13 / 20 Seminar Garbage Collection | WS2005 Algorithmus 7 – größter gemeinsamer Teiler /** Größter gemeinsamer Teiler * Bedingung: x >= y >= 0 */ int gcd(int x, int y) { if (y == 0) return x; t = x-y; if (x>t) return gcd(y,t); else return gcd(t,y); } Getroffene Konventionen: Alle Objekte werden am Heap abgelegt Ausdrücke werden als Graph dargestellt dessen Knoten Objekte am Heap sind Der System Stack enthält Zeiger auf Heap Objekte Atomare Objekte werden mit ihrem Wert bezeichnet Zustand nach reconcile()

Thomas Negeli | Reference Counting I Folie 14 / 20 Seminar Garbage Collection | WS2005 Algorithmus 7 – größter gemeinsamer Teiler /** Größter gemeinsamer Teiler * Bedingung: x >= y >= 0 */ int gcd(int x, int y) { if (y == 0) return x; t = x-y; if (x>t) return gcd(y,t); else return gcd(t,y); } Getroffene Konventionen: Alle Objekte werden am Heap abgelegt Ausdrücke werden als Graph dargestellt dessen Knoten Objekte am Heap sind Der System Stack enthält Zeiger auf Heap Objekte Atomare Objekte werden mit ihrem Wert bezeichnet Das Spiel beginnt wieder von Vorne.

Thomas Negeli | Reference Counting I Folie 15 / 20 Seminar Garbage Collection | WS2005 reconcile() wird bei Überlauf der ZCT gestartet Problem wenn mehrere Zellen gleichzeitig freigegeben werden Mögliche Lösungen: 1.Freigabe der Zelle die den Überlauf verursacht wird erst beim nächsten reconcile() durchgeführt 2.Anpassung des Weizenbaum Algorithmus. Zeiger erst bei erneuter Anforderung der Zelle löschen, tritt dann ein Überlauf auf, reconcile() anstoßen. Verfahren reduziert Kosten bei Schreibvorgängen auf Zeiger %-Werte der absoluten Ausführungszeit. Versuch mit Smalltalk Programmiersprache Nachteil des Verfahrens: keine sofortige Freigabe von Speicher der nicht mehr benötigt wird (erst im reconcile() )

Thomas Negeli | Reference Counting I Folie 16 / 20 Seminar Garbage Collection | WS2005 Problem des Speicherplatzes beim Reference Count Feld Schlimmster Fall: max. mögliche Anzahl Zeiger einer Architektur speichern ABER: Praktisch nie so hohe Zählerstände Speicher sparen, jedoch Überläufe behandeln Algorithmus 8 – sticky Zählerstände /** Referenzzähler Dekrement mit * Sticky Wert */ public void decrementRC() { if (this.rc < sticky) this.rc--; } /** Referenzzähler Inkrement mit * Sticky Wert */ public void incrementRC() { if (this.rc < sticky) this.rc++; } 1.Maximal zulässiger Wert eines Zählers darf nicht überschritten werden 2.Maximaler Wert erreicht bleibt sticky Reference Counting kann Zellen die sticky sind nie mehr freigeben! Tracing nötig

Thomas Negeli | Reference Counting I Folie 17 / 20 Seminar Garbage Collection | WS2005 Strategie: 1.Heap durchwandern und alle Count Werte auf 0 setzen 2.Markieren aller aktiven Zellen 3.Zelle erreicht ursprünglichen Wert an Referenzen bzw. sticky Wert Algorithmus 9 – einfacher Mark & Sweep void mark_sweep() { /** löschen aller Count Werte */ for(i=0; i<Heap.SIZE; i++) { Heap.getCell(i).rc = 0; } /** markieren aller referenzierten Zellen */ for(i=0; i<Stack.SIZE; i++) { mark(Stack.getCell(i)); } /** bereinigen des Speichers */ sweep(); if (free_list==null) /** Abbruch, kein Speicher mehr frei */ System.exit(1); } void mark(MemoryCell mc) { mc.incrementRC(); if(mc.rc==1) { /** rekursiv alle Kinder markieren */ if(mc.next!=null) mark(mc.next); } mark(…) arbeitet rekursiv.

Thomas Negeli | Reference Counting I Folie 18 / 20 Seminar Garbage Collection | WS2005 Reduzierung des Count Feldes auf 1 Bit Zelle entweder sticky oder nicht (nicht genauer) Hauptteil der Zellen ist nicht shared Optimierungen hier ansetzen Ziele: 1.Hinauszögern der Garbage Collection 2.Verwaltungsspeicherplatz reduzieren 3.Vermeidung unnötiger Kopien z.B. Arrays mit tausenden Elementen Algorithmus 10 – 1 Bit Counting Update(R,S) = delete(*R) T = sticky(*S) if RC(*S) == unique *S = T *R = T Sticky Bit wandert von der Zelle in den Zeiger = Tagging Auslesen der Zelle selbst vermeiden weniger Cache Misses bzw. Page Faults Reference Counting + Tracing um Zellen wieder unique machen zu können Count Bit vom Zeiger in den Knoten mark Bit von mark_sweep() benutzen

Thomas Negeli | Reference Counting I Folie 19 / 20 Seminar Garbage Collection | WS2005 /** Update von Objekten */ void Update(MemoryCell r, MemoryCell s){ if(s.rc==unique) insert(s); delete(r); r = s; } /** Cache füllen */ void insert(MemoryCell s) { if(hit(s)) /** markieren wenn bereits * im Cache */ s.rc = sticky; else cache.put(s); } /** Löschen von Referenzen */ void delete(MemoryCell t) { if(!hit(t)) { if(t.rc == unique) { if(t.next!=null) delete(t.next); free(t); } /** Überprüfen ob Zelle bereits im * Cache ist */ boolean hit(MemoryCell s) { if(cache.contains(s)) { cache.remove(s); return true; } else return false; } Algorithmus 11 – Ought to be Two Cache N = select(N) Software Cache für Zellen deren Wert eigentlich 2 ist

Thomas Negeli | Reference Counting I Folie 20 / 20 Seminar Garbage Collection | WS2005 Reference Counting per Hardware self-managing heap memories based on reference counting Aktiver Speicher mit Intelligenz = RCM (Reference Counting Memory) Bänke Einfacher Einsatz in Multiprozessor Systemen Standard Datenspeicher + RCM Bereich Jeder Bereich hat eigenen Bus und eigene Ports Je Bereich eine eigene Liste an freiem speicher Performance abhängig von Problemgröße Spezielle Architektur hohe Entwicklungskosten hohe Kosten für den Endkunden da wenig Absatz Lösung: vorgaukeln einer regulären Speicherbank