CSE 613: Parallel Programming. Lecture 17 ( Concurrent Data Structures: Queues and Stacks )
|
|
|
- Joseph Reynard Stewart
- 6 years ago
- Views:
Transcription
1 CSE 613: Parallel Programming Lecture 17 ( Concurrent Data Structures: Queues and Stacks ) Rezaul A. Chowdhury Department of Computer Science SUNY Stony Brook Spring 2012
2 Desirable Properties of Concurrent Objects Safety Property Nothing bad ever happens Needed for correctness Liveness Property Something good eventually happens Needed for progress ( e.g., no deadlock )
3 Correctness Properties Sequential Consistency Method calls should appear to happen in a one-at-a-time sequential order For each thread method calls should appear to take effect in program order Thread 1 q.enq( x) q.deq( y) Thread 2 q.enq( y) q.deq( x)
4 Correctness Properties Sequential Consistency Method calls should appear to happen in a one-at-a-time sequential order For each thread method calls should appear to take effect in program order Thread 1 q.enq( x) q.enq( y) q.deq( x) q.deq( y) Thread 2 Sequentially Consistent ( one way )
5 Correctness Properties Sequential Consistency Method calls should appear to happen in a one-at-a-time sequential order For each thread method calls should appear to take effect in program order Thread 1 q.enq( y) q.enq( x) q.deq( y) q.deq( x) Thread 2 Sequentially Consistent ( another way )
6 Correctness Properties Sequential Consistency Method calls should appear to happen in a one-at-a-time sequential order For each thread method calls should appear to take effect in program order Sequential Consistency is not compositional Thread 1 p.enq( x) q.enq( x) p.deq( y) Thread 2 q.enq( y) p.enq( y) q.deq( x)
7 Correctness Properties Sequential Consistency Method calls should appear to happen in a one-at-a-time sequential order For each thread method calls should appear to take effect in program order Sequential Consistency is not compositional Thread 1 p.enq( x) q.enq( x) p.deq( y) Thread 2 q.enq( y) p.enq( y) q.deq( x) p and q are independently sequentially consistent, but their composition is not
8 Correctness Properties Linearizability Each method call should appear to take effect instantaneously at some moment between its invocation and response Compositional Thread 1 q.enq( x) q.deq( y) Thread 2 q.enq( y) q.deq( x) Time
9 Correctness Properties Linearizability Each method call should appear to take effect instantaneously at some moment between its invocation and response Compositional Thread 1 q.enq( x) q.deq( y) Thread 2 q.enq( y) q.deq( x) Linearizable Time
10 Correctness Properties Linearizability Each method call should appear to take effect instantaneously at some moment between its invocation and response Compositional Thread 1 q.enq( x) q.deq( y) Thread 2 q.enq( y) Time
11 Correctness Properties Linearizability Each method call should appear to take effect instantaneously at some moment between its invocation and response Compositional Thread 1 q.enq( x) q.deq( y) Thread 2 q.enq( y) Not Linearizable Time
12 Correctness Properties Linearizability Each method call should appear to take effect instantaneously at some moment between its invocation and response Compositional Thread 1 q.enq( x) q.deq( y) Thread 2 q.enq( y) q.deq( x) Time
13 Correctness Properties Linearizability Each method call should appear to take effect instantaneously at some moment between its invocation and response Compositional Thread 1 q.enq( x) q.deq( y) Thread 2 q.enq( y) q.deq( x) Linearizable ( one way ) Time
14 Correctness Properties Linearizability Each method call should appear to take effect instantaneously at some moment between its invocation and response Compositional Thread 1 q.enq( x) q.deq( y) Thread 2 q.enq( y) q.deq( x) Linearizable ( another way ) Time
15 Correctness Properties Linearizability Each method call should appear to take effect instantaneously at some moment between its invocation and response Compositional Thread 1 push( x) pop( y) push( z) Thread 2 push( y) pop( x) Time
16 Correctness Properties Linearizability Each method call should appear to take effect instantaneously at some moment between its invocation and response Compositional Thread 1 push( x) pop( y) push( z) Thread 2 push( y) pop( x) Not Linearizable Time
17 A Bounded Lock-Based Queue 1. public class BoundedQueue< T > { 2. ReentrantLock enqlock, deqlock; 3. Condition notemptycondition, notfullcondition; 4. AtomicInteger size; 5. Node head, tail; 6. int capacity; 7. public BoundedQueue( int _capacity ) { 8. capacity = _capacity; 9. head = new Node( null ); 10. tail = head; 11. size = new AtomicInteger( 0 ); 12. enqlock = new ReentrantLock( ); 13. notfullcondition = enqlock.newcondition( ); 14. deqlock = new ReentrantLock( ); 15. notemptycondition = deqlock.newcondition( ); 16. } head tail null 1. protected class Node { 2. public T value; 3. public Node next; 4. public Node( T x ) { 5. value = x; 6. next = null; 7. } 8. } Source:Herlihy & Shavit., The Art of Multiprocessor Programming, 1 st Edition
18 A Bounded Lock-Based Queue: Enqueue 1. public void enq( T x ) { 2. boolean mustwakedequeuers = false; 3. enqlock.lock( ); 4. try { 5. while ( size.get( ) == capacity ) 6. notfullcondition.await( ); 7. Node e = new Node( x ); 8. tail.next = tail = e; 9. if ( size.getandincrement( ) == 0 ) 10. mustwakedequeuers = true; 11. } finally { 12. enqlock.unlock( ); 13. } 14. if ( mustwakedequeuers ) { 15. deqlock.lock( ); 16. try { 17. notemptycondition.signalall( ); 18. } finally { 19. deqlock.unlock( ); 20. } 21. } 22. } Source:Herlihy & Shavit., The Art of Multiprocessor Programming, 1 st Edition head null e f tail g
19 A Bounded Lock-Based Queue: Enqueue 1. public void enq( T x ) { 2. boolean mustwakedequeuers = false; 3. enqlock.lock( ); 4. try { 5. while ( size.get( ) == capacity ) 6. notfullcondition.await( ); 7. Node e = new Node( x ); 8. tail.next = tail = e; 9. if ( size.getandincrement( ) == 0 ) 10. mustwakedequeuers = true; 11. } finally { 12. enqlock.unlock( ); 13. } 14. if ( mustwakedequeuers ) { 15. deqlock.lock( ); 16. try { 17. notemptycondition.signalall( ); 18. } finally { 19. deqlock.unlock( ); 20. } 21. } 22. } Source:Herlihy & Shavit., The Art of Multiprocessor Programming, 1 st Edition head null e f tail g
20 A Bounded Lock-Based Queue: Dequeue 1. public T deq( ) { 2. T result; 3. boolean mustwakeenqueuers = false; 4. deqlock.lock( ); 5. try { 6. while ( size.get( ) == 0 ) 7. notemptycondition.await( ); 8. result = head.next.value; 9. head = head.next; 10. if ( size.getanddecrement( ) == capacity ) { 11. mustwakeenqueuers = true; 12. } 13. } finally { deqlock.unlock( ); } 14. if ( mustwakeenqueuers ) { 15. enqlock.lock( ); 16. try { 17. notfullcondition.signalall( ); 18. } finally { enqlock.unlock( ); } 19. } 20. return result; 21. } Source:Herlihy & Shavit., The Art of Multiprocessor Programming, 1 st Edition head null e f tail
21 A Bounded Lock-Based Queue: Dequeue 1. public T deq( ) { 2. T result; 3. boolean mustwakeenqueuers = true; 4. deqlock.lock( ); 5. try { 6. while ( size.get( ) == 0 ) 7. notemptycondition.await( ); 8. result = head.next.value; 9. head = head.next; 10. if ( size.getandincrement( ) == capacity ) { 11. mustwakeenqueuers = true; 12. } 13. } finally { deqlock.unlock( ); } 14. if ( mustwakeenqueuers ) { 15. enqlock.lock( ); 16. try { 17. notfullcondition.signalall( ); 18. } finally { enqlock.unlock( ); } 19. } 20. return result; 21. } Source:Herlihy & Shavit., The Art of Multiprocessor Programming, 1 st Edition head null e f tail
22 A Bounded Lock-Based Queue: Dequeue 1. public T deq( ) { 2. T result; 3. boolean mustwakeenqueuers = true; 4. deqlock.lock( ); head tail 5. try { 6. while ( size.get( ) == 0 ) 7. notemptycondition.await( ); 8. result = head.next.value; null null f 9. head = head.next; 10. if ( size.getandincrement( ) == capacity ) { 11. mustwakeenqueuers = true; 12. } 13. } finally { deqlock.unlock( ); } 14. if ( mustwakeenqueuers ) { 15. enqlock.lock( ); 16. try { 17. notfullcondition.signalall( ); 18. } finally { enqlock.unlock( ); } 19. } 20. return result; 21. } Source:Herlihy & Shavit., The Art of Multiprocessor Programming, 1 st Edition e
23 A Bounded Lock-Based Queue: Dequeue 1. public T deq( ) { 2. T result; 3. boolean mustwakeenqueuers = true; 4. deqlock.lock( ); 5. try { 6. while ( size.get( ) == 0 ) 7. notemptycondition.await( ); 8. result = head.next.value; 9. head = head.next; 10. if ( size.getandincrement( ) == capacity ) { 11. mustwakeenqueuers = true; 12. } 13. } finally { deqlock.unlock( ); } 14. if ( mustwakeenqueuers ) { 15. enqlock.lock( ); 16. try { 17. notfullcondition.signalall( ); 18. } finally { enqlock.unlock( ); } 19. } 20. return result; 21. } Source:Herlihy & Shavit., The Art of Multiprocessor Programming, 1 st Edition head e null f tail
24 An Unbounded Lock-Free Queue head tail null 1. public class Node { 2. public T value; 3. public AtomicReference< Node > next; 4. public Node( T _value ) { 5. value = _value; 6. next = new AtomicReference< Node >( null ); 7. } 8. } Source:Herlihy & Shavit., The Art of Multiprocessor Programming, 1 st Edition
25 An Unbounded Lock-Free Queue: Enqueue head tail null e f 2. CAS tail 1. public void enq( T value ) { 2. Node node = new Node( value ); 3. while ( true ) { 4. Node last = tail.get( ); 5. Node next = last.next.get( ); 6. if ( last == tail.get( ) ) { 7. if ( next == null ) { 8. if ( last.next.compareandset( next, node ) ) { 9. tail.compareandset( last, node ); 10. return; 11. } 12. } else { tail.compareandset( last, next ); } 13. } 14. } 15. } 1. CAS next Source:Herlihy & Shavit., The Art of Multiprocessor Programming, 1 st Edition g
26 An Unbounded Lock-Free Queue: Dequeue 1. public T deq( ) throws EmptyException { 2. while ( true ) { 3. Node first = head.get( ); 4. Node last = tail.get( ); 5. Node next = first.next.get( ); 6. if ( first == head.get( ) ) { 7. if ( first == last ) { 8. if ( next == null ) { 9. throw new EmptyException( ); 10. } 11. tail.compareandset( last, next ); 12. } else { 13. T value = next.value; 14. if ( head.compareandset( first, next ) ) 15. return value; 16. } 17. } 18. } 19. } Source:Herlihy & Shavit., The Art of Multiprocessor Programming, 1 st Edition
27 Exponential Backoff 1. public class Backoff { 2. final int mindelay, maxdelay; 3. int limit; 4. final Random rand; 5. public Backoff( int min, int max ) { 6. mindelay = min; 7. maxdelay = min; 8. limit = mindelay; 9. rand = new Random( ); 10. } 11. public void backoff( ) throws InterruptedException { 12. int delay = rand.nextint( limit ); 13. limit = Math.min( maxdelay, 2 * limit ); 14. Thread.sleep( delay ); 15. } 16. } Source:Herlihy & Shavit., The Art of Multiprocessor Programming, 1 st Edition
28 An Unbounded Lock-Free Stack 1. public class LockFreeStack< T > { 2. AtomicReference< Node > top = new AtomicReference< Node >( null ); 3. static final int MIN_DELAY =...; 4. static final int MAX_DELAY =...; 5. Backoff backoff = new Backoff( MIN_DELAY, MAX_DELAY ); 6. protected class Node { 7. public T value; 8. public Node next; 9. public Node( T _value ) { 10. value = _value; 11. next = null; 12. } 13. } Source:Herlihy & Shavit., The Art of Multiprocessor Programming, 1 st Edition
29 An Unbounded Lock-Free Stack: Push top d e f c 1. protected boolean trypush( Node node ) { 2. Node oldtop = top.get( ); 3. node.next = oldtop; 4. return ( top.compareandset( oldtop, node ) ); 5. } 6. public void push( T value ) { 7. Node node = new Node( value ); 8. while ( true ) { 9. if ( trypush( node ) ) { return; } 10. else { backoff.backoff( ); } 11. } 12. } Source:Herlihy & Shavit., The Art of Multiprocessor Programming, 1 st Edition
30 An Unbounded Lock-Free Stack: Push top d e f c 1. protected boolean trypush( Node node ) { 2. Node oldtop = top.get( ); 3. node.next = oldtop; 4. return ( top.compareandset( oldtop, node ) ); 5. } 6. public void push( T value ) { 7. Node node = new Node( value ); 8. while ( true ) { 9. if ( trypush( node ) ) { return; } 10. else { backoff.backoff( ); } 11. } 12. } Source:Herlihy & Shavit., The Art of Multiprocessor Programming, 1 st Edition
31 An Unbounded Lock-Free Stack: Push CAS top d e f c 1. protected boolean trypush( Node node ) { 2. Node oldtop = top.get( ); 3. node.next = oldtop; 4. return ( top.compareandset( oldtop, node ) ); 5. } 6. public void push( T value ) { 7. Node node = new Node( value ); 8. while ( true ) { 9. if ( trypush( node ) ) { return; } 10. else { backoff.backoff( ); } 11. } 12. } Source:Herlihy & Shavit., The Art of Multiprocessor Programming, 1 st Edition
32 An Unbounded Lock-Free Stack: Pop top d e f 1. protected Node trypop( ) throws EmptyException { 2. Node oldtop = top.get( ); 3. if ( oldtop == null ) { 4. throw new EmptyException( ); 5. } 6. Node newtop = oldtop.next; 7. if ( top.compareandset( oldtop, newtop ) ) { return oldtop; } 8. else { return null; } 9. } 10. public T pop( ) throws EmptyException { 11. while ( true ) { 12. Node returnnode = trypop( ); 13. if ( returnnode!= null ) { return returnnode.value; } 14. else { backoff.backoff( ); } 15. } 16. } Source:Herlihy & Shavit., The Art of Multiprocessor Programming, 1 st Edition
33 An Unbounded Lock-Free Stack: Pop top CAS d e f 1. protected Node trypop( ) throws EmptyException { 2. Node oldtop = top.get( ); 3. if ( oldtop == null ) { 4. throw new EmptyException( ); 5. } 6. Node newtop = oldtop.next; 7. if ( top.compareandset( oldtop, newtop ) ) { return oldtop; } 8. else { return null; } 9. } 10. public T pop( ) throws EmptyException { 11. while ( true ) { 12. Node returnnode = trypop( ); 13. if ( returnnode!= null ) { return returnnode.value; } 14. else { backoff.backoff( ); } 15. } 16. } Source:Herlihy & Shavit., The Art of Multiprocessor Programming, 1 st Edition
34 Elimination-Backoff Stack C: pop () A: return (b) C: return (d) A: pop () top B: push (b) d e f Shared Lock-Free Stack Lock-Free Elimination Array B: return ()
35 Elimination Array 1. public class EliminationArray< T > { 2. private static final int duration =...; 3. LockFreeExchanger< T >[ ] exchanger; 4. Random rand; 5. public EliminationArray( int capacity ) { 6. exchanger = ( LockFreeExchanger< T >[ ] ) new LockFreeExchanger[ capacity ]; 7. for ( int i = 0; i < capacity; i++ ) { 8. exchanger[ i ] = new LockFreeExchanger< T >( ); 9. } 10. rand = new Random( ); 11. } 12. public T visit( T value, int range ) throws TimeoutException { 13. int slot = rand.nextint( range ); 14. return ( exchanger[ slot ].exchange( value, duration, TimeUnit.MILLISECONDS ) ); 15. } 16. } Source:Herlihy & Shavit., The Art of Multiprocessor Programming, 1 st Edition
36 An Unbounded Lock-Free Elimination-Backoff Stack 1. public class EliminationBackoffStack< T > extends LockFreeStack< T > { 2. static final int capacity =...; 3. EliminationArray< T > eliminationarray = new EliminationArray< T >( capacity ); 4. static int range =...; 5. public void push( T value ) { 6. Node node = new Node( value ); 7. while ( true ) { 8. if ( trypush( node ) ) { return; } 9. else try { 10. T othervalue = eliminationarray.visit( value, range ); 11. if ( othervalue == null ) { return; } // exchanged with pop 12. } catch ( TimeoutException ex ) { } 13. } 14. } Source:Herlihy & Shavit., The Art of Multiprocessor Programming, 1 st Edition ( modified )
37 An Unbounded Lock-Free Elimination-Backoff Stack 1. public T pop( ) throws EmptyException { 2. while ( true ) { 3. Node returnnode = trypop( ); 4. if ( returnnode!= null ) { return returnnode.value; } 5. else try { 6. T othervalue = eliminationarray.visit( null, range ); 7. if ( othervalue!= null ) { return othervalue; } 8. } catch ( TimeoutException ex ) { } 9. } 10. } Source:Herlihy & Shavit., The Art of Multiprocessor Programming, 1 st Edition ( modified )
Concurrent Queues, Monitors, and the ABA problem. Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit
Concurrent Queues, Monitors, and the ABA problem Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit Queues Often used as buffers between producers and consumers
The Five-Fold Path. Queues & Stacks. Bounded vs Unbounded. Blocking vs Non-Blocking. Concurrent Queues and Stacks. Another Fundamental Problem
Concurrent Queues and Stacks The Five-Fold Path Coarse-grained locking Fine-grained locking Optimistic synchronization Lazy synchronization Lock-free synchronization 2 Another Fundamental Problem Queues
Blocking Non-blocking Caveat:
Overview of Lecture 5 1 Progress Properties 2 Blocking The Art of Multiprocessor Programming. Maurice Herlihy and Nir Shavit. Morgan Kaufmann, 2008. Deadlock-free: some thread trying to get the lock eventually
Concurrent Queues and Stacks. Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit
Concurrent Queues and Stacks Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit The Five-Fold Path Coarse-grained locking Fine-grained locking Optimistic synchronization
Programming Paradigms for Concurrency Lecture 3 Concurrent Objects
Programming Paradigms for Concurrency Lecture 3 Concurrent Objects Based on companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit Modified by Thomas Wies New York University
Programming Language Seminar Concurrency 2: Lock-free algorithms
Programming Language Seminar Concurrency 2: Lock-free algorithms Peter Sestoft Friday 2013-11-01 1 Outline for today Compare-and-swap instruction Atomic test-then-set operation Implemented directly in
Concurrent Objects. Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit
Concurrent Objects Companion slides for The by Maurice Herlihy & Nir Shavit Concurrent Computation memory object object 2 Objectivism What is a concurrent object? How do we describe one? How do we implement
Review of last lecture. Goals of this lecture. DPHPC Overview. Lock-based queue. Lock-based queue
Review of last lecture Design of Parallel and High-Performance Computing Fall 2013 Lecture: Linearizability Instructor: Torsten Hoefler & Markus Püschel TA: Timo Schneider Cache-coherence is not enough!
Introduction. Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit
Introduction Companion slides for The by Maurice Herlihy & Nir Shavit Moore s Law Transistor count still rising Clock speed flattening sharply 2 Moore s Law (in practice) 3 Nearly Extinct: the Uniprocesor
Introduction to Concurrency and Multicore Programming. Slides adapted from Art of Multicore Programming by Herlihy and Shavit
Introduction to Concurrency and Multicore Programming Slides adapted from Art of Multicore Programming by Herlihy and Shavit Overview Introduction Mutual Exclusion Linearizability Concurrent Data Structure
Unit 6: Indeterminate Computation
Unit 6: Indeterminate Computation Martha A. Kim October 6, 2013 Introduction Until now, we have considered parallelizations of sequential programs. The parallelizations were deemed safe if the parallel
Concurrent Objects and Linearizability
Chapter 3 Concurrent Objects and Linearizability 3.1 Specifying Objects An object in languages such as Java and C++ is a container for data. Each object provides a set of methods that are the only way
10/27/11. Is The Queue Correct? Concurrent Computaton. Objects. A Concurrent FIFO Queue head. A Concurrent FIFO Queue head
DD2451 Parallel and Distributed Computing --- FDD3008 Distributed Algorithms Lecture 2 Concurrent Objects memory Concurrent Computaton Mads Dam Autumn/Winter 2011 object object Art of Mul/processor 2 Objects
Whatever can go wrong will go wrong. attributed to Edward A. Murphy. Murphy was an optimist. authors of lock-free programs 3.
Whatever can go wrong will go wrong. attributed to Edward A. Murphy Murphy was an optimist. authors of lock-free programs 3. LOCK FREE KERNEL 309 Literature Maurice Herlihy and Nir Shavit. The Art of Multiprocessor
DD2451 Parallel and Distributed Computing --- FDD3008 Distributed Algorithms
DD2451 Parallel and Distributed Computing --- FDD3008 Distributed Algorithms Lecture 2 Concurrent Objects Mads Dam Autumn/Winter 2011 Concurrent Computaton memory object object Art of Mul*processor 2 Objects
Data Structures in the Multicore Age
DOI:0.45/897852.897873 The advent of multicore processors as the standard computing platform will force major changes in software design. BY NIR SHAVIT Data Structures in the Multicore Age MULTICORE PROCESSORS
Whatever can go wrong will go wrong. attributed to Edward A. Murphy. Murphy was an optimist. authors of lock-free programs LOCK FREE KERNEL
Whatever can go wrong will go wrong. attributed to Edward A. Murphy Murphy was an optimist. authors of lock-free programs LOCK FREE KERNEL 251 Literature Maurice Herlihy and Nir Shavit. The Art of Multiprocessor
Review of last lecture. Peer Quiz. DPHPC Overview. Goals of this lecture. Lock-based queue
Review of last lecture Design of Parallel and High-Performance Computing Fall 2016 Lecture: Linearizability Motivational video: https://www.youtube.com/watch?v=qx2driqxnbs Instructor: Torsten Hoefler &
Modern High-Performance Locking
Modern High-Performance Locking Nir Shavit Slides based in part on The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit Locks (Mutual Exclusion) public interface Lock { public void lock();
Spin Locks and Contention. Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit
Spin Locks and Contention Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit Real world concurrency Understanding hardware architecture What is contention How to
Sequen&al Consistency and Linearizability
Sequen&al Consistency and Linearizability (Or, Reasoning About Concurrent Objects) Acknowledgement: Slides par&ally adopted from the companion slides for the book "The Art of Mul&processor Programming"
CS171 Midterm Exam. October 29, Name:
CS171 Midterm Exam October 29, 2012 Name: You are to honor the Emory Honor Code. This is a closed-book and closed-notes exam. You have 50 minutes to complete this exam. Read each problem carefully, and
Introduction to Multiprocessor Synchronization
Introduction to Multiprocessor Synchronization Maurice Herlihy http://cs.brown.edu/courses/cs176/lectures.shtml Moore's Law Transistor count still rising Clock speed flattening sharply Art of Multiprocessor
Linked Structures. See Section 3.2 of the text.
Linked Structures See Section 3.2 of the text. First, notice that Java allows classes to be recursive, in the sense that a class can have an element which is itself an object of that class: class Person
Advances in Programming Languages
O T Y H Advances in Programming Languages APL5: Further language concurrency mechanisms David Aspinall (including slides by Ian Stark) School of Informatics The University of Edinburgh Tuesday 5th October
CS 241 Honors Concurrent Data Structures
CS 241 Honors Concurrent Data Structures Bhuvan Venkatesh University of Illinois Urbana Champaign March 27, 2018 CS 241 Course Staff (UIUC) Lock Free Data Structures March 27, 2018 1 / 43 What to go over
A linear-list Data Structure where - addition of elements to and - removal of elements from are restricted to the first element of the list.
A linear-list Data Structure where - addition of elements to and - removal of elements from are restricted to the first element of the list. the first element of the list a new element to (the Top of)
Spin Locks and Contention. Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit
Spin Locks and Contention Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit Focus so far: Correctness and Progress Models Accurate (we never lied to you) But idealized
Spin Locks and Contention
Spin Locks and Contention Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit Modified for Software1 students by Lior Wolf and Mati Shomrat Kinds of Architectures
8. Fundamental Data Structures
172 8. Fundamental Data Structures Abstract data types stack, queue, implementation variants for linked lists, [Ottman/Widmayer, Kap. 1.5.1-1.5.2, Cormen et al, Kap. 10.1.-10.2] Abstract Data Types 173
Linearizability Testing Manual
Linearizability Testing Manual Gavin Lowe April 8, 2016 This manual describes how to use the linearizability testing framework, described in [Low16]. The framework is available from http://www.cs.ox. ac.uk/people/gavin.lowe/linearizabiltytesting/.
CS 351 Design of Large Programs Threads and Concurrency
CS 351 Design of Large Programs Threads and Concurrency Brooke Chenoweth University of New Mexico Spring 2018 Concurrency in Java Java has basic concurrency support built into the language. Also has high-level
Abstract Data Types. Abstract Data Types
Abstract Data Types Wolfgang Schreiner Research Institute for Symbolic Computation (RISC) Johannes Kepler University, Linz, Austria Wolfgang.Schreiner@risc.jku.at http://www.risc.jku.at Wolfgang Schreiner
A Non-Blocking Concurrent Queue Algorithm
A Non-Blocking Concurrent Queue Algorithm Bruno Didot bruno.didot@epfl.ch June 2012 Abstract This report presents a new non-blocking concurrent FIFO queue backed by an unrolled linked list. Enqueue and
Fine-grained synchronization & lock-free data structures
Lecture 19: Fine-grained synchronization & lock-free data structures Parallel Computer Architecture and Programming Redo Exam statistics Example: a sorted linked list struct Node { int value; Node* next;
Fine-grained synchronization & lock-free programming
Lecture 17: Fine-grained synchronization & lock-free programming Parallel Computer Architecture and Programming CMU 15-418/15-618, Spring 2016 Tunes Minnie the Moocher Robbie Williams (Swings Both Ways)
CS510 Concurrent Systems. Jonathan Walpole
CS510 Concurrent Systems Jonathan Walpole Simple, Fast, and Practical Non-Blocking and Blocking Concurrent Queue Algorithms utline Background Non-Blocking Queue Algorithm Two Lock Concurrent Queue Algorithm
Overview of Lecture 4. Memory Models, Atomicity & Performance. Ben-Ari Concurrency Model. Dekker s Algorithm 4
Concurrent and Distributed Programming http://fmt.cs.utwente.nl/courses/cdp/ Overview of Lecture 4 2 Memory Models, tomicity & Performance HC 4 - Tuesday, 6 December 2011 http://fmt.cs.utwente.nl/~marieke/
Keeping Order:! Stacks, Queues, & Deques. Travis W. Peters Dartmouth College - CS 10
Keeping Order:! Stacks, Queues, & Deques 1 Stacks 2 Stacks A stack is a last in, first out (LIFO) data structure Primary Operations: push() add item to top pop() return the top item and remove it peek()
Spin Locks and Contention. Companion slides for Chapter 7 The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit
Spin Locks and Contention Companion slides for Chapter 7 The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit Focus so far: Correctness and Progress Models Accurate (we never lied to you)
Please note that if you write the mid term in pencil, you will not be allowed to submit a remark request.
University of Toronto CSC148 Introduction to Computer Science Fall 2001 Mid Term Test Section L5101 Duration: 50 minutes Aids allowed: none Make sure that your examination booklet has 8 pages (including
The Stack ADT. Stacks and Queues. Stack: Illustration. What is a Stack? Accessors top size isempty
The Stack ADT Stacks and Queues ADT Data Structure Interface add() remove() find() request result EECS200: Advanced Object Oriented Programming Fall 2017 CHEN-WEI WANG Accessors top Mutators push pop of
CSE 214 Computer Science II Heaps and Priority Queues
CSE 214 Computer Science II Heaps and Priority Queues Spring 2018 Stony Brook University Instructor: Shebuti Rayana shebuti.rayana@stonybrook.edu http://www3.cs.stonybrook.edu/~cse214/sec02/ Introduction
Outline of lecture. i219 Software Design Methodology 10. Multithreaded programming. Kazuhiro Ogata (JAIST)
i219 Software Design Methodology 10. Multithreaded programming Kazuhiro Ogata (JAIST) Outline of lecture 2 Thread Race condition Synchronization Deadlock Bounded buffer problem Thread (1) 3 Units of execution.
Concurrent Programming using Threads
Concurrent Programming using Threads Threads are a control mechanism that enable you to write concurrent programs. You can think of a thread in an object-oriented language as a special kind of system object
CONCURRENT LIBRARIES. Correctness Criteria, Verification
CONCURRENT LIBRARIES Correctness Criteria, Verification Verification Ingredients Specifying a Library: φ Implementing a Library: L Verifying a Library implementation: L φ The History of an Object Object
DNHI Homework 3 Solutions List, Stacs and Queues
Solutions List, Stacs and Queues Problem 1 Given the IntegerQueue ADT below state the return value and show the content of the, initially empty, queue of Integer objects after each of the following operations.
CS2012 Programming Techniques II
27 January 14 Lecture 6 (continuing from 5) CS2012 Programming Techniques II Vasileios Koutavas 1 27 January 14 Lecture 6 (continuing from 5) 2 Previous Lecture Amortized running time cost of algorithms
Universality of Consensus. Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit
Universality of Consensus Companion slides for The by Maurice Herlihy & Nir Shavit Turing Computability 1 0 1 1 0 1 0 A mathematical model of computation Computable = Computable on a T-Machine 2 Shared-Memory
Stacks and Queues. EECS2030: Advanced Object Oriented Programming Fall 2017 CHEN-WEI WANG
Stacks and Queues EECS2030: Advanced Object Oriented Programming Fall 2017 CHEN-WEI WANG What is a Stack? A stack is a collection of objects. Objects in a stack are inserted and removed according to the
Locks Chapter 4. Overview. Introduction Spin Locks. Queue locks. Roger Wattenhofer. Test-and-Set & Test-and-Test-and-Set Backoff lock
Locks Chapter 4 Roger Wattenhofer ETH Zurich Distributed Computing www.disco.ethz.ch Overview Introduction Spin Locks Test-and-Set & Test-and-Test-and-Set Backoff lock Queue locks 4/2 1 Introduction: From
BlockingArrayQueue.java. Page 1
1 //BlockingArrayQueue.java 2 //Template blocking queue class, implemented with emulated circular array. 3 //Programmer: Randy Miller 4 //Last modification: April 13, 2015 5 6 7 8 import java.util.arraylist;
Programming Languages and Techniques (CIS120)
Programming Languages and Techniques (CIS120) Lecture 26 Mar 21, 2012 EncapsulaBon & Queues CIS120 / Spring 2012 EncapsulaBon Object encapsulabon EncapsulaBon preserves invariants about the state of the
Quasi-Linearizability Relaxed Consistency For Improved Concurrency
TEL-AVIV UNIVERSITY RAYMOND AND BEVERLY SACKLER FACULTY OF EXACT SCIENCES SCHOOL OF COMPUTER SCIENCE Quasi-Linearizability Relaxed Consistency For Improved Concurrency Dissertation submitted in partial
Non-blocking Array-based Algorithms for Stacks and Queues!
Non-blocking Array-based Algorithms for Stacks and Queues! Niloufar Shafiei! Department of Computer Science and Engineering York University ICDCN 09 Outline! Introduction! Stack algorithm! Queue algorithm!
Cache-Aware Lock-Free Queues for Multiple Producers/Consumers and Weak Memory Consistency
Cache-Aware Lock-Free Queues for Multiple Producers/Consumers and Weak Memory Consistency Anders Gidenstam Håkan Sundell Philippas Tsigas School of business and informatics University of Borås Distributed
Linked List Nodes (reminder)
Outline linked lists reminders: nodes, implementation, invariants circular linked list doubly-linked lists iterators the Java foreach statement iterator implementation the ListIterator interface Linked
Announcements. CS18000: Problem Solving And Object-Oriented Programming
Announcements Exam 1 Monday, February 28 Wetherill 200, 4:30pm-5:20pm Coverage: Through Week 6 Project 2 is a good study mechanism Final Exam Tuesday, May 3, 3:20pm-5:20pm, PHYS 112 If you have three or
COMPSCI 230 Threading Week8. Figure 1 Thread status diagram [http://www.programcreek.com/2009/03/thread-status/]
![COMPSCI 230 Threading Week8. Figure 1 Thread status diagram [http://www.programcreek.com/2009/03/thread-status/]](/thumbs/76/73083042.jpg "COMPSCI 230 Threading Week8. Figure 1 Thread status diagram [http://www.programcreek.com/2009/03/thread-status/]")
COMPSCI 230 Threading Week8 Figure 1 Thread status diagram [http://www.programcreek.com/2009/03/thread-status/] Synchronization Lock DeadLock Why do we need Synchronization in Java? If your code is executing
Spin Locks and Contention. Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit
Spin Locks and Contention Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit Focus so far: Correctness and Progress Models Accurate (we never lied to you) But idealized
CSC212:Data Structure
CSC212:Data Structure 1 Queue: First In First Out (FIFO). Used in operating systems, simulations etc. Priority Queues: Highest priority item is served first. Used in operating systems, printer servers
CMSC 433 Programming Language Technologies and Paradigms. Spring 2013
1 CMSC 433 Programming Language Technologies and Paradigms Spring 2013 Wait / Notify / NotifyAll Optimistic Retries Composition Follow-up (the risk I mentioned) ReentrantLock, Wait, Notify, NotifyAll Some
Lecture 27: Safety and Liveness Properties, Java Synchronizers, Dining Philosophers Problem
COMP 322: Fundamentals of Parallel Programming Lecture 27: Safety and Liveness Properties, Java Synchronizers, Dining Philosophers Problem Mack Joyner and Zoran Budimlić {mjoyner, zoran}@rice.edu http://comp322.rice.edu
Recap. Contents. Reenterancy of synchronized. Explicit Locks: ReentrantLock. Reenterancy of synchronise (ctd) Advanced Thread programming.
Lecture 07: Advanced Thread programming Software System Components 2 Behzad Bordbar School of Computer Science, University of Birmingham, UK Recap How to deal with race condition in Java Using synchronised
Insertions and removals follow the Fist-In First-Out rule: Insertions: at the rear of the queue Removals: at the front of the queue
Queues CSE 2011 Fall 2009 9/28/2009 7:56 AM 1 Queues: FIFO Insertions and removals follow the Fist-In First-Out rule: Insertions: at the rear of the queue Removals: at the front of the queue Applications,
Data Structure Advanced
Data Structure Advanced 1. Is it possible to find a loop in a Linked list? a. Possilbe at O(n) b. Not possible c. Possible at O(n^2) only d. Depends on the position of loop Solution: a. Possible at O(n)
cs Java: lecture #6
cs3101-003 Java: lecture #6 news: homework #5 due today little quiz today it s the last class! please return any textbooks you borrowed from me today s topics: interfaces recursion data structures threads
Lecture 7: Mutual Exclusion 2/16/12. slides adapted from The Art of Multiprocessor Programming, Herlihy and Shavit
Principles of Concurrency and Parallelism Lecture 7: Mutual Exclusion 2/16/12 slides adapted from The Art of Multiprocessor Programming, Herlihy and Shavit Time Absolute, true and mathematical time, of
Ownership of a queue for practical lock-free scheduling
Ownership of a queue for practical lock-free scheduling Lincoln Quirk May 4, 2008 Abstract We consider the problem of scheduling tasks in a multiprocessor. Tasks cannot always be scheduled independently
COL106: Data Structures and Algorithms. Ragesh Jaiswal, IIT Delhi
Stack and Queue How do we implement a Queue using Array? : A collection of nodes with linear ordering defined on them. Each node holds an element and points to the next node in the order. The first node
CSE 131 Computer Science 1 Module 9a: ADT Representations. Stack and queue ADTs array implementations Buffer ADT and circular lists
CSE 11 Computer Science 1 Module 9a: ADT Representations Stack and queue ADTs array implementations Buffer ADT and circular lists Buffer ADT add and remove from both ends»can grow and shrink from either
Fun facts about recursion
Outline examples of recursion principles of recursion review: recursive linked list methods binary search more examples of recursion problem solving using recursion 1 Fun facts about recursion every loop
Locking. Part 2, Chapter 11. Roger Wattenhofer. ETH Zurich Distributed Computing
Locking Part 2, Chapter 11 Roger Wattenhofer ETH Zurich Distributed Computing www.disco.ethz.ch Overview Introduction Spin Locks Test-and-Set & Test-and-Test-and-Set Backoff lock Queue locks 11/2 Introduction:
Exam Distributed Systems
Exam Distributed Systems 5 February 2010, 9:00am 12:00pm Part 2 Prof. R. Wattenhofer Family Name, First Name:..................................................... ETH Student ID Number:.....................................................
Concurrent Programming Benoît Garbinato
Concurrent Programming Benoît Garbinato 1 Processes & threads A process is a unit of execution managed at the level of the operating system Each process has its own address space, i.e., no other process
Locking Granularity. CS 475, Spring 2019 Concurrent & Distributed Systems. With material from Herlihy & Shavit, Art of Multiprocessor Programming
Locking Granularity CS 475, Spring 2019 Concurrent & Distributed Systems With material from Herlihy & Shavit, Art of Multiprocessor Programming Discussion: HW1 Part 4 addtolist(key1, newvalue) Thread 1
CS 112 Introduction to Computing II. Wayne Snyder Computer Science Department Boston University
CS 112 Introduction to Computing II Wayne Snyder Department Boston University Today Introduction to Linked Lists Stacks and Queues using Linked Lists Next Time Iterative Algorithms on Linked Lists Reading:
16. Dynamic Data Structures
Data Structures 6. Dynamic Data Structures A data structure is a particular way of organizing data in a computer so that it can be used efficiently Linked lists, Abstract data types stack, queue, Sorted
NON-BLOCKING DATA STRUCTURES AND TRANSACTIONAL MEMORY. Tim Harris, 28 November 2014
NON-BLOCKING DATA STRUCTURES AND TRANSACTIONAL MEMORY Tim Harris, 28 November 2014 Lecture 8 Problems with locks Atomic blocks and composition Hardware transactional memory Software transactional memory
Stacks and Queues
Stacks and Queues 2-25-2009 1 Opening Discussion Let's look at solutions to the interclass problem. Do you have any questions about the reading? Do you have any questions about the assignment? Minute Essays
Apply to be a Meiklejohn! tinyurl.com/meikapply
Apply to be a Meiklejohn! tinyurl.com/meikapply Seeking a community to discuss the intersections of CS and positive social change? Interested in facilitating collaborations between students and non-profit
Proving liveness. Alexey Gotsman IMDEA Software Institute
Proving liveness Alexey Gotsman IMDEA Software Institute Safety properties Ensure bad things don t happen: - the program will not commit a memory safety fault - it will not release a lock it does not hold
30. Parallel Programming IV
924 30. Parallel Programming IV Futures, Read-Modify-Write Instructions, Atomic Variables, Idea of lock-free programming [C++ Futures: Williams, Kap. 4.2.1-4.2.3] [C++ Atomic: Williams, Kap. 5.2.1-5.2.4,
Data Structure. Recitation VII
Data Structure Recitation VII Recursion: Stack trace Queue Topic animation Trace Recursive factorial Executes factorial(4) Step 9: return 24 Step 8: return 6 factorial(4) Step 0: executes factorial(4)
Lists. CSC212 Lecture 8 D. Thiebaut, Fall 2014
Lists CSC212 Lecture 8 D. Thiebaut, Fall 2014 Review List = Organization of Data in a Linear Fashion, where Order is Important Set of actions that can be carried out efficiently on the data. Typical Actions
Atomic Variables & Nonblocking Synchronization
Atomic Variables & Nonblocking Synchronization CMSC 433 Fall 2014 Michael Hicks (with some slides due to Rance Cleaveland) A Locking Counter public final class Counter { private long value = 0; public
CSE 613: Parallel Programming. Lecture 11 ( Graph Algorithms: Connected Components )
CSE 61: Parallel Programming Lecture ( Graph Algorithms: Connected Components ) Rezaul A. Chowdhury Department of Computer Science SUNY Stony Brook Spring 01 Graph Connectivity 1 1 1 6 5 Connected Components:
CMSC Introduction to Algorithms Spring 2012 Lecture 7
CMSC 351 - Introduction to Algorithms Spring 2012 Lecture 7 Instructor: MohammadTaghi Hajiaghayi Scribe: Rajesh Chitnis 1 Introduction In this lecture we give an introduction to Data Structures like arrays,
Concurrency User Guide
Concurrency User Guide Release 1.0 Dylan Hackers January 26, 2019 CONTENTS 1 Basic Abstractions 3 1.1 Executors................................................. 3 1.2 Queues..................................................
Threads Chate Patanothai
Threads Chate Patanothai Objectives Knowing thread: 3W1H Create separate threads Control the execution of a thread Communicate between threads Protect shared data C. Patanothai Threads 2 What are threads?
Computer Science 62. Bruce/Mawhorter Fall 16. Midterm Examination. October 5, Question Points Score TOTAL 52 SOLUTIONS. Your name (Please print)
Computer Science 62 Bruce/Mawhorter Fall 16 Midterm Examination October 5, 2016 Question Points Score 1 15 2 10 3 10 4 8 5 9 TOTAL 52 SOLUTIONS Your name (Please print) 1. Suppose you are given a singly-linked
Lock-Free Techniques for Concurrent Access to Shared Objects
This is a revised version of the previously published paper. It includes a contribution from Shahar Frank who raised a problem with the fifo-pop algorithm. Revised version date: sept. 30 2003. Lock-Free
The Art of Multiprocessor Programming Copyright 2007 Elsevier Inc. All rights reserved. October 3, 2007 DRAFT COPY
The Art of Multiprocessor Programming Copyright 2007 Elsevier Inc. All rights reserved Maurice Herlihy October 3, 2007 Nir Shavit 2 Contents 1 Introduction 13 1.1 Shared Objects and Synchronization..............
Implementing Mutual Exclusion. Sarah Diesburg Operating Systems CS 3430
Implementing Mutual Exclusion Sarah Diesburg Operating Systems CS 3430 From the Previous Lecture The too much milk example shows that writing concurrent programs directly with load and store instructions
COMP 213 Advanced Object-oriented Programming Lecture 8 The Queue ADT (cont.)
COMP 213 Advanced Object-oriented Programming Lecture 8 The Queue ADT (cont.) Recall: The Queue ADT A data structure in which elements enter at one end and are removed from the opposite end is called a
CIS 120 Programming Languages and Techniques. Final Exam, May 3, 2011
CIS 120 Programming Languages and Techniques Final Exam, May 3, 2011 Name: Pennkey: My signature below certifies that I have complied with the University of Pennsylvania s Code of Academic Integrity in
The Relative Power of Synchronization Methods
Chapter 5 The Relative Power of Synchronization Methods So far, we have been addressing questions of the form: Given objects X and Y, is there a wait-free implementation of X from one or more instances
Fast and Lock-Free Concurrent Priority Queues for Multi-Thread Systems
Fast and Lock-Free Concurrent Priority Queues for Multi-Thread Systems Håkan Sundell Philippas Tsigas Outline Synchronization Methods Priority Queues Concurrent Priority Queues Lock-Free Algorithm: Problems
Principles of Software Construction: Concurrency, Part 2
Principles of Software Construction: Concurrency, Part 2 Josh Bloch Charlie Garrod School of Computer Science 1 Administrivia Homework 5a due now Homework 5 framework goals: Functionally correct Well documented
Lindsay Groves, Simon Doherty. Mark Moir, Victor Luchangco
Lindsay Groves, Simon Doherty Victoria University of Wellington Mark Moir, Victor Luchangco Sun Microsystems, Boston (FORTE, Madrid, September, 2004) Lock-based concurrency doesn t scale Lock-free/non-blocking