a. What are two such problems?
b. Can we ensure the same degree of security in a time-shared machine as in a dedicated machine? Explain your answer.
a. Mainframe or minicomputer systems : CPU, Main Memory, Storage
b. Workstations connected to servers : Network
c. Handheld computers : ์ ๋ ฅ ์๋น๋
์์ ์ด ๋๋ฌด ํฐ ๊ฒฝ์ฐ single user workstation ๋ณด๋ค ์ปดํจํ ํ์๊ฐ ํฐ ์ฅ๋น๋ก ์ํํ๋ time-sharing system์ด ์ ํฉํ ๊ฒ ๊ฐ๋ค. ๋ค๋ง ๋๋ฌด ๋ง์ง ์์ ์ฌ์ฉ์๊ฐ time-sharing ํด์ผํ๋ค๋ ์ ์ฝ์กฐ๊ฑด์ด ๋ฐ๋ฅธ๋ค.
a. Batch programming
b. Virtual memory : (a),(b)
c. Time sharing : (b)
๋๊ธฐ, ๋น๋๊ธฐ์ ํด๋ฌ์คํฐ๋ง์ด ์ ๊ณต๋๋ค๋ฉด ๊ณ ๊ฐ์ฉ์ฑ์ ์ ๊ณตํ ์ ์๋ค. ๋๊ธฐ์์ ๊ฒฝ์ฐ Active-Active ์ํ๋ฅผ ์ ์งํ๋ฉฐ ๋น๋๊ธฐ์ ํด๋ฌ์คํฐ๋ง์ ๊ฒฝ์ฐ Active-Standby ์ํ๋ฅผ ์ ์งํ๋ค. ๋ ๋ค ํ์ชฝ์ด ์คํจํ์ ๋ ํด๋น ์ฅ์น๋ฅผ ๋์ฒดํ์ฌ ๋์ํ ์ ์๋ค. clustered system์ ์ฌ๋ฌ๊ฐ์ ์ฅ์น์ ๊ตฐ์ง์ ๋ปํ๊ณ , ๋ฉํฐํ๋ก์ธ์ ์์คํ ์ ํ๋์ ๋ฌผ๋ฆฌ ์ฅ์น๋ก ๊ตฌ์ฑ๋๋ค.
server๋ client์ ์์ฒญ์ ์๋ต ๋ฐ ์๋น์ค๋ฅผ ์ ๊ณตํ๋ ๊ตฌ์กฐ์ด๋ค. peer๋ ๊ทธ ์์ฒด๋ก ์๋ฒ์ด์ ํด๋ผ์ด์ธํธ์ ์ญํ ์ ์ํํ๋ค. ํ์ผ์ ๊ณต์ ํ ๋ peer to peer ๊ตฌ์กฐ์์๋ ์ฌ๋ฌ peer๋ก๋ถํฐ ํ์ผ์ ๋ค์ด๋ก๋ ํ ์ ์๊ธฐ ๋๋ฌธ์ ์๋๊ฐ ๋น ๋ฅด๋ค.(๋นํธํ ๋ ํธ) ๋ํ ๋์ ์๋์ฑ๋ ์ ๊ณตํ๋ค.(ํ ๋ฅด ๋ธ๋ผ์ฐ์ ).
๋น๋๊ธฐ์/๋๊ธฐ์ ํด๋ฌ์คํฐ๋ง์ผ๋ก ํ๊ฐ์ ๋ฐ์ดํฐ๋ฒ ์ด์ค๋ฅผ ๊ตฌ์ฑํ๊ณ ํด๋น ๋ด์ฉ์ duplicateํ๋ ๋ฐฉ์์ผ๋ก ๊ณ ๊ฐ์ฉ์ฑ์ ์ง์ํ๋ ๋ฐฉ์์ ๋ฐ์ดํฐ๋ฒ ์ด์ค ์ด์ฉ ๋ฐฉ์์ด ์๊ณ , ๋ค๋ฅธ ํ๋๋ ๋ณ๋ ฌ ํด๋ฌ์คํฐ๋ง์ ์ด์ฉํ์ฌ ๊ณต์ DB๋ฅผ ๊ตฌ์ฑํ๋ ๋ฐฉ์์ด ์๋ค. ๋ณ๋ ฌ ํด๋ฌ์คํฐ๋ง์ ๊ฒฝ์ฐ ๋ ๋์ ์ปดํจํ ์์์ ๋ชจ๋ ํ์ฉํ ์ ์๋ค๋ ๊ฒ ์ด์ ์ด์ง๋ง ๊ณต์ ๋ฐ์ดํฐ๋ฒ ์ด์ค์ ํน์ฑ์ ๋ฝํน๊ธฐ๋ฒ์ด ํ์ํ๋ฉฐ ๋ฝํน์๋ ์ค๋ฒํค๋๊ฐ ๋ฐ์ํ๋ค๋๊ฒ ๋จ์ ์ด๋ค. ๋๊ธฐ/๋น๋๊ธฐ์์ ๊ฒฝ์ฐ ๊ณ ๊ฐ์ฉ์ฑ ์์ฒด๊ฐ ์ด์ ์ด์ง๋ง ๋ ๋์ ์ปดํจํ ์์์ ๋ชจ๋ ํ์ฉํ์ง๋ ๋ชปํ๋ค๋ ์ ์ด ๋จ์ ์ด๋ค.
NC๋ ๊ฒฝ๋ํ๋ ์ด์์ฒด์ ์ ์ต์ํ์ ๋ฉ๋ชจ๋ฆฌ, CPU๋ฅผ ๊ฐ์ถ๋ฉด ๋๋ฉฐ ๊ต์ฅํ ๊ฐ๊ฒฉ์ด ์ธ๋ค. ์ด๋ ์ ํต์ ์ธ PC๊ฐ ์ฌ์ฉ์๊ฐ ์ฌ์ฉํ๊ธฐ ํธ๋ฆฌํ ์ด์์ฒด์ ๋ฅผ ๊ฐ์ถ๊ณ ๋์ ๋ฉ๋ชจ๋ฆฌ์ ๊ณ ์ฑ๋ฅ CPU๋ฅผ ๊ฐ์ถ๋ ๊ฒ๊ณผ๋ ๋์กฐ๋๋ค. NC๋ ๋คํธ์ํฌ๋ง ์ง์๋๋ค๋ฉด ์๊ฒฉ์ง์ ์ํผ์ปดํจํฐ ์์์ ํ ๋น๋ฐ์์ ์ด์ฉํ๋ ๋ฐฉ์์ด๊ณ , ๊ฐ๊ฒฉ์ด ์ผ NC์ ํน์ฑ์ ์ด๋์์๋ ์์ฝ๊ฒ ํ๋์จ์ด๋ฅผ ๊ตฌ์ ํ ์ ์์ผ๋ฉฐ ๊ฐ๋จํ ๋ก๊ทธ์ธ์ผ๋ก ์ ๊ทผ์ด ๊ฐ๋ฅํ๋ค๋ ์ฅ์ ์ ๊ฐ์ง๋ค. ๋ํ NC๋ ์๊ฒฉ์ง์ ์ํผ์ปดํจํฐ๋ฅผ ๋ค์์ ์ฌ์ฉ์๊ฐ ์ด์ฉํ๊ธฐ ๋๋ฌธ์ ์์์ด ๋๊ณ ์๋ ์ํ๊ฐ ์ค์ด๋ ๋ค.
์ธํฐ๋ฝํธ๋ ํ๋์จ์ด์์ ๋ฐ์ํ๋ ์ ํธ์ด๋ค. ์ธํฐ๋ฝํธ๊ฐ ๋ฐ์ํ๋ฉด ๋ฌธ๋งฅ๊ตํ์ด ์ผ์ด๋๊ณ ์ธํฐ๋ฝํธ ์๋น์ค ๋ฃจํด์ ์คํํ๋ค. ํธ๋ฉ์ ์ผ๋ฐ์ ์ผ๋ก ์ํํธ์จ์ด์์ ๋ฐ์ํ ์ธํฐ๋ฝํธ๋ผ๊ณ ๋ถ๋ฆฌ๋ฉฐ ์ ์ ํ๋ก๊ทธ๋จ์์๋ ์๋์ ์ผ๋ก ๋ฐ์ ๊ฐ๋ฅํ๋ค. ์๋์ ์ผ๋ก arithmetic error๋ฅผ ์ผ์ผํค๋ ์ฝ๋๋ฅผ ์์ฑํ๋ ํ์๊ฐ ์๋์ ๋ฐ์์ ์์ด๋ค.
a. How does the CPU interface with the device to coordinate the transfer?
CPU์์ DMA Controller์๊ฒ ์ ํธ๋ฅผ ๋ณด๋ด๋ฉด DMAC๋ ์์
์ ์์ํ๊ณ ์์
์ด ๋๋๋ฉด CPU์๊ฒ ์ธํฐ๋ฝํธ๋ก ํต์งํ๋ค.
b. How does the CPU know when the memory operations are complete?
์์
์ด ์ข
๋ฃ๋์๋ค๋ Interrupt๋ฅผ ํตํด CPU์๊ฒ ์๋ฆฌ๊ฒ ๋๋ค.
c. The CPU is allowed to execute other programs while the DMA controller is transferring data. Does this process interfere with the excution of the user programs? If so, describe what forms of interference are caused.
DMA๊ฐ ๋ฉ๋ชจ๋ฆฌ์ ์ ๊ทผํ ๋ ๋ฉ๋ชจ๋ฆฌ ๋ฒ์ค์์ ์ธ์ดํด ์คํธ๋ง์ด ๋ฐ์ํ๋ฉด DMA์ ์ฐ์ ์์๊ฐ ๋๊ธฐ๋๋ฌธ์ CPU์์๋ ๋ฉ๋ชจ๋ฆฌ๋ก์ ์ ๊ทผ์ด ๋ถ๊ฐ๋ฅํ๋ค. ๋ฐ๋ผ์ CPU์ ์ ์์ ์ธ User program ์ด์ฉ์ ๋ฌธ์ ๊ฐ ์๊ธธ ์ ์๋ค.
์ ๋ฌธ์ ์ data update์ ๋์ผํ ๋ด์ฉ์ด๋ค.
a. Single-processor systems
b. Multiprocessor systems
c. Distributed systems
a. ํ๋ก์ธ์๊ฐ ์บ์ ๊ฐ์ ๋ณ๊ฒฝํ๋ฉด ๋ฉ๋ชจ๋ฆฌ์ ์
๋ฐ์ดํธ ํ๋ค.
b. ํ๋ก์ธ์๊ฐ ๋ก์ปฌ์บ์ ๊ฐ์ ๋ณ๊ฒฝํ๋ฉด ๋ค๋ฅธ ํ๋ก์ธ์๋ค์ ๋ก์ปฌ์บ์ ๊ฐ๋ ๋ณ๊ฒฝ ๋๋ ์ฌ์ฉ๋ถ๊ฐ ์ํ๊ฐ ๋์ด์ผ ํ๋ฉฐ ํด๋น ๋ด์ฉ์ด ๋ฉ๋ชจ๋ฆฌ์ ์
๋ฐ์ดํธ ๋์ด์ผํ๋ค.
c. ๋ณ๋์ ์
๋ฐ์ดํธ๋ ํ์ง ์๋๋ค. ํด๋ผ์ด์ธํธ์ ์บ์ ํ์ผ ๋ฐ์ดํฐ์ ์ํด ๋ถ์ผ์น ํ์์ด ๋ํ๋ ์๋ ์๋ค.
base and limit register๋ฅผ ์ด์ฉํ์ฌ ๋ฉ๋ชจ๋ฆฌ ๋ณดํธ๋ฅผ ์งํํ๋ค.
base register - process์ ์์์ง์
limit register - ์์์ง์ ๋ถํฐ ๋ฉ๋ชจ๋ฆฌ์ ์ ๊ทผํ ์ ์๋ ์ง์ ์ ํ์ํ๋ค.
base <= ์ฃผ์ <= base+limit
Operating system structure
The services and functions provided by an operating system can be divided into two main categories. Briefly describe the two categories and discuss how they differ.
- ํ๋ก์ธ์ค์ ๋ณดํธ
- ํ๋์จ์ด๊ฐ ์ ๊ณตํ์ง ๋ชปํ๋ ๋ค์ํ ๊ธฐ๋ฅ์ ์ ๊ณต (ํ์ผ์์คํ , ๊ฐ์๋ฉ๋ชจ๋ฆฌ ๋ฑ)
Describe three general methods for passing parameters to the operating system.
- ํ๋ผ๋ฏธํฐ๋ฅผ ๋ ์ง์คํฐ์ ์ ๋ฌํ๋ค.
- ํ๋ผ๋ฏธํฐ๋ฅผ ๋ฉ๋ชจ๋ฆฌ๋ด์ ๋ถ๋ก์ด๋ ํ ์ด๋ธ์ ์ ์ฅํ๊ณ ๋ธ๋ก์ ์ฃผ์๊ฐ์ ๋ ์ง์คํฐ์ ์ ๋ฌํ๋ค.
- ๋งค๊ฐ๋ณ์๋ ํ๋ก๊ทธ๋จ์ ์ํด ์คํ์ Push๋๊ณ , OS์ ์ํด Pop๋๋ค.
- OS๋ ๋ธ๋ก์ด๋ ์คํ๋ฐฉ์ (2),(3)๋ฒ์ ์ ํธํ๋ค. ์๋ํ๋ฉด ์ ๋ฌ๋๋ ๋งค๊ฐ๋ณ์์ ๊ฐ์๋ ๊ธธ์ด๋ฅผ ์ ํํ์ง ์๊ธฐ ๋๋ฌธ์ด๋ค.
ํ์ผ์ ์์ฑ, ํ์ผ์ ์ญ์ , ๋๋ ํฐ๋ฆฌ ์์ฑ, ๋๋ ํฐ๋ฆฌ ์ญ์ , The application's symbolic instructions need to be translated into the machine-level instructions either by an interpreter or by compiling the application code, ํ์ผ ๋ฐฑ์ , ์๊ตฌ ์ ์ฅ์๋ก ๋งคํ
Short-term(CPU scheduler) : ๋ฉ๋ชจ๋ฆฌ๋ก๋ถํฐ ready ์ํ์ ์๋ job ๋ค์ ์ ํํด์ CPU๋ฅผ ํ ๋นํ๋ ์ค์ผ์ฅด๋ง
medium-term : ํนํ ์๋ถํ ์์คํ
์์ ์ฌ์ฉ๋๋ medium-term scheduler๋ CPU๊ฒฝ์์ํ๋ฅผ ์ํ์ฌ ๋ฉ๋ชจ๋ฆฌ์์ ํ๋ก์ธ์ค๋ค์ ์ ๊ฑฐํ๋ฉฐ, ๋ค์ค ํ๋ก๊ทธ๋๋ฐ์ ์ ๋๋ฅผ ์ํํ๋ ๊ฒ์ด๋ค. ์ถํ ํ๋ก์ธ์ค๋ฅผ ๋ฉ๋ชจ๋ฆฌ๋ก ๋ถ๋ฌ์์ ์ค๋จ๋ ์ง์ ๋ถํฐ ์ฌ๊ฐํ๋ swapping๊ธฐ๋ฒ์ ์ฌ์ฉํ๋ค.
long-term : ๋ณด์กฐ๊ธฐ์ต์ฅ์น๋ก๋ถํฐ ์ฃผ๊ธฐ์ต์ฅ์น๋ก job์ loadํ์ฌ ํด๋น ํ๋ก์ธ์ค๋ฅผ ready ์ํ๋ก ๋ง๋ ๋ค.
์ฃผ์ํ ์ฐจ์ด๋ ์คํ ๋น๋์
์ด๋ค. short-term์ ์๋ก์ด ํ๋ก์ธ์ค๋ฅผ ์์ฃผ ์ ํํด์ผํ๊ณ , long-term์ job์ด ๋๋๋ ์๊ฐ์ ๊ธฐ๋ค๋ ค์ผ ํ๊ธฐ ๋๋ฌธ์ ๋ค๋ฅธ job์ ์์ฉํ๋๋ฐ์ ์๋์ ์ผ๋ก ๊ธด ์๊ฐ์ด ๊ฑธ๋ฆฐ๋ค.
์ปค๋์ ํ์ฌ ์คํ์ค์ธ ํ๋ก์ธ์ค์ ์ํ๋ฅผ ์ ์ฅํด์ผ๋ง ํ๋ค. ๋, ๋ค์์ผ๋ก ์คํ๋ ํ๋ก์ธ์ค์ ์ํ๋ฅผ restore ํด์ผํ๋ค.
The OS must save the PC and user stack pointer of the currently executing process, in response to a clock interrupt and transfers control to the kernel clock interrupt handler
Saving the rest of the registers, as well as other machine state, such as the state of the floating point registers, in the process PCB is done by the clock interrupt handler.
The scheduler to determine the next process to execute is invoked the OS.
Then the state of the next process from its PCB is retrieved by OS and restores the registers. The restore operation takes the processor back to the state in which the previous process was previously interrupted, executing in user code with user-mode privileges.
๋ค ๋ฒ์ fork()๊ฐ ์งํ๋๋ค.
#1 2๊ฐ์ ํ๋ก์ธ์ค๋ก ๋ถ๊ธฐํ๋ค.
#2 2๊ฐ์ ํ๋ก์ธ์ค๊ฐ ๊ฐ๊ฐ 2๊ฐ๋ก ๋ถ๊ธฐํ์ฌ ์ด 4๊ฐ๊ฐ ๋๋ค.
#3 4๊ฐ์ ํ๋ก์ธ์ค๊ฐ ๊ฐ๊ฐ 2๊ฐ๋ก ๋ถ๊ธฐํ์ฌ ์ด 8๊ฐ๊ฐ ๋๋ค.
#4 8๊ฐ์ ํ๋ก์ธ์ค๊ฐ ๊ฐ๊ฐ 2๊ฐ๋ก ๋ถ๊ธฐํ์ฌ ์ด 16๊ฐ๊ฐ ๋๋ค.
ํด๋น ์ฝ๋์ ๋๋ฌํ ์ ์๋ ํ๊ฒฝ์ ๋ค์๊ณผ ๊ฐ๋ค.
fork() ์์คํ ์ฝ๋ก ๋ถ๊ธฐ๋ ์์ ํ๋ก์ธ์ค๋ pid๊ฐ 0์ด๋ค. ๋ฐ๋ผ์ ์์ ํ๋ก์ธ์ค์์๋ ls ๋ช ๋ น์ด๋ฅผ ์คํ์ํจ ํ โLINE Jโ๋ฅผ ์ถ๋ ฅํ๊ฒ ๋๋ค. ๋ถ๋ชจ ํ๋ก์ธ์ค๋ wait(NULL)๋ก ์์ ํ๋ก์ธ์ค๊ฐ ์ข ๋ฃ๋ ๋๊น์ง ๊ธฐ๋ค๋ ธ๋ค๊ฐ โChild Completeโ๋ฅผ ์ถ๋ ฅํ๋ค.
A=0, B=2603, C=2603, D=2600
์ ๋ง๋ค๊ธฐ ๊ณผ์ ๋ฅผ ํ ๋, pipe๋ฅผ ๊ตฌํํ๋ค๊ณ ๊ฐ์ ํ๋ค๋ฉด, ordinary pipe๊ฐ ์ ๋นํ ๊ฒ์ด๋ผ๊ณ ์๊ฐํ๋ค. ์๋ํ๋ฉด ์คํ๋ ์ ๋ช ๋ น์ด๋ฅผ ์ด์ฉํ์ฌ ๋ค์ ๋ช ๋ น์ด์์ ์ฌ์ฉํ๊ธฐ ๋๋ฌธ์ ํด๋น ๋ด์ฉ์ด ์ ์ฅ๋์ด ๋จ์ ํ์๊ฐ ์๊ธฐ ๋๋ฌธ์ด๋ค. ํ์ง๋ง ๋ง์ฝ ๋ณด์ ๊ด์ ์์ Accountability๋ฅผ ์ํด ์ฌ์ฉ์๊ฐ ์ ๋ ฅํ ๋ชจ๋ ๋ช ๋ น์ด๋ฅผ logging ํ๋ค๊ณ ๊ฐ์ ํ๋ ์ํฉ์ด๋ผ๋ฉด named pipe๊ฐ ์ ๋นํ ๊ฒ์ผ๋ก ๋ณด์ธ๋ค.
๋ ๋ช
๋ น์ด ๋ชจ๋ ํ๋ฒ์ ํธ์ถ
์ ์๋ฏธํ์ง๋ง, ์คํจ์์ ๋์์ด ๋ค๋ฅด๋ค.
at-least-once์ ๊ฒฝ์ฐ ์์คํ
์ด ํด๋น ํจ์ ํธ์ถ์ด ์ฑ๊ณตํ๋ค๋ ์ฌ์ค์ ์ ๋๊น์ง ๋ฐ๋ณตํ๋ฏ๋ก ๊ฒฐ์ ์
๋ฌด ๋ฑ์ ์ ์ฉ๋๋ฉด ์๋๋ค. ๋ฐ์ดํฐ ๋ฒ ์ด์ค์ ์
๋ฐ์ดํธ์ ๊ฐ์ด ์ต์ ์ ๊ฐ์ผ๋ก ๋ฎ์ด์จ๋ ๋๋ ๊ฒฝ์ฐ ์ฌ์ฉํ๋ฉด ์ข๋ค. ๋ฐ๋ฉด at-most-once์ ๊ฒฝ์ฐ ์ค์๋ก ๋ค๋ฅธ ์ฌ๋์๊ฒ ๋๋ฒ ๊ฒฐ์ ํ๊ณ ์ถ์ง ์์๋ ์ฌ์ฉํ๋ค. exactly-once์ at-most-once์ ๋น์ทํ๋ค. ํ์ง๋ง ๋ค๋ฅธ์ ์ด ์๋ค๋ฉด at-most-once๋ ACK๋ฅผ ๋ฐ์์ ๋ ๋ ์ด์ ์ฌ์ ์ก ํ์ง ์๋ ๋ฐฉ์์ด๋ผ๋ฉด exactly-once ๋ฐฉ์์ cache๊ฐ ์กด์ฌํ๋ค๋ฉด ํด๋น ๊ฐ์ ๋๋ ค์ฃผ์ด duplicate ํ์์ ๋ฐฉ์งํ๋ค.
At-least-once
At-most-once
Exactly-once
a. Synchronous and asynchronous communication
๋๊ธฐ์ ์ก์ ์ ๊ตฌํ์ด ๊ฐ๋จํ๊ณ ๋ณ๋ค๋ฅธ ์ด๋ฒคํธ์ ๋ํ ํธ๋ค๋ง์ด ํ์ ์๋ค. ํ์ง๋ง blocking ๋ฐฉ์์ผ๋ก ํ ๋ฉ์์ง๋ฅผ ์ฃผ๊ณ ๋ฐ์ ๋ ๋ค๋ฅธ ๋์์ ํ์ง ๋ชปํ๋ค๋ ๋จ์ ์ด ์๋ค. (rendezvous) ๋ฐ๋ฉด ๋น๋๊ธฐ์ ํต์ ์ ๋ค๋ฅธ ์์
๋ ์ํํ ์ ์์ง๋ง, ๋ณ๋์ ์ด๋ฒคํธ ํธ๋ค๋ง์ด ํ์ํ๋ค.
b. Automatic and explicit buffering
์๋ ๋ฒํผ๋ง์ ํจ์จ์ ์ธ ์์ ํ์ฉ์ด ๊ฐ๋ฅํ๋ฉฐ, ์ ์ก์๊ฐ block์ ํ ํ์๊ฐ ์๋ค. ๋ช
์์ ๋ฒํผ๋ง์ ํ๊ฐ ๋ค ์ฐจ๋ฉด blockํด์ผํ๋ค๋ ๋จ์ ์ด ์์ผ๋ ์ ์กฐ์ ํ๋ค๋ฉด ์๋ ๋ฒํผ๋ง๋ณด๋ค ํจ์จ์ ์ผ ์ ์๋ค.
c. Send by copy and send by reference
๋ณต์ฌ ์๋ณธ์ด ๋จ๊ธฐ ๋๋ฌธ์ ์์ ์ฑ์ ํ๋ณดํ ์ ์์ผ๋ ๋ฉ๋ชจ๋ฆฌ์ ๋ญ๋น๊ฐ ์ผ์ด๋๋ค.
๋ฐ๋๋ก ์ฐธ์กฐ๋ ์๋์น ์์ ๊ฐ ๋ณ๊ฒฝ์ด๋ผ๋ ๋ถ์์ฉ์ด ์์ ์ ์๋ค.
d. Fixed-sized and variable-sized messages
๊ณ ์ ํฌ๊ธฐ์ ๋ฉ์์ง๋ ๊ตฌํ์ด ์ฝ๊ณ , ์์คํ
์ฐ์ฐ์ ์ต์ ํ๊ฐ ํด๋น ์ฌ์ด์ฆ์ ๋ง์ถ์ด ๊ฐ๋ฅํด์ง๋ค.
๋ฐ๋๋ก ๊ฐ๋ณ ํฌ๊ธฐ ๋ฉ์์ง๋ ๊ณต๊ฐ์ ํจ์จ์ ํ์ฉ๊ณผ ๋ฉ๋ชจ๋ฆฌ ๋ฒ์ ๋ด์ ๋ชจ๋ ํฌ๊ธฐ ๋ฉ์์ง๋ฅผ ์ ์กํ ์ ์๋ค๋ ์ฅ์ ์ด ์๋ค. ํ์ง๋ง ์์คํ
์ฐ์ฐ์ ์ต์ ํ๋ ๋ถ๊ฐ๋ฅํ๋ค.
์์ฐจ์ ์ผ๋ก ์คํ๋๋ ํ๋ก๊ทธ๋จ์ ๊ฒฝ์ฐ ๋ฉํฐ์ฐ๋ ๋ฉ์ ์ ํฉํ์ง ์๋ค.
๋ฐ๋ฉด, shell ๋ง๋ค๊ธฐ ๊ณผ์ ์ ๊ฐ์ด ๋ฐฑ๊ทธ๋ผ์ด๋ ์คํ์ ์ง์ํ๋ฉฐ ์ค์๊ฐ์ผ๋ก ์ฌ์ฉ์์ ์ปค๋ฎค๋์ผ์ด์
์ ํ๋ ํ๋ก๊ทธ๋จ์ด๋ผ๋ฉด ๋ฉํฐ ์ฐ๋ ๋ฉ์ด ํ์ํ๋ค.
ํ๋ก์ธ์ค์ ๋ฌธ๋งฅ ๊ตํ๊ณผ๋ ์๋นํ ๋น์ทํ์ง๋ง ๋ ์ ์ ์ค๋ฒํค๋๋ฅผ ๊ฐ์ง๋ค. stack ์์ญ์ ์ ์ธํ ๋ชจ๋ ๋ฉ๋ชจ๋ฆฌ๋ฅผ ๊ณต์ ํ๊ธฐ ๋๋ฌธ์ Context switching ๋ฐ์์ Stack ์์ญ๋ง ๋ณ๊ฒฝํ์ฌ ์งํํ๋ฉด ๋๋ค.
๋จ์ผ ์ค๋ ๋ ํ๋ก๊ทธ๋จ์ ์๊ตฌ๊ฐ ๋์ฐฉํ ๋๋ง๋ค ์๋ก์ด ํ๋ก์ธ์ค๋ฅผ ์์ฑํ๊ณ
๋ฌธ๋งฅ๊ตํ์ ์ค๋ฒํค๋๊ฐ ๋ฐ์ํ์ง๋ง, ๋ค์ค ์ค๋ ๋๋ผ๋ฉด ํด๋น ์๊ตฌ์ ๋ํด์ ์ค๋ ๋๋ก ์ฒ๋ฆฌ
ํ๋ฏ๋ก ๋ฌธ๋งฅ๊ตํ ๋น์ฉ์ด ๊ฐ์ํ๋ค.
a. Register values
b. Heap memory
c. Global variables
d. Stack memory
b
,c
์ฌ์ฉ์ ์์ค ์ค๋ ๋๋ OS์์ ๋จ์ผ ํ๋ก์ธ์ค๋ก๋ง ํด์๋๋ฉฐ ๋ณ๋์ ํ๋ก์ธ์์์ ํ๋ก์ธ์ค์ ๋ค๋ฅธ ์ค๋ ๋๋ฅผ ์ค์ผ์ฅด๋งํ์ง ์์ต๋๋ค. ์ด๋์ด ์ํฉ์์ ์ฑ๋ฅ์์ ์ด์ ์ด ์์์ ๊ฐ๋ ฅํ ์์ฌํฉ๋๋ค.
์ด๋ค ์ค๋ ๋๊ฐ ์ด๋ค ํ๋ก์ธ์ค์ ํด๋นํ๋์ง ์๋ณํ๊ณ Accounting์ ํ ๋ ์ถ๊ฐ์ ์ธ ๋ณต์ก์ฑ์ด ์๊ตฌ๋๋ค. ํ์ง๋ง ์ค์ผ์ฅด๋ง์ ๊ตฌ๋ณํ์ง ์๊ธฐ ๋๋ฌธ์ ๋ ๋จ์ํ๊ฒ ๊ตฌํ ํ ์ ์๋ค.
fork() ๋ช
๋ น์ด๋ฅผ ์ํํ๋ฉด ๋ถ๋ชจ ํ๋ก์ธ์ค์ ์๋ฃ๊ตฌ์กฐ๋ฅผ ๋ณต์ฌํ์ง๋ง clone() ๋ช
๋ น์ด๋ฅผ ์ํํ๋ฉด ์ ๋ฌ๋ ํ๋๊ทธ๊ฐ ๋ค๋ฅด๋ฉฐ, ๋ถ๋ชจ ํ๋ก์ธ์ค์ ์๋ฃ๊ตฌ์กฐ๋ฅผ ํฌ์ธํ
ํ๋ค.
ํ ์ค๋ ๋์์ ์ค๋ฅ๊ฐ ๋ฐ์ํ๋ฉด ํ๋ก์ธ์ค ์์ฒด์ ์ค๋ฅ๋ก ๋ฒ์ง๊ธฐ ๋๋ฌธ์ ๋ค๋ฅธ ์ค๋ ๋๋ค๋ ์ ๋ถ ์ข ๋ฃ๋๋ ๋ถ์์ฉ์ด ์๊ธด๋ค. ๋ฐ๋ผ์ ๊ฐ๋ณ ํ๋ก์ธ์ค๋ก ์์ฉํ๋๊ฒ ๋ง๋ค.
์ฌ์ฉ์์ ์ธ์ง๋ณด๋ค ๋น ๋ฅด๊ฒ ๋ฌธ๋งฅ๊ตํ์ ํ๋ค๋ฉด concurrencyํ๊ฒ ๋๋ ์ ์๋ค.
์๋ฌ์ ๋ฒ์น
S๋ ์์ฐจ์ํ ๋ถ๋ถ์ด๊ธฐ ๋๋ฌธ์ 40percent์ธ 0.4์ด๊ณ , N์ a์์ 2, b์์ 4์ด๋ค.
๊ฐ๊ฐ์ ๊ณ์ฐ ๊ฒฐ๊ณผ๊ฐ์ (a) <= 1 / 0.4+0.3 = ์ฝ 1.42
, (b) <= 1 / 0.4+0.15 = ์ฝ 1.81
๋ฐ์ดํฐ ๋ณ๋ ฌ์ฑ
๋ฐ์ดํฐ ๋ณ๋ ฌ์ฑ์ ์ ์ฒด ๋ฐ์ดํฐ๋ฅผ ์๋ธ ๋ฐ์ดํฐ๋ค๋ก ๋๋ ํ
์๋ธ ๋ฐ์ดํฐ๋ค์ ๋ณ๋ ฌ ์ฒ๋ฆฌํ์ฌ ์์ ์ ๋น ๋ฅด๊ฒ ์ํํ๋ ๊ฒ์ ๋งํ๋ค.
ํ์คํฌ ๋ณ๋ ฌ์ฑ
ํ์คํฌ ๋ณ๋ ฌ์ฑ์ ์๋ก ๋ค๋ฅธ ์์ ์ ๋ณ๋ ฌ ์ฒ๋ฆฌํ๋ ๊ฒ์ ๋งํ๋ค.
ex) ์น ์๋ฒ๋ ๊ฐ๊ฐ์ ํด๋ผ์ด์ธํธ์์ ์์ฒญํ ๋ด์ฉ์ ์ค๋ ๋๋ก ๋ณ๋ ฌ๋ก ์ฒ๋ฆฌํ๋ค.
โข The multithreaded statistical program described in Exercise 4.21
์ธ๊ฐ์ ์ค๋ ๋๋ก ๊ฐ๊ฐ์ ๊ฐ์ ๊ตฌํ๋ ํ์คํฌ ๋ณ๋ ฌ์ค
โข The multithreaded Sudoku validator described in Project 1 in this
chapter 2๊ฐ์ ์ค๋ ๋๋ก ํ๋ ฌ์ ๊ฒ์ฌ(ํ์คํฌ ๋ณ๋ ฌ์ฑ)ํ๊ณ , 9๊ฐ์ ์ค๋ ๋๋ก 3x3 9๊ฐ์ ๋ถ๋ถ์ ๊ฐ๊ฐ ๊ฒ์ฌ(๋ฐ์ดํฐ ๋ณ๋ ฌ์ฑ)ํ๋ค.
โข The multithreaded sorting program described in Project 2 in this
chapter ์ ์ฒด ๋ฐ์ดํฐ๋ฅผ 2๊ฐ๋ก devide(๋ฐ์ดํฐ ๋ณ๋ ฌ์ฑ)ํ์ฌ ์ ๋ ฌํ๊ณ ์ค๋ ๋๋ฅผ mergeํ๋ค.
โข The multithreaded web server described in Section 4.1
์๋ฒ๋ ํด๋ผ์ด์ธํธ๋ก๋ถํฐ ์์ฒญ์ด ๋ค์ด์ค๋ฉด ๊ฐ๋ณ ์ค๋ ๋๋ก ์ฒ๋ฆฌํ๋ค (ํ์คํฌ ๋ณ๋ ฌ์ฑ)
๋ ๊ฐ์ ์ด์ค ์ฝ์ด ์ฒ๋ฆฌ๊ธฐ๋ ์ค์ผ์ค ๊ฐ๋ฅํ 4๊ฐ์ ์ฒ๋ฆฌ๊ธฐ๋ฅผ ๊ฐ์ง๊ณ ์๋ค. CPU-bound application์ด ์์คํ ์์ ์คํ์ค์ด๋ผ๊ณ ํ์. ๋ชจ๋ ์ ๋ ฅ์ ํ๋ก๊ทธ๋จ์ด ์์ํ ๋ ์ฃผ์ด์ง๊ณ ๋ฐ๋์ ํ๋์ ํ์ผ์ด ์ด๋ ค์ผ ํ๋ค. ๋ง์ฐฌ๊ฐ์ง๋ก ๋ชจ๋ ์ถ๋ ฅ์ ํ๋ก๊ทธ๋จ์ด ์ข ๋ฃ๋๊ธฐ ์ ์ ์ํ๋๋ค. ํ๋ก๊ทธ๋จ์ ๊ฒฐ๊ณผ๋ ํ๋์ ํ์ผ์ ๋ชจ๋ ๊ธฐ๋ก๋์ด์ผํ๋ค. ํ๋ก๊ทธ๋จ์ด ์์ํด์ ์ข ๋ฃํ ๋๊น์ง ํ๋ก๊ทธ๋จ์ CPU ์ง์ค์ ์ด๋ค. ์ฌ๋ฌ๋ถ์ ์ด ํ๋ก๊ทธ๋จ์ ๋ค์ค ์ค๋ ๋ํํ์ฌ ์ฑ๋ฅ์ ํฅ์์์ผ์ผํ๋ค. application์ ์ผ๋์ผ ์ค๋ ๋ ๋ชจ๋ธ์ ์ฌ์ฉํ๋ฉฐ ๊ฐ ์ฌ์ฉ์ ์์ค ์ค๋ ๋๋ ์ปค๋์ค๋ ๋์ ์ฌ์๋๋ค.
โข How many threads will you create to perform the input and output?
Explain. ์ธํ 1๊ฐ ์ค๋ ๋, ์์ํ 1๊ฐ ์ค๋ ๋
โข How many threads will you create for the CPU-intensive portion of
the application? Explain. 4๊ฐ ์ค๋ ๋ ๋ชจ๋ ํ ๋น.
a. How many unique processes are created?
6๊ฐ์ ํ๋ก์ธ์ค๊ฐ ์์ฑ๋๋ค.
b. How many unique threads are created?
8๊ฐ์ ์ค๋ ๋๊ฐ ์์ฑ๋๋ค. (4๊ฐ์ ๋จ์ผ ์ค๋ ๋ ํ๋ก์ธ์ค + 2๊ฐ์ ๋๋ธ ์ค๋ ๋ ํ๋ก์ธ์ค)
โข The initial call to fork() (labeled โ1โ above) creates a copy of the original process (2 processes at this point)
โข The second call to fork() (labeled โ2โ above) is executed only by the child process from the first fork() call. (3 processes at this point)
โข There are now two processes executing the code inside the if statement, meaning both of those processes call thread_create() (3 processes, 2 threads)
o What should have been made clear in the original assignment is that each newly created thread starts a different function than the one currently executingโone of the arguments to a thread_create() function is a pointer to the function to begin executing. The threads therefore donโt move on to the last fork() call.
โข All three processes execute the final call to fork() (labeled โ4โ above), so each process copies itself at that point (6 processes, 2 threads)
However, Peter brought to my attention the fact that the above solution does not account for the fact that each process starts as a single thread of execution. A better solution would be to say that this code segment creates a total of six processes and eight threads (two threads created by calls
to thread_create() and six threads corresponding to the six single-threaded processes).
attr : ์ค๋ ๋ ํน์ฑ ์ง์
pthread_create : ์ค๋ ๋ ์์ฑ, ํนํ ์ธ๋ฒ์งธ ์ธ์๋ ์ค๋ ๋ ์์์ ์คํํ ์ค๋ ๋ ํจ์.
pthread_join : ์ค๋ ๋์ ์ข
๋ฃ๋ฅผ ๊ธฐ๋ค๋ฆฐ๋ค.
child : 5
, parent : 0
a. The number of kernel threads allocated to the program is less than
the number of processing cores.
๋ชจ๋ ์ปค๋ ์ค๋ ๋๋ 1๋1๋ก ๋์ํ์ฌ ์๋น์ค๋ฅผ ๋ฐ๊ณ , ์ผ๋ถ ํ๋ก์ธ์ฑ ์ฝ์ด๋ idle ์๊ฐ์ ๊ฐ์ง๋ค.
b. The number of kernel threads allocated to the program is equal to
the number of processing cores.
๋ชจ๋ ์ปค๋์ค๋ ๋๋ ํ๋ก์ธ์์ 1๋1 ๋์ํ์ฌ ์๋น์ค๋ฅผ ๋ฐ๋๋ค. ๊ทธ๋ ์ง๋ง ๋ง์ฝ ์ปค๋์ค๋ ๋์ ๋ด์(block)๊ฐ ๋ฐ์ํ๋ค๋ฉด (ํ์ด์ง ๋ถ์ฌ, ์์คํ
์ฝ ๋ฑ์ ์ด์ ๋ก) ๋์ํ๋ ํ๋ก์ธ์๋ idle ์๊ฐ์ ๊ฐ์ง๊ฒ ๋๊ฒ ๋ค.
c. The number of kernel threads allocated to the program is greater
than the number of processing cores but less than the number of
user-level threads.
์๋น์ค ๋ฐ์ผ๋ ค๊ณ ๊ฒฝ์์ด ์์๋๋ค. pcs์ scs๊ฐ ๋ ๋ค ๋ฐ์ํจ.
โข PCS(Process contention scope) : ํ๋ก์ธ์ค ๊ฒฝ์ ๋ฒ์(PSC)์ด๋ค. (LWP ํฌํจ)
โข SCS(System contention scope) : ์ปค๋ ์ค๋ ๋ ๊ฐ์ ๊ฒฝ์ ๋ฒ์
I/O ๋ฐ์ด๋ ํ๋ก๊ทธ๋จ์ CPU์ ์ ์ ์จ์ด ๋ฎ๊ณ ์์ฃผ I/O ์ฒ๋ฆฌ๋ฅผ ํ๋ฌ ๊ฐ๊ธฐ ๋๋ฌธ์ CPU Burst time์ด ์งง๊ณ , CPU ๋ฐ์ด๋ ํ๋ก๊ทธ๋จ์ Burst time์ด ๊ธธ๋ค. ๋ฐ๋ผ์ CPU ๋ฐ์ด๋ ํ๋ก๊ทธ๋จ์ด CPU๋ฅผ ์ค๋ซ๋์ ์ ์ ํ๋ฉด ๋ค๋ฅธ ํ๋ก์ธ์ค๋ค์ด ์ค๋ซ๋์ ๊ธฐ๋ค๋ฆฌ๋ Convoy effect(ํธ์ ํจ๊ณผ)๊ฐ ๋ฐ์ํ๋ค.
a. CPU utilization and response time
CPU ์ฌ์ฉ๋์ ๋๋ฆฌ๋ ค๋ฉด Context switch๋ฅผ ์ต์ํํ๋ฉด ๋์ง๋ง, ๊ทธ๋ด ๊ฒฝ์ฐ ํ ํ๋ก์ธ์ค๊ฐ ์ค๋ CPU๋ฅผ ์ ์ ํ๋ ํธ์ ํจ๊ณผ๊ฐ ๋ฐ์ํ ์ ์๊ธฐ๋๋ฌธ์ response time์ ์ปค์ง๊ฒ(๋๋ ค์ง๊ฒ) ๋๋ค.
b. Average turnaround time and maximum waiting time
์งง์ ์์
๋ถํฐ ์ค์ผ์ฅด๋ง ํ๊ณ ์๋น์ค ํ๋ค๋ฉด ํ๊ท turnaround time์ ์ค์ด๋ค์ง๋ง, ๋ฌดํ์ waitingํ๋ ๊ธฐ์์ํ๊ฐ ๋ฐ์ํ ์ ์๋ค.
c. I/O device utilization and CPU utilization
CPU์ ์ฌ์ฉ๋์ ์ต๋ํํ๋ ค๋ฉด CPU ๋ฐ์ด๋ ํ์คํฌ๋ฅผ ์ํํ๋๊ฒ ๋ง๊ณ , I/O์ฅ์น์ ๊ฒฝ์ฐ I/O ๋ฐ์ด๋ ํ์คํฌ๋ฅผ ์ํํ ๋ ์ฌ์ฉ๋์ด ์ต๋๊ฐ ๋๊ณ ๊ณผ์ ์์ ๋ฌธ๋งฅ๊ตํ์ด ๋ง์ด ์ผ์ด๋๊ฒ ๋๋ค.
a. alpha๊ฐ 0 ์ด๋ผ๋ ์๋ฆฌ๋ ํ์ฌ์ ๊ฐ์ ๋ํด์ ๋ฐ์์ ํ์ง ์๊ฒ ๋ค๋ ๋ป์ด๊ธฐ ๋๋ฌธ์ burst time์ ํญ์ 100์ด ๋์ค๊ฒ ๋๋ค.
b. alpha๊ฐ 0.99๋ผ๋ ๊ฒ์ ํ์ฌ์ ๊ฐ์ ๋ํ ๋ฐ์๋ฅ ์ 99ํผ์ผํธ๋ก ํ๊ณ ๊ณผ๊ฑฐ์ ๋ฐ์ดํฐ๋ค์ 1ํผ์ผํธ๋ง ๋ฐ์ํ๋ค๋ ์ด์ผ๊ธฐ์ด๋ค. ์ด์ ์ burst ๊ฐ์ ๊ฑฐ์ ๋์ผํ๊ฒ ์ฌ์ฉํ๋ค๋ ๋ป์ด ๋๋ค.
a. Draw four Gantt charts illustrating the execution of these processes
using FCFS, SJF, a nonpreemptive priority (a smaller priority number implies a higher priority), and RR (quantum = 1) scheduling.
b. What is the turnaround time of each process for each of the scheduling algorithms in part a?
c. What is the waiting time of each process for each of the scheduling
algorithms in part a?
d. Which of the schedules in part a results in the minimal average
waiting time (over all processes)?
a. First-come, first-served
b. Shortest job first
c. Round robin
d. Priority
b
,d
a. What would be the effect of putting two pointers to the same process in the ready queue?
b. What would be the major advantages and disadvantages of this scheme?
c. How would you modify the basic RR algorithm to achieve the same effect without the duplicate pointers?
a. ํ๋ก์ธ์ค๋ ๋ ์์ฃผ ์๊ฐ์ ํ ๋น๋ฐ๊ฒ ๋๋ค. ๋ฐ๋ผ์ ์ฐ์ ์์๊ฐ ๋์์ง๋ค.
b : ์ค์ํ ํ๋ก์ธ์ค ์ฐ์ ์์๋ฅผ ๋์ผ ์ ์๋ค. ๋ ์ค์ํ ์์
์ ๋ฐ๋ ค๋ ์ ์๋ค.
c : ๋์ ์ฐ์ ์์๋ฅผ ๊ฐ์ง ํ๋ก์ธ์ค์ ๊ธด ์๊ฐ์ ํ ๋นํ๋ค. RR ์ค์ผ์ค์์ ๋ ๋ง์ ํํ
์ ์ค๋ค.
What is the CPU utilization for a round-robin scheduler when:
a. The time quantum is 1 millisecond
b. The time quantum is 10 milliseconds
a. time quantum์ด 1ms ์ด๋ฏ๋ก, 1ms + 0.1ms = 1.1ms๊ฐ ๋๊ณ , ์ฌ์ฉ์๊ฐ์ 1ms๊ฐ ๋๋ค. ๋ฐ๋ผ์ CPU ์ฌ์ฉ๋ฅ ์ 1/1.1 100 = 91(%)์ด๋ค.
b. time quantum์ด 10ms ์ด๋ค. 10๊ฐ์ 1.1ms์ 1๊ฐ์ 10.1ms์ ์์
์ด ์ด ๊ฑธ๋ฆฐ ์๊ฐ์ด๊ณ , ์ค์ ์ฌ์ฉ ์๊ฐ์ 110.1ms์ ๋บ 20ms์ด๋ค. ๋ฐ๋ผ์ 20/21.1 *100 = 94(%) ์ด๋ค.
๋ต : OS ๊ด์ ์์๋ User job ํ์ ์๊ฐ ํ ๋น์ ๋ค๋ฅธ ํ๋ค๋ณด๋ค ๋๋ ค์ค๋ค.
๋ ๋์๊ฐ๊ธฐ : ์ค์ผ์ฅด๋ง ์๊ณ ๋ฆฌ์ฆ์ด ํ์์ฌ๋ผ์ด์ค๋ฅผ ์ฑ์ฐ์ง ์๊ณ ๋๋ ํ๋ก์ธ์ค์ ๋ํด์ ์ฐ์ ์์๋ฅผ ๋์ฌ์ฃผ๋ ๋ฐฉ์์ผ๋ก ์ค๊ณ๋์๋ค๋ฉด, ์ฆ ๋ฉํฐ๋ ๋ฒจํ ์ค ๋ฉํฐ ๋ ๋ฒจ ํผ๋๋ฐฑ ํ๋ก์ ์ค๊ณ ๋์๋ค๋ฉด, ํ๋ก๊ทธ๋จ์ ์๊ฐ ํํ ์ ์์ ํ ํ์ฉํ์ง ์์์ผ๋ก์จ ํ ๋น๋๋ CPU ์๊ฐ์ ์ต๋ํํ ์ ์๋ค. ํ ๋น๋ ํํ ์ ๋ง์ ๋ถ๋ถ์ ์ฌ์ฉํ ์ ์์ง๋ง, ํํ ์ด ๋๋๊ธฐ ์ ์ CPU๋ฅผ ํฌ๊ธฐํ์ฌ ํ๋ก์ธ์ค์ ๊ด๋ จ๋ ์ฐ์ ์์๋ฅผ ์ฆ๊ฐ์ํจ๋ค.
๋ค์ค ์์ค ํผ๋๋ฐฑ ๋๊ธฐ์ด์ ํน๋ณํ CPU ์์ฝ์ ๊ตฌํํฉ๋๋ค. ํ๋ก์ธ์ค๊ฐ ํ ๋น๋ ์ ์ฒด ํํ ์ ์ฌ์ฉํ์ง ์๋ ๊ฒฝ์ฐ OS๋ ์ด ํ๋ก์ธ์ค๊ฐ ์ผ๋ถ I/O ๋๋ฐ์ด์ค๋ฅผ ๊ธฐ๋ค๋ฆฌ๊ณ ์๋ค๊ณ ๊ฐ์ ํฉ๋๋ค. ๋ฐ๋ผ์ ๋์ค์ CPU๋ฅผ ์ต๋ํ ๋นจ๋ฆฌ ๊ฐ์ ธ์ฌ ์ ์๋๋ก ์ฐ์ ์์๊ฐ ๋์ ๋๊ธฐ์ด์ ๋ณด๊ดํด์ผ ํฉ๋๋ค. ๋ฐ๋ฉด์, ํ๋ก์ธ์ค๊ฐ ํ ๋น๋ ์ ์ฒด ์๊ฐ ํํ ์ ์ฌ์ฉํ๋ ๊ฒฝ์ฐ, OS๋ ์ด ํ๋ก์ธ์ค๊ฐ ์๊ฐ์ด ๋ง์ด ๊ฑธ๋ฆฌ๋ ํ๋ก์ธ์ค๋ผ๊ณ ์๊ฐํ์ฌ ์ฐ์ ์์๊ฐ ๋ฎ์ ๋๊ธฐ์ด๋ก ์ด๋ํฉ๋๋ค. ์ด๋ ๊ฒ ํ๋ฉด ์์คํ ์ ํญ์ ์๋ก์ด ํ๋ก์ธ์ค๋ฅผ ์ ํธํ๊ณ ๋จผ์ ์คํํฉ๋๋ค.
๋ฐ๋ผ์ CPU ์๊ฐ์ ์ต๋ํํ๊ธฐ ์ํด ์ฌ์ฉ์ ํ๋ก์ธ์ค๋ ๋์ ์ฐ์ ์์ ๋๊ธฐ์ด์ ๋จธ๋ฌด๋ฅด๊ณ 1ํ ์์ ๋ด์ ์๋ฃ๋์ง ์์ ๋ ๋ฎ์ ์ฐ์ ์์ ๋๊ธฐ์ด์ ํธ์๋์ง ์๊ธฐ๋ฅผ ์ํฉ๋๋ค. I/O ๊ฒฝ๊ณ ํ๋ก์ธ์ค๋ก ๊ฐ์ฅํ๋ ๊ฒ์ด ์ ๋ต์ ๋๋ค. ์ฒซ ๋ฒ์งธ ๋จ๋ฝ์์ ์ค๋ช ํ ๋ฉ์ปค๋์ฆ์ ๋ฐ๋ฅด๋ฉด, ํ๋ก์ธ์ค๊ฐ ์๊ฐ ํํ ์ ์ฌ์ฉํ์ง ์๊ณ CPU์ ๋จ์ ์์ผ๋ฉด OS๋ I/O ๊ฒฝ๊ณ ํ๋ก์ธ์ค๋ก ๊ฐ์ฃผํ์ฌ ๋์ ์ฐ์ ์์ ๋๊ธฐ์ด์ ๋ณด๊ดํฉ๋๋ค.
์ ๋ฆฌํ์๋ฉด running ์ํ์์๋ B์ rate๋ก ๋ณํ๋ ์ฐ์ ์์, ready ์ํ์์๋ A์ rate๋ก ๋ณํ๋ค.
B>A>0์ธ ๊ฒฝ์ฐ : running ์ํ์ ์๋ ํ๋ก์ธ์ค์ ์ฐ์ ์์๊ฐ ๊ฐ์ฅ ๋์์ง๋ค๋ ๋ง์ ์ฆ ๋จผ์ ๋ค์ด์จ๊ฒ ๋จผ์ ๋๊ฐ๋ค๋ ์๋ฏธ์ด๋ค. FIFO(FCFS)
A<B<0์ธ ๊ฒฝ์ฐ : ๋ง์ง๋ง์ผ๋ก ready ํ๋ก ์ง์
ํ ํ๋ก์ธ์ค์ ์ฐ์ ์์๊ฐ ๊ฐ์ฅ ๋๋ค. LIFO
*discriminate in favor of (~๋ฅผ ์ฐ๋ํ๋ค)
a. FCFS
b. RR
c. Multilevel feedback queues
a. ready queue์ ๋ค์ด์จ ์์๋๋ก ์๋น์ค๋ฅผ ํ๋ ๋ฐฉ์์ด๋ค. ์งง์ ์์
์ ์ฐ๋ํ๊ฑฐ๋ ๋จผ์ ์ฒ๋ฆฌํ์ง ์๋๋ค.
b. time slice ๋จ์๋ก ํ๋ก์ธ์ค๋ค์๊ฒ ๊ณต์ ํ๊ฒ CPU์์์ ํ ๋นํ๋ค. ์งง์ ์์
์ ์ฐ๋ํ๊ฑฐ๋ ๋จผ์ ์ฒ๋ฆฌํ์ง ์์ง๋ง, ํ์ ์ฌ๋ผ์ด์ค ์์์ ๋๋ฑํ๊ฒ ์ฒ๋ฆฌ๋๊ธฐ ๋๋ฌธ์ ์งง์ ์์
์ด FCFS๋ณด๋ค ์๋์ ์ผ๋ก ๋น ๋ฅด๊ฒ ๋๋ธ๋ค.
c. ์ฌ๋ฌ ๋จ๊ณ์ ํ๋ฅผ ๋๊ณ , ์ฒซ๋ฒ์งธ ํ์์ ๋๋์ง ์๋ ์์
์ ์๊ฐ์ด ์ค๋ ๊ฑธ๋ฆด ๊ฒ์ด๋ผ๊ณ ๊ฐ์ ํ๋ฉฐ ๋ค์ ํ๋ก ์ด๋์ํจ๋ค. ์งง์ ์์
์ ์ต์ด์ ํ์์ ์ฒ๋ฆฌ๋๋ ํธ์ด๊ธฐ ๋๋ฌธ์ ์งง์ ์์
์ ์ฐ๋ํ๋ค.
ํน์ ์ด ํด์ฆ ์ด๋ ์ฑ ์ด๋ ์๋ฃ์์ ๊ฐ์ ธ์ค์ ๊ฑด์ง ์ฌ์ญค๋ด๋ ๋ ๊น์?