Endianness (big vs little): Visual walkthrough — Hinglish deep dive

5.1.11 · D2 · Hardware › Instruction Set Architecture (ISA) › Endianness (big vs little)

Yeh page parent note Endianness (big vs little) ko bilkul zero se rebuild karta hai. Jo bhi use hua hai, woh pehle define kiya gaya hai.

Step 1 — Byte kya hota hai, aur address kya hota hai?

KYA. Memory ek lambi row of tiny boxes hai. Har box mein exactly ek byte hota hai — ek number $0$ se $255$ tak. Har box ka ek numbered label hota hai jise uska address kehte hain: $0, 1, 2, 3, \dots$ Kyunki har box ka apna address hai, hum memory ko byte-addressable kehte hain.

KYUN. Bytes ki order ki baat karne se pehle, hume agree karna hoga ki byte kya hai (ek box, jo $0$ – $255$ store karta hai) aur address kya hai (box ka numeric label). Order ka koi matlab tabhi hai jab boxes line up karke number ho.

PICTURE. White boxes ki row dekho. Har box ke neeche ka number (grey) uska address hai; woh address sirf boxes count karta hai, bits nahi.

$0$ – $255$ kyun? Ek byte $8$ bits ka hota hai, aur $2^{8} = 256$ alag-alag patterns hote hain, yaani values $0$ se $255$ tak. Yeh Data Representation se connect hota hai.

Step 2 — Ek box kaafi kyun nahi hota

KYA. 32-bit value lo $V = 0x12345678 .$ Yahan "32-bit" ka matlab hai ise $32$ bits $= 4$ bytes chahiye. Ek box sirf $8$ bits hold karta hai, isliye $V$ ek single box mein fit nahi ho sakta.

KYUN. Yahi poori wajah hai ki endianness exist karta hai: value $4$ boxes mein phail jaati hai, aur boxes consecutive addresses par hote hain, toh kuch na kuch decide karna hoga ki $V$ ka kaunsa hissa kaunse box mein jaayega.

PICTURE. Pura 32-bit bar chaar 8-bit chunks mein slice ho jaata hai. Har chunk ek byte hai jise hume kahin rakhna hai.

byte 3 12 byte 2 34 byte 1 56 byte 0 78

$12$ — sabse baaye do hex digits; sabse zyada weight wala chunk.
$78$ — sabse daaye do hex digits; sabse kam weight wala chunk.

Step 3 — Significance: chunks equal kyun nahi hote

KYA. Charon chunks ek jaisi counting nahi karte. $V$ ko ek real number ki tarah padhte hue: $V = 0x12 \cdot 2^{24} + 0x34 \cdot 2^{16} + 0x56 \cdot 2^{8} + 0x78 \cdot 2^{0} .$

Term by term:

$0x12 \cdot 2^{24}$ — top byte, $2^{24}$ se multiply hua (left $24$ bits shift hua). Sabse bada contribution → most significant byte (MSB).
$0x34 \cdot 2^{16}$ — agla byte, weight $2^{16}$ .
$0x56 \cdot 2^{8}$ — weight $2^{8} = 256$ .
$0x78 \cdot 2^{0}$ — "ones" byte, weight $1$ → least significant byte (LSB).

KYUN. Storage order choose karne se pehle yeh weighting chahiye, kyunki dono conventions literally isi se define hote hain ki kaun sa weight lowest address par jaata hai. Yeh jaane bina ki kaunsa byte "sabse bada" hai, big-endian aur little-endian ka koi matlab nahi.

PICTURE. Chaar weights $2^{0}, 2^{8}, 2^{16}, 2^{24}$ ka log scale par ek bar chart — aap dekh sakte hain ki $12$ dominate karta hai aur $78$ bahut chhota hai.

Step 4 — Big-endian: bada end pehle rakho

KYA. $V$ ko base address $A$ se store karo. Big-endian rule: MSB lowest address par jaata hai. $A + 0 : 12 A + 1 : 34 A + 2 : 56 A + 3 : 78$

KYUN. "Big-endian" = "big end pehle." Kyunki $A + 0$ wala box pehla box hai, hum wahan sabse bada byte rakh dete hain. Isse ek memory dump left-to-right bilkul human-written number $12345678$ ki tarah readable hoti hai.

PICTURE. Dekho chaar coloured chunks seedha neeche boxes mein girte hain same order mein jaise woh number mein hain — koi crossing wires nahi.

Formula form mein, offset $i$ par: $mem [i] = b_{N - 1 - i} (N = 4) .$

$N - 1 - i$ — reversed index. $i = 0$ par hume top byte $b_{3}$ chahiye; $i = 3$ par $b_{0}$ chahiye. Toh $mem [0] = b_{3} = 12$ . ✓

Step 5 — Little-endian: chhota end pehle rakho

KYA. Same value, same base $A$ . Little-endian rule: LSB lowest address par jaata hai. $A + 0 : 78 A + 1 : 56 A + 2 : 34 A + 3 : 12$

KYUN. "Little end pehle." Ones-byte $78$ sabse chhote address par hota hai. Ek elegant match note karo: offset $i$ par jo byte hai woh exactly $b_{i}$ hai — offset equals significance index.

PICTURE. Ab chunks cross over karte hain: sabse daaya chunk $78$ sabse baaye box mein swing karta hai. Crossing wires little-endian ki visual signature hai.

$mem [i] = b_{i} .$

$b_{i}$ — koi reversal nahi. $mem [0] = b_{0} = 78$ , $mem [3] = b_{3} = 12$ . ✓

Step 6 — Payoff case: kam bytes padhna

KYA. Chhoti value $V = 0x00000005$ lo address $100$ par, aur pucho: agar main address 100 par sirf 1 byte padhuun toh?

Little-endian: $100 : 05, 101 : 00, 102 : 00, 103 : 00$ . $100$ par $1$ byte padhne se $05$ milta hai — sahi value!
Big-endian: $100 : 00, 101 : 00, 102 : 00, 103 : 05$ . $100$ par $1$ byte padhne se $00$ milta hai — galat; $05$ $103$ par chhupa hai.

KYUN. Little-endian mein lowest address par byte hamesha low-order part hota hai, isliye ek $8$ -bit read ko $32$ -bit tak widen karna "free" hai: extra high bytes already higher addresses par hain. Yahi ek practical reason hai ki little-endian common hai (dekho Memory Addressing).

PICTURE. Green arrow address $100$ par ek box read karta hai. Little-endian ka arrow $05$ par land karta hai; big-endian ka $00$ par.

Step 7 — Degenerate & edge cases (koi gap mat chhodo)

KYA & KYUN. Har scenario, taaki reader ko kuch surprise na kare:

Ek single byte ( $N = 1$ ). Tab $N - 1 - i = 0 - 0 = 0 = i$ , toh big aur little identical layout dete hain $mem [0] = b_{0}$ . Ek one-byte value ki koi endianness nahi hoti.
Ek byte array / string ${’H’, ’i’}$ . Har element apna khud ka one-byte scalar hai. Toh H phir i dono machines par — array element order endianness nahi hai. (Dekho Pointers and Type Punning.)
Value $V = 0$ . Saare bytes $00$ hain; dono conventions $00000000$ store karte hain — indistinguishable.
Kisi byte ke andar bits kabhi touch nahi hote. $0x12 = 00010010$ $00010010$ hi rehta hai; sirf whole boxes move hote hain.

PICTURE. Left: $N = 1$ case, dono rules agree karte hain. Right: string case, H/i dono par same order mein — ek red "✗ not endianness" stamp ke saath.

Step 8 — Detection trick, derived

KYA. int x = 1; store karo, phir lowest address par single byte padho.

Agar woh byte $01$ hai → little-endian.
Agar woh byte $00$ hai → big-endian.

KYUN. Value $1$ ka exactly ek nonzero byte hai: uska LSB $01$ hai, aur $b_{1} = b_{2} = b_{3} = 00$ . Toh akele $01$ byte ki location rule reveal karti hai. Little-endian LSB (the $01$ ) ko lowest address par rakhta hai; big-endian use highest par chhupa deta hai.

PICTURE. Number $1$ ke dono layouts; ek pointer box $0$ read karta hai aur result ( $01$ vs $00$ ) har machine ko label karta hai.

Ek-picture summary

Sab kuch ek saath: number $0x12345678$ significance se split hua, reconstruction weights, aur dono storage orders side by side — big-endian straight-down, little-endian crossed-over.

Recall Poore walkthrough ki Feynman retelling

Ek number jo ek mailbox mein fit nahi hota, woh chaar byte-chunks mein slice ho jaata hai. Chunks equal nahi hote: sabse baaya "big" chunk hai (worth $2^{24}$ ), sabse daaya "ones" chunk hai (worth $1$ ) — yahi woh formula $b_{k} = ⌊ V /25 6^{k} ⌋ mod 256$ measure karta hai, low chunks ko divide karke hataata hai aur bottom one rakhta hai. Ab chaar mailboxes line up karo. Big-endian pehle mailbox mein big chunk drop karta hai, toh ek memory dump normal number ki tarah read hoti hai. Little-endian pehle little (ones) chunk drop karta hai, jo wires cross karta hai lekin iska matlab hai ki pehla mailbox hamesha low-order part hota hai — toh sirf ek byte padhne se chhoti value free mein mil jaati hai. Ek one-byte value ya ek text string dono taraf identical dikhti hai, kyunki reorder karne ke liye kuch hai hi nahi. Aur classic test: number $1$ store karo; uska sirf nonzero byte $01$ hai — jis bhi mailbox mein woh $01$ land kare woh aapko machine ka rule bata deta hai. Har baar same number; sirf mailbox-order badalta hai.

Recall

Ek single-byte value ki endianness kyun nahi hoti?

N = 1

ke saath, offset formula deta hai

N - 1 - i = 0 = i

, toh big aur little dono address 0 par identical byte store karte hain.

Formula

b_{k} = ⌊ V /25 6^{k} ⌋ mod 256

mein,

25 6^{k}

se divide karna kya karta hai?

Low

k

bytes ko shift away (divide out) karta hai taaki byte

k

sabse neeche wala remaining byte ban jaaye.

Little-endian: offset

i

par byte equals?

b_{i}

(offset equals significance index, LSB lowest address par).

Big-endian: offset

i

par byte equals?

b_{N - 1 - i}

(reversed index, MSB lowest address par).

Little-endian mein 8→32-bit read widen karna "free" kyun hai?

Lowest address hamesha low-order byte hold karta hai, toh extra high bytes already higher addresses par hote hain.

int 1 store karo; lowest address par byte 0x01 hai — kaun sa endianness?

Little-endian (LSB 0x01 lowest address par hota hai).

Kya {'H','i'} endianness se reorder hota hai?

Nahi — har element apna khud ka 1-byte scalar hai; array order dono machines par unchanged rehta hai.

Connections

Endianness (big vs little) — parent topic; yeh page uska picture-by-picture derivation hai.
Data Representation — weighting $V = \sum b_{k} 25 6^{k}$ jo Steps 2–3 mein use hua.
Bitwise Operations — shift = power of two se divide karna, mask = mod, bytes extract karne ke liye use hua.
Memory Addressing — byte-addressable boxes aur lowest-address ordering.
Pointers and Type Punning — lowest address par ek byte padhna (detection trick).
Network Protocols — big-endian multi-byte fields ke liye "network byte order" hai.