5장. 프로세스동기화(P S h i ti )(Process Sychronization)

목표

임계구역(Critical Region) 문제소개 이문제에대한해결책은공유데이터의일관성유지에사용가능 이문제에대한해결책은공유데이터의일관성유지에사용가능

임계구역문제의하드웨어및소프트웨어해결책제시 전통적인프로세스동기화문제소개 프로세스동기화문제해결에사용되는도구조사

2

5.1 배경

협력프로세스(Cooperating process) 다른프로세스의실행을영향을주거나받는프로세스 다른프로세스의실행을영향을주거나받는프로세스 서로비동기적으로수행하면서데이터를공유할수있음 공유방법: (1) 직접공유 - 논리주소공간(메모리) 공유

간접공유 파일 는메시지를경유(2) 간접공유 – 파일또는메시지를경유

공유데이터에대한병행/병렬접근은데이터일관성을보장하지못할수있음(data inconsistency)할수있음( y)

병행/병렬실행환경 CPU 스케줄링 : 한프로세스가일부만실행한상태에서다른프로세스로스케줄될수있음로스케줄될수있음

인터럽트 : 프로그램의어떠한지점에서도인터럽트가가능 병렬실행 : 여러개의프로세스가동시에실행됨

데이터일관성유지 협력프로세스들이바른순서로실행(orderly execution)하는것을보장하는메커니즘이필요하는메커니즘이필요

3

생산자-소비자문제 – 공유데이터사용

유한버퍼를사용한생산자-소비자문제

while (TRUE) {while (count == BUFFER SIZE)

while (TRUE) {while (count == 0)

Producer Consumer

while (count BUFFER_SIZE) ; // do nothing during full

// add an item to the buffer1

while (count 0) ; // do nothing during empty

// remove an item from the buffer1count = count + 1;

buffer[in] = item;in = (in + 1) % BUFFER_SIZE;

count = count – 1;item = buffer[out];out = (out + 1) % BUFFER_SIZE;( ) _

}( ) _

}

i shared variable : count

in

buffer

in

buffer

4

out out

경쟁조건(race condition)

경쟁조건 여러개의프로세스가공유자료를접근하여조작하고 여러개의프로세스가공유자료를접근하여조작하고 그실행결과가자료접근순서에영향을받는상황

non-deterministic 결과 예

Process A Process B

r1 = count

count = count + 1

r2 = count

count = count – 1

r1 = countr1 = r1 + 1count = r1

r2 = countr2 = r2 – 1count = r2

machinelanguage

machinelanguage

5

경쟁조건에서의가능한결과

3가지결과가가능함

sequential order (count=5)

r1 = count (r1=5)

interleaved order (count=4)

r1 = count (r1=5)

interleaved order (count=6)

r1 = count (r1=5)r1 = countr1 = r1+1count = r1> r2 = count

(r1=5)(r1=6)(count=6)(r2=6)

r1 = countr1 = r1+1> r2 = count> r2 = r2–1

(r1=5)(r1=6)(r2=5)(r2=4)

r1 = countr1 = r1+1> r2 = count> r2 = r2–1

(r1=5)(r1=6)(r2=5)(r2=4)> r2 count

> r2 = r2–1> count = r2

(r2 6)(r2=5)(count=5)

r2 r2 1count = r1> count = r2

(r2 4)(count=6)(count=4)

> r2 r2 1> count = r2count = r1

(r2 4)(count=4)(count=6)

correct incorrect incorrect

6

병행접근(Concurrent Access)

단일프로세서시스템에서

shared data

선점(preemptive) 스케줄링을사용할때에, 경쟁조건이발생할수있음

7

병렬(Parallel) 접근

다중프로세서시스템에서

shared datashared data

스케줄링알고리즘에관계없이, 경쟁조건이발생할수있음

8

5.2 임계구역(Critical-Section) 문제

임계구역(Critical section: CS) 프로세스(쓰레드)가공유자원을변경할수있는코드부분 프로세스(쓰레드)가공유자원을변경할수있는코드부분

공유자원 – 공유변수, 테이블, 파일등

P2

shared

critical section

P1 P2

sharedresource

critical section

section

임계구역문제 프로세스들이임계구역에서경쟁조건이발생하지않도록 프로세스들이임계구역에서경쟁조건이발생하지않도록서로협력하기위해사용할수있는프로토콜(대화규약)을설계하는것프로세스동기화(synchronization)와조정(coordination)

9

임계구역문제의해결책

프로세스의일반구조while (true) {while (true) {

... remainder sectionentry section // request permission to enter CS

critical section… critical sectionexit section… remainder section

}; 3가지필요조건

1. 상호배제(Mutual Exclusion)1. 상호배제(Mutual Exclusion)2. 진행(Progress)3. 한정대기(Bounded Waiting)가정 가정 프로세스들의상대속도를가정하지않음. 프로세스들은 0이아닌속도로실행됨세 들 이아 속 실행됨

10

상호배제(Mutual Exclusion)

프로세스가자신의 CS에서실행중이라면다른프로세스들은자신의 CS에서실행될수없음다른프로세스들은자신의 CS에서실행될수없음

enter exit

P1 CS

enter exit

iP2 CS

enter exitreq

wait

동시에두개이상의프로세스가임계구역(CS)에서실행될수없음

11

진행(Progress)

CS에서실행되는프로세스가없고, 자신의 CS로진입하려는프로세스가있다면세스가있다면 나머지구역(remainder section)에서실행하지않는프로세스들만이

CS에진입하는프로세스결정에참여하고이선택이무한히(indefinitely) 지연될수없음 progress 이선택이무한히(indefinitely) 지연될수없음 progress

selection

P1

P2

CSreq

waitCSP2

req

P3req

waitCS

CS 밖에서수행중인프로세스는다른프로세스를 block할수없음

q

12

한정대기(Bounded Waiting)

프로세스가 CS 진입을요청한후에요청이허용될때까지다른프로세스가 CS 진입이허용되는횟수에제한이있어야함다른프로세스가 CS 진입이허용되는횟수에제한이있어야함

bounded waitT1

T2

req

bounded wait

CS

CS

T2 CS

T3 CS

T4 CST4 CS

Tn CS

어떤프로세스도 CS 진입을영원히기다리지않아야함

13

커널에서의경쟁조건과선점/비선점커널

커널에서의경쟁조건 커널에서여러개의커널모드프로세스(루틴)이활성화될수있으며 커널에서여러개의커널모드프로세스(루틴)이활성화될수있으며커널자료구조를공유할수있음경쟁조건발생가능

커널은경쟁조건이발생하지않도록설계해야함 커널은경쟁조건이발생하지않도록설계해야함. 임계구역을다루기위한운영체제커널의두가지방식

선점형(preemptive) 커널 – 커널모드에서프로세스가선점되는것을선점형(preemptive) 커널 커널 에서 세 가선점되는것을허용

경쟁조건이발생하지않도록설계해야함SMP 시스템에서는특히어려움 SMP 시스템에서는특히어려움

비선점형(nonpreemptive) 커널 – 커널모드에서프로세스가선점되는것을허용하지않음

경쟁조건이발생하지않도록다음상황까지프로세스를계속실행 경쟁조건이발생하지않도록다음상황까지프로세스를계속실행(1) 커널모드종료 (2) 봉쇄(block) (3) 자발적양보(yield)

14

5.3 Peterson의해결안

Peterson 알고리즘임계구역문제에대한고전적인소프트웨어기반해결방안 임계구역문제에대한고전적인소프트웨어기반해결방안 두프로세스에대해서만적용가능 (P0 , P1)

동기화변수 프로세스들의동작을동기화하는데사용하는공유변수

Peterson 알고리즘에서의동기화변수int turn; (initially turn=0)int turn; (initially turn=0)boolean flag[2]; (initially, flag[0]=flag[1]=false)

if (turn==i) then Pi can enter its critical section (Pi 차례) if (flag[i] == true) then Pi ready to enter its critical section (Pi 준비)

if flag[0] is true and flag[1] is false P0’s turn (하나만 CS 진입요청)if both flag[0] and flag[1] are true Pturn’s turn (둘다 CS 진입요청)

15

Peterson 알고리즘

Process Pi 의구조 (다른프로세스: Pj , j = 1 – i )do {do {

flag[i]:= true; turn = j;while (flag[j] and turn == j)

entry CSif (flag[j]==false or turn==i)while (flag[j] and turn == j)

;… critical section

if (flag[j]==false or turn==i)then enter CS

flag [i] = false;… remainder section

} while (1);

exit CS

} while (1); 세필요조건을충족

상호배제 – 둘다진입불가 (turn에의해서하나만진입가능)진행 상대장의 가 이면바로 진입 두 두 이면 진행 – 상대장의 flag가 false이면바로 CS진입, 두 flag 모두 true이면turn이 0 또는 1의값을가지므로둘중하나는 CS로진입

한정대기 – 상대방의수행이끝나면 flag가 false가되므로 CS진입. 상대방 flag가다시 true가되어도, turn을넘겨주므로 CS 진입

16

임계구역을구현하는소프트웨어알고리즘

2 프로세스알고리즘 Peterson 알고리즘 Peterson 알고리즘 Dekker 알고리즘 (Exercise 5.10/6.2)

n-프로세스알고리즘훨씬복잡 Eisenberg and McGuire 알고리즘 (Exercise 5.11/6.3)

Dekker 알고리즘의확장 Bakery 알고리즘 – Lamport Bakery 알고리즘 Lamport

알고리즘방식은실제로널리사용되지않음매우 잡함 매우복잡함

정확성(올바르게동작함)에대한증명이복잡함

17

5.4 동기화하드웨어(Synchronization Hardware)

lock을사용하는임계구역문제해결책while (true) {while (true) {

acquire lock... critical sectionrelease lock... remainder section

}} 임계구역을 lock으로보호하여, 경쟁조건을방지함

Lock의구현소프트웨어알고리즘 복잡하고비효율적 소프트웨어알고리즘 – 복잡하고비효율적

하드웨어지원 인터럽트금지(disable)( ) Atomic 명령어

18

인터럽트금지(Interrupt Disable)

인터럽트금지(disable) 임계구역실행동안인터럽트를방지하여선점을허용하지않음 임계구역실행동안인터럽트를방지하여선점을허용하지않음

현재수행중인코드가선점되지않고계속수행됨

단일프로세서시스템에서는임계구역문제해결가능

cli ; interrupt disable... critical section

sti ; interrupt enable

(80x86)

멀티프로세서시스템에서는적용불가능 한 CPU의인터럽트를금지시켜도, 다른 CPU는여전히임계구역에진입할수있음

p

입할수있음. 모든 CPU의임계구역진입을방지하기위해서, 모든 CPU의인터럽트를금지시키는것은시간이소요되므로비효율적임.

시스템클록(시계)에대한영향 시스템클록이인터럽트에의해서갱신되는시스템에서, 인터럽트금지는시간에영향을줄수있음는시간에영향을줄수있음

19

원자적명령어(Atomic Instruction)

Atomic 명령어 = Indivisible Instruction 연속되는여러개동작(read-modify-write 동작)을원자적으로 연속되는여러개동작(read-modify-write 동작)을원자적으로

(인터럽트되지않고/분리되지않고) 수행하는기계어명령어

At i 명령어의예 Atomic 명령어의예 Test and Set (TAS) instruction:

word 내용을검사(test)하고변경(set)하는동작을원자적으로수행( ) ( )(ex) 80386: bit test and set

BTS [100], 2 ; CF M[100]2, M[100]2 168000: test and set

test set

t t t68000: test and setTAS $5000 ; N M[5000]7, M[5000]7 1

Swap instruction:

test set

두 word의내용의교환(swap)을원자적으로수행(ex) 80386: exchange

XCHG AX [BX] ; AX M[BX]XCHG AX, [BX] ; AX M[BX]

20

Lock 변수사용하기 – Atomic 명령어사용

Lock 변수의사용 두상태: 0 (unlock open 사용중이아님) 1 (lock close 사용중) 두상태: 0 (unlock, open, 사용중이아님), 1 (lock, close, 사용중) atomic 명령어를사용하여 lock 변수를조작함

TAS 또는 SWAP 명령어를사용한 lock 변수의조작

Test and Set (TAS) instruction SWAP instruction

TAS lock mov r1, 1 // set값설정

CPU memoryCPU

,swap r1, lock

testFlag

F 11 Fr1

locklock set1 F 1 lock

21

Test-and-Set을사용한상호배제

공유데이터 lock = 0; // global shared data – unlock lock 0; // global shared data unlock

Process Piwhile ( TestAndSet(&lock) )

; critical section

entry section busy waitingwait loop

… critical sectionlock = 0;… remainder section

exit section TestAndSet() 연산은TAS 또는 Swap 명령어로구현가능함

필요조건충족여부 이알고리즘은상호배제및진행조건을만족시킴

구현가능함

이알 리즘은상 배제및진행 건을만족시킴 한정대기조건은만족시키지못함

22

Test&Set를사용한한정대기를만족하는상호배제

공유자료구조 boolean waiting[n]; // initialized to false(0) boolean waiting[n]; // initialized to false(0) boolean lock; // initialized to false(0)

Process Piwaiting[i] = TRUE; key = TRUE; while (waiting[i] && key)

key = TestAndSet(&lock); unlock상태이면 key=0이됨

entry section

key TestAndSet(&lock); waiting[i] = FALSE; ... critical section

j (i 1) % li d i

태이 y 이

it ti j = (i + 1) % n; while ( (j != i) && ! waiting[j] )

j = (j + 1) % n;

cyclic ordering :• Pi 다음프로세스부터대기여부검사(waiting[j]=true)

• 임계구역진입을기다리는

exit section

j (j )if (j == i) lock = FALSE; else waiting[j] = FALSE;

remainder section

• 임계구역진입을기다리는프로세스는최대 n-1회내에진입가능

... remainder section

23

6.5 뮤텍스락(Mutex Locks)

임계구역문제에대한하드웨어기반해결안 응용프로그래머에게는복잡하며일반적으로직접사용할수없음 응용프로그래머에게는복잡하며일반적으로직접사용할수없음 해결방법 – 운영체제에서응용프로그래머에게이를위한소프트웨어도구를제공 Mutex Lock

M t L k (상호배제락) Mutex Lock (상호배제락) Mutual Exclusion의줄임말 두함수제공

acquire(&lock)

acquire() – lock 획득 release() – lock 반환

release(&lock)

스핀락(Spinlock) : busy-waiting mutex lock 루프를반복실행하면서 lock 획득을기다림 CPU cycle이낭비됨단일프로세서시스템에서특히문제임 멀티프로세서시스템에서짧은시간내에 lock 획득이예상되면

spinlock이유용함 - context switching이없음spinlock이유용함 - context switching이없음

24

Busy-waiting이없는 Mutex Lock

Busy-waiting이없는 Test and Set을사용한상호배제 lock을획득하지못하면프로세스는 lock을기다리는대기상태로전환 lock을획득하지못하면프로세스는 lock을기다리는대기상태로전환하고 CPU를내어놓음

알고리즘 lock = 0; Process Pi

while ( TestAndSet(&lock) )entry section nobusy waiting( ( ) )block();

… critical sectionlock = 0;

y= acquire( )

exit section

nobusy waiting

lock = 0;… non-critical section

}

= release( )다른프로세스가 release()를호출하여unlock이될때에 wakeup()이호출되어wait 상태에있는 block된프로세스를깨움

25

5.6 세마포(Semaphores)

세마포(Semaphore) Mutex Lock보다더정교하고강력한프로세스동기화도구

사전뜻: 수기신호

Mutex Lock보다더정교하고강력한프로세스동기화도구 세마포 S

특별한표준동기화연산을통해서만접근할수있는정수변수.세마 값은대개사용가능한특정자원의수를나타냄 세마포값은대개사용가능한특정자원의수를나타냄

Semaphore 연산 초기화연산 – semaphore S 값초기화 초기화연산 semaphore S 값초기화 두개의원자적(atomic) 연산 (by Dijkstra)

P operation (Proberen = test) wait(S), acquire(S) V ti (V h i t) i l(S) l (S)

다른표기

V operation (Verhogen = increment) signal(S), release(S)

hil (S 0)P(S)

S S 1V(S)

while (S 0) ; // busy-wait

// now S > 0S = S 1;

S = S + 1;

세마포 S값 (검사및) 변경은

26

S = S - 1; 세마포 S값 (검사및) 변경은원자적으로실행되어야함

Semaphore 용도

용도 상호배제(Mutual exclusion) 이진세마포(binary semaphore)( ) ( y p ) 유한개수의자원접근, 한정된 concurrency counting semaphore 프로세스동기화: signaling

Binary semaphore 상호배제구현 (mutex lock과유사) Binary semaphore 상호배제구현 (mutex lock과유사) semaphore 값: 0 or 1 (1로초기화) 임계구역접근제어에사용

S=1 : unlockS=0 : lock

Semaphore S = 1; // initialize

…P(S);

Process 1…P(S);

Process 2

wait(S) acquire(S)P(S);… critical sectionV(S);…

P(S);… critical sectionV(S);…

wait(S)

signal(S)

acquire(S)

release(S)

27

카운팅세마포(Counting Semaphore)

Counting semaphore 한정된 concurrency, 유한개수자원접근 semaphore 값: 가용자원개수를의미(최대가용자원개수로초기화) semaphore 값: 가용자원개수를의미(최대가용자원개수로초기화) 유한개수의자원의접근제어에사용

S h S // i iti li 최대 n 프로세스가병행하여Semaphore S = n; // initialize

Process 1 Process 2 Process N

최대 n 프로세스가병행하여수행될수있음

…P(S);… critical section

…P(S);… critical section

…P(S);… critical section

acquire(S)… critical sectionV(S);…

… critical sectionV(S);…

… critical sectionV(S);…

release(S)

28

일반적인동기화

동기화(synchronization) (예) 프로세스 P1의 A 부분실행후에프로세스 P2의 B 부분이실행되 (예) 프로세스 P1의 A 부분실행후에프로세스 P2의 B 부분이실행되

어야함 Code:

Semaphore를

Process P1 Process P2

Semaphore S = 0; // intializeSemaphore를0으로초기화

1 2

... ...A P(S) wait until P1 executes V(S)V(S) BS=0

S=0S=0

wait(S)

i l(S) V(S) B...S=1

signal(S)

29

Semaphore 구현

바쁜대기(Busy waiting) Semaphore spinlock과유사하게구현 spinlock과유사하게구현

바쁜대기없는(No Busy waiting) Semaphore 프로세스의 block-wakeup 방법이용

semaphore를획득할수없을때 semaphore 대기큐에 자기프로세스 semaphore를획득할수없을때 semaphore 대기큐에 자기프로세스를추가하고자신을 block 시킴

semaphore를사용가능하게되면, semaphore 대기큐에서한프로세스를꺼내어 ready queue로이동하여 대기중인하나의프로세스를스를꺼내어 ready queue로이동하여, 대기중인하나의프로세스를wakeup시킴

코드다음 slide 코드다음 slide

30

No busy-waiting 세마포구현

Sempahore S – 다음두 item으로자료구조가구성됨 value – 세마포값 value – 세마포값 list – 이세마포를 대기하는프로세스리스트 (세마포대기큐)

Semaphore 연산P(S){

S.value - -;

V(S) {

S.value++;S.value ;if (S.value < 0) {

add this process to S.listblock()

if (S.value <= 0) {remove a process Q from S.listwakeup(Q);()

}}

}}

세마포값을먼저감소음수가능- 세마포값을먼저감소음수가능- 음수의 크기는세마포를대기하는프로세스들의개수임(세마포검사와감소의순서가 busy-waiting 방법과반대)두프로세스가같은세마포에대해 P 또는 S 연산이중첩되어실행되지

31

- 두프로세스가같은세마포에대해 P 또는 S 연산이중첩되어실행되지않도록해야함. (atomic 실행)

교착상태(Deadlock)와기아(Starvation)

Semaphore를사용한코드는교착상태와기아가발생할수있음 교착상태(Deadlock) 교착상태(Deadlock)

두개이상의프로세스들이그들중한프로세스에의해서만발생될수있는사건을무한정기다리고있어서, 진행이되지않는상황두 로초기화됨(ex) 두 binary semaphore S, Q: S=1, Q=1로초기화됨

P0 P1P(S); P(Q); Sget둘째 P 연산들이 P(Q); P(S);

… … V(S); V(Q);

S

P0 P1

waitget둘째 P 연산들이교착상태가됨

V(Q) V(S);

기아(Starvation) 무한봉쇄(indefinite blocking)Qwait get

기아(Starvation) – 무한봉쇄(indefinite blocking) 일부프로세스가무한정대기할수있는상황 (예) 세마포대기리스트가 LIFO 순서로되어있으면리스트앞쪽에있는프로세스는제거되지못할수있음 세마포가빈번히사용되는경우는프로세스는제거되지못할수있음(세마포가빈번히사용되는경우)

32

5.7 고전적인동기화문제

유한버퍼문제(Bounded-Buffer Problem)두프로세스가

Readers와 Writers 문제

bounded bufferProducer Consumer두프로세스가하나의자료공유

shared

readwrite read

sim ltaneo se cl si e rite

exclusive read/write 여러프로세스가하나의자료공유일부는읽기만수행shared

data

readreadwrite

simultaneousread

exclusive write - 일부는읽기만수행- 일부는갱신수행

식사하는철학자문제(Dining-Philosophers Problem)

P P P여러프로세스가

R R RP P P

several processes several shared resources

여러자료공유

33

Bounded-Buffer Problem – 세마포사용

int n; Semaphore full = 0;

// n: buffer size// empty full: counting semaphoreSemaphore full = 0;

Semaphore empty = n;Semaphore mutex = 1;

// empty, full: counting semaphorefor synchronization

// mutex: semaphore for buffer accessesC Producer

do {…. produce an item

Consumer

do {pP(empty);P(mutex);++count;

P(full);P(mutex);--count;++count;

buffer[in]=item;in=(in+1)%BUFSIZE;

( )

count;item = buffer[out];out=(out+1)%BUFSIZE;V( t )V(mutex);

V(full);}

V(mutex);V(empty);… consume the item

}

34

Readers-Writers Problem – 세마포사용

Semaphore mutex = 1 Semaphore rw mutex=1;

ReaderP(mutex); acquireReadLockSemaphore rw_mutex 1;

int read_count = 0// mutex: for updating read_count// rw mutex: for updating shared

P(mutex);read_count++;if (read_count==1) // first reader

P( t )// rw_mutex: for updating shared database (common to reader/writer)

P(rw_mutex);V(mutex);…

Writer P(rw_mutex);…

reading is performed…P(mutex); releaseReadLock

acquireWriteLock

writing is performed…

V(rw mutex);

( );read_count --;if (read_count==0) // last reader

V(rw mutex);releaseWriteLockV(rw_mutex); V(rw_mutex);V(mutex);

releaseWriteLock

일부시스템에서는 d it l k( l k)과 이를위한연산을제공한다

35

일부시스템에서는 read-writer lock(rwlock)과 이를위한연산을제공한다.rwlock을획득하고반환할때에용도(reader용, writer용)를지정해야한다.

Dining-Philosophers Problem philosopher

chopsticks

5명의철학자가 thinking과 eating을g g반복하며시간을보냄

양쪽젓가락을집는다

양쪽젓가락을내려놓는다 집는다내려놓는다.

식사하는철학자문제여러프로세스들에게여러자원을할당할필요가있는 여러프로세스들에게여러자원을할당할필요가있는병행제어(concurrency control) 문제를단순하게나타낸예임.

철학자프로세스(process), 젓가락자원(resource)

36

Dining-Philosophers Problem – 세마포사용

Semaphore chopStick[5] = {1,1,1,1,1} ; // initially all values are 1

Philosopher iwhile (true) {

P(chopStick[i]); // get left chopstickP(chopStick[(i+1) % 5]); // get right chopstick

eat… eatV(chopStick[i]); // return left chopstickV(chopStick[(i+1) % 5]); // return right chopstick

hi k… think};

이코드는교착상태의가능성이있음(not deadlock-free)이 는 착상태의가능성이있음( ) 모든철학자가왼쪽젓가락을집으면 ? 오른쪽젓가락을무한히대기 해결책: (1) 젓가락두개를모두집을수있을때에집게함

(2) 홀수철학자는왼쪽먼저 짝수철학자는오른쪽먼저집는다(2) 홀수철학자는왼쪽먼저, 짝수철학자는오른쪽먼저집는다. (3) 최대 4명의철학자가앉는다.

37

5.8 모니터(Monitors)

Semaphore 사용의문제점 프로그래머가잘못사용하면다양한유형의오류발생가능 프로그래머가잘못사용하면다양한유형의오류발생가능

잘못된 Semaphore 사용예 P와 V 연산의순서를반대로사용

V(mutex)critical sectionP(mutex)

상호배제위반

P(mutex) V대신에 P를사용

P(mutex)iti l ticritical section

P(mutex) P 또는 V를누락

deadlock

P(mutex) critical sectioncritical section V(mutex)

이러한실수가아니어도동작의정확성을증명하기어렵고

deadlock 상호배제위반

이러한실수가아니어도동작의정확성을증명하기어렵고식사하는철학자문제와같이교착상태를유발할수있다.

38

모니터(Monitor) 병행프로그래밍(Concurrent Programming)을위한지원

병행프로그래밍이순차프로그래밍보다어려움 세마포와같은기능을직접사용하지않고병행프로그래밍을위해고수준의상호배제를지원하는기능이개발됨

잘못사용할위험성을줄임잘못사용할위험성을줄임

모니터(Monitor)세 기화 위한편리하 효율적이 안전한방법을제 하 프로세스동기화를위한편리하고, 효율적이고, 안전한방법을제공하

는고수준의동기화추상화데이터형(ADT) – data와 procedure를포함 monitor에서정의된 procedure만에 monitor 내의 local data를접근가능 monitor의 procedure들은한번에하나의프로세스만진입하여실행할수있음상호배제보장

39

Monitor 구문 Monitor 구문

monitor monitor_name{ shared data

entry queue

{// shared variable declarationsprocedure p1(…) {

…

p1 p2

}procedure p2(…) {

…}

initializationd

operations

}…

initialization code (...) {…

code

…}

}

monitor를지원하는프로그래밍언어 monitor를지원하는프로그래밍언어 Concurrent Pascal, Ada, Mesa, Concurrent Euclid, Modula-3, D, C# Java, Python …

40

조건변수(Condition Variables)

Condition: 모니터에서동기화에사용되는특별한자료형condition x y;condition x, y;

Condition 변수를사용하는연산 - wait, signalwait(), signal()

wait(x) 를호출한연산은프로세스는다른프로세스가 signal(x)을호출할때까지일시중지(suspend)됨

signal(x) 연산은정확히하나의프로세스만재개시킴.g ( )일시중지된프로세스가없으면, 아무런영향이없음

condition x wait wait wait signal

(cf) 세마포의 V 연산은세마포값에영향을줌

wait wait wait signal

모니터내에서의동기화 조건변수에대한두연산(wait, signal)을사용하여수행함 건변수에대한두연산(wait, signal)을사용하여수행함

41

condition 변수를갖는모니터

42

Dining Philosophers 문제 – monitor 사용

monitor diningPhilosophers { // pseudo-codeint state[5]; // THINKING(0) HUNGRY(1) EATING(2)int state[5]; // THINKING(0), HUNGRY(1), EATING(2)condition self[5]; // condition variablesdiningPhilosophers { // initialization code

f (i t i 0 i 5 i )for (int i = 0; i < 5; i++) state[i] = THINKING;

}}procedure pickUp(int i) { /* see next slides */ }procedure putDown(int i) { /* see next slides */ }private test(int i) { /* see next slides */ }private test(int i) { / see next slides / }

} 양쪽젓가락모두사용가능할때에만양쪽젓가락을집고, 그렇지않으면

i 상태가됨wait 상태가됨 젓가락을내려놓을때에옆의철학자의상태를확인하여철학자가

HUNGRY상태에있고, 양쪽젓가락사용이가능하면 signal을보내상태를해제함wait 상태를해제함

43

Dining Philosophers 문제 – monitor 사용 (계속)

procedure pickUp(int i) { private test(int i) {state[i] = HUNGRY;test(i);if (state[i] != EATING)

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

wait(self[i]);}procedure putDown(int i) {

( [( ) ] ) ) {state[i] = EATING;signal(self[i]);

}signal

procedure putDown(int i) {state[i] = THINKING;// test left and right neighbors

}} test left/right

putDown

test((i + 4) % 5);test((i + 1) % 5);

}T H

pickUpE

test OK

t t f il} 이해결안은 deadlock-free이지만

starvation-free는아님H: wait

test failsignal

44

Dining Philosophers 문제 – monitor 사용 (계속)

// initially, it d di i Phil h ()monitor dp = new diningPhilosophers();

philosopher i philosopher i

while (true) {dp.pickUp(i);eat();dp.putDown(i);p p ( );think();

}

45

Java Monitors - Java Synchronization

Synchronized method wait() notify() statements wait(), notify() statements Multiple Notifications: notifyAll()

46

synchronized Statement

Synchronized method Java의모든 object는자신과연관된 lock을가짐 Java의모든 object는자신과연관된 lock을가짐 synchronized method 호출은 lock의소유를필요로함 object에대한 lock을소유하지않은 thread가 object의 synchronized

th d를호출하면 bj t l k에대한 t t에놓임method를호출하면 object lock에대한 entry set에놓임 synchronized method를사용하는 thread가 method 사용을종료하면

lock을해제함

공유데이터에대한병행접근을직렬화(serialize)하여경쟁조건발생을방지함

47

wait()와 notify() Method*

wait() method object lock을해제하고 thread를 Block상태로설정하고 wait set에놓임 object lock을해제하고 thread를 Block상태로설정하고 wait set에놓임

notify() method wait set에서임의의 thread T를선택하여 entry set으로이동하고

를 상태로설정thread를 Runnable상태로설정 thread T 는다시 object lock을얻으려고경쟁할수있음

Java의 wait(), notify()는모니터의 wait(), signal()과유사하지만Java의 wait(), notify()는 니터의 wait(), signal()과유사하지만condition variable은사용하지않음 (object 당 1개의조건변수를사용하는것과같음)

48

wait/notify methods를사용한 insert()와 remove()*public synchronized void insert(Object item) {

while (count == BUFFER_SIZE) // fulltry { wait(); } catch (InterruptedException e) { }try { wait(); } catch (InterruptedException e) { }

++count;buffer[in] = item;in = (in + 1) % BUFFER SIZE;in = (in + 1) % BUFFER_SIZE;notify(); // notify threads waiting for non-empty buffer

}bli h i d Obj t () {public synchronized Object remove() {Object item;while (count == 0) // empty wait() wait()

insert() remove()

try { wait(); } catch (InterruptedException e) { }

- - count;

wait()

notify()

()

notify()item = buffer[out];out = (out + 1) % BUFFER_SIZE;notify(); // notify threads waiting for non-full buffer

y() y

return item;}

49

5.9 동기화(Synchronization) 사례

Windows Synchronization Linux Synchronization Linux Synchronization Solaris Synchronization pthread libraryp y

50

Windows Synchronization

Window kernel의 global resources에대한접근보호 단일프로세서시스템 – 일시적으로 interrupt mask 단일프로세서시스템 – 일시적으로 interrupt mask 다중프로세서시스템 – spinlock 사용

spinlock을가지고있는동안선점되지않음

Kernel 외부의 thread 동기화 dispatcher objects 제공 - mutex, semaphores, events(조건변수)

critical-section object – user-mode mutex, kernel 개입없음 다중프로세서시스템에서, 처음에 spinlock 사용. 오랫동안기다리면 kernel mutex를할당하고 block됨오랫동안기다리면 kernel mutex를할당하고 block됨

경쟁이있을때만 kernel mutex가할당되어효율적51

Linux Synchronization

Linux kernel에서의동기화 atomic 정수연산제공 atomic 정수연산제공

mutex locks, semaphore, reader-writer locksi l k (다중프로세서시스템에서) spinlocks (다중프로세서시스템에서)

disable/enable kernel preemption짧은시간만유지될때사용

52

Solaris Synchronization

Solaris Synchronization 적응적(adaptive) mutex : spinlock 또는 sleeping lock 적응적(adaptive) mutex : spinlock 또는 sleeping lock

lock을다른 CPU에서실행중인 thread가소유 spinlock 사용 lock을소유한 thread가수행중이아니면 lock이방출될때까지

l ( l i l k)sleep (sleeping lock) 짧은코드세그먼트(수백개이하의명령어사용)에서 접근되는데이터를보호하기위해서사용

condition variables, semaphores 긴코드세그먼트용으로사용

reader-writer locksreader writer locks 빈번히사용되지만주로 read-only로접근되는데이터보호에사용

t til l k을대기하는상태에있는 th d들의큐 turnstile – lock을대기하는상태에있는 thread들의큐 객체가아닌커널 thread 마다한개의 turnstile을가지게함

53

Pthread Synchronizations

Pthreads 동기화 Pthreads API는사용자수준에서프로그래머에게제공 Pthreads API는사용자수준에서프로그래머에게제공. 운영체제에독립적 API

Pthread 동기화기능 mutex locks condition variables non-portable extensions – semaphore read-write lock spin locks non portable extensions semaphore, read write lock, spin locks

54

Pthread mutex

#include <pthread.h>int pthread mutex init(pthread mutex t *mutexint pthread_mutex_init(pthread_mutex_t mutex,

const pthread_mutexattr_t *mutexattr);int pthread_mutex_lock(pthread_mutex_t *mutex);int pthread mutex unlock(pthread mutex t *mutex);int pthread_mutex_unlock(pthread_mutex_t *mutex);int pthread_mutex_destroy(pthread_mutex_t *mutex);

pthread_mutex_t mutex (mutual exclusive lock) type

th d t i it pthread_mutex_init initialize mutex (mutual exclusive lock) mutexattr: attributes (usually NULL)

alternative intialization codepthread_mutex_init(&mutex, NULL);mutex = PTHREAD MUTEX INITIALIZER; /* same code */mutex = PTHREAD_MUTEX_INITIALIZER; /* same code */

55

Example: job-queue2.c

initialize mutex variable

56

lock()()

57unlock()

58

Pthread semaphore

#include <semaphore.h>int sem init(sem t *sem int pshared unsigned int value);int sem_init(sem_t sem, int pshared, unsigned int value);int sem_wait(sem_t *sem);int sem_post(sem_t *sem);i t d t ( t * )int sem_destroy(sem_t *sem);

sem t sem_t semaphore type

sem_init intialized a semaphore object

sem: pointer to the semaphore pshared: a sharing option (0: local)ps a ed a s a g opt o (0 oca ) value: initial value to the semaphore

sem_post: V operation (atomically increment) sem_wait: P operation (atomically decrement)

59

job-queue3.c

60

61

62

63

64

Pthread condition variables

#include <pthread.h>pthread cond t cond = PTHREAD COND INITIALIZER;pthread_cond_t cond PTHREAD_COND_INITIALIZER;int pthread_cond_init(pthread_cond_t *cond,

pthread_condattr_t *cond_attr);i t th d d i l( th d d t * d)int pthread_cond_signal(pthread_cond_t *cond);int pthread_cond_broadcast(pthread_cond_t *cond);int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex);p _ _ (p _ _ p _ _ )int pthread_cond_destroy(pthread_cond_t *cond);

th d d i it pthread_cond_init initialize a condition variable cond_attr: usually NULL_ y a condition variable must always be associated with a mutex

65

pthread_cond_t cv;pthread mutex t mutex;pthread_mutex_t mutex;...pthread_mutex_init (&mutex, NULL);

th d d i it(& NULL)pthread_cond_init(&cv, NULL);...pthread_mutex_lock(&mutex)p _ _ ( )pthread_cond_wait( &cv, &mutex);pthread_mutex_unlock(&mutex)...pthread_mutex_lock(&mutex)pthread_cond_signal(&cv);pthread_mutex_unlock(&mutex)

66