ROBERT BOCCHINO, ET AL. UNIVERSAL PARALLEL COMPUTING RESEARCH CENTER UNIVERSITY OF ILLINOIS A Type and Effect System for Deterministic Parallel Java Based on OOPSLA-2009 conference presentation by Robert Bocchino Presented by Thawan Kooburat Computer Science Department University of Wisconsin - Madison
24
Embed
ROBERT BOCCHINO, ET AL. UNIVERSAL PARALLEL COMPUTING RESEARCH CENTER UNIVERSITY OF ILLINOIS A Type and Effect System for Deterministic Parallel Java *Based.
This document is posted to help you gain knowledge. Please leave a comment to let me know what you think about it! Share it to your friends and learn new things together.
Transcript
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
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