Hagit Attiya (CS, Technion) Joint work with Rachid Guerraoui (EPFL) Eric Ruppert (York University) Partial Snapshots.

Slides:



Advertisements
Similar presentations
College of Information Technology & Design
Advertisements

Impossibilities for Disjoint-Access Parallel Transactional Memory : Alessia Milani [Guerraoui & Kapalka, SPAA 08] [Attiya, Hillel & Milani, SPAA 09]
© 2005 P. Kouznetsov Computing with Reads and Writes in the Absence of Step Contention Hagit Attiya Rachid Guerraoui Petr Kouznetsov School of Computer.
1 © R. Guerraoui The Power of Registers Prof R. Guerraoui Distributed Programming Laboratory.
Today’s Agenda  Stacks  Queues  Priority Queues CS2336: Computer Science II.
Lower bound for sorting, radix sort COMP171 Fall 2005.
CS 267: Automated Verification Lecture 10: Nested Depth First Search, Counter- Example Generation Revisited, Bit-State Hashing, On-The-Fly Model Checking.
Highly-Concurrent Data Structures Hagit Attiya and Eshcar Hillel Computer Science Department Technion.
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.
Pessimistic Software Lock-Elision Nir Shavit (Joint work with Yehuda Afek Alexander Matveev)
Two Techniques for Proving Lower Bounds Hagit Attiya Technion TexPoint fonts used in EMF. Read the TexPoint manual before you delete this box.: AA A.
Common2 Extended to Stacks Adam Morrison joint with Eli Gafni Yehuda Afek.
A Mile-High View of Concurrent Algorithms Hagit Attiya Technion.
Max Registers, Counters, and Monotone Circuits James Aspnes, Yale University Hagit Attiya, Technion Keren Censor, Technion PODC 2009.
CSE 143 Lecture 4: testing and complexity reading:
Lower bound for sorting, radix sort COMP171 Fall 2006.
Winter School: Hot Topics in Distributed Computing 2010 Algorithms that Adapt to Contention Hagit Attiya (Technion & EPFL)
Algorithmics for Software Transactional Memory Hagit Attiya Technion.
1 Dynamic Atomic Storage Without Consensus Alex Shraer (Technion) Joint work with: Marcos K. Aguilera (MSR), Idit Keidar (Technion), Dahlia Malkhi (MSR.
What Can Be Implemented Anonymously ? Paper by Rachid Guerraui and Eric Ruppert Presentation by Amir Anter 1.
Wait-Free Consensus with Infinite Arrivals James Aspnes Gauri Shah Jatin Shah Yale University STOC 2002.
Locality in Concurrent Data Structures Hagit Attiya Technion.
The Cost of Privatization Hagit Attiya Eshcar Hillel Technion & EPFLTechnion.
Sorting and Searching Algorithms Week 11 DSA. Recap etc. Arrays are lists of data 1-D, 2-D etc. Lists associated with searching and sorting Other structures.
Analysis of Algorithms 7/2/2015CS202 - Fundamentals of Computer Science II1.
Analysis of Algorithms Spring 2015CS202 - Fundamentals of Computer Science II1.
1 © R. Guerraoui Seth Gilbert Professor: Rachid Guerraoui Assistants: M. Kapalka and A. Dragojevic Distributed Programming Laboratory.
CS 312: Algorithm Analysis
Simple Wait-Free Snapshots for Real-Time Systems with Sporadic Tasks Håkan Sundell Philippas Tsigas.
Faster than Optimal Snapshots (for a While) James Aspnes, Yale University Hagit Attiya, Technion Keren Censor-Hillel, MIT Faith Ellen, University of Toronto.
1 Time Analysis Analyzing an algorithm = estimating the resources it requires. Time How long will it take to execute? Impossible to find exact value Depends.
Complexity of algorithms Algorithms can be classified by the amount of time they need to complete compared to their input size. There is a wide variety:
Atomic Snapshots. Abstract Data Types Abstract representation of data & set of methods (operations) for accessing it Implement using primitives on base.
1 CS 430 Database Theory Winter 2005 Lecture 16: Inside a DBMS.
Håkan Sundell, Chalmers University of Technology 1 Simple and Fast Wait-Free Snapshots for Real-Time Systems Håkan Sundell Philippas.
A Consistency Framework for Iteration Operations in Concurrent Data Structures Yiannis Nikolakopoulos A. Gidenstam M. Papatriantafilou P. Tsigas Distributed.
SEMINAR OPEN PROBLEMS IN DISTRIBUTED COMPUTING Winter Hagit Attiya & Faith Ellen Introduction1.
Carnegie Mellon Lecture 14 Loop Optimization and Array Analysis I. Motivation II. Data dependence analysis Chapter , 11.6 Dror E. MaydanCS243:
CSC 221: Recursion. Recursion: Definition Function that solves a problem by relying on itself to compute the correct solution for a smaller version of.
Data Structure Introduction.
Common2 extended to stacks and unbound concurrency By:Yehuda Afek Eli Gafni Adam Morrison May 2007 Presentor: Dima Liahovitsky 1.
Fence Complexity in Concurrent Algorithms Petr Kuznetsov TU Berlin/DT-Labs.
Complexity Implications of Memory Models. Out-of-Order Execution Avoid with fences (and atomic operations) Shared memory processes reordering buffer Hagit.
Max Registers, Counters, and Monotone Circuits Keren Censor, Technion Joint work with: James Aspnes, Yale University Hagit Attiya, Technion (Slides
Heaps and basic data structures David Kauchak cs161 Summer 2009.
Priority Queues, Heaps, and Heapsort CSE 2320 – Algorithms and Data Structures Vassilis Athitsos University of Texas at Arlington 1.
Distributed Algorithms (22903) Lecturer: Danny Hendler The Atomic Snapshot Object The Renaming Problem This presentation is based on the book “Distributed.
Atomic snapshots in O(log³ n) steps using randomized helping James Aspnes, Yale Keren Censor-Hillel, Technion 1.
Building Java Programs Chapter 13 Lecture 13-1: binary search and complexity reading:
SORTING Sorting is storage of data in some order, it can be in ascending or descending order. The term Sorting comes along-with the term Searching. There.
Analysis of Algorithms Spring 2016CS202 - Fundamentals of Computer Science II1.
Priority Queues, Heaps, and Heapsort CSE 2320 – Algorithms and Data Structures Vassilis Athitsos University of Texas at Arlington 1.
Distributed Algorithms (22903) Lecturer: Danny Hendler Approximate agreement This presentation is based on the book “Distributed Computing” by Hagit attiya.
Distributed Algorithms (22903)
Applied Discrete Mathematics Week 2: Functions and Sequences
Analysis of Algorithms
On disjoint access parallelism
Computation.
Distributed Algorithms (22903)
(Slides were added to Keren’s original presentation. DH.)
Lecture 5: complexity reading:
CS 201 Fundamental Structures of Computer Science
Distributed Algorithms (22903)
Distributed Algorithms (22903)
Distributed Algorithms (22903)
Building Java Programs
Distributed Algorithms (22903)
CS210- Lecture 16 July 11, 2005 Agenda Maps and Dictionaries Map ADT
(Slides were added to Keren’s original presentation. DH.)
Presentation transcript:

Hagit Attiya (CS, Technion) Joint work with Rachid Guerraoui (EPFL) Eric Ruppert (York University) Partial Snapshots

June 15, 2008SPAA2 Taking a Full Snapshot n components Update a single component Scan all the components “at once” (atomically) Provides an instantaneous view of the whole memory update ok scan v 1,…,v n

June 16, 2008SPAA3 Taking a Partial Snapshot n components Update a single component Scan components “at once” (atomically) Allows to read parts of the memory Worthwhile if we can do it more efficiently than a (full) scan update ok scan v i1,…,v ir

June 15, 2008SPAA4 Partial Snapshots: Non-Terminating Algorithm Update(v,k) A[k] =  v,seq i, i  PartialScan() repeat read A[i 1 ],…,A[i r ] if equal return A[i 1,…,i r ] double collect [Afek, Attiya, Dolev, Gafni, Merritt, Shavit, JACM 1993] Linearize: Updates with their writes Scans inside the double collects

June 15, 2008SPAA5 Partial Snapshot: Linearizability Double collect (read a set of values twice) If equal, there is no write between the collects –Assuming each write has a new value (seq#) Creates a “safe zone”, where the scan can be linearized read A[i 1 ],…,A[i r ] write A[j]

June 15, 2008SPAA6 Termination? Hat tip [Ellen, Fatuoruo, Ruppert] Embed a scan within the Update. Update(v,k) V = FullScan A[k] =  v,seq i, i,V  PartialScan() repeat read A[i 1 ],…,A[i r ] if equal return A[i 1,…,i r ] if 2 values in same component return V j Linearize: Updates with their writes Direct scans as before Borrowed scans in place direct scan borrowed scan

June 15, 2008SPAA7 Atomic Snapshot: Borrowed Scans Interference by process p j And another one…  p j does a scan inbeteween Linearizing with the borrowed scan is OK. write A[j] read A[j] …… …… embedded scan write A[j] read A[j] …… ……

June 15, 2008SPAA8 More Efficient Update Scan only components needed for overlapping scans But how to know what these are? Active set object: Tracks processes in the execution [Afek, Stupp, Touitou] active set join ok leave ok getSet S

June 15, 2008SPAA9 More Efficient Update Scan only components needed for overlapping scans But how to know what these are? Active set object: Tracks processes in the execution [Afek, Stupp, Touitou] active set p.join ok p.leave ok q.getSet {… …}{…,p,…}

June 15, 2008SPAA10 Partial Scans w/ Active Set Update(v,k) V = EmbeddedScan() A[k] =  v,seq i, i,V  PartialScan() announce {i 1, …, i r } join repeat read A[i 1 ],…,A[i r ]... leave

June 15, 2008SPAA11 Partial Scans w/ Active Set Update(v,k) V = EmbeddedScan() A[k] =  v,seq i, i,V  EmbbededScan() getSet read components repeat double collect needed components... if 3 different values in same component borrow the view

June 15, 2008SPAA12 New Active Set Algorithm To join last …. p 1716

June 15, 2008SPAA13 …. New Active Set Algorithm To leave GetSet reads the array ignoring empty locations last ….,17, p 1716

June 15, 2008SPAA14 Why in the TM Session? I need to catch a flight at 17h25 Partial snapshots are very restricted transactions –PartialScan  read-only transaction –Update  transaction writing to a single location  Understanding them provides a handle on the inherent cost of TM implementations

June 15, 2008SPAA15 Wrap-Up A new object: partial snapshot –Obvious applications –Implications for TM Suggested an approach for solving it using an active set object –New active set algorithms? Esp., less space. –Will have applications to adaptive algorithms. Better algorithms? Lower bounds?