Garbage Collection ist nicht gleich Garbage Collection. Neben den grundsätzlich unterschiedlichen Ansätzen wie parallel und concurrent, verfolgen alle JVM's hier unterschiedliche Strategien und das Verhalten unterscheidet sich beträchtlich. Diese Session erläutert die grundsätzlichen Strategien und Tuning Möglichkeiten. Wir widmen uns im Besonderen den Unterschieden im Verhalten und Tuning der drei grossen JVMs Sun, JRockit und IBM. Zuletzt werden erläutern wir die häufigsten Probleme, wie sie erkannt und gelöst werden können.

1. Garbage Collection verstehen
3 JVMs – ähnlich aber doch verschieden

2. • Langsam? Wann und Warum
• Auswirkungen
• Jede JVM ist anders
• GC Strategien & Richtiges Tuning
• Probleme und Lösungen

3. Die Basics

4. GC auf einen Blick
Nicht Erreichbare
Objekte  Garbage
Vergessene Referenz
 Memory Leak
Erreichbare Objekte
GC Roots

5. Viele (über)lebende Objekte
=
Lange Garbage Collection

6. Generational Heap
• Wenige Allokationen
• Viele Überlebende
• Viele Allokationen
• Wenige Überlebende
Marking Phase
Marking Phase
Speicher nach Sweep Nach Copy Phase

7. Performance Auswirkungen
Runtime Suspensions

8. Suspensions
• Alle Anwendungs Threads pausieren
• Auch Young/Minor Collections!
• Antwortzeiten  1:1
• Durchsatz  Exponentiell

9. Suspensions
Serial Collector Parallel Collector
Pause
Pause
Remark
Concurrent
Mark
Concurrent Collector
Concurrent
Sweep

10. Performance Auswirkungen
Fragmentierung

11. Fragmentierung
Marking Phase
Speicher nach Sweep

12. Compacting GC
• Young Generation  Copy Collection
• Old Generation (außer CMS)
Fragmentierter Speicher
Speicher nach Kompaktifizierung

13. Performance Auswirkungen
CPU Verbrauch

14. CPU Verbrauch
• Zeit ≈ CPU Zeit
• Seriell <≈ Parallel
• Je mehr CPUs desto kürzer Suspension
• Negative Auswirkung auf andere
Prozesse
• CMS  single Threaded

15. Die Unterschiede
Jede JVM ist anders

16. Young Tenured
Eden
Survior
Survior
SUN/ORACLE JVM

17. ORACLE JROCKIT

18. Heap
• Generational
Nursery Tenured
Keep
Area
oder
• Kontinuierlicher Heap

19. Mostly Concurrent
Mark and Sweep
Pause
Final Remark
Concurrent Mark
& remark
Sweep 1. Hälfte
Sweep 2. Hälfte
Pause

20. Compacting Windows
• Inkrementelles Compacting
• Auch bei CMS
Fragmentierter Speicher

21. Thread-Lokale Allokation
• Separatere Heap Bereiche
• Dynamische Zuteilung
• Keine Synchronisation
Schnellere Allokation

22. „GROßE“ UND „KLEINE“
OBJEKTE

23. Permanent Generation?
• Klassen werden wie Objekte behandelt
• Sofortige Garbage Collection möglich!

24. IBM JVM

25. Die Unterschiede
• Kontinuierlicher Heap ist Standard
• Allocate und Survivor
• „Große“ und „Kleine“ Objekte
• Keine Permanent Generation
Nursery Tenured
Allocate
Survior

26. Garbage Collection
TUNING

27. Das Ziel vor Augen halten

28. GC Strategien
Antwortzeit Durchsatz
Kontinuierlicher Heap Kleine Anwendungen,
Clients, evtl mit CMS
Ja, Parallel GC
Generational Heap Ja Ja, parallel GC
Concurrent Mark and
Sweep
Server Nein, außer wenn
Suspension sensitiv
Parallel GC Young, Nicht old Ja

29. Richtig Messen
• Suspensions messen
 Auswirkung auf Antwortzeit
• Garbage Collection Zeit/CPU messen
• Garbage Collection Häufigkeit messen

30. JMX Metriken

31. Echte Auswirkung

32. Auf die Größe kommt es an
• Objekt stirb Young
• Old Generation abspecken
• Richtiges Verhältnis

33. Objekt Churning
• Allokiere so viel du willst, aber
– nicht zu viel
– nicht zu lange
• Cachen ist gut, aber
– Nicht zu viel
– Nicht zu kurz

34. PROBLEME, MYTHEN,
LEGENDEN

35. Minor vs. Major
• Minor Collections pausieren auch!
• Old Generation ≠ Major Collection

36. Zu großer Heap
• Lange und teure Garbage Collections
• Caches
– HTTP-Session as Cache
– Soft/Weak Referenzen
• Memory Leaks

37. Memory Leaks
• Statische veränderliche Variablen
• Thread Lokale Variablen
• JNI
• Equals/Hashcode
• Bi-direktionale Referenzen

38. Bi-direktionale Referenzen
Document doc = readXmlDocument();
Node child =
doc.getDocumentElement().getFirstChild();
doc.removeNode(child);
doc = null;
// child hat eine Referenz auf doc,
// daher doc wird nicht freigegeben

39. Classloader Probleme
• Class Loader Leaks
• Mehrfach geladene Klassen
• Zu viele, große Klassen
• Wiederholtes Laden

40. Out Of Memory
• GC Thrashing
• Transaktionaler Speicherverbrauch
• Große temporare Objekte
• Permanent Generation

41. Große Temp. Objekte
byte tmpData[] = new byte [1024];
int offs = 0;
do{
int readLen = bis.read (tmpData, offs, tmpData.length -
offs);
if (readLen == -1)
break;
offs+= readLen;
if (oofs == tmpData.length){
byte newres[] = new byte[tmpData.length + 1024];
System.arraycopy(tmpData, 0, newres, 0, tmpData.length);
tmpData = newres;
}
} while (true);

42. FRAGEN
Michael Kopp
michael.kopp@dynatrace.com
@mikopp
http://blog.dynatrace.com