Transcript Mutex

7장 프로세스 동기화 II
2015-10-30
7.5 동기화의 전통적 문제
1. 유한 버퍼 문제
전제조건 :
버퍼풀은 n개로 구성되어 있으며, 각각은 하나의 항목을
보관할 수 있다.
 Mutex 세마포어


버퍼풀에 접근하기 위한 상호배제
값은 1로 초기화
 Empty와 full 세마포어



계속하여 버퍼가 empty와 full 인지를 계산
세마포어 empty 는 값 n으로 초기화
세마포어 full 은 값0으로 초기화
7.5 Classical Problem of Synchronization
 생산자 프로세스의 구조
do {

Produce an item in nextp

wait( empty ); // Notify getting resources to another processes
wait( mutex ); // Get mutual exclusion about resource

add nextp to buffer // Produce full buffers for the consumer

signal( mutex ); // Release mutual exclusion
signal( full );
// Notify releasing resources
} while (1)
7.5 Classical Problem of Synchronization
 소비자 프로세스 구조
do {
wait(full);
// Notify getting resources to another processes
wait(mutex); // Get mutual exclusion about resource

remove an item from buffer to nextc

 Produce empty buffers for the producer
signal(mutex); // Release mutual exclusion
signal(empty); // Notify releasing resources

consume the item in nextc

} while(1)
7.5 Classical Problem of Synchronization
2. readers-writers 문제 (1)
 데이터 객체(file or record 등)는 여러 개의 병행 프로세스에
의해서 공유된다.
 프로세스의 두가지 형태



Reader : 읽기만 하는 프로세스
Writer : 읽고 쓰는 프로세스
만약 writer 와 함께 다른 프로세스(reader 혹은 writer) 가
동시에 공유 객체에 접근할 경우  Chaos
reader-writer problem


1st readers-writers 문제
 Solution : writer가 공유 객체에 대한 권한을 받은 경우가
아니면 reader는 기다리지 않는다.
2nd readers-writers 문제
 Solution : writer는 준비되면 최대한 빨리 실행한다. Writer가
기다리면, 새로운 reader는 허용되지 않는다.
7.5 Classical Problem of Synchronization
2. readers-writers 문제 (2)
 각 해결책은 starvation을 야기시킬 수 있다.

1st case - Writers’ starvation
2nd case - Readers’ starvation
 해결책
첫번째 해결책에 starvation이 없는 방법 제시
semaphore mutex, wrt;
int
readcount;
mutex, wrt – 세마포어이며 값는 1로 초기화
readcount – 값은 0으로 초기화
 wrt semaphore : reader와 writer에게 공용
writer 프로세스는 상호배제
 mutex semaphore : readcount가 수정될 때 상호배제를 보증
 readcount : 객체를 읽은 프로세스 수

7.5 Classical Problem of Synchronization
 writer 프로세스 구조
wait( wrt );

writing is performed

signal( wrt );
 reader 프로세스 구조
wait( mutex );
readcount++;
if (readcount == 1)
wait( wrt );
signal( mutex );
····
reading is performed
····
wait( mutex );
readcount--;
if (readcount == 0)
signal( wrt );
signal( mutex );
7.5.3 철학자들의 만찬 문제

전통적인 동기화 문제
 Allocate several resources among several processes in a
deadlock and starvation-free manner
•5명의 철학자는 단지 생각하고 먹기만
한다.
• 다섯개의 밥그릇과 젓가락이 있다.
•철학자는 한번에 하나의 젓가락을 집을 수
있다.
• 철학자는 동시에 두개의 젓가락을 모두
잡았을 때 식사를 할수 있고, 식사중에는
젓가락을 놓지 않는다.
7.5 The Dining-Philosophers Problem

해결책 1
 각 젓가락의 세마포어 값을 1로 초기화
 젓가락 잡기 - a wait operation on that semaphore
 젓가락 놓기 - a signal operation on the appropriate
semaphores
 이웃하는 두사람이 동시에 식사하지 않는다고 보장한다.
그러나 이 해결책은 교착상태를 발생시킬 가능성이 있다.
 All philosophers grab their left chopsticks simultaneously,
 All the element of chopstick will be 0
 When each philosopher tries to grab her right chopstick, she
will be delayed forever
 Need some remedies against the deadlock
7.5 The Dining-Philosophers Problem

교착상태 문제의 해결책
 동시에 테이블에 앉을 수 있는 철학자 수는 4로 한다.
 철학자는 두개의 젓가락을 모두 잡을 수 있는 경우에만
잡는것을 허용한다.
 비동기식 해결 :


홀수번째 철학자는 왼쪽을 먼저 집고 오른쪽을 집도록 한다.
짝수 번째 철학자는 오른쪽을 먼저 잡고 왼쪽을 잡도록 한다.
Any satisfactory solution must guard against the possibility of
starvation. A deadlock-free solution does not necessarily
eliminate the possibility of starvation
7.6 임계영역(Critical Regions)

Various difficulties (Semaphore)
 (Suppose) A process interchanges the order
signal(mutex);
…
critical section
…
wait(mutex);


mutual-exclusion 요구사항을 위반
항상 재현가능한 상황이 아님
7.6 Critical Regions
 (Suppose) replaces signal(mutex) with wait(mutex)
wait(mutex);
…
critical section
….
wait(mutex)

Deadlock will occur
 (Suppose) process omits the wait(mutex), or the signal(mutex), or both

상호배제(Mutual exclusion) 위반

교착상태(deadlock) 발생
7.6 Critical Regions

Fundamental high level synchronization construct
 Critical region(conditional critical region)
 Monitor

Critical region
 Encapsulation


프로세스가 다른 프로세스의 지역 데이터에 직접 접근하지 못함
그러나 프로세스는 전역 데이터를 공유할 수 있음.
 Variable v of type T

다음과 같이 선언
– v : shared T;

변수 v 는 region 내에서만 접근 가능
– region v when B do S;
• expression B : Boolean expression
• When a process tries the enter the critical-section region,B is evaluated
7.6 Critical Regions
 Distinct sequential processes(별개의 순차 프로세스)
region v when (true) S1;
region v when (true) S2;

“S1 followed by S2” or “S2 followed by S1”
 Let us code the bounded-buffer scheme

The buffer space and its pointers are encapsulated in
struct buffer {
item pool[n] ;
int
count, in, out ;
};
7.6 Critical Regions

The producer process
region buffer when (count < n) {
pool[in] = nextp ;
in = (in+1) % n;
count++;
}

The consumer process
region buffer when (count > 0) {
nextc = pool[out]
out = (out +1) mod n;
count--;
end;
7.6 Critical Regions
 How the conditional critical region could be Implemented by
a compiler

shared variable
semaphore mutex, first_delay, second_delay ;
int
first_count, second_count
7.6 Critical Regions
region x when (B) S;
Implementation of
the conditional-region construct
wait(mutex);
while ( !B ) {
first_count++;
if (second_count > 0)
signal(second_delay)
else signal(mutex);
wait(first_delay);
first_count--;
second_count++;
if (first_count > 0)
signal(first_delay)
else signal(second_delay);
wait(second_delay);
second-count --;
}
S;
if (first_count) > 0
signal(first_delay);
else if (second_count )> 0
signal(second_delay);
else signal(mutex);
7.7 Monitors

Monitor
 Characterized by a set of programmer-defined operators

The syntax of a monitor
 Monitor Structure
monitor monitor-name
{
shared variable declarations
procedure body P1( … ) {
…
}
prodedure body P2( … {
…
}
.
.
.
.
procedure body P1( … ) {
…
}
{
initialization code
}
7.7 Monitors

Monitor type
 cannot be used directly by the various processes.

Monitor construct
 Only one process at a time can be active within the monitor
 Programmer

Don’t need to code the synchronization
공유 데이터
진입 큐
연산들
초기화
코드
조건변수를 갖는 모니터
7.7 Monitors

Variable and operation

condition x,y ;
 Operation

x.wait();
– suspend

x.signal();
– resume
 Example



Two processes P and Q
When the x.signal operation is invoked by a process P, there is
a suspended process Q associated with condition x.
If the suspended process Q is allowed to resume its execution,
the signaling process P must wait.
P : active
(x.signal)
Q
suspended
Q
Resume
P
Wait
7.7 Monitors

Process-resumption
 FCFS ordering


The longest is resumed first
Too simple
 Conditional-wait



x.wait( c );
c : priority number
The smallest associated priority number is resumed next
 Example

Controls the allocation of a single resource among competing
processes.
7.7 Monitors

A monitor to allocate a single resource
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((i + 4) % 5);
test((i + 1) % 5);
}
void test (int i) {
if ( state[ (i+4) % 5 ] != eating) &&
( state[ i ] == hungry) &&
( state[ (i+1) % 5 ] != eating))
state [i] = eating;
self[i].signal();
}
}
void init() {
for (int i = 0; i < 5; i++)
state[i] = thinking;
}
}
7.7 Monitors

Sequence
R.acquire(t);
…
access the resource;
...
R.release;
(R is an instance of type resource-allocation)
 The monitor concept cannot guarantee that the preceding
access sequences will be observed




Access the resouce without gaining access permission to that
resource
Never release the resource once it has been granted access to
that resource
Attempt to release a resource that it never requested
Request the same resource twice
( without first releasing that resource)