Garbage Collection Algorithms

1. GC Algorithms
Michał Warecki

2. Who am I?
●
Programming Geek interested in:
–
GC
–
JiT Compilers
–
Concurrency
–
Non-blocking algorithms
–
Programming languages runtime

3. Outline
●
Introduction
●
Detecting dead objects
●
Basic algorithms
●
Generational GC
●
Multi-threaded GC
●
Real-time GC

4. What I'm not covering
●
GC tuning
●
JVM GC Options
●
JVM Specific GC Implementation
-Xms8g -Xmx8g -XX:MaxPermSize=256m -XX:NewSize=3G
-XX:MaxNewSize=3g -XX:NewRatio=4 -XX:MaxTenuringThreshold=5
-XX:+UseConcMarkSweepGC -XX:+CMSScavengeBeforeRemark
-verbose:gc -XX:+PrintGCDetails -XX:+PrintGCTimeStamps
-Xloggc:gclogs.txt -XX:+PrintGCApplicationStoppedTime
-XX:+PrintGCApplicationConcurrentTime -XX:ParallelGCThreads=7
-XX:+UseGCTaskAffinity -XX:+BindGCTaskThreadsToCPUs
-XX:+UnlockDiagnosticVMOptions -XX:ParGCCardsPerStrideChunk=32768

5. Why do I need to know about GC?
Because GC stops your application!

7. Why to collect garbage?
●
Limited storage
●
Programmers do not like to get dirty
●
Programmers make mistakes
–
Too little collected – memory leaks – error
–
Too much collected – broken programs – error
●
Programmers like good software design
–
Explicit memory management conflicts with the software
engineering principles of abstraction and modularity

8. What is garbage?
Garbage is an object which does not carry any
reference from other objects.

9. Detecting dead objects
Reference tracing vs Reference counting

10. Reference tracing
Root references HEAP

11. Reference tracing
Root references HEAP

12. Reference tracing
Root references HEAP

13. Reference tracing
Root references HEAP

14. Reference tracing
Root references HEAP

15. Reference tracing
Root references HEAP

16. Reference tracing
Root references HEAP

17. Reference tracing
Root references HEAP

18. Reference tracing
Root references HEAP

19. Reference tracing
Root references HEAP

20. Reference tracing
Root references HEAP

21. Reference tracing
Root references HEAP

22. Reference tracing
Root references HEAP

23. Reference tracing
Root references HEAP

24. Reference tracing
Root references HEAP

25. Reference tracing
Root references HEAP

26. Reference tracing
Root references HEAP

27. Reference tracing
Root references HEAP

28. Reference tracing
Root references HEAP

29. Reference tracing
Root references HEAP

30. Reference counting (naive)
New():
ref ← allocate()
if ref = null
error “Out of memory”
rc(ref) ← 0
return ref
atomic Write(src, i, ref):
addReference(ref)
deleteReference(src[i])
src[i] ← ref
addReference(ref):
if ref != null
rc(ref) ← rc(ref) + 1
deleteReference(ref):
if ref != null
rc(ref) ← rc(ref) – 1
if rc(ref) = 0
for each fld in Pointers(ref)
deleteReference(*fld)
free(ref)
The Garbage Collection Handbook – Jones, Hosking, Moss

31. Reference counting (naive)
Root references HEAP

32. Reference counting (naive)
Root references
1
1
1
2
3
0
1
1
1
1
HEAP

33. Reference counting (naive)
Root references
1
1
1
1
1
0
1
1
1
1
HEAP

34. Reference counting (naive)
Root references
1
1
1
1
1
0
1
1
1
1
HEAP
Memory leak!

35. Detecting dead objects
●
Reference tracing
✔ No mutator overhead
✔ Collect cycles
✔ High throughput
✗ Batch style
✗ Not real time
●
Reference counting
✔ Incremental
✔ Short pause
✔ Real time
✗ Reference cycles
✗ High mutator overhead
✗ Low throughput

36. Basic tracing algorithms
Not Moving Moving
Mark/Sweep Mark/Compact Copying

37. Mark/Sweep vs Mark/Compact
Before collection
After Mark/Sweep
After Mark/Compact
Live object
Free space
Dead object

38. Mark/Sweep vs Mark/Compact
After Mark/Sweep
After Mark/Compact
Free list allocation
Bump the pointer allocation

39. Mark/Sweep vs Mark/Compact
●
Mark/Sweep
✔ Fast
✗ Fragmentation
✗ Slower free list
allocation
●
Mark/Compact
✗ Slow
✔ Compacted heap
✔ Fast bump the pointer
allocation

40. Copying GC (Ping Pong)
ToFrom

41. Copying GC (Ping Pong)
ToFrom

42. Copying GC (Ping Pong)
To From

43. Copying GC (Survivor spaces)
Eden From To
Eden From To
Eden From To
Eden From To

44. Copying GC (Survivor spaces)
Eden From To
Eden To From
Eden To From
Eden From To

45. Copying GC
✔ Compacted heap
✔ The speed depends on
the number of live
objects
✔ Possible improvement of
locality during
evacuation
✗ Space overhead

46. Generational hypothesis
Weak generational hypothesis is the
observation that, in most cases, young objects
are much more likely to die than old objects.
Conversely any object that has survived several
GC cycles will probably survive a lot more.

47. Generational GC
Young space Old space
4 10 16 16
Objects headers
Object age
Max tenuring threashold = 15

48. Generational GC algorithms
Young space Old space
Copying GC
Mark/Sweep
Mark/Compact
Reference counting

49. Dynamic Generational GC
G1 GC
Eden
Survivor
Old
Humongous
Unused

50. Card Table and Remembered Set
Young space Old space
Card Table
Dirty
Dirty card – write to memory – possible reference to young generation.
Will be added to Remembered Set

51. Card Table
Ref picture: http://blog.ragozin.info/2011/06/understanding-gc-pauses-in-jvm-hotspots.html

52. Multi-threaded GC
Mutator
GC
Serial GC
Parallel GC
Concurrent GC
Incremental GC

53. Thread Local Allocation Buffer
●
Thread allocates within TLAB using bump the pointer
●
Improved objects locality
●
No contention single pointer
TLAB

54. Promotion Local Allocation Buffer
Each thread has two PLABs:
• One for survivor space,
• One for tenured space
PLAB1 PLAB2
GC Thread 1
GC Thread 2

55. Real-time GC
Plane: I'm landing.
GC: Pff, please wait
2 minutes, I'm collecting

56. Real-time GC
Real-time systems impose operational deadlines
on particular tasks within an application. These
real-time tasks must be able to response to
application inputs (events) within a fixed time
window.
The Garbage Collection Handbook – Jones, Hosking, Moss

57. Metronome GC
Traditional GC
Metronome GC

58. Thanks!!
Questions?