CS 326 Operating Systems Synchronization. Greg Benson Department of Computer Science University of San Francisco

Transcription

1 CS 326 Operating Systems Synchronization Greg Benson Department of Computer Science University of San Francisco

2 High-level Synchronization So far we have seen low-level mechanisms for synchronization (mutual exclusion): Disabling interrupts on uniprocessors Spinlocks (test-and-set) on multiprocessors We will now look at higher-level mechanisms: Semaphores Monitors 2

3 Semaphores Special kind of variable (s) A non-negative integer with atomic increment and decrement Two operations P(s) or down(s) Decrement counter, if counter is 0 then block V(s) or up(s) Increment counter and wake one blocked thread 3

4 Semaphores - Formal Def Let np = number of completed P operations on s Let nv = number of completed V operations on s Let initval = initial value of s Require: np <= nv + initval If s = (nv + initval) - np, then Invariant: s >= 0 4

5 Semaphore Implementation First, a busy-waiting implementation: int sem; down(int *s) { int acquired = 0; while (!acquired) { disable_preemption(); if (*s > 0) { *s--; acquired = 1; enabled_preemption(); up(int *s) { disable_preemption(); *s++; enable_preemption(); 5

6 Semaphore Implementation 2 Now, a blocking implementation: struct sem {int value, list_elem list; down(struct sem *s) { disable_preemption(); if (s->value == 0) { listadd(cur, s->list); thread_block(); else { s->value--; enabled_preemption(); up(int *s) { disable_preemption(); if (!listempty(s->list) thread_unblock(listremove(s->list)); else *s++; enable_preemption(); 6

7 Semaphore Implementation 3 The Pintos blocking implementation: struct sem {int value, list_elem list; down(struct sem *s) { disable_preemption(); while (s->value == 0) { /* allow for higher priority threads */ listadd(cur, s->list); thread_block(); /* disable preemption */ s->value--; enabled_preemption(); up(int *s) { disable_preemption(); if (!listempty(s->list) thread_unblock(listremove(s->list)); *s++; enable_preemption(); 7

8 Types of Semaphores Counting semaphore: semaphore with any value >= 0 Used for scheduling Binary semaphore: semaphore with only two values (0 or 1) Used for mutual exclusion and scheduling 8

9 Semaphores in Practice Not too low-level and not too high-level Often used in OS kernels to build even highlevel synchronization E.g., Pintos uses semaphores to implement locks! Very flexible 9

10 Semaphore Examples We will look at three example uses of semaphores: Mutual exclusion Bounded buffer Dining philosophers 10

11 Semaphore Mutual Exclusion Use a binary semaphore as a lock variable int counter; struct semaphore c_mutex; sema_init(&c_mutex, 1); thread: sema_down(&c_mutex); /* enter CS */ counter++; sema_up(&c_mutex); /* leave CS */ 11

12 Semaphore Bounded Buffer Also called producer-consumer problem int buf[n], front = 0; rear = 0; struct semaphore mutex, full, empty; sema_init(&mutex, 1); sema_init(&full, 0), sema_init(&empty, N); Producer Thread: /* produce item */ /* wait for empty slot */ sema_down(&empty); sema_down(&mutex); /* put item in buffer */ buf[rear] = item; rear = (rear + 1) % N; sema_up(&mutex); /* announce item in buf */ sema_up(&full); Consumer Thread: /* wait for item */ sema_down(&full); sema_down(&mutex); /* put item in buffer */ item = buf[front]; front = (front + 1) % N; sema_up(&mutex); /* announce free slot */ sema_up(&empty); /* consume item */ 12

13 Dining Philosophers 5 philosophers, 5 plates of food, but only 5 forks Each philosopher does two things, thinks and eats In order to eat, a philosopher must grab two forks We want to devise a semaphore solution in which each philosopher is represented as a thread and each philosopher is allowed to think and eat P2 Do not delay other philosophers Prevent starvation P1 P3 P5 P4 13

14 Semaphore Dining Philosophers Represent each philosopher as a thread Represent each fork as a semaphore struct semaphore fork[n]; int i; for (i = 0; i < N; i++) sema_init(&fork[i], 1); void philosopher(void *id) { int i = (int) id; /* get philosopher number */ left = i; right = (i + 1) % N; while (1) { /* think */ /* get forks */ sema_down(&fork[left]); sema_down(&fork[right]); /* eat */ /* release forks */ sema_up(&fork[left]); sema_up(&fork[right]); 14

15 Monitors The monitor is a collection of shared variables and operations on those variables Implicit mutual exclusion Only one thread can be inside a monitor at a time Explicit signaling for condition synchronization Classic monitors are a language-level mechanism (compiler support required) Monitor-like functionality can be achieved with mutual exclusion locks and condition variables (more later) 15

16 Monitor Structure monitor buf { /* shared variables */ char buf[100]; int pos = 0; /* functions */ /* monitor invocation */ buf.putchar( A ); int putchar(char c) { buf[pos] = c; pos++; On invocation, a thread enters the monitor Only one thread may enter a monitor at a time 16

17 Monitor Variables Exist as long as monitor exists Initialized once before any monitor function executes They are not visible outside the monitor, only the monitor functions are visible A monitor looks like an abstract data type or OO class 17

18 Monitor Condition Variables Declaration condition cvname; The value of a condition variable is a queue of threads (not visible to the programmer) Operations wait(cv) signal(cv) Puts executing thread at the end of the cv queue Releases access to the monitor Awakens first thread (if any on cv queue) Executing thread eventually leaves monitor 18

19 Monitor Implementation Entry Queue - queue of threads that wish to enter the monitor CV Queue - one queue for each condition variable wait(cv) - wait outside monitor on cv queue signal(cv) - wake up thread, put on entry queue This is just one possible implementation cv1q cv2q EntryQ Monitor Shared variables Only one thread at a time 19

20 Comparison to Semaphores Differences between wait()/signal() and P()/V() a signal() is not remembered if no thread is on the cv queue V() operations are remembered (why?) Unlike P(), wait() always blocks the executing thread 20

21 Comparison to Java Java class can act like monitor with one (implicit) condition variable Java has a wait() operation Java has a notify() operation instead of signal() To use Java monitors you must declare methods as synchronized (or use the synchronized statement) 21

22 Monitor Examples Mutual exclusion Bounded buffer Dining philosophers Readers-writers 22

23 Monitor Mutual Exclusion Monitors have implicit mutual exclusion to monitor shared variables Can implement mutual exclusion locks with monitors monitor mutex { int locked = FALSE; condition busy; void enter(void) { if (locked) wait(busy); locked = TRUE; Thread:... mutex.enter(); /* in CS */ mutex.exit();... void exit(void) { locked = FALSE; signal(busy); 23

24 Monitor Bounded Buffer monitor buffer { int buf[n]; int front=0, rear=0, count=0; condition not_full, not_empty; void deposit(int data) { if (count == N) wait(not_full); buf[rear] = data; rear = (rear + 1) % N; count++; signal(not_empty); int fetch(void) { int rv; if (count == 0) wait(not_empty); rv = buf[front]; front = (front + 1) % N; count--; signal(not_full); return rv; Producer Thread:... buffer.deposit(item);... Consumer Thread:... item = buffer.fetch();... 24

25 Monitor Dining Philosophers monitor dp { int forks[n] = {2, 2,..., 2; condition both_free[n]; /* right[i] is i s right neighbor */ int right[n] = {1,..., N-1, 0; /* left[i] is i s left neighbor */ int left[n] = {N-1, 0, 1,..., N-2; void getforks(int i) { if (forks[i] < 2) wait(both_free); forks[right[i]]--; forks[left[i]]--; void relforks(int i) { forks[right[i]]++; forks[left[i]]++; if (forks[right[i]] == 2) signal(both_free[right[i]]); if (forks[left[i]] == 2) signal(both_free[left[i]]); 25 Philosopher Thread i: while(1) { /* Think */... dp.getforks(i); /* Eat */ dp.relforks(i);

26 Readers-Writers Problem We have shared data or a shared database Two types of threads: Readers of shared data Writers of shared data Want to allow multiple readers to access the shared data simultaneously Want to only allow a single writer to modify the data (no readers or other writers) 26

27 Monitor Readers-Writers monitor rw { int nr = 0, nw = 0; condition OKR, OKW; void req_read(void) { if (nw > 0) wait(okr); nr++; signal(okr); void rel_read(void) { nr--; if (nr = 0) signal(okw); void req_write(void) { if (nr > 0 nw > 0) wait(okw); nw++; void rel_write(void) { nw--; if (!empty(okw)) signal(okw); if (!empty(okr)) signal(okr); 27 Reader Thread: rw.req_read(); read shared_data rw.rel_read(); Writer Thread: rw.req_write(); modify shared data rw.rel_write();

28 Monitors in C C does not have language support for threads and synchronization We can achieve monitor-like functionality with locks and condition variables In Pthreads: In Pintos: Use mutex locks and condition variables Use locks and condition variables 28

29 Monitors in C Continued Basic idea Declare a single lock/mutex for each monitor (e.g., buflock) Declare variables/structs to associate with the monitor Declare condition variables to associate with the monitor For each monitor function, first acquire the monitor lock, release on exit Use the monitor lock as a parameter to cond_wait(): (Pthreads) pthread_cond_wait(&cv, &buflock) (Pintos) cond_wait(&cv, &buflock) 29

30 Monitors in C Example Bounded buffer in C struct bbuf { struct mutex m; struct condition not_full, not_empty; int buf[n]; int count, front, rear; ; void bb_put(struct bbuf *b, int data) { lock_acquire(&(b->m)); if (count == N) wait(&(b->not_full), &(b->m)); b->buf[b->rear] = data; b->rear = (b->rear + 1) % N; count++; signal(&(b->not_empty)); lock_release(&(b->m)); 30