Chapter 6: Synchronization 籃玉如. Part Three: Process Coordination Chapter 6 Synchronization...

Chapter 6: SynchronizationChapter 6: Synchronization

籃玉如籃玉如

Part Three: Process CoordinationPart Three: Process Coordination

Chapter 6 Synchronization

Chapter 7 Deadlocks

2

Chapter 6: SynchronizationChapter 6: Synchronization

6.1 Background

6.2 The Critical-Section Problem

6.3 Peterson’s Solution

6.4 Synchronization Hardware

6.5 Semaphores

6.6 Classic Problems of Synchronization

6.7 Monitors

6.8 Synchronization Examples

6.9 Atomic Transactions (X)

3

6.1 Background6.1 Background

Concurrent access to shared data may result in data inconsistency

Maintaining data consistency requires mechanisms to ensure the orderly execution of cooperating processes

Suppose that we wanted to provide a solution to the consumer-producer problem that fills all the buffers. We can do so by having an integer count that keeps track of the number of full buffers. Initially, count is set to 0. It is incremented by the producer after it produces a new buffer and is decremented by the consumer after it consumes a buffer.

4

Producer Producer

while (true)

{

/* produce an item and put in nextProduced

while (count == BUFFER_SIZE)

; // do nothing

buffer [in] = nextProduced;

in = (in + 1) % BUFFER_SIZE;

count++;

}

while (true)

{

while (count == 0)

; // do nothing

nextConsumed = buffer[out];

out = (out + 1) % BUFFER_SIZE;

count--;

/* consume the item in nextConsumed

}

ConsumerConsumer

5

Race ConditionRace Condition

count++ could be implemented as (in machine language)

register1 = count register1 = register1 + 1 count = register1

count-- could be implemented as

register2 = count register2 = register2 - 1 count = register2

Consider this execution interleaving with “count = 5” initially:

S0: producer execute register1 = count {register1 = 5}S1: producer execute register1 = register1 + 1 {register1 = 6} S2: consumer execute register2 = count {register2 = 5} S3: consumer execute register2 = register2 - 1 {register2 = 4} S4: producer execute count = register1 {count = 6 } S5: consumer execute count = register2 {count = 4}

6

6.2 The Critical-Section Problem6.2 The Critical-Section Problem

A system 包括 n 個 processes {p0, p1, …, pn-1}. 每一個 process 擁有一段程式片段 (the segment of code is called a critical section) ， in this segment 這個 process 可以改變共同變數 (common variables) ，更新表格，寫入一的檔案等。 這樣系統的一個重要特性是當有一個 process 再這段 critical section 執

行某些運算時，其他的 processes 就不被允許對此 critical section 進行任何運算動作。

此稱為 The critical section problem ，它的設計主要的目的是作為cooperating processes 之間的 protocol

do {

entry section

critical section

exit section

remainder section

} while (TRUE);

7

Solution to Critical-Section ProblemSolution to Critical-Section Problem

要解決 the critical-section problem 必須滿足 3個要求：

1. Mutual Exclusion – 如果 process pi 正在執行它的 CS ，則其他之 processes 不得執行它們自己的 CS 。

2. Progress – 又稱為 lockstep synchronization ，沒有 process 正在執行 CS ，則欲進入 CS5 之 processes ( 非在 remainder section) 可以被 select 。

3. Bounded Waiting – 一個 已發出 request 之 process 經過一段時間 (bound) 應該會被 grant 。

8

6.3 Peterson’s Solution (Software Solution)6.3 Peterson’s Solution (Software Solution)

A classic software-based solution to the critical-section problem

解決兩個 processes 輪流在他們的 critical sections & remainder

sections 執行的問題 Assume that the LOAD and STORE instructions are atomic;

that is, cannot be interrupted. The two processes share two variables:

int turn; Boolean flag[2]

The variable turn indicates whose turn it is to enter the critical section.

The flag array is used to indicate if a process is ready to enter the critical section. flag[i] = true implies that process Pi is ready!

9

Algorithm for Process Algorithm for Process PPii

do {

flag[i] = TRUE;

turn = j;

while ( flag[j] && turn == j);

CRITICAL SECTION

flag[i] = FALSE;

REMAINDER SECTION

} while (TRUE);

10

6.4 Synchronization Hardware 6.4 Synchronization Hardware (Hardware Solution)(Hardware Solution)

硬體上的特殊性質可以使寫程式的工作變得比較容易，並且增進系統的效率。

Uniprocessors – could disable interrupts (i.e., 正在執行的 critical-section modifying 不能被中斷 ) to solve critical-section problem

Currently running code would execute without preemption

Generally too inefficient on multiprocessor systems

因為這個訊息必須傳給所有的 processors ，此具相當浪費時間，使的系統效能大為降低

Modern machines provide special atomic hardware instructions ，亦即可在一個 memory cycle 內完成，不可被切割 Atomic = non-interruptable

Test-and-set 與 swap 指令都是 indivisible ，即 executed atomically 於 1 個 memory cycle 。

11

Algorithm 1: TestAndndSet Instruction Algorithm 1: TestAndndSet Instruction

Definition:

boolean TestAndSet (boolean *target)

{

boolean rv = *target;

*target = TRUE;

return rv:

}

12

Shared boolean variable lock., initialized to false. Solution:

do {

while ( TestAndSet (&lock ))

; /* do nothing

// critical section

lock = FALSE;

// remainder section

} while ( TRUE);

Solution using TestAndSetSolution using TestAndSet

13

Algorithm 2: Swap InstructionAlgorithm 2: Swap Instruction

Definition:

void Swap (boolean *a, boolean *b)

{

boolean temp = *a;

*a = *b;

*b = temp:

}

14

Solution using SwapSolution using Swap

Shared Boolean variable lock initialized to FALSE; Each process has a local Boolean variable key.

Solution:

do {

key = TRUE;

while ( key == TRUE)

Swap (&lock, &key );

// critical section

lock = FALSE;

// remainder section

} while ( TRUE);15

Algorithm 3: Burn’s AlgorithmAlgorithm 3: Burn’s Algorithm

Bounding-waiting mutual exclusion with TestAndSet ()

Satisfies all the critical-section requirements The common data structures are Waiting [n]

and lock, both are initialized to false.

Boolean Waiting [n];

Boolean lock;

16

Burn’s AlgorithmBurn’s Algorithmdo {

waiting [i] = TRUE;

key = TRUE;

while ( waiting [i] && key )

key = TestAndSet (&lock);

waiting [i] = FALSE;

// critical section

j = ( I + 1 ) % n;

while (( j != i) && ! waiting [j] )

j = ( j+1 ) % n;

if ( j == i )

lock = FALSE;

else

waiting [j] = FALSE;

// remainder section

} while (TRUE);17

6.5 Semaphore6.5 Semaphore 由於 software & hardware solutions 很難應用到複雜的問題

，為了解決這個問題，可以使用 semaphore (a synchronization tool) 。

對應用程式設計者而言不像 software & hardware solutions複雜

Synchronization tool that does not require busy waiting

Semaphore S – integer variable

Can only be accessed via two indivisible (atomic) operations: S: wait() and signal()

Originally called P() and V()

18

6.5 Semaphore6.5 Semaphore

wait (S) {

while S <= 0

; // no-op

S--;

}

signal (S) {

S++;

}

19

Semaphore as General Synchronization ToolSemaphore as General Synchronization Tool

Counting semaphore – integer value can range over an unrestricted domain

Binary semaphore – integer value can range only between 0 and 1; can be simpler to implement

Also known as mutex locks

Can implement a counting semaphore S as a binary semaphore to deal with the critical-section problem for n processes

Provides mutual exclusion

Semaphore S; // initialized to 1

wait (S);

Critical Section

signal (S);

20

signal (S) { S++; }

Usage of SemaphoreUsage of Semaphore

Counting semaphore 可用在資源的管控上： S is initialized to n

每一個需要使用 resource 的 process 執行 wait ()

當一個 resource 被 release 時，執行 signal ()

當 S=0 時，則需要使用 resource 的 processes 就必須等待 Semaphore 也用來處理不同的同步問題，例如有兩個同步的

processes ， P1 要執行 S1 指令，而 P2 要執行 S2 指令，但是 S2 得在 S1之後才能執行。 方法： p1 & P2 共享一個 semaphore synch (initial synach =0)

在 P1 加入 S1;

signal ();

在 P2 加入 wait (synch);

S2;

21

Semaphore ImplementationSemaphore Implementation

Must guarantee that no two processes can execute wait () and signal () on the same semaphore at the same time

Thus, implementation becomes the critical section problem where the wait and signal code are placed in the critical section.

Could now have busy waiting in critical section implementation

But implementation code is short

Little busy waiting if critical section rarely occupied

Note that applications may spend lots of time in critical sections and therefore this is not a good solution.

22

Semaphore Implementation with no Busy waitingSemaphore Implementation with no Busy waiting

With each semaphore there is an associated waiting queue. Each entry in a waiting queue has two data items:

value (of type integer)

pointer to next record in the list

Two operations:

block – place the process invoking the operation on the appropriate waiting queue.

wakeup – remove one of processes in the waiting queue and place it in the ready queue.

23

Semaphore Implementation with no Busy waitingSemaphore Implementation with no Busy waiting (Cont.)(Cont.)

Implementation of wait:

wait (S){

value--;

if (value < 0) {

add this process to waiting queue

block(); }

}

Implementation of signal:

Signal (S){

value++;

if (value <= 0) {

remove a process P from the waiting queue

wakeup(P); }

}

24

Deadlock and StarvationDeadlock and Starvation

Deadlock – two or more processes are waiting indefinitely for an event that can be caused by only one of the waiting processes 互相在等對方發出 signal ()

Let S and Q be two semaphores initialized to 1

P0 P1

wait (S); wait (Q);

wait (Q); wait (S);

. .

. .

signal (S); signal (Q);

signal (Q); signal (S);

Starvation – indefinite blocking. A process may never be removed from the semaphore queue in which it is suspended.

25

6.6 Classical Problems of Synchronization6.6 Classical Problems of Synchronization

These problems are used for testing nearly every newly proposed synchronization scheme.

Bounded-Buffer Problem

Readers and Writers Problem

Dining-Philosophers Problem

26

Bounded-Buffer ProblemBounded-Buffer Problem

N buffers, 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.

27

Bounded Buffer Problem (Cont.)Bounded Buffer Problem (Cont.)

The structure of the producer process

do { // produce an item

wait (empty);

wait (mutex);

// add the item to the buffer

signal (mutex);

signal (full);

} while (true);

28

Bounded Buffer Problem (Cont.)Bounded Buffer Problem (Cont.)

The structure of the consumer process

do {

wait (full);

wait (mutex);

// remove an item from buffer

signal (mutex);

signal (empty);

// consume the removed item

} while (true);29

Readers-Writers ProblemReaders-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.

30

Readers-Writers ProblemReaders-Writers Problem

Shared Data

Data set

Semaphore mutex initialized to 1.

Semaphore wrt initialized to 1.

Integer readcount initialized to 0.

31

Readers-Writers Problem (Cont.)Readers-Writers Problem (Cont.)

The structure of a writer process

do {

wait (wrt) ;

// writing is performed

signal (wrt) ;

} while (true)

32

Readers-Writers Problem (Cont.)Readers-Writers Problem (Cont.)

The structure of a reader process

do {

wait (mutex) ;

readcount ++ ;

if (readercount == 1) wait (wrt) ;

signal (mutex)

// reading is performed

wait (mutex) ;

readcount - - ;

if redacount == 0) signal (wrt) ;

signal (mutex) ;

} while (true)

33

Dining-Philosophers ProblemDining-Philosophers Problem

Shared data

Bowl of rice (data set)

Semaphore chopstick [5] initialized to 1

34

Dining-Philosophers Problem (Cont.)Dining-Philosophers Problem (Cont.)

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) ;

35

Problems with SemaphoresProblems with Semaphores

Incorrect use of semaphore operations:

signal (mutex) …. wait (mutex)

wait (mutex) … wait (mutex)

Omitting of wait (mutex) or signal (mutex) (or both)

36

6.7 Monitors6.7 Monitors

A high-level abstraction that provides a convenient and effective mechanism for process synchronization

包括 data 以及 procedures

Only one process may be active within the monitor at a time

37

6.7 Monitors6.7 Monitors

monitor monitor-name

{

// shared variable declarations

procedure P1 (…) { …. }

…

procedure Pn (…) {……}

Initialization code ( ….) { … }

…

}

}

38

Fig. 6.18 Syntax of a monitor

Schematic view of a MonitorSchematic view of a Monitor

39

MonitorsMonitors

Monitor 結構可確保在一個時間點只有一個 process在 monitor 中執行。

40Fig. 6.19 Schematic view of a monitor

MonitorsMonitors

雖然 programmer 不需要明確的寫 synchronization constraint 的程式碼，但仍需定義 additional synchronization mechanisms 。 This mechanisms are provided by the

condition construct.

41

MonitorsMonitors

condition x, y;

Two operations on a condition variable:

x.wait () – a process that invokes the operation is

suspended.

x.signal () – resumes one of processes (if any) tha

invoked x.wait ()

如果沒有 process 在 suspend 則 signal operation 沒有任何動作 ( 與 P / V 不同， V 每次都會影響semaphore)

42

Monitor with Condition VariablesMonitor with Condition Variables

43Fig. 6.20

MonitorsMonitors

如果 process P 引發 x.signal () 時，正有一個 process Q 是在等 x condition ，則有以下兩種情形： Signal and wait.

P either waits until Q leaves the monitor or waits for another condition.

Signal and continue.

Q either waits until P leaves the monitor or waits for another condition.

44

6.7.2 Solution to Dining Philosophers6.7.2 Solution to Dining Philosophers

monitor DP

{

enum { THINKING; HUNGRY, EATING) state [5] ;

condition self [5];

void pickup (int i) {

state[i] = HUNGRY;

test(i);

if (state[i] != EATING) self [i].wait;

}

void putdown (int i) {

state[i] = THINKING;

// test left and right neighbors

test((i + 4) % 5);

test((i + 1) % 5);

} 45

Solution to Dining Philosophers (cont)Solution to Dining Philosophers (cont)

void test (int i) {

if ( (state[(i + 4) % 5] != EATING) &&

(state[i] == HUNGRY) &&

(state[(i + 1) % 5] != EATING) ) {

state[i] = EATING ;

self[i].signal () ;

}

}

initialization_code() {

for (int i = 0; i < 5; i++)

state[i] = THINKING;

}

} 46

6.7.3 Implementing a Monitor Using Semaphores6.7.3 Implementing a Monitor Using Semaphores

對每一個 monitor 提一個 semaphore: mutex (initialized to 1) 。每一個行程在進入 monitor 之前，都必須先執行 wait (mutex) 的動作，並在離開 monitor 之後，執行 signal (mutex) 的動作。

因為一個 signaling process 可能必須等待，直到 the resumed process 離開 monitor 或是等待，所以增加一個semaphore: next (initialized to 0).

The signaling processes may suspend themselves on next semaphore.

next_count: an integer variable

To count the number of processes suspended on next

47

6.7.3 Implementing a Monitor Using Semaphores6.7.3 Implementing a Monitor Using Semaphores

Each external procedure F:

wait (mutex);

…

body of F

…

if (next_count > 0)

signal (next);

else

signal (mutex);

48

6.7.3 Implementing a Monitor Using Semaphores6.7.3 Implementing a Monitor Using Semaphores

Condition x:

semaphore x_sem (initialized to 0)

x_count (an integer, initialized to 0)

49

6.7.4 Resuming Processes Within a Monitor6.7.4 Resuming Processes Within a Monitor

可能有以下問題，在 Chap 17 System Protection 再討論 一個 process 可能在沒有先取得某項資源的

存取允許權之前就先使用該資源。 一個 process 在獲得某項資源的存取權之後

，就佔住不放。 一個 process 可能會試圖釋放一項從未取得

過的資源。 一個 process 可能會對相同的資源提出兩次

要求 ( 沒有先釋放出該資源 ) 。50