0. Overview
1) Thread๋ : A basic unit of CPU utilization
- thread ID, a program counter (PC), a register set, and a stack ์ผ๋ก ๊ตฌ์ฑ๋จ
- ๊ฐ์ process์ ๋ค๋ฅธ ์ฐ๋ ๋์ code section, data section, and other operating-system resources ๊ณต์ ํจ
2) Single / Multithreaded Processes
๊ฒฝ์ฐ์ ๋ฐ๋ผ ๋จ์ผ ์์ฉ ํ๋ก๊ทธ๋จ์ด ์ฌ๋ฌ ๊ฐ์ ์ ์ฌํ ์์
์ ์ํํด์ผ ํ ์ ์์ต๋๋ค. ์๋ฅผ ๋ค์ด, ์น ์๋ฒ๋ ์น ํ์ด์ง, ์ด๋ฏธ์ง, ์๋ฆฌ ๋ฑ์ ๋ํ ์์ฒญ์ ์๋ฝํด์ผ ํ ์ ์์ต๋๋ค. ์ด๋ฌํ ์์ฒญ์ ์ฒ๋ฆฌํ๋ ํ ๊ฐ์ง ํด๊ฒฐ ๋ฐฉ๋ฒ์ ์๋ฒ๋ฅผ ํด๋ผ์ด์ธํธ ์์ฒญ์ ์๋ฝํ๋ ๋จ์ผ ํ๋ก์ธ์ค๋ก ์คํํ๋ ๊ฒ์
๋๋ค. ์๋ฒ๋ ์์ฒญ์ ์์ ํ ๋ ํด๋น ์์ฒญ์ ์ฒ๋ฆฌํ๋ ๋ณ๋์ ํ๋ก์ธ์ค๋ฅผ ์์ฑํ ์ ์์ต๋๋ค. ๊ทธ๋ฌ๋ ์ด ์ ๊ทผ ๋ฐฉ์์๋ ํ๋ก์ธ์ค ์์ฑ์ ๋ฆฌ์์ค๊ฐ ๋ง์ด ์๋ชจ๋๊ณ ์๊ฐ์ด ๋ง์ด ์์๋๋ฏ๋ก ๋ช ๊ฐ์ง ๋จ์ ์ด ์์ต๋๋ค.
๋ค๋ฅธ ๋ฐฉ๋ฒ์ ๋ฉํฐ์ค๋ ๋ฉ์ ์ฌ์ฉํ๋ ๊ฒ์
๋๋ค. ์ด ์ ๊ทผ ๋ฐฉ์์์ ์น ์๋ฒ ํ๋ก์ธ์ค๋ ํด๋ผ์ด์ธํธ ์์ฒญ์ ์์ ํ๊ธฐ ์ํด ๋ณ๋์ ์ค๋ ๋๋ฅผ ์์ฑํ ์ ์์ต๋๋ค. ์์ฒญ์ด ์์ ๋ ์๋ฒ๋ ์ ํ๋ก์ธ์ค๋ฅผ ๋ง๋๋ ๋์ ์ถ๊ฐ ์์ฒญ์ ๊ณ์ ์์ ํ๋ ๋์ ํด๋น ์์ฒญ์ ์ฒ๋ฆฌํ ์ ์ค๋ ๋๋ฅผ ์์ฑํ ์ ์์ต๋๋ค. ์ด ๋ฐฉ๋ฒ์ ๊ฐ ์์ฒญ์ ๋ํด ์ ํ๋ก์ธ์ค๋ฅผ ๋ง๋๋ ๊ฒ๋ณด๋ค ๋ ํจ์จ์ ์
๋๋ค. ๋ฆฌ์์ค ๋ฐ ์๊ฐ ์ธก๋ฉด์์ ์ค๋ ๋ ์์ฑ ๋น์ฉ์ด ๋ ๋ค๊ธฐ ๋๋ฌธ์
๋๋ค. ๋ํ ์ค๋ ๋๋ ๋์ผํ ํ๋ก์ธ์ค ๋ด์์ ๋ฉ๋ชจ๋ฆฌ์ ๋ฆฌ์์ค๋ฅผ ๊ณต์ ํ ์ ์์ผ๋ฏ๋ก ์ฑ๋ฅ์ ํฅ์์ํฌ ์๋ ์์ต๋๋ค.
๋๋ถ๋ถ์ os system kernel์ ๋ฉํฐ์ค๋ ๋์
๋ฉํฐ์ค๋ ๋์ ์ฅ์
- Responsiveness : ์ผ๋ถ๊ฐ ๋งํ๊ฑฐ๋ ๋๋ฌด ์ค๋ ์๊ฐ ์ํํ๋๋ผ๋ ๊ณ์ ์คํ์ด ๊ฐ๋ฅํจ
- Resource Sharing : ํ๋ก์ธ์ค๋ shared memory์ message passing๊ณผ ๊ฐ์ ๊ธฐ์ ์ ํตํด ๋ฆฌ์์ค๋ฅผ ๊ณต์ ํ ์ ์์
- Economy : threads๊ฐ resource๋ฅผ ๊ณต์ ํ๊ธฐ ๋๋ฌธ์, context-switch, create thread๊ฐ ๋์ฑ ๊ฒฝ์ ์ ์
- Scalability : ์ฐ๋ ๋๊ฐ ๋ค๋ฅธ ํ๋ก์ธ์ฑ core์์ ํํํ๊ฒ ์คํ๋๋ ๋ฉํฐํ๋ก์ธ์ ์์์ ๋ greater
1. Multicore Programming
1) Multicore Programming์ด๋
: ์ฌ๋ฌ computing cores๋ฅผ ๋ณด๋ค ํจ์จ์ ์ผ๋ก ์ฌ์ฉํ๊ณ concurrency(๋์์ฑ)์ ํฅ์์ํค๋ ๋งค์ปค๋์ฆ
- single computing core
- ์๊ฐ๋น ์ฐ๋ ๋ 1๊ฐ ์ํ. ํ๋ก์ธ์ฑ ์ฝ์ด๊ฐ ํ ๋ฒ์ ํ๋์ ์ค๋ ๋๋ง ์คํํ ์ ์๊ธฐ ๋๋ฌธ์ ์ฐ๋ ๋ ์คํ์ด interleaved ๋จ (์ฌ๋ฌ๊ฐ ๋์๊ฐ๋ ์ฒ!!!)
- multiple cores
- ์ฐ๋ ๋ n๊ฐ ๋์ ์ํ. ์์คํ ์ด ๊ฐ ์ฝ์ด์ ๋ณ๋์ ์ค๋ ๋๋ฅผ ํ ๋นํ ์ ์๊ธฐ ๋๋ฌธ์ ์ผ๋ถ ์ค๋ ๋๊ฐ ๋ณ๋ ฌ์ ์ผ๋ก ์คํ๋ ์ ์์
- Parallelism : ์์คํ ์ด ๋ ๊ฐ ์ด์์ ์์ ์ ๋์์ ์ํํ ์ ์์
- Concurrency : ๋ชจ๋ ์์ ์ด ์งํ๋๋๋ก ํ์ฉํ์ฌ ๋์์ ๋ ์ด์์ ์์ ์ ์ง์ํจ
multicore system์ ํ๋ก๊ทธ๋๋ฐ ํ ๋ ํด๊ฒฐํด์ผ ํ๋ 5๊ฐ์ง ์์ญ
1. Identifying tasks
โ To find areas that can be divided into separate, concurrent tasks
2. Balance
โ Ensure that the tasks perform equal work of equal value
3. Data splitting
โ The data accessed and manipulated by the tasks must be divided to run on separate cores
4. Data dependency
โ The data accessed by the tasks must be examined for dependencies between two or more tasks
5. Testing and debugging
โ Testing and debugging such concurrent programs is inherently more difficult than testing and debugging single-threaded applications
Parallelism์ ์ข ๋ฅ
- Data parallelism
- ๊ฐ์ ๋ฐ์ดํฐ๋ฅผ multiple computing core๋ก ๋๋ ์ ๊ฐ core๊ฐ ๊ฐ์ operation์ ์ํํจ
- Task parallelism
- data๋ฅผ ๋๋์ง ์๊ณ , task๋ฅผ ๊ฐ core๊ฐ ๋๋ ๊ฐ์ง (๋์ผ ๋ฐ์ดํฐ ๋ค๋ฅธ operation)
2) Amdahl's Law
: ์ถ๊ฐ์ ์ผ๋ก computing core๋ฅผ ์ถ๊ฐํ์ ๋ ์ป์ ์ ์๋ performance(์๋ ํฅ์) ๊ณ์ฐํ๋ ๊ณต์
S : portion of the application that must be performed serially on a system (๋ฌด์กฐ๊ฑด ์ํ์ ํ๊ฒ ์ํ๋์ด์ผํ๋ ๊ฒ์ ์)
N : processing core ์
ํ๋ก๊ทธ๋จ์ด ๋ ๋ถ๋ถ์ผ๋ก ๊ตฌ์ฑ๋์ด ์๋๋ฐ ๊ทธ ์ค ํ๋๋ ๋ณ๋ ฌํํ ์ ์๊ณ ๋ค๋ฅธ ํ๋๋ ๋ณ๋ ฌํํ ์ ์๋ ๊ฒฝ์ฐ์. ์ต๋ ์๋ ํฅ์์ ๋ณ๋ ฌํํ ์ ์๋ ๋ถ๋ถ์ ์ํด ๊ฒฐ์ ๋จ.
N์ด ๋ฌดํ๋๋ก ๊ฐ๋ฉด, speed up coverge๋ 1 / S๋ก ์๋ ดํจ.
์ผ๋ถ๋ Amdahl's Law๊ฐ ํ๋์จ์ด์ ํฅ์์ ๊ณ ๋ คํ์ง ์์๋ค๊ณ ๋งํ๊ธฐ๋...
S๊ฐ ํด ์๋ก, ์ฆ ๋ณ๋ ฌํ ๋ถ๊ฐ๋ฅํ ๊ฒ์ด 50%๋ฉด ์ต๋ 2๋ฐฐ๊น์ง๋ง ์ฆ๊ฐํ ์ ์์
2. Multithreading Models
User Threads : ์ปค๋ ์์์ ์ง์๋๋ฉฐ ์ปค๋ ์ง์ ์์ด ๊ด๋ฆฌ๋จ
kernal space: core์ ์ฐ๊ฒฐํ๋ bridge ์ญํ ์ ํจ. ์ด ์์ ์ปค๋ ๋ ๋ฒจ ์ค๋ ๋๊ฐ ์กด์ฌํจ
์ด ์์ ์๋ user space์ ์๋ ๊ฒ์ด ์ ์ ๋ ๋ฒจ ์ค๋ ๋!
Thread library๋ thread๋ฅผ ์์ฑํ๊ฑฐ๋ ์์ ๋ ์ฝ๋, threads๊ฐ ๋ฐ์ดํฐ์ ๋ฉ์์ง๋ฅผ ๋๊ฒจ์ฃผ๋ ์ฝ๋, thread execution์ ์ค์ผ์ค๋งํ๋ ์ฝ๋, thread context๋ฅผ ์ ์ฅํ๊ฑฐ๋ ๋ถ๋ฌ์ค๋ ์ฝ๋๋ฅผ ํฌํจํ๊ณ ์์
์ฅ์
- Thread switching ํ ๋ kernel mode ๊ถํ์ ํ์๋ก ํ์ง ์๋๋ค
- ์ ์ ์ค๋ ๋๋ ์ด๋ os์์๋ ์คํ๋๋ค
- ์ ์ ์ค๋ ๋๋ ๋ง๋ค๊ณ ๊ด๋ฆฌํ๋๊ฒ ๋น ๋ฅด๋ค
๋จ์
- ํ ์ ์ ์ค๋ ๋๊ฐ blocking operation์ ์ํํ๋ฉด ๋ชจ๋ ํ๋ก์ธ์ค๊ฐ blocked ๋๋ค
- ๋ฉํฐ์ค๋ ๋ application์ multiprocessing์ ์ด์ ์ ๊ฐ์ง ๋ชปํ๋ค.
- user thread๋ user level์์ ๊ด๋ฆฌ๋๊ธฐ ๋๋ฌธ์ ์ด์ ์ฒด์ ๊ฐ multiple process๋ฅผ ๋์ด์ scheduling thread ํ ์ ์์. ๋ฐ๋ผ์ user thread๋ฅผ ์ฌ์ฉํ๋ ๋ฉํฐ์ค๋ ๋ ์์ฉํ๋ก๊ทธ๋จ์ ๋ฉํฐํ๋ก์ธ์ฑ์ ํ์ฉํ๊ธฐ ์ด๋ ค์
kernel threads : OS์ ์ํด ์ง์ ์ ์ผ๋ก ์ง์๋๊ณ ๊ด๋ฆฌ๋๋ ์ค๋ ๋
์ฅ์
- ์ปค๋ ์ค๋ ๋์ ์๋ก ๋ค๋ฅธ ํ๋ก์ธ์์์ ๋์ผํ ํ๋ก์ธ์ค์ ๋ฉํฐ ์ค๋ ๋๋ฅผ ์ค์ผ์ค๋ง ํ ์ ์์
- ํ ํ๋ก์ธ์ค๊ฐ blocked ๋์ด๋, ์ปค๋์ด ๊ฐ์ ํ๋ก์ธ์ค์ ๋ค๋ฅธ ์ค๋ ๋๋ก ์ค์ผ์ค๋ง ํ ์ ์์
๋จ์
- ํ ์ค๋ ๋์์ ๋ค๋ฅธ ํ๋ก์ธ์ค๋ก ์ ์กํ๊ธฐ ์ํด์๋ ์ปค๋ ๋ชจ๋๋ก switch ํด์ผํจ
- ์ค๋ ๋ operation์ด user thread์ ๋นํด 100๋ฐฐ ์ด์ ๋๋ฆผ
์ปค๋์ด ์ฌ์ฉ์ ์์ค ์ค๋ ๋์ ์กด์ฌ๋ฅผ ์ธ์ํ์ง ๋ชปํ๊ณ ์ค๋ ๋๊ฐ ์๋ ํ๋ก์ธ์ค๋ฅผ ์์ฝํ๊ณ ๊ด๋ฆฌํ๊ธฐ ๋๋ฌธ์ ์ฌ์ฉ์ ์ค๋ ๋๊ฐ ์๋ ๋ค์ค ์ค๋ ๋ ์์ฉ ํ๋ก๊ทธ๋จ์์ ๋ค์ค ์ฒ๋ฆฌ๋ฅผ ์ต๋ํ ํ์ฉํ๊ธฐ ์ด๋ ต์ต๋๋ค. ์ด๋ ์ปค๋์ด ํ๋ก์ธ์ค ๋ด์์ ์ฌ์ฉ ๊ฐ๋ฅํ ์ค๋ ๋ ์์ ๊ด๊ณ์์ด ํ๋ก์ธ์ค์์ ํ ๋ฒ์ ํ๋์ ์ค๋ ๋๋ง ์์ฝํ ์ ์์์ ์๋ฏธํฉ๋๋ค. ๊ฒฐ๊ณผ์ ์ผ๋ก ์์คํ ์ ์ฌ๋ฌ ๊ฐ์ ํ๋ก์ธ์๊ฐ ์๋๋ผ๋ ํ ๋ฒ์ ํ๋์ ์ค๋ ๋๋ง ์คํํ ์ ์๊ณ ๋ค๋ฅธ ํ๋ก์ธ์๋ ์ ํด ์ํ๋ฅผ ์ ์งํ ์ ์์ต๋๋ค.
๋ฐ๋๋ก ์ปค๋ ์์ค ์ค๋ ๋๋ฅผ ์ฌ์ฉํ๋ฉด ์ปค๋์ด ํ๋ก์ธ์ค์ ๋ชจ๋ ์ค๋ ๋๋ฅผ ์ธ์ํ๊ณ ์ฌ๋ฌ ํ๋ก์ธ์์์ ์ค๋ ๋๋ฅผ ๋ณด๋ค ํจ์จ์ ์ผ๋ก ์์ฝํ ์ ์์ผ๋ฏ๋ก ์ค๋ ๋๊ฐ ๋์์ ์คํ๋๊ณ ๋ค์ค ์ฒ๋ฆฌ๋ฅผ ์ต๋ํ ํ์ฉํ ์ ์์ต๋๋ค. ๋ํ ์ปค๋ ์์ค ์ค๋ ๋๋ ์ฌ์ฉ์ ์์ค ์ค๋ ๋์์๋ ๋ถ๊ฐ๋ฅํ ์ ์ฒด ํ๋ก์ธ์ค๋ฅผ ์ฐจ๋จํ์ง ์๊ณ ์ฐจ๋จ ์์ ์ ์ํํ ์ ์์ต๋๋ค.
1) Many-to-One Model
์ฌ๋ฌ๊ฐ์ user thread - ํ๋์ kernel thread
ํ ๋ฒ์ ํ๋์ ์ค๋ ๋๋ง ์ปค๋์ ์ก์ธ์คํ ์ ์์ผ๋ฏ๋ก multicore system ์์์ ์ฌ๋ฌ ์ค๋ ๋๋ฅผ ๋ณ๋ ฌ๋ก ์คํํ ์ ์์.
2) One-to-One Model
user thread - kernel thread 1๋1 ๋์
many to one ๋ณด๋ค concurrency ! ๋์์ ์ฌ๋ฌ ์์ ์ฒ๋ฆฌ ๊ฐ๋ฅ
multiprocessor ์์ parallel ํ๊ฒ ์คํ๋จ
์ด ๋ชจ๋ธ์ ์ ์ผํ ๋จ์ ์ ์ ์ ์ค๋ ๋๋ฅผ ์์ฑํ๋ ค๋ฉด ํด๋น ์ปค๋ ์ค๋ ๋๋ฅผ ์์ฑํด์ผ ํ๋ฉฐ, ์ปค๋ ์ค๋ ๋๊ฐ ๋ง์์ ธ ์์คํ ์ฑ๋ฅ์ ๋ถ๋ด์ ์ค ์ ์๋ค๋ ๊ฒ์
3) Many-to-Many Model
one-to-one๊ณผ many-to-many์ ๋จ์ ์ ํด๊ฒฐํจ
์ ์ ์ค๋ ๋๋ ๊ทธ๊ฒ๊ณผ ๊ฐ๊ฑฐ๋ ์ ์ ์์ kernel thread์ ์ฐ๊ฒฐ๋จ. kernel thread์ ์๋ application์ด๋ machine์ ๋ฐ๋ผ ๊ฒฐ์ ๋ ์ ์์
โฆ many-to-one model์ ๊ฐ๋ฐ์๊ฐ ์ํ๋ ๋งํผ์ ์ ์ ์ค๋ ๋๋ฅผ ๋ง๋ค ์ ์์ง๋ง ์ปค๋์ด ํ ๋ฒ์ ํ๋์ ์ปค๋ ์ค๋ ๋๋ง ์์ฝํ ์ ์๊ธฐ ๋๋ฌธ์ ๋ณ๋ ฌ ์ฒ๋ฆฌ๊ฐ ๋์ง ์์
โฆ one-to-one model ์ ๋ ํฐ ๋์์ฑ์ ํ์ฉํ์ง๋ง ์์ฉํ๋ก๊ทธ๋จ ๋ด์ ๋๋ฌด ๋ง์ ์ค๋ ๋๋ฅผ ๋ง๋ค๊ฒ ๋ ์๋ ์์
• many-to-many model์
โฆ ๊ฐ๋ฐ์๋ ํ์ํ ๋งํผ์ ์ฌ์ฉ์ ์ค๋ ๋๋ฅผ ์์ฑํ ์ ์์ผ๋ฉฐ ํด๋น ์ปค๋ ์ค๋ ๋๋ ๋ฉํฐํ๋ก์ธ์์์ ๋ณ๋ ฌ๋ก ์คํ
โฆ ๋ํ ์ค๋ ๋๊ฐ blocking system call์ ์ํํด๋ ์ปค๋์ ๋ค๋ฅธ ์ค๋ ๋์ ์คํ์ scheldule ํ ์ ์์
4) Two-level Model
many-to-many model๊ณผ ๊ฑฐ์ ์ ์ฌํ์ง๋ง, ํ๋์ ์ ์ ์ค๋ ๋๊ฐ ํ๋์ ์ปค๋ ์ค๋ ๋๋ฅผ ๋ด๋นํ ์๋ ์์
'๐ก๐ธ๐ธ๐ถ5: ๐ฆ๐๐๐๐ถ ๐ฐ๐๐พ๐ > ์ด์์ฒด์ Operating Systems (COSE341)' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[์ด์์ฒด์ ] CH4. CPU Scheduling (0) | 2023.04.22 |
---|