2022. 12. 14. 02:01ใ_Study/OperationSystem
Concurrency : Deadlock ๐¸.•*¨*•¸.•*¨*•¸.•*¨*•¸.•*¨*•
ํด๋น ์๋ฃ๋ ๊ฐ์ ํ์ต์๋ฃ์ ๋๋ค.
์๋์ ์ธ ํ๋ก์ธ์ค๋ ํ์ฌ ๋ฐ๋๋ฝ(deadlock) ์ํฉ์ด๋ค. process 1์ ์์ 1์ ๊ฐ์ง๊ณ ์์ 2๋ฅผ ์์ฒญํ๋ ์ค์ธ๋ฐ ์ด๋ ์์ฒญ์ด ๋ฐ์๋ค์ฌ์ง์ง ์์ผ๋ฉด ๋ค์ ๋จ๊ณ๋ก ๋์ด๊ฐ ์ ์๋ค. ์ฆ, P1์ ๋ค์์ ์์ฒญ์ ๊ธฐ๋ค๋ฆฌ๊ณ ๋๊ธฐํ๊ณ ์๋ค. P2, P3๋ ๋์์ ์์ฒญ์ ๊ธฐ๋ค๋ฆฌ๊ณ ์์ ๋ ๋ชจ๋ ํ๋ก์ธ์ค๊ฐ ๋ค์ ๋จ๊ณ๋ก ๋์ ํ ๋์ด๊ฐ์ง ๋ชปํ์ฌ ๋ฉ์ถฐ์๋ ์ํฉ, state์ ๋ณํ๊ฐ ์๋ ์ํฉ์ ๋ฐ๋๋ฝ์ด๋ผ๊ณ ํ๋ค.
์ด์์ฒด์ ์ ํ๋ก์ธ์ ๊ฐ์ ๋ ๋ฒจ ์ฐจ์ด ๋๋ฌธ์ ์ง์ ์ ์ผ๋ก ์ผ์ด๋์ง ์๊ฒ ์ง๋ง deadlock ์ด ๋ฐ์ํ๊ธฐ ์ ์ ์กฐ์น๋ฅผ ์ทจํด์ผ ํ๋ค.
System models
๋ ๊ฐ์ง์ Model๋ก ํ์ฌ ์ํฉ์ ํํํ ์ ์๋ค. P-R Model ๊ณผ S-T Model์ธ๋ฐ ๋ ์ ์ฐจ์ด๋ฅผ ์ ์ดํดํด์ผ ํ๋ค.
Process-Resource Model
: ํ๋ก์ธ์ค์ ๋ฆฌ์์ค์ ์งํฉ์ผ๋ก ๊ตฌ์ฑ P, R
: Cj: number of units of Rj in the system (๋ฆฌ์์ค์ ๊ฐ์)
: ใ ์ O๋ก ์ด๋ฃจ์ด์ง ๋ชจํ์ผ๋ก ๊ทธ๋ฆฐ๋ค. ๊น๋ง ๋๊ทธ๋ผ๋ฏธ๊ฐ resource
State_Transition Model : ์ํ ์ ์ด ๋ชจ๋ธ
: S : ํ์ฌ ์ํ, ํ๋ก์ธ์ค๋ค์ด ๋์ํ๋ฉด ์ํ๊ฐ ๋ฐ๋๋๋ฐ ์ด ์ํ๋ค์ ์งํฉ
: ํ๋ก์ธ์ค์ ๋ฆฌ์์ค์ ์์ธ๋ฅผ ์์ธํ ๋ณด์ง ์์ง๋ง, ์ํ๋ค์ ์งํฉ์ผ๋ก ํํํ๋ค.
: state changes when processes take action
: This allows us to indentfy a deadlock situation in the operating system.
์ํ ์ ์ด๋ process์ action์ ์ํด system ๋ณํ ์ ์์์ ์๋ฏธํ๊ณ 3๊ฐ์ง์ ํ๋(๋ฐฉ๋ฒ)์ด ์๋ค.
์ํ๋ฅผ ๋ณํํ๋ action์๋ 3 ๊ฐ์ง๊ฐ ์๋ค.
- request : request one or more units of a resource : ๋ฆฌ์์ค๋ฅผ ์์ฒญ
- allocation : All outstanding requests from a process for a given resource are satisfied. : ๋ฆฌ์๋ฅผ ํ ๋น
- deallocation : the process release units of a resoucre. : ๋ฆฌ์๋ฅด๋ฅผ ๋๋ ค์ค(๋ด๋๊ธฐ)
P2 ์ ์ํด ๋ณ๊ฒฝ๋๋ ์ํ๊ฐ ์๋ค๋ฉด p2๋ block๋์๋ค๊ณ ๋งํ๋ค.
์ํ ์ ์ด ๋ชจ๋ธ๋ก deadlock ํ์ธํ๊ธฐ
deadlock ์ ๋ง๋ ๋ฐฉ๋ฒ : deadlock์ด ๋ฐ์ํ๋ ์กฐ๊ฑด 4๊ฐ์ง ์ค์ ํ๋๋ผ๋ ๋ถ๋ง์กฑํ๋ฉด ๋๋ค.
- Prevention : ์๋ฐฉ , deadlock์ด ๋ฐ์ํ์ง์๋๋ก ์์คํ ์ ์ค๊ณ -> deadlock์ ์กฐ๊ฑด์ ์์์ผํจ (4๊ฐ์ง)
- Avoidance : ํํผ , deadlock๊น์ง ์งํํ์ง ์๋ ๋ชจ๋ธ์ ์ค๊ณํ๊ณ ์ ๋ต์ ์ค์ -> ์์ธกํ๊ธฐ ์ํด์ action ์ ๋ณด์ ์๋ฎฌ๋ ์ด์ ์ด ํ์ํ๋ค.
- Detection & Recovery : ๊ฐ์ง, ํ๋ณต : ์ฃผ๊ธฐ์ ์ผ๋ก ๋ชจ๋ํฐ๋ง ํ๋ ํจ์(๋ฐฑ๊ทธ๋ผ์ด๋)
- Manual intervention : ์ ์๋๋ฉด ๊ป๋ค ์ผ๊ธฐ(Reboot)
deadlock์ ์กฐ๊ฑด 4๊ฐ์ง
- mutual exclusion : ํ ๋ฒ์ CS๋ ํ๋๋ง ์คํํ๋ค. ๋ฐ๋์ ์ง์ผ์ผํ ์กฐ๊ฑด์ด๋ค.
- hold and wait : ๋ฆฌ์์ค๋ฅผ ๊ฐ์ง๊ณ ๊ธฐ๋ค๋ฆฐ๋ค.
- circular waiting : ์ํ์ ๋ชจ์์ ์ ์งํ๋ค.
- No preemption : ์ ์ ๋๋ ์ทจ์๋ฅผ ํ์ง ์๋๋ค. -> ์์ฒญ์ ๊ณ์ ๊ธฐ๋ค๋ฆฐ๋ค. ์ฐ์ ์ ์ผ๋ก ๋ณ๊ฒฝํ๋ฉด block์ ํผํ ์ ์๋ค.
Hold and Wait :Need to be sure a process does not hold one resource while requesting another
ํ์ํ๊ฒ ์์ผ๋ฉด ํ๊บผ๋ฒ์ ์์ฒญํ๊ธฐ
์๋๋ฅผ ํฅํ ํ์ดํ์ฒ๋ผ ๋ค๋ฅธ ํ๋ก์ธ์ค์ action์๋ ์ํฉ์ด ๋ฐ๋ ์๋ ์์ง๋ง ๋ชจ๋ ๋ฆฌ์์ค์ ์์ฒญ์ ํ ๋ฒ์ ์งํํ๋ฉด ๋ฐ๋๋ฝ์ ๋ฐฉ์งํ ์ ์๋ค.
Approach 1: Force process to request all resources it needs at one time.
ํ ๋ฒ์ ๋ชจ๋ ๋ฆฌ์์ค๋ฅผ ํ ๋น ๋ฐ๋๋ค.
Approach 2: If a process needs to acquire a new resource, it must first release all resources it holds, then reacquire all it needs.
์๋ก์ด ๋ฆฌ์์ค๊ฐ ํ์ํ๋ฉด ๋ชจ๋ ๋ฆฌ์์ค๋ฅผ ๋ด๋ ค๋๊ณ ๋ค์ ์์ฒญํ๋ค.
์ด๋ฐ ๋ชจ๋ธ์ ๋ง๋ ์ด์ ๋ ์์คํ ์ ์ ์ํด์ผ ํ๊ธฐ ๋๋ฌธ์ด๋ค. ๋ฐ๋๋ฝ์ด ๋ฐ์ํ์ง ์๋ ์ค๊ณ๋ฅผ ๋ง๋ค๊ธฐ ์ํด์ ๋จผ์ ๊ฐ๋ ์ ์ธ ์ ์๊ฐ ํ์ํ๋ค.
ํ๋ก์ธ์ค๊ฐ ๋ฆฌ์์ค๋ฅผ ๊ฐ์ง๊ณ ์์ผ๋ฉด์ ๋ค๋ฅธ ๊ฒ์ ์๊ตฌํ์ฌ ๋ฐ์ํ๋ ๊ผฌ์ด๊ณ ๊ผฌ์ธ ๋ชจ์์ ๋ฐ๋๋ฝ์ ์ฌ์ ์ ๋ฐฉ์งํ ์ ์๋ค.
Circular wait : Have a situation in which there are N processes holding units of N resources
๋ชจ๋ ํ๋ก์ธ์ค๋ฅผ ์์๋ฅผ ๋งค๊ธด๋ค. ๊ทธ๋ฆฌ๊ณ ๊ฐ ํ๋ก์ธ์ค๋ ์์ ์ ์ซ์๋ณด๋ค ๋์ ํ๋ก์ธ์ค์๊ฒ ์์ฒญํ ์ ์๋ค.
O๊ฐ process, ใ ๊ฐ Resources
R -> P : Hold : ์ค์
P -> R : request : ์ ์
์ฒ ํ์๋ค์ ์ ๋ ์์ฌ์ ์ ์ฉํ๋ฉด : ์์ ํํ์ ์์ฒญ์ ๋ฐฉ์ ๋๋ฌธ์ ๋ฐ์ํจ.
-> ๋ง์ง๋ง ์ซ์์ธ 4์ ๋ฐ์ ์์๋ง ์ ๋ฐฐ์นํ๋ฉด ๋๋ค.
Circular wait (cont')
There is a cycle in the graph of processes and resources
choose a resource request strategy by which no cycle will be introduced
์ผ์ข ์ ์ ๋ต์ ์ทจํ๋ค.
Total order on all resources, then can only ask for Rj if Ri < Rj for all Ri the process is currently holding.
Allow Preemption
Allow a process to time-out on a blockes request - withdrawing(Wu) the request if it fails
request ์ ์ผ๋ก ์ทจ์ํ๋ ๊ฒ์ ์ถ๊ฐํ์๋ค. -> Si๋ก ๋ค์ ๋์์จ๋ค. ๋ด๊ฐ ์ทจ์ํ๋ฉด ๋ค๋ฅธ ํ๋ก์ธ์ค๋ ์ํ๋ฅผ ๋ณํํ ์ ์๋ค. -> ์ด์ ๋์ ์ฐ์ ์์ ๋ณํ๋ ์ถฉ๋ถํ๋ค.
deadlock์ ์๋๋ฐ deadlock ์ฒ๋ผ ๋ณด์ด๋ ํ์ : ๋จธ๋ฌผ๋ฌ์๋ ๊ฒ์ฒ๋ผ ๋ณด์ด์ง๋ง, ๊ณ์ ์๋ค๊ฐ๋ค ์๋ณดํ๋ฉด์ ๋ฆฌ์์ค๋ฅผ ์ฌ์ฉํ์ง ๋ชปํ๋ ์ํฉ์ด๋ค.
Livelock :์๋ก์๋ณดํ๊ธฐ : two or more processes continually repeat the ame interaction in response to changes in the other processes without doing any useful work
- These processes are not in the waiting state, and they are running concurrently.
- This is different from a deadlock because in a deadlock all processes are in the waiting state.
Deadlock Avoidance : ๋ฐ๋๋ฝ ํํผ
deadlock๊น์ง ์งํํ์ง ์๋ ๋ชจ๋ธ์ ์ค๊ณํ๊ณ ์ ๋ต์ ์ค์ -> ์์ธกํ๊ธฐ ์ํด์ action ์ ๋ณด์ ์๋ฎฌ๋ ์ด์ ์ด ํ์ํ๋ค.
Define a model of system states , then choose a strategy that will guarantee that the system will not go to a deadlock state
Requires extra inforamation, e.g., the maximum claim for each process
์ต๋ ์๊ตฌ๋์ ๊ณ์ฐํ๋ค.
Allows resouce manager to see the worst case that could happen, then to allow transitions based on that knowledge.
๋ฆฌ์์ค๊ด๋ฆฌ์(OS)๊ฐ worst case๊ฐ ์ผ์ด๋๋์ง ํญ์ ๊ฐ์ํ๊ณ ์๋ค.
- the resource is available :๋ฆฌ์์ค๋ ์ฌ์ฉ ๊ฐ๋ฅํ๋ค.
- Even if all processes use ther maximun reosources, : ๋ชจ๋ ํ๋ก์ธ์ค๊ฐ ์ต๋ ๋ฆฌ์์ค๋ฅผ ์ฌ์ฉํ๋ค.
- Finally, when a state transition that can complete the execution of all processes in the system is possible : ๋ชจ๋ ํ๋ก์ธ์ค๊ฐ ์ํ์ค์ ์ต๋์ ๋ฆฌ์์ค๋ฅผ ์ฌ์ฉํ๋ ์ํฉ์ ์ฌ์ฉํ๋๋ผ๋ ์์ ํ ์ํ๋ผ๋ฉด ์ด๋ฅผ ํ์ฉํ๋ค.
์ํ๋ฅผ ๊ตฌ๋ถํ ์ ์์ด์ผํ๋๋ฐ 2๊ฐ์ง๋ก ๋๋๋ค.
Safe vs UnSafe states
safe state: one in which the system can assure that any sequence of subsequent transitions leads back to the initial state : init์ผ๋ก ๋์๊ฐ ์ ์๋ ์ํฉ
- Even if all exercies their maximun claim, there is an allocation strategy by which all claims can be met.
Unsafe state: one in which the system cannot gurantee that the system will transition block to the initial state.
- unsafe stste can lead to a dead lock state if too many processes exercise their maximum claim at once.
์ด๊ธฐ ์ํ๋ก ๋์๊ฐ๋๊ฑธ ๋ณด์ฅ์ ๋ชปํ๊ณ
dead lock ์ด ๋ฐ์ํ ์ ์๋ (์ง์ ) ์ํ
์ต๋์น๋ก ์ฌ์ฉํ๋๊ฑธ ๋น๊ถ์ฅํ๋ ์ด์ : ์ฌ๋ฌ ํ๋ก์ธ์ค๊ฐ ๋์ํ๊ธฐ ๋๋ฌธ์ ์ ๋ release ํ๋ฉด ๋คํ์ด์ง๋ง ์ฌ์ฉํ๋ ๊ฒฝ์ฐ deadlock์ด ๋ฐ์ํ ์ ์๋ค. ๋ณด์์ ์ผ๋ก ์์ ํ๊ฒ ์ฌ์ฉํ๋๊ฑธ ๋ณด์ฅํ๋ค.
๋ํ์ ์ธ ์๊ณ ๋ฆฌ์ฆ์ผ๋ก Banker Algorithm์ด ์๋ค.
๋์ถ ์์คํ ๊ณผ ๋น์ทํ๋ฐ ๊ณ ๊ฐ๋ง๋ค ๋์ถ ํ๋๊ฐ ๋ค๋ฅด๊ณ ๋ฐ๋ฉํด์ผ ํ๋๊ฒ ๋น์ทํด์ ์ด ๊ฐ๋ ์ ์ ์ฉํ ์๊ณ ๋ฆฌ์ฆ์ด๋ค. ์ด๋ ์๋ฎฌ๋ ์ด์ ์ด๋ค.
ํ์ํ ์กฐ๊ฑด 3๊ฐ์ง
maxc[i,j] : ์ต๋ ์์ฒญ๊ฐ๋ฅํ ๋ฆฌ์์ค ๊ฐ์์ด๋ค. Maximun Claim
alloc[i,j] : ํ ์ํ์์ ํ๋ก์ธ์ค๊ฐ ๊ฐ์ง ๋ฆฌ์์ค ๊ฐ์์ด๋ค. :Allocated Resources
C : ํ ๋น ์์์ ํฉ
avail[j] ๊ณ์ฐ ๊ฐ์ ํตํด safe์ธ์ง unsafe์ธ์ง ํ์ธํ๋ค.
ํ ์์ ์์ ๊ฐ๊ฐ ํ๋ก์ธ์ค์๊ฒ ๋ช๊ฐ์ฉ ํ ๋น ๋์ด์๋์ง copyํ๋ค.
์ง๊ธ ๋ฆฌ์์ค์ ์ต๋ ์ด์ฉ๋์ ์ด์ฉํ์ฌ avail์ ๊ณ์ฐํ๋ค. (์ผ์ข ์ ์ฌ์ ๋ถ)
์ด ์กฐ๊ฑด์ ๋ง์กฑํ๋ ํ๋ก์ธ์ค๋ฅผ ์ฐพ๋๋ค.
๋จ์์๋ avail ๋ณด๋ค ํฐ ์กฐ๊ฑด์ ์๊ตฌํ๋ฉด unsafe
๋ชจ๋ process๊ฐ ๋ค 0์ด๋๋ฉด safe ์ํ์ด๋ค.
ํ๋ก์ธ์ค p0๋ฅผ ๋ณผ ๋ R0์ ๋ฆฌ์์ค๋ฅผ ์ฌ์ฉํ๋ ๊ฒ์ ๋ณด๋ฉด ์ต๋ 3๊ฐ๋ฅผ ์์ฒญํ ์ ์์ผ๋ ํ์ฌ 2๊ฐ(allocated)๋ฅผ ์ฌ์ฉํ๊ณ ์๋ค. ๋ฐ๋ผ์ 1๊ฐ๋ง ๋ ํ ๋น ๋ฐ์ ์ ์๋ค.
total allocated ๊ฐ์ ๊ตฌํ์ฌ
C - total alloc = avail ๊ฐ์ ๊ตฌํ๋ค.
maxc - alloc ์ด avail๊ฐ(์ต๋์น๊น์ง ๋ค ์ด๊ฒฝ์ฐ)๋ณด๋ค ์๋ค๋ฉด ๋์๊ฐ๋ฅํ ์์ ํ ์ํ์ด๋ค.
์์์ ํด์ ํ๋ค๊ณ ์๊ฐํ๊ณ ์์ ํ์๋ฅผ ํ๋ค. avail + alloc
avail ์ํ๊ฐ ๋ฐ๋ ์ดํ๋ฅผ ๋ณธ๋ค๋ฉด ์์คํ ์ ์์์ด 5225๋ก ์ฆ๊ฐํ์๋ค.
์ต๋๋ก ๋ ํธ์ถํ ์ ์๋ ๊ฒฝ์ฐ๊ฐ 2003 ์ผ๋ก avail๋ณด๋ค ์์ safe์ํ์ธ์ง ํ์ธํ๋ค.
์ฌ์ฉํ๊ณ ํ ๋น ํด์ฒดํ๋ค.
5225 + 1030 = 6255
unsafe ๋ก ์๋ชป ํ๊ธฐ ํ์๋ค.
ํ ๋น์ ํด์ ํด์ ๊ฐ์ ๋๋ ค์ฃผ๋ฉด C์ ๋ค์ ๋ํด์ง๋๋ฐ ๋ชจ๋ ํด์ ๊ฐ ๊ฐ๋ฅํ๋ฉด ๋ค์ 8597๋ก ๋์๊ฐ๋ค.
gray๋ก ๋๊ฒ์ ๋ฐํํ ์ํ
Unsafe ์ํฉ์ ์์๋ณด์.
์ผ๋จ C์ allocated sum ์ ๋บ๋ค.
8597 - 8375 = 0222
๋ด๊ฐ ์๊ตฌํ ์ ์๋ ์ต๋๋์ ์๊ตฌํด๋ณธ๋ค.
P3 max-allo = 1530-1210
0320 < 0222
p3์ ์์ R1 ์์ unsafe ์ํฉ์ด ๋ฐ๊ฒฌ๋์๋ค.
Deadlock Detection & Recovery : ๋ฐ๋๋ฝ ๊ฐ์ง์ ํ๋ณต <-> avoidance ํ ๋นx ํํผํ๋๋ฐ
check for deadlock , then recovery
can be far more aggressive with allcoation
no maximum claim, no safe/ unsafe states
Differentiate between
- Serially reusable resources : ์ฌ์ฌ์ฉ ๊ฐ๋ฅํ ์์, ์๋นํ๊ณ ๋ฐํํ์ฌ ๋ค์ ์ฑ์์ง๋ ์์
- consumable resources : ๋ฐํํ์ง ์๊ณ ์ฌ์ฉ ํ ์์ด์ง๋ ์์. ์์ฐ์์ ์๋น์๊ฐ ์๋ค.
์ด๋ ํ์ผํฌ์ธํฐ, ๋ฌธ์์ ๋ ฅ, ๋ง์ฐ์ค ํด๋ฆญ ,์ด๋ฒคํธ ์๊ทธ๋ : ๋ชจ๋ ๋ฆฌ์์ค์ด๋ค.
Reusable Resoucre Graph RRG : Micro model, C๊ฐ ์ด ํฉ์ด๋ค. ์์ ์๊ฑฐ
Micro model : ํ๋์ single state๋ฅผ ์กฐ๊ธ ๋ ์์ธํ๊ฒ ์ค๋ช ํ๋ค.
Nodes ๊ฐ ๋๊ฐ์ง๊ฐ ์๋๋ฐ p(o), R(ใ ) ์ด๋ค.
p,R ์ธ ๊ฒฝ์ฐ request edge : ์์ฒญ ์ํฉ
R,p ์ธ ๊ฒฝ์ฐ assighment edge : ํ ๋น ์ํฉ
ํ์ดํ๋ฅผ ํด์ ํ๋ฉด ์์์ ๋ฐ๋ฉํ ๊ฒ์ด๋ค.
์ํ ๋ณํ(์ ์ด)๊ฐ ์ผ์ด๋ ์ ์๋ค.
reusable resource๋ฅผ ์ํ์ ์ด๊ทธ๋ํ๋ก ๋ณธ ๊ฒฝ์ฐ์ด๋ค.
Graph Reduction ๊ทธ๋ํ์ถ์ : ์ ๊ฑฐ๊ฐ ๋ถ๊ฐ๋ฅํ๋ฉด deadlock์ด๋ค. ๋ชจ๋ ์ ๊ฑฐํ๋ฉด ์๋๋ค.
Deaklock state if there is no sequence of transitions unblocking every process
๋ชจ๋ ํ๋ก์ธ์ค๋ฅผ unblockํ๋ ๊ฒฝ์ฐ๊ฐ ์์ผ๋ฉด ๊ด์ฐฎ์ง๋ง,
A RRG represents a state; can analyze the RRG to determine if there is a sequence
์ ๊ฑฐ : ๊ทธ ํ๋์ด ์ผ์ด๋ ์ํฉ์ ๊ฐ์ ํ๊ณ ์ญ์
์ ๊ฑฐ๊ฐ ๊ฐ๋ฅํ ์ํฉ
- block ์ํ๊ฐ ์๋๋ค. (๋ค์ ์ํ์ ์ด๊ฐ ๊ฐ๋ฅํ๋ค.)
- request edges ๋ฅผ ๊ฐ์ง๊ณ ์์ง ์๊ณ assign edge๋ ์์ ๋
RRG ๊ทธ๋ํ ์ถ์ ๋ฐฉ๋ฒ ์ ๋ฆฌ
1. ์ผ๋จ process ๋ฅผ ์ฐพ๋๋ค.
2. ์์ฒญ์ค์ธ์ง ํ์ธํ๋ค.
2.1. ์์ฒญ์ด ๊ฐ๋ฅํ๋ฉด ์์ค๋ค.
2.2. ์์ฒญ์ด ๋ถ๊ฐ๋ฅํ๋ฉด ํ์ฌ block์ด๋ค.
๋ค๋ฅธ ํ๋ก์ธ์ค๋ฅผ ์ฐพ๊ณ ๊ณ์ ์งํํด์ ์ ์ด ๋จ์์์ผ๋ฉด deadlock์ด๋ค.
Consumable Resource Graph (CRGs)
consumable resource ๊ฐ์ ๊ฒฝ์ฐ
p,R request egde : ์์ฒญ ์ํฉ
R,p producer edge : ์์ฐ ์ํฉ , ๋ง๋ค์ด๋ด๊ณ ์ ์ ์ง์๋ฒ๋ฆฐ๋ค.
๋ฐ๋ผ์ producer๊ฐ ์ด์์์ผ๋ฉด ์ผ๋ง๋ ์ง ๋ง๋ค์ด ๋ผ ์ ์๊ธฐ ๋๋ฌธ์ ์ ์ด ์์ด๋ producer๊ฐ ์ด์์์ผ๋ฉด deadlock ์ด ์๋๋ค
๋ฐ๋ผ์ ์๋ ์๋์ ์ ์ด ๋จ์ ์์ด๋ deadlock ์ด ์๋๋ค. (P1๋ฅผ ์ ๊ฑฐํ๊ณ ์ถ์ง๋ง R0์ ๋ฆฌ์์ค๊ฐ ์์ด์ ์ ๊ฑฐ๊ฐ ์๋จ) ๊ทธ๋ ์ง๋ง ์ํ์ ๋ชจ์์ด๋ผ ์ด๊ฒ ์ deadlcok์ด ์๋์ง ๋ชจ๋ฅด๊ฒ ๋ค. ํ๋๋ผ๋ producer ๊ฐ ์ด์์์ผ๋ฉด ๋๋๊ฑด์ง ์ถ๋ค. ๋ฐ๋๋ฝ์ ๊ธฐ์ค์ด ๋ค๋ฅด๋ค๊ณ ํ๋๋ฐ ์์ฐ์์ฒด๋ง ๋๋ฉด -> ์ผ๋จ ์ํ๊ฐ ๋ณํ๋๋๊น ์ ์ง๋ ์ํ๋ ์๋๋ค?? ๋ก ์ดํดํ๋ค.
General Resource Graph : ์ผ๋ฐ์ ์ธ ๋ฆฌ์์ค ๊ทธ๋ํ
reusable : ์์ ์๊ฑฐ
consumable : unblock
Recovery : ๋ณต๊ตฌ (ํ๋ณต)
No magic here
-choose a blocked resource
- preempt it (releasing its resources) / ์ ์ ํ์ฌ ๊ฐ์ง๊ณ ์๋ ๋ฆฌ์์ค๋ฅผ ๋ฐํ
- Run the detection algorithm
- Iterate if until the state is not a deadlock state
checkpoint / rollback (์์คํ ๋ฆฌ๋ถํ ์ ์ด๋ป๊ฒ ๊ธฐ์ต์ ํ๋ ๊ฑธ๊น? -> ํ์ฌ running state๋ฅผ ์ ์ฅ)
- Process periodically saves (checkpoints) the current running state.
- If the OS determines that there is a deadlock, the OS removes the process -> Another process uses the resource.
- After then, restart by resetting the process state based on checkpoint info.
์ด์ ๋์์ผ๋ก ๋ฆฌ๋ถํธ