๋ณธ ๊ฒ์๊ธ์ KOCW ์ดํ์ฌ์๋ํ๊ต ๋ฐํจ๊ฒฝ ๊ต์๋์ <์ด์์ฒด์ > ๊ฐ์๋ฅผ ๋ฃ๊ณ ,
<ํผ์ ๊ณต๋ถํ๋ ์ปดํจํฐ๊ตฌ์กฐ + ์ด์์ฒด์ > ์ฑ ์ ์ฐธ๊ณ ํ์ฌ ์ ๋ฆฌํ ๋ด์ฉ์ ๋๋ค.
๊ฒ์๊ธ์ ํฌํจ๋๋ ์ด๋ฏธ์ง ์๋ฃ๋ <์ด์์ฒด์ > ๊ฐ์์ ํฌํจ๋ ๊ฐ์ ์๋ฃ์ ๋๋ค.
ํ๋ก์ธ์ค ๊ณ์ธต๊ตฌ์กฐ
ํ๋ก์ธ์ค๋ ์คํ ๋์ค ์์คํ ํธ์ถ์ ํตํด ๋ค๋ฅธ ํ๋ก์ธ์ค๋ฅผ ์์ฑํ ์ ์์ต๋๋ค.
์ด๋ ์ ํ๋ก์ธ์ค๋ฅผ ์์ฑํ ํ๋ก์ธ์ค๋ฅผ ๋ถ๋ชจ ํ๋ก์ธ์ค(parent process), ๋ถ๋ชจ ํ๋ก์ธ์ค์ ์ํด ์์ฑ๋ ํ๋ก์ธ์ค๋ฅผ ์์ ํ๋ก์ธ์ค(child process)๋ผ๊ณ ํฉ๋๋ค.
๋ถ๋ชจ ํ๋ก์ธ์ค๋ก๋ถํฐ ์์ฑ๋ ์์ ํ๋ก์ธ์ค๋ ์คํ ๊ณผ์ ์์ ๋ ๋ค๋ฅธ ์์ ํ๋ก์ธ์ค๋ฅผ ์์ฑํ ์ ์๊ณ , ๊ทธ ์์ ํ๋ก์ธ์ค๋ ์์ ํ๋ก์ธ์ค๋ฅผ ์์ฑํ ์ ์์ต๋๋ค. ๋ง์ ์ด์์ฒด์ ๋ ์ด์ฒ๋ผ ํ๋ก์ธ์ค๊ฐ ํ๋ก์ธ์ค๋ฅผ ๋ณ๋ ๊ณ์ธต์ ์ธ ๊ตฌ์กฐ(= ํธ๋ฆฌ ๊ตฌ์กฐ)๋ก์จ ํ๋ก์ธ์ค๋ค์ ๊ด๋ฆฌํฉ๋๋ค.
ํ๋ก์ธ์ค ์์ฑ
๋จผ์ ํ๋ก์ธ์ค ์์ฑ ๊ณผ์ ์ ์์ฝ๋ถํฐ ํ์๋ฉด, fork์ exec๋ฅผ ํตํด ์๋ก์ด ํ๋ก์ธ์ค๊ฐ ์์ฑ๋ฉ๋๋ค.
๋ถ๋ชจ ํ๋ก์ธ์ค๋ fork๋ฅผ ํตํด ์์ ์ ๋ณต์ฌ๋ณธ์ ์์ ํ๋ก์ธ์ค๋ก ์์ฑํด๋ด๊ณ , ๋ง๋ค์ด์ง ๋ณต์ฌ๋ณธ(์์ ํ๋ก์ธ์ค)์ exec๋ฅผ ํตํด ์์ ์ ๋ฉ๋ชจ๋ฆฌ ๊ณต๊ฐ์ ๋ค๋ฅธ ํ๋ก๊ทธ๋จ์ผ๋ก ๊ต์ฒด(๋ฎ์ด์์ฐ๊ธฐ)ํ๋ ๋ฐฉ์์ผ๋ก ์๋ก์ด ํ๋ก์ธ์ค๋ฅผ ์์ฑํฉ๋๋ค.
ํ๋ก์ธ์ค ์์ฑ ๊ณผ์
1. ํ๋ก์ธ์ค์ ์ฃผ์ ๊ณต๊ฐ์ ๋ณต์ฌํด์ ์์ ํ๋ก์ธ์ค ์์ฑ
- ์ด๋, ๋ถ๋ชจ์ context (๋ฉ๋ชจ๋ฆฌ - code, data, stack / CPU - Program Counter, Register) ๋ฅผ ๊ทธ๋๋ก ๋ณต์ฌ
2. ์์์ ๊ทธ ๊ณต๊ฐ์ ์๋ก์ด ํ๋ก๊ทธ๋จ์ ์ฌ๋ฆผ
์ ๋์ค์ ์
1. fork() ์์คํ ์ฝ์ด ์๋ก์ด ํ๋ก์ธ์ค๋ฅผ ์์ฑ
- ๋ถ๋ชจ๋ฅผ ๊ทธ๋๋ก ๋ณต์ฌ (PID์ ์ธํ OS data + binary)
- ์ฃผ์ ๊ณต๊ฐ ํ ๋น
2. exec() ์์คํ ์ฝ์ ํตํด ์๋ก์ด ํ๋ก๊ทธ๋จ์ ๋ฉ๋ชจ๋ฆฌ์ ์ฌ๋ฆผ
fork() ์์คํ ์ฝ
์๋ก์ด ํ๋ก์ธ์ค๋ fork() ์์คํ ์ฝ์ ์ํด ์์ฑ๋ฉ๋๋ค.
์ด๋, ์์คํ ์ฝ์ ํธ์ถํ ํ๋ก์ธ์ค๋ฅผ ์๋ก์ด ์ฃผ์๊ณต๊ฐ์ ๊ทธ๋๋ก ๋ณต์ฌํ์ฌ ์๋ก์ด ํ๋ก์ธ์ค๋ฅผ ์์ฑํ๊ฒ ๋ฉ๋๋ค.
int main() {
int pid;
pid = fork(); // fork() ํธ์ถ -> ํ๋ก์ธ์ค ์์ฑ
if (pid == 0) /* this is child */
printf("\n Hello, I am child!\n");
else if (pid > 0) /* this is parent */
printf("\n Hello, I am parent!\n");
}
fork()์ ๋ฆฌํด ๊ฐ(= pid)์ด ๋ค๋ฅด๊ธฐ ๋๋ฌธ์ ์์ ํ๋ก์ธ์ค์ ๋ถ๋ชจ ํ๋ก์ธ์ค๋ฅผ ๊ตฌ๋ถํ ์ ์์ต๋๋ค.(๋ถ๋ชจ์ pid > 0, ์์์ pid == 0)
fork() ํจ์๋ฅผ ์คํํ๊ฒ ๋๋ฉด ์์ ํ๋ก์ธ์ค๋ฅผ ์์ฑํ๊ฒ ๋๋๋ฐ, ์์ ํ๋ก์ธ์ค๋ ๋ถ๋ชจ ํ๋ก์ธ์ค์ context๋ฅผ ๊ทธ๋๋ก ๋ณต์ฌํ๊ธฐ ๋๋ฌธ์ ์์ ํ๋ก์ธ์ค์์๋ fork() ์ดํ์ ์ฝ๋๋ถํฐ ์คํ๋ฉ๋๋ค.
exec() ์์คํ ์ฝ
exec() ์์คํ ์ฝ์ ์ด๋ค ํ๋ก๊ทธ๋จ์ ์์ ํ ์๋ก์ด ํ๋ก์ธ์ค๋ก ํ์ด๋๊ฒ ํ๋ ์ญํ ์ ํด์ค๋๋ค.
int main() {
int pid;
pid = fork();
if (pid == 0) {
printf("\n Hello, I am child!\n"); /* this is child */
execlp("/bin/date", "/bin/date", (char *)0); // ์๋ก์ด ํ๋ก๊ทธ๋จ์ผ๋ก ๋ฎ์ด์์
printf("-----"); // ์คํ๋์ง ์์
}
else if (pid > 0) /* this is child */
printf("\n Hello, I am parent!\n");
}
์์ ์ฝ๋์์ excelp()๋ฅผ ๋ง๋๊ฒ ๋๋ฉด fork()๋ก ์์ฑํ ํ๋ก์ธ์ค๋ฅผ ์๋ก์ด ํ๋ก๊ทธ๋จ์ผ๋ก ๋ฎ์ด์์ฐ๊ฒ ๋ฉ๋๋ค.
์๋ก์ด ํ๋ก๊ทธ๋จ์ ์์๋ถ๋ถ๋ถํฐ ์คํ๋๊ธฐ ๋๋ฌธ์ exec() ์ดํ์ ์ฝ๋๋ ์คํ๋์ง ์์ต๋๋ค.
wait() ์์คํ ์ฝ
wait() ์์คํ ์ฝ์ ๋ณดํต ์์ ํ๋ก์ธ์ค๋ฅผ ๋ง๋ ๋ค์์ ํธ์ถํ๊ฒ ๋๋ ํจ์์ ๋๋ค.
ํ๋ก์ธ์ค A๊ฐ wait() ์์คํ ์ฝ์ ํธ์ถํ๋ฉด, A๋ ์์ ํ๋ก์ธ์ค์ ์ฝ๋๊ฐ ๋ชจ๋ ์คํ๋๊ณ ์ข ๋ฃ๋ ๋๊น์ง blocked ์ํ๊ฐ ๋ฉ๋๋ค.
์์ ํ๋ก์ธ์ค๊ฐ ์ข ๋ฃ๋๋ฉด ์ปค๋์ ํ๋ก์ธ์ค A๋ฅผ ๊นจ์ A๋ blocked ์ํ์์ ready ์ํ๋ก ๋ณ๊ฒฝ๋ฉ๋๋ค.
int main() {
int pid;
pid = fork();
if (pid == 0) /* this is child */
printf("\n Hello, I am child!\n");
else
wait();
}
wait()๋ฅผ ํตํด ๋ถ๋ชจ์ ์์์ด ๋์์ CPU ๋ฑ ์์์ ์ป์ผ๋ ค๊ณ ๊ฒฝ์ํ์ง ์๊ณ , ์์์ด ์ข ๋ฃ๋์ด์ผ ๋ถ๋ชจ๊ฐ ์คํ๋๋๋ก ํ ์ ์์ต๋๋ค.
ํ๋ก์ธ์ค ์ข ๋ฃ
ํ๋ก์ธ์ค๊ฐ ๋ง์ง๋ง ๋ช ๋ น์ ์ํํ ํ ์ด์์ฒด์ ์๊ฒ exit() ์์คํ ์ฝ์ ํตํด ์๋ฆผ์ผ๋ก์จ ํ๋ก์ธ์ค๊ฐ ์ข ๋ฃ๋ฉ๋๋ค.
ํน์ ๋ถ๋ชจ ํ๋ก์ธ์ค๊ฐ ์์์ ์ํ์ ๊ฐ์ ์ ์ผ๋ก ์ข ๋ฃ์ํค๋ ๊ฒฝ์ฐ๋ ์์ต๋๋ค. (abort๋ฅผ ํตํด)
1. ํ๋ก์ธ์ค๊ฐ ๋ง์ง๋ง ๋ช ๋ น์ ์ํํ ํ ์ด์์ฒด์ ์๊ฒ ์ด๋ฅผ ์๋ ค์ฃผ๋ ๊ฒฝ์ฐ (exit)
- ์์์ด ๋ถ๋ชจ์๊ฒ output data๋ฅผ ๋ณด๋ (wait ์์คํ ์ฝ์ ํตํด)
- ํ๋ก์ธ์ค์ ๊ฐ์ข ์์๋ค์ด ์ด์์ฒด์ ์๊ฒ ๋ฐ๋ฉ๋จ
2. ๋ถ๋ชจ ํ๋ก์ธ์ค๊ฐ ์์์ ์ํ์ ์ข ๋ฃ์ํค๋ ๊ฒฝ์ฐ (abort)
- ์์์ด ํ ๋น ์์์ ํ๊ณ์น๋ฅผ ๋์ด์ค ๋
- ์์์๊ฒ ํ ๋น๋ ํ์คํฌ๊ฐ ๋ ์ด์ ํ์ํ์ง ์์ ๋
- ๋ถ๋ชจ๊ฐ ์ข ๋ฃ(exit)ํ๋ ๊ฒฝ์ฐ
- ์ด์์ฒด์ ๋ ๋ถ๋ชจ ํ๋ก์ธ์ค๊ฐ ์ข ๋ฃํ๋ ๊ฒฝ์ฐ ์์์ด ๋ ์ด์ ์ํ๋๋๋ก ๋์ง ์๋๋ค.
- ๋จ๊ณ์ ์ธ ์ข ๋ฃ
exit() ์์คํ ์ฝ
exit() ์์คํ ์ฝ์ ํ๋ก์ธ์ค๋ฅผ ์ข ๋ฃ์ํฌ ๋ ํธ์ถํ๋ ์์คํ ์ฝ์ ๋๋ค. (์๋ฐ์ ์ข ๋ฃ)
์๋ฐ์ ์ข ๋ฃ
- ๋ง์ง๋ง statement ์ํ ํ exit() ์์คํ ์ฝ์ ํตํด
- ํ๋ก๊ทธ๋จ์ ๋ช ์์ ์ผ๋ก ์ ์ด์ฃผ์ง ์์๋ main ํจ์๊ฐ ๋ฆฌํด๋๋ ์์น์ ์ปดํ์ผ๋ฌ๊ฐ ๋ฃ์ด์ค
๋น์๋ฐ์ ์ข ๋ฃ
- ๋ถ๋ชจ ํ๋ก์ธ์ค๊ฐ ์์ ํ๋ก์ธ์ค๋ฅผ ๊ฐ์ ์ข ๋ฃ์ํด
- ์์ ํ๋ก์ธ์ค๊ฐ ํ๊ณ์น๋ฅผ ๋์ด์๋ ์์ ์์ฒญ
- ์์์๊ฒ ํ ๋น๋ ํ์คํฌ๊ฐ ๋ ์ด์ ํ์ํ์ง ์์
- ํค๋ณด๋๋ก kill, break ๊ฐ์ ์ปค๋ฉ๋๋ฅผ ์ ๋ ฅํ ๊ฒฝ์ฐ
- ๋ถ๋ชจ๊ฐ ์ข ๋ฃํ๋ ๊ฒฝ์ฐ
- ๋ถ๋ชจ ํ๋ก์ธ์ค๊ฐ ์ข ๋ฃํ๊ธฐ ์ ์ ์์๋ค์ด ๋จผ์ ์ข ๋ฃ๋จ
ํ๋ก์ธ์ค ๊ฐ ํ๋ ฅ
์์น์ ์ผ๋ก ํ๋ก์ธ์ค๋ ๋ ๋ฆฝ์ ์ด๊ธฐ ๋๋ฌธ์ ํ๋์ ํ๋ก์ธ์ค๊ฐ ๋ค๋ฅธ ํ๋ก์ธ์ค์ ์ํ์ ์ํฅ์ ๋ฏธ์น์ง ๋ชปํฉ๋๋ค.
ํ์ง๋ง ๊ฒฝ์ฐ์ ๋ฐ๋ผ ํ๋ก์ธ์ค๋ผ๋ฆฌ ํ๋ ฅ(์๋ก ์ ๋ณด๋ฅผ ์ฃผ๊ณ ๋ฐ์ผ๋ฉฐ ์คํํ๋ ๊ฒ)์ ํด์ผ ๋ ํจ์จ์ ์ผ๋ก ์คํ๋๋ ๊ฒฝ์ฐ๊ฐ ์์ต๋๋ค. ๊ทธ๋ ๊ธฐ ๋๋ฌธ์ ํ๋ก์ธ์ค ๊ฐ ํ๋ ฅ ๋ฉ์ปค๋์ฆ(IPC: Interprocess Communication)์ด ์กด์ฌํฉ๋๋ค.
ํ๋ก์ธ์ค ๊ฐ ํ๋ ฅ ๋ฉ์ปค๋์ฆ (IPC)
ํ๋ก์ธ์ค ๊ฐ์ ์ ๋ณด๋ฅผ ์ฃผ๊ณ ๋ฐ์ ์ ์๋ ๋ฐฉ๋ฒ์ IPC๋ผ๊ณ ๋ถ๋ฅด๋ฉฐ, IPC์๋ ํฌ๊ฒ ๋ ๊ฐ์ง(Message Passing, Shared Memory)๊ฐ ์์ต๋๋ค.
Message Passing
- ์ปค๋์ ํตํด ๋ฉ์์ง๋ฅผ ์ ๋ฌํ๋ ๋ฐฉ๋ฒ (OS ์ปค๋์ด ๋ฉ์ ์ ์ญํ)
- ํ๋ก์ธ์ค ์ฌ์ด์ ๊ณต์ ๋ณ์๋ฅผ ์ฌ์ฉํ์ง ์๊ณ ํต์
1. Direct Communication
ํต์ ํ๋ ค๋ ํ๋ก์ธ์ค์ ์ด๋ฆ์ ๋ช ์์ ์ผ๋ก ํ์
2. InDirect Communication
mailbox(๋๋ port)๋ฅผ ํตํด ๋ฉ์์ง๋ฅผ ๊ฐ์ ์ ์ผ๋ก ์ ๋ฌ
Shared Memory
์๋ก ๋ค๋ฅธ ํ๋ก์ธ์ค๋ผ๋ฆฌ ์ผ๋ถ ์ฃผ์ ๊ณต๊ฐ์ ๊ณต์ ํ๋ ๋ฐฉ์์ผ๋ก, ์์คํ ์ฝ์ ํตํด ์ด์์ฒด์ ๋ก๋ถํฐ ๊ณต์ ๋ฉ๋ชจ๋ฆฌ ๊ณต๊ฐ์ ๋ฐ์ ์ ์์ต๋๋ค.
'๐ฅ CS > ์ด์์ฒด์ ' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[์ด์์ฒด์ ] CPU ์ค์ผ์ค๋ง (0) | 2023.03.09 |
---|---|
[์ด์์ฒด์ ] ์ค๋ ๋ (Thread) (0) | 2023.02.24 |
[์ด์์ฒด์ ] ํ๋ก์ธ์ค ์ํ (0) | 2023.02.13 |
[์ด์์ฒด์ ] ํ๋ก์ธ์ค (0) | 2023.02.12 |
[์ด์์ฒด์ ] ํ๋ก๊ทธ๋จ์ ์คํ (1) | 2023.02.01 |