๋ฐ์ดํธ โ KB/MB/GB ๋ณํ๊ธฐ๋?
์ด ๊ณ์ฐ๊ธฐ๋ ๋ฐ์ดํธ(byte) ๋จ์ ์ซ์๋ฅผ ํฌ๋ก๋ฐ์ดํธ(KB), ๋ฉ๊ฐ๋ฐ์ดํธ(MB), ๊ธฐ๊ฐ๋ฐ์ดํธ(GB)๋ก ํ ๋ฒ์ ๋ณํํด ์ค๋๋ค. ๋๋ถ๋ถ์ ์ด์์ฒด์ ๊ฐ ์ฌ์ฉํ๋ ์ด์ง ๊ธฐ์ค(1024)๊ณผ ์ ์ฅ์ฅ์น ์ ์กฐ์ฌ๊ฐ ์ฌ์ฉํ๋ ์ญ์ง ๊ธฐ์ค(1000)์ ๋ชจ๋ ์ง์ํ๋ฏ๋ก, ์ํฉ์ ๋ง๋ ์ ํํ ๊ฐ์ ๋ฐ๋ก ํ์ธํ ์ ์์ต๋๋ค.
์ฌ์ฉ ๋ฐฉ๋ฒ
๋ณํํ ์ฉ๋์ ๋ฐ์ดํธ๋ก ์ ๋ ฅํ๊ณ ๊ธฐ์ค์ ์ ํํ ๋ค ๋ณํ ๊ฒฐ๊ณผ๋ฅผ ํ์ธํ์ธ์. Windows, macOS, Linux๊ฐ ํ์ํ๋ ํ์ผ ํฌ๊ธฐ์ ๋ง์ถ๋ ค๋ฉด 1024(์ด์ง, KiB/MiB/GiB)๋ฅผ ์ ํํ๊ณ , ํ๋๋์คํฌ๋ USB ๋ฉ๋ชจ๋ฆฌ์ ์ ํ ์ฉ๋๊ณผ ๋ง์ถ๋ ค๋ฉด 1000(์ญ์ง)์ ์ ํํ๋ฉด ๋ฉ๋๋ค.
๋ณํ ๊ณต์ ์ดํดํ๊ธฐ
๋จ์๊ฐ ํ ๋จ๊ณ ์ฌ๋ผ๊ฐ ๋๋ง๋ค ๊ธฐ์ค๊ฐ์ผ๋ก ๋๋๋๋ค. ์ด์ง ๊ธฐ์ค์์๋ 1ํฌ๋ก๋ฐ์ดํธ๊ฐ 1024๋ฐ์ดํธ, 1๋ฉ๊ฐ๋ฐ์ดํธ๊ฐ \(1024 \times 1024 = 1{,}048{,}576\)๋ฐ์ดํธ, 1๊ธฐ๊ฐ๋ฐ์ดํธ๊ฐ \(1024^{3} = 1{,}073{,}741{,}824\)๋ฐ์ดํธ์ ๋๋ค. ํต์ฌ ๊ณต์์ ๋ค์๊ณผ ๊ฐ์ต๋๋ค.
$$\text{KB} = \frac{B}{b}, \quad \text{MB} = \frac{B}{b^{2}}, \quad \text{GB} = \frac{B}{b^{3}}$$ $$\text{where}\quad \left\{ \begin{aligned} B &= \text{Bytes} \\ b &= \text{Base} \end{aligned} \right.$$
MB = ๋ฐ์ดํธ รท 1,048,576. ๋ค๋ฅธ ๋จ์๋ ๋๋๋ ๊ฐ์ 1024(KB) ๋๋ 1,073,741,824(GB)๋ก ๋ฐ๊พธ๋ฉด ๋ฉ๋๋ค.
๊ณ์ฐ ์์
์ด์ง ๊ธฐ์ค์ผ๋ก 5,242,880๋ฐ์ดํธ์ง๋ฆฌ ํ์ผ์ด ์๋ค๊ณ ๊ฐ์ ํด ๋ด ์๋ค. ๋ฉ๊ฐ๋ฐ์ดํธ $$= \frac{5{,}242{,}880}{1{,}048{,}576} = 5\ \text{MB}$$์ ๋๋ค. ํฌ๋ก๋ฐ์ดํธ $$= \frac{5{,}242{,}880}{1024} = 5{,}120\ \text{KB}$$์ ๋๋ค. ์ฆ ์ด ํ์ผ์ ์ ํํ 5 MB, ๋๋ 5,120 KB์ ๋๋ค.
๋ฐ์ดํฐ ํฌ๊ธฐ ๋ณํ ํ
๋ฐ์ดํฐ ํฌ๊ธฐ๋ ๋ ๊ฐ์ง ๋ฐฉ์์ผ๋ก ์ ์๋ฉ๋๋ค. ์ญ์ง๋ฒ(SI) ์์คํ ์ 1000์ ๊ฑฐ๋ญ์ ๊ณฑ์ ์ฌ์ฉํ๋ฉฐ ์ ์ฅ์ ์ ์กฐ์ ์ฒด ๋ฐ ๋คํธ์ํน์์ ํ์ค์ ๋๋ค. ์ด์ง๋ฒ(IEC) ์์คํ ์ 1024์ ๊ฑฐ๋ญ์ ๊ณฑ์ ์ฌ์ฉํ๋ฉฐ ๋๋ถ๋ถ์ ์ด์ ์ฒด์ ๊ฐ ํ์ผ ๋ฐ ๋์คํฌ ํฌ๊ธฐ๋ฅผ ๋ณด๊ณ ํ ๋ ์ฌ์ฉํ๋ ๋ฐฉ์์ ๋๋ค. ์๋ ํ๋ ๋ ์์คํ ๋ชจ๋์์ ๊ฐ ๋จ์์ ์ ํํ ๋ฐ์ดํธ ์๋ฅผ ๋ณด์ฌ์ค๋๋ค.
| ๋จ์ | ์์คํ / ๊ธฐ์ | ๋ฐ์ดํธ ๋จ์์ ์ ํํ ๊ฐ | ๊ฑฐ๋ญ์ ๊ณฑ |
|---|---|---|---|
| 1 ๋ฐ์ดํธ(B) | โ | 1 | \(b^0\) |
| 1 ํฌ๋ก๋ฐ์ดํธ(KB) | ์ญ์ง๋ฒ(1000) | 1,000 | \(1000^1\) |
| 1 ํค๋น๋ฐ์ดํธ(KiB) | ์ด์ง๋ฒ(1024) | 1,024 | \(1024^1\) |
| 1 ๋ฉ๊ฐ๋ฐ์ดํธ(MB) | ์ญ์ง๋ฒ(1000) | 1,000,000 | \(1000^2\) |
| 1 ๋ฉ๋น๋ฐ์ดํธ(MiB) | ์ด์ง๋ฒ(1024) | 1,048,576 | \(1024^2\) |
| 1 ๊ธฐ๊ฐ๋ฐ์ดํธ(GB) | ์ญ์ง๋ฒ(1000) | 1,000,000,000 | \(1000^3\) |
| 1 ๊ธฐ๋น๋ฐ์ดํธ(GiB) | ์ด์ง๋ฒ(1024) | 1,073,741,824 | \(1024^3\) |
| 1 ํ ๋ผ๋ฐ์ดํธ(TB) | ์ญ์ง๋ฒ(1000) | 1,000,000,000,000 | \(1000^4\) |
| 1 ํ ๋น๋ฐ์ดํธ(TiB) | ์ด์ง๋ฒ(1024) | 1,099,511,627,776 | \(1024^4\) |
์๋ฅผ ๋ค์ด, 500,000,000๋ฐ์ดํธ ํ์ผ์ ์ญ์ง๋ฒ ์์คํ ์์๋ ์ ํํ 500MB์ด์ง๋ง, ์ด์ง๋ฒ ์์คํ ์์๋ ์ฝ 476.837MiB์ ๋๋ค. ์ด๊ฒ์ด "500MB"๋ผ๊ณ ํ์๋ ๋๋ผ์ด๋ธ๊ฐ ์ผ๋ถ ์ด์ ์ฒด์ ์์๋ ์ฝ 477MB๋ก ํ์๋๋ ์ด์ ์ ๋๋ค.
์ฃผ์ ์ฉ์ด ์ค๋ช
- ๋ฐ์ดํธ(B)
- ๋์งํธ ๋ฐ์ดํฐ ์ ์ฅ์ ๊ธฐ๋ณธ ๋จ์๋ก, 8๋นํธ์ ๊ฐ์ต๋๋ค. ๋จ์ผ ๋ฐ์ดํธ๋ ASCII์ ๊ฐ์ ๊ธฐ๋ณธ ์ธ์ฝ๋ฉ์์ ํ ์คํธ์ ํ ๋ฌธ์๋ฅผ ๋ํ๋ผ ์ ์์ต๋๋ค.
- ํฌ๋ก๋ฐ์ดํธ(KB)
- SI(์ญ์ง๋ฒ) ํ์ค์ ๋ฐ๋ฅด๋ฉด, 1KB = 1,000๋ฐ์ดํธ(\(1000^1\))์ ๋๋ค. "ํฌ๋ก"๋ผ๋ ์ ๋์ฌ๋ ์ฒ์ ์๋ฏธํฉ๋๋ค. ์ ์ฅ์ ๋ฐ ๋คํธ์ํน ๊ณต๊ธ์ ์ฒด์์ ์ผ๋ฐ์ ์ผ๋ก ์ฌ์ฉ๋ฉ๋๋ค.
- ํค๋น๋ฐ์ดํธ(KiB)
- IEC ์ด์ง๋ฒ ํ์ค์ ๋ฐ๋ฅด๋ฉด, 1KiB = 1,024๋ฐ์ดํธ(\(2^{10}\))์ ๋๋ค. "ํค๋น"๋ "ํฌ๋ก ์ด์ง๋ฒ"์ ์ฝ์์ ๋๋ค. ์ด ๋จ์๋ "KB"๋ฅผ 1,024๋ฐ์ดํธ๋ฅผ ์๋ฏธํ๋ ๊ฒ์ผ๋ก ์ฌ์ฉํ๋ ๋ชจํธํจ์ ์ ๊ฑฐํฉ๋๋ค.
- ๋ฉ๊ฐ๋ฐ์ดํธ(MB)
- ์ญ์ง๋ฒ: 1MB = 1,000,000๋ฐ์ดํธ(\(1000^2\)). ๋ง์ ์ ํ๋ฆฌ์ผ์ด์ ๊ณผ ๋์คํฌ ์ ์กฐ์ ์ฒด์์ ํ์ผ ํฌ๊ธฐ์ ์ฌ์ฉ๋ฉ๋๋ค.
- ๋ฉ๋น๋ฐ์ดํธ(MiB)
- ์ด์ง๋ฒ: 1MiB = 1,048,576๋ฐ์ดํธ(\(2^{20}\)). ๋๋ถ๋ถ์ ์ด์ ์ฒด์ ๊ฐ RAM ๋ฐ ํ์ผ ํฌ๊ธฐ์ ๋ํด "MB"๋ฅผ ํ์ํ ๋ ์๋ฏธํ๋ ๊ฐ์ ๋๋ค.
- ๊ธฐ๊ฐ๋ฐ์ดํธ(GB)
- ์ญ์ง๋ฒ: 1GB = 1,000,000,000๋ฐ์ดํธ(\(1000^3\)). ํ๋ ๋๋ผ์ด๋ธ ๋ฐ SSD์ ์ธ์๋ ์์น์ ๋๋ค.
- ๊ธฐ๋น๋ฐ์ดํธ(GiB)
- ์ด์ง๋ฒ: 1GiB = 1,073,741,824๋ฐ์ดํธ(\(2^{30}\)). "1TB" ๋๋ผ์ด๋ธ๊ฐ ํ์ผ ๊ด๋ฆฌ์์์ ์ฝ 931GiB๋ก ํ์๋๋ ์ด์ ์ ๋๋ค.
- ์ด์ง๋ฒ ๊ธฐ์(1024)
- 2์ ๊ฑฐ๋ญ์ ๊ณฑ์ ๊ธฐ๋ฐ์ผ๋ก ํ๋ ๊ณ์ฐ ์ฒด๊ณ๋ก, ๊ฐ ๋จ๊ณ์์ 1,024๋ฅผ ๊ณฑํฉ๋๋ค. bi-, kibi-, mebi-, gibi-, tebi- ์ ๋์ฌ(KiB, MiB, GiB, TiB)๋ก IEC์ ์ํด ํ์ํ๋์์ต๋๋ค.
- ์ญ์ง๋ฒ ๊ธฐ์(1000)
- 10์ ๊ฑฐ๋ญ์ ๊ณฑ์ ๊ธฐ๋ฐ์ผ๋ก ํ๋ ๊ณ์ฐ ์ฒด๊ณ๋ก, ๊ฐ ๋จ๊ณ์์ 1,000์ ๊ณฑํฉ๋๋ค. ์ด๋ SI ๋ฏธํฐ๋ฒ ์ ๋์ฌ kilo-, mega-, giga-, tera-(KB, MB, GB, TB)์ ์ผ์นํฉ๋๋ค.
IEC 80000-13 ํ์ค์ ๋ ์์คํ ๊ฐ์ ์ค๋ซ๋์ ๊ณ์๋ ํผ๋์ ํด๊ฒฐํ๊ธฐ ์ํด ํน๋ณํ ์ด์ง๋ฒ ์ ๋์ฌ(KiB, MiB ๋ฑ)๋ฅผ ๋์ ํ์ต๋๋ค. ์ค์ ๋ก ์ ์ฅ์ ์ ์กฐ์ ์ฒด ๋ฐ ๋คํธ์ํฌ ์๋๋ ์ญ์ง๋ฒ ๋จ์๋ฅผ ์ฌ์ฉํ์ง๋ง, RAM ๋ฐ ๋ง์ ์ด์ ์ฒด์ ๋ ์ฉ๋์ ์ด์ง๋ฒ ๋จ์๋ก ๋ณด๊ณ ํฉ๋๋ค.
์์ฃผ ๋ฌป๋ ์ง๋ฌธ
์ ๋ด ์ ์ฅ์ฅ์น ์ฉ๋์ด ๊ด๊ณ ๋ณด๋ค ์ ๊ฒ ํ์๋๋์? ์ ์กฐ์ฌ๋ ์ญ์ง(1 GB = 1,000,000,000๋ฐ์ดํธ)์ผ๋ก ๊ณ์ฐํ๋ ๋ฐ๋ฉด, ์ด์์ฒด์ ๋ ์ด์ง(1 GB = 1,073,741,824๋ฐ์ดํธ)์ผ๋ก ๊ณ์ฐํฉ๋๋ค. ๊ทธ๋์ ๊ฐ์ ๋๋ผ์ด๋ธ๋ผ๋ ํ๋ฉด์์๋ ๋ ์๊ฒ ๋ณด์ ๋๋ค.
MB์ MiB์ ์ฐจ์ด๋ ๋ฌด์์ธ๊ฐ์? ๋ฉ๋น๋ฐ์ดํธ(MiB)๋ ์ ํํ 1,048,576๋ฐ์ดํธ(์ด์ง)์ ๋๋ค. ๋ฉ๊ฐ๋ฐ์ดํธ(MB)๋ ๊ธฐ์ ์ ์ผ๋ก 1,000,000๋ฐ์ดํธ(์ญ์ง)์ด์ง๋ง, ์ค์ ๋ก๋ "MB"๊ฐ MiB์ ์๋ฏธ๋ก ๋๋ฃจ๋ญ์ ํ๊ฒ ์ฐ์ด๋ ๊ฒฝ์ฐ๊ฐ ๋ง์ต๋๋ค.
์ด๋ค ๊ธฐ์ค์ ์ ํํด์ผ ํ๋์? ํ์ผ ํฌ๊ธฐ์ ๋ฉ๋ชจ๋ฆฌ(RAM)์๋ 1024๋ฅผ, ์ ์ฅ์ฅ์น ์ฉ๋๊ณผ ๋ฐ์ดํฐ ์ ์ก ์๋์๋ 1000์ ์ฌ์ฉํ์ธ์.