Endianness (big vs little): Exercises — Hinglish deep dive

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

Shuru karne se pehle, ek reminder us single formula ka jis par poora page tika hua hai. Ek $N$ -byte value $V$ ke liye, uske bytes ko $k = 0$ se number karo jahan $k = 0$ least significant byte (LSB) hai. Tab

$b_{k} = ⌊ \frac{V}{25 6 ^{k}} ⌋ mod 256$

$25 6^{k} = 2^{8 k}$ low $k$ bytes ko raste se shift out karta hai (har byte 8 bits ka hota hai).
$mod 256$ baaki sab kuch mask karke sirf sabse neeche wala byte bachata hai.

Aur base address $A$ , offset $i$ par memory mein placement:

Little-endian: $mem [A + i] = b_{i}$ (LSB jaata hai lowest address par)
Big-endian: $mem [A + i] = b_{N - 1 - i}$ (MSB jaata hai lowest address par)

Neeche diya reference figure har problem ke liye mental picture hai: addresses $A + 0 \dots A + 3$ par chaar mailboxes, aur unhe bharne ke do rules.

L1 — Recognition

Recall Solution 1.1

HUM KYA CHECK KARTE HAIN: kya lowest address wala byte value ke most significant byte se match karta hai ya least significant byte se? Value ka MSB hai 0xAA (sabse baaya pair, weight $2^{24}$ ). Lowest address par AA hai. MSB at lowest address ⇒ big-endian ("Big end → Beginning").

Recall Solution 1.2

Lowest address par DD hai, jo LSB hai (weight $2^{0}$ ). LSB at lowest address ⇒ little-endian.

Recall Solution 1.3

Big-endian. Dekho Network Protocols — isi liye htonl/ntohl exist karte hain: yeh host ke order aur is agreed big-endian wire order ke beech convert karte hain.

L2 — Application

Recall Solution 2.1

Bytes extract karo ( $k = 0$ is LSB): $b_{0} = EF, b_{1} = BE, b_{2} = AD, b_{3} = DE$ . Kyun: $b_{k} = ⌊ V /25 6^{k} ⌋ mod 256$ ; e.g. $b_{1} = ⌊ V /256 ⌋ mod 256 = BE$ . Place karo little-endian ( $mem [200 + i] = b_{i}$ ): 200:EF 201:BE 202:AD 203:DE.

Recall Solution 2.2

Big-endian index ko reverse karta hai: $mem [200 + i] = b_{3 - i}$ . 200:DE 201:AD 202:BE 203:EF. Check: sabse bada byte (DE) sabse chhote address par pada — "Big end first" se match karta hai.

Recall Solution 2.3

Bytes: $b_{0} = FF$ (LSB), $b_{1} = 00$ (MSB). Little-endian ( $mem [10 + i] = b_{i}$ ): 10:FF 11:00. Big-endian ( $mem [10 + i] = b_{1 - i}$ ): 10:00 11:FF. $N$ kyun matter karta hai: big-endian index $N - 1 - i$ hota hai, isliye reversal ki length value ki width par depend karti hai.

L3 — Analysis

Recall Solution 3.1

Little-endian mein offset $i$ wala byte hi byte index $k = i$ hai, toh ise $25 6^{i}$ se weight karo: $V = 78 \cdot 25 6^{0} + 56 \cdot 25 6^{1} + 34 \cdot 25 6^{2} + 12 \cdot 25 6^{3} = 0x12345678 .$

Recall Solution 3.2

Big-endian mein $mem [i] = b_{N - 1 - i}$ , toh offset $0$ wala byte MSB hai. Lowest address ko sabse zyada weight do: $V = 78 \cdot 25 6^{3} + 56 \cdot 25 6^{2} + 34 \cdot 25 6^{1} + 12 \cdot 25 6^{0} = 0x78563412 .$ Lesson: identical bytes, opposite convention ⇒ ek bilkul alag number. Isi liye do machines ka agree karna zaroori hai.

Recall Solution 3.3

Writer (little-endian) rakhta hai: 0:44 1:33 2:22 3:11. Reader (big-endian) offset $0$ ko MSB maanta hai: $V = 44 \cdot 25 6^{3} + 33 \cdot 25 6^{2} + 22 \cdot 25 6^{1} + 11 \cdot 25 6^{0} = 0x44332211 .$ Value byte-reversed ho gayi — classic bug jo Network Protocols mein ntohl se fix hota hai.

L4 — Synthesis

Recall Solution 4.1

Little-endian bytes: 0:09 1:00 2:00 3:00. Address 0 par ek byte = 0x09 = 9 — sahi low-order value, widening "free" hai. Big-endian bytes: 0:00 1:00 2:00 3:09. Address 0 par ek byte = 0x00 = 0 — galat; 9 address 3 par hai. Kyun: little-endian low-order data ko low addresses par rakhta hai, isliye narrow reads directly kaam karte hain (dekho Memory Addressing).

Worked example Problem 4.2 (the pointer / type-punning detector)

uint32_t x = 1;
uint8_t  b = *(uint8_t*)&x;   // read the first byte

Little-endian machine par b kya hoga? Big-endian par? (Dekho Pointers and Type Punning.)

Recall Solution 4.2

$x = 1$ ke bytes hain $b_{0} = 01$ , $b_{1} = b_{2} = b_{3} = 00$ . Little-endian: lowest address par $b_{0} = 01$ hai ⇒ b == 1. Big-endian: lowest address par MSB $b_{3} = 00$ hai ⇒ b == 0. Single nonzero byte ki location convention reveal karti hai.

Recall Solution 4.3

$V = (0x12 ≪ 24) ∣ (0x34 ≪ 16) ∣ (0x56 ≪ 8) ∣ 0x78 .$ Equivalently $V = 0x12 \cdot 2^{24} + 0x34 \cdot 2^{16} + 0x56 \cdot 2^{8} + 0x78$ . Yeh endianness se independent hai: shifts value (abstract number) par operate karte hain, kabhi memory addresses par nahi. Endianness tabhi aati hai jab woh value bytes mein lay out hoti hai. Dekho Data Representation.

L5 — Mastery

Recall Solution 5.1

char[] ek array of single bytes hai, koi ek multi-byte scalar nahi, isliye endianness ise bilkul touch nahi karti. Dono machines: 0:48 ('H') 1:69 ('i') 2:00 (NUL). Endianness bytes ko ek wide integer ke andar reorder karti hai; array element order array ke khud se fix hoti hai.

Recall Solution 5.2

Intended (big-endian reader): offset 0 MSB hai ⇒ $V = 01 \cdot 256 + 00 = 0x0100 = 256$ . Little-endian host, bina conversion ke: offset 0 ko LSB maanta hai ⇒ $V = 01 + 00 \cdot 256 = 0x0001 = 1$ . Woh 1 padhta hai 256 ki jagah — ek byte-swap ka fark. Sahi handling: ntohs wapas swap karta hai. Yahi everyday reason hai ki network code explicitly convert karta hai.

Recall Solution 5.3

Store: $mem [i] = b_{i} = ⌊ V /25 6^{i} ⌋ mod 256$ . Har offset ko $25 6^{i}$ se weight karke wapas padho: $V^{'} = \sum_{i = 0}^{N - 1} mem [i] \cdot 25 6^{i} = \sum_{i = 0}^{N - 1} b_{i} \cdot 25 6^{i} .$ Lekin $\sum_{i} b_{i} \cdot 25 6^{i}$ bilkul $V$ ka base-256 expansion hai, isliye $V^{'} = V$ . Convention lossless hai jab tak write rule = read rule ho. (Yahi big-endian par bhi laagu hota hai $25 6^{N - 1 - i}$ ke saath.)

Level Map

Connections

Endianness (big vs little) — parent topic; saare rules wahan build hue hain.
Memory Addressing — variable-width reads (Problem 4.1) address ordering par rely karti hain.
Data Representation — value-to-bytes map $V = \sum b_{k} 25 6^{k}$ .
Network Protocols — big-endian wire order, Problems 3.3 aur 5.2.
Pointers and Type Punning — Problem 4.2 mein detector cast.
Bitwise Operations — Problem 4.3 mein shift/mask construction.