Search
moon
sun
๐Ÿค”

Philosophers

philosophers.ko.pdf
1862.0KB
๊ถ๊ธˆํ•œ์ 
์™œ Trap์„ ๋™๊ธฐ์ , Interrupt๋ฅผ ๋น„๋™๊ธฐ์ ์ด๋ผ๋Š” ํ‘œํ˜„์„ ์ผ์„๊นŒ
User Mode์˜ ํ”„๋กœ์„ธ์Šค๋Š” ๋Œ€์ฒด์ ์œผ๋กœ ์‚ฌ์šฉ์ž์— ์˜ํ•ด ๊ตฌ๋™๋œ ์–ดํ”Œ๋ฆฌ์ผ€์ด์…˜์ด๋ผ๊ณ  ํ–ˆ๋Š”๋ฐ, ๊ทธ ์–˜๊ธฐ๋Š” ์–ดํ”Œ๋ฆฌ์ผ€์ด์…˜ ํ”„๋กœ์„ธ์Šค๋ฅผ ์ƒ์„ฑํ•˜๋Š” ๊ฑฐ ์ž์ฒด๋Š” Kernel Mode์—์„œ ์ด๋ฃจ์–ด์ง€๊ณ  ๊ทธ๋ ‡๊ฒŒ ์ƒ์„ ๋œ ์–ดํ”Œ๋ฆฌ์ผ€์ด์…˜ ์ƒ์—์„œ ์ผ์–ด๋‚˜๋Š” ์ผ๋“ค์ด User mode๋กœ ์ฒ˜๋ฆฌ๋œ๋‹ค๋Š”๊ฑด๊ฐ€?
์ฒ ํ•™์ž ๋ฌธ์ œ ํ•ด๊ฒฐ ๊ฐœ์„ ์•ˆ
/* ** i ๋ฒˆ์งธ ์ฒ ํ•™์ž๊ฐ€ ์‹์‚ฌ๋ฅผ ํ•  ์ค€๋น„๊ฐ€ ๋˜์—ˆ๋Š”์ง€ ํ™•์ธํ•œ๋‹ค. ** ์–‘ ์˜†์˜ ์ฒ ํ•™์ž๊ฐ€ ์‹์‚ฌ๋ฅผ ํ•˜๊ณ  ์žˆ์ง€ ์•Š์•„ ์ “๊ฐ€๋ฝ์„ ๋ชจ๋‘ ์ด์šฉํ•  ์ˆ˜ ์žˆ๋‹ค๋ฉด, ์ฒ ํ•™์ž๊ฐ€ take_chopsticks์—์„œ waitํ•˜์ง€ ์•Š๋„๋ก signal์„ ๋ณด๋‚ธ๋‹ค. ** ์ฃผ์–ด์ง„ ์กฐ๊ฑด์„ ๋งŒ์กฑํ•˜๋Š” ๊ฒฝ์šฐ์—๋Š” philo[i]์˜ ๊ฐ’์ด 1์ด๋ฏ€๋กœ take_chopsticks์—์„œ Block๋˜์ง€ ์•Š๊ณ  EATING ํ•  ์ˆ˜ ์žˆ๋‹ค. */ check(int i) { if (state[i] == THINKING && state[LEFT] != EATING && state[RIGHT] != EATING) { state[i] = EATING; signal(philo[i]); } } /* ** mutex๋ฅผ ํ†ตํ•ด i ๋ฒˆ์งธ ์ฒ ํ•™์ž์˜ ์ƒํƒœ๋ฅผ ๋ณ€๊ฒฝํ•œ๋‹ค. ** check๋ฅผ ํ†ตํ•ด ์–‘์ชฝ ์ฒ ํ•™์ž์˜ ์ƒํƒœ๋ฅผ ํ™•์ธํ•œ๋‹ค. ** i ๋ฒˆ์งธ ์ฒ ํ•™์ž๋Š” ์ž์‹ ์ด ์‹์‚ฌ๋ฅผ ํ•  ์ˆ˜ ์žˆ์„ ๋•Œ๊นŒ์ง€ ๊ธฐ๋‹ค๋ฆฐ๋‹ค. */ take_chopsticks(int i) { wait(mutex); state[i] = THINKING; check(i); signal(mutex); wait(philo[i]); } /* ** mutex๋ฅผ ํ†ตํ•ด i ๋ฒˆ์งธ ์ฒ ํ•™์ž์˜ ์ƒํƒœ๋ฅผ ๋ณ€๊ฒฝํ•œ๋‹ค. ** check๋ฅผ ํ†ตํ•ด ์™ผ์ชฝ ์ฒ ํ•™์ž์™€ ์˜ค๋ฅธ์ชฝ ์ฒ ํ•™์ž์˜ ์–‘ ์˜†์„ ํ™•์ธํ•œ๋‹ค. ** ๋‘˜ ์ค‘ ์‹์‚ฌ๊ฐ€ ๊ฐ€๋Šฅํ•œ ์ฒ ํ•™์ž์—๊ฒŒ check ๋‚ด๋ถ€์—์„œ signal์„ ๋ณด๋‚ธ๋‹ค. */ put_chopsticks(int i) { wait(mutex); state[i] = SLEEPING; check(LEFT); check(RIGHT); signal(mutex); } /* ** Solution */ do { ... THINKING ... take_chopsticks(i) ... EATING ... put_chopsticks(i); ... SLEEPING ... } while (1);
C
๋ณต์‚ฌ
ํ˜„์žฌ ์ƒํ™ฉ
โ€ข
์ฒ ํ•™์ž1(sleeping) ์ฒ ํ•™์ž2(Eating) ์ฒ ํ•™์ž3 ์ฒ ํ•™์ž4(sleeping) ์ฒ ํ•™์ž5(sleeping)
โ€ข
์ฒ ํ•™์ž3๊ฐ€ ์‹์‚ฌํ•  ์ˆ˜ ์žˆ๋Š”์ง€์— ๋Œ€ํ•œ ํŒ๋‹จ๊ณผ์ •์„ ํ™•์ธ
๊ณผ์ •
1.
์ฒ ํ•™์ž3๊ฐ€ take_chopsticksํ•จ์ˆ˜๋กœ ๋“ค์–ด๊ฐ
take_chopsticks(int i) { wait(mutex); state[์ฒ ํ•™์ž3] = THINKING; check(์ฒ ํ•™์ž3); signal(mutex); wait(philo[์ฒ ํ•™์ž3]); }
C
๋ณต์‚ฌ
โ€ข
wait(mutex)
์ฒ ํ•™์ž3 ๋ง๊ณ  ๋‹ค๋ฅธ ์ฒ ํ•™์ž์— ๋Œ€ํ•œ ์ƒํƒœ ์ ‘๊ทผ ๋ถˆ๊ฐ€
โ€ข
state[์ฒ ํ•™์ž3] = THINKING;
๋ฐฅ์„ ๋จน๊ธฐ ์ „์— THINKING
โ€ข
check(์ฒ ํ•™์ž3)
check(int i) { if (state[์ฒ ํ•™์ž3] == THINKING && state[์ฒ ํ•™์ž2] != EATING && state[์ฒ ํ•™์ž4] != EATING) { state[i] = EATING; signal(philo[i]); } }
C
๋ณต์‚ฌ
์ฒ ํ•™์ž2๊ฐ€ Eating์ด๊ธฐ ๋•Œ๋ฌธ์— ์กฐ๊ฑด๋ฌธ ์•ˆ์€ ํ™œ์„ฑํ™”๋˜์ง€ ์•Š๊ณ  ๋„˜์–ด๊ฐ
โ€ข
signal(mutex)
์ฒ ํ•™์ž3๊ฐ€ ์‹์‚ฌ๋ฅผ ํ•  ์ˆ˜ ์žˆ๊ธฐ ์œ„ํ•ด์„œ๋Š” ์ฒ ํ•™์ž2๊ฐ€ ์‹์‚ฌ๊ฐ€ ๋์ด ๋‚˜์•ผํ•˜๊ธฐ ๋•Œ๋ฌธ์— ๋‹ค๋ฅธ ์ฒ ํ•™์ž๋“ค์˜ ์ƒํƒœ์ ‘๊ทผ์„ ํ—ˆ์šฉํ•ด์คŒ
โ€ข
wait(philo[์ฒ ํ•™์ž3])
์ฒ ํ•™์ž2๊ฐ€ ์‹์‚ฌ๋ฅผ ๋งˆ์น ๋•Œ๊นŒ์ง€ ๊ธฐ๋‹ค๋ฆฐ๋‹ค
2.
์ฒ ํ•™์ž2๊ฐ€ put_chopsticksํ•จ์ˆ˜๋กœ ๋“ค์–ด๊ฐ
put_chopsticks(int i) { wait(mutex); state[์ฒ ํ•™์ž2] = SLEEPING; check(์ฒ ํ•™์ž1); check(์ฒ ํ•™์ž3); signal(mutex); }
C
๋ณต์‚ฌ
โ€ข
wait(mutex)
๋‹ค๋ฅธ ์ฒ ํ•™์ž ์ƒํƒœ์— ์ ‘๊ทผํ•˜์ง€ ๋ชปํ•˜๊ฒŒ guard
โ€ข
state[์ฒ ํ•™์ž2] = SLEEPING;
์ฒ ํ•™์ž2์˜ ์ƒํƒœ๋ฅผ sleeping
โ€ข
check(์ฒ ํ•™์ž1)
์ฒ ํ•™์ž1์ด sleeping์ด๊ธฐ ๋•Œ๋ฌธ์— ๊ทธ๋ƒฅ ๋„˜์–ด๊ฐ
โ€ข
check(์ฒ ํ•™์ž3)
check(int i) { if (state[์ฒ ํ•™์ž3] == THINKING && state[์ฒ ํ•™์ž2] != EATING && state[์ฒ ํ•™์ž4] != EATING) { state[i] = EATING; signal(philo[i]); } }
C
๋ณต์‚ฌ
์ด๋ ‡๊ฒŒ ๋‹ค์‹œ ์ฒ ํ•™์ž3์˜ ์ƒํƒœ๋ฅผ ํ™•์ธํ•˜๊ฒŒ ๋˜๊ณ  ์ฒ ํ•™์ž2๊ฐ€ Eating์—์„œ sleeping์ด ๋˜์—ˆ๊ธฐ ๋•Œ๋ฌธ์— ์ด์ œ ์ฒ ํ•™์ž3๋Š” ์‹์‚ฌ๋ฅผ ํ•  ์ˆ˜ ์žˆ๊ฒŒ ๋œ๋‹ค

context switch

โ€ข
ํ•˜๋‚˜์˜ ์ฝ”์–ด์—๋Š” ํ•˜๋‚˜์˜ ์ž‘์—…๋งŒ ์กด์žฌ
โ€ข
๋ชจ๋“  ํ”„๋กœ์„ธ์Šค๋ฅผ ์ฒ˜๋ฆฌํ•˜๊ธฐ ์œ„ํ•ด์„  ํ•˜๋‚˜์˜ ํ”„๋กœ์„ธ์Šค๋ฅผ ์ฒ˜๋ฆฌํ•˜๊ณ  ๊ทธ ๋‹ค์Œ ํ”„๋กœ์„ธ์Šค๊ฐ€ ์ฒ˜๋ฆฌํ•˜๋Š” ์‹์˜ ํ”„๋กœ์„ธ์Šค ๊ฐ„์˜ ์ „ํ™˜
โ€ข
Kernel์˜ Dispatcher๋ผ๋Š” ๊ณณ์—์„œ ์ผ์–ด๋‚˜๋ฉฐ PCB๋ผ๋Š” ์ž๋ฃŒ๊ตฌ์กฐ๊ฐ€ ํ•„์š”
โ€ข
Time Quantum์ด ๋ชจ๋‘ ์†Œ์ง„๋˜๊ฑฐ๋‚˜, Interrupt์— ์˜ํ•ด ๋ฐœ์ƒ
Time Quantum์€ ํ”„๋กœ์„ธ์Šค๊ฐ€ ํ•œ ๋ฒˆ์— ์ฒ˜๋ฆฌ๋  ์ˆ˜ ์žˆ๋Š” ์‹œ๊ฐ„ ์ด๋Ÿ‰์„ ์˜๋ฏธํ•œ๋‹ค. ์ผ๋ฐ˜์ ์œผ๋กœ ํ”„๋กœ์„ธ์Šค์—๊ฒŒ ํ• ๋‹น๋˜๋Š” Time Quantum์€ ์‚ฌ์šฉ์ž๊ฐ€ ์ฒด๊ฐํ•˜์ง€ ๋ชปํ•  ์ •๋„๋กœ ์ž‘๋‹ค. ๋•๋ถ„์— ํ•œ ๋ฒˆ์— ํ•˜๋‚˜์˜ ํ”„๋กœ์„ธ์Šค ๋ฐ–์— ์ฒ˜๋ฆฌํ•˜์ง€ ๋ชปํ•˜๋Š” ์ƒํ™ฉ์ž„์—๋„ ์‚ฌ์šฉ์ž๋Š” ๋ชจ๋“  ํ”„๋กœ์„ธ์Šค๊ฐ€ ๋™์‹œ์— ์ฒ˜๋ฆฌ๋˜๋Š” ๊ฒƒ์ฒ˜๋Ÿผ ๋А๋ผ๊ฒŒ ๋œ๋‹ค.
โ€ข
์ž‘์—…ํ•˜๋˜ ๋‚ด์šฉ์„ PCB์— ์ €์žฅํ•˜๊ณ  ์ž‘์—…ํ•˜๊ณ  ์‹ถ์€ ๋‚ด์šฉ์„ PCB๋กœ ๋ถ€ํ„ฐ ์ฝ์–ด๋“ค์ธ๋‹ค
Context Switch๋Š” Interrupt์— ์˜ํ•ด ๋ฐœ์ƒํ•˜์ง€๋งŒ ํ”„๋กœ์„ธ์Šค์˜ ๊ธฐ๋ก ์ž์ฒด๋Š” ์‹œ์Šคํ…œ ์ฝœ์— ๊ธฐ๋ฐ˜ํ•˜๋Š” ๊ฒƒ์„ ์•Œ ์ˆ˜ ์žˆ๋‹ค.
Context Switch ์ž์ฒด๋Š” ์œ„์—์„œ ์–ธ๊ธ‰๋œ ๊ฒƒ์ฒ˜๋Ÿผ Dispatcher์— ์˜ํ•ด์„œ ์ฒ˜๋ฆฌ๋˜๋Š”๋ฐ, ์ด๋Š” ๊ณง Dispatcher์˜ ํ˜ธ์ถœ๋กœ๋ถ€ํ„ฐ ์‹œ์ž‘๋œ๋‹ค. Dispatcher์˜ ํ˜ธ์ถœ์€ Interrupt์— ์˜ํ•ด ๋ฐœ์ƒํ•œ๋‹ค. Dispatcher๋ฅผ ํ˜ธ์ถœํ•˜๋Š” Interrupt๋Š” Preemptive Scheduling๊ณผ Non-Preemptive Scheduling์œผ๋กœ ๋‚˜๋‰œ๋‹ค. Time Quantum์„ ๋ชจ๋‘ ์†Œ์ง„ํ•˜์—ฌ ์šด์˜์ฒด์ œ ๊ถŒํ•œ์œผ๋กœ ํ”„๋กœ์„ธ์Šค์˜ ๊ถŒํ•œ์„ ๋บ์œผ๋ฉด์„œ ๋ฐœ์ƒํ•˜๋Š” Interrupt๊ฐ€ Preemptive Scheduling์ด๊ณ , I/O ํ˜ธ์ถœ๊ณผ ๊ฐ™์ด ํ”„๋กœ์„ธ์Šค๊ฐ€ ์Šค์Šค๋กœ CPU ์ ์œ ๋ฅผ ํฌ๊ธฐํ•˜๋ฉด์„œ ๋ฐœ์ƒํ•˜๋Š” Interrupt๊ฐ€ Non-Preemptive Scheduling์ด๋‹ค.
Preemptive / Non-preemptive
โ—ฆ
๋น„์„ ์ ํ˜• ์Šค์ผ€์ค„๋ง
์–ด๋–ค ํ”„๋กœ์„ธ์Šค๊ฐ€ CPU๋ฅผ ํ• ๋‹น ๋ฐ›์œผ๋ฉด ๊ทธ ํ”„๋กœ์„ธ์Šค๊ฐ€ ์ข…๋ฃŒ๋˜๊ฑฐ๋‚˜ IO request๊ฐ€ ๋ฐœ์ƒํ•˜์—ฌ ์ž๋ฐœ์ ์œผ๋กœ ๋Œ€๊ธฐ ์ƒํƒœ๋กœ ๋“ค์–ด๊ฐˆ ๋•Œ๊นŒ์ง€ ๊ณ„์† ์‹คํ–‰
์–ด๋–ค ํ”„๋กœ์„ธ์Šค๊ฐ€ ์ž‘์—…์„ ๋งˆ์น˜๊ณ  ์ž๋ฐœ์ ์œผ๋กœ ๋Œ€๊ธฐ ์ƒํƒœ๋กœ ๋“ค์–ด๊ฐ€๊ฑฐ๋‚˜ ์ข…๋ฃŒ๋˜๋Š” ๊ฒฝ์šฐ ๋‹ค๋ฅธ ํ”„๋กœ์„ธ์Šค๊ฐ€ ์‹คํ–‰
โ—ฆ
์„ ์ ํ˜• ์Šค์ผ€์ค„๋ง
์–ด๋–ค ํ”„๋กœ์„ธ์Šค๊ฐ€ ์‹คํ–‰๋˜๋‹ค time slice๋ฅผ ๋ชจ๋‘ ์‚ฌ์šฉํ•ด time-out๋˜๊ฑฐ๋‚˜, IO๊ฐ€ ๋ฐœ์ƒํ•˜๊ฑฐ๋‚˜, event๋ฅผ ๊ธฐ๋‹ค๋ ค์•ผ ํ•˜๋Š” ์ƒํ™ฉ์ด๋ผ๋ฉด ๋‹ค๋ฅธ ํ”„๋กœ์„ธ์Šค์—๊ฒŒ CPU ์‚ฌ์šฉ์„ ์–‘๋ณด
ํ”„๋กœ์„ธ์Šค๋ฅผ ์ซ’์•„ ๋‚ด๊ณ  CPU์ž์›์„ ์„ ์ ํ•  ์ˆ˜ ์žˆ๋‹ค๋Š” ๋œป
ํ˜„์žฌ OS๋Š” ๋Œ€๋ถ€๋ถ„ ์‹œ๋ถ„ํ•  ์„ ์ ํ˜• ์Šค์ผ€์ฅด๋ง์„ ์‚ฌ์šฉ. ๋น„์„ ์ ํ˜•์€ ํ•ด๋‹น ์ž‘์—…์ด ๋๋‚  ๋•Œ ๊นŒ์ง€ ๊ณ„์† ์‹คํ–‰๋˜๊ธฐ ๋•Œ๋ฌธ์— ๋ฉ€ํ‹ฐ ํ”„๋กœ์„ธ์Šค ํ™˜๊ฒฝ์—์„œ ์‘๋‹ต์„ฑ์„ ๊ธฐ๋Œ€ํ•  ์ˆ˜ ์—†๋‹ค

User mode & kernel mode

ํ”„๋กœ์„ธ์Šค์—์„œ instruction์„ ์ˆ˜ํ–‰ํ• ๋•Œ usermode ์™€ kernelmode์— ๋”ฐ๋ผ์„œ cpu ์‹คํ–‰์ด ๋‹ฌ๋ผ์ง
User Mode์˜ ํ”„๋กœ์„ธ์Šค๋Š” ๋Œ€์ฒด์ ์œผ๋กœ ์‚ฌ์šฉ์ž์— ์˜ํ•ด ๊ตฌ๋™๋œ ์–ดํ”Œ๋ฆฌ์ผ€์ด์…˜์ด๋ฉฐ, Instruction์— ๋Œ€ํ•ด ๋ฒ”์šฉ์ ์ธ ๊ถŒํ•œ์„ ๊ฐ–๊ณ ๋Š” ์žˆ์ง€๋งŒ Kernel Mode ๋งŒํผ์˜ ๊ถŒํ•œ์„ ๊ฐ–์ง€๋Š” ๋ชปํ•œ๋‹ค.

trap & interrupt

1.
trap
โ€ข
๋™๊ธฐ์  ์ด๋ฒคํŠธ ์ฒ˜๋ฆฌ
โ€ข
ํ˜„์žฌ ์ฒ˜๋ฆฌํ•˜๊ณ  ์žˆ๋Š” ํ”„๋กœ๊ทธ๋žจ์— ์˜ํ•ด ๋ฐœ์ƒ
โ€ข
์ฃผ๋กœ ์‹œ์Šคํ…œ์ฝœ ์ฒ˜๋ฆฌ
โ€ข
trap handler์— ์˜ํ•ด ์ฒ˜๋ฆฌ
โ€ข
trap์ด ๋ฐœ์ƒํ•˜๊ฒŒ ๋˜๋ฉด ๊ทธ ๋…€์„์ด ๋‹ค ์ฒ˜๋ฆฌ๋˜๊ณ  ๋‚˜์•ผ ๋‹ค๋ฅธ ํ”„๋กœ๊ทธ๋žจ์„ ์ฒ˜๋ฆฌํ•˜๊ธฐ ๋•Œ๋ฌธ์— context๋ฅผ ์ €์žฅํ•  ํ•„์š”๋„ ์—†๊ณ  sp์™€ pc๋งŒ์„ ์ด์šฉํ•˜์—ฌ ๊ธฐ์กด์— ์ˆ˜ํ–‰ํ•˜๋˜ ๋™์ž‘์œผ๋กœ ๋ณต๊ท€ ๊ฐ€๋Šฅ
2.
interrupt
โ€ข
๋น„๋™๊ธฐ์  ์ด๋ฒคํŠธ ์ฒ˜๋ฆฌ
โ€ข
๋„คํŠธ์›Œํฌ ํŒจํ‚ท ๋„์ฐฉ ํ˜น์€ I/O์— ๋Œ€ํ•œ ์ด๋ฒคํŠธ ์ฒ˜๋ฆฌ
โ€ข
ํ•˜๋“œ์›จ์–ด์— ์˜ํ•ด ๋ฐœ์ƒ. ํ•˜๋“œ์›จ์–ด์˜ ์šฐ์„  ์ˆœ์œ„์— ๋”ฐ๋ผ ์šฐ์„  ์ˆœ์œ„ ๊ฒฐ์ •
โ€ข
ํ•˜๋“œ์›จ์–ด๋“ค์ด ๋™์‹œ์— interrupt๋ฅผ ๊ฑธ์–ด๋„ ์ฒ˜๋ฆฌ ๊ฐ€๋Šฅ
โ€ข
interrupt handler์— ์˜ํ•ด ์ฒ˜๋ฆฌ
โ€ข
interrupt๋ฅผ ์ฒ˜๋ฆฌํ•œ ๋’ค ๋ณต๊ท€ํ•ด์•ผ ํ•˜๋Š” ํ”„๋กœ์„ธ์Šค๊ฐ€ ํ˜„์žฌ ํ”„๋กœ์„ธ์Šค๊ฐ€ ์•„๋‹ ์ˆ˜ ์žˆ๊ธฐ ๋•Œ๋ฌธ์— context์— ๋Œ€ํ•œ ๊ธฐ๋ก์ด ์š”๊ตฌ๋จ
3.
ํŠน์ง•
Trap์˜ ๊ฒฝ์šฐ์—๋Š” Trap Service Routine ๋‚ด์—์„œ ์ฒ˜๋ฆฌ ๋„์ค‘์— Interrupt๋ฅผ ๋ฐ›์„ ์ˆ˜๋„ ์žˆ์ง€๋งŒ, Interrupt์˜ ๊ฒฝ์šฐ์—๋Š” Interrupt Service Routine ๋‚ด์—์„œ ์ฒ˜๋ฆฌ ๋„์ค‘์— Inetrrupt๋ฅผ ๋ฐ›์„ ์ˆ˜ ์—†๊ฒŒ ๋˜์–ด ์žˆ๋‹ค. ์ด๋Š” Interrupt์˜ Depth๊ฐ€ ๊นŠ์–ด์ง์— ๋”ฐ๋ผ ํ•˜๋‚˜์˜ Interrupt๊ฐ€ ๋๋‚˜๋Š”๋ฐ ๊ธด ์‹œ๊ฐ„์ด ์š”๊ตฌ๋˜๋Š” ๊ตฌ์กฐ๊ฐ€ ๋  ์ˆ˜ ์žˆ๊ธฐ ๋•Œ๋ฌธ์ด๋‹ค. ๋”ฐ๋ผ์„œ Interrupt๋ฅผ ์ฒ˜๋ฆฌํ•  ๋•Œ ๋‹ค๋ฅธ Interrupt๋“ค๋„ ์ฒ˜๋ฆฌํ•  ์ˆ˜ ์žˆ๋„๋ก Interrupt Serivce Routine์€ ์ตœ๋Œ€ํ•œ ์งง๊ฒŒ ์ˆ˜ํ–‰๋˜๋„๋ก ์„ค๊ณ„ ๋˜์–ด ์žˆ๋‹ค.
Trap์€ ํ”„๋กœ์„ธ์Šค์˜ Context๋ฅผ ์ €์žฅํ•˜์ง€ ์•Š์•„๋„ ๋œ๋‹ค๋Š” ๋ฉด์—์„œ Interrupt๋ณด๋‹ค ๊ฐ€๋ณ์ง€๋งŒ Trap์— ๋Œ€ํ•œ ์ฒ˜๋ฆฌ๊ฐ€ ์™„๋ฃŒ๋  ๋•Œ๊นŒ์ง€ Block๋œ๋‹ค๋Š” ํŠน์ง•์ด ์žˆ๋‹ค. Interrupt๋Š” Trap์˜ ๋ฐ˜๋Œ€์˜ ํŠน์ง•์„ ๊ฐ–๊ณ  ์žˆ๋‹ค๊ณ  ๋ณด๋ฉด ๋œ๋‹ค.
๋งŒ์ผ Interrupt๊ฐ€ ๋™์‹œ์— ๋ฐœ์ƒํ•˜๋ฉด ์šฐ์„  ์ˆœ์œ„์— ๋”ฐ๋ผ ์ฒ˜๋ฆฌํ•œ๋‹ค๊ณ  ํ–ˆ๋Š”๋ฐ, ๋™์ผํ•œ ์šฐ์„  ์ˆœ์œ„๋ฅผ ๊ฐ€์ง„ Interrupt๋ฅผ ๋ฐ›๊ฒŒ ๋˜๋ฉด ์šด์˜์ฒด์ œ์™€ ํ•˜๋“œ์›จ์–ด์— ์˜ํ•ด ํ•˜๋‚˜์˜ Interrupt๋ฅผ ์ฒ˜๋ฆฌํ•˜๊ณ  ๋‚˜๋จธ์ง€ Interrupt๋Š” ์ €์žฅํ•ด๋‘๊ฑฐ๋‚˜ ๋ฌด์‹œํ•˜๊ฒŒ ๋œ๋‹ค.

๊ฐœ๋ฐœ์ผ์ง€

์ž…๋ ฅ๊ฐ’

./philo number_of_philosophers time_to_die time_to_eat time_to_sleep {number_of_times_each_philosopher_must_eat}
Shell
๋ณต์‚ฌ
number_of_philosophers: ์ฒ ํ•™์ž์˜ ์ˆ˜์™€ ํฌํฌ์˜ ์ˆ˜์ด๋‹ค.
time_to_die: ๋ฐ€๋ฆฌ ์ดˆ ๋‹จ์œ„์ด๋ฉฐ, ๋งŒ์•ฝ ์ฒ ํ•™์ž๊ฐ€ ๋งˆ์ง€๋ง‰ ์‹์‚ฌ๋ฅผ ์‹œ์ž‘ํ•˜๊ฑฐ๋‚˜ ์‹œ๋ฎฌ๋ ˆ์ด์…˜์„ ์‹œ์ž‘ํ•œ ํ›„ 'time_to_die' miliseconds๋ฅผ ๋จน๊ธฐ ์‹œ์ž‘ํ•˜์ง€ ์•Š๋Š”๋‹ค๋ฉด ์ฃฝ๋Š”๋‹ค.
time_to_eat: ๋ฐ€๋ฆฌ ์ดˆ ๋‹จ์œ„์ด๋ฉฐ, ์ฒ ํ•™์ž๊ฐ€ ์‹์‚ฌํ•˜๋Š” ๋ฐ ๊ฑธ๋ฆฌ๋Š” ์‹œ๊ฐ„์ด๋‹ค. ๊ทธ ์‹œ๊ฐ„ ๋™์•ˆ ๊ทธ๋Š” ํฌํฌ ๋‘๊ฐœ๋ฅผ ์œ  ์ง€ํ•ด์•ผ ํ•  ๊ฒƒ์ด๋‹ค.
time_to_sleep: ๋ฐ€๋ฆฌ ์ดˆ ๋‹จ์œ„์ด๋ฉฐ, ์ฒ ํ•™์ž๊ฐ€ ์ž ์„ ์ž๋Š” ๋ฐ ์“ฐ๋Š” ์‹œ๊ฐ„์ด๋‹ค.
number_of_times_each_philosopher_must_eat: ๋…ผ์Ÿ์€ ์„ ํƒ์‚ฌํ•ญ์ด๋ฉฐ, ๋งŒ์•ฝ ๋ชจ๋“  ์ฒ ํ•™์ž๋“ค์ด ์ ์–ด๋„ 'number_of_times_each_philosopher_must_eat'์„ ๋จน๋Š”๋‹ค๋ฉด, ์‹œ๋ฎฌ๋ ˆ์ด์…˜์€ ์ค‘๋‹จ๋  ๊ฒƒ์ด๋‹ค. ๊ตฌ์ฒด์ ์œผ๋กœ ๋ช…์‹œํ•˜์ง€ ์•Š์œผ๋ฉด, ์‹œ๋ฎฌ๋ ˆ์ด์…˜์€ ์ฒ ํ•™์ž๊ฐ€ ์‚ฌ๋ง ํ•  ๋•Œ๋งŒ ์ค‘๋‹จ๋  ๊ฒƒ์ž…๋‹ˆ๋‹ค.

Pseudo code

์ธ์ž๊ฐ’ ๊ตฌ์กฐ์ฒด์— ์ดˆ๊ธฐํ™”() { ์ธ์ž๊ฐ’ atoi() ์ฒ ํ•™์ž ์ˆ˜๋งŒํผ mutex์ƒ์„ฑ() } ์ธ์ž๊ฐ’๊ตฌ์กฐ์ฒด๋ฅผ ์ฒ ํ•™์ž ๊ตฌ์กฐ์ฒด์— ์ดˆ๊ธฐํ™”() { int main() { ์ธ์ž๊ฐœ์ˆ˜ ์œ ํšจ์„ฑ์ฒดํฌ() ์ธ์ž๊ฐ’ ๊ตฌ์กฐ์ฒด์— ์ดˆ๊ธฐํ™”() ์ธ์ž๊ฐ’๊ตฌ์กฐ์ฒด๋ฅผ ์ฒ ํ•™์ž ๊ตฌ์กฐ์ฒด์— ์ดˆ๊ธฐํ™”()
C
๋ณต์‚ฌ

mutex ๊ฑธ์–ด์•ผ ํ•˜๋Š” ์ด์œ 

#include <stdio.h> #include <pthread.h> #include <unistd.h> #include <stdlib.h> pthread_mutex_t m; void *t_function(void *data) { pid_t pid; // process id pthread_t tid; // thread id pid = getpid(); tid = pthread_self(); char* thread_name = (char*)data; int i = 0; pthread_mutex_lock(&pm); while (i < 5) // 0,1,2 ๊นŒ์ง€๋งŒ loop ๋Œ๋ฆฝ๋‹ˆ๋‹ค. { // ๋„˜๊ฒจ๋ฐ›์€ ์“ฐ๋ ˆ๋“œ ์ด๋ฆ„๊ณผ // ํ˜„์žฌ process id ์™€ thread id ๋ฅผ ํ•จ๊ป˜ ์ถœ๋ ฅ printf("[%s] pid:%u, tid:%x --- %d\n", thread_name, (unsigned int)pid, (unsigned int)tid, i); i++; sleep(1); // 1์ดˆ๊ฐ„ ๋Œ€๊ธฐ } pthread_mutex_unlock(&m); } int main() { pthread_t p_thread[2]; int thr_id; int status; char p1[] = "thread_1"; char p2[] = "thread_2"; char pM[] = "thread_m"; sleep(1); pthread_mutex_init(&m, NULL); thr_id = pthread_create(&p_thread[0], NULL, t_function, (void *)p1); if (thr_id < 0) { perror("thread create error : "); exit(0); } thr_id = pthread_create(&p_thread[1], NULL, t_function, (void *)p2); if (thr_id < 0) { perror("thread create error : "); exit(0); } while(1) ; pthread_join(p_thread[0], (void **)&status); pthread_join(p_thread[1], (void **)&status); printf("์–ธ์ œ ์ข…๋ฃŒ ๋ ๊นŒ์š”?\n"); return (0); }
C
๋ณต์‚ฌ
#include <stdio.h> #include <pthread.h> #include <unistd.h> #include <stdlib.h> pthread_mutex_t m; void *t_function(void *data) { pid_t pid; // process id pthread_t tid; // thread id pid = getpid(); tid = pthread_self(); char* thread_name = (char*)data; int i = 0; // pthread_mutex_lock(&m); while (i < 5) // 0,1,2 ๊นŒ์ง€๋งŒ loop ๋Œ๋ฆฝ๋‹ˆ๋‹ค. { // ๋„˜๊ฒจ๋ฐ›์€ ์“ฐ๋ ˆ๋“œ ์ด๋ฆ„๊ณผ // ํ˜„์žฌ process id ์™€ thread id ๋ฅผ ํ•จ๊ป˜ ์ถœ๋ ฅ printf("[%s] pid:%u, tid:%x --- %d\n", thread_name, (unsigned int)pid, (unsigned int)tid, i); i++; sleep(1); // 1์ดˆ๊ฐ„ ๋Œ€๊ธฐ } // pthread_mutex_unlock(&m); } int main() { pthread_t p_thread[2]; int thr_id; int status; char p1[] = "thread_1"; char p2[] = "thread_2"; char pM[] = "thread_m"; sleep(1); pthread_mutex_init(&m, NULL); thr_id = pthread_create(&p_thread[0], NULL, t_function, (void *)p1); //pthread_detach(p_thread[0]); if (thr_id < 0) { perror("thread create error : "); exit(0); } thr_id = pthread_create(&p_thread[1], NULL, t_function, (void *)p2); //pthread_detach(p_thread[1]); if (thr_id < 0) { perror("thread create error : "); exit(0); } while(1) ; pthread_join(p_thread[0], (void **)&status); pthread_join(p_thread[1], (void **)&status); printf("์–ธ์ œ ์ข…๋ฃŒ ๋ ๊นŒ์š”?\n"); return (0); }
C
๋ณต์‚ฌ
โ€ข
mutex๋ฅผ ๊ฑธ์–ด์ฃผ๋ฉด thread1์ด ๋จผ์ € ๋‹ค ๋Œ๊ณ  thread2๊ฐ€ ๋„๋Š” ๊ฒƒ์„ ์•Œ ์ˆ˜ ์žˆ๋‹ค

์“ฐ๋ ˆ๋“œ๋ž€?

pthread_detach์™€ pthread_join์˜ ์ฐจ์ด

๋‘˜๋‹ค ํ•จ์ˆ˜๊ฐ€ ๋์ด๋‚˜๋ฉด ์ž์›ํ•ด์ œ๋ฅผ ํ•ด์คŒ. thread์‹œ์ž‘์„ ํ–ˆ์œผ๋ฉด ์ž์›ํ•ด์ œ๋ฅผ ๋ฌด์กฐ๊ฑด ํ•ด์ค˜์•ผํ•จ
join
โ€ข
join์€ ๊ทธ ํ•ด๋‹น ์“ฐ๋ ˆ๋“œ๊ฐ€ ๋๋‚ ๋•Œ๊นŒ์ง€ ๋Œ€๊ธฐ. ๋ฆฌํ„ด๊ฐ’์„ ๋ฐ›์•„์˜ด
#include <pthread.h> #include <stdio.h> #include <unistd.h> #include <stdlib.h> // ์“ฐ๋ ˆ๋“œ ํ•จ์ˆ˜ // 1์ดˆ๋ฅผ ๊ธฐ๋‹ค๋ฆฐํ›„ (๋งค๊ฐœ๋ณ€์ˆ˜*๋งค๊ฐœ๋ณ€์ˆ˜)๋ฅผ ๋ฆฌํ„ดํ•ฉ๋‹ˆ๋‹ค void *t_function(void *data) { int num = *((int *)data); printf("num %d\n", num); sleep(1); num *= num; printf("์“ฐ๋ ˆ๋“œ ํ•จ์ˆ˜ ์ข…๋ฃŒ ํ•ฉ๋‹ˆ๋‹ค\n"); return (void *)(num); // warning ๋ฐœ์ƒ } int main() { pthread_t p_thread; int thr_id; int result; int a = 200; thr_id = pthread_create(&p_thread, NULL, t_function, (void *)&a); if (thr_id < 0) { perror("thread create error : "); exit(0); } // ์“ฐ๋ ˆ๋“œ ์‹๋ณ„์ž p_thread ๊ฐ€ ์ข…๋ฃŒ๋˜๊ธธ ๊ธฐ๋‹ค๋ ธ๋‹ค๊ฐ€ // ์ข…๋ฃŒํ›„์— ๋ฆฌํ„ด๊ฐ’์„ ๋ฐ›์•„์˜ต๋‹ˆ๋‹ค. //pthread_join(p_thread, (void *)&result); printf("thread join : %d\n", result); printf("main() ์ข…๋ฃŒ\n"); return 0; }
C
๋ณต์‚ฌ
pthread_join x
pthread_join o
detach๋Š” ๋ฉ”์ธ ์“ฐ๋ ˆ๋“œ์—์„œ ๋ถ„๋ฆฌ๋˜์–ด ๋ฉ”์ธ ์“ฐ๋ ˆ๋“œ๊ฐ€ ๋๋‚˜๋ฉด ์ข…๋ฃŒ. ์ด๊ฒƒ์„ ๋ง‰๊ธฐ ์œ„ํ•ด ์ ์ ˆํ•œ mutex lock ํ•„์š”. join๊ณผ ๋‹ค๋ฅด๊ฒŒ ๋ฐ”๋กœ ๋‹ค์Œ ๋ช…๋ น์ด ์‹คํ–‰
pthread_detach, pthread_join ์ฐจ์ด์ 
ํ•˜์ง€๋งŒ ๋ณด์กฐ์Šค๋ ˆ๋“œ๊ฐ€ ์ข…๋ฃŒ๋˜์—ˆ๋‹ค๊ณ  ํ•˜์—ฌ ์ž์›๊นŒ์ง€ ๋ฐ˜ํ™˜ํ•˜๋Š” ๊ฒƒ์€ ์•„๋‹ˆ๋‹ค. -> ๋ฉ”๋ชจ๋ฆฌ ๋ฆญ์œผ๋กœ ๋‚จ๊ฒŒ๋œ๋‹ค. pthread_join์„ ํ†ตํ•˜์—ฌ ์ •์ƒ์ ์œผ๋กœ ์ข…๋ฃŒ๋œ ๋ณด์กฐ์Šค๋ ˆ๋“œ์˜ ์ž์›์„ ์ •์ƒ์ ์œผ๋กœ ๋ฐ˜ํ™˜์‹œ์ผœ์ฃผ๋ฉฐ, ptrhead_detachํ•จ์ˆ˜๋ฅผ ํ†ตํ•˜์—ฌ ์Šค๋ ˆ๋“œ๊ฐ€ ์ข…๋ฃŒ์‹œ ์ž์›์„ ์ •์ƒ์ ์œผ๋กœ ๋ฐ˜ํ™˜์‹œ์ผœ์ฃผ๋„๋ก ํ•˜๋Š” ํ•จ์ˆ˜๋กœ ๋ฉ”๋ชจ๋ฆฌ๋ฆญ์„ ๋ฐฉ์ง€ํ•  ์ˆ˜ ์žˆ๋‹ค. pthread_detach ์ƒ์„ฑ๋œ thread์—์„œ pthread_detach๋ฅผ ํ•˜๋ฉด joinํ•  ํ•„์š”์—†์ด ์ƒ์„ฑ๋œ thread๊ฐ€ ํ• ์ผ์„ ๋‹ค ๋งˆ์น˜๊ณ  pthread_exit๋ฅผ ํ•˜๋Š” ์ˆœ๊ฐ„ ์ž์›์ด OS์— ๋ฐ˜๋‚ฉ(๋ณด์žฅ๋จ) --> detach(๋–ผ์–ด๋‚ด๋‹ค), ์ƒ์„ฑ๋œ ์Šค๋ ˆ๋“œ๋ฅผ ๋ฉ”์ธ ์Šค๋ ˆ๋“œ์—์„œ ๋ถ„๋ฆฌ์‹œํ‚จ๋‹ค.