81
How to Write a Distributed Garbage Collector Name: Ari Zilka, Saravanan Subbiah Terracotta, Inc. 1 Sunday, 7 June 2009

How to Write a Distributed Garbage Collector in a single Terracotta server 18 > Concurrent mark / sweep algorithm > Phases: mark, rescue1, rescue2, delete > Mark objects still reachable

Embed Size (px)

Citation preview

Page 1: How to Write a Distributed Garbage Collector in a single Terracotta server 18 > Concurrent mark / sweep algorithm > Phases: mark, rescue1, rescue2, delete > Mark objects still reachable

How to Write a Distributed Garbage Collector

Name: Ari Zilka, Saravanan SubbiahTerracotta, Inc.

1Sunday, 7 June 2009

Page 2: How to Write a Distributed Garbage Collector in a single Terracotta server 18 > Concurrent mark / sweep algorithm > Phases: mark, rescue1, rescue2, delete > Mark objects still reachable

Goals

> Learn a little...> about Terracotta> about garbage collection> about distributed algorithms> about complexity

2

2Sunday, 7 June 2009

Page 3: How to Write a Distributed Garbage Collector in a single Terracotta server 18 > Concurrent mark / sweep algorithm > Phases: mark, rescue1, rescue2, delete > Mark objects still reachable

Agenda

> Hypothesis> Case study: virtual heaps / distributed gc> Terminology> Step 1: DGC in single Terracotta server> Step 2: Adding generational collection> Step 3: DGC for Terracotta server arrays> Conclusions

3

3Sunday, 7 June 2009

Page 4: How to Write a Distributed Garbage Collector in a single Terracotta server 18 > Concurrent mark / sweep algorithm > Phases: mark, rescue1, rescue2, delete > Mark objects still reachable

Agenda

> Hypothesis> Case study: virtual heaps / distributed gc> Terminology> Step 1: DGC in single Terracotta server> Step 2: Adding generational collection> Step 3: DGC for Terracotta server arrays> Conclusions

4

4Sunday, 7 June 2009

Page 5: How to Write a Distributed Garbage Collector in a single Terracotta server 18 > Concurrent mark / sweep algorithm > Phases: mark, rescue1, rescue2, delete > Mark objects still reachable

HypothesisAlgorithm design outweighs platform importance

> Some say, “don’t distribute” but the push is in the opposite direction

> distribution / multi-threading is more about algorithms than platform• Asynchronous nature leaks everywhere

• Variations in environment and inputs force this leak

• the more “bare metal”, the better ?!?!

5

5Sunday, 7 June 2009

Page 6: How to Write a Distributed Garbage Collector in a single Terracotta server 18 > Concurrent mark / sweep algorithm > Phases: mark, rescue1, rescue2, delete > Mark objects still reachable

Agenda

> Hypothesis> Case study: virtual heaps / distributed gc> Terminology> Step 1: DGC in single Terracotta server> Step 2: Adding generational collection> Step 3: DGC for Terracotta server arrays> Conclusions

6

6Sunday, 7 June 2009

Page 7: How to Write a Distributed Garbage Collector in a single Terracotta server 18 > Concurrent mark / sweep algorithm > Phases: mark, rescue1, rescue2, delete > Mark objects still reachable

Case Study: Virtual heapsWhat are they?

> Terracotta can make application heap page in and out of the JVM machine

> It can persist application heap to disk> It can provide centralized object identity across

distributed JVMs across a TCP/IP network

7

7Sunday, 7 June 2009

Page 8: How to Write a Distributed Garbage Collector in a single Terracotta server 18 > Concurrent mark / sweep algorithm > Phases: mark, rescue1, rescue2, delete > Mark objects still reachable

Virtual heap pictorial

8

Java Virtual Machine

Application instance

A

B C

D E F G

H I J K L M N O

8Sunday, 7 June 2009

Page 9: How to Write a Distributed Garbage Collector in a single Terracotta server 18 > Concurrent mark / sweep algorithm > Phases: mark, rescue1, rescue2, delete > Mark objects still reachable

Virtual heap pictorial

8

A-C

Java Virtual Machine

Application instance

A

B C

D E F G

H I J K L M N O

8Sunday, 7 June 2009

Page 10: How to Write a Distributed Garbage Collector in a single Terracotta server 18 > Concurrent mark / sweep algorithm > Phases: mark, rescue1, rescue2, delete > Mark objects still reachable

Virtual heap pictorial

9

Java Virtual Machine

Application instance

Terracotta Server

app heap in memory

A

B C

D E F G

H I J K L M N O

A

B C

D E F G

H I J K L M N O

page to Terracotta

9Sunday, 7 June 2009

Page 11: How to Write a Distributed Garbage Collector in a single Terracotta server 18 > Concurrent mark / sweep algorithm > Phases: mark, rescue1, rescue2, delete > Mark objects still reachable

Virtual heap pictorial

9

A-G

Java Virtual Machine

Application instance

Terracotta Server

app heap in memory

A

B C

D E F G

H I J K L M N O

A

B C

D E F G

H I J K L M N O

page to Terracotta

9Sunday, 7 June 2009

Page 12: How to Write a Distributed Garbage Collector in a single Terracotta server 18 > Concurrent mark / sweep algorithm > Phases: mark, rescue1, rescue2, delete > Mark objects still reachable

Virtual heap pictorial

10

Java Virtual Machine

Application instance

Terracotta Server

Terracotta Server's disk

app heap on disk

app heap in memory

A

B C

D E F G

H I J K L M N O

A

B C

D E F G

H I J K L M N O

A

B C

D E F G

H I J K L M N O

page to Terracotta

page to disk

10Sunday, 7 June 2009

Page 13: How to Write a Distributed Garbage Collector in a single Terracotta server 18 > Concurrent mark / sweep algorithm > Phases: mark, rescue1, rescue2, delete > Mark objects still reachable

Virtual heap pictorial

10

A-O

Java Virtual Machine

Application instance

Terracotta Server

Terracotta Server's disk

app heap on disk

app heap in memory

A

B C

D E F G

H I J K L M N O

A

B C

D E F G

H I J K L M N O

A

B C

D E F G

H I J K L M N O

page to Terracotta

page to disk

10Sunday, 7 June 2009

Page 14: How to Write a Distributed Garbage Collector in a single Terracotta server 18 > Concurrent mark / sweep algorithm > Phases: mark, rescue1, rescue2, delete > Mark objects still reachable

The Garbage Collection ChallengeVirtual heaps represent a distributed computing challenge

> How do we collect garbage in a distributed world?> No one layer has “everything”> Crawling disk on Terracotta server is too slow> Crawling memory in application instances is

incorrect as heap is now virtual

> NOTE: platform would not help with any of these issues...

11

11Sunday, 7 June 2009

Page 15: How to Write a Distributed Garbage Collector in a single Terracotta server 18 > Concurrent mark / sweep algorithm > Phases: mark, rescue1, rescue2, delete > Mark objects still reachable

Agenda

> Hypothesis> Case study: virtual heaps / distributed gc> Terminology> Step 1: DGC in single Terracotta server> Step 2: Adding generational collection> Step 3: DGC for Terracotta server arrays> Conclusions

12

12Sunday, 7 June 2009

Page 16: How to Write a Distributed Garbage Collector in a single Terracotta server 18 > Concurrent mark / sweep algorithm > Phases: mark, rescue1, rescue2, delete > Mark objects still reachable

TerminologyLet’s get on the same page

> L1 application node, JVM machine> L2 Terracotta server instance> root top-most object in a graph clustered by

Terracotta (for example, “a”)

> garbage in Terracotta garbage in Java• no reference from any object reachable from roots• not resident in any application heap

13

13Sunday, 7 June 2009

Page 17: How to Write a Distributed Garbage Collector in a single Terracotta server 18 > Concurrent mark / sweep algorithm > Phases: mark, rescue1, rescue2, delete > Mark objects still reachable

How distributed garbage gets created the last bit of context...

> Create a shared object by adding it to a shared graph

> Remove the shared object from the graph in L1> GC in L1 collects object> Now the object is garbage and needs to be

collected> Collect it in the L2> Example: map.put( k,v); map.remove(k); // value is

garbage

14

14Sunday, 7 June 2009

Page 18: How to Write a Distributed Garbage Collector in a single Terracotta server 18 > Concurrent mark / sweep algorithm > Phases: mark, rescue1, rescue2, delete > Mark objects still reachable

Creating distributed garbageAn existing object graph

15

Java Virtual Machine #1

Application instance

A

B C

Java Virtual Machine #2

Application instance

// #1 creates A, B, and C// links them together

A = new object();A.child = B;A.child = C;// ...

15Sunday, 7 June 2009

Page 19: How to Write a Distributed Garbage Collector in a single Terracotta server 18 > Concurrent mark / sweep algorithm > Phases: mark, rescue1, rescue2, delete > Mark objects still reachable

Creating distributed garbageMutating that graph

16

Java Virtual Machine #1

Application instance

A

B C

Java Virtual Machine #2

Application instance

E

// later, #2 changes C to E

//...

A.setChild( E );

// ...

16Sunday, 7 June 2009

Page 20: How to Write a Distributed Garbage Collector in a single Terracotta server 18 > Concurrent mark / sweep algorithm > Phases: mark, rescue1, rescue2, delete > Mark objects still reachable

Creating distributed garbageMutating that graph

16

Java Virtual Machine #1

Application instance

A

B C

Java Virtual Machine #2

Application instance

E

// later, #2 changes C to E

//...

A.setChild( E );

// ...

16Sunday, 7 June 2009

Page 21: How to Write a Distributed Garbage Collector in a single Terracotta server 18 > Concurrent mark / sweep algorithm > Phases: mark, rescue1, rescue2, delete > Mark objects still reachable

Creating distributed garbageMutating that graph

16

“C” becomes distributed garbage, even though JVM #2 never accesses it.

Java Virtual Machine #1

Application instance

A

B C

Java Virtual Machine #2

Application instance

E

// later, #2 changes C to E

//...

A.setChild( E );

// ...

16Sunday, 7 June 2009

Page 22: How to Write a Distributed Garbage Collector in a single Terracotta server 18 > Concurrent mark / sweep algorithm > Phases: mark, rescue1, rescue2, delete > Mark objects still reachable

Agenda

> Hypothesis> Case study: virtual heaps / distributed gc> Terminology> Step 1: DGC in single Terracotta server> Step 2: Adding young generations> Step 3: DGC for Terracotta server arrays> Conclusions

17

17Sunday, 7 June 2009

Page 23: How to Write a Distributed Garbage Collector in a single Terracotta server 18 > Concurrent mark / sweep algorithm > Phases: mark, rescue1, rescue2, delete > Mark objects still reachable

DGC in a single Terracotta server

18

> Concurrent mark / sweep algorithm> Phases: mark, rescue1, rescue2, delete> Mark objects still reachable from the set of all roots

(rootset)> monitor references in app heap for deltas > rescue any objects not marked but joining the graph

during mark phase (rescueset)> rescue any objects not reachable but still in L1 heap> Pause L2, rescue again, and delete garbage

18Sunday, 7 June 2009

Page 24: How to Write a Distributed Garbage Collector in a single Terracotta server 18 > Concurrent mark / sweep algorithm > Phases: mark, rescue1, rescue2, delete > Mark objects still reachable

objects paged in to L1 heap

A

B C

D E F G

L

M N OP

Marking reachable objectsGC_Candidates exclude rootset, reachables

19

GC_Candidates:A B C D E F G L M O PN

19Sunday, 7 June 2009

Page 25: How to Write a Distributed Garbage Collector in a single Terracotta server 18 > Concurrent mark / sweep algorithm > Phases: mark, rescue1, rescue2, delete > Mark objects still reachable

objects paged in to L1 heap

A

B C

D E F G

L

M N OP

Marking reachable objectsGC_Candidates exclude rootset, reachables

19

rootset: A, L

GC_Candidates:A B C D E F G L M O PN

19Sunday, 7 June 2009

Page 26: How to Write a Distributed Garbage Collector in a single Terracotta server 18 > Concurrent mark / sweep algorithm > Phases: mark, rescue1, rescue2, delete > Mark objects still reachable

objects paged in to L1 heap

A

B C

D E F G

L

M N OP

Marking reachable objectsGC_Candidates exclude rootset, reachables

19

rootset: A, L

GC_Candidates:B C D E F G L M O PN

19Sunday, 7 June 2009

Page 27: How to Write a Distributed Garbage Collector in a single Terracotta server 18 > Concurrent mark / sweep algorithm > Phases: mark, rescue1, rescue2, delete > Mark objects still reachable

objects paged in to L1 heap

A

B C

D E F G

L

M N OP

Marking reachable objectsGC_Candidates exclude rootset, reachables

19

rootset: A, L

GC_Candidates:C D E F G L M O PN

19Sunday, 7 June 2009

Page 28: How to Write a Distributed Garbage Collector in a single Terracotta server 18 > Concurrent mark / sweep algorithm > Phases: mark, rescue1, rescue2, delete > Mark objects still reachable

objects paged in to L1 heap

A

B C

D E F G

L

M N OP

Marking reachable objectsGC_Candidates exclude rootset, reachables

19

rootset: A, L

GC_Candidates:C E F G L M O PN

19Sunday, 7 June 2009

Page 29: How to Write a Distributed Garbage Collector in a single Terracotta server 18 > Concurrent mark / sweep algorithm > Phases: mark, rescue1, rescue2, delete > Mark objects still reachable

objects paged in to L1 heap

A

B C

D E F G

L

M N OP

Marking reachable objectsGC_Candidates exclude rootset, reachables

19

rootset: A, L

GC_Candidates:C F G L M O PN

19Sunday, 7 June 2009

Page 30: How to Write a Distributed Garbage Collector in a single Terracotta server 18 > Concurrent mark / sweep algorithm > Phases: mark, rescue1, rescue2, delete > Mark objects still reachable

objects paged in to L1 heap

A

B C

D E F G

L

M N OP

Marking reachable objectsGC_Candidates exclude rootset, reachables

19

rootset: A, L

GC_Candidates:F G L M O PN

19Sunday, 7 June 2009

Page 31: How to Write a Distributed Garbage Collector in a single Terracotta server 18 > Concurrent mark / sweep algorithm > Phases: mark, rescue1, rescue2, delete > Mark objects still reachable

objects paged in to L1 heap

A

B C

D E F G

L

M N OP

Marking reachable objectsGC_Candidates exclude rootset, reachables

19

rootset: A, L

GC_Candidates:G L M O PN

19Sunday, 7 June 2009

Page 32: How to Write a Distributed Garbage Collector in a single Terracotta server 18 > Concurrent mark / sweep algorithm > Phases: mark, rescue1, rescue2, delete > Mark objects still reachable

objects paged in to L1 heap

A

B C

D E F G

L

M N OP

Marking reachable objectsGC_Candidates exclude rootset, reachables

19

rootset: A, L

GC_Candidates:L M O PN

19Sunday, 7 June 2009

Page 33: How to Write a Distributed Garbage Collector in a single Terracotta server 18 > Concurrent mark / sweep algorithm > Phases: mark, rescue1, rescue2, delete > Mark objects still reachable

objects paged in to L1 heap

A

B C

D E F G

L

M N OP

Marking reachable objectsGC_Candidates exclude rootset, reachables

19

rootset: A, L

GC_Candidates:M O PN

19Sunday, 7 June 2009

Page 34: How to Write a Distributed Garbage Collector in a single Terracotta server 18 > Concurrent mark / sweep algorithm > Phases: mark, rescue1, rescue2, delete > Mark objects still reachable

objects paged in to L1 heap

A

B C

D E F G

L

M N OP

Marking reachable objectsGC_Candidates exclude rootset, reachables

19

rootset: A, L

GC_Candidates:O PN

19Sunday, 7 June 2009

Page 35: How to Write a Distributed Garbage Collector in a single Terracotta server 18 > Concurrent mark / sweep algorithm > Phases: mark, rescue1, rescue2, delete > Mark objects still reachable

objects paged in to L1 heap

A

B C

D E F G

L

M N OP

Marking reachable objectsGC_Candidates exclude rootset, reachables

19

rootset: A, L

GC_Candidates:O P

19Sunday, 7 June 2009

Page 36: How to Write a Distributed Garbage Collector in a single Terracotta server 18 > Concurrent mark / sweep algorithm > Phases: mark, rescue1, rescue2, delete > Mark objects still reachable

objects paged in to L1 heap

A

B C

D E F G

L

M N OP

Marking reachable objectsGC_Candidates exclude rootset, reachables

19

rootset: A, L

GC_Candidates:P

19Sunday, 7 June 2009

Page 37: How to Write a Distributed Garbage Collector in a single Terracotta server 18 > Concurrent mark / sweep algorithm > Phases: mark, rescue1, rescue2, delete > Mark objects still reachable

objects paged in to L1 heap

A

B C

D E F G

L

M N OP

Rescue phase 1Reference monitoring informs L2 of changes

20

20Sunday, 7 June 2009

Page 38: How to Write a Distributed Garbage Collector in a single Terracotta server 18 > Concurrent mark / sweep algorithm > Phases: mark, rescue1, rescue2, delete > Mark objects still reachable

objects paged in to L1 heap

A

B C

D E F G

L

M N OP

Rescue phase 1Reference monitoring informs L2 of changes

20

reference deleted

20Sunday, 7 June 2009

Page 39: How to Write a Distributed Garbage Collector in a single Terracotta server 18 > Concurrent mark / sweep algorithm > Phases: mark, rescue1, rescue2, delete > Mark objects still reachable

objects paged in to L1 heap

A

B C

D E F G

L

M N OP

Rescue phase 1Deleted references that are still paged in are special

21

21Sunday, 7 June 2009

Page 40: How to Write a Distributed Garbage Collector in a single Terracotta server 18 > Concurrent mark / sweep algorithm > Phases: mark, rescue1, rescue2, delete > Mark objects still reachable

objects paged in to L1 heap

A

B C

D E F G

L

M N OP

Rescue phase 1Deleted references that are still paged in are special

21

reference deleted

21Sunday, 7 June 2009

Page 41: How to Write a Distributed Garbage Collector in a single Terracotta server 18 > Concurrent mark / sweep algorithm > Phases: mark, rescue1, rescue2, delete > Mark objects still reachable

objects paged in to L1 heap

A

B C

D E F G

L

M N OP

Rescue phase 1Because they can be rescued by other paged in objects

22

22Sunday, 7 June 2009

Page 42: How to Write a Distributed Garbage Collector in a single Terracotta server 18 > Concurrent mark / sweep algorithm > Phases: mark, rescue1, rescue2, delete > Mark objects still reachable

objects paged in to L1 heap

A

B C

D E F G

L

M N OP

Rescue phase 1Because they can be rescued by other paged in objects

22

reference rescued

22Sunday, 7 June 2009

Page 43: How to Write a Distributed Garbage Collector in a single Terracotta server 18 > Concurrent mark / sweep algorithm > Phases: mark, rescue1, rescue2, delete > Mark objects still reachable

Rescue phase 1The resultant garbage in this scenario

23

GC_Candidates:

objects paged in to L1 heap

A

B C

D E F G

L

M N OP

G P

23Sunday, 7 June 2009

Page 44: How to Write a Distributed Garbage Collector in a single Terracotta server 18 > Concurrent mark / sweep algorithm > Phases: mark, rescue1, rescue2, delete > Mark objects still reachable

Rescue phase 2One quick pause and we are done

> Logically same as rescue 1> but no changes are allowed into L2

• “C” could not be collected even if not rescued because it cannot be GCed

> So apply any rescueset objects to GC_Candidates> Then collect garbage> In the example, “G”, “P” are garbage> We’re done...

24

24Sunday, 7 June 2009

Page 45: How to Write a Distributed Garbage Collector in a single Terracotta server 18 > Concurrent mark / sweep algorithm > Phases: mark, rescue1, rescue2, delete > Mark objects still reachable

Drawbacks to simple DGCMight require tuning

> Frequent DGC • pauses app too often• uses up L2 cycles / adds workload

> Infrequent DGC• more time to delete• increase chance that reachable objects have

flushed to disk• disk can fill up • more overhead in bookkeeping garbage

25

25Sunday, 7 June 2009

Page 46: How to Write a Distributed Garbage Collector in a single Terracotta server 18 > Concurrent mark / sweep algorithm > Phases: mark, rescue1, rescue2, delete > Mark objects still reachable

Agenda

> Hypothesis> Case study: virtual heaps / distributed gc> Terminology> Step 1: DGC in single Terracotta server> Step 2: Adding generational collection> Step 3: DGC for Terracotta server arrays> Conclusions

26

26Sunday, 7 June 2009

Page 47: How to Write a Distributed Garbage Collector in a single Terracotta server 18 > Concurrent mark / sweep algorithm > Phases: mark, rescue1, rescue2, delete > Mark objects still reachable

Generational collectortrying to avoid distribution

> If we partition data across L2s, each will have less data to manage• divide and conquer data• divide and conquer GC• ...but more later

> Generational collection• We can avoid marking anything that is on disk• can help avoid disk I/O • maybe help avoid the need to distribute L2s

27

27Sunday, 7 June 2009

Page 48: How to Write a Distributed Garbage Collector in a single Terracotta server 18 > Concurrent mark / sweep algorithm > Phases: mark, rescue1, rescue2, delete > Mark objects still reachable

Generational collectionDifferences from simple DGC

> Similar to simple DGC> redefine rootset to be roots currently in memory> add oldgen, younggen spaces

• oldgen objects that have fallen out of cache at some point

• younggen newly created objects in L2> rememberedset

• backpointers from oldgen to younggen• this one is tricky

28

28Sunday, 7 June 2009

Page 49: How to Write a Distributed Garbage Collector in a single Terracotta server 18 > Concurrent mark / sweep algorithm > Phases: mark, rescue1, rescue2, delete > Mark objects still reachable

Young generation pictorialoldgen, younggen, rootset

29

A

B C

D E F

L

M N O

younggen in memory

oldgen on disk

P

29Sunday, 7 June 2009

Page 50: How to Write a Distributed Garbage Collector in a single Terracotta server 18 > Concurrent mark / sweep algorithm > Phases: mark, rescue1, rescue2, delete > Mark objects still reachable

Young generation pictorialoldgen, younggen, rootset

29

rootset: AA

B C

D E F

L

M N O

younggen in memory

oldgen on disk

P

29Sunday, 7 June 2009

Page 51: How to Write a Distributed Garbage Collector in a single Terracotta server 18 > Concurrent mark / sweep algorithm > Phases: mark, rescue1, rescue2, delete > Mark objects still reachable

A

B C

D E F

L

M N O

younggen in memory

oldgen on disk

P

The rememberedsetbackpointers help skip I/O

30

rememberedset: C,Mrootset: A

30Sunday, 7 June 2009

Page 52: How to Write a Distributed Garbage Collector in a single Terracotta server 18 > Concurrent mark / sweep algorithm > Phases: mark, rescue1, rescue2, delete > Mark objects still reachable

A

B C

D E F

L

M N O

younggen in memory

oldgen on disk

P

The rememberedsetLet’s mark in younggen

31

rememberedset: C,M

GC_Candidates:A B C M P

rootset: A

31Sunday, 7 June 2009

Page 53: How to Write a Distributed Garbage Collector in a single Terracotta server 18 > Concurrent mark / sweep algorithm > Phases: mark, rescue1, rescue2, delete > Mark objects still reachable

A

B C

D E F

L

M N O

younggen in memory

oldgen on disk

P

The rememberedsetLet’s mark in younggen

31

rememberedset: C,M

GC_Candidates:B C M P

rootset: A

31Sunday, 7 June 2009

Page 54: How to Write a Distributed Garbage Collector in a single Terracotta server 18 > Concurrent mark / sweep algorithm > Phases: mark, rescue1, rescue2, delete > Mark objects still reachable

A

B C

D E F

L

M N O

younggen in memory

oldgen on disk

P

The rememberedsetLet’s mark in younggen

31

rememberedset: C,M

GC_Candidates:C M P

rootset: A

31Sunday, 7 June 2009

Page 55: How to Write a Distributed Garbage Collector in a single Terracotta server 18 > Concurrent mark / sweep algorithm > Phases: mark, rescue1, rescue2, delete > Mark objects still reachable

A

B C

D E F

L

M N O

younggen in memory

oldgen on disk

P

The rememberedsetLet’s mark in younggen

31

rememberedset: C,M

GC_Candidates:C M P

rootset: A

DISK BARRIER

31Sunday, 7 June 2009

Page 56: How to Write a Distributed Garbage Collector in a single Terracotta server 18 > Concurrent mark / sweep algorithm > Phases: mark, rescue1, rescue2, delete > Mark objects still reachable

A

B C

D E F

L

M N O

younggen in memory

oldgen on disk

P

The rememberedsetLet’s mark in younggen

31

rememberedset: C,M

GC_Candidates:M P

rootset: A

DISK BARRIER

31Sunday, 7 June 2009

Page 57: How to Write a Distributed Garbage Collector in a single Terracotta server 18 > Concurrent mark / sweep algorithm > Phases: mark, rescue1, rescue2, delete > Mark objects still reachable

A

B C

D E F

L

M N O

younggen in memory

oldgen on disk

P

The rememberedsetLet’s mark in younggen

31

rememberedset: C,M

GC_Candidates:P

rootset: A

DISK BARRIER

31Sunday, 7 June 2009

Page 58: How to Write a Distributed Garbage Collector in a single Terracotta server 18 > Concurrent mark / sweep algorithm > Phases: mark, rescue1, rescue2, delete > Mark objects still reachable

Generational collection summaryWe need a generic “large scale” algorithm

> Benefits• We avoided all disk I/O• Younggen GC run in milliseconds• Can run very frequently• avoids sending objects to oldgen / disk

> Issues• Doesn’t visit all objects, doesn’t find all garbage• Full DGCs must still occur• Distributed garbage must be created often

32

32Sunday, 7 June 2009

Page 59: How to Write a Distributed Garbage Collector in a single Terracotta server 18 > Concurrent mark / sweep algorithm > Phases: mark, rescue1, rescue2, delete > Mark objects still reachable

Agenda

> Hypothesis> Case study: virtual heaps / distributed gc> Terminology> Step 1: DGC in single Terracotta server> Step 2: Adding generational collection> Step 3: DGC for Terracotta server stripes> Conclusions

33

33Sunday, 7 June 2009

Page 60: How to Write a Distributed Garbage Collector in a single Terracotta server 18 > Concurrent mark / sweep algorithm > Phases: mark, rescue1, rescue2, delete > Mark objects still reachable

DGC for Server Stripeslots of challenges to address

> Distributing the object graphs lets us handle arbitrary use cases

> We can do fast updates w/o distributed transaction overhead• another talk though...

> But we can’t get around distributed algorithm for GC• no single L2 knows the whole graph shape• what if nodes fail? network fails?• async updates means DGC is totally async

34

34Sunday, 7 June 2009

Page 61: How to Write a Distributed Garbage Collector in a single Terracotta server 18 > Concurrent mark / sweep algorithm > Phases: mark, rescue1, rescue2, delete > Mark objects still reachable

Graphical view of server stripes

35

Terracotta server 1 Terracotta server 2 Terracotta server 3

A

B C

D E F G

L

M N O

P

35Sunday, 7 June 2009

Page 62: How to Write a Distributed Garbage Collector in a single Terracotta server 18 > Concurrent mark / sweep algorithm > Phases: mark, rescue1, rescue2, delete > Mark objects still reachable

Core algorithm

> Coordinator L2 decides when to start a DGC> Coordinator L2 decides when it is complete> pass marking token on to other L2s> Share no lists, sets, etc. amongst L2s

> Make L2s respond to a global ticker event to track progress

36

36Sunday, 7 June 2009

Page 63: How to Write a Distributed Garbage Collector in a single Terracotta server 18 > Concurrent mark / sweep algorithm > Phases: mark, rescue1, rescue2, delete > Mark objects still reachable

Terracotta server 1 Terracotta server 2 Terracotta server 3

A

B C

D E F G

L

M N O

P

Distributed marking

37

rootset: A rootset: null rootset: L

GC_Candidates: GC_Candidates: GC_Candidates:

A B D E M C F G N L O P

37Sunday, 7 June 2009

Page 64: How to Write a Distributed Garbage Collector in a single Terracotta server 18 > Concurrent mark / sweep algorithm > Phases: mark, rescue1, rescue2, delete > Mark objects still reachable

Terracotta server 1 Terracotta server 2 Terracotta server 3

A

B C

D E F G

L

M N O

P

Distributed marking

37

rootset: A rootset: null rootset: L

GC_Candidates: GC_Candidates: GC_Candidates:

B D E M C F G N L O P

37Sunday, 7 June 2009

Page 65: How to Write a Distributed Garbage Collector in a single Terracotta server 18 > Concurrent mark / sweep algorithm > Phases: mark, rescue1, rescue2, delete > Mark objects still reachable

Terracotta server 1 Terracotta server 2 Terracotta server 3

A

B C

D E F G

L

M N O

P

Distributed marking

37

rootset: A rootset: null rootset: L

GC_Candidates: GC_Candidates: GC_Candidates:

D E M C F G N L O P

37Sunday, 7 June 2009

Page 66: How to Write a Distributed Garbage Collector in a single Terracotta server 18 > Concurrent mark / sweep algorithm > Phases: mark, rescue1, rescue2, delete > Mark objects still reachable

Terracotta server 1 Terracotta server 2 Terracotta server 3

A

B C

D E F G

L

M N O

P

Distributed marking

37

rootset: A rootset: null rootset: L

GC_Candidates: GC_Candidates: GC_Candidates:

E M C F G N L O P

37Sunday, 7 June 2009

Page 67: How to Write a Distributed Garbage Collector in a single Terracotta server 18 > Concurrent mark / sweep algorithm > Phases: mark, rescue1, rescue2, delete > Mark objects still reachable

Terracotta server 1 Terracotta server 2 Terracotta server 3

A

B C

D E F G

L

M N O

P

Distributed marking

37

rootset: A rootset: null rootset: L

GC_Candidates: GC_Candidates: GC_Candidates:

M C F G N L O P

37Sunday, 7 June 2009

Page 68: How to Write a Distributed Garbage Collector in a single Terracotta server 18 > Concurrent mark / sweep algorithm > Phases: mark, rescue1, rescue2, delete > Mark objects still reachable

Terracotta server 1 Terracotta server 2 Terracotta server 3

A

B C

D E F G

L

M N O

P

Distributed marking

37

rootset: A rootset: null rootset: L

GC_Candidates: GC_Candidates: GC_Candidates:

M C F G N L O P

outboundmark request

37Sunday, 7 June 2009

Page 69: How to Write a Distributed Garbage Collector in a single Terracotta server 18 > Concurrent mark / sweep algorithm > Phases: mark, rescue1, rescue2, delete > Mark objects still reachable

Terracotta server 1 Terracotta server 2 Terracotta server 3

A

B C

D E F G

L

M N O

P

Distributed marking

37

rootset: A rootset: null rootset: L

GC_Candidates: GC_Candidates: GC_Candidates:

M F G N L O P

outboundmark request

37Sunday, 7 June 2009

Page 70: How to Write a Distributed Garbage Collector in a single Terracotta server 18 > Concurrent mark / sweep algorithm > Phases: mark, rescue1, rescue2, delete > Mark objects still reachable

Terracotta server 1 Terracotta server 2 Terracotta server 3

A

B C

D E F G

L

M N O

P

Distributed marking

37

rootset: A rootset: null rootset: L

GC_Candidates: GC_Candidates: GC_Candidates:

M G N L O P

outboundmark request

37Sunday, 7 June 2009

Page 71: How to Write a Distributed Garbage Collector in a single Terracotta server 18 > Concurrent mark / sweep algorithm > Phases: mark, rescue1, rescue2, delete > Mark objects still reachable

Terracotta server 1 Terracotta server 2 Terracotta server 3

A

B C

D E F G

L

M N O

P

Distributed marking

37

rootset: A rootset: null rootset: L

GC_Candidates: GC_Candidates: GC_Candidates:

M N L O P

outboundmark request

37Sunday, 7 June 2009

Page 72: How to Write a Distributed Garbage Collector in a single Terracotta server 18 > Concurrent mark / sweep algorithm > Phases: mark, rescue1, rescue2, delete > Mark objects still reachable

Terracotta server 1 Terracotta server 2 Terracotta server 3

A

B C

D E F G

L

M N O

P

Distributed marking

37

rootset: A rootset: null rootset: L

GC_Candidates: GC_Candidates: GC_Candidates:

M N O P

outboundmark request

37Sunday, 7 June 2009

Page 73: How to Write a Distributed Garbage Collector in a single Terracotta server 18 > Concurrent mark / sweep algorithm > Phases: mark, rescue1, rescue2, delete > Mark objects still reachable

Terracotta server 1 Terracotta server 2 Terracotta server 3

A

B C

D E F G

L

M N O

P

Distributed marking

37

rootset: A rootset: null rootset: L

GC_Candidates: GC_Candidates: GC_Candidates:

M N O

outboundmark request

37Sunday, 7 June 2009

Page 74: How to Write a Distributed Garbage Collector in a single Terracotta server 18 > Concurrent mark / sweep algorithm > Phases: mark, rescue1, rescue2, delete > Mark objects still reachable

DGC for stripes details

> Mark starts at roots• Requests to mark are batched, asynch for “A”, “C”

and “L”> We find the “M,N,O” graph to be garbage> Since no single machine has all GC_Candidates

we...• Asked Server #2 to follow from “C” for us

> We ignore failures and abandon the DGC run• Nothing persisted / changed till last stage• will get results when it comes back to life

38

38Sunday, 7 June 2009

Page 75: How to Write a Distributed Garbage Collector in a single Terracotta server 18 > Concurrent mark / sweep algorithm > Phases: mark, rescue1, rescue2, delete > Mark objects still reachable

The TICKER TOKENour coordinating device

> Ticker token a token that gets passed around the server ring

> Coordinator initiates> Each node adds its status and passes token on

• outbound farmed marking tasks to other servers• inbound tasks completed on behalf of others

> Phase complete when ∑inbound - ∑outbound==0> Phase not complete, start a new token on next tick

39

39Sunday, 7 June 2009

Page 76: How to Write a Distributed Garbage Collector in a single Terracotta server 18 > Concurrent mark / sweep algorithm > Phases: mark, rescue1, rescue2, delete > Mark objects still reachable

DGC for stripes is totally asynchronous

> We do...• mark in parallel• rescue in parallel• accept graph changes in parallel

> We don’t...• share GC_Candidates, rootset or rememberedset• have any synchronous remote calls

40

40Sunday, 7 June 2009

Page 77: How to Write a Distributed Garbage Collector in a single Terracotta server 18 > Concurrent mark / sweep algorithm > Phases: mark, rescue1, rescue2, delete > Mark objects still reachable

Platform independent

> We could have used• messaging• JGroups• RMI• raw TCP or UDP protocols• RESTful HTTP interface

> Transport doesn’t really matter.> and neither does language or framework, we think

41

41Sunday, 7 June 2009

Page 78: How to Write a Distributed Garbage Collector in a single Terracotta server 18 > Concurrent mark / sweep algorithm > Phases: mark, rescue1, rescue2, delete > Mark objects still reachable

Have we proven our hypothesis?

> Algorithm design outweighs platform importance > Specific asynch frameworks may or may not help> Not a dig on any technology but

• the TICKER TOKEN• the mark/sweep• and more, make us go fast and those are algorithms

> Was distribution valuable? On 10GB of data:• 1 L2: 2.2MM objects, 1 hour• 8 L2s: 2.2MM objects, 55 seconds

42

42Sunday, 7 June 2009

Page 79: How to Write a Distributed Garbage Collector in a single Terracotta server 18 > Concurrent mark / sweep algorithm > Phases: mark, rescue1, rescue2, delete > Mark objects still reachable

Future optimizations

> Generational collection for stripes > Object migration and packing, train algorithms> Resume after crash (only restarts today)

43

43Sunday, 7 June 2009

Page 80: How to Write a Distributed Garbage Collector in a single Terracotta server 18 > Concurrent mark / sweep algorithm > Phases: mark, rescue1, rescue2, delete > Mark objects still reachable

Want to learn more?

> Come by our booth> Ask about

• avoiding distributed transactions• lock leasing and fairness

> There are all sorts of cool runtime optimizations inside the Terracotta array

> http://www.terracotta.org> TWITTER: @ikarzali @ssubbiah

44

44Sunday, 7 June 2009

Page 81: How to Write a Distributed Garbage Collector in a single Terracotta server 18 > Concurrent mark / sweep algorithm > Phases: mark, rescue1, rescue2, delete > Mark objects still reachable

Ari Zilka, Saravanan [email protected]@terracotta.org

@ikarzali@ssubbiah@terracottatech

45Sunday, 7 June 2009