Scribd
Upload
9 views13 pages

2.6, 2.7 - Classical Problems of Synchronization

The document discusses classical synchronization problems used to test synchronization schemes, including the Bounded-Buffer Problem, Readers-Writers Problem, and Dining-Philosophers Problem. Each problem is explained with its structure and algorithms, highlighting the use of semaphores for managing access to shared resources. Additionally, variations and potential issues like deadlock and starvation are addressed, particularly in the context of the Readers-Writers and Dining-Philosophers Problems.

Uploaded by

anwarraja.a2023ai-ds
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
9 views13 pages

2.6, 2.7 - Classical Problems of Synchronization

The document discusses classical synchronization problems used to test synchronization schemes, including the Bounded-Buffer Problem, Readers-Writers Problem, and Dining-Philosophers Problem. Each problem is explained with its structure and algorithms, highlighting the use of semaphores for managing access to shared resources. Additionally, variations and potential issues like deadlock and starvation are addressed, particularly in the context of the Readers-Writers and Dining-Philosophers Problems.

Uploaded by

anwarraja.a2023ai-ds
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 13

Classical Problems of

Synchronization
Classical Problems of Synchronization
• Classical problems used to test
newly-proposed synchronization schemes
– Bounded-Buffer Problem
– Readers and Writers Problem
– Dining-Philosophers Problem
Bounded-Buffer Problem
• nbuffers, each can hold one item
• Semaphore mutex initialized to the value 1
• Semaphore full initialized to the value 0
• Semaphore empty initialized to the value n
Bounded Buffer Problem (Cont.)
• The structure of the producer process

do {
...
/* produce an item in next_produced */
...
wait(empty);
wait(mutex);
...
/* add next produced to the buffer */
...
signal(mutex);
signal(full);
} while (true);
Bounded Buffer Problem (Cont.)
● The structure of the consumer process

Do {
wait(full);
wait(mutex);
...
/* remove an item from buffer to next_consumed */
...
signal(mutex);
signal(empty);
...
/* consume the item in next consumed */
...
} while (true);
Readers-Writers Problem
• A data set is shared among a number of concurrent processes
– Readers – only read the data set; they do not perform any updates
– Writers – can both read and write
• Problem – allow multiple readers to read at the same time
– Only one single writer can access the shared data at the same time
• Several variations of how readers and writers are considered –
all involve some form of priorities
• Shared Data
– Data set
– Semaphore rw_mutex initialized to 1
– Semaphore mutex initialized to 1
– Integer read_count initialized to 0
Readers-Writers Problem (Cont.)
• The structure of a writer process

do {
wait(rw_mutex);
...
/* writing is performed */
...
signal(rw_mutex);
} while (true);
Readers-Writers Problem (Cont.)
• The structure of a reader process
do {
wait(mutex);
read_count++;
if (read_count == 1)
wait(rw_mutex);
signal(mutex);
...
/* reading is performed */
...
wait(mutex);
read count--;
if (read_count == 0)
signal(rw_mutex);
signal(mutex);
} while (true);
Readers-Writers Problem Variations
• First variation – no reader kept
waiting unless writer has permission
to use shared object
• Second variation – once writer is
ready, it performs the write ASAP
• Both may have starvation leading to
even more variations
• Problem is solved on some systems by
kernel providing reader-writer locks
Dining-Philosophers Problem

• Philosophers spend their lives alternating thinking and eating


• Don’t interact with their neighbors, occasionally try to pick up 2 chopsticks
(one at a time) to eat from bowl
– Need both to eat, then release both when done
• In the case of 5 philosophers
– Shared data
• Bowl of rice (data set)
• Semaphore chopstick [5] initialized to 1
Dining-Philosophers Problem Algorithm

• The structure of Philosopher i:


do {
wait (chopstick[i] );
wait (chopStick[ (i + 1) % 5] );

// eat

signal (chopstick[i] );
signal (chopstick[ (i + 1) % 5] );

// think

} while (TRUE);

• What is the problem with this


algorithm?
Dining-Philosophers Problem Algorithm (Cont.)

• Deadlock handling
– Allow at most 4 philosophers to be
sitting simultaneously at the table.
– Allow a philosopher to pick up the forks
only if both are available (picking must
be done in a critical section.
– Use an asymmetric solution -- an
odd-numbered philosopher picks up
first the left chopstick and then the right
chopstick. Even-numbered philosopher
picks up first the right chopstick and
then the left chopstick.
Assignment
• Explain Bounded-Buffer Problem
• Explain Readers-Writers Problem
• Explain Dining-Philosophers Problem.

You might also like