[OS] Operating System(4-1): Multicore Programming, Multithreading, Pthread
๐ ์ด์์ฒด์ ์ ๊ณต ์์ ์ ๋ฆฌ
Single and Multithreaded Processes
- single threaded process:
- ํ๋์ ์ค๋ ๋๋ง ์กด์ฌ
- ๋ชจ๋ ์์์ ๋จ์ผ ์ค๋ ๋๊ฐ ์ฌ์ฉ
- multithreaded process:
code
,data
,files
๋ฅผ ๊ณต์registers
,PC
,stack
: ์ค๋ ๋๋ณ ๊ณต์ ์์ญ
Multithreaded Server Architecture
multithreaded Server์ ์ฒ๋ฆฌ๊ณผ์ :
- client์ ์์ฒญ ์ ์
- ์์ฒญ ์ฒ๋ฆฌ๋ฅผ ์ํ ์ ์ค๋ ๋ ์์ฑ
- ๋ค๋ฅธ ํด๋ผ์ด์ธํธ์ ์์ฒญ์ ๋ฐ๊ธฐ ์ํด ๋ฆฌ์ค๋ ์ํ๋ก ๋ณต๊ท
Benefit of Multithreading
- Responsiveness
- ํ๋ก์ธ์ค ์ผ๋ถ๊ฐ block ๋์ด๋ ๊ณ์ ์คํ ๊ฐ๋ฅ
- Resource Sharing
- ์ค๋ ๋๋ ํ๋ก์ธ์ค์ ์์์ ๊ณต์
- ๊ณต์ ๋ฉ๋ชจ๋ฆฌ๋ ๋ฉ์์ง ์ ๋ฌ๋ณด๋ค ํจ์จ์
- Economy
- ํ๋ก์ธ์ค ์์ฑ๋ณด๋ค ์ ๋ ด
- ์ค๋ ๋ ์ ํ์ด
context switching
๋ณด๋ค ์ค๋ฒํค๋๊ฐ ๋ฎ์
- Scalability
Multicore architecture
ํ์ฉ ๊ฐ๋ฅ
Multicore Programming
Multicoreํ๊ฒฝ์ ๋ช๊ฐ์ง์ ๋์ ๊ณผ์ ๊ฐ ์์๋ค.
Dividing activities
Balance
Data splitting
Data dependency
Testing and debugging
- Parallelism(๋ณ๋ ฌ): ์ฌ๋ฌ๊ฐ์ ์ฝ์ด/CPU๊ฐ โ๋์์โ ์ฌ๋ฌ๊ฐ์ task๋ฅผ ์งํํจ, ์ง์ง๋ก ๋์์ ์ฌ๋ฌ ์์ ์ด ์คํ(simultaneously) ๋๋ ๊ฒ
- Concurrency(๋ณํ): ํ๋์ ์ฝ์ด/CPU๊ฐ ์ฌ๋ฌ ๊ฐ์ task๋ฅผ ์๊ฐ์ ๋ถํ ํด์ ๋์์ ์งํํจ(=scheduler)
single-core์ ๊ฒฝ์ฐ: ํ๋์ ์ฝ์ด๊ฐ ์๊ฐ์ ์กฐ๊ฐ๋ด์ด ์ฌ๋ฌ task๋ฅผ ๋ฒ๊ฐ์๊ฐ๋ฉฐ ์คํ. ์ค์ ๋ก๋ ํ ๋ฒ์ ํ๋์ด์ง๋ง, ๋น ๋ฅธ ์ ํ์ผ๋ก ๋ง์น โ๋์์โ ์คํํ๋ ๊ฒ์ฒ๋ผ ๋ณด์
multi-core์ ๊ฒฝ์ฐ: ์ฌ๋ฌ ์ฝ์ด๊ฐ ๊ฐ๊ฐ ๋ค๋ฅธ task๋ฅผ ๋์์ ์คํ
Type of parallelism
- Data parallelism: ๋์ผํ ๋ฐ์ดํฐ์ ์ ์ฌ๋ฌ ๋ถ๋ถ์ ์ฌ๋ฌ ์ฝ์ด์ ๋ถ๋ฐฐํ์ฌ ๋์ผํ ์ฐ์ฐ์ ์ํํ๋ ๋ฐฉ์(์: ํฐ ์ด๋ฏธ์ง๋ฅผ ์ฌ๋ฌ ๋ถ๋ถ์ผ๋ก ๋๋์ด ๊ฐ ์ฝ์ด์์ ๊ฐ์ ํํฐ๋ฅผ ์ ์ฉํ๋ ๊ฒฝ์ฐ)
- Task parallelism: ์๋ก ๋ค๋ฅธ ์ค๋ ๋๋ฅผ ์ฌ๋ฌ ์ฝ์ด์ ๋ถ๋ฐฐํ์ฌ ๊ฐ ์ค๋ ๋๊ฐ ์๋ก ๋ค๋ฅธ ์ฐ์ฐ์ ์ํํ๋ ๋ฐฉ์(์: ์น ๋ธ๋ผ์ฐ์ ์์ ํ๋์ ์ค๋ ๋๋ UI๋ฅผ ์ฒ๋ฆฌํ๊ณ , ๋ค๋ฅธ ์ค๋ ๋๋ ๋คํธ์ํฌ ์์ฒญ์ ์ฒ๋ฆฌํ๋ ๊ฒฝ์ฐ)
Amdahlโs Law
๐์ ํ๋ฆฌ์ผ์ด์ ์ ์ฝ์ด๋ฅผ ์ถ๊ฐํ์ ๋ ์ป์ ์ ์๋ ์ฑ๋ฅ ํฅ์์ ์๋ณํจ
- ๊ฒฐ๋ก : ์ฝ์ด์ ์๊ฐ 2๋ฐฐ๊ฐ ๋๋ค๊ณ ์ฑ๋ฅ์ด 2๋ฐฐ ์ข์์ง์ง ์๋๋ค(1.6๋ฐฐ ํฅ์)
S: ์ง๋ ฌ ๋ถ๋ถ ๋น์จ(%)
,1-S: ๋ณ๋ ฌ ๋น์จ
,N: processing core ์
๋ง์ฝ ์ด๋ค task์ 75%๊ฐ ๋ณ๋ ฌ์ด ๊ฐ๋ฅํ๊ณ ๋๋จธ์ง๋ ์ง๋ ฌ๋ง(25%) ๊ฐ๋ฅํ ๋, ์ฝ์ด๊ฐ 2๋ฐฐ๊ฐ ๋๋ฉด ์ต๋ ํจ์จ์ 1.6๋ฐฐ์ด๋ค.
์ฆ, ์ต๋์ speedup์ ์ํด์ ์ง๋ ฌ๋ง ๊ฐ๋ฅํ ํ๋ก๊ทธ๋จ์ด ์ ์ด์ผํ๋ค
S๊ฐ 50%์ธ ๊ฒฝ์ฐ ์๋ฌด๋ฆฌ core๋ฅผ ๋๋ ค๋ speed๊ฐ 2๋ฐฐ๊ฐ ๋์ง ์๋๋ค.
User Threads and Kernel Threads
โ
process์ thead๋ฅผ ํผ๋ํ ์ ์๋ค โ ํ์ฌ๋ ๊ฑฐ์ ๋ชจ๋ thread๋ฅผ ์ฌ์ฉํ๋ค.
์๋ ์๋ process๋จ์๋ก scheduler๋ฅผ ํ์ง๋ง ํ์ฌ๋ thread ๋จ์๋ก ํจ
- User threads: management done by user-level threads library
- Three primary thread libraries:
POSIX Ptheads
: thread์ ์๋ฐ์ / ํ์ฌ๋ kernel levelWindows threads
Java threads
- Kernel threads: Supported by the Kernel
- ๋๋ถ๋ถ์ ํ๋ ๋ฒ์ฉ ์ด์์ฒด์ ์์ ์ง์:
Windows
Linux
Mac OS X
iOS
Andriod
๊ฐ๋ ์ ์ผ๋ก๋ user์ kernel์ด ๋ถ๋ฆฌ๋จ
๊ทธ ๋ถ๋ฆฌ๋ฅผ ํฉ์น๊ธฐ ์ํ ๋ฐฉ๋ฒ์ด ์๋ค.
1. Many-to-One
๐Many-to-One: ์ฌ๋ฌ User Thread๊ฐ ํ๋์ Kernel Thread์ Mapping๋๋ ๋ฐฉ์
โ ์ฅ์ :
- ์ํ๋ ๋งํผ ๋ง์ ์ฌ์ฉ์ ์ค๋ ๋ ์์ฑ ๊ฐ๋ฅ
โ๋จ์ :
- ๋ณ๋ ฌ ์ฒ๋ฆฌ ๋ถ๊ฐ๋ฅ โ ๋ฉํฐ์ฝ์ด์ ์ฅ์ ๋ชป ์ด๋ฆผ
- ํ๋๋ผ๋ ๋ธ๋กํน๋๋ฉด ์ ๋ถ ๋ฉ์ถค โ ํจ์จ์ฑ ์ ํ ํ์ฌ๋ ๊ฑฐ์ ์ฌ์ฉ X
2. One-to-One
๊ฐ ํ๋์ ์ ์ ์ค๋ ๋์ ์ปค๋ ์ค๋ ๋๊ฐ ๋งคํ๋จ โ user thread๋ฅผ ์์ฑํ๋ฉด kernel thread๋ ํจ๊ป ์์ฑ๋จ
โ ์ฅ์ :
- ์ค๋ ๋๊ฐ ๋ธ๋กํน๋์ด๋ ๋ค๋ฅธ ์ค๋ ๋ ์คํ ๊ฐ๋ฅ
- ์ฌ๋ฌ ์ค๋ ๋๋ฅผ ๋ค์ค์ฝ์ด์ ๋งคํ ๊ฐ๋ฅ
โ๋จ์ :
- ์ค๋ ๋ ์์ฑ ์ ์ค๋ฒํค๋ ๋๋ฌธ์ ํ๋ก์ธ์ค๋น ์ค๋ ๋ ์๊ฐ ์ ํ๋ ์ ์์
3. Many-to-Many Model
์ฌ๋ฌ๊ฐ์ ์ ์ ์ค๋ ๋๋ฅผ ์ฌ๋ฌ๊ฐ์ ์ปค๋ ์ค๋ ๋์ ๋งคํ๋๋ ๋ฐฉ์
โ ์ฅ์ :
- ์ฌ์ฉ์ ์ค๋ ๋๋ฅผ ๋ง์๋๋ก ์์ฑ ๊ฐ๋ฅ + ๋ฉํฐ์ฝ์ด์์ ๋ณ๋ ฌ๋ก ์คํ๊ฐ๋ฅ
โ๋จ์ :
- ์ฌ๋ฌ๊ฐ์ ์ ๋ ฅ๊ณผ ์ฌ๋ฌ๊ฐ์ ์ถ๋ ฅ์ ์ค์์นญํด์ค์ผํ๋๋ฐ ๊ทธ ๋น์ฉ์ด ์๋นํจ โ ๊ตฌํ์ด ์ด๋ ค์
Thread Library
๐Thread Library: ํ๋ก๊ทธ๋๋จธ์๊ฒ ์ค๋ ๋๋ฅผ ์์ฑํ๊ณ ๊ด๋ฆฌํ ์ ์๋ API(Application Programming Interface)๋ฅผ ์ ๊ณต
์ด ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ ๋ ๊ฐ์ง ๋ฐฉ์์ผ๋ก ๊ตฌํ:
- user space์๋ง ์๋ ๋ผ์ด๋ธ๋ฌ๋ฆฌ:
- ๋ชจ๋ ์ค๋ ๋ ์ฝ๋๊ฐ ์ฌ์ฉ์ ๊ณต๊ฐ์์ ์คํ๋จ
- ์ปค๋์ ์ค๋ ๋์ ์กด์ฌ๋ฅผ ์ธ์ํ์ง ๋ชปํจ
- kernel-level์์ ์ง์ํ๋ ๋ผ์ด๋ธ๋ฌ๋ฆฌ:
- ์ค๋ ๋ ์์ฑ ๋ฐ ๊ด๋ฆฌ๊ฐ ์ปค๋์ ์ํด ์ํ๋จ
- ์์คํ ์ฝ์ ํตํด ์ปค๋๊ณผ ํต์
Asynchronous Threading
: ๋ถ๋ชจ์ ์์ ์ค๋ ๋๊ฐ ๋ ๋ฆฝ์ ์ผ๋ก ๋ณํ ์คํSynchronous Threading
: ๋ถ๋ชจ ์ค๋ ๋๋ ๋ชจ๋ ์์ ์ค๋ ๋๊ฐ ์ข ๋ฃ๋ ๋๊น์ง ๊ธฐ๋ค๋ฆผ๋ถ๋ชจ ์ค๋ ๋๋ ๋ฉ์ธ ์ค๋ ๋, ์์ ์ค๋ ๋๋ ์๋ธ ์ค๋ ๋๋ผ๊ณ ๋ ํ๋ค.
POSIX Pthreads
: user or kernel level
Windows threads
: kernel level
javathreads
: depending on OS
Pthreads
์ฌ์ฉ์ ์์ค์ด๋ ์ปค๋ ์์ค์ผ๋ก ์ ๊ณต๋ ์ ์์
- ์ค๋ ๋ ์์ฑ ๋ฐ ๋๊ธฐํ๋ฅผ ์ํ API
- ํ์ค๋ง ์ ์: ์ค์ ๊ตฌํ์ ๋ผ์ด๋ธ๋ฌ๋ฆฌ ๊ฐ๋ฐ์์๊ฒ ๋งก๊น
์ค๋ ๋ ์์ฑ
1
2
3
4
#include <pthread.h>
int pthread_create(pthread_t *thread, const pthread_attr_t *attr,
void *(*start_routine)(void *), void *arg);
thread
: ์์ฑ๋ ์ค๋ ๋์ ID๋ฅผ ์ ์ฅํ ํฌ์ธํฐattr
: ์ค๋ ๋์ ์์ฑ(NULL์ด๋ฉด ๊ธฐ๋ณธ๊ฐ)start_routine
: ์ค๋ ๋๊ฐ ์คํํ ํจ์ ์ฃผ์arg
: ์์ ํจ์์ ์ ๋ฌํ ์ธ์
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
/* Example pthread */
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
int sum; /* this data is **shared** by the thread(s) */
void *runner(void *param); /* threads call this function */
int main(int argc, char *argv[])
{
pthread_t tid; /* ์ค๋ ๋ ์๋ณ์ */
pthread_attr_t attr; /* ์ค๋ ๋ ์์ฑ ์งํฉ */
/* set the default attributes of the thread */
pthread_attr_init(&attr);
/* create the thread */
pthread_create(&tid, &attr, runner, argv[1]);
/* wait for the thread to exit */
pthread_join(tid, NULL);
printf("sum= %d\n", sum);
}
void *runner(void *param)
{
int i, upper=atoi(param);
sum =0;
for(i=1; i<=upper; i++)
sum += i;
pthread_exit(0);
}
// 10๊ฐ์ ์ค๋ ๋๋ฅผ ์์ฑํ๊ณ ์์ ํ ์ข
๋ฃ๋ ๋๊น์ง main thread๊ฐ ๊ธฐ๋ค๋ฆฌ๋ ์ฝ๋
#define NUM_THREADS 10
/* an array of threads to be joined upon */
pthread_t workers[NUM_THREADS];
for(int i = 0; i<NUM_THREADS; i++)
pthread_join(workers[i], NULL); // ์ค๋ ๋ ์ข
๋ฃ ๋๊ธฐ