๐ ๊ณต๋ฃก์ฑ ๊ธฐ๋ฐ์ผ๋ก ํ๊ต์์ ์์ ํ๋ ์ด์์ฒด์ ๋ฅผ ์ ๋ฆฌํฉ๋๋ค.
1๏ธโฃ Thread
(1) ๊ฐ๋
ํ๋์ ํ๋ก์ธ์ค๋ ์ฌ๋ฌ ๊ฐ์ ์ค๋ ๋๋ฅผ ๊ฐ์ง ์ ์๋ค. ์ค๋ ๋๋ ๋ญ๊น?
- Thread : CPU๋ฅผ ์ฌ์ฉํ๋ ๊ธฐ๋ณธ์ ์ธ ๋จ์ (Basic Unit of CPU utilization)
- ์ค๋ ๋ = ์ค = Execution flow(์คํ ํ๋ฆ)
์ค๋ ๋๋ฅผ ์ฌ์ฉํ ๋์ ํ์ง ์์ ๋ ํ๋ก๊ทธ๋๋ฐ ํ๋ ๋ฐฉ์๋ ์์ ๋ฌ๋ผ์ง๊ฒ ๋๋ค!
Single-Threaded์ผ ๋
: ๊ฐ์ ๊ณต๊ฐ์์(= ํ๋์ ํ๋ก์ธ์ค, ํ๋์ ์ค๋ ๋) task1() ํจ์๋ฅผ ์คํํ๊ณ ๋ ๋ค์์ task2() ํจ์ ์คํํ๋ค


Multi-Threaded์ผ ๋
: ์ฝ๋ ์์ฒด๋ ๊ฐ์ ๊ณต๊ฐ์ ์์ง๋ง(= ๊ฐ์ ํ๋ก์ธ์ค์ ์์ง๋ง), ๋ค๋ฅธ ์ค๋ ๋์์ ์คํ → task1()๊ณผ task2()๊ฐ ๋์์ ๊ฐ ์ค๋ ๋์์ ์์


๊ทธ๋ ๋ค๋ฉด ๊ฐ์ ํ๋์ ํ๋ก์ธ์ค๋๋ผ๋, ์ค๋ ๋๋ฅผ ๋ง๋ค์ด์ ์ฒ๋ฆฌํ๋ฉด ์ด๋ป๊ฒ ๋ค๋ฅผ๊น?
- ์ค๋ ๋ ๊ฐ๊ฐ ๊ฐ๋ณ๋ก ๊ฐ๋ ๋ถ๋ถ
- ๊ฐ์ Thread ID
- ๊ฐ์์ execution flow : flow์ ์งํ ํ์ → PC
- ๊ฐ์ ์ฒ๋ฆฌํ๋ ์ฝ๋๊ฐ ๋ค๋ฆ : Register
- ๊ฐ ์ค๋ ๋๊ฐ ์๋ก ๋ค๋ฅธ ํจ์๋ฅผ ํธ์ถ : Stack
- ์ค๋ ๋ ๊ฐ์ ๊ณต์ ํ๋ ๋ถ๋ถ
- ์ฝ๋, ์ ์ญ ๋ณ์, open files …

์ฆ, ๋ ํจ์๋ฅผ ๋์์ ์คํ์ํค๊ณ ์ถ์ ๋
์ฌ๋ฌ ๊ฐ์ ํ๋ก์ธ์ค๋ฅผ ๋ง๋๋ ๊ฒ (= Multi-Process)๊ณผ
์ฌ๋ฌ ๊ฐ์ ์ค๋ ๋๋ฅผ ๋ง๋๋ ๊ฒ(= Multi-Thread)์ ์ฐจ์ด๊ฐ ์๋ ๊ฒ์ด๋ค!
→ ์ฝ๋์ ์ ์ญ ๋ณ์๋ฅผ ๊ณต์ ํ๊ธฐ ๋๋ฌธ์ ์๋ก ๋ฌด์ธ๊ฐ๋ฅผ ์ฃผ๊ณ ๋ฐ๊ฑฐ๋ ํ๋ ์ปค๋ฎค๋์ผ์ด์ ํ๊ธฐ๊ฐ ์ฝ๋ค!

(2) Process in Memory
์ค๋ ๋๊ฐ ํ๋์ผ ๋์, ์ฌ๋ฌ ๊ฐ์ผ ๋ ํ๋ก์ธ์ค์์ ๋ฉ๋ชจ๋ฆฌ๋ฅผ ์ด๋ป๊ฒ ์ฌ์ฉํ๋์ง๋ฅผ ๊ทธ๋ฆผ์ผ๋ก ๋น๊ตํด๋ณด์.
๋ฉํฐ ์ค๋ ๋์ผ ๋๋ฅผ ๋ณด๋ฉด ์ค๋ ๋๋ง๋ค stack์ ๊ฐ๊ฐ ๊ฐ์ง๊ณ ๊ทธ ์์์ ๊ฐ ํจ์ ๋ถ๋ถ์ด ์ ์ฅ๋์ง๋ง, ์ ์ญ ๋ณ์ ๋ถ๋ถ(data)์ ๊ณต์ ํ๋ค!


- ๋ฉํฐ ์ค๋ ๋ ํ๋ก์ธ์ค๋ฅผ ํ์ ๋์ ์ฅ์ ์ ๋ฌด์์ผ๊น?
- Responsiveness(๋ฐ์์ฑ) : execution flow๊ฐ ์ฌ๋ฌ๊ฐ → ํ๋๊ฐ block ๋์ด๋ ๋ค๋ฅธ ๊ฒ์ ์ด์์๋ค = ๋ ์ข์ ๋ฐ์์ฑ ์ ๊ณต
- Resource sharing
- Economy : ์ง์ ์ด๋๋ ์ค๋ฅผ ๊ณต์ ํ๋๊น ํ๋ก์ธ์ค๋ฅผ ๋ง๋๋ ๊ฒ๋ณด๋ค ๋ ๊ฒฝ์ ์ ์ด๋ค
- Scalability : ๋ชจ๋ ์ฝ์ด ์ด์ฉํ ์ ์๊ฒ(์ฑ๊ธ์ด๋ฉด ์ฝ์ด๊ฐ ๋ช๊ฐ์ด๋ 1๊ฐ ์ฝ์ด๋ง ์ธ ์๋ฐ์ ์์ผ๋๊น)
(3) Use Cases
1. Multithreaded Server
: ์ธ์ ํด๋ผ์ด์ธํธ๊ฐ ์ ์ํ ์ง ๋ชจ๋ฅธ๋ค → ํด๋ผ์ด์ธํธ๊ฐ ์ ์์ ํ์ ๋ client๋ฅผ handlingํ๋ ์ฐ๋ ๋๋ฅผ ๋ง๋ ๋ค.
→ ์ฑ๊ธ์ด๋ฉด ํ๋์ ํด๋ผ์ด์ธํธ๋ง ํ ์ ์์ง๋ง, ๋ฉํฐ ์ค๋ ๋๋ฉด ์ฌ๋ฌ๋ช concurrent ๋์์ ์ฒ๋ฆฌํ ์ ์๊ฒ ๋๋ค.

2. Loop Pararellization
: Matrix Multiplication(ํ๋ ฌ๊ณฑ)์ ํ ๋ ํ๋์ ์ด๊ณผ ํ์ ๊ณฑํด์ ๋์์ parallel ํ๊ฒ ๋ณ๋ ฌ์ฒ๋ฆฌํ๋ค.
์ค๋ ๋๋ฅผ 2๊ฐ๋ง ํด๋ T → T/2 ๋ก ์ ๋ฐ์ ์๊ฐ์ด ์ ์ฝ ๊ฐ๋ฅํ๋ค.

2๏ธโฃ Parallelism vs Concurrency โญ๏ธโญ๏ธ
๋์ด ๋ค๋ฅธ ๊ฐ๋ ์ด๋ค! ์๋จ์ด๋ผ์ ํท๊ฐ๋ฆด ์ ์๋๋ฐ ๊ผญ ์ฐจ์ด๋ฅผ ๊ธฐ์ตํด๋์!
- Parallelism : ์ค์ ๋ก(physically) ๋ค๋ฅธ ์ฝ์ด์์ ๋ค๋ฅธ ํ ์คํฌ๊ฐ ๋์๊ฐ๋ ๊ฒ
- Concurrency : ํ๋์ ์ฝ์ด์ง๋ง, ์ค๋ ๋๊ฐ ์ฝ์ด๋ฅผ ๋๋ ์ ์ฌ์ฉํ์ ๋

Parallelism์ ๋ค์ ๋ ๊ฐ์ง ์ข ๋ฅ๋ก ๊ตฌ๋ถํ ์ ์๋ค.
- data : ํ๋ ์์ ์ ๋๊ฐ๋ค. ํ๋ ฌ๊ณฑ์ฒ๋ผ row์ col์ ๊ณฑํ๋ ์์ ์ ๋๊ฐ์ง๋ง ๋ฐ์ดํฐ๊ฐ ๋ถ๋ฆฌ๋ ๊ฒฝ์ฐ.
- task : ํ๋ ์ผ์ด ์๋ก ๋ค๋ฅผ ๋. ๋๋ ์ ์ฒ๋ฆฌ. (e.g server application์์ ๋ค๋ฅธ ๊ณ ๊ฐ ๋์์)

3๏ธโฃ Multicore Processing
Single-core์์ ์ฑ๋ฅ์ ๋์ด๊ธฐ ์ํด์ Logical core์ ์ ์ฆ๊ฐํ๋ ๋ฐฉ์(hyperthreading)์ผ๋ก ํ์ง๋ง, ํฅ์์ ํ๊ณ๊ฐ ์์๋ค.
๋ฐ๋ผ์, Multi-core๋ก ํ๊ฒ ๋๋ฉด parallel ์ด ๊ฐ๋ฅํ๋ฏ๋ก ์ด ๋ฐฉ์์ด ๋ฐ์ ํ๊ณ ์๋ค!
- Multi-core๋ Multi-Process๋ฅผ ์ฌ์ฉํ๋ ์์คํ
์์์ ์ด๋ ค์
- Identifying tasks (ํ์คํฌ ์ธ์)
- Balance
- Data Splitting
- Data Dependency ; Synchronization(๋๊ธฐํ), Data sharing(๋ฐ์ดํฐ ๊ณต์ )
- Testing and Debugging
+ ์ค๋ ๋ library๋ก๋ low level library์ธ POSIX Pthread๊ฐ ์๋ค!
4๏ธโฃ Amdahl’s Law โญ๏ธโญ๏ธ
: ์ต์ ํ ํ ์ ์๋ ๋ถ๋ถ ํ์ ๋์ด ์๊ธฐ ๋๋ฌธ์, ์ต์ ํ ๊ฐ๋ฅํ ๋ถ๋ถ์ ๋ฐ๋ผ์ ์ฝ์ด ์๊ฐ ์ฆ๊ฐํ ๋ ์ผ๋ง๋ ํ๋ก๊ทธ๋จ์ด ๋นจ๋ผ์ง์ง ๊ฒฐ์ ํ๋ ์

- S : serial portion = ๋ณ๋ ฌ ์ฒ๋ฆฌ๊ฐ ๋ถ๊ฐ๋ฅํ ๋น์จ
- N : processing cores ( N์ด ๋ฌดํ์ด๋ฉด, 1 / S ์ ๊ฐ๊น์์ง๋ค.)
์๋ฅผ ๋ค์ด์ ์ ๋ถ ๋ณ๋ ฌํ ๊ฐ๋ฅํ๋ค๋ฉด (ํ๋์ ์ฝ์ด์์ ๋ ๊ฑฐ๋ฅผ 2๊ฐ์ ์ฝ์ด์์→ ์๊ฐ์ด ์ ํํ ๋ฐ์ผ๋ก ์ค์ด๋ค๊ฒ ๋๋ค.)
speed up๊ฐ์ 2๊ฐ ๋๋ค. ์ฆ, ์ฝ์ด ์๊ฐ 1๊ฐ ๋์ด๋ ๋๋ง๋ค 2๋ฐฐ์ฉ ํ๋ก๊ทธ๋จ์ด ๋นจ๋ผ์ง๋ค.
์ ๋ฐ๋ง ๋ณ๋ ฌํ ๊ฐ๋ฅํ๋ค๋ฉด 1๊ฐ์ ์ฝ์ด์์ 2๊ฐ์ ์ฝ์ด๊ฐ ๋์ ๋ speed up ๊ฐ์ 100/75๊ฐ ๋๋ค.
์ฆ, 1๊ฐ์ ์ฝ์ด์์ 100์๊ฐ์ด ๊ฑธ๋ ธ๋ ์ผ์ 2๊ฐ์ ์ฝ์ด์์๋ 75์๊ฐ ๊ฑธ๋ ค์ ํ ์ ์๋ ๊ฒ์ด๋ค.
๋ฐ๋ผ์ ์ต๋ํ ์ค์ํ ๋ถ๋ถ, ๋ง์ ๋ถ๋ถ์ ์ต์ ํํ๋๊ฒ ์ค์ํ๊ณ , ์ต์ ํ ๊ฐ๋ฅํ ๋ถ๋ถ์ด ์ด๋์ ๋์ธ์ง ๊ณ ๋ คํด์ผ ํ๋ค!

5๏ธโฃ User and Kernel Threads
- user thread : ์ฐ๋ฆฌ๊ฐ ์์ฑํ ์ค๋ ๋
- kernel thread : ์ค์ ๋ก ์ฝ์ด์ ๋์๊ฐ๋ ๊ฒ์ ์ปค๋์ด ์ค์ผ์ค๋งํ๋ค
์ฆ, OS์์ ์ด๋ค kernel thread๊ฐ ๋์๊ฐ์ง ๊ฒฐ์ ํด์, user์์ mappingํด์ฃผ๋ ๋ฐฉ์์ด๋ค.

์ด mapping์ ํด์ฃผ๋ ๋ฐฉ์์ ์ข ๋ฅ์ ๋ํด์ ์์๋ณด์
(1) Many-to-One

- user thread ์ฌ๋ฌ๊ฐ ↔ kernel thread 1๊ฐ
- ํ ์ปค๋์๋ ํ ์ค๋ ๋๋ง ๊ฐ๋ฅํ๊ธฐ ๋๋ฌธ์ ๋์๊ฐ๋ฉด์ kernel thread์ mappingํ๋ค
- BUT ํ ์ค๋ ๋์ ๋ฌธ์ ๋ก ์ ์ฒด๊ฐ ๋ธ๋ฝ์ด ๋๋ฏ๋ก ์ฐ๋ ๋์ ์ฅ์ ์ ์ด๋ฆด ์ ์๋ ๋ฐฉ์์ด๋ค
(2) One-to-One

- ์ ์ - ์ปค๋์ 1 ๋ 1๋ก ๋งตํ
- ํ๋์ ์ปค๋์ด block๋์ด๋ ๋ค๋ฅธ ์ค๋ ๋์์ ์์ ํ ์ ์๋ค (Many-to-One์ ๋ฌธ์ ํด๊ฒฐ)
- BUT ์ฌ์ฉ์ ์ค๋ ๋์ ๊ฐ์๋งํผ ์ปค๋ ์ค๋ ๋ ํ์ํ๋ฏ๋ก...
- ๊ด๋ฆฌํ๋ ๋ฐ overhead๊ฐ ์๊ธด๋ค (kernel์ data structure ๋ง๋ค์ด์ ๊ด๋ฆฌํด์ผ ํ๊ธฐ ๋๋ฌธ)
- ์ค๋ ๋ ๊ฐ์ ์ ํ : ๋ฆฌ๋ ์ค pthread_create()์์๋ ๋ง๋ค ์ ์๋ ์ค๋ ๋์ ๊ฐ์๊ฐ ์ ํ๋์ด์๋ค
(3) Many-to-Many Model

- ์ฌ๋ฌ๊ฐ to ์ฌ๋ฌ๊ฐ, ์์ ๋๊ฐ ๋๋ค
- ๊ตฌํ์ด ๋๋ฌด ์ด๋ ค์์ ์ ์ฌ์ฉ๋์ง ์๋๋ค (์ด๋ ค์ด ์ด์ = ์ด๋์ ๋ฐฐ์น? ์ฑ๋ฅ ์ํฅ? → ๋ณต์กํด!!)
6๏ธโฃ Pthreads
(1) ๊ฐ๋
๊ฒฐ๊ตญ ์ค๋ ๋๋ฅผ ์์ฑ ๋ฐ ๊ด๋ฆฌํ๋ ๊ฒ์ ํ๋ก๊ทธ๋๋จธ ๋ชซ์ด๊ธฐ ๋๋ฌธ์ API๋ฅผ ์ ๊ณตํ๊ณ ์ด๊ฒ์ด Thread Library์ด๋ค.
Thread Library๋ฅผ ๊ตฌํํ๋ ๋ฐฉ๋ฒ์๋ 2๊ฐ์ง๊ฐ ์๋ค.
- ์ ์ ์คํ์ด์ค( =ํ๋ก๊ทธ๋๋จธ ์ ์ฅ์์) → Pthreads๋ก ์ฐ๋ฆฌ๊ฐ ์ง์
- ์ปค๋ ๋ ๋ฒจ์์ OS์ ์ํด
์ด ์ค์์ Pthreads๋ ์ค๋ ๋ ์์ฑ ๋ฐ ๋๊ธฐํ์ ๊ด๋ จ๋ POSIX ์ธํฐํ์ด์ค ํ์ค API์ด๋ค
- ๊ตฌํ๋ ๊ฒ์ด ์๋๋ค! (NOT implementation, Specification์ด๋ค!!)
- ์ด๋ ์ค๋ ๋๋ฅผ ๋ง๋๋ ๋ฐฉ์๊ณผ ๊ด๋ฆฌํ๋ ๋ฐฉ์์ด ๋๊ฐ์์(์์ user/kernel ๋ ๋ค ๊ฐ๋ฅ), OS์ ์๊ด์์ด ๊ฐ๋ฅํ๋ค
(2) Pthreads ํจ์
์ด์ ์ค๋ ๋๋ฅผ ๊ตฌํํ ํจ์๋ฅผ ์ ์ํด์ผํ๋๋ฐ, ์ด๋ป๊ฒ ํ ๊น?
Pthreads๋ ์ฐ์ ๊ฐ ์ค๋ ๋๊ฐ ํ๋ ์์ ์ ํจ์๋ก ๊ตฌํํ๊ณ ์ด๋ฅผ function pointer๋ก ์ ๋ฌํด์ ์ค๋ ๋๋ฅผ ์์ฑํ๋ค.

(1) Task๋ฅผ ํจ์๋ก ์ ์
- `void* task (void* arg);` → ๋ชจ๋ ํ์ ์ ๋ค๋ฃจ๊ธฐ ์ํด type์ void pointer๋ก ๊ณ ์ ํ๋ค
(2) Thread ์์ฑ ํจ์
: ์ค์ ๋ก ํ ์์ ์ ํจ์๋ก ๊ตฌํํด์ `pthread_create()`์ function pointer๋ก ์ ๋ฌํ๋ค
int pthread_create(pthread_t *restrict thread,
const pthread_attr_t *restrict attr,
void *(*start_routine) (void*),
void *restrict arg);
(3) Thread Join
: main์์ ์ค๋ ๋๊ฐ ์ข ๋ฃ๋๊ธฐ๋ฅผ ๊ธฐ๋ค๋ฆฌ๋ ์ญํ ์ด๋ค (process ์์ฑ์์ Parent ํ๋ก์ธ์ค์ wait์ ๋น์ทํ๋ค๊ณ ์๊ฐํ๋ฉด ์ฝ๋ค)
- `int pthread_join(pthread_t thread, void **retval);`
- `pthread_t thread` : ์ค๋ ๋ ID
- `void **retval` : ์ค๋ ๋๊ฐ ์ข ๋ฃ๋ ๋ ๋ฐํ๊ฐ์ด ์ด ๊ณณ์ด ๊ฐ๋ฆฌํค๋ ์์น์ ์ ์ฅ๋๋ค.
(4) Thread Termination(์ข ๋ฃ)
- `noreturn void pthread_exit(void *retval);`
(3) Example
์์ ์ฝ๋๋ฅผ ํตํด์ Pthreads์ ๋์์ ์ง์ ํ์ธํด๋ณด์

- `pthread_t tid` : `pthread_create()`ํ ๋ ์ด๊ธฐํ๋๋ค.
- create์ join ์ฌ์ด์ ๋์ง ์๊ณ ๋ค๋ฅธ ์ ์ฉํ ์์ ์ ํ๊ณ ์ค๋ ๋์ ๊ฒฐ๊ณผ๋ฅผ ๊ฐ์ ธ์ฌ ์๋ ์๋ค.
- exit ํ ๋ ๋ค์ด์ค๋ ๊ฐ = join ํ ๋ ๋ค์ด์ค๋ ๊ฐ ๋์ผํ๋ค!
- sum์ ์ ์ญ๋ณ์๋ก ์ฌ์ฉํ์ง ์์ ๋ ๋ฐฉ๋ฒ(์ ๊ทธ๋ฆผ์์ ํ๋์ ๊ธ์จ) : task function์ defineํ ๋ pthread.exit()์ ํ๋ผ๋ฏธํฐ๋ก ๋ณ์(sum)๋ฅผ ๋ฃ์ด์ฃผ๊ณ , pthread_join()์ ๋ ๋ฒ์งธ ํ๋ผ๋ฏธํฐ์(๊ทธ๋ฆผ์์๋ NULL๋ก ์ง์ ๋์ด์์) ๊ฐ์ ๋ณ์(sum)๋ฅผ ๋ฃ์ด์ฃผ๋ฉด ์ค๋ ๋์์ ์์ ํ ๋ด์ฉ์ด ๋ฐ์๋์ด ์ ์ฅ๋๋ค.
7๏ธโฃ Thread Cancellation
Cancellation = ์ค๋ ๋๊ฐ ๋๋๊ธฐ์ ์ ์ข ๋ฃํ๋ ๊ฒ
- `pthread_cacel(tid);` ๋ก ํ ์ ์๋ค.
cancellation์๋ ์ธ์ ์ข ๋ฃ๋๋์ง์ ๋ฐ๋ผ 3๊ฐ์ง ์ข ๋ฅ๊ฐ ์๋ค
- Asynchronous : ์ฆ์ ์ข ๋ฃ
- deferred : ๋ฐ๋ก ์ข
๋ฃ๋๋ ๊ฒ ์๋๋ผ, ๋ญ๊ฐ ์ธ์ด๋ธํฌ์ธํธ๊ฐ ์์ ์ ์๋ค.
- ๊ทธ๊ฒ์ด cancel๋์ด์ผํ๋์ง ์ฃผ๊ธฐ์ ์ผ๋ก ํ์ธํ๋ค
- `pthread_testcancel()` ์ ๋๋ฌํด์ผ๋ง cancel์ด ๋ฐ์ํ๋ค

- Off : cancel ๋ถ๊ฐ๋ฅ. State๊ฐ Enabled๋ ๋๊ฐ์ง ๋ณด๋ฅ ์ํ๋ก ๋จ์์๊ฒ ๋๋ค.
๋ฐ๋ผ์ ์ด๋๊ฑธ ์ธ์ง Mode๋ฅผ ๋ฏธ๋ฆฌ ์ค์ ํด๋ฌ์ผ ํ๋ค!

'๐ฑ CS > ์ด์์ฒด์ (OS)' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
| [์ด์์ฒด์ ๊ณต๋ฃก์ฑ ] Ch 3. Processes (1) | 2024.04.26 |
|---|---|
| [์ด์์ฒด์ ๊ณต๋ฃก์ฑ ] Ch 2. Operating-System Structures (1) | 2024.04.26 |
| [์ด์์ฒด์ ๊ณต๋ฃก์ฑ ] Ch 1. Introduction (1) | 2024.04.13 |