Upload
tamsyn-patrick
View
214
Download
0
Tags:
Embed Size (px)
Citation preview
ROBERT BOCCHINO, ET AL .
U N I V E R S A L PA R A L L E L C O M P U T I N G R E SE A R C H C E N T E R
U N I V E R S I T Y O F I L L I N O I S
A Type and Effect System forDeterministic Parallel Java
*Based on OOPSLA-2009 conference presentation by Robert Bocchino
Presented by
Thawan KooburatComputer Science Department
University of Wisconsin - Madison
2
Outline
PrologueIntroductionDeterministic Parallel Java (DPJ)Usage PatternsImplementationEvaluation
3
Prologue
ParallelArray (Java 7 – java.util.concurrent) Slice up data into blocks Perform operation on all data concurrently
4
Prologue
ParallelArray of distinct objects
Framework cannot prevent programmer from writing code will
break the semantic
Access global variables
Time
5
Introduction
Deterministic Execution Same input always produce same output Many computational algorithms are deterministic
Many programs use parallel execution in order to gain performance , but it is not part of the specification.
6
Deterministic-by-default
Guaranteed deterministic execution by default
Nondeterministic behavior must be explicitly requested. foreach
Iterating over independent objects foreach_nd
Iterating over overlapping objects
R. Bocchino, V. Adve, S. Adve, and M. Snir, “Parallel Programming Must Be Deterministic by Default”
7
Benefits
Can reason sequentiallyNo hidden parallel bugs Testing based on input
No need to test all interleaving combinationsParallelize incrementally Easier to compose
8
Deterministic Parallel Java (DPJ)
Based on Java languageFork/Join parallelism
Cobegin Foreach
Type and effect system Expose noninterference (Soundness) Field-level granularity Differentiate between readers and writers
Guarantee deterministic execution at compile time
9
Regions and Effects
Regions Divide memory location into regions Can be formed into a tree
class TreeNode<region P> { region L, R, V; int value in V; TreeNode<L> left = new TreeNode<L>(); TreeNode<R> right = new TreeNode<R>();}
Parameterized by region
10
Regions
Root
Root:L Root:R
Root:L:L
Root:L:R
Root:R:L
Root:R:R
11
Effects
Effects Read or write operations on data Programmer specify effect summary for each method
class TreeNode<region P> { ... TreeNode<L> left = new TreeNode<L>(); TreeNode<R> right = new TreeNode<R>(); void updateChildren() writes L, R { cobegin { left.data = 0; /* writes L */ right.data = 1; /* writes R */ } }
Method effect summary
Compiler inferred from type
Non interferenc
e
12
Usage Patterns
Region path lists (RPLs) Updating nested data structure with field-granularity
Index-parameterized array Updating an array of objects
Subarray Partition array for divide and conquer pattern.
Commutativity Declare effect summary based on operation’s
semantic
13
Region Path Lists (RPLs)
class Tree<region P> { region L, R; int value in P; Tree<P:L> left = new Tree<P:L>(); Tree<P:R> right = new Tree<P:R>();}
P= Rootvalu
eRoot
left Root:Lright Root:R
P=Root:Lvalu
eRoot:L
left Root:L:Lright Root:L:R
P=Root:Rvalu
eRoot:R
left Root:R:Lright Root:R:R
14
Region Path Lists (RPLs)
class Tree<region P> { ... int increment() writes P:* { value++; /* writes P */ cobegin { /* writes P:L:* */ if (left != null) left.increment(); /* writes P:R:* */ if (right != null) right.increment(); }}
P:L:* ⊆ P:* P:R:* ⊆ P:*
Inclusion(Method effect)
Disjointness(Cobegin
body)
P:L:* ∩ P:R:* = ∅
Method effect summary
Effect inferred from type and summary
15
Index-parameterized Array
Enforce disjointness of array’s element (reference)
Syntax: C<[i]>[]#i
1 2 3 4 1 2 3 4
a[i] b[i]
C<[1]> C<[2]> C<[3]> C<[4]>
1 2 3 4c[i]
16
Index-parameterized Array
final Body<[_]>[]<[_] > bodies = new Body<[_]>[N]<[_]>;foreach (int i in 0, N) { /* writes [i] */ bodies[i] = new Body<[i]> ();}foreach (int i in 0, N) { /* reads [i], Link, *:M writes [i]:F */ bodies[i].computeForce();
class Body<region P> { double mass in P:M; double force in P:F; Body <*> link in Link; void computeForce() reads Link, *:M writes P:F {..}}
Write to each element is distinct
Read does not interfere write
Objects are parameterlized by index region
Operations in foreach block is noninterference
17
Subarray
Mechanisms: DPJ Libraries DPJArray: Wrapper class for Java array DPJPartition: Collections of disjoint DPJArray
Divide and Conquer usage pattern Initialize an array using DPJArray Recursively partition original array using DPJPartition
Each partition is a disjoint subset of original array Create a tree of partition based on flat array
18
Subarray
static <region R> void quicksort(DPJArray<R> A) writes R:* { int p = quicksortPartition(A); /* Chop array into two disjoint pieces */ final DPJPartition<R> segs = new DPJPartition<R>(A, p, OPEN); cobegin { /* write segs:[0]:* */ quicksort(segs.get(0)); /* write segs:[1]:* */ quicksort(segs.get(1)); }}
Use local variable to represent regions
RDPJArray
segs[0] segs[1]pDPJPartition
19
Commutativity
Method annotation
Allow programmers to override effect system Compiler will not check inside the method
This allows cobegin { add(e1); add(e2); } Any order of operations is equivalent Operation is atomic
interface Set<type T, region R> { commutative void add(T e) writes R;}
20
Commutativity
Method invocation
foreach (int i in 0, n) { /* invokes Set.add with writes R */ set.add(A[i]);}
cobegin { /* invokes Set.add with writes R */ set.add(A); /* invokes Set.size with read R */ set.size();}
21
Implementation
Extend Sun’s javac compiler Covert DPJ into normal Java source
Compile to ForkJoinTask Framework (Java7) Similar to Cilk DPJ translates foreach and cobegin to tasks
22
Evaluation
Benchmarks
23
Performance
4
8
12
16
20
24
4 8 12 16 20 24
Sp
eed
up
Number of cores
Barnes-HutMergesortIDEAK-MeansCollision TreeMonte Carlo
24
Q/A