1 Synchronization Threads communicate to ensure consistency If not: race condition (non-deterministic result) Accomplished by synchronization operations How to write concurrent code How to implement synchronization operations

2 Synchronization – Motivation “The too much milk problem” Model of need to synchronize activities

3 Synchronization Terminology Mutual exclusion (“mutex”) – prevents multiple threads from entering Critical section – regions of code that modify or access shared variables – code only one thread can execute at a time Lock – mechanism for mutual exclusion Lock on entering critical section, accessing shared data Unlock when complete Wait if locked

4 Solving the Too Much Milk Problem Correctness properties Safety: “nothing bad happens” Progress: “something good eventually happens” First: use atomic loads & stores as building blocks “Leave a note” (lock) “Remove a note” (unlock) “Don’t buy milk if there’s a note” (wait)

5 Too Much Milk: Solution 1 thread A if (no milk && no note) leave note buy milk remove note thread B if (no milk && no note) leave note buy milk remove note Does this work? too much milk

6 Too Much Milk: Solution 2 thread A leave note A if (no note B) if (no milk) buy milk remove note A thread B leave note B if (no note A) if (no milk) buy milk remove note B Idea: use labeled notes oops – no milk

7 Language Support Synchronization complicated Better way – provide language-level support Higher-level approach Hide gory details in runtime system Increasingly high-level approaches: Locks, Atomic Operations Semaphores – generalized locks Monitors – tie shared data to synchronization

8 Locks Provide mutual exclusion to shared data via two atomic routines Lock::Acquire – wait for lock, then take it Lock::Release – unlock, wake up waiters Rules: Acquire lock before accessing shared data Release lock afterwards Lock – initially released

9 Too Much Milk: Locks Clean, symmetric - but how do we implement it? thread A Lock.acquire() if (no milk) buy milk Lock.release() thread B Lock.acquire() if (no milk) buy milk Lock.release()

10 Implementing Locks Requires hardware support (in general) Can build on atomic operations: Disable interrupts Uniprocessors only Test & Set, Compare & Swap

11 Disabling Interrupts Prevent scheduler from switching threads in middle of critical sections Ignores quantum expiration (timer interrupt) No handling I/O operations (Don’t make I/O calls in critical section!) To ensure current sequence of instructions run atomically Drawback?

12 Atomic Read-Write-Modify Instructions Atomically read old value, write new value Examples: Test & Set (most arch) Exchange (x86) Compare & Swap (68K, Sparc)

13 Implementing Locks: Test & Set int testset (int value) { int old = value; value = 1; return old; } pseudo-code: red = atomic class Lock { private int value; Lock() { value = 0; } void acquire() {…} void release() {…} } void acquire() { while (testset(value)) {} } void release() { value = 0; } Effect of testset(value) when value = 0? or 1? acquire – wait until lock released, then take it release – release lock value: 1 (locked); 0 (unlocked)

14 Busy Waiting (“Spinning”) What’s wrong with this implementation? CPU utilization? Different priorities? void acquire() { while (testset(value)) {} } void release() { value = 0; } spin-lock

15 Minimizing Busy Waiting Can’t implement locks with test & set without any waiting (w/o disabling interrupts) Add queue to lock and sleep: blocking lock void acquire() { while (1) { if (testset(value)) { put thread on queue, sleep } else { break; } } } void release() { value = 0; wake up threads; }

16 Locks in POSIX pthread_mutex_t my_mutex; pthread_mutex_init(&my_mutex); // also: pthread_mutex_t my_mutex = PTHREAD_MUTEX_INITIALIZER;... pthread_mutex_lock(&my_mutex); x = x + 1;/* This is the critical section */ pthread_mutex_unlock(&my_mutex);... pthread_mutex_destroy(&my_mutex); pthread_mutex_t my_mutex; pthread_mutex_init(&my_mutex); // also: pthread_mutex_t my_mutex = PTHREAD_MUTEX_INITIALIZER;... pthread_mutex_lock(&my_mutex); x = x + 1;/* This is the critical section */ pthread_mutex_unlock(&my_mutex);... pthread_mutex_destroy(&my_mutex);

17 Locks in POSIX: Example Reader-writer problem: Share a buffer which holds one item (an integer) A single reader and writer Reader: only read when there is item in buffer Writer: only write when there is space in buffer

18 Locks in POSIX: Example - II #include int buffer_has_item = 0; int buffer; pthread_mutex_t mutex; void * reader_function(void *) { while(1){ pthread_mutex_lock( &mutex ); if ( buffer_has_item == 1) { printf("reader consumes one item: %d.\n", buffer); buffer_has_item = 0; } pthread_mutex_unlock( &mutex ); }

19 Locks in POSIX: Example - III void writer_function(void) { while(1) { pthread_mutex_lock( &mutex ); if ( buffer_has_item == 0 ){ buffer = rand()*100; printf("writer produces one item: %d\n", buffer); buffer_has_item = 1; } pthread_mutex_unlock( &mutex ); } void main() { pthread_t reader; pthread_mutex_init(&mutex, NULL); pthread_create( &reader, NULL, reader_function,NULL); writer_function(); }

20 Locks as Synch Primitive +Locks provide mutual exclusion +Only one thread enters section at a time +Simplifies writing concurrent programs - Low-level - Can complicate coding - e.g., “allow at most n threads to access resource”  What are some alternatives?

21 Locks & Semaphores Implementing locks Semaphores Monitors

22 Semaphores What’s a “semaphore” anyway? A visual system for sending information by means of two flags that are held one in each hand, using an alphabetic code based on the position of the signaler's arms.

23 Semaphores What’s a “semaphore” anyway? A visual signaling apparatus with flags, lights, or mechanically moving arms.

24 Semaphores in CS Computer science: Dijkstra (1965) A non-negative integer counter with atomic increment & decrement. Blocks rather than going negative. Higher-level than locks but not too high level

25 Semaphores: Key Concepts P(sem), a.k.a. wait = decrement counter If sem = 0, block until greater than zero P = “prolagen” (proberen te verlagen, “try to decrease”) In Holland the good Dr. Dijkstra Took a break from a walk on his bijkstra And said: "Which shall it be? Take a P or a V? For the two seem to me quite alijkstra!" V(sem), a.k.a. signal = increment counter Wake 1 waiting process V = “verhogen” (“increase”)

26 Implementing Semaphores class Semaphore { private int value; private Queue q; Semaphore(int v) { value = v; } } void wait() { if (value > 0) { value = value – 1; } if (value == 0) { add this process to Q; sleep(); } void signal() { value = value + 1; if (anyone on Q) { remove P from Q; wakeup(P); }

27 Variants of Semaphores Binary semaphore just two values (0 or 1), typically initial value 1 (“free”) Counting semaphore useful when units of resource are available initialized to number of resources  thread can access as long as one unit available

28 Binary Semaphores: Example “too much milk” with locks thread A Lock.acquire() if (no milk) buy milk Lock.release() thread B Lock.acquire() if (no milk) buy milk Lock.release() thread A sem.wait() if (no milk) buy milk sem.signal() thread B sem.wait() if (no milk) buy milk sem.signal() “too much milk” with binary semaphores (initially 1)

29 Binary Semaphore: Example More flexible than locks! By initializing semaphore to 0, threads can wait for an event to occur thread A // wait for thread B sem.wait(); // do stuff … thread B // do stuff, then // wake up A sem.signal();

30 Counting Semaphores: Example Controlling resources: Allow threads to use at most 5 files simultaneously Initialize to 5 thread A sem.wait(); // use a file sem.signal(); thread B sem.wait(); // use a file sem.signal();

31 Semaphore in POSIX sem_t sem; sem_init(&sem, int pshared, unsigned value); sem_wait(&sem); sem_post(&sem); sem_destroy(&sem); sem_t sem; sem_init(&sem, int pshared, unsigned value); sem_wait(&sem); sem_post(&sem); sem_destroy(&sem);

32 Solving Reader-writer Problem Using Semaphore Reader-writer problem: Share a buffer which holds one item (an integer) A single reader and writer Reader: only read when there is item in buffer Writer: only write when there is space in buffer How to make the writer enter the critical section first? How to make the reader & writer alternate to enter critical section?

33 Semaphore in Linux: Solving Reader-writer Problem #include sem_t readers_turn, writers_turn; /* semaphore declaration */ int buffer, loopcnt = 5; void * reader_function(void *) { int i; for (i=0; i<loopcnt; i++) { sem_wait( &readers_turn ); printf("reader consumes one item: %d.\n", buffer); sem_post( &writers_turn ); } void writer_function(void) { int i; for (i=0; i<loopcnt; i++) { sem_wait( &writers_turn ); buffer = rand(); printf("writer produces one item: %d\n", buffer); sem_post( &readers_turn ); }

34 Semaphore in Linux: Solving Reader-writer Problem - II int main() { pthread_t reader; if (sem_init(&readers_turn, 0, 0) < 0) { perror("sem_init"); exit(1); } if (sem_init(&writers_turn, 0, 1) < 0) { perror("sem_init"); exit(1); } if(pthread_create( &reader, NULL, reader_function, NULL) != 0) { perror("pthread_create"); exit(1); } writer_function(); sem_destroy(&readers_turn); sem_destroy(&writers_turn); return 1; }

35 Summary Implementing locks Test & Set Spin locks, blocking locks Semaphores Generalization of locks Binary, counting (“Dijkstra-style”) Useful for: Controlling resources Waiting on events