Lecture 12: Synchronization 3 - Semaphores

Question 1

Goals for Solving Critical Sections

Answer 1

1. Mutual Exclusion
   no more than 1 process in its critical section at a time
2. Progress
   cannot keep postponing scheduling process into its critical section if no other is in its critical section
3. Bounded wait
   once a process requests entering critical section, there must be a bound on # of other processes allowed to enter their critical section before granted

Question 2

Clever Algorithms

Answer 2

1. Strict Alternation
2. After You
3. Peterson’s Algorithm

Question 3

Strict Alternation

Answer 3

Threads take turns entering C/S

Mutex? Yes
Progress? No
Bounded-wait? Yes

Question 4

After You

Answer 4

Threads enter C/S when no others want to

Mutex? Yes
Progress? No
Bounded-wait? No

Question 5

Peterson’s Algorithm

Answer 5

Combines Strict Alternation and After You algorithms. Thread enters C/S when its turn, or thread whose turn it is not interested

Mutex? Yes
Progress? Yes
Bounded-wait? Yes

Question 6

Disabling Interrupts

Answer 6

+: Easy to see that it works

–: Overkill

1. Disables all interrupts (e.g.: I/O)
2. Disallows concurrency with threads in non- critical sections

–: Doesn’t work for multicore systems
(Each CPU has own interrupts: threads on different
CPU’s can access their critical sections at same time)

Question 7

Test and Set

Answer 7

• New AL instruction (∴ Atomic)

- Can be used to implement “locking”

Question 8

Semaphores

Answer 8

Data structure consisting of lock with wait queue

Question 9

Semaphore variations

Answer 9

Binary Semaphore: one thread can hold lock at a time (n = 1) good for critical sections

Counting Semaphore:n threads can hold lock at a time (good for other synchronization problems)

Question 10

Binary Semaphores and Critical Sections: Why so much simpler than Peterson’s algorithm?

Answer 10

• devil is in the details
must ensure that no two threads can execute acquire, release on
same semaphore at the same time (shared counter, cnt)

• C/S Problem moved to semaphore implementation! Will Revisit After Talking About Monitors

Question 11

Bounded-Buffer Problem

Answer 11

1. Shared variable
   buffer [N]: shared by all
   in: shared by all producers
   out: shared by all consumers
2. Full buffer:
   ensure that producer doesn’t try and insert into (instead wait until not full)
3. Empty buffer:
   ensure that consumer doesn’t try to consume from (instead wait until not empty)

Question 12

Bounded Buffer Problem: Use of Semaphores

Answer 12

1. mutex
   • binary (initialized to 1)
   • ensures exclusive access to code reading, writing in, out, buffer
2. empty
   • counting (initialized to buffer size, N)
   • when = 0, no empty slots. Begins queueing producers
3. full
   • counting (initialized to 0)
   • when = 0, no full slots. Begins queueing consumers