์ง๋ ฌ ์๊ณ ๋ฆฌ์ฆ(Serial Algorithm)
- ๋ช ๋ น์ ํ ๋ฒ์ ํ๋๋ง ์คํํ๋ Single Processor ์ปดํจํฐ์ ์ ํฉํ ์๊ณ ๋ฆฌ์ฆ์ ๋๋ค.
๋ณ๋ ฌ ์๊ณ ๋ฆฌ์ฆ(Parallel Algorithm)
- ์ฌ๋ฌ ๋ช ๋ น์ด๋ฅผ ๋์์ ์ํํ๋ Multi Processor ์ปดํจํฐ์ ์ ํฉํ ์๊ณ ๋ฆฌ์ฆ์ ๋๋ค.
Computer Architecture
Shared Memory
Distributed Memory
- ํ๋ก์ธ์๋ง๋ค ๋ฉ๋ชจ๋ฆฌ๋ฅผ ๊ฐ์ ธ ๋ค๋ฅธ ํ๋ก์ธ์์ ๋ฉ๋ชจ๋ฆฌ๋ฅผ ์ฌ์ฉํ๋ ค๋ฉด ํ๋ก์ธ์๋ผ๋ฆฌ ๋ช ํํ ๋ฉ์์ง๋ฅผ ๋ณด๋ด์ผ ํฉ๋๋ค.
์ ์ ์ค๋ ๋ฉ(Static Threading)
- ๋๋ถ๋ถ์ ์์ฉ ํ๋ก๊ทธ๋จ์์ ๊ณ์ฐํ๋ ๋์ ์ค๋ ๋๋ฅผ ์ ์ง์ํค๋๋ฐ ์ด๋ฐ ๋ฐฉ๋ฒ์
์ ์
์ด๋ผ๊ณ ๋ถ๋ฆ ๋๋ค. - ๊ณต์ ๋ฉ๋ชจ๋ฆฌ ๋ณ๋ ฌ ์ปดํจํฐ์์๋ ์ ์ ์ค๋ ๋๋ฅผ ์ด์ฉํด ์ง์ ํ๋ก๊ทธ๋๋ฐํ๊ธฐ๊ฐ ์ด๋ ต๊ณ ์ค๋ฅ๊ฐ ๋ฐ์ํ๊ธฐ ์ฝ์ต๋๋ค.
- ์ค๋ ๋๋ค ์ฌ์ด์์ ์์ ์ ๋์ ์ผ๋ก ๋ถํ ํ์ฌ ๊ฐ ์ค๋ ๋๊ฐ ๋ก๋๋ฅผ ๋๋ต ๊ฐ๊ฒ ๋ฐ๋๋ก ํ๋ ๊ฒ์ด ๋งค์ฐ ๋ณต์กํฉ๋๋ค.
๊ทธ๋ ๊ธฐ์ ๋ณ๋ ฌ์ฑ ๊ณ์ฐ ๋ฆฌ์์ค๋ฅผ ์กฐ์ , ๊ณํ ๊ด๋ฆฌํ๋ ์ํํธ์จ์ด ๊ณ์ธต์ ์ ๊ณตํ๋ ๋์์ฑ ํ๋ซํผ์ ๋ง๋ค์ด์ผ ํฉ๋๋ค.
๋์ ์ค๋ ๋ฉ(Dynamic Threading)
- ํ๋ก๊ทธ๋๋จธ๊ฐ ํต์ ํ๋กํ ์ฝ, ๋ก๋ ๋ฐธ๋ฐ์ฑ, ์ ์ ์ค๋ ๋ ํ๋ก๊ทธ๋๋ฐ์ ๋ณ์น์ฑ์ ์ ๊ฒฝ ์ฐ์ง ์๊ณ ์์ฉ ํ๋ก๊ทธ๋จ์ ๋ณ๋ ฌ์ฑ์ ์ง์ ํ ์ ์์ต๋๋ค.
Example - ํผ๋ณด๋์น ์
Nested Parallelism
- ์ค์ฒฉ๋ ๋ณ๋ ฌ์ฑ์ ์๋ธ ๋ฃจํด์ด ์ฌ๋ฌ๋ฒ ๋ฐ๋ณต๋๋ ๊ฒ์ ํ์ฉํฉ๋๋ค.
- ํธ์ถ์๊ฐ ์๋ธ ๋ฃจํด์ ๊ณ์ฐ ๊ฒฐ๊ณผ๋ฅผ ๋ฐ๋ณต ์งํํ๋ ๊ฒ์ ํ์ฉํฉ๋๋ค.
P-FIB(n)
if n <= ๔ฐ1
return n
else
x = spawn P-FIB(n-1) # Create Child Process
y = P-FIB(n๔ฐ-2) # Processing Parent Process
sync # Waiting Child Process Result
return x+y # Return Value
- ๋ ผ๋ฆฌ์ ์ธ ๋ณ๋ ฌ์ ๋ํ๋ด๋ ๊ฒ์ด๋ผ ์ค์ ๋ก ๊ผญ ๋์์ ์คํํด์ผ ํ๋ค๋ ์๋ฏธ๋ ์๋๋๋ค.
- ์ค์ผธ์ค๋ฌ๊ฐ ๊ณ์ฐ์ ์ ๊ฐํ ๋ ์ ์ฉํ ํ๋ก์ธ์๋ฅผ ๋ถ๋ถ๊ณ์ฐ์ ํ ๋นํจ์ผ๋ก์จ ์ค์ ๋ก ์ด๋ค ๋ถ๋ถ๊ณ์ฐ์ ๋์์ ์คํํ ์ง๋ฅผ ๊ฒฐ์ ํฉ๋๋ค.
Parallel loop
- ๋ฃจํ๋ฅผ ๋ฐ๋ณต์ ์ผ๋ก ๋์์ ์คํํ ์ ์๋ค๋ ์ ์ ์ ์ธํ๋ฉด ์ผ๋ฐ for-loop์ ๋์ผํฉ๋๋ค.
- ์ปดํ์ผ๋ฌ๋ ๊ฐ
parallel for
๋ฃจํ๋ฅผ ์ค์ฒฉ๋ ๋ณ๋ ฌ์ฑ ๊ณ์ฐ์ผ๋ก ์ด์ฉํ๋ ๋ถํ -์ ๋ณต ์๋ธ ๋ฃจํด์ ์ด์ฉํ ์ ์์ต๋๋ค.
MAT-VEC(A,x)
n = A.rows
parallel for i = 1 to n
yi = 0
parallel for i = 1 to n
for j = 1 to n
yi = yi + aij * xj
return y
- ์ฌ๊ท์ ์ผ๋ก ์์ฑ๋๋ ๋น์ฉ๋ ๋ฌด์ํ์ง ๋ง๊ณ ํ์ธํด์ผ ํฉ๋๋ค.
Multi Thread ์คํ ๋ชจ๋ธ
DAG(Directed acyclic graph)
- ๊ทธ๋ํ์ ์ฌ์ดํด์ด ์๋๊ฒ ํน์ง.
Multi Thread Scheduling
- ์ข์ Multi Threading์ด๋ ์์ ์ ๋ฒ์๋ฅผ ์ต์ํํ ๋ฟ๋ง ์๋๋ผ ์์ ์ด ๋ณ๋ ฌ ๊ธฐ๊ณ์ ํ๋ก์ธ์์ ์ํด ํจ์จ์ ์ผ๋ก ์ค์ผธ์ค๋ง๋์ด์ผ ํฉ๋๋ค.
- https://en.wikipedia.org/wiki/Scheduling_(computing)
Work Stealing
Race Condition
RACE-EXAMPLE()
x = 0
parallel for i = 1 to 2
x = x + 1
print x
ADD Process - Assembly language
- x๋ฅผ ๋ฉ๋ชจ๋ฆฌ๋ก๋ถํฐ ํ๋ก์ธ์์ ํ๋์ Register๋ก ์ฝ์ด๋ค์ ๋๋ค.
- Register์ ์๋ ๊ฐ์ ์ฆ๊ฐ์ํต๋๋ค.
- Register์ ์๋ ๊ฐ์ ๋ฉ๋ชจ๋ฆฌ์ x์ ์ ์ฅํฉ๋๋ค.
์ด๋ค ๋ฌธ์ ๊ฐ ๋ฐ์ํ ๊น์?
- ๊ฐ๊ฐ CPU๊ฐ ๊ฐ์ง๊ณ ์๋ Register ๊ฐ์ ๋ถ์ผ์น๊ฐ ๋ฐ์ํฉ๋๋ค.
- Register ๊ฐ์ ๋ถ์ผ์น๋ก ์ธํด ์ฐ๋ฆฌ๊ฐ ์ํ๋ ๊ฐ์ด ์๋ ๋ค๋ฅธ ๊ฐ์ด ๋์ค๊ฒ ๋๋ ๊ฒฝ์ฐ๋ ์ข ์ข ๋ฐ์ํ๊ฒ ๋ฉ๋๋ค.
์ด๋ฌํ ๋ฒ๊ทธ๋ ์ฐพ๊ธฐ๋ ๋งค์ฐ ํ๋ค๊ณ , ์ฌ์ฐํ๊ธฐ๋ ๋งค์ฐ ํ๋ญ๋๋ค. ๋ํ ์ฌ๊ฐํ ๊ฒฐ๊ณผ๋ฅผ ์ด๋ํ ์๋ ์์ต๋๋ค.
์ด๋ป๊ฒ ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ ๊น์?
- Mutex, Lock, Semaphore์ ๊ฐ์ ๊ธฐ๋ฒ์ ์ฌ์ฉํด์ ๋๊ธฐํ๋ฅผ ์งํํฉ๋๋ค.
- Memory barrier
- ์ฌ๊ท์ ์ผ๋ก ํธ์ถ์ ํ๊ฒ ๋๋ค๋ฉด?
- ์ด๋ค์ ์๋ก ๋ ๋ฆฝ์ ์ด์ฌ์ผ ํฉ๋๋ค.
- ์ฆ ์์์ ์๊ด์์ด ํธ์ถ๋๊ณ ํ๋์ ๊ณ์ฐ ๊ฒฐ๊ณผ๊ฐ ๋ค๋ฅธ ๊ณ์ฐ์ ์ํฅ์ ์ฃผ์ง ์์์ผ ํฉ๋๋ค.
๋ณ๋ ฌ ํ๋ก๊ทธ๋๋ฐ์ด ๊ณผ์ฐ ๋ต์ผ๊น์?
Amdahlโs Law
์ค์ ํ๋ก์ธ์๋ ๋ ธ๋ ์๋ฅผ ๋ง์ด ๋๋ฆฐ๋ค๊ณ ํด๋, ์ด๋ ์์ค ์ด์์์๋ ์๋ ํฅ์์ ๊ธฐ๋ํ ์ ์๋ค.
- ํ๋ก๊ทธ๋จ์ 95%๊ฐ ๋ณ๋ ฌํ ๋์ด ์๋ค๊ณ ํด๋ 16๊ฐ์ ํ๋ก์ธ์๋ฅผ ๊ฐ์ง๊ณ 10๋ฐฐ ์ด์์ ์๋ํฅ์์ ๋ด์ง ๋ชปํ๋ค.
- ์๋ฌด๋ฆฌ ๋ง์ ํ๋ก์ธ์ค๋ฅผ ๊ฐ์ง๊ณ ์์ด๋ 20๋ฐฐ ์ด์์ ์๋ ํฅ์์ ๋ผ ์๊ฐ ์๋ค.
Reference
- https://www.quora.com/What-is-the-difference-between-forking-and-spawning-a-process
- http://sunyzero.tistory.com/191
- https://blog.koriel.kr/fork-hamsureul-iyonghayeo-pibonaci-suyeoleul-culryeoghaeboja/
- http://bart7449.tistory.com/244
- http://www.albahari.com/threading/part4.aspx
- https://actor-framework.readthedocs.io/en/stable/Scheduler.html
- https://youtu.be/M1e9nmmD3II