1 / 73

Commutativity and Coarse-Grained Transactions

Commutativity and Coarse-Grained Transactions. Maurice Herlihy Brown University Joint work with Eric Koskinen and Matthew Parkinson   (POPL 10). Moore’s Law. Transistor count still rising. Clock speed flattening sharply. (hat tip: Herb Sutter). The Multicore Processor. More processors,

Audrey
Télécharger la présentation

Commutativity and Coarse-Grained Transactions

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. Commutativity andCoarse-Grained Transactions Maurice Herlihy Brown University Joint work with Eric Koskinen and Matthew Parkinson  (POPL 10)

  2. Moore’s Law Transistor count still rising Clock speed flattening sharply (hat tip: Herb Sutter) CCDP February 2011

  3. The Multicore Processor More processors, Same clock Sun T2000 Niagara cache cache cache Bus Bus shared memory CCDP February 2011 3

  4. If more cores does not deliver more value … Then why upgrade? What Keeps Microsoft and Intel awake at Night? ? CCDP February 2011

  5. Computers could become like washing machines You don’t trade it in every 2 years for a cooler model You keep it until it breaks. Washing Machine Science? CCDP February 2011

  6. What could possibly go wrong? • Concurrent programming is hard • Locks, monitors, etc. do not scale • Confusing • Subject to deadlock • Relies on conventions • Not composable • … CCDP February 2011

  7. The Transactional Manifesto • Threads + locking don’t scale • Replace locking with a transactional API • Promising … but not there yet CCDP February 2011

  8. Challenge • Do transactions provide enough concurrency? • As implemented, arguably No. • Does the transactional model provide enough concurrency? • Arguably, Yes. CCDP February 2011

  9. Skew Heaps Tree with “heap” property 0 1 2 3 4 TMW April 2010

  10. Concurrent Skew Heap Insert me! Insert me! 6 0 2 1 3 4 5 TMW April 2010

  11. Concurrent Skew Heap 2 6 0 Lock parent Swap R & L 1 3 4 5 TMW April 2010

  12. Concurrent Skew Heap 2 6 0 Unlock parent 1 3 4 5 Lock right child TMW April 2010

  13. Concurrent Skew Heap No global rebalancing 6 0 1 3 Good amortized performance 4 5 2 Good concurrency TMW April 2010

  14. Transactional Skew Heap Insert me! Insert me! 6 0 2 1 3 4 5 TMW April 2010

  15. Transactional Skew Heap Good concurrency with locking 2 6 0 Write-write conflict! I wrote Not with transactions … 1 3 0 4 5 Confusion between thread-level & transaction-level synchronization TMW April 2010

  16. Coarse-Grained Synchronization Synchronize on high-level operations, Like add(), remove(), etc. … Not low-level reads and writes Pessimistic: update in place, undo on abort Optimistic: update private copy, apply changes on commit But what is the meaning ofconflict? TMW April 2010

  17. Pessimistic Boosting Undo Logs transactions Abstract locks Black-box linearizable data object TMW April 2010

  18. Pessimistic Boosting add(x) Undo Logs transactions Abstract locks Black-box linearizable data object TMW April 2010

  19. Pessimistic Boosting add(x) Undo Logs transactions Abstract locks Black-box linearizable data object TMW April 2010

  20. Pessimistic Boosting add(x) Undo Logs transactions Abstract locks Black-box linearizable data object TMW April 2010

  21. Pessimistic Boosting add(x) rem(x) x Undo Logs transactions Abstract locks Black-box linearizable data object TMW April 2010

  22. Pessimistic Boosting add(x) rem(x) add(y) x y Undo Logs transactions Abstract locks Black-box linearizable data object TMW April 2010

  23. Pessimistic Boosting add(x) rem(x) member(x) x Undo Logs transactions Abstract locks Black-box linearizable data object TMW April 2010

  24. Pessimistic Boosting Thread-safe base object Log Inverses Updated in place Conflicting operations blocked by abstract locks What does it mean for operations to conflict? TMW April 2010

  25. Optimistic Boosting Black-box linearizable data object TMW April 2010

  26. Optimistic Boosting private copies Black-box linearizable data object TMW April 2010

  27. Optimistic Boosting redo logs private copies Black-box linearizable data object TMW April 2010

  28. Optimistic Boosting add(x) redo logs private copies Black-box linearizable data object TMW April 2010

  29. Optimistic Boosting add(x) redo logs add(x) private copies x Black-box linearizable data object TMW April 2010

  30. Optimistic Boosting add(y) add(x) redo logs add(x) add(y) private copies x y Black-box linearizable data object TMW April 2010

  31. On Commit redo logs add(x) add(y) add(x) private copies x y add(x) Black-box linearizable data object TMW April 2010

  32. No conflict, apply updates to my copy On Commit redo logs add(x) add(y) add(x) private copies x x y add(x) x Black-box linearizable data object TMW April 2010

  33. On Commit Different physical values, Same logical values add(x) add(y) add(x) x x y add(x) x TMW April 2010

  34. Conflict! Abort & restore my copy On Commit redo logs add(x) rem(x) add(x) private copies x add(x) x Black-box linearizable data object TMW April 2010

  35. Optimistic Boosting Thread-local object copies Deferred operatons kept in redo log No inverses On commit, broadcast deferred operations To other transactions, public copy Transactions snoop on broadcast, Abort if conflict detected What does it mean for operations to conflict? TMW April 2010

  36. time Left-Movers legal history TMW April 2010

  37. time Left-Movers If and are adjacent, Ok to move earlier TMW April 2010

  38. time Left-Mover Example: Semaphore dec() inc() dec() 1 0 1 0

  39. time Inc() is Left-mover WRT Dec() inc() dec() dec() 1 0 1 1 0 2 1 1 0

  40. time Left-Mover Example: Semaphore Same sequence of calls (results unaffected) inc() dec() dec() 1 0 1 1 0 2 1 1 0

  41. time Left-Mover Example: Semaphore inc() dec() dec() 3 3 2 3 2 4 3 3 2 Same final state

  42. dec() inc() dec() time 0 1 0 Left-Mover Counter-example 1

  43. dec() inc() dec() time 0 1 0 Dec() not Left-Mover WRT Inc() -1 1

  44. time Right-Movers legal history

  45. time Right-Movers If and are adjacent, Ok to move later

  46. time Commutativity If and are adjacent, Ok to swap

  47. time Pessimistic Semantics(modify shared state in place) Txn A beg cmt Txn B beg Pessimistic Commit: Move Left of pending

  48. time Pessimistic Semantics(modify shared state in place) Txn A beg abt Txn B beg

  49. time Pessimistic Semantics(modify shared state in place) Txn A beg 2 3 1 3 2 4 4 1 Txn B beg Pessimistic Abort: Move Right of pending Pessimistic Abort: Pending ops move Left

  50. time Optimistic Semantics(modify local copies; merge) Txn A beg cmt Txn B cmt Optimistic Commit: Move Right of committed

More Related