Folie - System Software
Werbung
Seminar Garbage Collection 339.372 | WS2005 Reference Counting I Folie 1 / 20 Thomas Negeli | 0255604 [email protected] Reference Counting I Negeli Thomas (0255604 / 521) Student an der Johannes Kepler Universität Linz, Österreich Präsentation für: Seminar Garbage Collection WS2005 339.372 [email protected] Seminar Garbage Collection 339.372 | WS2005 Reference Counting I Folie 2 / 20 Thomas Negeli | 0255604 [email protected] 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 Seminar Garbage Collection 339.372 | WS2005 Reference Counting I Folie 3 / 20 Thomas Negeli | 0255604 [email protected] Algorithmus 2 – Überschreiben von Zellen: /** Update von Objekten */ void Update(MemoryCell r, MemoryCell s) { delete(r); s.rc++; r = s; } Update(r,s) überschreibt r mit s /** Löschen von Referenzen */ void delete(MemoryCell t) { t.rc--; if(t.rc == 0) { if (t.next != null) delete(t); free(t); } } delete(t) löscht rekursiv alle Kinder von t /** Speicher freigeben */ void free(MemoryCell t) { t.next = free_list; free_list = t; } free(t) gibt den Speicher von t frei Reference Counting I Seminar Garbage Collection 339.372 | WS2005 Thomas Negeli | 0255604 [email protected] Folie 4 / 20 Stärken und Schwächen des Reference Counting Vorteile 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 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 Nachteile Aufwand zur Aufrechterhaltung der Invariante Werte in alter und neuer Zelle justieren Starke Kopplung an das Speichermanagement des Benutzerprogrammes bzw. Compilers Zerbrechliche Strategie Extra Speicherplatz in jeder Zelle Maximaler RC Wert = Anzahl der Pointer Problem mit zyklischen Datenstrukturen Seminar Garbage Collection 339.372 | WS2005 Reference Counting I Folie 5 / 20 Thomas Negeli | 0255604 [email protected] 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 Seminar Garbage Collection 339.372 | WS2005 Reference Counting I Folie 6 / 20 Thomas Negeli | 0255604 [email protected] 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 3 + 4 – Weizenbaum‘s 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; } 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. Problem nur teilweise gelöst: Schneller bei kaskadierten Freigaben. Problem wurde nur verschoben, eventuell Verschwendung von Speicherplatz. Seminar Garbage Collection 339.372 | WS2005 Reference Counting I Folie 7 / 20 Thomas Negeli | 0255604 [email protected] 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 Seminar Garbage Collection 339.372 | WS2005 Reference Counting I Folie 8 / 20 Thomas Negeli | 0255604 [email protected] Studien haben gezeigt: Hauptteil von Zeigermanipulationen erfolgt im Stack. Andere Operationen haben einen Anteil von 1% Operationen auf lokale Variablen optimieren Algorithmus 5 – nach Deutsch-Bobrow 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) /** 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); } } Seminar Garbage Collection 339.372 | WS2005 Reference Counting I Folie 9 / 20 Thomas Negeli | 0255604 [email protected] Algorithmus 6 – Aufräumen des Speichers Aufräumen des Speichers in 3 Stufen: 1. 2. 3. void reconcile() { /** markieren der Elemente */ for(i=0; i<stack.getSize(); i++) { stack.getElem(i).incrementRC(); } Alle Elemente der ZCT mit Referenzen aus dem Stack werden markiert Alle nicht markierten Elemente entfernen Alle Markierungen entfernen /** 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(); } } Seminar Garbage Collection 339.372 | WS2005 Reference Counting I Folie 10 / 20 Thomas Negeli | 0255604 [email protected] 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 Seminar Garbage Collection 339.372 | WS2005 Reference Counting I Folie 11 / 20 Thomas Negeli | 0255604 [email protected] 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 Seminar Garbage Collection 339.372 | WS2005 Reference Counting I Folie 12 / 20 Thomas Negeli | 0255604 [email protected] Algorithmus 7 – größter gemeinsamer Teiler /** Größter gemeinsamer Teiler Getroffene Konventionen: * Bedingung: x >= y >= 0 */ • Alle Objekte werden am Heap abgelegt int gcd(int x, int y) { • Ausdrücke werden als Graph dargestellt dessen Knoten Objekte am Heap sind if (y == 0) return x; • Der System Stack enthält Zeiger auf Heap Objekte t = x-y; • Atomare Objekte werden mit ihrem Wert bezeichnet if (x>t) return gcd(y,t); Update(right(R),6) else return gcd(t,y); Update(left(R),B) } Seminar Garbage Collection 339.372 | WS2005 Reference Counting I Folie 13 / 20 Thomas Negeli | 0255604 [email protected] 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); } Zustand nach reconcile() 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 Seminar Garbage Collection 339.372 | WS2005 Reference Counting I Folie 14 / 20 Thomas Negeli | 0255604 [email protected] 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); } Das Spiel beginnt wieder von Vorne. 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 Seminar Garbage Collection 339.372 | WS2005 Reference Counting I Thomas Negeli | 0255604 [email protected] Folie 15 / 20 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()) Seminar Garbage Collection 339.372 | WS2005 Reference Counting I Folie 16 / 20 Thomas Negeli | 0255604 [email protected] 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 Reference Counting I Seminar Garbage Collection 339.372 | WS2005 Folie 17 / 20 Thomas Negeli | 0255604 [email protected] Algorithmus 9 – einfacher Mark & Sweep Strategie: 1. Heap durchwandern und alle Count Werte auf 0 setzen 2. Markieren aller aktiven Zellen 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)); } 3. Zelle erreicht ursprünglichen Wert an Referenzen bzw. sticky Wert /** bereinigen des Speichers */ sweep(); if (free_list==null) /** Abbruch, kein Speicher mehr frei */ System.exit(1); } mark(…) arbeitet rekursiv. void mark(MemoryCell mc) { mc.incrementRC(); if(mc.rc==1) { /** rekursiv alle Kinder markieren */ if(mc.next!=null) mark(mc.next); } } Seminar Garbage Collection 339.372 | WS2005 Reference Counting I Folie 18 / 20 Thomas Negeli | 0255604 [email protected] 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 Seminar Garbage Collection 339.372 | WS2005 Reference Counting I Folie 19 / 20 Thomas Negeli | 0255604 [email protected] Algorithmus 11 – Ought to be Two Cache N = select(N) Software Cache für Zellen deren Wert eigentlich 2 ist /** 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; } Seminar Garbage Collection 339.372 | WS2005 Reference Counting I Folie 20 / 20 Thomas Negeli | 0255604 [email protected] 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 Spezielle Architektur hohe Entwicklungskosten hohe Kosten für den Endkunden da wenig Absatz Lösung: vorgaukeln einer regulären Speicherbank 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
