๊ณต์ ๋ฐ์ดํฐ ์ ๊ทผ
do {
entry section
critical section
exit section
remainder section
} while (1)
ํ๋ก๊ทธ๋จ์ ํด๊ฒฐ๋ฒ์ ์ถฉ์กฑ ์กฐ๊ฑด
1) Mutual Exclusion(์ํธ ๋ฐฐ์ )
ํน์ ํ๋ก์ธ์ค๊ฐ critical section์ ์ํ ์ค์ด๋ฉด ๋ค๋ฅธ ๋ชจ๋ ํ๋ก์ธ์ค๋ค์ critical section์ ๋ค์ด๊ฐ๋ฉด ์ ๋๋ค
2) Progress
์๋ฌด๋ critical section์ ์์ง ์์ ์ํ์์ critical section์ ๋ค์ด๊ฐ๊ณ ์ ํ๋ ํ๋ก์ธ์ค๊ฐ ์๋ค๋ฉด critical section์ ๋ค์ด๊ฐ๊ฒ ํด์ฃผ์ด์ผ ํ๋ค.
3) Bounded Waiting(์ ํ ๋๊ธฐ)
ํ๋ก์ธ์ค๊ฐ critical section์ ๋ค์ด๊ฐ๋ ค๊ณ ์์ฒญํ ํ๋ถํฐ ๊ทธ ์์ฒญ์ด ํ์ฉ๋ ๋๊น์ง ๋ค๋ฅธ ํ๋ก์ธ์ค๋ค์ด critical section์ ๋ค์ด๊ฐ๋ ํ์์ ํ๊ณ๊ฐ ์์ด์ผ ํ๋ค
Peterson's Algorithm
1) sync var
- int turn, initially turn = 0; / turn == 1์ด๋ฉด ready
- boolean flag[2] = false; / flag[i] == true์ด๋ฉด ready
2) algorithm
3) result
- ์ธ ๊ฐ์ง ์กฐ๊ฑด์ ๋ชจ๋ ๋ง์กฑํ๋ค
- ๋ฌธ์ : ๊ณ์ CPU์ Memory๋ฅผ ์ฐ๋ฉด์ ๊ธฐ๋ค๋ฆฌ๊ธฐ ๋๋ฌธ์ Busy Waiting(while๋ฌธ์ ๋๋ฉด์ ๋ง๋ Spin Lock) ๋ฐ์ํ๋ค
Test and Set
ํ๋์จ์ด์ ์ผ๋ก test & modify๋ฅผ atomicํ๊ฒ ์ํํ ์ ์๋๋ก ํ๋ instruction
์ง๊ธ๊น์ง์ ๋ฌธ์ ๋ read & write๋ฅผ ๋์์ ์คํํ ์ ์๊ธฐ ๋๋ฌธ์ ๋ฐ์ํ์.
> read, write๋ฅผ ํ๋์ instruction์ผ๋ก ์ํํ๋๋ก ๋ณ๊ฒฝํ๋ฉด ์ํํธ์จ์ด์ ์ผ๋ก ๋ณต์กํ ์ฝ๋๋ฅผ ์งค ํ์๊ฐ ์์ด์ง
> ๋ฐ์ดํฐ์ ํ์ฌ ๊ฐ์ ์ฝ๊ณ / ๊ฐ์ 1๋ก ๋ฐ๊พธ์ด์ค
1) ํ์ฌ lock์ ์ฌ์ฉํ์ง ์์ผ๋ฉด, lock = 1๋ก ๋ณ๊ฒฝํ๊ณ critical section์ ๋ค์ด๊ฐ
2) ํ์ฌ lock์ ์ฌ์ฉํ๊ณ ์์ผ๋ฉด, while๋ฌธ์ ๋๋ค๊ฐ lock ํ๋ฆฐ ํ์ critical section์ ๋ค์ด๊ฐ
Semaphores
๊ฐ๋ฐ์์ ํธ์๋ฅผ ์ํด ์์ ๋ฐฉ์๋ค์ ์ถ์ํ์ํด
- integer variable S : ๊ณต์ ์์์ ๊ฐ์
- ๋ ๊ฐ์ง atomic ์ฐ์ฐ์ ์ํด์๋ง ์ ๊ทผ ๊ฐ๋ฅ
1) P์ฐ์ฐ : ๊ณต์ ์์์ ํ๋ํ๋ ๊ณผ์ (lock์ ๊ฑฐ๋ ๊ณผ์ ) -> busy-waiting ๋ฌธ์ ๊ฐ ๋ฐ์!
2) V์ฐ์ฐ : ๊ณต์ ์์์ ๋ฐ๋ฉํ๋ ๊ณผ์ (lock์ ํธ๋ ๊ณผ์ )
1) Critical Section Implementation
- ๋จ์ : busy-waiting
2) Block & Wakeup Implementation(Sleep)
1) semaphore
typedef struct {
int value; // semaphore
struct process *L; // process wait queue
} semaphore;
2) block & wakeup
- block : block์ ํธ์ถํ ํ๋ก์ธ์ค๋ฅผ suspend ์ํด / ํด๋น ํ๋ก์ธ์ค์ PCB๋ฅผ semaphore์ ๋ํ wait queue์ ๋ฃ์
- wakeup(P) : block๋ ํ๋ก์ธ์ค๋ฅผ wakeup ์ํด / ํด๋น ํ๋ก์ธ์ค์ PCB๋ฅผ ready queue์ ๋ฃ์
3) ๋์ ๋น๊ต
- ์ผ๋ฐ์ ์ผ๋ก๋ block & wakeup์ ์ฐ๋ ๊ฒ์ด ๋ ํจ์จ์ ์
- ๊ทธ๋ฌ๋ critical section์ ๊ธธ์ด๊ฐ ๋งค์ฐ ์งง์ ๊ฒฝ์ฐ์๋ block & wakeup์ ์ค๋ฒํค๋๊ฐ busy-wait ์ค๋ฒํค๋๋ณด๋ค ์ปค์ง ์ ์์
Two types of Semaphores
1) counting semaphores : ์์์ ๊ฐ์๊ฐ ์ฌ๋ฌ ๊ฐ ์๋ ๊ฒฝ์ฐ
2) binary semaphore(mutex) : ์์์ ๊ฐ์๊ฐ 1๊ฐ๋ฐ์ ์๋ ๊ฒฝ์ฐ
Deadlock and Starvation
1) Deadlock : ๋ ์ด์์ ํ๋ก์ธ์ค๊ฐ ์๋ก ์๋๋ฐฉ์ ์ํด ์ถฉ์กฑ๋ ์ ์๋ ์ด๋ฒคํธ๋ฅผ ๋ฌดํํ ๊ธฐ๋ค๋ฆฌ๋ ํ์
-> ์์์ ์ป๋ ์์๋ฅผ ์ ํด์ฃผ๋ฉด ํด๊ฒฐ(ex. P๋ฅผ ์ป๊ณ ๋์ Q๋ฅผ ์ป์ด๋ผ)
2) Starvation : ํ๋ก์ธ์ค๊ฐ suspend๋ ์ด์ ์ ํด๋นํ๋ semaphore ํ์์ ๋น ์ ธ๋๊ฐ ์ ์๋ ํ์(infinite locking)
ex) dining-philisophers problem : ํน์ ํ๋ก์ธ์ค๊ฐ ์์์ ๋ ์ ํ๊ณ ์์ด์ ๋ค๋ฅธ ํ๋ก์ธ์ค๊ฐ ์ฌ์ฉํ ์ ์๋ค
Classical Problems of Synchronization
1) Bounded-Buffer Problem(Producer-Consumer Problem)
์ ํํ ๋ฒํผ. producer๊ฐ ๋ฐ์ดํฐ๋ฅผ ์์ฑํ๊ณ , consumer๊ฐ ๋ฐ์ดํฐ๋ฅผ ๊บผ๋ธ๋ค.
1) shared data : buffer ์์ฒด ๋ฐ buffer ์กฐ์ ๋ณ์(emtpy/full buffer์ ์์ ์์น)
- ๋์ผํ ์์น์ producer๋ผ๋ฆฌ ์ ๊ทผํ๊ฑฐ๋ consumer๋ผ๋ฆฌ ์ ๊ทผํ๋ฉด ๋ฌธ์ ๋ฐ์ ๊ฐ๋ฅ
2) synchronization var
- mutual exclusion : shared data์ mutual exclusion(binary semaphore ํ์)
- resource count : ๋จ์ full/emtpy buffer์ ์(integer semaphore ํ์)
semaphore full = 0, empty = n, mutex = 1
2) Readers-Writers Problem
1) write & read
- write : ํ process๊ฐ DB์ write ์ค์ผ ๋ ๋ค๋ฅธ process๊ฐ ์ ๊ทผํ๋ฉด ์ ๋จ
- read : ๋์์ ์ฌ๋ฟ์ด ํด๋ ๋จ
- writer๋ ๋๊ธฐ ์ค์ธ reader๊ฐ ํ๋๋ ์์ ๋ DB ์ ๊ทผ์ด ํ์ฉ
- wirter๊ฐ DB์์ ๋น ์ ธ๋๊ฐ์ผ๋ง reader์ ์ ๊ทผ์ด ํ์ฉ
2) shared data
int readcount = 0;
DB ์์ฒด;
3) sync var
semaphore mutex = 1, db = 1;
- ์ต์ด์ reader : writer๋ก ์ธํด ๋ด์ฉ ๋ณ๊ฒฝ๋๋ ๊ฒ์ ๋ง๊ธฐ ์ํด DB์ lock์ ๊ฑธ๊ณ ์ฝ๋๋ค
- 2๋ฒ์งธ~ reader : ์ด๋ฏธ DB์ lock์ด ๊ฑธ๋ ค ์๊ธฐ ๋๋ฌธ์ ์๋ฌด๋ฐ ์กฐ์น ์์ด ๊ทธ๋ฅ ์ฝ๋๋ค
3) Dining-Philosopher Problem
1) ๋ฌธ์ : deadlock ๊ฐ๋ฅ์ฑ์ด ์์
2) ํด๊ฒฐ ๋ฐฉ์
- 4๋ช ์ ์ฒ ํ์๋ง์ด ํ ์ด๋ธ์ ๋์์ ์์ ์ ์๊ฒ ํจ
- ์ ๊ฐ๋ฝ์ ๋ ๊ฐ ๋ชจ๋ ์ง์ ์ ์์ ๋๋ง ์ ๊ฐ๋ฝ์ ์ง์ ์ ์๊ฒ ํจ
- ๋น๋์นญ : ์ง์(ํ์) ์ฒ ํ์๋ ์ผ์ชฝ(์ค๋ฅธ์ชฝ) ์ ๊ฐ๋ฝ๋ถํฐ ์ง๋๋ก ํจ
semaphore ๋ฒ์ ์ ํด๊ฒฐ๋ฒ
testํจ์์์ ์ ๊ฐ๋ฝ 2๊ฐ๋ฅผ ๋ชจ๋ ์ง์ ์ ์๋์ง ํ์ธ
1) ์ผ์ชฝ๊ณผ ์ค๋ฅธ์ชฝ ์ฌ๋์ด ์ ๊ฐ๋ฝ์ ์ฌ์ฉํ๊ณ ์์ง ์์ ๊ฒฝ์ฐ
2) ๋ด๊ฐ ๋ฐฐ๊ฐ ๊ณ ํ ๊ฒฝ์ฐ
Monitor
* semaphore์ ๋ฌธ์ ์ ์ ํด๊ฒฐํ๊ธฐ ์ํด ๋์
- ์ ํํ๊ฒ ์ฝ๋ฉํ๊ธฐ ํ๋ค๋ค
- ์ ํ์ฑ correctness์ ์ ์ฆ์ด ์ด๋ ต๋ค
- ์๋ฐ์ ํ๋ ฅ voluntary cooperation์ด ํ์ํ๋ค
- ํ ๋ฒ์ ์ค์๊ฐ ๋ชจ๋ ์์คํ ์ ์น๋ช ์ ์ธ ์ํฅ
* ๋ชจ๋ํฐ ๋ด๋ถ procedure๋ฅผ ํตํด์๋ง shared data์ ์ ๊ทผํ ์ ์๋๋ก ํจ
์๋์ ์ผ๋ก ๋ด๋ถ procedure์ ๋์ ์คํ์ ๋ง๊ธฐ ๋๋ฌธ์(ํ๋๋ง ํ์ฑํ) ๊ฐ๋ฐ์๊ฐ lock์ ๋ฐ๋ก ๊ฑธ ํ์๊ฐ ์์
* condition variable : wait(), signal() ์ฐ์ฐ
1) x.wait() : ๋ค๋ฅธ ํ๋ก์ธ์ค๊ฐ x.signal()์ ํธ์ถํ๊ธฐ ์ ๊น์ง suspend๋๋ค
2) x.signal() : ํ๋์ suspen๋ ํ๋ก์ธ์ค๋ฅผ resumeํ๋ค
1) Bounded-Buffer Problem(Producer-Consumer Problem)
semaphore์์๋ ๋ณ์๊ฐ ๊ฐ์ ๊ฐ์ง์ง๋ง, monitor์์๋ ๋ณ์๊ฐ ๊ฐ์ ๊ฐ์ง์ง ์๋ ๋์ ์กฐ๊ฑด ๋ง์กฑ ์ฌ๋ถ๋ฅผ ๊ฐ๋ฐ์๊ฐ ์ฒดํฌํ๋ค
2) Dining-Philosopher Problem
์ ๊ฐ๋ฝ์ ์ก์ ํ์ ์ฝ๋๋ ๋ชจ๋ํฐ ๋ด๋ถ์ ์กด์ฌ
'๐ป CS > ์ด์์ฒด์ ' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[์ด์์ฒด์ ] 8. Memory Management (1) | 2023.01.08 |
---|---|
[์ด์์ฒด์ ] 7. Deadlocks (0) | 2023.01.01 |
[์ด์์ฒด์ ] 5. CPU Scheduling (0) | 2022.11.27 |
[์ด์์ฒด์ ] 4. Process Management (0) | 2022.11.27 |
[์ด์์ฒด์ ] 3. Process (0) | 2022.11.20 |
๋๊ธ