Presentation is loading. Please wait.

Presentation is loading. Please wait.

Chap. 7 Process Synchronization

Similar presentations


Presentation on theme: "Chap. 7 Process Synchronization"— Presentation transcript:

1 Chap. 7 Process Synchronization
OS 컴퓨터 운영체제 Operating Systems Copyright(c) 1999, Distributed Systems Lab., SungKyunKwan University, All rights reserved. No part of these slides may be reproduced, stored in a retrieval system or transmitted in any form or by any means, electronic, mechanical, photocopying, recording or otherwise, without the prior written permission of Distributed Systems Lab., SungKyunKwan University.

2 Introduction Process synchronization
Multiprogramming system에는 여러 process들이 존재 이들은 상호 독립적으로 움직임 Process들이 동시에 독립적으로 진행됨으로 인하여 발생하는 문제점들이 있음 이러한 문제점들을 해결하는 기법 Process synchronization 기법 대부분 이러한 문제는 resource에 대한 접근이나 shared data에 대한 접근 시에 발생

3 Asynchronous and Concurrent Processes
각 프로세스들이 다른 프로세스들의 진행 상태 등을 전혀 모름 Concurrent (병행적) 시스템 내에 다수의 프로세스들이 동시에 존재함 병행 수행중인 프로세스들이 동시에 공유 데이터에 접근할 때 문제 발생 가능 Note 병행성 (concurrency) - 여러 개의 process들이 processor를 번갈아 사용함 병렬성 (parallelism) - processor가 여러 개 존재, 여러 process들이 동시 실행 가능

4 Terminologies Terminologies Shared data, critical data
여러 프로세스들에 의해 공동으로 사용되는 데이터 Critical section 공유 데이터에 접근하는 프로그램 세그먼트 Mutual exclusion 둘 이상 프로세스의 임계 지역 동시 진입을 금지시킴 Note 기계어 명령(machine instruction)의 특성 - 원자성(atomicity), 분리불가능 (indivisible) (한 기계어 명령의 실행 도중에 인터럽트 받지 않음)

5 공유 데이터 접근 예 memory process-Pi process-Pj sdata  sdata + 1;
sdata memory

6 기계어 수준에서의 공유 데이터 접근 예 process-Pi process-Pj Load Ri, sdata
Add Ri, 1 Add Ri, 1 Store Ri, sdata Store Ri, sdata sdata 명령 수행 과정 (1) - ①  ②  ③       또는       ①  ②  ③ - 결과 sdata = 2 명령 수행 과정 (2) - ①  ②        ③ - 결과 sdata = 1

7 Mutual exclusion primitives
Mutual exclusion methods Mutual exclusion primitives enterCS() primitive 임계 지역 진입 전 검사 과정 다른 프로세스가 임계 지역 내에 존재하는지의 여부 검사 exitCS() primitive 임계 지역 벗어날 경우 처리 과정 임계 지역에서 벗어남을 시스템에 알림 Mutual exclusion primitives Pa Pb . . enterCS(CSk) enterCS(CSk) Critical Section CSk exitCS(CSk) exitCS(CSk) . .

8 Requirements Requirements for mutual exclusion primitives
If a process Pi is executing in its CS, then no other processes can be executing in their CS’s Progress Only those processes that are not executing in their remainder section can participate in the decision on which process will enter its CS next Decision should not be postponed indefinitely Bounded waiting Each process should be able to enter its CS after a finite number of trials

9 ME primitives version-1
Two Process Mutual Exclusion ME primitives version-1 P0 P1 repeat ...... turn repeat ...... while (turn = 1) do endwhile; while (turn = 0) do endwhile; Critical Section turn  1; turn  0; ...... until (false); ...... until (false); does not satisfy the progress requirement

10 ME primitives version-2
Two Process Mutual Exclusion ME primitives version-2 P0 P1 repeat ...... repeat ...... flag[0] flag[1] while (flag[1]) do endwhile; flag[0]  true; while (flag[0]) do endwhile; flag[1]  true; Critical Section flag[0]  false; flag[1]  false; ...... until (false); ...... until (false); does not satisfy mutual exclusion requirements

11 ME primitives version-3
Two Process Mutual Exclusion ME primitives version-3 P0 P1 repeat ...... repeat ...... flag[0] flag[1] flag[0]  true; while (flag[1]) do endwhile; flag[1]  true; while (flag[0]) do endwhile; Critical Section flag[0]  false; flag[1]  false; ...... until (false); ...... until (false); does not satisfy the progress requirement

12 Two Process Mutual Exclusion
Dekker’s algorithm Dekker’s algorithm P0 P1 repeat ...... repeat ...... flag[0]  true; while (flag[1]) do if (turn = 1) then begin flag[0]  false; while (trun = 1) do endwhile; end; flag[0] flag[1] flag[1]  true; while (flag[0]) do if (turn = 0) then begin flag[1]  false; while (trun = 0) do endwhile; end; turn Critical Section turn  1; flag[0]  false; turn  0; flag[1]  false; ...... until (false); ...... until (false);

13 Two Process Mutual Exclusion
Peterson’s algorithm Peterson’s algorithm P0 P1 repeat ...... repeat ...... flag[0] flag[1] flag[0]  true; turn  1; while (flag[1] and trun = 1) do endwhile; flag[1]  true; turn  0; while (flag[0] and trun = 0) do endwhile;  turn Critical Section flag[0]  false; flag[1]  false; ...... until (false); ...... until (false);

14 N-Process Mutual Exclusion
N-process mutual exclusion schemes Dijkstra’s algorithm 무기한 연기의 가능성이 있음 Knuth’s algorithm 무기한 연기의 가능성을 제거 지연 시간이 매우 큼 Eisenberg and McGuire’s algorithm 유한 시간 (n-1 번) 내의 시도 후 임계 지역 진입 보장 Lamport’s algorithm 분산 시스템 환경을 위한 상호 배제 기법 Bakery algorithm

15 Dijkstra’s algorithm의 flag[] 변수
N-Process Mutual Exclusion Dijkstra’s algorithm Dijkstra’s algorithm의 flag[] 변수 flag[] 값 의 미 idle 프로세스가 임계 지역 진입을 시도하고 있지 않을 때 want-in 프로세스의 임계 지역 진입 시도 1단계일 때 in-CS 프로세스의 임계 지역 진입 시도 2단계 및 임계 지역 내에 있을 때

16 ... ... ... Dijkstra’s algorithm ...... ...... 프로세스 Pi repeat repeat
/* 임계 지역 진입시도 1단계 */ flag[i]  want-in; while (turn  i) do if (flag[turn] = idle) then trun  i; endwhile; flag[i]  in-CS; j  0; while ((j < n) and (j = i or flag[j]  in-CS)) do j  j + 1; until (j  n); flag[1] flag[n] ... ... turn Critical Section flag[i]  idle; ... ...... until (false);

17 Synchronization Hardware
Hardware support for mutual exclusion ME를 위한 software solution들의 문제점 Low speed Primitive 실행 중 preemption 가능성 ME를 위한 hardware support 예 IBM의 TS(Test and Set) 명령 (machine instruction) Atomic, indivisible Note Machine instruction의 특성 - Atomic, indivisible (한 기계어 명령의 실행 도중에 인터럽트 받지 않음)

18 Synchronization Hardware
Definition of TS() instruction Atomic(indivisible) operation Boolean TS(boolean &target) { boolean rv = target; target = true; return rv; }

19 Synchronization Hardware
Mutual exclusion with TS() instruction TS 명령을 사용한 ME algorithm Pi Initially lock = false; repeat ...... while (TS(lock)) do endwhile; ... ... Critical Section lock  false; ... ... ...... until (false);

20 Summary 상기의 각종 mutual exclusion 기법들의 단점
busy waiting inefficiency busy waiting 방지하는 mutual exclusion 기법들 Semaphore 기법 sequencer/eventcount 기법 Critical section에 즉시 진입할 수 없는 process들을 대기(asleep/blocked/wait) 상태로 전이시킴

21 P() and V() are indivisible operations
Semaphore Spinlock 정의 : 세머퍼 integer variable P()연산과 V() 연산, 그리고 초기화 연산에 의해서만 접근 가능 P(S) { while (S  0) do endwhile; S  S – 1; } V(S) { S  S + 1; } P() and V() are indivisible operations

22 Semaphore Spinlock for mutual exclusion Spinlock을 이용한 ME ...... ......
Pj active repeat ...... repeat ...... 1 P(active); P(active); Critical Section V(active); V(active); ...... until (false); ...... until (false); active = 1 : 임계 지역을 실행중인 프로세스 없음 active = 0 : 임계 지역을 실행중인 프로세스 있음

23 Semaphore Spinlock Used in multiprocessor systems, not in uniprocessor systems Solaris 2, Windows 2000

24 Semaphore 1965년 Dijkstra 제안 Busy waiting 문제 해결 Binary semaphore
일종의 정수형 변수 P()연산과 V() 연산, 그리고 초기화 연산에 의해서만 접근 가능 임의의 세머퍼 S에는 하나의 대기 큐 Qs가 할당됨 Binary semaphore Semaphore 변수가 0과 1의 두 종류의 값만을 갖는 경우 ME 또는 process synchronization의 목적으로 사용 Counting semaphore Semaphore 변수가 0 이상의 모든 정수값을 가지는 경우 Producer-consumer 문제 등의 해결을 위해 사용

25 Semaphore Semaphore 변수에 접근 가능한 연산 initialization 연산
P() 연산, V() 연산 : 두 연산 모두 indivisible operation 정의 : P(S) 연산 정의 : V(S) 연산 if (S > 0) then S  S - 1; else wait on the queue Qs ; if ( waiting processes on Qs) then wakeup one of them; else S  S + 1;

26 Semaphore Semaphore 이용하여 해결 가능한 concurrent programming problems
Mutual exclusion problem Process synchronization problem Producer-consumer problem Reader-writer problem Dining philosopher problem Etc

27 Semaphore Mutual exclusion Semaphore를 이용한 ME ...... ...... ......
Pi Pj active repeat ...... repeat ...... 1 P(active); P(active); Critical Section V(active); V(active); ...... until (false); ...... until (false); active = 1 : 임계 지역을 실행중인 프로세스 없음 active = 0 : 임계 지역을 실행중인 프로세스 있음

28 Semaphore Process synchronization process-Pi process-Pj Li : Lj :

29 Semaphore Process synchronization sync process-Pi process-Pj
Lj 지점을 통과할 때까지 Li지점에서 대기함 Li : P(sync); Lj : V(sync) sync

30 Semaphore Producer-consumer problem Producer processes
메시지를 생성하는 process group Consumer processes 메시지를 전달 받는 process group Producer process Shared memory buf Consumer process 메시지 생성, 적재 메시지 인출, 소비 Single buffer의 경우 Semaphore 변수 consumed/produced 사용 Producer/consumer process가 번갈아가며 buffer에 메시지를 적재하고 소비하는 일을 반복함

31 Single buffer의 경우 producer-consumer 문제
Semaphore Single buffer의 경우 producer-consumer 문제 (shared variables) var consumed : semaphore  1, produced : semaphore  0, buffer : message; Producer Pi Consumer Cj repeat ... create a new message M; P(consumed); buffer  M; V(produced); until(false); repeat ... P(produced); m  buffer; V(consumed); consume the message m; until(false);

32 Multiple, circular buffer의 경우 producer-consumer 문제
Semaphore Producer-consumer problem Multiple buffer의 경우 Multiple, circular buffer의 경우 producer-consumer 문제 buffer[0] buffer[1] buffer[2] buffer[N-1] buffer[3] buffer[4] buffer[5] 생산자 프로세스 소비자

33 Multiple, circular buffer의 경우 producer-consumer code
Semaphore Multiple, circular buffer의 경우 producer-consumer code (shared variables) var nrfull : semaphore  0, nrempty : semaphore  N, mutexP : semaphore  1, mutexC : semaphore  1, buffer : array[0..N-1] of message, in, out : 0..N-1  0,0; Producer Ⓘ Consumer Ⓙ repeat ... create a new message M; P(mutexP); P(nrempty); buffer[in]  M; in  (in + 1) mod N; V(nrfull); V(mutexP); until(false); repeat ... P(mutexC); P(nrfull); m  buffer[out]; out  (out + 1) mod N; V(nrempty); V(mutexC); until(false);

34 Semaphore Reader-writer 문제 Reader process Writer process
임의의 data 에 대해 읽기 연산만 수행 Writer process 임의의 data에 대해 갱신 연산을 수행 Data integrity Reader process들간 data에 동시 접근 가능 Writer process들간 또는 reader-writer간 data에 동시 접근 불가능 해결법의 종류 Reader/writer process들에 대한 priority 부여 방법에 따라 weak reader preference solution strong reader preference solution writer preference solution

35 Weak reader preference solution
Semaphore (shared variables) var wmutex, rmutex : semaphore := 1, 1, nreaders : integer := 0 Reader Ri Writer Wj repeat ... P(wmutex); Perform write operations V(wmutex); until(false); repeat ... P(rmutex); if (nreaders = 0) then P(wmutex); endif; nreaders  nreaders + 1; V(rmutex); Perform read operations; nreaders  nreaders - 1; V(wmutex); until(false); Reader-Writer code Weak reader preference solution

36 Semaphore Semaphore 이용 기법의 특성 Busy waiting 문제 해결 진행 불가능한 경우 즉시 block 됨
Semaphore queue에서 대기중인 프로세스들의 wakeup 순서는 결정되지 않음 Starvation 문제점

37 Eventcount/Sequencer
은행의 서비스 순서가 기재된 티켓과 같은 형태로 process들간의 synchronization 및 mutual exclusion을 이루는 기법 정의 : Sequencer 일종의 정수형 변수 생성 즉시 0으로 초기화되며 그 값이 감소하지 않음 발생 사건들의 순서 유지 ticket() 연산으로만 이 변수에 접근 가능 정의 : ticket(S) S 는 sequencer 변수임 현재까지 ticket() 연산이 호출되었던 횟수를 반환하는 함수 indivisible operation

38 Eventcount/Sequencer
일종의 정수형 변수 생성 즉시 0으로 초기화되며 그 값이 감소하지 않음 특정 사건들의 발생 횟수를 기록, 추적하기 위하여 사용 read(), advance(), await() 연산으로만 이 변수에 접근 가능 정의 : read(E) E는 eventcount 변수임 현재 eventcount E가 가지고 있는 값을 반환함 정의 : advance(E) E 는 eventcount 변수임 E  E + 1; wakeup the process waiting for E’s value to reach to the current value just attained; 정의 : await(E, v) E는 eventcount 변수, v는 정수형 변수임 if ( E < v ) then place the executing process in the waiting queue associated with E and invoke CPU scheduler; endif

39 Eventcount/Sequencer
Mutual exclusion Eventcount/sequencer를 이용한 ME 기법 Pi repeat ...... v  ticket(S); await(E, v); ... ... Critical Section advance(E); ... ... ...... until (false);

40 Eventcount/Sequencer
Producer-consumer problem Producer-consumer code (shared variables) var Pticket, Cticket : sequencer, In, Out : eventcount, buffer : array[0..N-1] of message; Producer Pi Consumer Cj var t : integer; repeat ... Create a new message M; t  ticket(Pticket); await(In, t); await(Out, t - N + 1); buffer[t mod N]  M; advance(In); until(false) var u : integer; repeat ... u  ticket(Cticket); await(Out, u); await(In, u + 1); m  buffer[u mod N] ; advance(Out); Consume the message m; until(false)

41 Eventcount/Sequencer
Busy waiting 방지 가능 Block 된 순서대로 wakeup 됨 (FIFO 스케줄링) Starvation 문제점 해결

42 Conclusion multiprogramming system 내의 process 특성
Asynchronous Concurrent 공유 데이타의 관리 및 프로세스들간의 정보 전달 지원을 위해 상호 배제 기법이나 프로세스 동기화 기법이 필요함 상호 배제 및 동기화를 위한 소프트웨어적 해결법 Dekker 알고리즘 Peterson 알고리즘 상호 배제 및 동기화를 위한 하드웨어적 해결법 IMB에서 제안된 TS 명령 사용 소프트웨어적 해결법의 속도 문제 해결 Semaphore와 Eventcount/Sequencer busy waiting 문제 해결

43 Concurrent Programming Constructs
OS 컴퓨터 운영체제 Operating Systems Copyright(c) 1999, Distributed Systems Lab., SungKyunKwan University, All rights reserved. No part of these slides may be reproduced, stored in a retrieval system or transmitted in any form or by any means, electronic, mechanical, photocopying, recording or otherwise, without the prior written permission of Distributed Systems Lab., SungKyunKwan University.

44 Introduction Mutual exclusion & process synchronization 기법
Low level mechanisms Dekker algorithm, Peterson algorithm Dijkstra, Knuth, Eisenberg, MacGuire/Lamport algorithms Hardware support (TS instruction) Semaphore Eventcount/sequencer 프로그래머의 사용이 매우 불편, 오류 범하기 쉬움 High-level mechanisms Monitor Path expressions Serializers Critical regions, conditional critical regions 대부분 객체지향 개념(object-oriented concept) 사용자들이 사용하기 쉬움

45 Waiting signaler queue
Monitor Definition of monitor Shared data와 critical section code들의 집합 Monitor의 구조 Critical data & Critical sections Monitor entry queues Condition queues Waiting signaler queue

46 Monitor Monitor의 구조 및 기능 Entry queues Mutual exclusion 자동 보장
Monitor 내의 procedure 수만큼 존재 Mutual exclusion 자동 보장 Monitor 내에는 항상 하나 이하의 process만 진입 가능 Information hiding Shared data에 대한 접근 Monitor 내에 진입하여 자신이 호출한 procedure를 실행하는 방법 외에 다른 방법으로 접근 불가능 Condition queues Monitor 내에 진입 후 필요할 경우 process가 원하는 조건에 해당하는 condition queue에서 대기 Signaler queue Monitor에 항상 하나의 signaler queue가 존재 signal() 명령을 실행한 process가 임시 대기

47 Monitor Example Resource allocation resourceRiAllocator
entry queue for releaseRi() RiIsAvailable condition queue RiIsFree entry queue for requestRi() signaler queue requestRi() releaseRi()

48 resourceRiAllocator code
Monitor Example resourceRiAllocator code monitor resourceRiAllocator; var RiIsAvailable : boolean, RiIsFree : condition; procedure requestRi(); begin if (¬RiIsAvailable) then RiIsFree.wait(); RiIsAvailable  false; end; procedure releaseRi(): RiIsAvailable  true; RiIsFree.signal(); end.

49 Monitor Example Resource allocation scenario Monitor state 1
자원 Ri가 프로세스 Pj에게 할당되고, 프로세스 Pk가 Ri를 요구한 후, 다시 Pm이 자원 Ri를 요구한 경우 Monitor state 1 Pk Pm entry queue for releaseRi() RiIsAvailable condition queue RiIsFree entry queue for requestRi() signaler queue Pj Ri requestRi() releaseRi()

50 Monitor Example Resource allocation scenario Monitor state 2
프로세스 Pj가 자원 Ri를 반납하고자 하고 프로세스 Pk가 wakeup된다고 가정하는 경우 Monitor state 2 1 Pm entry queue for releaseRi() RilsAvailable condition queue RiIsFree entry queue for requestRi() Pk Pj signaler queue requestRi() releaseRi()

51 Monitor Example Resource allocation scenario Monitor state 3
프로세스 Pk가 자원 Ri를 할당받아 모니터를 벗어난 후 프로세스 Pj가 모니터에 다시 진입하여 나머지 실행을 마치게 되는 경우 Monitor state 3 Pm entry queue for releaseRi() RilsAvailable condition queue RilsFree entry queue for requestRi() Pj signaler queue Pk Ri requestRi() releaseRi()

52 Producer-consumer monitor
Monitor Example Producer-consumer relationship Multiple circular buffer Producer-consumer monitor entry queue for fillBuf() bufHasData buffer[N-1] buffer[0] buffer[1] entry queue for emptyBuf() bufHasSpace buffer[5] buffer[2] buffer[4] buffer[3] in out validBufs fillBuf() emptyBuf() signaler queue

53 Producer-consumer monitor code
monitor ringbuffer; var buffer : array[0..N-1] of message, validBufs : 0..N, in : 0..N-1, out : 0..N-1, vufHasData, bufHasSpace : condition; procedure fillBuf(data : message); begin if (validBufs = N) then bufHasSpace.wait(); buffer[in]  data; validBufs  validBufs + 1; in  (in + 1) mod N; bufHasData.signal(); end; procedure emptyBuf(var data : message): if (validBufs = 0) then bufHasData.wait(); data  buffer[out]; validBufs  validBufs - 1; out  (out + 1) mod N; bufHasSpace.signal(); validBufs  0; in  0; out  0; end.

54 Monitor Example Reader-writer 문제
Reader/writer process들간의 데이터 무결성 보장 기법 Writer process에 의한 데이터 접근 시에만 상호 배제 및 동기화 필요 Monitor 구성 Two variables 현재 읽기 작업을 진행하고 있는 reader process의 수 현재 writer process가 쓰기 작업 중인지 표시 2 condition queues reader/writer process가 대기해야 할 경우에 사용 4 procedures Reader(writer) process가 읽기(쓰기) 작업을 원할 경우에 호출, 읽기(쓰기) 작업을 마쳤을 때 호출

55 Reader-writer monitor code
monitor readers_and_writers; var numReaders : integer, writing : boolean, readingAllowed, writingAllowed : conditon; procedure beginReading; begin if (writing or queue(writingAllowed)) then readingAllowed.wait(); numReaders  numReaders + 1; if (queue(readingAllowed)) then readingAllowed.signal(); end; procedure finishReading: numReaders  numReaders - 1; if (numReaders = 0) then writingAllowed.signal(); procedure beginWriting; if (numReaders > 0 or writing) then writingAllowed.wait() writing  true; procedure finishWriting: writing  false; else writingAllowed.signal(); numReaders  0; writing  false; end.

56 Dining-philosopher 문제
Monitor Example Dining philosopher Dining-philosopher 문제 P3 P4 spaghetti P5 P2 P1

57 Dining-philosopher monitor code
monitor dining_philosophers; var numForks : array[0..4] of integer, ready : array[0..4] of condition, i : integer; procedure pickup(me); var me : integer; begin if (numForks[me]  2) then ready[me].wait(); numForks[right(me)]  numForks[right(me)] - 1; numForks[left(me)]  numForks[left(me)] - 1; end; procedure putdown(me): numForks[right(me)]  numForks[right(me)] + 1; numForks[left(me)]  numForks[left(me)] + 1; if (numForks[right(me)] = 2) then ready(right(me)].signal(); if (numForks[left(me)] = 2) then ready(left(me)].signal(); for i  0 to 4 do numForks[i]  2; end.

58 Code for philosopher process
Pi do forever pickup(i); eating; putdown(i); thinking; end.

59 Conclusion Low-level concurrent programming constructs
Programmer의 사용이 불편하고 오류 범하기 쉬움 High-level concurrent programming constructs Monitor, path expressions, serializers, critical regions 등 사용자들이 병행 프로그래밍을 보다 쉽게 할 수 있도록 지원함 객체지향 개념 코딩 중 오류 발생 가능성을 크게 줄임


Download ppt "Chap. 7 Process Synchronization"

Similar presentations


Ads by Google