๐ Bit Byte Word
2020-10-12 03:33:00
๋ค์ด๋ฒ ๋ธ๋ก๊ทธ ์ธ ๋น์ 32-Bit, 64-Bit ๊ด๋ จ ๊ธ์ ๊ณต์ ๋ชฉ์ ์ผ๋ก ์คํฌ๋ฉ ํ๋ ๊ธ ๊ณ์น
๐ซ ์ 2์ง์?
๐ซง Digit, Decimal - ์ญ์ง๋ฒ
๊ณ ๋ ๋ผํด์ด๋ก Digita๋ โ์๊ฐ๋ฝโ์ ๋ปํ๊ณ ,
์ฌ๋ฌ ์ธ์ด์์ Digit์ โ์๊ฐ๋ฝโ๊ณผ โ๋ฐ๊ฐ๋ฝโ์ ๋ปํ๋ค.
์๊ฐ๋ฝ๊ณผ ๋ฐ๊ฐ๋ฝ์ ์ 10๊ฐ = 10
๊ทธ๋ฆฌ์ค์ด๋ก Deci, Deca๋ 10์ ๋ปํ๋ ์ ๋์ด๋ค.
Decimal์ โ์ญ์ง๋ฒ์โ, โ์์์โ ๋ผ๋ ๋ป์ ๊ฐ์ง๋ค.
๐ซง ์ 2์ง์?
10์ง์๋ ์ ์์ ๊ตฌํ์ ํ๊ณ๊ฐ ์์๋ค.
- ์ ์ฅ/์ ์ก์ ์ด๋ ค์
- ์ต์ด์ ์ปดํจํฐ ENIAC์ 10์ง์๋ฅผ ์ผ๋๋ฐ, ํ ๋จ์์ ์ ๋ณด๋ฅผ ํํํ๊ธฐ ์ํด 10๊ฐ์ ๋ฐฐ๊ด์ด ํ์ํ๋ค. (0 ~ 9)
- ๋์งํธ ๋
ผ๋ฆฌ ํจ์ ๊ตฌํ์ ์ด๋ ค์
- Addition, Multipplication, โฆ
์ต์ด์ ์ปดํจํฐ ENIAC์ 10์ง์๋ฅผ ์ฌ์ฉํ์ง๋ง, ํฐ ๋ ธ์ด๋ง์ ์ํด 2์ง์๊ฐ ๊ณ ์๋๋ค.
- ์ ์ฅ/์ ์ก์ ๊ฐํธํ
- 2์ง์๋ฅผ ์ด์ฉํ๋ฉด, ํ ๋จ์์ ์ ๋ณด๋ฅผ ํํํ๊ธฐ ์ํด 1๊ฐ์ ๋ฐฐ๊ด๋ง ์์ผ๋ฉด ๋๋ค. (0๊ณผ 1, ๋ฐฐ๊ด์ด ๋ผ์์ ธ์๋ ๋ง๋๋)
- ์ก์๊ณผ ๋ถ์ ํํ ์์ด์ด์๋ ๋ฌธ์ ์์ด ์์ ์ ์ผ๋ก ์ ์ก์ด ๊ฐ๋ฅํ๋ค.
- ๊ฐ๋จํ ๊ตฌํ
- ๊ฐ๋จํ ์ฐ์ ํจ์
- ์ฌ๋ฌ ๋ฐฉ์์ผ๋ก ์ธ์ฝ๋ฉ/๋ฒ์ญ ๊ฐ๋ฅ
๐ซ Byte = 8 Bit ?
Byte๋ ์ค์ํ๋ค.
Byte๋ CPU๊ฐ ํ๋ฒ์ ์ฒ๋ฆฌํ๋ ๋ฐ์ดํฐ ํฌ๊ธฐ = Word(TDU)์ ๊ธฐ์ค์ด ๋๊ณ ,
์ด๋ ์ปดํจํฐ๊ฐ ๋ฐ์ดํฐ๋ฅผ ๋ค๋ฃจ๋ ๊ธฐ๋ณธ ๋จ์, ๋ฉ๋ชจ๋ฆฌ ์ฃผ์์ ํฌ๊ธฐ์ ๊ธฐ์ค์ด ๋๋ค.
Byte์ ํฌ๊ธฐ ์ญ์ ์ค์ํ๋ค.
ํ๋ ์ปดํจํฐ ์ํคํ
์ณ์์, Byte = 8 Bit ๊ฐ ํ์ค.
๋ณธ๋ Byte๋ ์ปดํจํฐ์์ ๋ฌธ์ Character ํ๋๋ฅผ ํํํ๊ธฐ ์ํ Bit ์์๋๋ฐ,
์ด๊ฐ ํ์ฅ๋์ด, โ๋์งํธ ์ ๋ณด์ ๊ฐ์ฅ ์์ ๋จ์โ๊ฐ ๋์๋ค.
๊ณผ๊ฑฐ Byte์ ํฌ๊ธฐ๋ HW์ ์ข ์๋์๊ณ , ๋ช ํํ ํ์ค์ด ์์ด, ๊ณณ์ ๋ฐ๋ผ 1 ~ 48 Bit ๋ฑ์ ๋ค์ํ ํฌ๊ธฐ๋ก ์ฌ์ฉ๋์๋ค๊ณ ํ๋ค.
๊ทธ ์ค์์๋, 6-Bit๋ฅผ ์ฌ์ฉํ๋ ๋ฌธ์ ํํ ๋ฐฉ์์ด ์ฃผ๋ก ์ฌ์ฉ๋์๊ณ , 1960๋
๋์๋ 6-Bit, 9-Bit ๋ฅผ ์ฌ์ฉํ๋ ์ปดํจํฐ๊ฐ ์ผ๋ฐ์ ์ด์๋ค๊ณ ํจ.
์ด๋ฐ ์ปดํจํฐ๋ค์ 2, 3, 4, 5, 6, 8, 10 6-Bit Byte์ ์์ํ๋, 12, 18, 24, 30, 36, 48, 60 Bit์ Memory Word๋ฅผ ์ฃผ๋ก ์ฌ์ฉํ์.
์ด ์๋์ ์ด๋ฐ Bit Groupings๋ฅผ Syllables, Slab ๋ฑ์ผ๋ก ๋ถ๋ ์. (Byte๊ฐ ์ผ๋ฐํ๋๊ธฐ ์ ๊น์ง)
ASCII Code๋ 7-Bit๋ง์ผ๋ก๋ ํ์๋ก ํ๋ ๋ฌธ์๋ฅผ ๋ชจ๋ ํํ ํ ์ ์์๋๋ฐ,
2-์ง์ Binary๋ฅผ ์ฌ์ฉํ๋ ์ปดํจํฐ ์ํคํ
์ณ ํน์ฑ์, ํธ๋ฆฌํ๊ฒ 2-๋ฐฐ์๋ก ๋ง๋ค๊ธฐ ์ํด,
7-Bit์ 1-Bit๋ฅผ ๋ํ์ฌ 8-Bit๋ก ๋ง๋ค์ด ์ฌ์ฉ
IBM์ System/360 ์ปดํจํฐ๊ฐ ์ด๋ฐ 8-Bit Byte์ ์์ด.
ISO/IEC 2382-1:1933 ์ ๋ฌธ์ํ ๋์์ผ๋ฉฐ,
8-Bit Byte ๋ง์ดํฌ๋กํ๋ก์ธ์๊ฐ ๋์ธํ 70๋
๋๋ถํฐ ํ์ค์ผ๋ก ๊ตณ์ด์ง๊ธฐ ์์ํจ (์ฌ์ค์ ํ์ค De Facto Standard)
์ด๋ฐ 8-Biy Byte์ ๊ธฐ๋ฐํ์ฌ 8์ ๋ฐฐ์์ธ, 8-Bit, 16-Bit, 32-Bit, 64-Bit Words๋ฅผ ์ฌ์ฉํ๊ฒ ๋จ.
ISO International Organization for Standardization
IEC International Electrotechnical Organization
๐ซ 32-Bit, 64-Bit ?
Program Counter
32-Bit = 2^32 = 4,294,967,296
64-Bit = 2^64 = 18,446,744,073,709,551,616
32-Bit = ์ฝ 4-GB ๋ฉ๋ชจ๋ฆฌ
64-Bit = ์ฝ 256-TB ๋ฉ๋ชจ๋ฆฌ (48-Bit๋ง ์ฌ์ฉ)
์ 48-Bit๋ง ์ฌ์ฉํ๋๋ฉด, โ์ผ๋ฐ์ ์ผ๋กโ, 256-TB ์ด์์ ์ฃผ์ ๊ณต๊ฐ์ ์ฌ์ฉํ์ง ์๊ธฐ ๋๋ฌธ์ด๋ค.
์ด์์ฒด์ ๋ 32-Bit, 64-Bit ๋ก ๋๋๋ค.
32-Bit CPU ์๋ 64-Bit ์ด์์ฒด์ ๊ฐ ๋์ํ์ง ์๋๋ค.
64-Bit CPU ์๋ 32-Bit ์ด์์ฒด์ ๊ฐ ๋์ํ๊ธฐ๋ ํ์ง๋ง, ํ์ ํธํ Backward Compatibility ๋๋ค.
์ฑ ์ญ์ 32-Bit, 64-Bit ๋ก ๋๋๋ค.
32-Bit ์ด์์ฒด์ ์๋ 64-Bit ์ฑ (Programs File)์ด ๋์ํ์ง ์๋๋ค.
64-Bit ์ด์์ฒด์ ์๋ 32-Bit ์ฑ (Programs File (x86))์ด ๋์ํ๊ธฐ๋ ํ์ง๋ง, ํ์ ํธํ Backward Compatibility ๋๋ค.
๐ซ x86, x64 (x86-64) ?
x85 = 8-bit
x86 = 32-Bit (์ผ๋ฐ์ ์ผ๋ก)
x64 = 64-Bit (x86-64)
x86 (80x86) =
1978๋
์ธํ
์ด ๊ฐ๋ฐํ ์ธํ
8086์ ์ ์ฉ๋ ์ํคํ
์ณ,
๊ทธ ํธํ ํ๋ก์ธ์์ ํ์์ (8086์ ๋ช
๋ น์ด ์ธํธ๋ฅผ ๊ธฐ๋ฐํ์ฌ ํ์ฅํ, 386, 486, โฆ )
IA-16, IA-32, IA-64 ๋ฅผ ๋ชจ๋ ํฌํจํ๋ ๋จ์ด์ด์ง๋ง,
์ผ๋ฐ์ ์ผ๋ก x86์ด๋ผ ํ๋ฉด IA-32์ ์ง์นญ
IA = Intel Architecture
๐ซ ์๋ WORD ?
๊ธฐ๊ณ์ด ๋ช
๋ น์ด๋ ์ฐ์ฐ์ ํตํด ์ ์ฅ๋ ์ฅ์น๋ก๋ถํฐ ๋ ์ง์คํฐ์ ์ฎ๊ฒจ ๋์ ์ ์๋ ๋ฐ์ดํฐ ๋จ์
= CPU๊ฐ ์ฒ๋ฆฌํ ์ ์๋, ๋ฒ์ค์ ํ ๋ฒ์ ์ง๋๊ฐ ์ ์๋ ํฌ๊ธฐ์ ๋จ์
= DTU Data Transport Unit (DTU๋ฅผ ์ฌ์ฉํ๋ ์ฉ์ด๊ฐ ๋ง์๊ธฐ์ WORD๋ฅผ ์ฌ์ฉํ๊ธฐ ์์)
์ปดํจํฐ ์ํคํ
์ณ์์,
32-Bit = WORD : 32-Bit
64-Bit = WORD : 64-Bit
๋ฐ๋จ ํ๋ก๊ทธ๋๋ฐ์์,
Win32 API์ WORD๋ 16-Bit๋ค.
์ Why
IA = Intel Architecture
IA-16์ ๊ธฐ๋ณธ ์ฒ๋ฆฌ ๋จ์ DTU = WORD = 16-Bit
์ถํ 32-Bit, 64-Bit ๋ฑ์ ํ๋ก์ธ์ (IA-32, IA-64 ๋ฑ) ๋ฑ์ฅ
ํธํ์ฑ์ ๋ฌธ์ ์ผ๋ก ์ธํด, ๊ธฐ์กด ๋จ์ ํฌ๊ธฐ๋ฅผ ๋ฐ๊ฟ ์๋ ์๊ณ ,
๋๋ฌธ์ ๊ธฐ์กด 16-Bit Word๋ฅผ ๊ธฐ๋ฐ์ผ๋ก ํ ์๋ก์ด ๋จ์๋ฅผ ๋ง๋ค์ด ์ผ๋ค.
DWORD = Double Word = 32-Bit
QWORD = Quad/Quotable Word = 64-Bit
๐ซ ์ปดํจํฐ์์์ 1K = 1024 ?
I.E. 1 KB = 1024 Byte
์ Why
k, Kilo, 10^3, SI ์ ๋์ด
1 KM, 1 KG ๋ฑ ์ฌ๋ฌ ๋จ์์ ์ฐ์ด๋ ํฌ๋ก
์ปดํจํฐ์์๋ ํฐ ๋จ์๋ฅผ ๋ค๋ฃฐ ๋ ํฌ๋ก๋ฅผ ์ฌ์ฉํ๋๋ฐ,
2์ง์๋ฅผ ์ฌ์ฉํ๋ ์ปดํจํฐ ์์คํ
์์ 1000์ ๋ค๋ฃจ๊ธฐ ๋ณต์กํ ์ซ์
1000 = b1111101000
๋๋ฌธ์ 2์ง์ ์ปดํจํฐ ์์คํ
์์ ๋ค๋ฃจ๊ธฐ ์ฝ๋๋ก 2์ ๋ฐฐ์์ด๋ฉด์,
๊ฐ์ฅ ์๋ 1K = 1000 ์ ๊ฐ๊น์ด, 2^10 = 1024๋ฅผ ์ปดํจํฐ ์์คํ
์์์ 1K๋ก ์ฌ์ฉ
1024 = b10000000000
๊ธฐ์ต์ฅ์น๋ฅผ ํ ๋์๋,
๊ธฐ์กด 1K = 1000 ๋จ์๋ก ๊ด๊ณ ํ์ฌ ํ๊ธฐ ๋๋ฌธ์,
500GB ๋ถํ์ ์ฌ๋ ์ปดํจํฐ๋ 466GB๋ก ์ธ์
์ธํฐ๋ท ์๋๋ ๋น์ทํ ์ด์ ๋ก,
MB๊ฐ ์๋ Mb๋ก ํ๊ธฐ ๋๋ฌธ์,
100Mb ์๋น์ค๋ฅผ ์ฌ๋ 12.5MB๋ก ์ธ์
๐ซ @์ฌ์น
CPU๋ฅผ ์ง์ ์ ์ดํ๋ ์ด์ ๋ธ๋ฆฌ ํ๋ก๊ทธ๋๋ฐ์ ๊ฒฝ์ฐ ํ๋ก๊ทธ๋๋จธ๊ฐ ์ฌ๋ฌ ๊ฐ์ ๋ ์ง์คํฐ๋ฅผ ์ฌ์ฉํด์ ๋ ํฐ ์ซ์๋ฅผ ์ฌ์ฉํ ์ ์๋๋ก ์งค ์ ์๋ค. ๊ณ ๊ธ ์ธ์ด์ ๊ฒฝ์ฐ๋ ์ปดํ์ผ๋ฌ๊ฐ ์ด๋ฌํ ์ฝ๋๋ฅผ ์์ฑํด์ค๋ค. ๋น์ฐํ ์ฝ๋๊ฐ ๋๋ฆฌ๊ณ ๋ณต์กํด์ง๋ค.
โ์ ๋ฒ์ค์ ์ด 32๊ฐ๋ฉด 32๋นํธ CPU๊ฒ ๊ตฐ!โ
์์ฃผ ํ๋ฆฐ ์๋ฆฐ ์๋์ง๋ง ๋ ์ ๋ต์ ์๋๋ค.
์ธํ
ํํฐ์์ ๊ฒฝ์ฐ 32๋นํธ CPU์ง๋ง ์ธ๋ถ ๋ฐ์ดํฐ ๋ฒ์ค๋ 64๋นํธ๋ค. ๊ณผ๊ฑฐ ์ธํ
8086 CPU๋ํ 16๋นํธ CPU์์ง๋ง ์ธ๋ถ ๋ฐ์ดํฐ๋ฒ์ค๋ 8๋นํธ์ง๋ฆฌ์๋ค.
- N-Bit CPU
- N-Bit = CPU ๋ด๋ถ์์ ์ฒ๋ฆฌํ๋ ๋จ์
- = ์ฐ์ฐ, (์ ์ด = ๋ฉ๋ชจ๋ฆฌ๋ฅผ ์ต์ธ์ค = ์ฃผ์ = ์ด๋๋ ์ค ๋ฒ์ค)
HEX
32๋นํธ CPU๋ผ๋ฉด ๊ทธ ์์ ๊ฐ์ง๊ณ ์๋ ๋ฒ์ฉ ๋ ์ง์คํฐ๋ ๋ชจ๋ 32๋นํธ์ง๋ฆฌ์ด๋ค.
๊ฐ ๋ ์ง์คํฐ๋ค์ ํ๋ฒ์ 32๋นํธ์ง๋ฆฌ ๋ฐ์ดํฐ๋ง์ ์ ์ฅํ ์ ์๋ค.
๋ฌผ๋ก ๋ฉ๋ชจ๋ฆฌ ์ด๋๋ ์ฑ์ ์ํ ํน์ํ ๋ ์ง์คํฐ๋ SIMD(Single Instrunction Multiple Data)์ฉ ๋ ์ง์คํฐ๋ค์ ์ฌ์ด์ฆ๊ฐ ์ ๊ฐ๊ฐ์ด๋ค)