Dusty Caches for Reference Counting Garbage Collection

Scott Friedman, Praveen Krishnamurthy, Roger Chamberlain, Ron K. Cytron, Jason

FrittsDept. of Computer Science and Engineering

Washington University in St. Louis

Sponsored by NSF grant ITR-0313203

2

Outline

• Introduction– Reference counting garbage collection

• Dusty cache– Design and policy

• Evaluating dusty caches– Quantifying performance using JVM– Experiment on Liquid Architecture

• Conclusions

3

• Garbage collection– Java, C#– Unused objects are reclaimed

• Techniques– Reference counting– Mark and sweep– Copy and collect …

Introduction

4

Reference Counts

P = new Integer(..);

class members

P

Integer

1reference count

5

Reference Counts

P = new Integer(..);

Q = P;

class members

P

Integer

2

reference count

Q

6

Reference Counts

P = new Integer(..);

Q = new Integer(..);

class members

P

1

Q

class members

1

7

Reference Counts

P = Q;

class members

P

2

Q

class members

0

“Garbage”

8

Ref. counts & Memory Traffic

• Short-lived (temporary) changes in reference counts– Linked lists, trees, sorting, hashtables etc.

node 0 node 1 node 2 node nhead

9

Ref. counts & Memory Traffic

node 01

node 11

node 21

node n1

head

linkedList list;iterator iter = list.iterator();while(iter.hasNext()) {

Object item = iter.next();foo(item);

}

10

Ref. counts & Memory Traffic

node 02

node 11

node 21

node n1

head

linkedList list;iterator iter = list.iterator();while(iter.hasNext()) {

Object item = iter.next();foo(item);

}

iter

11

Ref. counts & Memory Traffic

node 01

node 12

node 21

node n1

head

linkedList list;iterator iter = list.iterator();while(iter.hasNext()) {

Object item = iter.next();foo(item);

}

iter

12

Ref. counts & Memory Traffic

node 01

node 11

node 22

node n1

head

linkedList list;iterator iter = list.iterator();while(iter.hasNext()) {

Object item = iter.next();foo(item);

}

iter

13

Ref. counts & Memory Traffic

node 01

node 11

node 21

node n2

head

linkedList list;iterator iter = list.iterator();while(iter.hasNext()) {

Object item = iter.next();foo(item);

}

iter

14

Ref. counts & Memory Traffic

node 01

node 11

node 21

node n1

head

• Consequence– Every object is marked dirty in the cache

• Will be written back to RAM upon eviction

– Unnecessary writes to RAM• Temporally silent stores (Lepak & Lipasti, 2002)

• Our solution - Dusty Cache– Eliminates all such unnecessary writes to memory

15

Outline

• Introduction– Reference counting

• Dusty caches– Design and operations

• Evaluating dusty caches– Quantifying performance using JVM– Experiment on Liquid Architecture

• Conclusions

16

Cache Design: WriteBackca

che lin

es

tag ddata

address cachedvalue

tag offset valid dirty

x

A B C D

101 1

x x x

x

Read: update the tag, valid and data

Write: update dirty and data

17

Read: update tag, data and image

Cache Design: Dustyca

che lin

es

tag ddata

address cachedvalue

x

xdimage

memvalue

tag offset valid dirty ivalid

A B C D

101 1

xA B E D

x

Writes: update tag and data

18

Outline

• Introduction– Reference counting

• Dusty cache– Design and operations

• Evaluating dusty caches– Quantifying performance using JVM– Experiment on Liquid Architecture

• Conclusions

19

Evaluating Dusty Cache

• Traces from JVM instrumentation– Sun’s Java Virtual Machine

• Reference counting garbage collection

– Reference count for all objects– # of JVM instructions between reference count

changes– # of cache altering instructions between changes

• Eviction from cachewindow: for a window of size ‘k’ cache writes, a value ‘v’ written at write ‘i’ will be evicted at write ‘i+k’

20

JVM: Quantifying Memory Savings

• Cache configurations– Unified, Non-unified caches

• WriteThrough, WriteBack, Dusty

• Measured as “memory writes saved”– Baseline was a WriteThrough cache

21

1. SPEC DataBase

8,088 objs

~10%

22

2. SPEC JESS

46,129 objs

~15%

23

Experiments on a flexible processor

• Liquid Architecture– Platform to study microarchitecture refinements– Softcore LEON2: 5-stage SPARC compliant 32-bit – Statsmod:‘non intrusive’ performance measurement tool

• Limitations– 4 MB of SRAM, No JVM

24

Experiment on Liquid Architecture

• Deployed LEON with a ‘dusty’ cache policy– Replicated all of the L1 cache

• Monte Carlo Experiment– Determine probability of cache altering events

• Reads, Writes, HeapRefCount++, HeapRefCount--

– Events access random addresses in memory– Experiments monitored both RC and non-RC traffic

25

Emulation using Liquid ArchitectureResults of the Monte Carlo

Experiment

50%reduction

26

Conclusions

• Dusty cache policy effectively filters the unnecessary reference counting traffic– Savings around 5 - 25 % over WB cache

• Microarchitecture optimization– Dusty cache can be a small subset of the

cache • Could potentially reduce writes even in

non-reference counting traffic– Inferred from Characterization of silent stores

(Bell et al. 2000)

27

Liquid Architecture Project

http://www.arl.wustl.edu/liquidEmail: liquid@cs.wustl.edu

Sponsored by NSF grant ITR-0313203