CSCE Operating Systems Synchronization: Producer-Consumer Problem. Qiang Zeng, Ph.D. Fall 2018

Transcription

1 CSCE Operating Systems Synchronization: Producer-Consumer Problem Qiang Zeng, Ph.D. Fall 2018

2 Previous Class Restroom problem Bar problem Enforcing execution order CSCE 311 Operating Systems 2

3 Binary Semaphore for the restroom problem: mutual exclusion Given a single-spot restroom, write the function for using the restroom Hint: Binary Semaphore, a special semaphore, whose counter value can only be 0 or 1 Here, Binary Semaphore is used as Mutex, a blocking lock for enforcing MUTual EXclusion S = 1; // shared among customers (processes) use_restroom() { down(s); // try to enter the restroom; = lock() Use the restroom //critical section up(s); // leave the restroom; = unlock() } CSCE 311 Operating Systems 3

4 Semaphore for the bar problem Capacity = 100 Many customers try to enter the bar concurrently Please write code to make sure customers<=100 Caution: a Mutex will not work well; why? S = 100; // shared among processes // each process does the following down(s); // try to enter the bar Have fun; up(s); // leave the bar CSCE 311 Operating Systems 4

5 Semaphore for enforcing order Two processes: p0 and p1 How to enforce the order: p0.a1 -> p1.b1 -> p1.b2 -> p0.a2 Hint: use two semaphores S1 = 0; // shared S2 = 0; // shared // Process 0 A1; up(s1); down(s2); A2; // Process 1 down(s1); B1; B2; up(s2); CSCE 311 Operating Systems 5

6 Outline Single-slot producer-consumer problem Multi-slot producer-consumer problem CSCE 311 Operating Systems 6

7 Using Semaphores: Single-slot Producer-Consumer problem

8 Single-slot Producer-Consumer problem One slot; multi Producers keep producing items, while multi Consumers keep consumes items Hint: removeitem() cannot proceed if there is no item in the slot fillslot() cannot proceed if the slot still has an item S_slot = 1; // shared S_item = 0; // shared // Producer while(true) { down(s_slot); fillslot(); up(s_item); } // Consumer while(true) { down(s_item); removeitem(); up(s_slot); } CSCE 311 Operating Systems 8

9 Using Semaphores: The Producer-Consumer Problem Acknowledgement: some slides courtesy of Dr. Brighten Godfrey

10 Producer-consumer problem Chefs cook items and put them on a conveyer belt Waiters pick items off the belt CSCE 311 Operating Systems 10

11 Producer-consumer problem Now imagine many chefs!...and many waiters! CSCE 311 Operating Systems 11

12 Producer-consumer problem A potential mess! CSCE 311 Operating Systems 12

13 Producer-consumer problem inserts items removes items Shared resource: bounded buffer Efficient implementation: circular fixed-size buffer CSCE 311 Operating Systems 13

14 Shared buffer CSCE 311 Operating Systems 14

15 Shared buffer insertptr removeptr What does the chef do with a new pizza? Where does the waiter take a pizza from? CSCE 311 Operating Systems 15

16 Shared buffer insertptr insertptr removeptr Insert pizza CSCE 311 Operating Systems 16

17 Shared buffer insertptr removeptr Insert pizza CSCE 311 Operating Systems 17

18 Shared buffer insertptr removeptr Insert pizza CSCE 311 Operating Systems 18

19 Shared buffer insertptr removeptr Remove pizza removeptr CSCE 311 Operating Systems 19

20 Shared buffer insertptr Insert pizza removeptr CSCE 311 Operating Systems 20

21 Shared buffer Insert pizza insertptr removeptr CSCE 311 Operating Systems 21

22 Shared buffer BUFFER FULL: Producer must wait! Insert pizza insertptr removeptr CSCE 311 Operating Systems 22

23 Shared buffer removeptr insertptr Remove pizza CSCE 311 Operating Systems 23

24 Shared buffer removeptr insertptr Remove pizza CSCE 311 Operating Systems 24

25 Shared buffer removeptr insertptr Remove pizza CSCE 311 Operating Systems 25

26 Shared buffer removeptr insertptr Remove pizza CSCE 311 Operating Systems 26

27 Shared buffer removeptr insertptr Remove pizza CSCE 311 Operating Systems 27

28 Shared buffer removeptr insertptr Remove pizza CSCE 311 Operating Systems 28

29 Shared buffer removeptr insertptr Remove pizza CSCE 311 Operating Systems 29

30 Shared buffer Buffer empty: Consumer must be blocked! removeptr insertptr Remove pizza CSCE 311 Operating Systems 30

31 Designing a solution Wait for empty slot Insert item Signal item arrival Wait for item arrival Remove item Signal empty slot available What synchronization do we need? CSCE 311 Operating Systems 31

32 Designing a solution Wait for empty slot Insert item Signal item arrival Mutex (shared buffer) Wait for item arrival Remove item Signal empty slot available What synchronization do we need? CSCE 311 Operating Systems 32

33 Designing a solution Wait for empty slot Insert item Signal item arrival Semaphore (# empty slots) Wait for item arrival Remove item Signal empty slot available What synchronization do we need? CSCE 311 Operating Systems 33

34 Designing a solution Wait for empty slot Insert item Signal item arrival Semaphore (# filled slots) Wait for item arrival Remove item Signal empty slot available What synchronization do we need? CSCE 311 Operating Systems 34

35 Producer-Consumer Code buffer[pi] = data; pi = (pi + 1) % N; result = buffer[ci]; ci = (ci +1) % N; CSCE 311 Operating Systems 35

36 Single-slot Producer-Consumer problem One slot; multi Producers keep producing items, while multi Consumers keep consumes items Hint: Consumer.removeItem() has to occur after Producer.fillSlot() Once the slot is filled, Producer.fillSlot() has to occur after Consumer.removeItem() S_slot = 1; // shared S_item = 0; // shared // Producer while(true) { down(s_slot); fillslot(); up(s_item); } // Consumer while(true) { down(s_item); removeitem(); up(s_slot); } CSCE 311 Operating Systems 36

37 Producer-Consumer Code Counting semaphore check and decrement the number of free slots sem_wait(&slots); Block if there are mutex_lock(&mutex); no free buffer[pi] = data; slots pi = (pi + 1) % N; mutex_unlock(&mutex); Counting semaphore check and decrement the number of available items sem_wait(&items); mutex_lock(&mutex); result = buffer[ci]; ci = (ci +1) % N; mutex_unlock(&mutex); Block if there are no items to take sem_post(&items); sem_post(&slots); Done increment the number of available items Done increment the number of free slots CSCE 311 Operating Systems 37

38 Implementation based on Monitor and CV monitor ProducerConsumer condition cv_full, cv_cempty; int count; procedure produce(); { while (count == N) wait(cv_full); // if buffer is full, block put_item(widget); // put item in buffer count = count + 1; // increment count of full slots if (count == 1) signal(cv_empty); // if buffer was empty, wake consumer } procedure consume(); { while (count == 0) wait(cv_empty); // if buffer is empty, block remove_item(widget); // remove item from buffer count = count - 1; // decrement count of full slots if (count == N-1) signal(cv_full); // if buffer was full, wake producer } CSCE 311 Operating Systems 38

39 Summary Single-slot producer-consumer problem Multi-slot producer-consumer problem CSCE 311 Operating Systems 39

40 References Monitor type: Hoare vs Mesa (Mesa is the choice of most OSes) MONITOR/monitor-types.html CSCE 311 Operating Systems 40