Operating Systems CMPSCI 377 Spring Mark Corner University of Massachusetts Amherst

Transcription

1 Operating Systems CMPSCI 377 Spring 2017 Mark Corner University of Massachusetts Amherst

2 Clicker Question #1 public static void main(string[] args) { (new Thread(new t1())).start(); (new Thread(new t2())).start();} What could go wrong here? (A) Nothing (B) Exception will be thrown (C) The threads will never complete // Defined somewhere in a class locks Semaphore sem1 = new Semaphore(1); Semaphore sem2 = new Semaphore(1); public class t1 implements Runnable{ public void run(){ locks.sem1.wait(); locks.sem2.wait(); Thread.sleep(1000); locks.sem1.signal(); locks.sem2.signal(); }} public class t2 implements Runnable{ public void run(){ locks.sem2.wait(); locks.sem1.wait(); Thread.sleep(1000); locks.sem1.signal(); locks.sem2.signal(); }}

3 Answer on Next Slide

4 Today: Deadlocks What are deadlocks? Conditions for deadlocks Deadlock prevention Deadlock detection CS377: Operating Systems

5 Deadlocks Deadlock: A condition where two or more threads are waiting for an event that can only be generated by these same threads. disk.wait(); printer.wait(); // copy from disk // to printer printer.signal(); disk.signal(); printer.wait(); disk.wait(); // copy from disk // to printer printer.signal(); disk.signal(); CS377: Operating Systems

6 Not Always Obvious Java s vector class is synchronized, which means you never see the locks Vector v1, v2; Thread 1: v1.addall(v2); Thread 2: Vector v1, v2; v2.addall(v1);

7 Deadlocks: Terminology Deadlock can occur when several threads compete for a finite number of resources simultaneously Deadlock prevention algorithms check resource requests and possibly availability to prevent deadlock. Deadlock detection finds instances of deadlock when threads stop making progress and tries to recover. Starvation occurs when a thread waits indefinitely for some resource, but other threads are actually using it (making progress). => Starvation is a different condition from deadlock CS377: Operating Systems

8 Necessary Conditions Deadlock can happen if all the following conditions hold. Circular wait: A set of waiting threads {t 1,..., t n } where t i is waiting on t i+1 (i = 1 to n) and t n is waiting on t 1. Hold and Wait: at least one thread holds a resource and is waiting for other resource(s) to become available. A different thread holds the resource(s). No Preemption: A thread can only release a resource voluntarily; another thread or the OS cannot force the thread to release the resource. Mutual Exclusion: at least one thread must hold a resource in nonsharable mode, i.e., the resource may only be used by one thread at a time. CS377: Operating Systems

9 Break any of these and you can prevent deadlock

10 Break Circular Wait Most common method: simply order your locks! Either a total ordering of all locks OR A partial order of locks (those that are used together) Disadvantage: You have to be *very* careful while writing code.. Lock(lock1) Lock(lock2) v1.addall(v2);

11 Example from Linux /* * Lock ordering: * * ->i_mmap_rwsem (truncate_pagecache) * ->private_lock ( free_pte-> set_page_dirty_buffers) * ->swap_lock (exclusive_swap_page, others) * ->mapping->tree_lock

12 Break Hold and Wait Acquire all locks before working Remember the dining philosophers? Our solutions acquired both forks or none (and waited). pthread_mutex_lock(prevention); // begin lock acquistion pthread_mutex_lock(l1); pthread_mutex_lock(l2);... pthread_mutex_unlock(prevention); // end

13 Break No Preemption Avoid deadlock by interrupting the lock and giving it up if you can t acquire all of the locks you need pthreads provides trylock to see if the lock is busy What could possibly go wrong? top: pthread_mutex_lock(l1); if (pthread_mutex_trylock(l2)!= 0) { pthread_mutex_unlock(l1); goto top; }

14 Livelock Instead of deadlock where everything is frozen, threads are working, but making no real progress Consider two people that meet in a hallway. One moves to the right to let the other by, the other moves to the left. Repeat! Also very hard to dig yourself out of a deep hole in code to go back to where you started acquiring locks

15 Break Mutual Exclusion Wait what? Don t I need that? Let s try not using locks at all! Consider x+=1. Really that is: temp = x+1 x=temp

16 Atomic Increment void AtomicIncrement(int *value, int amount) { do { int old = *value; } while (CompareAndSwap(value, old, old + amount) == 0); }

17 Clicker Question #2 What lines should be included in the critical section? (A) 1-7 (B) 2-6 (C) 4-6 (D) 5-6 (E) 6 1 void insert(int value) { 2 node_t *n = malloc(sizeof(node_t)); 3 assert(n!= NULL); 4 n->value = value; 5 n->next = head; 6 head = n; 7 }

18 Answer on Next Slide

19 Lock-free insert void insert(int value) { node_t *n = malloc(sizeof(node_t)); assert(n!= NULL); n->value = value; do { n->next = head; } while (CompareAndSwap(&head, n->next, n) == 0); }

20 Lock free data structures A rich subject May not be any faster (or even slower) for lightly contended locks

21 Deadlock detection What if we just let it run, detect deadlock when it happens and restart the system? Not really possible in general programs, but it is used in databases where it is clear how to abort something. (see your local DB professor for more)

22 Resource Allocation Graph We define a graph with vertices that represent both resources and threads A directed edge from a thread to a resource indicates that the thread has requested that resource, but has not yet acquired it A directed edge from a resource to a thread indicates that the thread is holding that resource If the graph has no cycles, no deadlock exists.

23 Cycles = Deadlock Detecting cycles takes O(n) time, where n is T + R + Edges. When should we execute this algorithm? Just before granting a resource, check if granting it would lead to a cycle? (Each request is then O(n).) Whenever a resource request can't be filled? (Each failed request is O(n).) On a regular schedule (hourly or...)? (May take a long time to detect deadlock) When CPU utilization drops below some threshold? (May take a long time to detect deadlock)

24 Correcting Deadlock Scan the resource allocation graph for cycles, and then break the cycles. Different ways of breaking a cycle: Kill all threads in the cycle. Kill the threads one at a time, forcing them to give up resources. Preempt resources one at a time rolling back the state of the thread holding the resource to the state it was in prior to getting the resource. This technique is common in database transactions. CS377: Operating Systems

25 Summary Deadlock: situation in which a set of threads/processes cannot proceed because each requires resources held by another member of the set. Detection and recovery: recognize deadlock after it has occurred and break it. Avoidance: don't allocate a resource if it would introduce a cycle. Prevention: design resource allocation strategies that guarantee that one of the necessary conditions never holds Code concurrent programs very carefully. This only helps prevent deadlock over resources managed by the program, not OS resources. Ignore the possibility! (Most OSes use this option!!) CS377: Operating Systems