νλ‘μΈμ€λ μ€νμ€μΈ νλ‘κ·Έλ¨.
Process is a program in execution
β’
νλ‘μΈμ€μ λ¬Έλ§₯(context)
β¦
νΉμ μμ μ λκ³ λ΄€μ λ μ΄ νλ‘μΈμ€κ° μ΄λκΉμ§ μνμ νκ³ , 무μμ ν΄μΌνλλ₯Ό μλ €μ£Όλ κ²
β¦
PCκ° μ΄λλ₯Ό κ°λ₯΄ν€κ³ μλκ° μ½λμ μ΄λλΆλΆκΉμ§ μ€ννλκ°
β¦
νλ‘μΈμ€ λ©λͺ¨λ¦¬μ μ΄λ€ λ΄μ©μ λ΄κ³ μλκ° μ€νμ μ΄λκΉμ§, 무μμ μμλκ°
ββββββββββββββββββ
β¦
CPU μ κ΄λ ¨λ νλμ¨μ΄ λ¬Έλ§₯
βͺ
νλ‘μΈμ€λ CPU λ₯Ό μ‘κ³ λ§€μκ° instruction μ μ€ν
βͺ
λ¬Έλ§₯μ μκΈ° μν΄μ register μ μ΄λ€ κ°μ΄ λ€μ΄κ°μκ³ , PC λ μ΄λλ₯Ό κ°λ₯΄ν€κ³ μλμ§ νμΈ
β¦
λ©λͺ¨λ¦¬μ κ΄λ ¨λ λ¬Έλ§₯
βͺ
code, data, stack μ μ΄λ€ λ΄μ©μ΄ λ€μ΄κ°μλκ°
β¦
컀λ μλ£ κ΅¬μ‘°μ κ΄λ ¨λ λ¬Έλ§₯
βͺ
PCB(Process Control Block)
βͺ
컀λ μ€ν
β’
νλ‘μΈμ€ 컨ν
μ€νΈλ₯Ό μμμΌ νλ μ΄μ
β time sharing(μλΆν ), λ©ν° νμ€νΉ λ± μ¬λ¬ νλ‘μΈμ€κ° νλμ CPU μμ λμμ μ€νλκΈ° λλ¬Έ
νλ‘μΈμ€ μν(Process State)
Running
β’
맀 μκ° CPU λ₯Ό μ‘κ³ instruction μ μ€ννλ νλ‘μΈμ€μ κ°μλ νλμ΄λ€.
β’
μ΄λ, instruction μ μ€ννλ νλ‘μΈμ€μ μνλ₯Ό running
β’
CPU λ₯Ό λ΄λ €λλ μν©μ 3κ°μ§
β¦
IO κ°μ μ€λ걸리λ μμ
μ΄ νμν΄μ μμ§νμ¬ λ΄λ €λμ β waiting
β¦
timer interrupt(ν λΉλ μκ°μ΄ λ§λ£) β ready
Ready
β’
λ©λͺ¨λ¦¬ λ± λ€λ₯Έ 쑰건μ λͺ¨λ λ§μ‘±νκ³ CPU λ₯Ό μ‘κΈ° μν΄ κΈ°λ€λ¦¬λ νλ‘μΈμ€μ μν
Blocked(wait, sleep)
β’
IO μμ
λλ λμ€ν¬μμ μ½μ΄μμΌνλλ° μμ§ μλ£νμ§ λͺ»νλ λ± CPU λ₯Ό μ‘μλ λΉμ₯ instruction μ μνν μ μλ μν
β’
IO, disk IO, 곡μ λ°μ΄ν° μ κ·Ό μμ
λ±
Suspended(stopped)
β’
μΈλΆμ μΈ μ΄μ (medium-term scheduler λ±)λ‘ νλ‘μΈμ€μ μνμ΄ μ μ§λ μν
β’
νλ‘μΈμ€λ ν΅μ§Έλ‘ λμ€ν¬μ swap out
Blocked: μμ μ΄ μμ²ν event κ° λ§μ‘±λλ©΄ ready μν
Suspended: μΈλΆμμ resume ν΄ μ£Όμ΄μ΄μΌ active
Plain Text
볡μ¬
νΈμμ queue μ§λ§, μ€μ λ‘λ priority queue μ΄λ€.
PCB(Process Control Block)
β’
μ΄μ체μ 컀λμ΄ κ° νλ‘μΈμ€λ§λ€ νλ‘μΈμ€μ κ΄λ ¨λ μ 보, νλ‘μΈμ€λ₯Ό κ΄λ¦¬νκΈ° μν΄ μ΄μ체μ κ° μμ μ λ°μ΄ν° μμμ λκ³ μλ κ²
OSκ° κ΄λ¦¬μ μ¬μ©νλ μ 보
β’
Process state, pointer, pid
β’
μ€μΌμ₯΄λ§ μ 보, μ°μ μμ λ±
CPU μν κ΄λ ¨ νλμ¨μ΄ κ°
β’
PC, registers
β’
νλ‘μΈμ€ 컨ν
μ€νΈλ₯Ό μ μ§νκΈ° μν μ 보λ€
λ©λͺ¨λ¦¬ κ΄λ ¨
β’
code, data, stack μ μμΉ μ 보
νμΌ κ΄λ ¨
β’
open files list
Context Switching
β’
νλ‘μΈμ€λ 짧μ μκ°λμ CPU λ₯Ό μ»μλ€κ° λ΄λλ κ³Όμ μ λ°λ³΅νλ€.
β’
CPU λ₯Ό ν νλ‘μΈμ€μμ λ€λ₯Έ νλ‘μΈμ€λ‘ λ겨주λ κ³Όμ
β¦
CPU λ₯Ό μ¬μ©νλ νλ‘μΈμ€κ° λ€λ₯Έ νλ‘μΈμ€μ λκ²¨μ€ λ λΉμμ μνλ₯Ό νλ‘μΈμ€μ PCB μ μ μ₯(PC, registers, memory map λ±)
β¦
CPU λ₯Ό μλ‘ μ‘λ νλ‘μΈμ€λ νλ‘μΈμ€μ μνλ₯Ό PCB μμ μ½μ΄μ΄
β’
System call: νλ‘μΈμ€κ° λ³ΈμΈμ΄ νμν΄μ OS μ μμ²
β’
system call μ΄λ interrupt λ°μ μ λ°λμ context switch κ° μΌμ΄λλ κ²μ μλλ€.
νλ‘μΈμ€κ° λ€λ₯Έ νλ‘μΈμ€λ‘ λμ΄κ°μΌ context switch
Process Queue
β’
queue μλ κ° νλ‘μΈμ€μ pcb κ° λ€μ΄κ°λ€.
β’
Job queue
β¦
νμ¬ μμ€ν
λ΄μ λͺ¨λ νλ‘μΈμ€ μ§ν©
β’
Ready queue
β¦
νμ¬ λ©λͺ¨λ¦¬ λ΄μ μμΌλ©΄μ CPU λ₯Ό μ‘μ μ€νλκΈ°λ₯Ό κΈ°λ€λ¦¬λ νλ‘μΈμ€μ μ§ν©
β’
Device queue
β¦
IO device μ²λ¦¬λ₯Ό κΈ°λ€λ¦¬λ νλ‘μΈμ€μ μ§ν©
β’
νλ‘μΈμ€λ€μ κ° νλ€μ μ€κ°λ©΄μ μν
IO request μ wait for an interrupt λ°μ€λ κ°λ
μ΄ μ μ¬
Scheduler
long-term scheduler
β’
job scheduler
β’
λ©λͺ¨λ¦¬λ₯Ό μ΄λ€ νλ‘μΈμ€μκ² μ€μ§ κ²°μ
β’
νλ‘μΈμ€κ° μμμ΄ λκ³ ready μνμ κ°κΈ° μν΄μλ memory ν λΉμ΄ νμνλ€. μ΄λ λ©λͺ¨λ¦¬ ν λΉμ κ²°μ νλ μ€μΌμ₯΄λ§
β’
time sharing system μλ λ³΄ν΅ long-term scheduler κ° μλ€(무쑰건 ready).
β’
multiprogramming μ μ μ΄
β’
λ©λͺ¨λ¦¬μ νλ‘κ·Έλ¨ λͺκ°λ₯Ό μ¬λ €λμμ§λ₯Ό μ μ΄
short-term scheduler
β’
CPU scheduler
β’
ms λ¨μ
β’
λ€μ λ²μ μ΄λ€ νλ‘μΈμ€λ₯Ό running μν¬μ§ κ²°μ
medium-term scheduler
β’
μ₯κΈ° μ€μΌμ₯΄λ¬λ νλ‘κ·Έλ¨μ΄ μμν λ λ©λͺ¨λ¦¬λ₯Ό ν λΉν μ§ λ§μ§ κ²°μ νλλ°, μ€κΈ° μ€μΌμ₯΄λ¬λ λ©λͺ¨λ¦¬μμ μΌλΆ νλ‘μΈμ€λ₯Ό ν΅μ§Έλ‘ λμ€ν¬λ‘ μ«μλΈλ€.
β’
multiprogramming μ μ μ΄
μ°λ λ
νλ‘μΈμ€ λ΄λΆ CPU μν λ¨μ
pointer, process state, process number λ OS κ΄λ¦¬μ© μ 보
memory limits, list of open files λ μμ κ΄λ ¨ μ 보
Program Counter: λ©λͺ¨λ¦¬μ μ΄λ λΆλΆμ μ€ννκ³ μλμ§ κ°λ₯΄ν€λ κ²
κ°μ μΌμ νλ νλ‘μΈμ€λ₯Ό μ¬λ¬κ° μ€ννλ €κ³ νμ λ λ©λͺ¨λ¦¬ λλΉκ° μκΈ°λλ¬Έμ νλ‘μΈμ€λ₯Ό νλλ§ μ€ννκ³ λ΄λΆμμ PC, λλ CPU μν λ¨μλ§ μ¬λ¬ κ° λλ κ²
νλ‘μΈμ€ λ΄λΆμμ 곡μ ν μ μλ λΆλΆμ μ΅λν 곡μ νκ³ CPU μνκ³Ό κ΄λ ¨λ μ 보(PC, registers, stack) λ§ λ
립μ μΌλ‘ κ°λλ€.
A thread(or lightweight process) is a basic unit of CPU utilization.
ꡬμ±
β’
Program Counter
β’
register set
β’
stack space
곡μ νλ λΆλΆ(task)
β’
code section
β’
data section
β’
OS resources
μ₯μ
β’
νλμ μ°λ λκ° blocked(waiting) μν λμμλ λ€λ₯Έ μ°λ λκ° running μνκ° λμ΄ λΉ λ₯΄κ² μ²λ¦¬(web page μ½μ΄μ€λ μμ)
β’
λμΌν μΌμ μννλ λ€μ€ μ°λ λκ° νλ ₯νμ¬ λμ μ²λ¦¬μ¨(throughput)κ³Ό μ±λ₯ ν₯μ
β’
λ³λ ¬μ± λμ
β’
Responsiveness
β¦
νλμ μ°λ λκ° block μνλΌλ λ€λ₯Έ μ°λ λλ running μν
β’
Resource Sharing
β¦
code, data, νλ‘μΈμ€ μμ λ±μ 곡μ
β’
κ²½μ μ±
β¦
n κ°μ νλ‘μΈμ€λ₯Ό λ§λλ κ²λ³΄λ€ n κ°μ μ°λ λλ₯Ό λ§λλ κ²μ΄ creating, CPU switching μμ κ²½μ μ μ΄λ€.
β’
λ©ν° νλ‘μΈμ ꡬ쑰μμ λ³λ ¬μ±
νλ‘μΈμ€ μμ±
β’
λΆλͺ¨ νλ‘μΈμ€κ° μμ νλ‘μΈμ€ μμ±
β’
νλ‘μΈμ€ νΈλ¦¬(κ³μΈ΅ ꡬ쑰) νμ±
β’
νλ‘μΈμ€κ° μ€νλλ €λ©΄ μμμ΄ νμ
β¦
OS λ‘λΆν° λ°μ
β’
μ£Όμ 곡κ°
β¦
μμ νλ‘μΈμ€λ λΆλͺ¨ νλ‘μΈμ€μ 곡κ°μ 볡μ¬νκ³ κ·Έ 곡κ°μ μλ‘μ΄ νλ‘κ·Έλ¨μ μ¬λ¦°λ€.
β’
μ λμ€
β¦
fork() μμ€ν
μ½μ΄ μλ‘μ΄ νλ‘μΈμ€ μμ±
A process is created by the fork() system call β creates a new address space that is a duplicate of the caller.
β¦
copy μ λͺ¨λ μ 보(code, data, stack)μ λ©λͺ¨λ¦¬μ copy νλ κ²μ΄ μλλΌ κ³΅μ ν μ μλ건 μ΅λν 곡μ ν λ€ copy
β¦
exec() μμ€ν
μ½λ‘ μλ‘μ΄ νλ‘κ·Έλ¨μ λ©λͺ¨λ¦¬μ μ¬λ¦Ό
β’
copy on write
int main()
{
int pid;
pid = fork();
if (pid == 0)
printf("I am child");
else if (pid > 0)
printf("I am parent");
}
C
볡μ¬
β λΆλͺ¨ νλ‘μΈμ€μμ fork() λ₯Ό νλ©΄ μμ νλ‘μΈμ€κ° λ§λ€μ΄μ§λλ°, μμ νλ‘μΈμ€λ main ν¨μ μ²μλΆν° λ€μ μμνλ κ²μ΄ μλκ³ , fork() μ΄νλΆν° μ€νλλ€. κ·Έλμ 무νν λ°λ³΅ X
μ΄μ λ fork() λΆλͺ¨ νλ‘μΈμ€μ 컨ν
μ€νΈ(PC)λ₯Ό 볡μ νκΈ° λλ¬Έμ΄λ€.
β fork() μ return value κ°μΌλ‘ μμ νλ‘μΈμ€λ 0 μ μ»κ³ λΆλͺ¨ νλ‘μΈμ€λ μμ κ°μ μ»λλ€. μ΄ return value λ‘ λΆλͺ¨ νλ‘μΈμ€μ μμ νλ‘μΈμ€λ₯Ό ꡬλΆν μ μλ€.
β¦
exec()
A process can execute a different program by the exec() system call. β replaces the memory image of the caller with a new program.
β¦
λ€λ₯Έ νλ‘κ·Έλ¨μ μ€νμν¨λ€.
int main() {
printf("hello");
/* execlp("/bin/date", "/bin/date", (char *) 0); */
execlp("echo", "echo", "HI", (char *) 0);
printf("bye");
}
C
볡μ¬
β printf(βbyeβ); λ μ€νλμ§ μλλ€.
β¦
wait()
β¦
컀λμ μμ νλ‘μΈμ€κ° μ’
λ£λ λκΉμ§ λΆλͺ¨ νλ‘μΈμ€λ₯Ό sleep μν¨λ€(block μν)
β¦
μμ νλ‘μΈμ€κ° μ’
λ£λλ©΄ 컀λμ λΆλͺ¨ νλ‘μΈμ€λ₯Ό κΉ¨μ΄λ€(ready μν)
main {
int childPID;
childPID = fork();
if (childPID == 0)
printf("HI");
else {
wait();
}
printf("wake up");
}
C
볡μ¬
β¦
exit()
β¦
λͺ
μμ μΌλ‘ νλ‘κ·Έλ¨ μ’
λ£
β’
μ 리
β¦
fork(): create a child(copy)
β¦
exec(): overlay new image
β¦
wait(): sleep until child is done
β¦
exit(): frees all the resources, notify parent
νλ‘μΈμ€κ° νλ ₯
λ 립μ νλ‘μΈμ€(independent process)
β’
νλ‘μΈμ€λ κ°μμ μ£Όμ 곡κ°μ κ°μ§κ³ μν
β’
μμΉμ μΌλ‘ νλμ νλ‘μΈμ€λ λ€λ₯Έ νλ‘μΈμ€μ μνμ μν₯ X
νλ ₯ νλ‘μΈμ€(cooperating process)
β’
νλ ₯ λ©μ»€λμ¦μ ν΅ν΄ νλμ νλ‘μΈμ€κ° λ€λ₯Έ νλ‘μΈμ€μ μνμ μν₯μ λ―ΈμΉ¨
IPC(inter-process communication)
β’
λ©μμ§ μ λ¬ λ°©μ
β¦
message passing: 컀λμ ν΅ν΄ λ©μμ§ μ λ¬(μ체μ μΌλ‘ μ λ¬μ λͺ»νκ³ μ»€λμ ν΅ν΄μ μ λ¬ν΄μΌ ν¨)
βͺ
νλ‘μΈμ€ μ¬μ΄μ 곡μ λ³μ(shared variable)λ₯Ό μ¬μ©νμ§ μκ³ ν΅μ
βͺ
direct communication: ν΅μ νλ €λ νλ‘μΈμ€μ μ΄λ¦μ λͺ
μμ μΌλ‘ νμ
βͺ
indirect communication: mailbox or port λ₯Ό ν΅ν΄ λ©μμ§λ₯Ό κ°μ μ μΌλ‘ μ λ¬
β’
μ£Όμ κ³΅κ° κ³΅μ λ°©μ
β¦
shared memory: μλ‘ λ€λ₯Έ νλ‘μΈμ€κ°μ μΌλΆ μ£Όμ 곡κ°μ 곡μ , 컀λμκ² shared memory νλ€λ μμ€ν
μ½μ ν΄μΌν¨