1. CACHETOR Detecting Cacheable Data to Remove Bloat
Khanh Nguyen
Guoqing Xu
UC Irvine
USA

2. Khanh Nguyen - UC Irvine
Introduction
Bloat: Excessive work to accomplish simple tasks
Modern software suffers from bloat [Xu et.al., FoSER 2010]
It is difficult for compilers to remove the penalty
One pattern: repeated computations that have the same inputs and produce the same outputs
4 out of 18 best practices (IBM’s)* are to reuse data
Khanh Nguyen - UC Irvine *

3. Khanh Nguyen - UC Irvine
Example
float[] fValues = {?, ?, ?, ?, , ?};
float[] fValues = {0.0, 1.0, 2.3, 1.0, 1.0, , 1.0, 1.0, , 1.0};
int[] iValues = new int[fValues.length] ;
for (int i = 0; i < fValues.length; i++){
iValues[i] = Float.floatToIntBits(fValues[i]); }
{adapted from sunflow, an open-source image rendering system}
int cached_result = Float.floatToIntBits(1.0);
if (fValues[i] == 1.0)
iValues[i] = cached_result;
else
iValues[i] = Float.floatToIntBits(fValues[i]);
Khanh Nguyen - UC Irvine

4. The Big Picture I-Cachetor D-Cachetor M-Cachetor
Dynamic Dependence Analysis
I-Cachetor
Inst.: a = b+c;
Dependence Profile/Graph
D-Cachetor
Obj.: a = new A();
M-Cachetor
Call: a = f();
Khanh Nguyen - UC Irvine

5. Khanh Nguyen - UC Irvine
Cachetor
Introduction
Scalable algorithms for the dependence analysis
3 detectors
Evaluations
Khanh Nguyen - UC Irvine

6. In Theory In Practice Full Value Profiling Cachetor
Abstract Value Profiling
Cachetor
Abstract Dynamic Slicing
Full Dynamic Slicing
Khanh Nguyen - UC Irvine

7. Khanh Nguyen - UC Irvine
Overview
Combine value profiling and dynamic slicing in a mutually-beneficial and scalable manner
Distinct values are used to abstract instruction instances
Result: an abstract dependence graph
Nodes: abstract representations of runtime instances
Edges: dependence relationships between nodes
Khanh Nguyen - UC Irvine

8. Khanh Nguyen - UC Irvine
Equivalence Class e1 … en
Instruction i
Inst. instances f1
Khanh Nguyen - UC Irvine

9. Equivalence Class f1(inst. instance) = value created Unbounded 1 2 3 45 6
Values created
Inst. instances
Unbounded
f1(inst. instance) = value created

10. f2 f1 Bounded -Top-N ? - Hashing ? Unbounded Values created
Inst. instances
Bounded
Size N
-Top-N ?
- Hashing ? f2
Unbounded f1

11. f2 f1 value % N 1 2 3 6 4 7 5 - Hashing 8 Values created3 6 1 4 7 2 5 8
Values created
Inst. instances
Size N
- Hashing f2
value % N f1

12. Another Abstraction Level
Context sensitive:
To distinguish entities based on the calling context
To improve the tool’s precision
Please refer to our paper for details
Khanh Nguyen - UC Irvine

13. Khanh Nguyen - UC Irvine
Cacheability
Quantitative measurement indicating how likely a program entity will keep producing/containing identical values
Compute cacheability for 3 kinds of program entities:
Instruction a = b+c;
Data structure a = new A();
Method call a = f();
Rank and report top entities
Khanh Nguyen - UC Irvine

14. Khanh Nguyen - UC Irvine
Cachetor
Introduction
Scalable algorithms for the dependence analysis
3 detectors
Evaluations
Khanh Nguyen - UC Irvine

15. 4/8 = 0.5 I-Cachetor Detect instructions that create identical values
Compute cacheability for each static instruction (Inst.CM)
Cacheability: 1 2 3 1 4 2 1
4/8 = 0.5

16. D-Cachetor: Overview 2 steps:
Step 1: detect cacheable individual objects
Step 2: detect cacheable data structure
Compute cacheability for each allocation site node

17. D-Cachetor: Step 1 Compute cacheability for each object (Obj.CM),
not considering reference relationships
Focus: instructions that write primitive-typed fields
a = new A()1
a.f = b<2,3>
a.g = c<3,3>
a.… = … 1 2 … t
a.h = d<5,7>

18. D-Cachetor: Step 2 Group objects using the reference relationships
Compute DataStructureCM
Focus: instructions that write reference-typed fields
Add only objects whose Obj.CM is within a range
ds = new DS()2
a = new A()4
b = new B()6
c = new C()2
d = new D()7

19. M-Cachetor
Detect method calls that have the same inputs and produce the same outputs
Compute CallSiteCM
For each call site c: a = f( ), CallSiteCM is:
If a is primitive: CallSiteCM = Inst.CMc
If a is reference: CallSiteCM = the average of DataStructureCM of all data structures rooted at a

20. Khanh Nguyen - UC Irvine
Implementation
Jikes RVM 3.1.1
Optimizing-compiler-only mode
Context-sensitive
Evaluated on 14 benchmarks from DaCapo & Java Grande 
Khanh Nguyen - UC Irvine

21. Khanh Nguyen - UC Irvine
Overheads
Khanh Nguyen - UC Irvine

22. Khanh Nguyen - UC Irvine
Case Studies
Program
Time Reduction
Space Reduction
GC runs
Reduction
GC time Reduction
montecarlo
12.1%
98.7%
70.0%
89.2%
raytracer
19.1%
1.2%
33.3%
30.2%
euler
20.5%
0.4%
40.0%
44.8%
bloat
13.1%
12.6%
-7.3%
-4.0%
xalan
5.2%
0.1%
-0.7%
-1.1%
Khanh Nguyen - UC Irvine

23. Khanh Nguyen - UC Irvine
False Positives
Program
D-Cachetor
M-Cachetor
montecarlo 2 6
raytracer 3 4
euler 1 7
bloat
xalan 5
Numbers of false positives identified among top 20 items in the reports of D-Cachetor and M-Cachetor.
Khanh Nguyen - UC Irvine

24. False Positives Sources
Handling of floating point values
Context-sensitive reporting
Missing the actual values
Hashing-induced false positives
Khanh Nguyen - UC Irvine

25. Khanh Nguyen - UC Irvine
Conclusions
Cachetor - novel tool, supports detection of cacheable data to improve performance
Scalable combination of value profiling and dynamic slicing
3 detectors that can detect cacheable:
Instructions
Data structures
Method calls
Large optimization opportunities can be found from Cachetor’s reports
Khanh Nguyen - UC Irvine

26. Khanh Nguyen - UC Irvine
THANK YOU!
Questions - Comments?
Khanh Nguyen - UC Irvine

27. What happened in montecarlo?
public void runSerial() {
results = new Vector(nRunsMC);
// Now do the computation.
PriceStock ps;
for( int iRun=0; iRun < nRunsMC; iRun++ ) { ps = new PriceStock(); ps.setInitAllTasks(initAllTasks); ps.setTask(tasks.elementAt(iRun)); ps.run(); results.addElement(ps.getResult()); }
ps.setTask(iRun, (long)iRun*11);
{Calculate the result on the fly}
private void processSerial() {
processResults(); }
private void initTasks(int nRunsMC) {
tasks = new Vector(nRunsMC);
for( int i=0; i < nRunsMC; i++ ) { String header=
"MC run “ + String.valueOf(i);
ToTask task =
new ToTask(header, (long)i*11);
tasks.addElement((Object) task); }
Khanh Nguyen - UC Irvine