PRINCIPLES OF OPERATING SYSTEMS

Transcription

1 Department of Computer Science, University of Calgary PRINCIPLES OF OPERATING SYSTEMS Tutorial 9/10: Concurrency CPSC 457, Spring 2015 June 1-2, 2015

2 Announcement Midterm exam is rescheduled. The exam will cover course materials up to the end of Concurrency topic Please consult the update announcement on D2L Thursday June 11, 9 am in ST 135 2

3 Progress Indicator: Tutorials 3

4 Review: Race Conditions Consider a scenario when two concurrent processes A and B are compe@ng for CPU and printer Time Process A Process B 1 A.next = Spooler.next 2 B.next = Spooler.next 3 B.print(foo,B.next) 4 Spooler.next ++ 5 A.print(fish, A.next) 6 Spooler.next ++ Job 1 Job 2 fish foo print next next A B Print Spooler next 4

5 Review: Race Conditions Race Two or more processes are reading from or to some shared data The final result depends on who runs precisely when Concept applies to threads as well Henceforth, use the term threads instead of process 5

6 Review: Avoid race conditions? Prohibit more than one thread from reading from or to the shared data at the Cri$cal sec$on (Cri$cal region): The part of the program that access the shared memory or files Mutual exclusion: a way of making sure that if one thread is using a shared memory or file, the other threads will be excluded from doing the same thing 6

7 Review: Mutex A mutex is a variable that can be in one of the two states: locked or unlocked Two opera@ons: lock() and unlock() The thread that locks the mutex must be the one unlocking it Can be used to prevent others from entering CS A queue is used to hold threads wai@ng on the mutex 7

8 Mutexes in Pthreads 8

9 The Producer-Consumer Problem Two threads share a common, fixed- size buffer Producer: puts informa@on into the buffer Consumer: takes the informa@on out Condi@ons The consumer must wait if the buffer is empty The producer must wait if the buffer is full 9

10 First In Last Out (FILO) Buffer Stack Queued at the front De- queued from the front Counter points to the for new item to be queued Counter 10

11 Producer-Consumer: Simple Sol. The producer thread: do { // produce an item while (counter == BUFFER_SIZE) /* do nothing */ buffer[counter] = item; counter ++; } while (TRUE); The consumer thread: do { while (counter == 0) /* do nothing */ item = buffer[counter-1]; counter --; } while (TRUE); Consider the following sequence when counter is 1: T0 - producer: register1 = counter [register1 = 1] T1 - producer: register1 = register1 + 1 [register1 = 2] T2 - consumer: register2 = counter [register2 = 1] T3 - consumer: register2 = register2-1 [register2 = 0] T4 - producer: counter = register1 [counter = 2] T5 - consumer: counter = register2 [counter = 0] RACE CONDITION" 11

12 Solution Using Mutex int counter; // a shared variable" pthread_mutex_t mutex; // a lock main(): pthread_t pr, cn; pthread_mutex_init(&mutex, 0); // Initialize the mutex pthread_create(&pr, NULL, produce, NULL); // Create producer pthread_create(&cv, NULL, consume, NULL); // Create consumer pthread_join(pr, 0); // Wait for the producer to finish pthread_join(cn, 0); // Wait for the consumer to finish pthread_mutex_destroy(&mutex); // Destroy the mutex 12

13 Mutex Solution The producer thread: do { // produce an item pthread_mutex_lock(&mutex); while (buffer is full) /* do nothing */ buffer[counter] = item; counter ++; pthread_mutex_unlock(&mutex); } while (TRUE); The consumer thread: do { pthread_mutex_lock(&mutex); while (buffer is empty) /* do nothing */ item = buffer[counter-1]; counter --; pthread_mutex_unlock(&mutex); } while (TRUE); DEADLOCK" 13

14 Review: Wait & Signal pthread_cond_wait(&cond, &mutex) This atomically releases mutex and causes the calling thread to block on the variable cond Other threads are now able to acquire the mutex pthread_cond_signal(&cond) Sends the signal to threads on the pthread_cond_signal() signal another thread and wake up pthread_cond_broadcast()wake all threads A signal is lost if no thread is wai@ng on the condi@onal variable 14

15 Condition Variables Mutexes are good for race variables allow threads to block due to some not being met (we use for gegng rid of deadlock here) Almost always, mutexes and variables are used together 15

16 Solution pthread_cond_t empty; pthread_cond_t not_empty; pthread_mutex_t mutex; // buffer is empty // buffer is not empty // mutual exclusion The producer thread: do { // produce an item pthread_mutex_lock(&mutex); while (buffer is full) pthread_cond_wait(&empty, &mutex); The consumer thread: do { pthread_mutex_lock(&mutex); while (buffer is empty) pthread_cond_wait(&not_empty, &mutex); // remove an item from buffer pthread_cond_signal(&empty); pthread_mutex_unlock(&mutex); } while (TRUE); // add the item to the buffer pthread_cond_signal(&not_empty); pthread_mutex_unlock(&mutex); } while (TRUE); 16

17 Circular Queue Buffer Buffer as a circular queue: typedef struct {... } item; item buffer[n]; front (read) rear (write) in int in = 0; // next free position int out = 0; // first filled position Buffer is empty if in == out Buffer is full if (in + 1) % BUFFER_SIZE == out 17

18 We have a direct solution The producer thread: do { buffer[in] = item; while((in+1)% BUFFER_SIZE)==out); /* do nothing */ in = (in+1) % BUFFER_SIZE; } while (TRUE); The consumer thread: do { while (in == out); /* do nothing */ item = buffer[out]; out = (out+1)% BUFFER_SIZE; } while (TRUE); Features Simple solu@on No special mutual exclusion or synchroniza@on required Can you guess a drawback? 18

19 CPU idling We want Producer to go to sleep when buffer is full; consumer wakes up producer when one item is consumed Consumer to go to sleep when buffer is empty; producer wakes up consumer when one item is produced Sol: CombinaJon of condijon variables and mutex 19

20 Final Solution pthread_cond_t empty; pthread_cond_t full; pthread_mutex_t mutex; The producer thread: do { buffer[in] = item; pthread_mutex_lock(&mutex); while (buffer is full) pthread_cond_wait(&empty, &mutex); // buffer is empty // buffer is not empty // mutual exclusion The consumer thread: do { pthread_mutex_lock(&mutex); while (buffer is empty) pthread_cond_wait(&full, &mutex); item = buffer[out]; out = (out+1)% BUFFER_SIZE; pthread_cond_signal(&empty); pthread_mutex_unlock(&mutex); } while (TRUE); in = (in+1) % BUFFER_SIZE; pthread_cond_signal(&full); pthread_mutex_unlock(&mutex); } while (TRUE); 20

21 Programming Exercise Download producer- consumer- skeleton.c Complete the code in class (circular buffer case) You may keep this slide for reference Discussion on 21