April 8, 2005Transactions Everywhere 1 Bradley C. Kuszmaul Charles E. Leiserson MIT CSAIL Joint research with Scott Ananian, Krste Asanović, Michael A.

Slides:



Advertisements
Similar presentations
Safe Open-Nested Transactions Jim Sukha MIT CSAIL Supercomputing Technologies Group Kunal Agrawal, I-Ting Angelina Lee, Bradley C. Kuszmaul, Charles E.
Advertisements

TRAMP Workshop Some Challenges Facing Transactional Memory Craig Zilles and Lee Baugh University of Illinois at Urbana-Champaign.
U NIVERSITY OF M ASSACHUSETTS, A MHERST Department of Computer Science 1 Three Challenges for Transactional Computing J. Eliot B. Moss Associate Professor,
Multi-core Computing Lecture 3 MADALGO Summer School 2012 Algorithms for Modern Parallel and Distributed Models Phillip B. Gibbons Intel Labs Pittsburgh.
Operating Systems Part III: Process Management (Process Synchronization)
Emmett Witchel Krste Asanović MIT Lab for Computer Science Hardware Works, Software Doesn’t: Enforcing Modularity with Mondriaan Memory Protection.
Transactional Memory Supporting Large Transactions Anvesh Komuravelli Abe Othman Kanat Tangwongsan Hardware-based.
Chapter 6: Process Synchronization
5.1 Silberschatz, Galvin and Gagne ©2009 Operating System Concepts with Java – 8 th Edition Chapter 5: CPU Scheduling.
Closest Point Transform: The Characteristics/Scan Conversion Algorithm Sean Mauch Caltech April, 2003.
Nested Parallelism in Transactional Memory Kunal Agrawal, Jeremy T. Fineman and Jim Sukha MIT.
Race Conditions. Isolated & Non-Isolated Processes Isolated: Do not share state with other processes –The output of process is unaffected by run of other.
Chapter 13 Embedded Systems
Progress Guarantee for Parallel Programs via Bounded Lock-Freedom Erez Petrank – Technion Madanlal Musuvathi- Microsoft Bjarne Steensgaard - Microsoft.
PARALLEL PROGRAMMING with TRANSACTIONAL MEMORY Pratibha Kona.
By Sarita Adve & Kourosh Gharachorloo Review by Jim Larson Shared Memory Consistency Models: A Tutorial.
Disk Drivers May 10, 2000 Instructor: Gary Kimura.
Capriccio: Scalable Threads for Internet Services Rob von Behren, Jeremy Condit, Feng Zhou, Geroge Necula and Eric Brewer University of California at Berkeley.
Chapter 13 Embedded Systems
Chapter 16 Programming and Languages: Telling the Computer What to Do.
Unbounded Transactional Memory Paper by Ananian et al. of MIT CSAIL Presented by Daniel.
1 Sharing Objects – Ch. 3 Visibility What is the source of the issue? Volatile Dekker’s algorithm Publication and Escape Thread Confinement Immutability.
A Transaction-Friendly Dynamic Memory Manager for Embedded Multicore Systems Maurice Herlihy Joint with Thomas Carle, Dimitra Papagiannopoulou Iris Bahar,
Operating Systems CSE 411 CPU Management Oct Lecture 13 Instructor: Bhuvan Urgaonkar.
Exceptions and Mistakes CSE788 John Eisenlohr. Big Question How can we improve the quality of concurrent software?
Introduction to High-Level Language Programming
1 Layers of Computer Science, ISA and uArch Alexander Titov 20 September 2014.
CS 346 – Chapter 8 Main memory –Addressing –Swapping –Allocation and fragmentation –Paging –Segmentation Commitment –Please finish chapter 8.
Microsoft Research Faculty Summit Panacea or Pandora’s Box? Software Transactional Memory Panacea or Pandora’s Box? Christos Kozyrakis Assistant.
CGS 3763 Operating Systems Concepts Spring 2013 Dan C. Marinescu Office: HEC 304 Office hours: M-Wd 11: :30 AM.
CS 346 – Chapter 1 Operating system – definition Responsibilities What we find in computer systems Review of –Instruction execution –Compile – link – load.
CDP 2013 Based on “C++ Concurrency In Action” by Anthony Williams, The C++11 Memory Model and GCCThe C++11 Memory Model and GCC Wiki and Herb Sutter’s.
Ivan Lanese Computer Science Department University of Bologna/INRIA Italy Causal-Consistent Reversibility in a Tuple-Based Language Joint work with Elena.
TECHNIQUES FOR REDUCING CONSISTENCY- RELATED COMMUNICATION IN DISTRIBUTED SHARED-MEMORY SYSTEMS J. B. Carter University of Utah J. K. Bennett and W. Zwaenepoel.
Ananian/Asanović/Kuszmaul/Leiserson/Lie: Unbounded Transactional Memory, HPCA '05 (1) Unbounded Transactional Memory C. Scott Ananian, Krste Asanović,
COMP 111 Threads and concurrency Sept 28, Tufts University Computer Science2 Who is this guy? I am not Prof. Couch Obvious? Sam Guyer New assistant.
Colorama: Architectural Support for Data-Centric Synchronization Luis Ceze, Pablo Montesinos, Christoph von Praun, and Josep Torrellas, HPCA 2007 Shimin.
Algorithms & Flowchart
The Fresh Breeze Memory Model Status: Linear Algebra and Plans Guang R. Gao Jack Dennis MIT CSAIL University of Delaware Funded in part by NSF HECURA Grant.
Shared Memory Consistency Models. SMP systems support shared memory abstraction: all processors see the whole memory and can perform memory operations.
Speculative Execution in a Distributed File System Ed Nightingale Peter Chen Jason Flinn University of Michigan.
1 3. Computing System Fundamentals 3.1 Language Translators.
CS510 Concurrent Systems Why the Grass May Not Be Greener on the Other Side: A Comparison of Locking and Transactional Memory.
Parallelism without Concurrency Charles E. Leiserson MIT.
Software Transactional Memory Should Not Be Obstruction-Free Robert Ennals Presented by Abdulai Sei.
Operating Systems CSE 411 CPU Management Dec Lecture Instructor: Bhuvan Urgaonkar.
Detecting Atomicity Violations via Access Interleaving Invariants
CSE 153 Design of Operating Systems Winter 2015 Midterm Review.
Concurrent Cache-Oblivious B-trees Using Transactional Memory
Kernel Synchronization in Linux Uni-processor and Multi-processor Environment By Kathryn Bean and Wafa’ Jaffal (Group A3)
Ananian/Asanović/Kuszmaul/Leiserson/Lie: Unbounded Transactional Memory, HPCA '05 (1) Unbounded Transactional Memory C. Scott Ananian, Krste Asanović,
1 Controlled concurrency Now we start looking at what kind of concurrency we should allow We first look at uncontrolled concurrency and see what happens.
The C++11 Memory Model CDP Based on “C++ Concurrency In Action” by Anthony Williams, The C++11 Memory Model and GCCThe C++11 Memory Model and GCC Wiki.
Gauss Students’ Views on Multicore Processors Group members: Yu Yang (presenter), Xiaofang Chen, Subodh Sharma, Sarvani Vakkalanka, Anh Vo, Michael DeLisi,
Process Synchronization. Objectives To introduce the critical-section problem, whose solutions can be used to ensure the consistency of shared data To.
Rely: Verifying Quantitative Reliability for Programs that Execute on Unreliable Hardware Michael Carbin, Sasa Misailovic, and Martin Rinard MIT CSAIL.
Tools and Libraries for Manycore Computing Kathy Yelick U.C. Berkeley and LBNL.
Kernel Synchronization David Ferry, Chris Gill CSE 522S - Advanced Operating Systems Washington University in St. Louis St. Louis, MO
Transactional Memory : Hardware Proposals Overview
Challenges in Concurrent Computing
143a discussion session week 3
Chapter 8: Memory management
Threads and Memory Models Hal Perkins Autumn 2009
Concurrency: Mutual Exclusion and Process Synchronization
Design and Implementation Issues for Atomicity
Introduction to Computer Systems
Transactions with Nested Parallelism
Lecture 24: Multiprocessors
Concurrent Cache-Oblivious B-trees Using Transactional Memory
COT 5611 Operating Systems Design Principles Spring 2014
Presentation transcript:

April 8, 2005Transactions Everywhere 1 Bradley C. Kuszmaul Charles E. Leiserson MIT CSAIL Joint research with Scott Ananian, Krste Asanović, Michael A. Bender, Martin Farach- Colton, Sean Lie, Gideon Stupp, and Jim Sukha. This research was supported in part by NSF Grant ACI “Transactions Everywhere,” by NSF Grant CNS , and by the Singapore-MIT Alliance.

April 8, 2005Transactions Everywhere 2 Transaction Bounds Definition. A transactional-memory system is bounded in duration if there exists a finite upper bound T on the time any xaction can execute. Definition. A transactional-memory system is bounded in footprint if there exists a finite upper bound B on the number of locations any xaction can access. Definition. A transactional-memory system is unbounded if it supports xactions of arbitrary duration and footprint.

April 8, 2005Transactions Everywhere 3 We have developed a hardware mechanism that is fast for small xactions and correct for large xactions. We automatically converted the lock-based Linux kernel to use xactions. 100% Xaction Footprint (64-Byte Cache Lines) 10% 0.1% 0.001% make dbench % Xactions That Are Bigger The largest xaction accesses over 8000 cache lines. 99.9% of xactions fit in 54 cache lines. Distribution of Footprint 1% % 0.01% %

April 8, 2005Transactions Everywhere 4 Transactional Linguistics We are experimenting with two languages: Transactional Cilk (XCilk) Transactional Java (XJava) Philosophy: Start with a correct program, and then speed it up; not start with a fast, incorrect program, and then add critical regions. Preliminary conclusions: Need unbounded xactions. The nonpreemptive scheduling semantics of yore provide a good model. Nonatomicity composes; atomicity does not.

April 8, 2005Transactions Everywhere 5 Fallacy of Bounded Xactions Our Thesis Only unbounded xactions can serve as a general tool for building large-scale software systems. Our Thesis Only unbounded xactions can serve as a general tool for building large-scale software systems. Q. What should the programmer or compiler do with a xaction that requires longer duration than T or larger footprint than B? A. We don’t know. But, unless a good answer can be found (and we’re doubtful), bounded xactions seem to be fatally flawed. *Okay, but in practice, nothing is unbounded. For example, is the size of physical memory a big enough bound on footprint? Sure would make the hardware easier! *

April 8, 2005Transactions Everywhere 6 Toward Transactions Everywhere Guaranteeing forward progress should not be left up to the application. The x-system (HW, OS, compiler) must solve it. Unfortunately, race detection is algorithmically harder with xactions than with locks. The x-mechanism must provide a semantic loophole for logging, debugging, and I/O. Semantics of x-consistency may actually speed up hardware. Stronger concurrency control in HW? E.g., read-only xactions always complete. How visible is the x-state, and how should the OS deal with it if it is invisible?