CS 241 Honors Concurrent Data Structures
|
|
|
- Francine Doyle
- 5 years ago
- Views:
Transcription
1 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, / 43
2 What to go over Terminology What is lock free Example of Lock Free Transactions and Linearizability The ABA problem Drawbacks Use Cases CS 241 Course Staff (UIUC) Lock Free Data Structures March 27, / 43
3 Word of warning Measure, Measure, Measure! CS 241 Course Staff (UIUC) Lock Free Data Structures March 27, / 43
4 Word of warning Measure, Measure, Measure! You need to make sure that the bottleneck of your problem is in fact your data structure. Meaning that you spend most of your time in mutex lock. CS 241 Course Staff (UIUC) Lock Free Data Structures March 27, / 43
5 Word of warning Measure, Measure, Measure! You need to make sure that the bottleneck of your problem is in fact your data structure. Meaning that you spend most of your time in mutex lock. Then, you make sure that there is no other algorithm that can just reduce the number of mutex locks outright. CS 241 Course Staff (UIUC) Lock Free Data Structures March 27, / 43
6 Word of warning Measure, Measure, Measure! You need to make sure that the bottleneck of your problem is in fact your data structure. Meaning that you spend most of your time in mutex lock. Then, you make sure that there is no other algorithm that can just reduce the number of mutex locks outright. Then, you have to choose the right lock free data structure. Most of them work best under circumstances with high contention and where the structure is full of elements. CS 241 Course Staff (UIUC) Lock Free Data Structures March 27, / 43
7 Word of warning Measure, Measure, Measure! You need to make sure that the bottleneck of your problem is in fact your data structure. Meaning that you spend most of your time in mutex lock. Then, you make sure that there is no other algorithm that can just reduce the number of mutex locks outright. Then, you have to choose the right lock free data structure. Most of them work best under circumstances with high contention and where the structure is full of elements. Then, you have to measure. If you don t measure, then you don t know if you improved. CS 241 Course Staff (UIUC) Lock Free Data Structures March 27, / 43
8 Terminology Atomic instructions - Instructions that happen in one step to the CPU or not at all. Some examples are atomic add, atomic compare and swap. CS 241 Course Staff (UIUC) Lock Free Data Structures March 27, / 43
9 Terminology Atomic instructions - Instructions that happen in one step to the CPU or not at all. Some examples are atomic add, atomic compare and swap. Transaction - Like atomic operations, either the entire transaction goes through or doesn t. This could be a series of operations (like push or pop for a stack) CS 241 Course Staff (UIUC) Lock Free Data Structures March 27, / 43
10 Terminology Atomic instructions - Instructions that happen in one step to the CPU or not at all. Some examples are atomic add, atomic compare and swap. Transaction - Like atomic operations, either the entire transaction goes through or doesn t. This could be a series of operations (like push or pop for a stack) Linearizability - Once a write completes, all reads after point to the new data. CS 241 Course Staff (UIUC) Lock Free Data Structures March 27, / 43
11 Terminology Atomic instructions - Instructions that happen in one step to the CPU or not at all. Some examples are atomic add, atomic compare and swap. Transaction - Like atomic operations, either the entire transaction goes through or doesn t. This could be a series of operations (like push or pop for a stack) Linearizability - Once a write completes, all reads after point to the new data. Atomic Compare and Swap CS 241 Course Staff (UIUC) Lock Free Data Structures March 27, / 43
12 Atomic Compare and Swap? CS 241 Course Staff (UIUC) Lock Free Data Structures March 27, / 43
13 Atomic Compare and Swap? int atomic_cas ( int * addr, int * expected, int value ){ if (* addr == * expected ){ * addr = value ; return 1; // swap success } else { * expected = * addr ; return 0; // swap failed } } CS 241 Course Staff (UIUC) Lock Free Data Structures March 27, / 43
14 Atomic Compare and Swap? int atomic_cas ( int * addr, int * expected, int value ){ if (* addr == * expected ){ * addr = value ; return 1; // swap success } else { * expected = * addr ; return 0; // swap failed } } But this all happens atomically! CS 241 Course Staff (UIUC) Lock Free Data Structures March 27, / 43
15 Types of Data Structures Blocking Data Structures Lock-Free Data Structures Bounded-Wait Data Structures Wait-Free Data Structures CS 241 Course Staff (UIUC) Lock Free Data Structures March 27, / 43
16 Blocking Structures CS 241 Course Staff (UIUC) Lock Free Data Structures March 27, / 43
17 Blocking Structures Advantages: Simpler to program Well defined critical sections Built-in Linearizability (To Be Explained) CS 241 Course Staff (UIUC) Lock Free Data Structures March 27, / 43
18 Blocking Structures Advantages: Simpler to program Well defined critical sections Built-in Linearizability (To Be Explained) Disadvantages Slower under high contention; Mutexes are not scalable across cores Lower priority processes often get locks Deadlock! Convoy Effect! Preemption/Signal Handler Safety CS 241 Course Staff (UIUC) Lock Free Data Structures March 27, / 43
19 Blocking Structures CS 241 Course Staff (UIUC) Lock Free Data Structures March 27, / 43
20 Blocking Structures CS 241 Course Staff (UIUC) Lock Free Data Structures March 27, / 43
21 Lock-Free Structures CS 241 Course Staff (UIUC) Lock Free Data Structures March 27, / 43
22 Lock-Free Structures Advantages: Better under high contention Atomics are faster when the number of CPUs is small. CS 241 Course Staff (UIUC) Lock Free Data Structures March 27, / 43
23 Lock-Free Structures Advantages: Better under high contention Atomics are faster when the number of CPUs is small. Disadvantages Critical Section a little harder to define Harder to debug Can get really complicated CS 241 Course Staff (UIUC) Lock Free Data Structures March 27, / 43
24 Bounded Wait + Wait Free Structures CS 241 Course Staff (UIUC) Lock Free Data Structures March 27, / 43
25 Bounded Wait + Wait Free Structures Advantages: Faster than lock free. The CPU is always doing something. Guaranteed work after some point More stable, less probability CS 241 Course Staff (UIUC) Lock Free Data Structures March 27, / 43
26 Bounded Wait + Wait Free Structures Advantages: Faster than lock free. The CPU is always doing something. Guaranteed work after some point More stable, less probability Disadvantages Not always possible Hard to guarantee Can get really complicated. CS 241 Course Staff (UIUC) Lock Free Data Structures March 27, / 43
27 Building a lock free Data Structure Alright, let s make a queue. What do we have to think about? Well there are two types of threads. Those pushing things on to the queue, and those popping off the queue. CS 241 Course Staff (UIUC) Lock Free Data Structures March 27, / 43
28 Starting out - No Code but Ownership A fundamental way to solve race conditions is to ask yourself the question who owns this piece of memory. If you make sure that one thread has access to the piece of memory at once, you will never get deadlock. CS 241 Course Staff (UIUC) Lock Free Data Structures March 27, / 43
29 Starting out - No Code but Ownership A fundamental way to solve race conditions is to ask yourself the question who owns this piece of memory. If you make sure that one thread has access to the piece of memory at once, you will never get deadlock. For the sake of not sitting here for days about lock free structures, we will assume that we have a fast, lock free malloc. CS 241 Course Staff (UIUC) Lock Free Data Structures March 27, / 43
30 Ownership? 1 We want to introduce the idea that a thread owns a piece of memory. This is to avoid race conditions. 2 There is going to be a shared part of memory and a part only visible to the thread. We are going to do all of our initialization in our memory part and then with one atomic instructions that are carefully placed 3 After that the data structure will be initialized CS 241 Course Staff (UIUC) Lock Free Data Structures March 27, / 43
31 Lock Free initialization typedef struct node ; typedef struct queue ; new_queue () destory_queue () CS 241 Course Staff (UIUC) Lock Free Data Structures March 27, / 43
32 Lock Free Enqueue void enqueue ( queue * fifo, void * val ){ node * pkg = malloc ( sizeof (* pkg )), * ptr ; * pkg = {val, NULL }; int succeeded = 0; while (! succeeded ){ node * none = NULL ; ptr = fifo -> tail ; succeeded = cas (& ptr ->next, none, pkg ) } // This is actually a critical section cas (& fifo ->tail, &ptr, package ); } CS 241 Course Staff (UIUC) Lock Free Data Structures March 27, / 43
33 Lock Free Dequeue node * dequeue ( queue * fifo ){ if (! fifo -> head ) { return NULL ; } node * start = &fifo -> head ; while (! atomic_cas (& fifo ->head, start, &fifo ->head -> next )){ start = atomic_load (& fifo - > head ); if( start == NULL ){ return NULL ; } // May do sleeping here } // You now have exclusive access return start ; } CS 241 Course Staff (UIUC) Lock Free Data Structures March 27, / 43
34 Transactions 1 The idea of transactions is that a group of operations go in together and become apparent to the data structure all at once. CS 241 Course Staff (UIUC) Lock Free Data Structures March 27, / 43
35 Transactions 1 The idea of transactions is that a group of operations go in together and become apparent to the data structure all at once. 2 This is important because this provides high concurrency. Each thread has its own place to do its work, and undergoes contention all at once. CS 241 Course Staff (UIUC) Lock Free Data Structures March 27, / 43
36 Transactions 1 The idea of transactions is that a group of operations go in together and become apparent to the data structure all at once. 2 This is important because this provides high concurrency. Each thread has its own place to do its work, and undergoes contention all at once. 3 You can see this in the previous example. CS 241 Course Staff (UIUC) Lock Free Data Structures March 27, / 43
37 Lock Free Enqueue node * package = malloc ( sizeof (* package )); package -> data = val ; package -> next = NULL ; node * ptr ;... CS 241 Course Staff (UIUC) Lock Free Data Structures March 27, / 43
38 Lock Free Enqueue ctx * tex = begin_transaction ( queue ); queue_pop ( tex ); queue_push ( tex, 1); queue_push ( tex, 2); queue_push ( tex, 3); end_transaction ( tex ); // Results pushed ( only 2 atomics computed ) CS 241 Course Staff (UIUC) Lock Free Data Structures March 27, / 43
39 Alterations pop ( tex ) { // Push the pop on the context } push ( tex ) { /* Allocate memory and push the value on the stack. if there is another pop instruction, squish the two nodes */ } CS 241 Course Staff (UIUC) Lock Free Data Structures March 27, / 43
40 Alterations end_transaction ( tex ) { void * none = NULL ; cas (& tex -> queue ->head, &tex -> queue ->head, none ); // My queue for ( transaction in tex ) { if ( transaction - > type == push ) queue_push (tex -> queue, transaction -> data ) //... } } CS 241 Course Staff (UIUC) Lock Free Data Structures March 27, / 43
41 Transactions 1 Of course, you have to resolve the idea of what a pop means in an empty queue in a transaction. More often than not in high performance parallel programming we just throw away bad pops in the case of a queue. CS 241 Course Staff (UIUC) Lock Free Data Structures March 27, / 43
42 Transactions 1 Of course, you have to resolve the idea of what a pop means in an empty queue in a transaction. More often than not in high performance parallel programming we just throw away bad pops in the case of a queue. 2 You also may have to deal with a transaction failing because the queue may have run out of space. CS 241 Course Staff (UIUC) Lock Free Data Structures March 27, / 43
43 Transactions 1 Of course, you have to resolve the idea of what a pop means in an empty queue in a transaction. More often than not in high performance parallel programming we just throw away bad pops in the case of a queue. 2 You also may have to deal with a transaction failing because the queue may have run out of space. 3 This is mainly a tool for the people using the lock free data structures keep track of their operations. CS 241 Course Staff (UIUC) Lock Free Data Structures March 27, / 43
44 Linearizability & Serializability CS 241 Course Staff (UIUC) Lock Free Data Structures March 27, / 43
45 Linearizability 1 Once a write completes, all reads after point to the new data. CS 241 Course Staff (UIUC) Lock Free Data Structures March 27, / 43
46 Linearizability 1 Once a write completes, all reads after point to the new data. 2 It is kind of obvious to see the benefit here, we want a data structure to be consistent and once the writes happen, all reads after make sense (they don t get stale data). CS 241 Course Staff (UIUC) Lock Free Data Structures March 27, / 43
47 Linearizability 1 Once a write completes, all reads after point to the new data. 2 It is kind of obvious to see the benefit here, we want a data structure to be consistent and once the writes happen, all reads after make sense (they don t get stale data). 3 Also good to determine a semi-ordering (Think of a reader writer consistency model). CS 241 Course Staff (UIUC) Lock Free Data Structures March 27, / 43
48 Linearizability 1 Once a write completes, all reads after point to the new data. 2 It is kind of obvious to see the benefit here, we want a data structure to be consistent and once the writes happen, all reads after make sense (they don t get stale data). 3 Also good to determine a semi-ordering (Think of a reader writer consistency model). 4 But sometimes we need stronger consistency models. CS 241 Course Staff (UIUC) Lock Free Data Structures March 27, / 43
49 Serializability 1 A series of transactions on objects has some consistent ordering. CS 241 Course Staff (UIUC) Lock Free Data Structures March 27, / 43
50 Serializability 1 A series of transactions on objects has some consistent ordering. 2 This is a strong model of consistency (not the strongest) but usually the highest one that lock free data structures succumb to. There is a performance hit but we want our data structure to make sense. CS 241 Course Staff (UIUC) Lock Free Data Structures March 27, / 43
51 Serializability 1 A series of transactions on objects has some consistent ordering. 2 This is a strong model of consistency (not the strongest) but usually the highest one that lock free data structures succumb to. There is a performance hit but we want our data structure to make sense. 3 Think of a stock market application that needs to tell which monetary transaction happened first. We need the application to be fast but we need to know who bought and sold first CS 241 Course Staff (UIUC) Lock Free Data Structures March 27, / 43
52 Strong Serializability 1 When a transaction is both Serializable and Linearizable. CS 241 Course Staff (UIUC) Lock Free Data Structures March 27, / 43
53 Strong Serializability 1 When a transaction is both Serializable and Linearizable. 2 Meaning that the order of transactions make sense if computed by one thread. CS 241 Course Staff (UIUC) Lock Free Data Structures March 27, / 43
54 Strong Serializability 1 When a transaction is both Serializable and Linearizable. 2 Meaning that the order of transactions make sense if computed by one thread. 3 Hardest to obtain. CS 241 Course Staff (UIUC) Lock Free Data Structures March 27, / 43
55 ABA Problem 1 The ABA problem, no it s not a problem about Dancing Queen. CS 241 Course Staff (UIUC) Lock Free Data Structures March 27, / 43
56 ABA Problem 1 The ABA problem, no it s not a problem about Dancing Queen. 2 It is the idea that a thread A can do something half way, then thread B does a lot of things, and A tries to complete its transaction but incorrectly succeeds. CS 241 Course Staff (UIUC) Lock Free Data Structures March 27, / 43
57 ABA Problem 1 The ABA problem, no it s not a problem about Dancing Queen. 2 It is the idea that a thread A can do something half way, then thread B does a lot of things, and A tries to complete its transaction but incorrectly succeeds. 3 This is a problem because over the long term the entire data structure could either break or leak memory. CS 241 Course Staff (UIUC) Lock Free Data Structures March 27, / 43
58 ABA Problem 1 The ABA problem, no it s not a problem about Dancing Queen. 2 It is the idea that a thread A can do something half way, then thread B does a lot of things, and A tries to complete its transaction but incorrectly succeeds. 3 This is a problem because over the long term the entire data structure could either break or leak memory. 4 Some cases there are no ways of preventing this problem, especially in a language like C without automagic garbage collection. CS 241 Course Staff (UIUC) Lock Free Data Structures March 27, / 43
59 ABA Problem void enqueue ( queue * fifo, void * val ) { node * pkg = malloc ( sizeof (* pkg )), * ptr ; * pkg = {val, NULL }; int succeeded = 0; while (! succeeded ) { node * none = NULL ; ptr = fifo -> tail ; succeeded = cas (& ptr ->next, none, pkg ) if (! succeeded ){ cas (& fifo ->next, &ptr, ptr -> next ); } } cas (& fifo ->tail, &ptr, package ); void * data = pkg -> val ; free ( pkg ); } CS 241 Course Staff (UIUC) Lock Free Data Structures March 27, / 43
60 ABA Problem CS 241 Course Staff (UIUC) Lock Free Data Structures March 27, / 43
61 Did you notice? 1 Our data structure does not need to worry about that! CS 241 Course Staff (UIUC) Lock Free Data Structures March 27, / 43
62 Did you notice? 1 Our data structure does not need to worry about that! 2 Our dequeue instead of returning the item returns the entire node. CS 241 Course Staff (UIUC) Lock Free Data Structures March 27, / 43
63 Did you notice? 1 Our data structure does not need to worry about that! 2 Our dequeue instead of returning the item returns the entire node. 3 That means the ABA problem has a near zero chance of actually occuring if the user doesn t free the node until after they are done using it. CS 241 Course Staff (UIUC) Lock Free Data Structures March 27, / 43
64 Drawbacks 1 These data structures can get complicated fast CS 241 Course Staff (UIUC) Lock Free Data Structures March 27, / 43
65 Drawbacks 1 These data structures can get complicated fast 2 No one knows if they always work CS 241 Course Staff (UIUC) Lock Free Data Structures March 27, / 43
66 Drawbacks 1 These data structures can get complicated fast 2 No one knows if they always work 3 Sometimes they can t always work CS 241 Course Staff (UIUC) Lock Free Data Structures March 27, / 43
67 Drawbacks 1 These data structures can get complicated fast 2 No one knows if they always work 3 Sometimes they can t always work 4 Sometimes they are slower CS 241 Course Staff (UIUC) Lock Free Data Structures March 27, / 43
68 Drawbacks CS 241 Course Staff (UIUC) Lock Free Data Structures March 27, / 43
69 Memory Orders 1 One last thing that we need to cover is memory orders CS 241 Course Staff (UIUC) Lock Free Data Structures March 27, / 43
70 Memory Orders 1 One last thing that we need to cover is memory orders 2 Memory orders or barriers are a way for you to tell the compiler not to out of order execute your instructions. CS 241 Course Staff (UIUC) Lock Free Data Structures March 27, / 43
71 Memory Orders 1 One last thing that we need to cover is memory orders 2 Memory orders or barriers are a way for you to tell the compiler not to out of order execute your instructions. 3 There are different levels of orders most of the time you want the most restrictive in order to ensure your behavior works. CS 241 Course Staff (UIUC) Lock Free Data Structures March 27, / 43
72 Memory Orders 1 One last thing that we need to cover is memory orders 2 Memory orders or barriers are a way for you to tell the compiler not to out of order execute your instructions. 3 There are different levels of orders most of the time you want the most restrictive in order to ensure your behavior works. 4 Only then move down to other orders CS 241 Course Staff (UIUC) Lock Free Data Structures March 27, / 43
73 Sequential Consistency -Thread 1- -Thread 2- y = 1 if (x.load() == 2) store(x, 2); y!= 1 && *NULL = 1; Will never segfault CS 241 Course Staff (UIUC) Lock Free Data Structures March 27, / 43
74 Relaxed Consistency -Thread 1- -Thread 2- store(x, 1) first = load(x) store(x, 2); second = load(x) first <= second A new value will never become old CS 241 Course Staff (UIUC) Lock Free Data Structures March 27, / 43
75 Use Cases 1 RabbitMQ/Apache Kafka is a distributed message queue that uses a queue similar to the one we described to distribute messages to a group of nodes. 2 Apache Spark and Hadoop use this for consensus, finger tables, and communicating and joining results together. 3 Every distributed (and a lot of non-distributed) databases use lock-free data structures to service SQL queries or read/write form disks 4 HPC uses them to manage concurrency (Possible MPI) CS 241 Course Staff (UIUC) Lock Free Data Structures March 27, / 43
76 Bonus! Why Spurious Wakeups Happen 1 Ever wonder why spurious wakeups happen? CS 241 Course Staff (UIUC) Lock Free Data Structures March 27, / 43
77 Bonus! Why Spurious Wakeups Happen 1 Ever wonder why spurious wakeups happen? 2 Well y all are masters at lock free data structures now so you can guess. CS 241 Course Staff (UIUC) Lock Free Data Structures March 27, / 43
78 Bonus! Why Spurious Wakeups Happen 1 Ever wonder why spurious wakeups happen? 2 Well y all are masters at lock free data structures now so you can guess. 3 Let s take the Windows NT way of implementing a condition variable. CS 241 Course Staff (UIUC) Lock Free Data Structures March 27, / 43
79 Bonus! Why Spurious Wakeups Happen 1 Ever wonder why spurious wakeups happen? 2 Well y all are masters at lock free data structures now so you can guess. 3 Let s take the Windows NT way of implementing a condition variable. 4 The real problem with CVs are broadcast. CS 241 Course Staff (UIUC) Lock Free Data Structures March 27, / 43
80 Windows NT struct CV { linked_list waiters ; } void wait ( cv, mtx ) { // mtx must be locked enqueue (cv.waiters, self ()); m. Release (); self (). sema. wait (); m. Acquire (); } CS 241 Course Staff (UIUC) Lock Free Data Structures March 27, / 43
81 Not Interesting void signal (cv) { if ( waiters!= null ) { waiters. sema. post (); cas ( waiters, waiters, waiters. next ); } } CS 241 Course Staff (UIUC) Lock Free Data Structures March 27, / 43
82 Interesting void broadcast ( cv) { while ( waiters!= null ) { waiters. sema. post (); cas ( waiters, waiters, waiters. next ); } } CS 241 Course Staff (UIUC) Lock Free Data Structures March 27, / 43
83 Interesting CS 241 Course Staff (UIUC) Lock Free Data Structures March 27, / 43
84 Questions? Thanks for sticking along! CS 241 Course Staff (UIUC) Lock Free Data Structures March 27, / 43
Synchronising Threads
Synchronising Threads David Chisnall March 1, 2011 First Rule for Maintainable Concurrent Code No data may be both mutable and aliased Harder Problems Data is shared and mutable Access to it must be protected
Parallel Programming: Background Information
1 Parallel Programming: Background Information Mike Bailey mjb@cs.oregonstate.edu parallel.background.pptx Three Reasons to Study Parallel Programming 2 1. Increase performance: do more work in the same
Parallel Programming: Background Information
1 Parallel Programming: Background Information Mike Bailey mjb@cs.oregonstate.edu parallel.background.pptx Three Reasons to Study Parallel Programming 2 1. Increase performance: do more work in the same
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 Advanced Topics in Concurrency. Jonathan Walpole
CS510 Advanced Topics in Concurrency Jonathan Walpole Threads Cannot Be Implemented as a Library Reasoning About Programs What are the valid outcomes for this program? Is it valid for both r1 and r2 to
Readers-Writers Problem. Implementing shared locks. shared locks (continued) Review: Test-and-set spinlock. Review: Test-and-set on alpha
Readers-Writers Problem Implementing shared locks Multiple threads may access data - Readers will only observe, not modify data - Writers will change the data Goal: allow multiple readers or one single
Operating Systems. Lecture 4 - Concurrency and Synchronization. Master of Computer Science PUF - Hồ Chí Minh 2016/2017
Operating Systems Lecture 4 - Concurrency and Synchronization Adrien Krähenbühl Master of Computer Science PUF - Hồ Chí Minh 2016/2017 Mutual exclusion Hardware solutions Semaphores IPC: Message passing
CS5460/6460: Operating Systems. Lecture 11: Locking. Anton Burtsev February, 2014
CS5460/6460: Operating Systems Lecture 11: Locking Anton Burtsev February, 2014 Race conditions Disk driver maintains a list of outstanding requests Each process can add requests to the list 1 struct list
Synchronization. CS61, Lecture 18. Prof. Stephen Chong November 3, 2011
Synchronization CS61, Lecture 18 Prof. Stephen Chong November 3, 2011 Announcements Assignment 5 Tell us your group by Sunday Nov 6 Due Thursday Nov 17 Talks of interest in next two days Towards Predictable,
Lecture 10: Avoiding Locks
Lecture 10: Avoiding Locks CSC 469H1F Fall 2006 Angela Demke Brown (with thanks to Paul McKenney) Locking: A necessary evil? Locks are an easy to understand solution to critical section problem Protect
Synchronization. CISC3595/5595 Fall 2015 Fordham Univ.
Synchronization CISC3595/5595 Fall 2015 Fordham Univ. Synchronization Motivation When threads concurrently read/write shared memory, program behavior is undefined Two threads write to the same variable;
CHAPTER 6: PROCESS SYNCHRONIZATION
CHAPTER 6: PROCESS SYNCHRONIZATION The slides do not contain all the information and cannot be treated as a study material for Operating System. Please refer the text book for exams. TOPICS Background
Stanford University Computer Science Department CS 140 Midterm Exam Dawson Engler Winter 1999
Stanford University Computer Science Department CS 140 Midterm Exam Dawson Engler Winter 1999 Name: Please initial the bottom left corner of each page. This is an open-book exam. You have 50 minutes to
The Java Memory Model
Jeremy Manson 1, William Pugh 1, and Sarita Adve 2 1 University of Maryland 2 University of Illinois at Urbana-Champaign Presented by John Fisher-Ogden November 22, 2005 Outline Introduction Sequential
Review: Test-and-set spinlock
p. 1/3 Review: Test-and-set spinlock struct var { int lock; int val; ; void atomic_inc (var *v) { while (test_and_set (&v->lock)) ; v->val++; v->lock = 0; void atomic_dec (var *v) { while (test_and_set
CS 241 Honors Memory
CS 241 Honors Memory Ben Kurtovic Atul Sandur Bhuvan Venkatesh Brian Zhou Kevin Hong University of Illinois Urbana Champaign February 20, 2018 CS 241 Course Staff (UIUC) Memory February 20, 2018 1 / 35
More Shared Memory Programming
More Shared Memory Programming Shared data structures We want to make data structures that can be shared by threads. For example, our program to copy a file from one disk to another used a shared FIFO
CS 162 Operating Systems and Systems Programming Professor: Anthony D. Joseph Spring 2004
CS 162 Operating Systems and Systems Programming Professor: Anthony D. Joseph Spring 2004 Lecture 9: Readers-Writers and Language Support for Synchronization 9.1.2 Constraints 1. Readers can access database
CS533 Concepts of Operating Systems. Jonathan Walpole
CS533 Concepts of Operating Systems Jonathan Walpole Introduction to Threads and Concurrency Why is Concurrency Important? Why study threads and concurrent programming in an OS class? What is a thread?
Midterm I October 12 th, 2005 CS162: Operating Systems and Systems Programming
University of California, Berkeley College of Engineering Computer Science Division EECS Fall 2005 John Kubiatowicz Midterm I October 12 th, 2005 CS162: Operating Systems and Systems Programming Your Name:
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
Chapter 6: Process Synchronization. Operating System Concepts 8 th Edition,
Chapter 6: Process Synchronization, Silberschatz, Galvin and Gagne 2009 Module 6: Process Synchronization Background The Critical-Section Problem Peterson s Solution Synchronization Hardware Semaphores
Operating Systems (234123) Spring (Homework 3 Wet) Homework 3 Wet
Due date: Monday, 4/06/2012 12:30 noon Teaching assistants in charge: Operating Systems (234123) Spring-2012 Homework 3 Wet Anastasia Braginsky All emails regarding this assignment should be sent only
Heap Arrays and Linked Lists. Steven R. Bagley
Heap Arrays and Linked Lists Steven R. Bagley Recap Data is stored in variables Can be accessed by the variable name Or in an array, accessed by name and index Variables and arrays have a type Create our
Background. The Critical-Section Problem Synchronisation Hardware Inefficient Spinning Semaphores Semaphore Examples Scheduling.
Background The Critical-Section Problem Background Race Conditions Solution Criteria to Critical-Section Problem Peterson s (Software) Solution Concurrent access to shared data may result in data inconsistency
Lecture #7: Implementing Mutual Exclusion
Lecture #7: Implementing Mutual Exclusion Review -- 1 min Solution #3 to too much milk works, but it is really unsatisfactory: 1) Really complicated even for this simple example, hard to convince yourself
PROJECT 6: PINTOS FILE SYSTEM. CS124 Operating Systems Winter , Lecture 25
PROJECT 6: PINTOS FILE SYSTEM CS124 Operating Systems Winter 2015-2016, Lecture 25 2 Project 6: Pintos File System Last project is to improve the Pintos file system Note: Please ask before using late tokens
Non-blocking Array-based Algorithms for Stacks and Queues. Niloufar Shafiei
Non-blocking Array-based Algorithms for Stacks and Queues Niloufar Shafiei Outline Introduction Concurrent stacks and queues Contributions New algorithms New algorithms using bounded counter values Correctness
CS 111. Operating Systems Peter Reiher
Operating System Principles: Mutual Exclusion and Asynchronous Completion Operating Systems Peter Reiher Page 1 Outline Mutual Exclusion Asynchronous Completions Page 2 Mutual Exclusion Critical sections
CSC501 Operating Systems Principles. Process Synchronization
CSC501 Operating Systems Principles Process Synchronization 1 Last Lecture q Process Scheduling Question I: Within one second, how many times the timer interrupt will occur? Question II: Within one second,
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!
Using Weakly Ordered C++ Atomics Correctly. Hans-J. Boehm
Using Weakly Ordered C++ Atomics Correctly Hans-J. Boehm 1 Why atomics? Programs usually ensure that memory locations cannot be accessed by one thread while being written by another. No data races. Typically
Midterm Exam Amy Murphy 6 March 2002
University of Rochester Midterm Exam Amy Murphy 6 March 2002 Computer Systems (CSC2/456) Read before beginning: Please write clearly. Illegible answers cannot be graded. Be sure to identify all of your
CMSC421: Principles of Operating Systems
CMSC421: Principles of Operating Systems Nilanjan Banerjee Assistant Professor, University of Maryland Baltimore County nilanb@umbc.edu http://www.csee.umbc.edu/~nilanb/teaching/421/ Principles of Operating
Midterm Exam March 13, 2013 CS162 Operating Systems
University of California, Berkeley College of Engineering Computer Science Division EECS Spring 2013 Anthony D. Joseph Midterm Exam March 13, 2013 CS162 Operating Systems Your Name: SID AND 162 Login:
Synchronization 1. Synchronization
Synchronization 1 Synchronization key concepts critical sections, mutual exclusion, test-and-set, spinlocks, blocking and blocking locks, semaphores, condition variables, deadlocks reading Three Easy Pieces:
Concurrency - II. Recitation 3/24 Nisarg Raval Slides by Prof. Landon Cox and Vamsi Thummala
Concurrency - II Recitation 3/24 Nisarg Raval Slides by Prof. Landon Cox and Vamsi Thummala So far lock () if (nonote && nomilk){ leave note at store unlock () buy milk lock () remove note unlock () else
Locking: A necessary evil? Lecture 10: Avoiding Locks. Priority Inversion. Deadlock
Locking: necessary evil? Lecture 10: voiding Locks CSC 469H1F Fall 2006 ngela Demke Brown (with thanks to Paul McKenney) Locks are an easy to understand solution to critical section problem Protect shared
CS 162 Operating Systems and Systems Programming Professor: Anthony D. Joseph Spring Lecture 8: Semaphores, Monitors, & Condition Variables
CS 162 Operating Systems and Systems Programming Professor: Anthony D. Joseph Spring 2004 Lecture 8: Semaphores, Monitors, & Condition Variables 8.0 Main Points: Definition of semaphores Example of use
CS-537: Midterm Exam (Spring 2001)
CS-537: Midterm Exam (Spring 2001) Please Read All Questions Carefully! There are seven (7) total numbered pages Name: 1 Grading Page Points Total Possible Part I: Short Answers (12 5) 60 Part II: Long
Chapter 6: Synchronization. Chapter 6: Synchronization. 6.1 Background. Part Three - Process Coordination. Consumer. Producer. 6.
Part Three - Process Coordination Chapter 6: Synchronization 6.1 Background Concurrent access to shared data may result in data inconsistency Maintaining data consistency requires mechanisms to ensure
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
Chapter 6: Process Synchronization
Chapter 6: Process Synchronization Chapter 6: Synchronization 6.1 Background 6.2 The Critical-Section Problem 6.3 Peterson s Solution 6.4 Synchronization Hardware 6.5 Mutex Locks 6.6 Semaphores 6.7 Classic
Background. Old Producer Process Code. Improving the Bounded Buffer. Old Consumer Process Code
Old Producer Process Code Concurrent access to shared data may result in data inconsistency Maintaining data consistency requires mechanisms to ensure the orderly execution of cooperating processes Our
CS 537: Introduction to Operating Systems (Summer 2017) University of Wisconsin-Madison Department of Computer Sciences.
CS 537: Introduction to Operating Systems (Summer 2017) University of Wisconsin-Madison Department of Computer Sciences Midterm Exam 2 July 21 st, 2017 3 pm - 5 pm There are sixteen (16) total numbered
Deadlock and Monitors. CS439: Principles of Computer Systems September 24, 2018
Deadlock and Monitors CS439: Principles of Computer Systems September 24, 2018 Bringing It All Together Processes Abstraction for protection Define address space Threads Share (and communicate) through
Locks. Dongkun Shin, SKKU
Locks 1 Locks: The Basic Idea To implement a critical section A lock variable must be declared A lock variable holds the state of the lock Available (unlocked, free) Acquired (locked, held) Exactly one
Thread-Local. Lecture 27: Concurrency 3. Dealing with the Rest. Immutable. Whenever possible, don t share resources
Thread-Local Lecture 27: Concurrency 3 CS 62 Fall 2016 Kim Bruce & Peter Mawhorter Some slides based on those from Dan Grossman, U. of Washington Whenever possible, don t share resources Easier to have
Semaphores. Jinkyu Jeong Computer Systems Laboratory Sungkyunkwan University
Semaphores Jinkyu Jeong (jinkyu@skku.edu) Computer Systems Laboratory Sungkyunkwan University http://csl.skku.edu EEE3052: Introduction to Operating Systems, Fall 2017, Jinkyu Jeong (jinkyu@skku.edu) Synchronization
Operating Systems. Designed and Presented by Dr. Ayman Elshenawy Elsefy
Operating Systems Designed and Presented by Dr. Ayman Elshenawy Elsefy Dept. of Systems & Computer Eng.. AL-AZHAR University Website : eaymanelshenawy.wordpress.com Email : eaymanelshenawy@yahoo.com Reference
LOCKLESS ALGORITHMS. Lockless Algorithms. CAS based algorithms stack order linked list
Lockless Algorithms CAS based algorithms stack order linked list CS4021/4521 2017 jones@scss.tcd.ie School of Computer Science and Statistics, Trinity College Dublin 2-Jan-18 1 Obstruction, Lock and Wait
COMP 3430 Robert Guderian
Operating Systems COMP 3430 Robert Guderian file:///users/robg/dropbox/teaching/3430-2018/slides/06_concurrency/index.html?print-pdf#/ 1/76 1 Concurrency file:///users/robg/dropbox/teaching/3430-2018/slides/06_concurrency/index.html?print-pdf#/
Page 1. Goals for Today" Atomic Read-Modify-Write instructions" Examples of Read-Modify-Write "
Goals for Today" CS162 Operating Systems and Systems Programming Lecture 5 Semaphores, Conditional Variables" Atomic instruction sequence Continue with Synchronization Abstractions Semaphores, Monitors
Part 1: Concepts and Hardware- Based Approaches
Part 1: Concepts and Hardware- Based Approaches CS5204-Operating Systems Introduction Provide support for concurrent activity using transactionstyle semantics without explicit locking Avoids problems with
DATABASE TRANSACTIONS. CS121: Relational Databases Fall 2017 Lecture 25
DATABASE TRANSACTIONS CS121: Relational Databases Fall 2017 Lecture 25 Database Transactions 2 Many situations where a sequence of database operations must be treated as a single unit A combination of
CMPSCI 377 Midterm (Sample) Name:
CMPSCI 377 Midterm (Sample) You will have 90 minutes to work on this exam, which is closed book. There are 4 problems on 9 pages. Please write your name on EVERY page. You are to abide by the University
Process & Thread Management II. Queues. Sleep() and Sleep Queues CIS 657
Process & Thread Management II CIS 657 Queues Run queues: hold threads ready to execute Not a single ready queue; 64 queues All threads in same queue are treated as same priority Sleep queues: hold threads
Process & Thread Management II CIS 657
Process & Thread Management II CIS 657 Queues Run queues: hold threads ready to execute Not a single ready queue; 64 queues All threads in same queue are treated as same priority Sleep queues: hold threads
Synchronization COMPSCI 386
Synchronization COMPSCI 386 Obvious? // push an item onto the stack while (top == SIZE) ; stack[top++] = item; // pop an item off the stack while (top == 0) ; item = stack[top--]; PRODUCER CONSUMER Suppose
Synchronization. CS 475, Spring 2018 Concurrent & Distributed Systems
Synchronization CS 475, Spring 2018 Concurrent & Distributed Systems Review: Threads: Memory View code heap data files code heap data files stack stack stack stack m1 m1 a1 b1 m2 m2 a2 b2 m3 m3 a3 m4 m4
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
Introduction to OS Synchronization MOS 2.3
Introduction to OS Synchronization MOS 2.3 Mahmoud El-Gayyar elgayyar@ci.suez.edu.eg Mahmoud El-Gayyar / Introduction to OS 1 Challenge How can we help processes synchronize with each other? E.g., how
CSE 153 Design of Operating Systems
CSE 153 Design of Operating Systems Winter 2018 Lecture 10: Monitors Monitors A monitor is a programming language construct that controls access to shared data Synchronization code added by compiler, enforced
CS370 Operating Systems
CS370 Operating Systems Colorado State University Yashwant K Malaiya Fall 2017 Lecture 11 Slides based on Text by Silberschatz, Galvin, Gagne Various sources 1 1 FAQ Multilevel Feedback Queue: Q0, Q1,
2 Threads vs. Processes
9 2 Threads vs. Processes A process includes an address space (defining all the code and data pages) a resource container (OS resource and accounting information) a thread of control, which defines where
Heap Arrays. Steven R. Bagley
Heap Arrays Steven R. Bagley Recap Data is stored in variables Can be accessed by the variable name Or in an array, accessed by name and index a[42] = 35; Variables and arrays have a type int, char, double,
Stanford University Computer Science Department CS 295 midterm. May 14, (45 points) (30 points) total
Stanford University Computer Science Department CS 295 midterm May 14, 2008 This is an open-book exam. You have 75 minutes. Write all of your answers directly on the paper. Make your answers as concise
Chapter 5: Process Synchronization. Operating System Concepts 9 th Edition
Chapter 5: Process Synchronization Silberschatz, Galvin and Gagne 2013 Chapter 5: Process Synchronization Background The Critical-Section Problem Peterson s Solution Synchronization Hardware Mutex Locks
Advanced Threads & Monitor-Style Programming 1/24
Advanced Threads & Monitor-Style Programming 1/24 First: Much of What You Know About Threads Is Wrong! // Initially x == 0 and y == 0 // Thread 1 Thread 2 x = 1; if (y == 1 && x == 0) exit(); y = 1; Can
JAVA CONCURRENCY FRAMEWORK. Kaushik Kanetkar
JAVA CONCURRENCY FRAMEWORK Kaushik Kanetkar Old days One CPU, executing one single program at a time No overlap of work/processes Lots of slack time CPU not completely utilized What is Concurrency Concurrency
Concurrency, Thread. Dongkun Shin, SKKU
Concurrency, Thread 1 Thread Classic view a single point of execution within a program a single PC where instructions are being fetched from and executed), Multi-threaded program Has more than one point
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;
CONCURRENT ACCESS TO SHARED DATA STRUCTURES. CS124 Operating Systems Fall , Lecture 11
CONCURRENT ACCESS TO SHARED DATA STRUCTURES CS124 Operating Systems Fall 2017-2018, Lecture 11 2 Last Time: Synchronization Last time, discussed a variety of multithreading issues Frequently have shared
Chapter 6: Synchronization. Operating System Concepts 8 th Edition,
Chapter 6: Synchronization, Silberschatz, Galvin and Gagne 2009 Outline Background The Critical-Section Problem Peterson s Solution Synchronization Hardware Semaphores Classic Problems of Synchronization
Threads and Synchronization. Kevin Webb Swarthmore College February 15, 2018
Threads and Synchronization Kevin Webb Swarthmore College February 15, 2018 Today s Goals Extend processes to allow for multiple execution contexts (threads) Benefits and challenges of concurrency Race
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
CS-537: Midterm Exam (Fall 2013) Professor McFlub
CS-537: Midterm Exam (Fall 2013) Professor McFlub Please Read All Questions Carefully! There are fourteen (14) total numbered pages. Please put your NAME (mandatory) on THIS page, and this page only. Name:
Process Synchronization: Semaphores. CSSE 332 Operating Systems Rose-Hulman Institute of Technology
Process Synchronization: Semaphores CSSE 332 Operating Systems Rose-Hulman Institute of Technology Critical-section problem solution 1. Mutual Exclusion - If process Pi is executing in its critical section,
CS3733: Operating Systems
Outline CS3733: Operating Systems Topics: Synchronization, Critical Sections and Semaphores (SGG Chapter 6) Instructor: Dr. Tongping Liu 1 Memory Model of Multithreaded Programs Synchronization for coordinated
CSE332: Data Abstractions Lecture 23: Programming with Locks and Critical Sections. Tyler Robison Summer 2010
CSE332: Data Abstractions Lecture 23: Programming with Locks and Critical Sections Tyler Robison Summer 2010 1 Concurrency: where are we Done: The semantics of locks Locks in Java Using locks for mutual
Page 1. Goals for Today" Atomic Read-Modify-Write instructions" Examples of Read-Modify-Write "
Goals for Today" CS162 Operating Systems and Systems Programming Lecture 5 Semaphores, Conditional Variables" Atomic instruction sequence Continue with Synchronization Abstractions Semaphores, Monitors
Chapter 5: Process Synchronization. Operating System Concepts Essentials 2 nd Edition
Chapter 5: Process Synchronization Silberschatz, Galvin and Gagne 2013 Chapter 5: Process Synchronization Background The Critical-Section Problem Peterson s Solution Synchronization Hardware Mutex Locks
6.824 Distributed System Engineering: Spring Quiz I Solutions
Department of Electrical Engineering and Computer Science MASSACHUSETTS INSTITUTE OF TECHNOLOGY 6.824 Distributed System Engineering: Spring 2009 Quiz I Solutions All problems are open-ended questions.
Interprocess Communication By: Kaushik Vaghani
Interprocess Communication By: Kaushik Vaghani Background Race Condition: A situation where several processes access and manipulate the same data concurrently and the outcome of execution depends on the
EECS 482 Midterm (Fall 1998)
EECS 482 Midterm (Fall 1998) You will have 80 minutes to work on this exam, which is closed book. There are 4 problems on 9 pages. Read the entire exam through before you begin working. Work on those problems
Synchronization 1. Synchronization
Synchronization 1 Synchronization key concepts critical sections, mutual exclusion, test-and-set, spinlocks, blocking and blocking locks, semaphores, condition variables, deadlocks reading Three Easy Pieces:
Introduction to Operating Systems
Introduction to Operating Systems Lecture 4: Process Synchronization MING GAO SE@ecnu (for course related communications) mgao@sei.ecnu.edu.cn Mar. 18, 2015 Outline 1 The synchronization problem 2 A roadmap
Concurrency. Chapter 5
Concurrency 1 Chapter 5 2 Concurrency Is a fundamental concept in operating system design Processes execute interleaved in time on a single processor Creates the illusion of simultaneous execution Benefits
Consistency. CS 475, Spring 2018 Concurrent & Distributed Systems
Consistency CS 475, Spring 2018 Concurrent & Distributed Systems Review: 2PC, Timeouts when Coordinator crashes What if the bank doesn t hear back from coordinator? If bank voted no, it s OK to abort If
Page 1. Goals for Today. Atomic Read-Modify-Write instructions. Examples of Read-Modify-Write
Goals for Today CS162 Operating Systems and Systems Programming Lecture 5 Atomic instruction sequence Continue with Synchronization Abstractions Semaphores, Monitors and condition variables Semaphores,
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
Advanced Topic: Efficient Synchronization
Advanced Topic: Efficient Synchronization Multi-Object Programs What happens when we try to synchronize across multiple objects in a large program? Each object with its own lock, condition variables Is
Lecture 8: September 30
CMPSCI 377 Operating Systems Fall 2013 Lecture 8: September 30 Lecturer: Prashant Shenoy Scribe: Armand Halbert 8.1 Semaphores A semaphore is a more generalized form of a lock that can be used to regulate
Introduction to Lock-Free Programming. Olivier Goffart
Introduction to Lock-Free Programming Olivier Goffart 2014 QStyleSheetStyle Itemviews Animation Framework QtScript (porting to JSC and V8) QObject, moc QML Debugger Modularisation... About Me About Me
Read-Copy Update (RCU) Don Porter CSE 506
Read-Copy Update (RCU) Don Porter CSE 506 RCU in a nutshell ò Think about data structures that are mostly read, occasionally written ò Like the Linux dcache ò RW locks allow concurrent reads ò Still require
Introduction to Concurrent Software Systems. CSCI 5828: Foundations of Software Engineering Lecture 08 09/17/2015
Introduction to Concurrent Software Systems CSCI 5828: Foundations of Software Engineering Lecture 08 09/17/2015 1 Goals Present an overview of concurrency in software systems Review the benefits and challenges
I/O Management Software. Chapter 5
I/O Management Software Chapter 5 1 Learning Outcomes An understanding of the structure of I/O related software, including interrupt handers. An appreciation of the issues surrounding long running interrupt
NON-BLOCKING DATA STRUCTURES AND TRANSACTIONAL MEMORY. Tim Harris, 31 October 2012
NON-BLOCKING DATA STRUCTURES AND TRANSACTIONAL MEMORY Tim Harris, 31 October 2012 Lecture 6 Linearizability Lock-free progress properties Queues Reducing contention Explicit memory management Linearizability
CS193k, Stanford Handout #10. HW2b ThreadBank
CS193k, Stanford Handout #10 Spring, 99-00 Nick Parlante HW2b ThreadBank I handed out 2a last week for people who wanted to get started early. This handout describes part (b) which is harder than part
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!