Introduction to concurrent programming patterns signalling, rendezvous, barrier. Introduction to classical problems like Producer & Consumer, Readers & Writers, Dinning Philosophers, and Cigarette Smokers Problem.

1. Concurrent Programming
Patterns
CS4532 Concurrent Programming
Dilum Bandara
Dilum.Bandara@uom.lk
Some sides adapted from “The Little Book of Semaphores” by Allen B. Downey
and Dr. Srinath Perera

2. Building Blocks for Synchronization
 Locks
 Monitors
 Semaphores
 Mutex
 Condition Variables
 When, where, & how to use them?
2

3. Signalling
 When 1 thread signals to another
 Solves serialization problem
 Can implement using a Semaphore
3

4. Rendezvous
 2 threads rendezvous at a point of execution
 Neither is allowed to proceed until both have
arrived
 Make sure that a1 happens before b2 & b1
happens before a2
 Implement using Semaphores
4

5. Barrier
 Generalized form of Rendezvous
 All threads must wait till last 1 arrives
5

6. Barrier Implementation
6
(1)

7. Classical Problems
 Problems that we learned in OS class
 Real-world problems
 We may find similar problems in OS &
applications
 Solutions are slightly different
 Parallel programming is more of an Art than a
science
 Teach Art is by demonstrating Great examples
 So we learn classical problems
7

8. Classical Problems (Cont.)
 Producer & Consumer
 Readers & Writers
 Dinning Philosophers
 Cigarette Smokers Problem
8

9. Producer-Consumer Problem
 Producer produce an item & add it to a data
structure
 Consumer removes an item from data structure
& process it
 Examples
 User input from a keyboard
 Network packets
 What can go wrong?
 Solution? 9
Producer Consumer

10. Parallel Program Design
 1st think about signaling
 Decide what semaphores you need if any?
 Decide any state you need?
 Think what state(s) needs mutual exclusions
 Problem state vs. signaling state
 Write program
 Look for race conditions & deadlocks?
 Test by considering different scenarios
10

11. Producer-Consumer Problem (Cont.)
11
Producer Consumer
Producer-Consumer Init
What if a context switch happen after line 4 of producer?

12. Producer-Consumer Problem (Cont.)
12
Improved Producer
Is no of items consistent at consumers?
Danger of deadlock when you wait for a Semaphore while holding a
Mutex

13. Producer-Consumer With a Finite
Buffer
 What if finite buffer?
 Fast producer
 Block producer when buffer is full
 Wakeup when at least 1 buffer slot is empty
 What if?
If items >= buffer.size()
block
 But we don’t know value of a Semaphore
13

14. Producer-Consumer With a Finite
Buffer (Cont.)
 Buffer of size n
 Producer produce cakes & put them in buffer, consumer
eats them
 When producer finds that a buffer is full, it goes to sleep
 When producer finds that a buffer is empty, it add new
cake & wake up a consumer
 If a buffer is empty when consumer comes in, it wake up
producer & go to sleep
14
Source: http://technogems.blogspot.com/2012/09/producer-consumer-in-c.html

15. Producer-Consumer With a Finite
Buffer
15
Producer Consumer
Producer-Consumer Init

16. Readers & Writers
 Data structure is accessed by readers & writers
 Readers can co-exists, but only 1 writer can be
writing at a given time
 Very common usecase
 Read/Write lock is derived from this problem
 How to solve this?
 Hint – assume a light switch in a room
16

17. Readers & Writers (Cont.)
17
Readers & Writers Init
Writers Readers
Are you sure that only 1 reader & many writers may await?
When reader signals roomEmpty is it actually True?

18. Readers & Writers (Cont.)
 What if readers continue to arrive?
 Writers will starve
 Not a deadlock
 Solution(s)?
 When a Writer come, give it Priority
 Don’t let more than N Readers to go in consequently
18

19. Writer Priority – 1st Attempt
19
Readers & Writers Init
Lock lock; Lock empty;
Semaphore wChance = S(1);
int readers = 0;
1. wChance.down();
2. empty.acquire();
3. //write
4. wChance.up();
5. empty.release();
1. wChance.down();
2. wChance.up();
3. lock.acquire();
4. readers = readers +1;
5. if(readers == 1)
6. empty.acquire();
7. lock.release();
9. //read
10. lock.acquire();
11. readers = readers -1;
12. if(readers == 0)
13. empty.release();
14. lock.release();
Writers
Readers
Is writer priority guaranteed?

20. Light Switch
20

21. Writer Priority – 2nd Attempt
21
Readers & Writers Init
Writers Readers
Will readers starve?

22. Dinning Philosophers
 Philosophers eat/think
 Eating needs 2 forks
 Pick one fork at a time
 How to prevent deadlock? 22

23. Constraints That Dinning Philosophers
Must Satisfy
1. Only 1 philosopher can hold a fork at a time
2. Must be impossible for a deadlock to occur
3. Must be impossible for a philosopher to starve
waiting for a fork
4. Must be possible for more than 1 philosopher to
eat at the same time
 Efficiency
23

24. Dinning Philosophers – 1st Attempt
24
Which constraints are satisfied?

25. Dinning Philosophers – 2nd Attempt
 Attack the deadlock
 Possible solutions
 Only 4 Philosophers are allowed to eat at a time
 1 Philosopher is left-handed while others are right-
handed
 Actually, only need at least 1 leftie & at least 1 rightie
25

26. Only 4 Philosophers Allowed to Eat
26
Footman is a
Multiplex that
controls no of
Philosophers
No deadlock
No starvation

27. Tanenbaum’s Solution (Part 1/2)
27

28. Tanenbaum’s Solution (Part 2/2)
28

29. Tanenbaum’s Solution
29
Not starvation free
Initially 2 & 4 eating
2  1 & 4  3 & process continues