1. Serialization Sets A Dynamic Dependence-Based Parallel Execution Model Matthew D. Allen Srinath Sridharan Gurindar S. Sohi University of Wisconsin-Madison

2. Motivation Multicore processors ubiquitous – Performance via parallel execution Multithreaded programming is problematic – Dependences encoded statically – Difficult to reason about locks, synchronization – Many errors not found in sequential programs – Execution is nondeterministic Need better parallel execution models! February 16, 20092PPoPP 2009

3. Serialization Sets Overview Sequential program with annotations – Identify potentially independent methods – Associate a serializer with these methods Serializer groups dependent method invocations into serialization sets – Runtime executes in order to honor dependences Serializer attempts to map independent methods invocations into different sets – Runtime opportunistically parallelizes execution February 16, 2009PPoPP 20093

4. Serialization Sets Overview Sequential program with no locks and no explicit synchronization Deterministic, race-free execution Comparable performance to multithreading – Sometimes better! February 16, 2009PPoPP 20094

5. Outline Overview Serialization Sets Execution Model Prometheus: C++ Library for SS Experimental Evaluation Related Work & Conclusions February 16, 2009PPoPP 20095

6. Running Example February 16, 2009PPoPP 20096 trans_t* trans; while ((trans = get_trans ()) != NULL) { account_t* account = trans->account; if (trans->type == DEPOSIT) account->deposit (trans->amount); if (trans->type == WITHDRAW) account->withdraw (trans->amount); } Several static unknowns! # of transactions? Points to? Loop-carried dependence?

7. Multithreading Strategy February 16, 2009PPoPP 20097 trans_t* trans; while ((trans = get_trans ()) != NULL) { account_t* account = trans[i]->account; if (trans->type == DEPOSIT) account->deposit (trans->amount); if (trans->type == WITHDRAW) account->withdraw (trans->amount); } 1)Read all transactions into an array 2)Divide chunks of array among multiple threads Oblivious to what accounts each thread may access! → Methods must lock account to → ensure mutual exclusion

8. Serialization Sets Potentially independent methods – Modify only data owned by object – Fields / Data members – Pointers to non-shared data – Consistent with OO practices (modularity, encapsulation, information hiding) Modifying methods for independence – Store return value in object, retrieve with accessor – Copy pointer data February 16, 2009PPoPP 20098

9. Serialization Sets Divide program into isolation epochs – Data partitioned into domains Privately writable: data that may be read or written by a single serialization set – Object or set of objects – Serializer dynamically identifies serialization set for each method invocation Shared read-only: data that may be read (but not written) by any method February 16, 2009PPoPP 20099

10. writable pw_account_t; begin_isolation (); trans_t* trans; while ((trans = get_trans ()) != NULL) { pw_account_t* account = trans->account; if (trans->type == DEPOSIT) delegate(account, deposit, trans->amount); if (trans->type == WITHDRAW) delegate(account, withdraw, trans->amount); } end_isolation (); End isolation epoch Example with Serialization Sets February 16, 2009PPoPP 200910 Declare privately-writable account Begin isolation epoch Delegate indicates potentially- independent operations Serializer type: uses account number to compute serialization set At execution, delegate: 1)Executes serializer 2)Identifies serialization set 3)Inserts invocation in serialization set

11. delegate February 16, 2009PPoPP 200911 deposit acct=100 $2000 SS #100SS #200SS #300 withdraw acct=300 $350 withdraw acct=200 $1000 withdraw acct=100 $50 deposit acct=300 $5000 withdraw acct=100 $20 withdraw acct=200 $1000 deposit acct=100 $300 Program context Delegate context Serializer: computes SS with account number ss_t ss = account->get_number();

12. Program thread Delegate threads Program context February 16, 2009PPoPP 200912 deposit acct=100 $2000 SS #100SS #200SS #300 withdraw acct=300 $350 withdraw acct=200 $1000 withdraw acct=100 $50 deposit acct=300 $5000 withdraw acct=100 $20 withdraw acct=200 $1000 deposit acct=100 $300 Delegate context Delegate 0Delegate 1 deposit acct=100 $2000 withdraw acct=100 $50 withdraw acct=100 $20 deposit acct=100 $300 withdraw acct=200 $1000 withdraw acct=300 $350 deposit acct=300 $5000 withdraw acct=200 $1000 delegate Race-free, deterministic execution without synchronization!

13. Parallel Execution w/o Sharing 1.Vary data in privately-writable/read-only domains in alternating epochs Outputs of one epoch become inputs of the next 2.Associative, commutative methods Operate on local copy of state Reduction to summarize result 3.Containers manipulated by program context Delegate operations on underlying data February 16, 2009PPoPP 200913

14. Outline Overview Serialization Sets Execution Model Prometheus: C++ Library for SS Experimental Evaluation Related Work & Conclusions February 16, 2009PPoPP 200914

15. Prometheus: C++ Library for SS Template library – Compile-time instantiation of SS data structures – Metaprogramming for static type checking Runtime orchestrates parallel execution Portable – x86, x86_64, SPARC V9 – Linux, Solaris February 16, 2009PPoPP 200915

16. Prometheus Serializers Serializers – Subclass serializer base class and override method – Or use built-in serializer supplied by library Reducibles – Subclass reducible base class and override virtual reduce method – Reduction automatically performed on first use after isolation epoch ends February 16, 2009PPoPP 200916

17. Prometheus Runtime February 16, 2009PPoPP 200917 Program Thread Delegate Thread 0 Delegate Thread 2 Delegate Thread 1 Delegate assignment: SS % NUM_THREADS Communication queues: Fast-Forward [PPoPP 2008] + Polymorphic interface

18. Debugging Support Tag all data accessed by serialization set – Objects – Smart pointers Any data accessed by multiple serialization sets indicates programmer error Problem: can’t detect some kinds of missing annotations – Future work: static checking of annotations February 16, 2009PPoPP 200918

19. Debugging Support Deterministic model means we can simulate SS execution in sequential program – Prometheus support for compiling debug version – Do all debugging on sequential program! Correct sequential → correct parallel (caveat: for a given input) February 16, 2009PPoPP 200919

20. Outline Overview Serialization Sets Execution Model Prometheus: C++ Library for SS Experimental Evaluation Related Work & Conclusions February 16, 2009PPoPP 200920

21. Evaluation Methodology Benchmarks – Lonestar, NU-MineBench, PARSEC, Phoenix Conventional Parallelization – pthreads, OpenMP Prometheus versions – Port program to sequential C++ program – Idiomatic C++: OO, inheritance, STL – Parallelize with serialization sets February 16, 2009PPoPP 200921

22. Results Summary February 16, 2009PPoPP 200922 4 Socket AMD Barcelona (4-way multicore) = 16 total cores

23. Results Summary February 16, 2009PPoPP 200923

24. Outline Overview Serialization Sets Execution Model Prometheus: C++ Library for SS Experimental Evaluation Related Work & Conclusions February 16, 2009PPoPP 200924

25. Related Work Actors / Active Objects – Hewitt [JAI 1977] MultiLisp – Halstead [ACM TOPLAS 1985] Inspector-Executor – Wu et al. [ICPP 1991] Jade – Rinard and Lam [ACM TOPLAS 1998] Cilk – Frigo et al. [PLDI 1998] OpenMP February 16, 2009PPoPP 200925

26. Conclusions Sequential program with annotations – No explicit synchronization, no locks Programmers focus on keeping computation private to object state – Consistent with OO programming practices Dependence-based model – Deterministic race-free parallel execution Performance close to, and sometimes better, than multithreading February 16, 2009PPoPP 200926

27. Questions February 16, 2009PPoPP 200927