We should define semantics for languages, not for TM Tim Harris (MSR Cambridge)

Slides:



Advertisements
Similar presentations
Dataflow Analysis for Datarace-Free Programs (ESOP 11) Arnab De Joint work with Deepak DSouza and Rupesh Nasre Indian Institute of Science, Bangalore.
Advertisements

Garbage Collection in the Next C++ Standard Hans-J. Boehm, Mike Spertus, Symantec.
Safe Open-Nested Transactions Jim Sukha MIT CSAIL Supercomputing Technologies Group Kunal Agrawal, I-Ting Angelina Lee, Bradley C. Kuszmaul, Charles E.
Tramp Ali-Reza Adl-Tabatabai, Richard L. Hudson, Vijay Menon, Yang Ni, Bratin Saha, Tatiana Shpeisman, Adam Welc.
TRAMP Workshop Some Challenges Facing Transactional Memory Craig Zilles and Lee Baugh University of Illinois at Urbana-Champaign.
Copyright 2008 Sun Microsystems, Inc Better Expressiveness for HTM using Split Hardware Transactions Yossi Lev Brown University & Sun Microsystems Laboratories.
The many faces of TM Tim Harris. Granularity Distributed, large-scale atomic actions Composable shared memory data structures Leaf shared memory data.
Pay-to-use strong atomicity on conventional hardware Martín Abadi, Tim Harris, Mojtaba Mehrara Microsoft Research.
TexPoint fonts used in EMF. Read the TexPoint manual before you delete this box.: A A A AAA A A A AA A Proving that non-blocking algorithms don't block.
Impossibilities for Disjoint-Access Parallel Transactional Memory : Alessia Milani [Guerraoui & Kapalka, SPAA 08] [Attiya, Hillel & Milani, SPAA 09]
Principles of Transaction Management. Outline Transaction concepts & protocols Performance impact of concurrency control Performance tuning.
A Rely-Guarantee-Based Simulation for Verifying Concurrent Program Transformations Hongjin Liang, Xinyu Feng & Ming Fu Univ. of Science and Technology.
Transactional Memory – Implementation Lecture 1 COS597C, Fall 2010 Princeton University Arun Raman 1.
Safety Definitions and Inherent Bounds of Transactional Memory Eshcar Hillel.
Inherent limitations on DAP TMs 1 Inherent Limitations on Disjoint-Access Parallel Transactional Memory Hagit Attiya, Eshcar Hillel, Alessia Milani Technion.
Transaction Processing on Top of Hadoop Spring 2012 Aviram Rehana Lior Zeno Supervisor : Edward Bortnikov.
A Programming Language View of Transactional Memory Hagit Attiya, Technion Joint work with Sandeep Hans, Alexey Gotsman and Noam Rinetzky Published in.
Making sense of transactional memory Tim Harris (MSR Cambridge) Based on joint work with colleagues at MSR Cambridge, MSR Mountain View, MSR Redmond, the.
Transactional Memory (TM) Evan Jolley EE 6633 December 7, 2012.
An Case for an Interleaving Constrained Shared-Memory Multi- Processor CS6260 Biao xiong, Srikanth Bala.
Parallelism and Concurrency Koen Lindström Claessen Chalmers University Gothenburg, Sweden Ulf Norell.
1 Lecture 21: Transactional Memory Topics: consistency model recap, introduction to transactional memory.
Formalisms and Verification for Transactional Memories Vasu Singh EPFL Switzerland.
1 Lecture 7: Transactional Memory Intro Topics: introduction to transactional memory, “lazy” implementation.
Algorithmics for Software Transactional Memory Hagit Attiya Technion.
Dependable computing needs pervasive debugging Tim Harris
The Cost of Privatization Hagit Attiya Eshcar Hillel Technion & EPFLTechnion.
CS510 Concurrent Systems Class 5 Threads Cannot Be Implemented As a Library.
XCalls: Safe I/O in Memory Transactions Haris Volos, Andres Jaan Tack, Neelam Goyal +, Michael Swift, Adam Welc § University of Wisconsin - Madison + §
Google File System.
A Behavioral Memory Model for the UPC Language Kathy Yelick Joint work with: Dan Bonachea, Jason Duell, Chuck Wallace.
An Introduction to Software Transactional Memory
Discovering and Understanding Performance Bottlenecks in Transactional Applications Ferad Zyulkyarov 1,2, Srdjan Stipic 1,2, Tim Harris 3, Osman S. Unsal.
Microsoft Research Faculty Summit Panacea or Pandora’s Box? Software Transactional Memory Panacea or Pandora’s Box? Christos Kozyrakis Assistant.
Reduced Hardware NOrec: A Safe and Scalable Hybrid Transactional Memory Alexander Matveev Nir Shavit MIT.
VMCAI / POPL 2009 Spy Report. Topics of Interest (I) Semantics of concurrent programs – Programming languages & abstractions – Transactional memory (TM)
CS5204 – Operating Systems Transactional Memory Part 2: Software-Based Approaches.
A Consistency Framework for Iteration Operations in Concurrent Data Structures Yiannis Nikolakopoulos A. Gidenstam M. Papatriantafilou P. Tsigas Distributed.
WG5: Applications & Performance Evaluation Pascal Felber
Writing Systems Software in a Functional Language An Experience Report Iavor Diatchki, Thomas Hallgren, Mark Jones, Rebekah Leslie, Andrew Tolmach.
Shared Memory Consistency Models. SMP systems support shared memory abstraction: all processors see the whole memory and can perform memory operations.
Wait-Free Multi-Word Compare- And-Swap using Greedy Helping and Grabbing Håkan Sundell PDPTA 2009.
ICFEM 2002, Shanghai Reasoning about Hardware and Software Memory Models Abhik Roychoudhury School of Computing National University of Singapore.
© 2008 Multifacet ProjectUniversity of Wisconsin-Madison Pathological Interaction of Locks with Transactional Memory Haris Volos, Neelam Goyal, Michael.
AtomCaml: First-class Atomicity via Rollback Michael F. Ringenburg and Dan Grossman University of Washington International Conference on Functional Programming.
Alpine Verification Meeting 2008 Model Checking Transactional Memories Vasu Singh (Joint work with Rachid Guerraoui, Tom Henzinger, Barbara Jobstmann)
Solving Difficult HTM Problems Without Difficult Hardware Owen Hofmann, Donald Porter, Hany Ramadan, Christopher Rossbach, and Emmett Witchel University.
Specifying Multithreaded Java semantics for Program Verification Abhik Roychoudhury National University of Singapore (Joint work with Tulika Mitra)
A Compositional Method for Verifying Software Transactional Memory Implementations Serdar Tasiran Koç University Istanbul, Turkey Thanks: Rustan Leino,
4 November 2005 CS 838 Presentation 1 Nested Transactional Memory: Model and Preliminary Sketches J. Eliot B. Moss and Antony L. Hosking Presented by:
A BORTING C ONFLICTING T RANSACTIONS IN AN STM PP O PP’09 2/17/2009 Hany Ramadan, Indrajit Roy, Emmett Witchel University of Texas at Austin Maurice Herlihy.
R 1 Transactional abstractions: beyond atomic update Tim Harris r.
Novel Paradigms of Parallel Programming Prof. Smruti R. Sarangi IIT Delhi.
Jim Fawcett CSE775 – Distributed Objects Spring 2017
(Nested) Open Memory Transactions in Haskell
Part 2: Software-Based Approaches
Google File System.
Threads Cannot Be Implemented As a Library
CS216: Data-Intensive Computing Systems
Specifying Multithreaded Java semantics for Program Verification
EECS 582 Midterm Review Mosharaf Chowdhury EECS 582 – F16.
Threads and Memory Models Hal Perkins Autumn 2011
Enforcing Isolation and Ordering in STM Systems
Changing thread semantics
Lecture 6: Transactions
Threads and Memory Models Hal Perkins Autumn 2009
Lecture 22: Consistency Models, TM
Atomic Commit and Concurrency Control
Controlled Interleaving for Transactions
Tim Harris (MSR Cambridge)
Presentation transcript:

We should define semantics for languages, not for TM Tim Harris (MSR Cambridge)

The main argument Language implementation Program Threads, atomic blocks, retry, OrElse TM StartTx, CommitTx, ReadTx, WriteTx H/W Read, Write, CAS We should focus on defining this programmer-visible interface, rather than the internal interface used by the language implementation

An analogy Language implementation Program Garbage collected “infinite” memory GC Low-level, broad, platform-specific API, no canonical def. H/W

How: strong semantics for race-free programs Strong semantics: simple interleaved model of multi- threaded execution T Thread 4 in an atomic block Data race: concurrent accesses to the same location, at least one a write Race-free: no data races (under strong semantics) Write(x)

Implementation 1: “classical” atomic blocks on TM Language implementation Program Threads, atomic blocks, retry, OrElse Strong TM Strong TM Simple transformation Lazy update, opacity, ordering guarantees... H/W

Language implementation Program Threads, atomic blocks, retry, OrElse StartTx, CommitTx, ValidateTx, ReadTx(addr)->val, WriteTx(addr, val) Implementation 2: very weak TM Very weak STM No: –Guarantee that reads see a consistent view of memory –Guarantee that reads/writes don’t “spill over” to adjacent memory –Detection of tx/non-tx conflicts –Publication/privatization safety Yes: –Strict serializability in a tx-only workload Sandboxing for zombies Isolation of tx via MMU Program analyses GC support H/W

Implementation 3: lock inference Language implementation Program Threads, atomic blocks, retry, OrElse Locks Lock, unlock Lock inference analysis H/W

Define semantics for languages, not for TM We should focus on the interface between the language and the programmer –Define it without talking about tx –Permit a range of tx and non-tx implementations In a high-perf implementation, it is hard to cleanly separate the TM from other components –Interface is likely to be broad, platform-specific, and may appear weaker than the language constructs