[๊ฐ๋ ] CPU, GPU, ๊ทธ๋ฆฌ๊ณ GPU ์๋ฆฌ
์๋ณธ ๊ฒ์๊ธ: https://velog.io/@euisuk-chung/๊ฐ๋ -CPU์-GPU
CPU์ GPU
๋ฅ๋ฌ๋๊ณผ ๋จธ์ ๋ฌ๋์ ํ์ตํ๊ฑฐ๋ ์์ ํ ๋ GPU๋ฅผ ์ฌ์ฉํ๋ ๊ฒ์ ์ด์ ๋น์ฐํ๊ฒ ์ฌ๊ฒจ์ง๋๋ค. ์ค์ ๋ก ์๋์ ๊ฐ์ ์ฝ๋๋ก GPU๋ CPU๋ฅผ ์์ฝ๊ฒ ์ ํํ ์ ์์ต๋๋ค.
1
2
3
4
5
6
7
8
import torch
# CUDA ์ฌ์ฉ ์ฌ๋ถ ํ์ธ
USE_CUDA = torch.cuda.is_available()
print(USE_CUDA)
# device ์ ์ธ
device = torch.device('cuda:0' if USE_CUDA else 'cpu')
ํ์ง๋ง, โCPU๋ ์ง๋ ฌ ์ฐ์ฐ, GPU๋ ๋ณ๋ ฌ ์ฐ์ฐ!โ์ด๋ผ๋ ๊ฐ๋จํ ์ง์๋ง์ผ๋ก ์ด ๊ฐ๋ ฅํ ์ฐ์ฐ ์ฅ์น๋ฅผ ์ ๋๋ก ์ดํดํ ์ ์์๊น์?
์ด๋ฒ ํฌ์คํ ์์๋ CPU์ GPU์ ์ฐจ์ด์ , GPU๊ฐ ๋ฅ๋ฌ๋์์ ๊ฐ๋ ฅํ ์ด์ , ๊ทธ๋ฆฌ๊ณ GPU ๋ด๋ถ์ ์ฐ์ฐ ๊ตฌ์กฐ๋ฅผ ๊น์ด ์๊ฒ ์ดํด๋ณด๊ฒ ์ต๋๋ค.
CPU์ GPU์ ์ฐจ์ด์
CPU์ GPU๋ ๋ ๋ค ๋ฐ์ดํฐ๋ฅผ ์ฝ์ด๋ค์ฌ ์ฐ์ฐ์ฒ๋ฆฌ๋ฅผ ํตํด ๋ต์ ๋์ถํ๋ ๊ธฐ๋ฅ์ ์ํํ๋, ์ด๋ฆ๊ณผ ๊ตฌ์กฐ์์ ์์ ์๋ฏ์ด ์ค์ ์ฒ๋ฆฌ ์ฅ์น(CPU)์ ๊ทธ๋ํฝ ์ฒ๋ฆฌ ์ฅ์น(GPU)๋ ์ญํ ์ด ๋งค์ฐ ๋ค๋ฆ ๋๋ค.
- ์ค์ ์ฒ๋ฆฌ ์ฅ์น(CPU, Central Processing Unit)
- ๊ทธ๋ํฝ ์ฒ๋ฆฌ ์ฅ์น(GPU, Grapical Processing Unit)
CPUยทGPU์ ๊ฐ์ ํ๋ก์ธ์ ๋ด๋ถ๋ ํฌ๊ฒ ์ฐ์ฐ์ ๋ด๋นํ๋ ์ฐ์ถ์ฐ์ฐ์ฒ๋ฆฌ์ฅ์น(ALU, Arithmetic Logic Unit)์ ๋ช ๋ น์ด๋ฅผ ํด์ยท์คํํ๋ ์ปจํธ๋กค์ ๋(CU, Control Unit), ๊ฐ์ข ๋ฐ์ดํฐ๋ฅผ ๋ด์๋๋ ์บ์(Cache)๋ก ๋๋๊ฒ ๋ฉ๋๋ค. ๊ฐ๊ฐ ํ๋์ฉ ์ดํด๋ณด๋๋ก ํ๊ฒ ์ต๋๋ค.
1. CPU๋ ๋ฌด์์ธ๊ฐ?
CPU(์ค์์ฒ๋ฆฌ์ฅ์น, Central Processing Unit)๋ ์ปดํจํฐ ์์คํ ์ ๋๋ ์ญํ ์ ํฉ๋๋ค. ๋ชจ๋ ๋ช ๋ น์ ์ฒ๋ฆฌํ๊ณ , ์ ๋ ฅ๊ณผ ์ถ๋ ฅ์ ์ ์ดํ๋ฉฐ, ์์คํ ์ ๋ค๋ฅธ ๋ถํ์ ์งํํฉ๋๋ค.
- ์์ฐจ ์ฒ๋ฆฌ(Sequential Processing): CPU๋ ์ ๋ ฅ๋ ๋ช ๋ น์ ํ๋์ฉ ์ฒ๋ฆฌํ๋ฉฐ, ๋ณต์กํ ์์ ์ ๋น ๋ฅด๊ฒ ํด๊ฒฐํ๋๋ก ์ค๊ณ๋์์ต๋๋ค.
- ๊ตฌ์ฑ ์์: CPU๋ ์ฐ์ฐ์ ๋ด๋นํ๋ ์ฐ์ ๋ ผ๋ฆฌ์ ๋(ALU), ๋ช ๋ น์ ์ ์ดํ๋ ์ปจํธ๋กค ์ ๋(CU), ๊ทธ๋ฆฌ๊ณ ๋ฐ์ดํฐ๋ฅผ ์์ ์ ์ฅํ๋ ์บ์(Cache)๋ก ์ด๋ฃจ์ด์ ธ ์์ต๋๋ค.
- ์ฝ์ด ์์ ์บ์: ์ผ๋ฐ์ ์ผ๋ก CPU๋ ์์์ ๊ฐ๋ ฅํ ์ฝ์ด(์: 4~8๊ฐ)๋ฅผ ๊ฐ์ง๋ฉฐ, ๋์ฉ๋ ์บ์๋ฅผ ํตํด ์๋ ๋ณ๋ชฉ์ ์ต์ํํฉ๋๋ค.
์ข ๋ ํ์ด์ ์ค๋ช ํ์๋ฉด ์๋์ ๊ฐ์ด ์ค๋ช ํ ์ ์์ต๋๋ค:
- CPU๋ ์ ์ถ๋ ฅ์ฅ์น, ๊ธฐ์ต์ฅ์น, ์ฐ์ฐ์ฅ์น๋ฅผ ๋น๋กฏํ ์ปดํจํฐ ๋ฆฌ์์ค๋ฅผ ์ด์ฉํ๋ ์ต์์ ๊ณ์ธต ์ฅ์น๋ก์จ, ์ปดํจํฐ์ ๋๋๋ฅผ ๋ด๋นํฉ๋๋ค. CPU๋ ์ปดํจํฐ ๋ฐ ์ด์ ์ฒด์ ์ ํ์ํ ๋ช ๋ น๊ณผ ์ฒ๋ฆฌ๋ฅผ ์คํํ๋ฏ๋ก ๋ชจ๋ ํ๋ ์ปดํจํ ์์คํ ์ ํ์์ ์ธ ์์์ ๋๋ค.
- CPU๋ ๋ช ๋ น์ด๊ฐ ์ ๋ ฅ๋ ์์๋๋ก ๋ฐ์ดํฐ๋ฅผ ์ฒ๋ฆฌํ๋ ์์ฐจ์ ์ธ(Sequential) ์ฒ๋ฆฌ ๋ฐฉ์์ ํนํ๋ ๊ตฌ์กฐ๋ฅผ ๊ฐ์ง๊ณ ์์ต๋๋ค. ์ด๋ ํ ๋ฒ์ ํ ๊ฐ์ง์ ๋ช ๋ น์ด๋ง ์ฒ๋ฆฌํ๋ค๋ ๊ฒ์ ์๋ฏธํ๋ฉฐ, ๊ทธ๋ ๊ธฐ์ ์ฐ์ฐ์ ๋ด๋นํ๋ ALU์ ๊ฐ์๊ฐ ๋ง์ ํ์๊ฐ ์๊ฒ ๋ฉ๋๋ค. ์๋ฅผ ๋ค์ด CPU ์ ํ๋ค ์ค Octa-core CPU์ ๊ฒฝ์ฐ์๋ ์ฝ์ด ๋น 1๊ฐ์ฉ, ์ด 8๊ฐ์ ALU๊ฐ ํ์ฌ๋์ด ์๋ ์ ํ์ ๋๋ค.
- CPU ๋ด๋ถ์ ์ ๋ฐ ์ด์์ ์บ์ ๋ฉ๋ชจ๋ฆฌ๋ก ์ฑ์์ ธ ์์ต๋๋ค. ์บ์ ๋ฉ๋ชจ๋ฆฌ๋ CPU์ ๋จ(RAM)๊ณผ์ ์๋์ฐจ์ด๋ก ๋ฐํํ๋ ๋ณ๋ชฉํ์์ ๋ง๊ธฐ ์ํ ์ฅ์น๋ก์จ, CPU๊ฐ ์ฒ๋ฆฌํ ๋ฐ์ดํฐ๋ฅผ ๋ฏธ๋ฆฌ RAM์์ ๋ถ๋ฌ์ CPU ๋ด๋ถ ์บ์ ๋ฉ๋ชจ๋ฆฌ์ ์์๋ก ์ ์ฅํด ์ฒ๋ฆฌ ์๋๋ฅผ ๋์ผ ์ ์๊ฒ ๋ฉ๋๋ค. CPU๊ฐ ๋จ์ผ ๋ช ๋ น์ด๋ฅผ ๋น ๋ฅด๊ฒ ์ฒ๋ฆฌํ ์ ์๋ ๋น๊ฒฐ๋ ๋ฐ๋ก ์ด ์บ์ ๋ฉ๋ชจ๋ฆฌ ๋๋ฌธ์ด๋ผ๊ณ ํ ์ ์์ต๋๋ค.
2. GPU๋ ๋ฌด์์ธ๊ฐ?
GPU(๊ทธ๋ํฝ์ฒ๋ฆฌ์ฅ์น, Graphics Processing Unit)๋ ๋๊ท๋ชจ ๋ณ๋ ฌ ์ฐ์ฐ์ ์ฒ๋ฆฌํ๋๋ก ์ค๊ณ๋ ์ฐ์ฐ ์ฅ์น์ ๋๋ค. ์ด๊ธฐ์๋ ์ฃผ๋ก ๊ทธ๋ํฝ ๋ ๋๋ง์ ์ฌ์ฉ๋์์ผ๋, ํ์ฌ๋ ๋ฅ๋ฌ๋, ๊ณผํ ์ฐ์ฐ, ์ํธํํ ์ฑ๊ตด ๋ฑ ๋ค์ํ ๋ถ์ผ์์ ํ์ฉ๋๊ณ ์์ต๋๋ค.
- ๋ณ๋ ฌ ์ฒ๋ฆฌ(Parallel Processing): GPU๋ ๋จ์ ์ฐ์ฐ์ ๋์์ ์ํํ ์ ์๋ ์์ฒ ๊ฐ์ ์ฝ์ด๋ฅผ ๊ฐ์ง๊ณ ์์ด ๋ฐ๋ณต์ ์ธ ์ฐ์ฐ์์ CPU๋ณด๋ค ํจ์ฌ ๋น ๋ฆ ๋๋ค.
- ๊ตฌ์ฑ ์์: GPU๋ ์ฌ๋ฌ ๊ฐ์ ์์ ์ฝ์ด์ ๋ณ๋ ฌ ์ฐ์ฐ์ ์ง์ํ๋ ๋ฉ๋ชจ๋ฆฌ ์ํคํ ์ฒ๋ก ๊ตฌ์ฑ๋์ด ์์ต๋๋ค.
- ์ฝ์ด ์์ ์ฑ๋ฅ: ์ต์ GPU๋ ์์ฒ ๊ฐ์ ์ฝ์ด๋ฅผ ๊ฐ์ง๋ฉฐ, ์ด๋ฅผ ํตํด ๋์ผํ ์์ ์ ๋ณ๋ ฌ๋ก ์ฒ๋ฆฌํฉ๋๋ค.
๐ก ์ฌ๊ธฐ์ ์ ๊น!
๊ทธ๋ ๋ค๋ฉด โ๋ฅ๋ฌ๋์ ํ์ตํ ๋ GPU๋ฅผ ์ฐ๋ฉด ๋ฌด์กฐ๊ฑด ์ฑ๋ฅ์ด ์ข๋ค๊ทธ๋ฌ๋๋ฐ ๊ทธ๋ผ GPU๊ฐ CPU๋ณด๋ค ๋น ๋ฅด๊ณ , ์ข์๊ฑฐ ์๋๊ฐ?โ ๋ผ๋ ์๋ฌธ์ ์ ํ๋ ์ด๋ค์ด ์์ ๊ฒ์ ๋๋ค.
- โ
์ผ๋ฐ์ ์ผ๋ก ๋ฒ์ฉ ์ปดํจํ ์ธก๋ฉด์์,
CPU๋ GPU๋ณด๋ค ํจ์ฌ ๋ ์ฑ๋ฅ์ด ์ข๋ค๊ณ ํ ์ ์์ต๋๋ค. CPU๋ GPU์์ ๋ฐ๊ฒฌ๋๋ ๊ฒ๋ณด๋ค ๋ ๋์ ํด๋ญ ์๋(aka ์ฃผํ์)๋ฅผ ๊ฐ์ง ๋ ์ ์ ์์ ํ๋ก์ธ์ ์ฝ์ด ๋ก ์ค๊ณ๋์ด ์ผ๋ จ์ ์์ ์ ๋งค์ฐ ๋น ๋ฅด๊ฒ ์๋ฃ ํ ์ ์๊ธฐ ๋๋ฌธ์ ๋๋ค.- ๐ค
ํ์ง๋ง, ๋ฅ๋ฌ๋ ํ์ต ์ธก๋ฉด์์๋
GPU๊ฐ CPU๋ณด๋ค ์ข๋ค๊ณ ํ ์ ์์ต๋๋ค.
GPU์ ๋ํด ๋ ๋ํ ์ผํ๊ฒ ์์๋ณผ๊น์?
GPU๋ CPU์ ๋นํด ํจ์ฌ ๋ ๋ง์ ์์ ์ฝ์ด๋ฅผ ๊ฐ์ง๊ณ ์์ผ๋ฉฐ ์ ์ด์ ์ค๊ณ๋ ๋ค๋ฅธ ๋ชฉ์ ์ผ๋ก ๋ง๋ค์ด์ก์ต๋๋ค. ์ต์ด์ GPU๋ ์ด๋ฆ์์ ์์ ์๋ค์ํผ ๊ทธ๋ํฝ ์ฒ๋ฆฌ ์ฅ์น๋ก์จ, ๊ทธ๋ํฝ ๋ ๋๋ง์ ์ฑ๋ฅ์ ๊ฐ์ํํ๋๋ก ์ค๊ณ๋์์ต๋๋ค.
CPU์ GPU์ ๋ฐ์ ์ ๊ฐ๋จํ๊ฒ ์๊ฐ๋ฅผ ์ ํ ์๊ฐ ์์ ๊ฒ ๊ฐ์๋ฐ์. ์์ฃผ ์ข์ ์ค๋ช ์ด ์์ด์ ๋งํฌ ๊ฑธ์ด๋๊ฒ ์ต๋๋ค. (๋งํฌ : ๊ทธ๋ํฝ ์นด๋ ์ด์ผ๊ธฐ)
๋ณธ ์์์ ์์ฝํ์๋ฉด, ๊ธฐ์กด์ CPU๋ ์ปดํจํฐ๊ฐ ํ๋ ๋ชจ๋ ์ผ์ ์กฐ์ข /ํต์ ํด์์ต๋๋ค. ๊ทธ๋ฌ๋ ์ ์ ๊ธฐ์ ์ด ๋ฐ์ ํ๋ฉด์ GUI(Graphical User Interface) ๋ฑ์ ๋ค์ํ ๋ก๋๊ฐ ์ถ๊ฐ ๋์๊ณ , ์ด๋ CPU์ ์ฑ๋ฅ ์ ํ๋ก ์ด์ด์ ธ CPU๊ฐ ์ ๋ ์ ๋ ์ค์ํ ์ฐ์ฐ์ ๋ชปํ๊ฒ ๋์์ต๋๋ค.
๊ทธ๋ฌ์ ์ด์ ๊ฐ๋ฐ์๋ค์ ๊ฐ๋จํ ์ฐ์ฐ๋ค(ex. ๊ทธ๋ํฝ ์์ )์ ๋ค๋ฅธ Processing Unit์๊ฒ ๋งก๊ธฐ๊ณ ๊ธฐ์กด์ ์ค์ํ ์ผ์ CPU์๊ฒ ๋งก๊ธฐ๋๋ก ํ์๋ ์์ด๋์ด๊ฐ ๋์๊ณ ๊ทธ๊ฒ์ด ๋ฐ๋ก GPU์ ํ์์ด ๋๊ฒ ๋ฉ๋๋ค.
์ด๋ ๊ฒ CPU์ ๋ถ๋ด์ค๋ฌ์ด ๊ณ์ฐ์ GPU๊ฐ ์คํ๋ก๋ํด์ค์ผ๋ก์จ ์ฒ๋ฆฌ ๋ฅ๋ ฅ์ ํ๋ณด ํ ์ ์๋๋กํจ์ผ๋ก์จ ๊ณ์ํด ๋ฐ์ ๋์ด ์์ต๋๋ค. CPU๋ GPU๋ฅผ ํฌํจํ ์์คํ ์ ๋๋จธ์ง ๋ถ๋ถ์ ์ง์นจ์ ์ ๊ณตํ๋ ์์ ์ ๋๋๋ก, GPU๋ ๋ณ๋ ฌ ์ฒ๋ฆฌ ์ํคํ ์ฒ๋ก ์ธํด CPU๋ณด๋ค ์ด๋ฏธ์ง ๋ ๋๋ง์ ์ต์ ํ๋์ด ๋ฐ์ ๋์ด ์์ต๋๋ค. ์์ฝํ์๋ฉด, CPU๋ ์ด๋ ค์ด ๋ฌธ์ ๋ฅผ ํธ๋๋ฐ ํนํ๋ ์์ ์ ์ ์ฑ๊ธ์ฝ์ด, ๊ทธ๋ฆฌ๊ณ GPU๋ ์ฌ์ด ๋ฌธ์ ๋ฅผ ๋์์ ํธ๋ ๋ฐ ํนํ๋ ์ธํด์ ์ ๋ฉํฐ์ฝ์ด๋ผ๊ณ ๋ณด๋ฉด ๋ ๊ฑฐ ๊ฐ์ต๋๋ค.
๊ธฐ์กด์ CPU๊ฐ ์์ฐจ์ ์ธ ์ฒ๋ฆฌ ๋ฐฉ์์ ํนํ๋์ด ์์๋ค๋ฉด, GPU๋ ๋ณ๋ ฌ์ ์ธ(Parallel) ์ฒ๋ฆฌ ๋ฐฉ์์ ํนํ๋์ด ์์ผ๋ฉฐ ์ด๋ก ์ธํด ๋ฐ๋ณต์ ์ด๊ณ ๋น์ทํ ๋๋์ ์ฐ์ฐ์ ์ํํ๋ ๋ฐ์ ์์ด์ ์๋๊ฐ ๋น ๋ฆ ๋๋ค. GPU๋ ๋ ์๊ณ ๋ณด๋ค ์ ๋ฌธํ๋ ์ฌ๋ฌ๊ฐ์ ์ฝ์ด๋ก ๊ตฌ์ฑ๋ ํ๋ก์ธ์์ ๋๋ค.
์ฌ๋ฌ ๊ฐ์ ์ฝ์ด๊ฐ ํจ๊ป ์๋ํ๋ฏ๋ก, ์ฌ๋ฌ ์ฝ์ด๋ก ๋๋์ด ์ฒ๋ฆฌํ ์ ์๋ ์์ ์ ๊ฒฝ์ฐ GPU๊ฐ ์์ฒญ๋ ์ฑ๋ฅ ์ด์ ์ ์ ๊ณตํฉ๋๋ค. ๊ธฐ์กด์ CPU๊ฐ 6-8๊ฐ์ ์ฝ์ด๋ก ๊ตฌ์ฑ๋์ด ์๋ค๋ฉด, GPU๋ ์ด๋ค GPU์ธ๊ฐ์ ๋ฐ๋ผ ๋ง์ด ์์ดํ์ง๋ง ์ ๊ฒ๋ ์๋ฐฑ๊ฐ์์ ๋ง๊ฒ๋ ์์ฒ๊ฐ์ ์ฝ์ด๋ก ๊ตฌ์ฑ๋์ด ์์ต๋๋ค.
Source : https://kr.nvidia.com/object/what-is-gpu-computing-kr.html
์ฐ๋ฆฌ๊ฐ ๋ฅ๋ฌ๋์ ์๊ฐํด๋ณด๋ฉด ๋๋ถ๋ถ์ด ๋ฒกํฐ๋ ํ๋ ฌ ์ฐ์ฐ์ผ๋ก ์ด๋ฃจ์ด์ ธ์๋ค๊ณ ํด๋ ๊ณผ์ธ์ด ์๋๋ฐ์. ์ด๋ฌํ ์ ๋๋์ด์ง๋ ๊ณ์ฐ, ์ฆ ๋ณ๋ ฌ์ฑ์ด ๊ทน๋ํ๋ ๊ณ์ฐ์ GPU๊ฐ ์ด๋ฏธ ํด์ค๋ ์ฐ์ฐ์ผ๋ก, GPU๋ฅผ ๋ฅ๋ฌ๋ ์ฐ์ฐ์ ์ฌ์ฉํ๊ฒ ๋จ์ผ์จ CPU๋ณด๋ค ๋ ๋น ๋ฅด๊ณ ์ต์ ํ๋ ์ฐ์ฐ์ ์ํํ๊ฒ ๋ฌ๋ค๊ณ ๋ณด์๋ฉด ๋ ๊ฒ ๊ฐ์ต๋๋ค.
๋น๊ต: CPU์ GPU์ ์ค๊ณ ์ฒ ํ
-
CPU๋ ์ ๋ฌธ๊ฐ, GPU๋ ์์ ๋ถ๋ดํ ๊ณต์ฅ
CPU๋ ๋ณต์กํ๊ณ ๋ค์ํ ์์ ์ ๊ณ ์์ผ๋ก ์ฒ๋ฆฌํ ์ ์๋ ๋ง๋ฅ ์ ๋ฌธ๊ฐ์ ๊ฐ์ต๋๋ค. ๋ฐ๋ฉด GPU๋ ๋ง์ ์ผ๊พผ์ด ํ ๊ฐ์ง ์์ ์ ๋๋์ด ์ํํ๋ ๊ณต์ฅ๊ณผ ๊ฐ์ ๋๋์ ๋ฐ์ดํฐ๋ฅผ ํจ์จ์ ์ผ๋ก ์ฒ๋ฆฌํฉ๋๋ค.
-
CPU vs GPU ์ํคํ ์ฒ ๋น๊ต
ํน์ง | CPU | GPU |
---|---|---|
์ฃผ์ ์ญํ | ๋ฒ์ฉ ์ฒ๋ฆฌ(์ด์์ฒด์ , ์ ํ๋ฆฌ์ผ์ด์ ๋ฑ) | ๋ณ๋ ฌ ์ฐ์ฐ(๊ทธ๋ํฝ, ๋ฅ๋ฌ๋ ๋ฑ) |
์ฝ์ด ์ | ์์(4~8๊ฐ) | ๋ค์(์๋ฐฑ~์์ฒ ๊ฐ) |
์ฒ๋ฆฌ ์๋ | ๊ณ ์ ์ฑ๊ธ ์ฐ์ฐ | ๋ค๋์ ์ฐ์ฐ์ ๋ณ๋ ฌ ์ฒ๋ฆฌ |
๋ฉ๋ชจ๋ฆฌ ๊ตฌ์กฐ | ๋์ฉ๋ ์บ์ | ๊ณ ๋์ญํญ ๋ฉ๋ชจ๋ฆฌ |
์ฐ์ฐ ์ต์ ํ | ์์ฐจ ์ฐ์ฐ | ๋ณ๋ ฌ ์ฐ์ฐ |
์คํํด๋ด ์๋ค!
๋ค์์ ์๋ ๋น๊ต๋ฅผ ์ํด ๊ฐ๋จํ๊ฒ ์ฝ๋๋ก ์ฐ์ฐ ๋ฐ ์ฒ๋ฆฌ ์๋๋ฅผ ๋น๊ตํด ๋ณธ ๊ฒ์ธ์.
๋จ์ํ ์์ ์ฐ์ฐ์ ์ํํ ๋ ๊ฐ๊ฐ CPU๋ 5.84ms, GPU๋ 42.8ms๊ฐ ๋์จ ๊ฒ์ ํตํด ์ฐ๋ฆฌ๋ CPU๊ฐ ํ๋์ ์ฐ์ฐ์ ์ํํจ์ ์์ด์ ๋ ์ฐ์ํ ๊ฒ์ ๋ณผ ์ ์์ต๋๋ค.
๋ฐ๋ฉด์ 10000 by 10000 ํ๋ ฌ์ฐ์ฐ์ ์ํํ๋ ๋ฐ ์์ด์๋ CPU๋ 13.7s, GPU๋ 785ms์ธ ๊ฒ์ ํตํด GPU๊ฐ ๋ณ๋ ฌ ์ฐ์ฐ์ ํ๋๋ฐ ์์ด์ ๋ ๋น ๋ฅธ ๊ฒ์ ์ง์ ์ ์ผ๋ก ํ์ธํด ๋ณผ ์ ์์ต๋๋ค.
GPU์ ์ค์ ์์ฉ
- GPU๋ ์๋ ์ฉ๋๋ก ์ฐ์ผ ์ ์์ต๋๋ค:
๋ฅ๋ฌ๋ ํ์ต
: ๋ฅ๋ฌ๋ ๋ชจ๋ธ์ ์์ญ์ต ๊ฐ์ ํ๋ผ๋ฏธํฐ๋ฅผ ํ์ตํ๊ธฐ ์ํด GPU์ ๋ณ๋ ฌ ์ฐ์ฐ์ ํ์ฉํฉ๋๋ค. GPU์ ํ ์ ์ฝ์ด๋ ์ด๋ฌํ ํ์ต ์์ ์ ๋น ๋ฅด๊ณ ํจ์จ์ ์ผ๋ก ์ํํฉ๋๋ค.๊ทธ๋ํฝ ๋ ๋๋ง
: GPU๋ 3D ๊ทธ๋ํฝ์์ ๋ชจ๋ธ ๋ณํ, ์กฐ๋ช ๊ณ์ฐ, ํ ์ค์ฒ ๋งคํ ๋ฑ ์ฌ๋ฌ ์์ ์ ๋์์ ์ฒ๋ฆฌํฉ๋๋ค. ์ด๋ฅผ ํตํด ์ค์๊ฐ์ผ๋ก ๊ณ ํ์ง ๊ทธ๋ํฝ์ ๋ ๋๋งํ ์ ์์ต๋๋ค.์ํธํํ ์ฑ๊ตด
: GPU๋ ๋ณ๋ ฌ๋ก ์๋ง์ ํด์ ์ฐ์ฐ์ ์ํํ์ฌ ๋นํธ์ฝ์ธ๊ณผ ๊ฐ์ ์ํธํํ ์ฑ๊ตด ์์ ์ ์ฌ์ฉ๋ฉ๋๋ค. SHA-256 ํด์ฑ ์๊ณ ๋ฆฌ์ฆ์ ๋ฐ๋ณต์ ์ผ๋ก ์คํํ์ฌ ๋น ๋ฅด๊ฒ ๊ฒฐ๊ณผ๋ฅผ ๋์ถํฉ๋๋ค.
GPU ๋ด๋ถ ๊ตฌ์กฐ ์ดํด๋ณด๊ธฐ
- ์ฐธ๊ณ ์์ : https://youtu.be/h9Z4oGN89MU
์ต์ GPU์ ๋ด๋ถ๋ ์๋ง์ ๊ธฐ์ ์ ํ์ ๊ณผ ๋ณ๋ ฌ ์ฐ์ฐ์ ๋น๋ฐ์ด ๋ด๊ธด ๋ณต์กํ ์ค๊ณ๋ฅผ ๊ฐ์ง๊ณ ์์ต๋๋ค.
์ถ์ฒ: How do Graphics Cards Work? Exploring GPU Architecture(๋งํฌ)
NVIDIA RTX 3090 GPU๋ฅผ ๊ธฐ์ค์ผ๋ก ํ์ฌ ์ธ๋ถ์ ์ผ๋ก ์ดํด๋ณด๊ฒ ์ต๋๋ค. ์ผ๋จ GPU๋ ์๋ 3๊ฐ์ง ์ฝ์ด๋ก ๊ตฌ์ฑ์ด ๋์ด ์์ต๋๋ค.
์ถ์ฒ: How do Graphics Cards Work? Exploring GPU Architecture(๋งํฌ)
- CUDA Cores
- Tensor Cores
- Ray Tracing Cores
1. ์ฝ์ด์ ๋ณ๋ ฌ ์ฒ๋ฆฌ
CUDA ์ฝ์ด๋ GPU์ ๊ธฐ๋ณธ ๊ตฌ์ฑ ์์์ ๋๋ค. RTX 3090์๋ 10,496๊ฐ์ CUDA ์ฝ์ด๊ฐ ์์ผ๋ฉฐ, ์ด ์ฝ์ด๋ค์ ๊ฐ๋จํ ์ฐ์ ์ฐ์ฐ(๋ง์ , ๊ณฑ์ ๋ฑ)์ ์ํํฉ๋๋ค.
์ถ์ฒ: How do Graphics Cards Work? Exploring GPU Architecture(๋งํฌ)
-
CUDA ์ฝ์ด๋? (๋ฒ์ฉ ๋ณ๋ ฌ ์ฐ์ฐ ์ ๋)
- ๊ธฐ๋ณธ ๊ฐ๋ : CUDA ์ฝ์ด๋ GPU์ ๊ฐ์ฅ ๊ธฐ๋ณธ์ ์ธ ์ฐ์ฐ ์ ๋์ผ๋ก, ์ผ๋ฐ์ ์ธ ์ฐ์ ์ฐ์ฐ(๋ง์ , ๊ณฑ์ ๋ฑ)์ ๋ณ๋ ฌ๋ก ์ฒ๋ฆฌํฉ๋๋ค.
-
์๋ ๋ฐฉ์: ๋ชจ๋ CUDA ์ฝ์ด๋ ํ๋์ ๋ช ๋ น์ด๋ฅผ ๋ฐ์ ๊ฐ ๋ฐ์ดํฐ๋ฅผ ๋ ๋ฆฝ์ ์ผ๋ก ๊ณ์ฐํฉ๋๋ค.
- ์๋ฅผ ๋ค์ด, 3D ๊ทธ๋ํฝ์์ ๋ฌผ์ฒด์ ๊ฐ ์ (vertex)์ ์ด๋์ํค๊ธฐ ์ํด ((x+dx, y+dy, z+dz)$ ์ฐ์ฐ์ ๋ณ๋ ฌ๋ก ์ํํฉ๋๋ค.
- ํน์ง: ๋ฒ์ฉ์ ์ผ๋ก ๋์ํ๋ฉฐ, ๊ฒ์ ๊ทธ๋ํฝ ๋ ๋๋ง, ๋ฐ์ดํฐ ๋ณ๋ ฌ ์ฒ๋ฆฌ ๋ฑ ๋ค์ํ ์์ ์ ์ฌ์ฉ๋ฉ๋๋ค.
-
์ฝ๊ฒ ์ดํดํ๊ธฐ: ๋ค์์ ์ผ๊พผ์ด ๊ฐ์ ๋ ๋ฆฝ์ ์ผ๋ก ์ผํ๋ ๊ณต์ฅ.
-
๋ณ๋ ฌ ์ฒ๋ฆฌ์ SIMD(Single Instruction Multiple Data)
- GPU๋ SIMD ์ํคํ ์ฒ๋ฅผ ํตํด ๋์ํฉ๋๋ค. ํ๋์ ๋ช ๋ น์ด๋ฅผ ์ฌ๋ฌ ๋ฐ์ดํฐ์ ๋์์ ์ ์ฉํ๋ ๋ฐฉ์์ผ๋ก ์๋ํฉ๋๋ค.
- ์๋ฅผ ๋ค์ด, 3D ๊ทธ๋ํฝ์์ ๋ฌผ์ฒด์ ๋ชจ๋ ์ (vertex)์ ํน์ ์์น๋ก ์ด๋์ํค๋ ์ฐ์ฐ์์ GPU๋ ๋ชจ๋ ์ ์ ๋ํด ๋์ผํ ๊ณ์ฐ์ ๋ณ๋ ฌ๋ก ์ํํฉ๋๋ค.
-
๋ณ๋ ฌ ์ฒ๋ฆฌ ์์
- 3D ๋ชจ๋ธ์ ๊ฐ ์ ์ ์ขํ(x, y, z)๋ฅผ ์ด๋์ํค๊ธฐ ์ํด (x+dx,y+dy,z+dz)(x + dx, y + dy, z + dz)(x+dx,y+dy,z+dz)๋ฅผ ๊ณ์ฐํ๋ ๊ฒ์ ์๋ก ๋ค ์ ์์ต๋๋ค.
- ์์ฒ ๊ฐ์ ์ ์ ๋์์ ์ฒ๋ฆฌํ ์ ์์ด CPU๋ณด๋ค ํจ์ฌ ๋น ๋ฅด๊ฒ ๊ฒฐ๊ณผ๋ฅผ ์์ฑํ ์ ์์ต๋๋ค.
-
GPU์ ์ฝ์ด ๋ฐฐ์น
- CUDA ์ฝ์ด๋
SM
, Streaming Multiprocessor๋ผ๋ ๊ทธ๋ฃน์ผ๋ก ๋ฌถ์ ๋๋ค. SM
์ ์ฌ๋ฌ ์ฝ์ด๋ฅผ ํฌํจํ๋ฉฐ, ๊ฐ SM ๋ด์์ ์ค๋ ๋(threads)๊ฐ ๋ณ๋ ฌ๋ก ์คํ๋ฉ๋๋ค.
- CUDA ์ฝ์ด๋
์ถ์ฒ: How do Graphics Cards Work? Exploring GPU Architecture(๋งํฌ)
NVIDIA์ GA102 GPU ์ํคํ ์ฒ๋ RTX 3080, 3090, 3080 Ti, 3090 Ti์ ์ฌ์ฉ๋๋ฉฐ, ๋์ผํ ์ค๊ณ๋ฅผ ๊ธฐ๋ฐ์ผ๋ก ์ ์๋์์ต๋๋ค.
- ๊ทธ๋ฌ๋ ์ด๋ค์ด ๋ค๋ฅธ ์ฑ๋ฅ์ ์ ๊ณตํ๋ ์ด์ ๋ ์ ์กฐ ๊ณต์ ๊ณผ ์นฉ์ ๊ฒฐํจ ์ฒ๋ฆฌ ๋ฐฉ์์ ์์ต๋๋ค.๐ฎ๐ฎ
-
-
๋ชจ๋ ์นด๋๊ฐ ๋์ผํ GA102 ์ํคํ ์ฒ๋ฅผ ์ฌ์ฉํ์ง๋ง, ์ ์กฐ ๊ณผ์ ์์ ๋ฐ์ํ๋ ๋ฏธ์ธํ ๊ฒฐํจ(ํจํฐ๋ ์ค๋ฅ, ๋จผ์ง ์ ์ ๋ฑ)์ ์ฒ๋ฆฌํ๊ธฐ ์ํด ์ค๊ณ๋ ์ฝ์ด ์ค ์ผ๋ถ๋ฅผ ๋นํ์ฑํํฉ๋๋ค.
- ์๋ฅผ ๋ค์ด, ๊ฒฐํจ์ด ์๋ ์คํธ๋ฆฌ๋ฐ ๋ฉํฐํ๋ก์ธ์(SM)๋ฅผ ๋นํ์ฑํํ๊ณ ๋๋จธ์ง ์ ์์ ์ผ๋ก ์๋ํ๋ ์ฝ์ด๋ง ํ์ฑํํฉ๋๋ค.
์ถ์ฒ: How do Graphics Cards Work? Exploring GPU Architecture(๋งํฌ)
- GPU ์นฉ์ ํ ์คํธ๋ฅผ ํตํด ์ฝ์ด ์์ ์ฑ๋ฅ์ ๋ฐ๋ผ ๋ถ๋ฅ(binning)๋ฉ๋๋ค.
- RTX 3090 Ti๋ ์๋ฒฝํ ์นฉ์ผ๋ก ๋ชจ๋ 10,752๊ฐ์ ์ฟ ๋ค ์ฝ์ด๋ฅผ ํ์ฑํํ๋ฉฐ, RTX 3080์ 8,704๊ฐ์ ์ฟ ๋ค ์ฝ์ด๋ง ํ์ฑํ๋ ๊ฒฐํจ ๋ฒ์ ์ ๋๋ค.
-
์๋๋ ์ด๋ฅผ ์ ๋ฆฌํ ํ ์ด๋ธ์ ๋๋ค:
๋ชจ๋ธ ํ์ฑํ๋ ์ฟ ๋ค ์ฝ์ด ์ ๋นํ์ฑํ๋ SM ์ ๋น๊ณ RTX 3090 Ti 10,752 0 ์๋ฒฝํ ์นฉ RTX 3090 10,496 2 ์ผ๋ถ ๊ฒฐํจ ์ฒ๋ฆฌ RTX 3080 Ti 10,240 4 ์ค๊ฐ ์ฑ๋ฅ RTX 3080 8,704 16 ๋ ๋ง์ ๊ฒฐํจ ์ฒ๋ฆฌ
2. ํ ์ ์ฝ์ด์ AI ๊ฐ์
ํ ์ ์ฝ์ด(Tensor Core)๋ ๋ฅ๋ฌ๋๊ณผ ๊ฐ์ ๊ณ ์ฑ๋ฅ ๊ณ์ฐ ์์ ์ ํนํ๋ GPU์ ์ฐ์ฐ ์ฅ์น์ ๋๋ค.
- ํ ์ ์ฝ์ด๋ ํ๋ ฌ ์ฐ์ฐ(Matrix Math)์ ๋น ๋ฅด๊ฒ ์ฒ๋ฆฌํ์ฌ ์ ๊ฒฝ๋ง์ ํ์ต ์๋๋ฅผ ํฌ๊ฒ ๋์ ๋๋ค.
์ถ์ฒ: Nvidia ๊ณต์ ์ฌ์ดํธ (Nvidia.com)
- (์ผ์ชฝ) ํ๋ ฌ ๋ด์ ๊ฐ ์์๋ฅผ ๊ฐ๋ณ์ ์ผ๋ก ๊ณ์ฐํ๋ ํ์ค์นผ ์ํคํ ์ฒ, (์ค๋ฅธ์ชฝ) ์ ์ฒด ์์ ์ ํ ๋ฒ์ ๋๋ด๋ ๋ณผํ ํ ์ ์ํคํ ์ฒ
-
Tensor ์ฝ์ด๋? (๋ฅ๋ฌ๋ ๊ฐ์๊ธฐ)
- ๊ธฐ๋ณธ ๊ฐ๋ : Tensor ์ฝ์ด๋ GPU์์ ๋ฅ๋ฌ๋ ์ฐ์ฐ์ ๊ฐ์ํ๊ธฐ ์ํด ์ค๊ณ๋ ์ ๋์ผ๋ก, ๋๊ท๋ชจ ํ๋ ฌ ์ฐ์ฐ(Matrix Multiplication)์ ํนํ๋์ด ์์ต๋๋ค.
-
์๋ ๋ฐฉ์: ํ๋์ ์ฐ์ฐ ์ฃผ๊ธฐ์์ D=AรB+CD = A \times B + CD=AรB+C์ ๊ฐ์ ๋ณต์กํ ํ๋ ฌ ์ฐ์ฐ์ ์ํํฉ๋๋ค.
- FP16(16-bit ๋ถ๋์์์ )์ ์ฌ์ฉํ์ฌ ์ฐ์ฐ ํจ์จ์ ๊ทน๋ํํฉ๋๋ค.
-
ํน์ง:
- ํ ๋ฒ์ 4x4 ๋๋ 8x8 ํ๋ ฌ์ ๋ณ๋ ฌ๋ก ๊ณ์ฐํ์ฌ, ๋ฅ๋ฌ๋ ๋ชจ๋ธ์ ํ์ต ์๋๋ฅผ ๋น์ฝ์ ์ผ๋ก ๋์ ๋๋ค.
- ๋ฅ๋ฌ๋์์ ์์ฃผ ์ฐ์ด๋ CNN(Convolutional Neural Network) ๋๋ Transformer ๋ชจ๋ธ์ ์ต์ ํ.
-
์ฝ๊ฒ ์ดํดํ๊ธฐ: AI ํ์ต์ ์ํ ์ ๋ฌธ ์์ ๋ฐ. ํ๋ ฌ ์ฐ์ฐ์ด๋ผ๋ ํฐ ์์ ์ ๋งก์ GPU ์ ์ฒด์ ํจ์จ์ ๊ทน๋ํํฉ๋๋ค.
์ถ์ฒ: How do Graphics Cards Work? Exploring GPU Architecture(๋งํฌ)
-
GPU์ AI
- ๋ฅ๋ฌ๋ ๋ชจ๋ธ์ ์์ฒ ๊ฐ์ ํ๋ ฌ ๊ณฑ์ ๊ณผ ๊ฐ์ ์ฐ์ฐ์ผ๋ก ๊ตฌ์ฑ๋ฉ๋๋ค.
- GPU์ ํ ์ ์ฝ์ด๋ ์ด๋ฌํ ์ฐ์ฐ์ ๋ณ๋ ฌ๋ก ์ฒ๋ฆฌํ์ฌ AI ๋ชจ๋ธ์ ํ์ต ์๋๋ฅผ CPU ๋๋น 10 ~ 100๋ฐฐ ์ด์ ๋์ผ ์ ์์ต๋๋ค.
-
ํ์ฉ ์ฌ๋ก
- ์์ฐ์ด ์ฒ๋ฆฌ ๋ชจ๋ธ(์: ChatGPT)
- ์ด๋ฏธ์ง ์์ฑ ๋ชจ๋ธ(์: Stable Diffusion)
- ์์ฑ ์ธ์ ๋ฐ ์์ฑ ๋ชจ๋ธ
์ถ์ฒ: Nvidia ๊ณต์ ์ฌ์ดํธ (Nvidia.com)
3. ๋ ์ด ํธ๋ ์ด์ฑ ์ฝ์ด
๋ ์ด ํธ๋ ์ด์ฑ ์ฝ์ด๋ ๋น์ ๋ฐ์ฌ, ๊ตด์ , ๊ทธ๋ฆผ์ ์์ฑ ๋ฑ์ ๋ฌผ๋ฆฌ์ ์ผ๋ก ์ ํํ๊ฒ ๊ณ์ฐํ์ฌ 3D ํ๊ฒฝ์์ ๋งค์ฐ ์ฌ์ค์ ์ธ ์ด๋ฏธ์ง๋ฅผ ์์ฑํฉ๋๋ค.
-
๋ ์ด ํธ๋ ์ด์ฑ์ด๋?
- ๋ ์ด ํธ๋ ์ด์ฑ์ ๊ด์ ์ด ๋ฌผ์ฒด์ ์ํธ์์ฉํ๋ ๋ฐฉ์์ ์๋ฎฌ๋ ์ด์ ํ์ฌ ํ์ค๊ฐ ์๋ ๊ทธ๋ํฝ์ ์์ฑํ๋ ๊ธฐ์ ์ ๋๋ค.
- ์๋ฅผ ๋ค์ด, ๋น์ด ์ ๋ฆฌ์์ ํต๊ณผํ๋ฉด์ ๊ตด์ ๋๊ณ ์ฃผ๋ณ ๋ฌผ์ฒด์ ๋ฐ์ฌ๋๋ ํจ๊ณผ๋ฅผ GPU๊ฐ ์ค์๊ฐ์ผ๋ก ๊ณ์ฐํฉ๋๋ค.
-
Ray Tracing ์ฝ์ด๋? (์ฌ์ค์ ์ธ ๊ทธ๋ํฝ ์์ฑ๊ธฐ)
- ๊ธฐ๋ณธ ๊ฐ๋ : Ray Tracing ์ฝ์ด๋ GPU์์ ๊ด์ (ray)๊ณผ ๋ฌผ์ฒด ๊ฐ์ ์ํธ์์ฉ(๋ฐ์ฌ, ๊ตด์ , ๊ทธ๋ฆผ์ ๋ฑ)์ ๋ฌผ๋ฆฌ์ ์ผ๋ก ์ ํํ๊ฒ ๊ณ์ฐํ๋ ์ ๋์ ๋๋ค.
-
์๋ ๋ฐฉ์: ๋น์ ๊ฒฝ๋ก๋ฅผ ์๋ฎฌ๋ ์ด์ ํ์ฌ ๊ด์ ์ด ๋ฌผ์ฒด์ ๋ถ๋ชํ ๋ ๋ฐ์ฌ๋๊ฑฐ๋ ๊ตด์ ๋๋ ํจ๊ณผ๋ฅผ ์ค์๊ฐ์ผ๋ก ๊ณ์ฐํฉ๋๋ค.
- ๊ฐ ๊ด์ ๊ณผ ๋ฌผ์ฒด์ ๊ต์ฐจ์ ์ ์ฐพ์๋ด๊ณ , ์ด๋ฅผ ๊ธฐ๋ฐ์ผ๋ก ํ๋ฉด์ ํ์๋๋ ์ด๋ฏธ์ง๋ฅผ ์์ฑํฉ๋๋ค.
-
ํน์ง:
- ์ฌ์ค์ ์ด๊ณ ์๋๊ฐ ์๋ ๊ทธ๋ํฝ์ ์ค์๊ฐ์ผ๋ก ๋ ๋๋ง ๊ฐ๋ฅ.
- Cyberpunk 2077 ๊ฐ์ ๊ณ ํ์ง ๊ฒ์์ด๋ ์ํ ์ ์์์ ์ฃผ๋ก ์ฌ์ฉ.
-
์ฝ๊ฒ ์ดํดํ๊ธฐ: 3D ๊ทธ๋ํฝ์ ๋น ์ ๋ฌธ ๋์์ด๋. ํ๋ฉด์ ๋น์ด ๋ฐ์ฌ๋๋ ๋ชจ์ต์ ์์ฐ์ค๋ฝ๊ฒ ๋ง๋ค์ด ์ค๋๋ค.
์ถ์ฒ: How do Graphics Cards Work? Exploring GPU Architecture(๋งํฌ)
- ์์ฉ ๋ถ์ผ
- ์ค์๊ฐ ๊ทธ๋ํฝ(๊ฒ์: Cyberpunk 2077, Minecraft RTX)
- 3D ๋ ๋๋ง ๋ฐ ์ ๋๋ฉ์ด์
- ์ํ ๋ฐ ๊ด๊ณ ์ ์
์์ฝ
์๋๋ CUDA ์ฝ์ด, Tensor ์ฝ์ด, ๊ทธ๋ฆฌ๊ณ Ray Tracing ์ฝ์ด์ ์ฐจ์ด๋ฅผ ํ ํ์ ์ ๋ฆฌํ๊ณ , ๊ฐ๊ฐ์ ๊ฐ๋ ์ ํ์ค๋ก ์ ๋ฆฌํ ๋ด์ฉ์ ๋๋ค..
ํน์ง | CUDA ์ฝ์ด(CUDA Core) | Tensor ์ฝ์ด(Tensor Core) | Ray Tracing ์ฝ์ด(Ray Tracing Core) |
---|---|---|---|
์ญํ | ๋ฒ์ฉ ๋ณ๋ ฌ ์ฐ์ฐ ์ฒ๋ฆฌ | ํ๋ ฌ ์ฐ์ฐ ๋ฐ ๋ฅ๋ฌ๋ ๊ฐ์ํ | ์ค์๊ฐ ๋น ์ถ์ ๊ณ์ฐ์ผ๋ก ์ฌ์ค์ ๊ทธ๋ํฝ ์์ฑ |
์ฐ์ฐ ์ ํ | ์ค์นผ๋ผ ์ฐ์ฐ (๋จ์ผ ๊ฐ์ ๋ง์ , ๊ณฑ์ ๋ฑ) | ํ๋ ฌ ์ฐ์ฐ (๋ค์ค ๊ฐ์ ๊ณฑ์ ๋ฐ ๋ง์ ) | ๊ด์ -๋ฌผ์ฒด ๊ต์ฐจ ๋ฐ ๋น์ ๋ฐ์ฌ, ๊ตด์ ๊ณ์ฐ |
์๋ ๋ฐฉ์ | ํ ๋ฒ์ ํ ๊ฐ์ ์ซ์ ์ฐ์ฐ ์ฒ๋ฆฌ | ํ ๋ฒ์ 4x4 ๋๋ 8x8 ํ๋ ฌ ๊ณ์ฐ | ๋ณต์กํ ๊ดํ ์ฐ์ฐ์ ๋ณ๋ ฌ๋ก ์ฒ๋ฆฌ |
์ฐ์ฐ ์ฑ๋ฅ | ๋ฒ์ฉ์ ์ผ๋ก ๋์, ๋๊ท๋ชจ ์ฐ์ฐ์์ ํจ์จ์ | ๋ฅ๋ฌ๋ ํ์ต์์ ์ด๊ณ ์ ์ฑ๋ฅ ์ ๊ณต | ์ฌ์ค์ ์ธ ๋น์ ๋ฐ์ฌ ๋ฐ ๊ทธ๋ฆผ์ ํํ ๊ฐ๋ฅ |
ํ์ฉ ๋ถ์ผ | ๊ทธ๋ํฝ ๋ ๋๋ง, ๊ธฐ๋ณธ ๋ณ๋ ฌ ์ฐ์ฐ | ๋ฅ๋ฌ๋ ํ์ต ๋ฐ ์ถ๋ก , AI ๋ชจ๋ธ | ์ค์๊ฐ ๊ทธ๋ํฝ, 3D ์ ๋๋ฉ์ด์ , ์ํ ์ ์ |
๋ฐ์ดํฐ ์ ๋ฐ๋ | FP32(32-bit ๋ถ๋์์์ ), INT32 | FP16(16-bit ๋ถ๋์์์ ), INT8 | ๊ดํ ๋ชจ๋ธ ๊ธฐ๋ฐ ์ฐ์ฐ |
ํจ์จ์ฑ | ๋จ์ ์ฐ์ฐ์์ ๊ฐ๋ ฅ | ๋๊ท๋ชจ ๋ณ๋ ฌ ์ฐ์ฐ์์ ๊ทน๋๋ก ํจ์จ์ | ๊ทธ๋ํฝ ์ฌ์ค์ฑ ๊ทน๋ํ, ๋ณ๋ ฌ ์ฒ๋ฆฌ ํจ์จ์ |
- CUDA ์ฝ์ด: ๊ฒ์์ด๋ ์ ํ๋ฆฌ์ผ์ด์ ์์ ๋ฐ๋ณต์ ์ธ ์ฐ์ฐ์ ์ํํ๋ฉฐ, ๊ทธ๋ํฝ๊ณผ ๋ฐ์ดํฐ ์ฒ๋ฆฌ๋ฅผ ๋ด๋น.
- Tensor ์ฝ์ด: AI์ ๋ฅ๋ฌ๋ ์์ ์์ ๋๊ท๋ชจ ๋ฐ์ดํฐ ํ์ต๊ณผ ์ถ๋ก ์ ๊ฐ์.
- Ray Tracing ์ฝ์ด: ์ฌ์ค์ ์ธ ์กฐ๋ช ๊ณผ ๊ทธ๋ฆผ์๋ฅผ ์์ฑํ์ฌ ๋ชฐ์ ๊ฐ์ ๋ํจ.
GPU์ ๋ณ๋ ฌ ์ฐ์ฐ: ๋ฅ๋ฌ๋์์์ ํ์ฉ
GPU๋ ๋ฒกํฐ ๋ฐ ํ๋ ฌ ์ฐ์ฐ์ ๋ณ๋ ฌ๋ก ์ฒ๋ฆฌํ๋ฉฐ, ์ด๋ ๋ฅ๋ฌ๋ ๋ชจ๋ธ์ ํ์ต๊ณผ ์ถ๋ก ์ ์ด์์ ์ ๋๋ค.
- ๋ฒกํฐ ์ฐ์ฐ์ ๋ณ๋ ฌํ
๋ฅ๋ฌ๋์ ๋ง์ ๊ณ์ฐ์ ๋ฒกํฐ(์ซ์์ ์ผ๋ ฌ ๋ฐฐ์ด)๋ก ์ํ๋ฉ๋๋ค. GPU๋ ๋ฒกํฐ์ ๊ฐ ์์๋ฅผ ๊ฐ๋ณ ์ฝ์ด์ ํ ๋นํ์ฌ ๋ณ๋ ฌ ์ฐ์ฐ์ ์ํํฉ๋๋ค.
-
์์:
๋ฒกํฐย A=[1,2,3]\text{๋ฒกํฐ A} = [1, 2, 3]๋ฒกํฐย A=[1,2,3], ๋ฒกํฐย B=[4,5,6]\text{๋ฒกํฐ B} = [4, 5, 6]๋ฒกํฐย B=[4,5,6]์ผ ๋, A+B=[5,7,9]\text{A} + \text{B} = [5, 7, 9]A+B=[5,7,9].
์ด ๊ณ์ฐ์์ GPU๋ ๊ฐ ์ฝ์ด๊ฐ A์ B์ ํ ์์๋ฅผ ๋์์ ์ฒ๋ฆฌํฉ๋๋ค.
- ํ๋ ฌ ๊ณฑ์ ์ ๋ณ๋ ฌํ
๋ฅ๋ฌ๋ ๋ชจ๋ธ์ ํต์ฌ ์ฐ์ฐ์ธ ํ๋ ฌ ๊ณฑ์ ๋ GPU์ ๋ณ๋ ฌ ์ฒ๋ฆฌ ๋๋ถ์ ํจ์จ์ ์ผ๋ก ์ํ๋ฉ๋๋ค.
-
์์:
๋ ํ๋ ฌ AAA์ BBB๋ฅผ ๊ณฑํ์ฌ ํ๋ ฌ CCC๋ฅผ ๊ณ์ฐํ๋ค๊ณ ๊ฐ์ ํฉ์๋ค. GPU๋ ํ๋ ฌ CCC์ ๊ฐ ์์๋ฅผ ๋ณ๋ ฌ๋ก ๊ณ์ฐํฉ๋๋ค.
ํ๋ ฌ ๊ณฑ์ ๊ณต์:
C[i][j]=โkA[i][k]รB[k][j]C[i][j] = \sum_k A[i][k] \times B[k][j]C[i][j]=โkโA[i][k]รB[k][j]
๊ฐ C[i][j]C[i][j]C[i][j] ๊ฐ์ ๋ ๋ฆฝ์ ์ผ๋ก ๊ณ์ฐ ๊ฐ๋ฅํ๋ฏ๋ก, GPU์ ์ฝ์ด๊ฐ ๊ฐ ๊ณ์ฐ์ ๋ณ๋ ฌ๋ก ์ํํฉ๋๋ค.
-
๋ฅ๋ฌ๋์์์ ์์ฉ
- ๋ด๋ฐ ๊ฐ์ ๊ฐ์ค์น ๊ณ์ฐ
- ๋ฐ์ดํฐ์ ์ ๋ฐฉ ์ ํ(Forward Propagation)
- ์ญ์ ํ(Back Propagation) ๋ฐ ๊ทธ๋๋์ธํธ ๊ณ์ฐ
GPU ์ํคํ ์ฒ์ ์ ์ฐ์ฑ: SIMD์์ SIMT๋ก
์ ํต์ ์ธ GPU๋ SIMD(Single Instruction Multiple Data) ๊ตฌ์กฐ๋ฅผ ์ฌ์ฉํ์ผ๋, ์ต์ GPU๋ ๋ ์ ์ฐํ SIMT(Single Instruction Multiple Threads) ๊ตฌ์กฐ๋ก ๋ฐ์ ํ์ต๋๋ค.
-
SIMD vs SIMT
- SIMD(Single Instruction Multiple Data): ํ๋์ ๋ช
๋ น์ด๋ฅผ ์ฌ๋ฌ ๋ฐ์ดํฐ์ ๋์์ ์ ์ฉ.
- ๋ชจ๋ ์ค๋ ๋๊ฐ ๋์ผํ ์๋๋ก ์งํํด์ผ ํจ.
- SIMT(Single Instruction Multiple Threads): ์ค๋ ๋ ๊ฐ ๋๊ธฐํ ์์ด ๋
๋ฆฝ์ ์ผ๋ก ๋ช
๋ น์ด๋ฅผ ์คํํ ์ ์์.
- ์กฐ๊ฑด๋ฌธ ๋ฑ์ผ๋ก ์ธํ ๋ถ๊ธฐ(branch)๋ฅผ ์ฒ๋ฆฌํ๊ธฐ์ ์ ํฉ.
- SIMD(Single Instruction Multiple Data): ํ๋์ ๋ช
๋ น์ด๋ฅผ ์ฌ๋ฌ ๋ฐ์ดํฐ์ ๋์์ ์ ์ฉ.
-
SIMT์ ์ฅ์
- ์ฝ๋ ์ ์ฐ์ฑ ์ฆ๊ฐ: ์กฐ๊ฑด๋ฌธ ์ฒ๋ฆฌ๊ฐ ๊ฐ๋ฅ.
- ๊ณ์ฐ ํจ์จ์ฑ ํฅ์: ๋ณ๋ ฌ ์ฐ์ฐ ์ฑ๋ฅ ๊ทน๋ํ.
๊ฒฐ๋ก
GPU๋ ๋ณ๋ ฌ ์ฐ์ฐ์ ํนํ๋ ๊ตฌ์กฐ์ ์๋ง์ ์ฝ์ด๋ฅผ ํตํด CPU๋ณด๋ค ๋๊ท๋ชจ ์ฐ์ฐ์์ ํจ์ฌ ๋ฐ์ด๋ ์ฑ๋ฅ์ ๋ฐํํฉ๋๋ค. ๋ฅ๋ฌ๋, ๊ทธ๋ํฝ ๋ ๋๋ง, ์ํธํํ ์ฑ๊ตด ๋ฑ ๋ค์ํ ์์ฉ ๋ถ์ผ์์ GPU๋ ์์ด์๋ ์ ๋ ์กด์ฌ์ ๋๋ค.
GPU์ ๋ด๋ถ ๊ตฌ์กฐ์ ์๋ ๋ฐฉ์์ ์ดํดํ๋ฉด ๋ฅ๋ฌ๋ ๋ชจ๋ธ์ ์ต์ ํํ๊ฑฐ๋ ํ๋์จ์ด๋ฅผ ์ ํํ๋ ๋ฐ ํฐ ๋์์ ๋ฐ์ ์ ์์ต๋๋ค.
์ด์์ผ๋ก ์ค๋ ํฌ์คํ ๋ง์น๋๋ก ํ๊ฒ ์ต๋๋ค ^~^
๊ธด ๊ธ ์ฝ์ด์ฃผ์ ์ ๊ฐ์ฌํฉ๋๋ค!