Advance Operating Systems (CS202) Locks Discussion

Transcription

1 Advance Operating Systems (CS202) Locks Discussion

2 Threads Locks Spin Locks Array-based Locks MCS Locks Sequential Locks Road Map

3 Threads Global variables and static objects are shared Stored in the static data segment, accessible by any thread Dynamic objects and other heap objects are shared Allocated from heap with malloc/free or new/delete Local variables are not shared Each thread has its own stack. Never pass/share/store a pointer to a local variable on another thread s stack

4 Basic Problem Trouble with Threads A critical section is a piece of code that accesses a shared resource, usually a variable or data structure. If two concurrent threads are accessing a shared variable, and that variable is read/modified/written by those threads, then access to the variable must be controlled to avoid erroneous behavior Mechanisms to control access to shared resources Locks, Mutexes, Semaphores, Monitors, Condition variables, etc.

5 Threads Locks Spin Locks Array-based Locks MCS Locks Sequential Locks Road Map

6 Locks One way to implement critical sections is to locking it while accessing it, and unlock it again while leaving the critical sections. A lock is an object in memory providing two operations acquire(): before entering the critical section release(): after leaving a critical section Threads pair calls to acquire() and release() Between acquire()/release(), the thread holds the lock. acquire() does not return until any previous holder releases the lock. [Algorithms for scalable synchronization on shared-memory multiprocessors - John M. Mellor-Crummey, Michael L. Scott]

7 Threads Locks Spin Locks Array-based Locks MCS Locks Sequential Locks Road Map

8 Simple Test_ and_ Set Lock. Spin Lock Polling loop to access a Boolean flag that indicates whether the lock is held. Each thread repeatedly executes a test_and_set instruction in an attempt to change the flag from false to true, thereby acquiring the lock. A thread releases the lock by setting it to false.

9 Problems with Spinlocks Problem with spinlocks is that they are wasteful If a thread is spinning on a lock, then the thread holding the lock cannot make progress. Each waiting thread accesses the single shared flag as frequently as possible, using relatively expensive read-modify-write instructions. How did the lock holder give up the CPU Lock holder calls yield or sleep Involuntary context switch Reduce Overhead Test-and test_and_set technique: use a test_and_set instruction only when a previous read indicates that the test_ and_set might succeed. Exponential Backoff: introduce delay between consecutive probes of the lock by a thread.

10 Ticket Lock Try to reduce the number of read-modify-write operations for a simple test_ and_set lock to one per lock acquisition. Ensure FIFO service by granting the lock to threads in the same order in which they first requested it. Eliminates the possibility of starvation. Ticket lock consists of two counters : number of requests to acquire the lock. number of times the lock has been released. processor acquires the lock by performing a fetch_ and_increment operation on the request counter and waiting until the result (its ticket) is equal to the value of the release counter. releases the lock by incrementing the release counter.

11 Ticket Lock

12 Threads Locks Spin Locks Array-based Locks MCS Locks Sequential Locks Road Map

13 Array based Locks Each thread to use the atomic operation to obtain the address of a location on which to spin. Each thread spins on a different location. Array-based queuing locks guarantee FIFO ordering of requests. Achieve the constant bound on cache-coherent multiprocessors that support atomic fetch_and_increment or fetch_and_store operations.

14 Array based Locks

15 Threads Locks Spin Locks Array-based Locks MCS Locks Sequential Locks Road Map

16 MCS Lock Guarantees FIFO ordering of lock acquisitions. Spins on locally-accessible flag variables only. Requires a small constant amount of space per lock. works equally well on machines with and without coherent caches. Advantages : first and second property is shared with the ticket lock and the array-based queuing locks, third is shared with the test_and_set and ticket locks, fourth property is unique to MCS and handle the consequence of second property.

17 MCS Lock Every thread using the lock allocates a qnode record containing a queue link(pointer) and a Boolean flag. Processors holding or waiting for the lock are chained together by the links. Each processor spins on its own locally-accessible flag. The lock itself contains a pointer to the qnode record for the processor at the tail of the queue, or a nil if the lock is not held Each processor in the queue holds the address of the record for the processor behind it.

18 MCS Lock

19 Threads Locks Spin Locks Array-based Locks MCS Locks Sequential Locks Road Map

20 Sequential Lock Support fast writes of shared variables between threads. Allows free access to a resources for readers, but each reader must check existence of conflicts with writers. Algorithm: Writer increments the sequence number, both after acquiring the lock and before releasing the lock. Readers read the sequence number before and after reading the shared data. If the sequence number is odd on either occasion, a writer had taken the lock while the data was being read and it may have changed. If the sequence numbers are different, a writer has changed the data while it was being read. In either case readers simply retry (using a loop) until they read the same even sequence number before and after.

21 Sequential Lock

22 References Principles of Operating Systems : Alex C. Snoeren (UCSD) Algorithms for scalable synchronization on shared-memory multiprocessors - John M. Mellor-Crummey, Michael L. Scott Can Seqlocks Get Along with Programming Language Memory Models? Hans-J. Boehm