এই পর্বে যা শিখবেন
- Alignment কেন লাগে, আর compiler কোন অ্যালগরিদমে প্রতিটি field-এর offset আর struct-এর মাপ ঠিক করে
- হাতে
sizeofআরoffsetofবের করা (পরীক্ষার প্রিয় প্রশ্ন), আর field সাজিয়ে মাপ কমানোর প্রমাণসহ নিয়ম - Packed struct আর endianness-এর বাস্তব দাম, সত্যিকারের Clang assembly আর object file দেখে
- Target আর ABI বদলালে layout কীভাবে বদলায়, আর array of structs বনাম struct of arrays
- Python, Java আর C++-এ object-এর লুকানো অংশ: header, vptr আর boxing
১ · কেন মাপ যোগফল নয় — alignment-এর ধারণা
পর্ব ২২-এ (Composite type) দেখেছিলেন, record-এর প্রতিটি field compile-এর সময়েই একটি স্থির offset পায়, আর o->unit হয়ে যায় একটি মাত্র load. সেখানে সব field ছিল ৮ byte-এর, তাই offset সহজ: 0, 8, 16. এবার field-গুলোর মাপ আলাদা হলে কী হয়, সেটি এই পর্বের বিষয়। বাজারঘরের একটি অর্ডারের ছোট রূপ ধরা যাক: অবস্থা (status, একটি অক্ষর: 'P' মানে pending), মোট টাকা (total) আর পরিমাণ (qty).
struct Order {
char status; /* 1 byte */
int64_t total; /* 8 bytes */
short qty; /* 2 bytes */
};যোগ করলে ১১ byte. কিন্তু সত্যিকারের Clang বলে ২৪ (নিচে run). বাকি ১৩ byte কোথায় গেল? উত্তর লুকিয়ে আছে CPU কীভাবে মেমরি পড়ে তার মধ্যে।
লাইব্রেরির তাকের কথা ভাবুন। প্রতিটি তাক ৮ ইঞ্চি চওড়া খোপে ভাগ করা, আর লাইব্রেরিয়ান একবারে একটি পুরো খোপ টেনে বের করেন। ৮ ইঞ্চির একটি মোটা অভিধান যদি খোপের শুরু থেকে রাখা হয়, এক টানেই পাওয়া যায়। কিন্তু কেউ যদি সেটি এক খোপের শেষ ১ ইঞ্চি আর পরের খোপের ৭ ইঞ্চি জুড়ে রাখে, দুটি খোপ টানতে হয়, তারপর জোড়া লাগাতে হয়। তাই নিয়ম করা হলো: মোটা বই সবসময় খোপের শুরুতে। দরকার হলে আগের খোপের বাকি জায়গা খালি থাকুক। সেই খালি জায়গাই padding.
যন্ত্রের ভাষায়: একটি type-এর alignment হলো একটি সংখ্যা a (সাধারণত ২-এর ঘাত: 1, 2, 4, 8, 16), আর নিয়ম হলো সেই type-এর প্রতিটি মান এমন ঠিকানায় বসবে যা a-এর গুণিতক। বেশিরভাগ সাধারণ type-এর alignment তার মাপের সমান (natural alignment): ৮ byte-এর int64_t বসে ৮-এর গুণিতক ঠিকানায়। কেন এই নিয়ম, তার hardware-এর দিক (bus, word, cache line, ভুল-ঠিকানায় পড়ার trap) Computer Architecture কোর্সে আছে (পর্ব ০৬ · ডেটার বিট-রূপ, অংশ ৩)। এখানে প্রশ্নটি ভাষা আর compiler-এর: কোন type-এর alignment কত, তা কে ঠিক করে, আর compiler এই নিয়ম মেনে layout কীভাবে বানায়?
প্রথম প্রশ্নের উত্তর: ভাষার standard নয়, ABI (Application Binary Interface), অর্থাৎ একটি নির্দিষ্ট CPU আর অপারেটিং সিস্টেমের চুক্তি। C17 শুধু বলে প্রতিটি type-এর একটি alignment আছে, যা _Alignof দিয়ে জানা যায় (C11 থেকে; C23-এ keyword alignof). সংখ্যাটি আসে target থেকে। এটি পর্ব ২০-এর (Primitive type) data model-এর গল্পের পরের ধাপ: সেখানে দেখেছিলেন long-এর মাপ Linux আর Windows-এ আলাদা; এখানে দেখবেন alignment-ও আলাদা হতে পারে, এমনকি একই CPU-তে।
~/haat $ python cross.py # Clang 22.1.8, -S -emit-llvm, constants read from the IR
target alignof(int64_t) alignof(double) sizeof(long) sizeof(char*)
x86_64-linux-musl 8 8 8 8
x86_64-windows-gnu 8 8 4 8
aarch64-linux-musl 8 8 8 8
riscv64-linux-musl 8 8 8 8
riscv32-linux-musl 8 8 4 4
arm-linux-musleabihf 8 8 4 4
wasm32-wasi 8 8 4 4
x86-windows-gnu 8 8 4 4
x86-linux-musl 4 4 4 4
সত্যিকারের run. এই পর্বের সব C run নেওয়া হয়েছে PyPI-র ziglang 0.17.1 (MIT licence) দিয়ে, যার ভেতরে Clang 22.1.8; নিচে zig মানে python -m ziglang. Cross target-এর সংখ্যাগুলো একটি ছোট script পড়েছে: সে প্রতিটি target-এর জন্য sizeof, _Alignof আর offsetof-এর একটি ধ্রুবক-array compile করে LLVM IR থেকে মানগুলো তুলে আনে। সবচেয়ে চমকের সারি i386 Linux: সেখানে int64_t আর double-এর alignment ৪, মাপ ৮ হলেও। অথচ একই ৩২-বিট x86 CPU-তে Windows-এর ABI ৮ চায়। CPU এক, চুক্তি দুই। আর wasm32-wasi সারিটি WebAssembly-র ৩২-বিট জগৎ, যেখানে ব্রাউজারের Python (Pyodide) চলে; অংশ ২ আর ৮-এ কাজে লাগবে।
২ · Padding আর layout-এর অ্যালগরিদম
Compiler-এর কাছে struct-এর layout বানানো একটি ছোট, নির্ভুল অ্যালগরিদম। C17-এর নিয়ম (§6.7.2.1) তিনটি শর্ত দেয়: member-গুলো ঘোষণার ক্রমে বাড়তে থাকা ঠিকানায় বসবে; প্রথম member-এর আগে কোনো ফাঁক থাকবে না (তাই struct-এর ঠিকানা আর প্রথম member-এর ঠিকানা এক); আর মাঝে বা শেষে unnamed padding থাকতে পারে। বাকিটা alignment ঠিক করে দেয়।
সহায়ক function: align_up(n, a) = ⌈n ÷ a⌉ × a, অর্থাৎ n-এর সমান বা বড় সবচেয়ে ছোট a-এর গুণিতক। প্রতিটি field f-এর মাপ size(f) আর alignment align(f).
- off ← 0, A ← 1 (A হবে record-এর নিজের alignment).
- প্রতিটি field f, ঘোষণার ক্রমে: offset(f) ← align_up(off, align(f)); off ← offset(f) + size(f); A ← max(A, align(f)).
- size(record) ← align_up(off, A); align(record) ← A.
ধাপ ২-এ align_up যে byte লাফিয়ে যায়, সেগুলো মাঝের padding; ধাপ ৩-এর বাড়তি byte-গুলো tail padding.
Order-এর ওপর অ্যালগরিদমটি ধাপে ধাপে চালানো যাক। ডানের “byte-মানচিত্র”-এ প্রতিটি অক্ষর একটি byte: S মানে status, T মানে total, Q মানে qty, আর · মানে padding.
1struct Order {2 char status; /* 1, align 1 */3 int64_t total; /* 8, align 8 */4 short qty; /* 2, align 2 */5};
| হিসাব | |
| offset | |
| off, A | |
| padding | |
| byte-মানচিত্র |
- শুরু। কোনো field বসেনি: off = 0, আর record-এর alignment A আপাতত 1.
- status. char-এর alignment 1, তাই যেকোনো ঠিকানা চলে: offset 0. এখন off = 1.
- total. int64_t-কে ৮-এর গুণিতকে বসতে হবে। 1-এর পরে প্রথম গুণিতক 8, তাই byte 1 থেকে 7, মোট ৭ byte padding. total বসে 8 থেকে 15-এ; off = 16, A = 8.
- qty. short-এর alignment 2, আর 16 আগেই ২-এর গুণিতক: কোনো ফাঁক নেই। qty বসে 16 আর 17-এ; off = 18.
- শেষ। মাপকে A = 8-এর গুণিতক করতে হবে: align_up(18, 8) = 24, তাই শেষে ৬ byte tail padding. ১১ byte কাজের ডেটা, ১৩ byte ফাঁকা: Clang-এর আসল ফলও ঠিক এটি।
শেষের ৬ byte কেন লাগে, যখন struct-এর পরে আর কোনো field নেই? Array-র কারণে। struct Order a[3]-এ দ্বিতীয় Order-এর ঠিকানা প্রথমটির ঠিক sizeof পরে। মাপ ১৮ হলে a[1] বসত 18-এ, আর তার total পড়ত 26-এ, যা ৮-এর গুণিতক নয়। মাপ ২৪ হলে প্রতিটি উপাদান ৮-এর গুণিতকে শুরু, তাই প্রতিটির ভেতরের offset-ও ঠিক থাকে। এজন্য C-তে সবসময় সত্য: sizeof একটি type-এর alignment-এর গুণিতক, আর sizeof(T[n]) = n × sizeof(T).
এবার সত্যিকারের Clang-এ। sizeof আর offsetof ছাপানো হয়েছে, আর -Wpadded flag compiler-কে প্রতিটি padding-এর কথা জানাতে বলে:
~/haat $ zig cc -std=c17 -Wall -Wextra -Wpadded layout.c -o layout.exe
layout.c:7:13: warning: padding struct 'struct Order' with 7 bytes to align 'total' [-Wpadded]
layout.c:5:8: warning: padding size of 'struct Order' with 6 bytes to alignment boundary [-Wpadded]
layout.c:11:8: warning: padding size of 'struct OrderSorted' with 5 bytes to alignment boundary [-Wpadded]
layout.c:23:8: warning: padding size of 'struct Item' with 3 bytes to alignment boundary [-Wpadded]
4 warnings generated.
~/haat $ ./layout.exe
struct Order: sizeof 24, alignof 8
status offset 0 size 1
total offset 8 size 8
qty offset 16 size 2
struct OrderSorted: sizeof 16
total offset 0 size 8
qty offset 8 size 2
status offset 10 size 1
struct OrderPacked: sizeof 11, alignof 1
struct Item: sizeof 16 (pointer 8)
struct Order[3]: sizeof 72
~/haat $ zig cc -target x86_64-linux-musl -c -Xclang -fdump-record-layouts rl.c
*** Dumping AST Record Layout
0 | struct Order
0 | char status
8 | int64_t total
16 | short qty
| [sizeof=24, align=8]
সত্যিকারের run, Clang 22.1.8, লেখকের Windows x86-64 যন্ত্রে (warning-এর source-লাইনগুলো ছেঁটে)। দুটি warning stepper-এর দুই padding-এর সঙ্গে হুবহু মেলে: ৭ byte total-এর আগে, ৬ byte শেষে। struct Order[3] ৭২ = ৩ × ২৪, tail padding-সহ। শেষ অংশটি Clang-এর ভেতরের layout-টেবিল, যা -Xclang -fdump-record-layouts ছাপে: compiler নিজে যে টেবিল ধরে code লেখে, সরাসরি সেটি। OrderSorted, OrderPacked আর Item পরের অংশগুলোর জন্য। -Wpadded প্রতিদিনের flag নয় (প্রায় সব struct-এ বাজে), কিন্তু layout বুঝতে খুব কাজের; Linux জগতে pahole নামের একটি tool debug তথ্য থেকে একই রকম “ফাঁক” দেখায়।
অ্যালগরিদমটি নিজে লিখে যাচাই করা যাক। নিচের Python কোড অ্যালগরিদম ২৫.১ হুবহু চালায়, আর প্রতিটি ফলকে Python-এর struct module-এর calcsize-এর সঙ্গে মেলায়। struct-এর @ চিহ্ন মানে “এই যন্ত্রের C compiler-এর মাপ আর alignment”. একটি ফাঁদ আছে: calcsize নিজে থেকে tail padding যোগ করে না; শেষে 0q (শূন্যটি int64) লিখলে শেষটাও ৮-এর গুণিতকে গোল হয় (Python documentation-এ এই কৌশলটিই বলা আছে)। শেষের দুটি সারি Haat-এর বর্ধিত রূপ-এর জন্য, অংশ ৩-এ ব্যাখ্যা।
import struct
# (size, align) on LP64, as Clang 22 reports; Bool/Int: Haat extension
C = {"char": (1, 1), "short": (2, 2), "int32": (4, 4), "int64": (8, 8),
"double": (8, 8), "Bool": (1, 1), "Int": (8, 8)}
CODE = {"char": "b", "short": "h", "int32": "i", "int64": "q",
"double": "d", "Bool": "?", "Int": "q"}
def align_up(n, a):
return (n + a - 1) // a * a
def layout(fields, sort=False):
if sort: # largest alignment first
fields = sorted(fields, key=lambda f: -C[f[1]][1])
off, max_al, rows = 0, 1, []
for name, ty in fields:
size, al = C[ty]
start = align_up(off, al) # skip to a multiple of al
rows.append(f"{name}@{start}" + (f"(+{start - off})" if start > off else ""))
off, max_al = start + size, max(max_al, al)
size = align_up(off, max_al) # tail padding
fmt = "@" + "".join(CODE[t] for _, t in fields) + "0" + "bhiq"[max_al.bit_length() - 1]
return size, max_al, " ".join(rows), struct.calcsize(fmt)
def check(name, fields, sort=False):
size, al, rows, real = layout(fields, sort)
print(f"{name:11} size {size:2} align {al} {rows} calcsize={real}")
order = [("status", "char"), ("total", "int64"), ("qty", "short")]
check("Order", order)
check("Order sort", order, sort=True)
check("Exam1", [("a", "char"), ("b", "int32"), ("c", "char")])
check("Exam2", [("b", "int32"), ("a", "char"), ("c", "char")])
check("Mixed", [("qty", "short"), ("price", "double"), ("paid", "char"), ("id", "int32")])
haat = [("paid", "Bool"), ("qty", "Int"), ("gift", "Bool"), ("total", "Int")]
check("Haat Order", haat)
check("Haat sort", haat, sort=True)
print("calcsize('@bqh') without the 0q trick:", struct.calcsize("@bqh"))আসল আউটপুট (ব্রাউজারের Python):
Order size 24 align 8 status@0 total@8(+7) qty@16 calcsize=24
Order sort size 16 align 8 total@0 qty@8 status@10 calcsize=16
Exam1 size 12 align 4 a@0 b@4(+3) c@8 calcsize=12
Exam2 size 8 align 4 b@0 a@4 c@5 calcsize=8
Mixed size 24 align 8 qty@0 price@8(+6) paid@16 id@20(+3) calcsize=24
Haat Order size 32 align 8 paid@0 qty@8(+7) gift@16 total@24(+7) calcsize=32
Haat sort size 24 align 8 qty@0 total@8 paid@16 gift@17 calcsize=24
calcsize('@bqh') without the 0q trick: 18
প্রতিটি সারিতে অ্যালগরিদমের মাপ আর calcsize এক। (+7) মানে সেই field-এর আগে ৭ byte padding. Exam1 বনাম Exam2 পরীক্ষার পুরোনো প্রিয়: একই তিনটি field, {char, int, char} ক্রমে ১২ byte, {int, char, char} ক্রমে ৮. Mixed-এ দুই জায়গায় ফাঁক: price-এর আগে ৬, id-এর আগে ৩. Order, Exam1, Exam2 আর Mixed-এর সব offset আর মাপ Clang-এর -fdump-record-layouts-এও আলাদা করে মিলিয়ে দেখা হয়েছে। শেষ লাইনটি ফাঁদটি দেখায়: 0q ছাড়া calcsize বলে ১৮, যা C-র sizeof নয়। আরেকটি সূক্ষ্মতা: ব্রাউজারের Python ৩২-বিট WebAssembly-তে চলে, তবু এখানে সংখ্যা x86-64-এর সমান, কারণ অংশ ১-এর টেবিল অনুযায়ী wasm32-তেও int64_t আর double-এর alignment ৮. long বা pointer রাখলে মিলত না।
৩ · Field সাজিয়ে জায়গা বাঁচানো — আর কে সাজানোর অধিকার রাখে
Exam1 আর Exam2 থেকেই কৌশলটি বোঝা যায়: বড় alignment-এর field আগে রাখুন। Order-এ total (৮), তারপর qty (২), তারপর status (১):
1/* sort: largest alignment first */2struct OrderSorted {3 int64_t total; /* align 8 */4 short qty; /* align 2 */5 char status; /* align 1 */6};
| ক্রম | |
| হিসাব | |
| off | |
| মাঝের padding | |
| byte-মানচিত্র |
- সাজানো। Field-গুলো alignment-এর বড় থেকে ছোট ক্রমে: 8, 2, 1. অর্থ একই, শুধু ঘোষণার ক্রম বদল।
- total. off = 0 আগেই ৮-এর গুণিতক, তাই offset 0; off = 8.
- qty. 8 আগেই ২-এর গুণিতক: কোনো ফাঁক নেই, offset 8; off = 10.
- status. char যেকোনো জায়গায় বসে: offset 10; off = 11.
- শেষ। align_up(11, 8) = 16; মাঝে কোনো padding নেই, শুধু শেষে ৫ byte. ২৪ থেকে ১৬, অর্থাৎ এক-তৃতীয়াংশ জায়গা বাঁচল; ১০০০টি অর্ডারের array-তে ২৪০০০-এর জায়গায় ১৬০০০ byte. Clang-এর run-এও OrderSorted ১৬, offset 0, 8, 10.
এটি কাকতালীয় নয়। একটি ছোট উপপাদ্য আছে, যা অনুশীলন ২-এ প্রমাণ করবেন: যদি সব alignment ২-এর ঘাত হয় আর প্রতিটি field-এর মাপ তার alignment-এর গুণিতক হয় (সাধারণ type-এ দুটিই সত্য), তাহলে বড় থেকে ছোট alignment-এর ক্রমে সাজালে মাঝে কোনো padding থাকে না, আর ফলের মাপ সম্ভাব্য সবচেয়ে ছোট। মূল যুক্তি এক লাইনে: প্রতিটি field শুরু হয় আগের field-গুলোর মাপের যোগফলে, আর সেই প্রতিটি মাপ বর্তমান alignment-এর গুণিতক।
তাহলে compiler নিজে সাজায় না কেন?
C-তে পারে না, কারণ অংশ ২-এর নিয়ম ঘোষণার ক্রম বাধ্যতামূলক করে। এর পেছনে বাস্তব কারণ আছে: struct-এর layout হলো অন্য compile-করা কোড, ফাইল-ফরম্যাট আর hardware-এর সঙ্গে চুক্তি। একটি library-র struct যদি compiler নিজের ইচ্ছায় সাজায়, আর অন্য compiler বা পুরোনো version অন্যভাবে, দুই পক্ষ একই byte-কে দুই রকম পড়বে। তাই C-তে প্রোগ্রামার নিজে ক্রম ঠিক করেন, আর জায়গা বাঁচানোর দায়িত্বও তাঁর।
Rust উল্টো সিদ্ধান্ত নিয়েছে: সাধারণ struct-এর layout ভাষা নির্দিষ্ট করে না, তাই compiler field সাজিয়ে padding কমাতে পারে, আর বর্তমান rustc তা করে বলে জানা যায়। C-র সঙ্গে কথা বলতে হলে (FFI) লিখতে হয় #[repr(C)], যা C-র নিয়ম চাপায় (উদাহরণ, এখানে চালানো হয়নি)। অর্থাৎ Rust “layout চুক্তি” আর “সাধারণ ডেটা”-কে আলাদা করেছে: যেখানে চুক্তি দরকার, সেখানে প্রোগ্রামার স্পষ্ট বলেন; বাকি সব জায়গায় compiler স্বাধীন। Java-তে প্রশ্নটিই ওঠে না: ভাষা field-এর মেমরি-অবস্থান প্রোগ্রামারকে দেখায় না, তাই JVM নিজের মতো সাজায়।
Haat-এর বর্ধিত রূপ — record-এর layout নীতি
Haat v1-এ record নেই; পর্ব ২২-এ প্রস্তাব করা হয়েছিল record Order { qty: Int, unit: Int }. Haat যখন পরে native code-এ যাবে (পর্ব ৭২-এর RISC-V back end), প্রতিটি record-এর layout ঠিক করতে হবে। Int ৬৪-বিট two's complement (reference README-র নকশা-সিদ্ধান্ত ১৩), তাই স্বাভাবিক পছন্দ ৮ byte, align 8; Bool-এর জন্য ১ byte ধরা হলো। এগুলো এই প্রস্তাবের সিদ্ধান্ত, reference-এর নয়। ধরুন:
record Order { paid: Bool, qty: Int, gift: Bool, total: Int } // Haat-এর বর্ধিত রূপওপরের Python run-এর শেষ দুই সারি দুটি নীতির ফল দেখায়: ঘোষণার ক্রমে ৩২ byte (দুটি ৭ byte-এর ফাঁক), সাজিয়ে ২৪. Haat-এর জন্য প্রস্তাবিত নীতি Rust-এর পথ: ডিফল্টে compiler সাজাবে, কারণ Haat প্রোগ্রাম record-এর ঠিকানা বা offset কখনো দেখতে পায় না (pointer নেই, পর্ব ২৩ · Pointer আর reference-এ বিস্তারিত), তাই ক্রম বদলালে কোনো প্রোগ্রামের অর্থ বদলায় না। শুধু যদি ভবিষ্যতে C-র সঙ্গে ডেটা ভাগের সুবিধা আসে, তখন একটি চিহ্ন দিয়ে C-ক্রম চাওয়া যাবে (অনুশীলন ১)।
৪ · Packed struct — ফাঁক বন্ধ করার দাম
আরও ছোট চাইলে compiler-কে padding দিতেই নিষেধ করা যায়। GCC আর Clang-এ __attribute__((packed)), MSVC-তে #pragma pack. এটি C standard-এর অংশ নয়, compiler-এর extension. ফল: packed struct, যেখানে field-গুলো গায়ে গায়ে, alignment 1.
ছবি ২৫.১ — একই তিনটি field, তিন রকম layout
প্রতিটি ছোট ঘর ১ byte. S = status, ডোরাকাটা ঘর = padding. নিচের সংখ্যাগুলো offset.
এই লাল দাগের দাম কী? নির্ভর করে CPU-র ওপর। x86-64 ভুল-ঠিকানা থেকে পড়া hardware-এই সামলায় (কখনো একটু ধীর, বিশেষত যদি মানটি দুটি cache line জুড়ে থাকে)। RISC-V-র spec ভুল-ঠিকানার load-কে hardware-এ চালানো বা trap করে software-এ নকল করা, দুটিই অনুমোদন করে বলে জানা যায়; দ্বিতীয়টি খুব ধীর। তাই সাধারণ riscv64 target-এর জন্য Clang ঝুঁকি নেয় না। দেখুন একই o->total পড়া:
- Source
o->totalএকই C - IR
align 1প্রতিশ্রুতি - x86-64
movq১টি নির্দেশ - RISC-V
lbu ×8২২টি নির্দেশ
int64_t get_total(
const struct Order *o) {
return o->total;
}
int64_t get_total_packed(
const struct OrderPacked *o) {
return o->total;
}
; get_total
%2 = getelementptr inbounds
nuw i8, ptr %0, i64 8
%3 = load i64, ptr %2, align 8
; get_total_packed
%2 = getelementptr inbounds
nuw i8, ptr %0, i64 1
%3 = load i64, ptr %2, align 1
get_total:
movq 8(%rdi), %rax
get_total_packed:
movq 1(%rdi), %rax
get_total:
ld a0, 8(a0)
get_total_packed:
lbu a1, 2(a0)
lbu a2, 3(a0)
lbu a3, 4(a0)
lbu a4, 1(a0)
slli a1, a1, 8
... (8 lbu, 7 slli, 7 or)
or a0, a0, a1
- একই source. দুটি function একই কাজ করে: total পড়া। পার্থক্য শুধু struct-এ: একটিতে total offset 8-এ, অন্যটিতে (packed) offset 1-এ।
- IR-এ প্রতিশ্রুতি। LLVM IR-এর
load-এ একটিalignসংখ্যা থাকে: compiler কতটা নিশ্চিত যে ঠিকানাটি সেই সংখ্যার গুণিতক। সাধারণ struct-এalign 8, packed-এ মাত্রalign 1. Back end এই প্রতিশ্রুতি দেখে নির্দেশ বাছে। - x86-64. দুটিই একটি
movq; শুধু offset 8-এর জায়গায় 1. x86 ভুল-ঠিকানার load মেনে নেয়, তাই compiler-এর বাড়তি কাজ নেই। - RISC-V. সাধারণ রূপে একটি
ld. Packed রূপে আটটি আলাদা byte পড়া (lbu), তারপর shift আর or দিয়ে জোড়া: মোট ২২টি নির্দেশ (frame-এর নির্দেশ বাদে, সত্যিকারের-O2 -Sথেকে গোনা)। ৫ byte বাঁচানোর দাম প্রতিটি পড়ায়।
আরও একটি সূক্ষ্ম বিপদ: packed field-এর ঠিকানা নিয়ে সাধারণ pointer-এ দিলে সেই pointer “মিথ্যা” বলে। int64_t * দেখে compiler ধরে নেয় ঠিকানাটি ৮-এর গুণিতক, আর C-তে ভুল-ঠিকানার pointer দিয়ে পড়া undefined behavior. Clang এটি ধরিয়ে দেয় (সত্যিকারের run):
~/haat $ zig cc -target x86_64-linux-musl -std=c17 -Wall -Wextra -c pk.c
pk.c:4:50: warning: taking address of packed member 'total' of class or structure 'OrderPacked' may result in an unaligned pointer value [-Waddress-of-packed-member]
4 | int64_t f(struct OrderPacked *o) { return twice(&o->total); }
| ^~~~~~~~
1 warning generated.
তাহলে packed কখন? মূলত যখন byte-বিন্যাস বাইরের কেউ ঠিক করে দিয়েছে: নেটওয়ার্ক protocol-এর header, ফাইল-ফরম্যাট, hardware register-এর মানচিত্র। এমনকি সেখানেও নিরাপদ পথ প্রায়ই অন্যটি: byte-এর সারি থেকে প্রতিটি field আলাদা করে পড়া (memcpy বা shift দিয়ে), যা alignment আর endianness দুটিই স্পষ্ট করে। পরের অংশে দেখবেন কেন endianness-ও এখানে ঢুকে পড়ে।
৫ · Endianness — একটি সংখ্যার byte-গুলো কোন ক্রমে
একটি ৪ byte-এর সংখ্যা চারটি ঘরে বসবে, কিন্তু কোন byte প্রথম ঘরে? এই প্রশ্নের উত্তরকে বলে endianness. বাংলাদেশে তারিখ লেখা হয় ১৯-১১-২০২৬ (দিন আগে), আর অনেক database-এ ২০২৬-১১-১৯ (বছর আগে)। মান একই, ক্রম উল্টো; আর কোন ক্রম চলছে না জেনে ০৩-০৪ পড়লে মার্চ না এপ্রিল, বোঝা যায় না। সংখ্যার byte-এও তাই:
- Little-endian: সবচেয়ে কম গুরুত্বের byte সবচেয়ে ছোট ঠিকানায়। x86, x86-64, RISC-V আর বাস্তবে প্রায় সব ARM সিস্টেম।
- Big-endian: সবচেয়ে বেশি গুরুত্বের byte আগে, যেভাবে আমরা কাগজে লিখি। IBM-এর s390x, পুরোনো SPARC আর PowerPC-র বড় অংশ, আর নেটওয়ার্ক protocol-এর network byte order.
নাম দুটি এসেছে Jonathan Swift-এর Gulliver's Travels (১৭২৬) থেকে, যেখানে দুই দেশ যুদ্ধ করে সেদ্ধ ডিম বড় দিক থেকে ভাঙা হবে না ছোট দিক থেকে, তা নিয়ে। Danny Cohen ১৯৮০ সালের ১ এপ্রিল “On Holy Wars and a Plea for Peace” (IEN 137) প্রবন্ধে নামগুলো কম্পিউটারের byte-ক্রমে আনেন, আর বলেন আসল প্রয়োজন কোনো একটি ক্রম বেছে সবাই মিলে মানা।
বাজারঘরের একটি অর্ডারের মোট 1040 টাকা, ৪ byte-এর int হিসেবে ধাপে ধাপে:
1int32_t total = 1040;2/* bytes, most significant first */3/* little-endian: x86-64, RISC-V */4/* big-endian: s390x, network */5/* big-endian bytes, read as little */
| মান | |
| byte (গুরুত্ব অনুযায়ী) | |
| ঠিকানা a … a+3 |
- Hex-এ। 1040 = 4 × 256 + 16, অর্থাৎ ৪ byte-এ 0x00000410.
- চারটি byte. গুরুত্বের ক্রমে (বড় থেকে ছোট):
00 00 04 10.10সবচেয়ে কম গুরুত্বের byte (মান 16),04তার পরের (4 × 256). - Little-endian. ছোট ঠিকানায় ছোট byte: মেমরিতে
10 04 00 00. সত্যিকারের Clang-এ x86-64 আর riscv64-এর object file-এর.rodata-তে ঠিক এই চারটি byte. - Big-endian. ছোট ঠিকানায় বড় byte:
00 00 04 10, কাগজে লেখার মতো। s390x, powerpc64, mips আর aarch64_be target-এর object file-এ এটিই এসেছে। - ভুল ক্রমে পড়া। Big-endian-এ পাঠানো
00 00 04 10যদি little-endian ধরে পড়া হয়, প্রথম byte হয় সবচেয়ে কম গুরুত্বের: মান 0x10040000 = 268697600. ১০৪০ টাকার অর্ডার হয়ে গেল ছাব্বিশ কোটির বেশি; কোনো error নেই, শুধু ভুল সংখ্যা।
~/haat $ cat n.c
const unsigned int total = 1040;
~/haat $ python endian.py x86_64-linux-musl riscv64-linux-musl s390x-linux-musl \
powerpc64-linux-musl mips-linux-musleabi aarch64_be-linux-musl
x86_64-linux-musl ELF little-endian .rodata: 10 04 00 00
riscv64-linux-musl ELF little-endian .rodata: 10 04 00 00
s390x-linux-musl ELF big -endian .rodata: 00 00 04 10
powerpc64-linux-musl ELF big -endian .rodata: 00 00 04 10
mips-linux-musleabi ELF big -endian .rodata: 00 00 04 10
aarch64_be-linux-musl ELF big -endian .rodata: 00 00 04 10
সত্যিকারের run. প্রতিটি target-এর জন্য zig cc -c -O2 একটি object file বানিয়েছে; তারপর ৩০ লাইনের একটি Python ELF-পাঠক file-এর header থেকে byte-ক্রম আর .rodata section-এর প্রথম চারটি byte পড়েছে (zig-এর নিজের objdump ELF পড়তে পারে না)। Source একই, compiler একই; শুধু target বদলেছে, আর সঙ্গে সঙ্গে মেমরির byte-ক্রম। Arm-এর aarch64_be দেখায় যে একই ISA দুই ক্রমেই চলতে পারে (bi-endian); বাস্তবে এর little-endian রূপটিই প্রচলিত।
এক যন্ত্রের ভেতরে endianness সাধারণত অদৃশ্য: আপনি total লিখে total পড়েন, যন্ত্র নিজের ক্রমে দুটিই করে। সমস্যা আসে byte যখন যন্ত্রের সীমানা পেরোয়: নেটওয়ার্কে, ফাইলে, অন্য ভাষার library-তে। তাই ভালো ভাষা বা library byte-ক্রম স্পষ্ট লিখতে দেয়। Python-এর struct-এ format-এর প্রথম অক্ষর: < little, > big, @ এই যন্ত্রের নিজের ক্রম আর alignment:
import struct, sys
print("this machine:", sys.byteorder, "| pointer:", struct.calcsize("P"), "bytes")
n = 1040 # one order total, 0x410
for fmt in ("<i", ">i", "<q", ">q"):
print(f"{fmt} ->", struct.pack(fmt, n).hex(" "))
wire = struct.pack(">i", n) # sent in network (big-endian) order
print("read as big :", struct.unpack(">i", wire)[0])
print("read as little:", struct.unpack("<i", wire)[0], "=", hex(struct.unpack("<i", wire)[0]))
# a whole Order record: '<' = little-endian AND no padding,
# '@' = this machine's order AND its C alignment
rec = (ord("P"), 1040, 2) # status, total, qty
packed = struct.pack("<bqh", *rec)
native = struct.pack("@bqh0q", *rec)
print("packed", len(packed), "bytes:", packed.hex(" "))
print("native", len(native), "bytes:", native.hex(" "))
print("total read back:", struct.unpack_from("<q", packed, 1)[0],
struct.unpack_from("<q", native, 8)[0])আসল আউটপুট (ব্রাউজারের Python):
this machine: little | pointer: 4 bytes
<i -> 10 04 00 00
>i -> 00 00 04 10
<q -> 10 04 00 00 00 00 00 00
>q -> 00 00 00 00 00 00 04 10
read as big : 1040
read as little: 268697600 = 0x10040000
packed 11 bytes: 50 10 04 00 00 00 00 00 00 02 00
native 24 bytes: 50 00 00 00 00 00 00 00 10 04 00 00 00 00 00 00 02 00 00 00 00 00 00 00
total read back: 1040 1040
প্রথম লাইন: ব্রাউজারের যন্ত্র little-endian, আর WebAssembly-র ৩২-বিট জগতে pointer ৪ byte (লেখকের ল্যাপটপের ৬৪-বিট CPython 3.14.4-এ একই লাইন বলে ৮)। তারপর stepper-এর সব byte, এবার Python-এর হাতে; ভুল ক্রমে পড়া আবার 268697600. শেষ অংশটি একসঙ্গে দুই বিষয়: <bqh-এ struct কোনো padding দেয় না (standard মাপ), তাই ১১ byte, packed struct-এর হুবহু ছবি, total offset 1-এ। @bqh0q-এ C-র alignment, তাই ২৪ byte, total offset 8-এ। এখানে padding-এর byte-গুলো 00, কারণ Python সেগুলো শূন্য দিয়ে ভরে; C-তে padding-এর byte-এর মান নির্দিষ্ট নয়, তাই কখনো struct-এর byte সরাসরি ফাইলে লিখে বা memcmp দিয়ে তুলনা করে নির্ভর করবেন না।
JavaScript-এ একই কাজের জন্য DataView: একটি ArrayBuffer-এর যেকোনো offset থেকে যেকোনো ক্রমে পড়া-লেখা। পর্ব ২২-এর typed array-এর সঙ্গে দুটি পার্থক্য: typed array যন্ত্রের নিজের ক্রম মানে আর ঠিক-ঠিকানা (alignment) চায়; DataView ক্রম জিজ্ঞেস করে আর যেকোনো offset মেনে নেয়।
// which byte order does this browser's machine use?
const probe = new Uint8Array(new Uint16Array([0x0102]).buffer);
console.log("platform:", probe[0] === 0x02 ? "little-endian" : "big-endian");
// an 11-byte packed Order as it arrives from the network (big-endian):
// status 'P' at 0, total 1040 at 1 (8 bytes), qty 2 at 9 (2 bytes)
const buf = new ArrayBuffer(11);
const dv = new DataView(buf);
dv.setUint8(0, 0x50);
dv.setBigInt64(1, 1040n, false); // false = big-endian
dv.setInt16(9, 2, false);
console.log("bytes:", [...new Uint8Array(buf)]
.map(b => b.toString(16).padStart(2, "0")).join(" "));
console.log("total (big) :", dv.getBigInt64(1, false).toString());
console.log("total (little):", dv.getBigInt64(1, true).toString());
console.log("qty:", dv.getInt16(9, false));
// a typed array view must start at a multiple of its element size
try {
new BigInt64Array(buf, 1, 1);
} catch (e) {
console.log(e.name + ":", e.message);
}আসল আউটপুট (ব্রাউজারের JavaScript; Node 24-এও হুবহু এক):
platform: little-endian
bytes: 50 00 00 00 00 00 00 04 10 00 02
total (big) : 1040
total (little): 1154047404513689600
qty: 2
RangeError: start offset of BigInt64Array should be a multiple of 8
DataView offset 1-এ ৮ byte লিখেছে আর পড়েছে, যদিও 1 ৮-এর গুণিতক নয়: সে byte ধরে কাজ করে, তাই packed ডেটা পড়ার স্বাভাবিক হাতিয়ার। একই byte little-endian ধরে পড়লে 1154047404513689600, আরেকটি অর্থহীন বিশাল সংখ্যা। শেষ লাইন: BigInt64Array offset 1 থেকে শুরু করতে রাজি নয়, RangeError দেয়। JavaScript এখানে ভাষার নিয়মেই alignment পরীক্ষা করে, C-র মতো undefined behavior-এ ছেড়ে দেয় না।
৬ · Target বদলালে layout বদলায় — layout হলো ABI
অংশ ১-এর alignment-টেবিল থেকে একটি সরাসরি সিদ্ধান্ত: একই struct ভিন্ন target-এ ভিন্ন মাপের হতে পারে। একই script-এ এই পর্বের চারটি struct ন'টি target-এ:
| Target (Clang 22.1.8) | Order | total-এর offset | OrderSorted | Packed | Item {char*, int32, char} |
|---|---|---|---|---|---|
| x86_64-linux, aarch64-linux, riscv64-linux | 24 | 8 | 16 | 11 | 16 |
| x86_64-windows | 24 | 8 | 16 | 11 | 16 |
| riscv32-linux, arm-linux (32-বিট), wasm32 | 24 | 8 | 16 | 11 | 12 |
| x86-windows (32-বিট) | 24 | 8 | 16 | 11 | 12 |
| x86-linux (i386) | 16 | 4 | 12 | 11 | 12 |
তিনটি শিক্ষা। এক, pointer-ওয়ালা struct (Item) ৬৪-বিট আর ৩২-বিট জগতে আলাদা, কারণ pointer ৮ বনাম ৪ byte. দুই, i386 Linux-এর System V ABI int64_t-কে struct-এর ভেতরে ৪-এর গুণিতকে বসায়, তাই Order মাত্র ১৬ (Clang-এর layout-টেবিলে total 4-এ, qty 12-এ)। তিন, packed সবখানে ১১: ফাঁক না থাকলে ABI-র কিছু করার নেই। আর একটি ছোট সত্য: শুধু “কোন CPU” বললে layout জানা যায় না; লাগে CPU, অপারেটিং সিস্টেম আর ABI, যাকে compiler-এর জগতে একসঙ্গে target triple বলে (যেমন x86_64-linux-musl).
ভাষা-নকশার দিক থেকে এর অর্থ গভীর। Struct-এর layout ABI-র অংশ: একটি shared library যে struct দেয়, তার প্রতিটি field-এর offset সেই library ব্যবহারকারী প্রতিটি compile-করা program-এর machine code-এ সংখ্যা হয়ে বসে আছে (পর্ব ২২-এর movq 8(%rdi) মনে করুন)। Library-র নতুন version-এ struct-এ মাঝখানে একটি field যোগ করলে পুরোনো program পুরোনো offset-এ পড়বে, আর নীরবে ভুল ডেটা পাবে। এজন্য দীর্ঘজীবী C library-গুলো প্রায়ই struct-এর ভেতর গোপন রাখে (শুধু pointer দেয়, “opaque type”), নয়তো শুধু শেষে field যোগ করে। পর্ব ১৮-এ module-এর সীমানায় ABI-র কথা এসেছিল (Module, package আর namespace); calling convention-সহ পুরো ABI পর্ব ৭১-এর বিষয়।
৭ · Array of structs বনাম struct of arrays
এতক্ষণ একটি record-এর ভেতরের সাজ দেখলেন। এবার অনেক record একসঙ্গে। বাজারঘরের দিনের ১০০০টি অর্ডার রাখার দুটি স্বাভাবিক উপায়:
/* array of structs (AoS): one Order after another */
struct Order orders[1000]; /* orders[k].total */
/* struct of arrays (SoA): one array per field */
struct Orders {
char status[1000];
int64_t total[1000]; /* orders.total[k] */
short qty[1000];
} orders_soa;Array of structs-এ একটি অর্ডারের সব তথ্য পাশাপাশি; struct of arrays-এ একটি field-এর সব মান পাশাপাশি। কোনটি ভালো, তা নির্ভর করে কোড কী পড়ে তার ওপর। দিনের মোট বিক্রি হিসাব করতে loop শুধু total পড়ে। CPU মেমরি আনে cache line ধরে (সাধারণত ৬৪ byte). AoS-এ প্রতিটি ২৪ byte-এর Order-এর মধ্যে মাত্র ৮ byte কাজের, বাকি ১৬ byte (status, qty, padding) অকারণে cache-এ আসে; SoA-তে আনা প্রতিটি byte কাজের। নিচের run-এর শেষ দুই লাইনে এটি গুনে দেখানো: AoS ৩৭৫টি cache line ছোঁয়, SoA ১২৫টি। এটি গোনা, সময় মাপা নয়; আসল গতির পার্থক্য যন্ত্র, cache আর prefetcher-এর ওপর নির্ভর করে, তাই কোনো গতির সংখ্যা এখানে দাবি করা হচ্ছে না। Cache-বান্ধব loop-এর hardware-এর দিক আছে Computer Architecture কোর্সের পর্ব ৪৮-এ.
উল্টো দিকও সত্য: একটি অর্ডারের সব field একসঙ্গে লাগলে (একটি অর্ডারের রসিদ ছাপা) AoS-এ সব এক জায়গায়, SoA-তে তিনটি আলাদা জায়গা। এই চিন্তা থেকেই data-oriented design: আগে প্রশ্ন “কোন loop কোন field কতবার পড়ে”, তারপর layout. ভাষা-নকশার প্রশ্নটি হলো, compiler কি AoS-কে নিজে SoA বানাতে পারে? সাধারণভাবে C-তে না: struct-এর layout ABI-র অংশ, আর &orders[k]-এর মতো pointer program-এর যেকোনো জায়গায় যেতে পারে। তাই কিছু ভাষা আর library এটি প্রোগ্রামারের হাতে সহজ করে দেয়, যেমন Zig-এর standard library-র MultiArrayList; আর analytics-এর জগতে Apache Arrow-এর মতো column-ভিত্তিক ফরম্যাট একই ধারণার বড় রূপ।
৮ · Managed ভাষায় object-এর আকার — header, vptr আর boxing
C-র struct-এ যা লেখেন তা-ই (আর padding). উচ্চস্তরের ভাষায় প্রতিটি object-এর সঙ্গে runtime-এর নিজের কিছু তথ্য থাকে, যাকে বলে object header: object-এর type কী, garbage collector-এর চিহ্ন, reference-এর গণনা, lock-এর অবস্থা। এর দাম ছোট object-এ সবচেয়ে বেশি চোখে পড়ে।
C++: class-এ একটি virtual function থাকলেই প্রতিটি object-এ একটি লুকানো vptr. পর্ব ০৮-এ (Object-oriented ভাষার ধারণা) এর কাজ আর vtable দেখেছেন; layout-এর চোখে Clang-এর টেবিল (সত্যিকারের run, x86-64 Linux):
~/haat $ cat cpp.cpp
struct Discount { virtual long long apply(long long t) { return t; } char kind; };
int a = sizeof(Discount);
~/haat $ zig c++ -target x86_64-linux-musl -c -Xclang -fdump-record-layouts cpp.cpp
*** Dumping AST Record Layout
0 | struct Discount
0 | (Discount vtable pointer)
8 | char kind
| [sizeof=16, dsize=9, align=8,
| nvsize=9, nvalign=8]
vptr একটি pointer, তাই offset 0-এ ৮ byte, আর সে struct-এর alignment ৮ করে দেয়; ফলে ১ byte-এর kind-এর জন্য মোট ১৬ byte. dsize=9 মানে আসল ডেটা ৯ byte পর্যন্ত; বাকি ৭ byte tail padding, যেখানে Itanium C++ ABI কিছু ক্ষেত্রে derived class-এর field বসাতে দেয় বলে জানা যায়।
Python (CPython): সবকিছুই object (Python কোর্সের পর্ব ০৫)। প্রতিটি object-এর শুরুতে অন্তত একটি reference-গণনা আর type-এর pointer: ৬৪-বিট build-এ ১৬ byte. তার ওপর মান। sys.getsizeof শুধু object-টির নিজের মাপ বলে, সে যাদের দিকে pointer রাখে তাদেরটা নয় (Python documentation-এ এটিই বলা)। চালিয়ে দেখুন:
import sys, struct
from array import array
from dataclasses import dataclass
print("Python", sys.version.split()[0], "| pointer:", struct.calcsize("P"), "bytes")
print("int 0, 1040, 2**64:", sys.getsizeof(0), sys.getsizeof(1040), sys.getsizeof(2**64))
print("float, True, None :", sys.getsizeof(1.5), sys.getsizeof(True), sys.getsizeof(None))
@dataclass
class Order: # fields live in a per-object dict
status: str
total: int
qty: int
@dataclass(slots=True)
class OrderS: # fields live in fixed slots
status: str
total: int
qty: int
o, s = Order("P", 1040, 2), OrderS("P", 1040, 2)
print("Order object:", sys.getsizeof(o), "+ dict", sys.getsizeof(o.__dict__))
print("OrderS (slots):", sys.getsizeof(s))
# 1000 totals: a list of int objects vs one array of raw 8-byte values
N = 1000
as_list = [1000 + i for i in range(N)]
as_array = array("q", as_list)
print("list :", sys.getsizeof(as_list), "+ ints", sum(map(sys.getsizeof, as_list)))
print("array:", sys.getsizeof(as_array), "| itemsize", as_array.itemsize)
# reading only 'total' of N C-style Orders: which 64-byte cache lines?
def lines(stride, off, size=8):
return len({(k * stride + off + b) // 64 for k in range(N) for b in (0, size - 1)})
print("cache lines AoS (24-byte Order):", lines(24, 8))
print("cache lines SoA (totals array) :", lines(8, 0))আসল আউটপুট (ব্রাউজারের Python, ৩২-বিট WebAssembly):
Python 3.14.2 | pointer: 4 bytes
int 0, 1040, 2**64: 16 16 24
float, True, None : 16 16 8
Order object: 24 + dict 156
OrderS (slots): 28
list : 4428 + ints 16000
array: 8040 | itemsize 8
cache lines AoS (24-byte Order): 375
cache lines SoA (totals array) : 125
একই কোড লেখকের ল্যাপটপের ৬৪-বিট CPython 3.14.4-এ (সত্যিকারের run):
Python 3.14.4 | pointer: 8 bytes
int 0, 1040, 2**64: 28 28 36
float, True, None : 24 28 16
Order object: 48 + dict 296
OrderS (slots): 56
list : 8856 + ints 28000
array: 8080 | itemsize 8
cache lines AoS (24-byte Order): 375
cache lines SoA (totals array) : 125
দুই run পাশাপাশি পড়লে header-এর দাম স্পষ্ট। সবচেয়ে ছোট object None: শুধু header, ব্রাউজারে ৮ byte (৪ byte-এর reference-গণনা আর ৪ byte-এর type-pointer), ৬৪-বিটে ১৬. একটি ছোট int-এ তার ওপর অঙ্কের তথ্য: ১৬ বনাম ২৮ byte, অথচ C-তে একই মান ৮ byte-এর ঘরে। Order: সাধারণ dataclass-এর object নিজে ছোট (২৪ বা ৪৮), কারণ field-গুলো আলাদা একটি dict-এ, যা নিজেই আরও ১৫৬ বা ২৯৬ byte; slots=True-এ dict নেই, field-এর তিনটি pointer object-এর ভেতরে, তাই object একটু বড় (২৮ বা ৫৬) কিন্তু মোটের হিসাবে অনেক ছোট। আর কোনো সংখ্যাতেই "P" বা 1040-এর নিজের object ধরা নেই, কারণ getsizeof pointer ধরে এগোয় না। ১০০০টি total: list-এ প্রতি উপাদানে একটি pointer (৪ বা ৮ byte) আর আলাদা একটি int object (১৬ বা ২৮), মোট প্রায় ২০ বা ৩৭ হাজার byte; array('q') দুই জগতেই প্রায় ৮ হাজার, কারণ সেখানে কাঁচা ৮ byte-এর মান পাশাপাশি, ঠিক C-র array-র মতো। শেষ দুই লাইন শুধু গোনা, তাই দুই জগতে এক: শুধু total পড়ার loop AoS-এ ৩৭৫টি আর SoA-তে ১২৫টি ৬৪ byte-এর cache line ছোঁয় (অংশ ৭)। সংখ্যাগুলো CPython-এর version আর build-এর ওপর নির্ভর করে; নিজের যন্ত্রে চালিয়ে মিলিয়ে নিন।
Java: এখানে কিছু চালানো হয়নি, তাই শুধু প্রচলিত তথ্য, সতর্কভাবে। ৬৪-বিট HotSpot JVM-এ compressed class pointer চালু থাকলে (সাধারণ ডিফল্ট) প্রতিটি object-এর header সাধারণত ১২ byte: ৮ byte-এর “mark word” (hash, lock, GC-র তথ্য) আর ৪ byte-এর class pointer; আর object-এর মাপ ৮-এর গুণিতকে গোল হয়। ফলে একটি Integer ১৬ byte, যেখানে int মাত্র ৪. JDK 24-এ পরীক্ষামূলক আর JDK 25-এ পূর্ণ বৈশিষ্ট্য হিসেবে “compact object headers” (JEP 450, JEP 519) header ৮ byte-এ নামানোর সুযোগ এনেছে বলে জানা যায়। Field-এর বিন্যাস JVM নিজে ঠিক করে, ভাষা কোনো ক্রম নিশ্চিত করে না; নিজের JVM-এ মাপ দেখতে OpenJDK-র JOL (Java Object Layout) tool আছে। JVM-এর মেমরির বাকি গল্প Java কোর্সের পর্ব ৪৪-এ.
এই অংশের মূল কথা boxing: একটি primitive মানকে header-ওয়ালা object-এ মোড়ানো। Boxing-এর বদলে পাওয়া যায় পরিচয় (identity), dynamic type, GC-র সহজ কাজ আর একই list-এ যেকোনো মান রাখার স্বাধীনতা। দাম মেমরি আর একটি বাড়তি pointer-লাফ। তাই প্রায় প্রতিটি managed ভাষা “কাঁচা মানের সারি”-র একটি পথ রাখে: Python-এর array আর NumPy, Java-র int[], JavaScript-এর typed array. Haat-এর reference interpreter Python-এ লেখা, তাই সেখানে প্রতিটি Haat Int আসলে একটি Python int object; পর্ব ৭২-এর native back end-এ সেটি হবে একটি ৮ byte-এর ঘর।
আরও গভীরে: Clang-এ record layout হিসাব হয় AST স্তরে (RecordLayoutBuilder), আর Microsoft-এর ABI-র জন্য সেখানে আলাদা নিয়ম আছে, কারণ MSVC-র layout কিছু ক্ষেত্রে (virtual base, bit-field, zero-size field) Itanium ABI থেকে আলাদা; এর একটি ঝলক আপনি -fdump-record-layouts-এ দেখলেন। Bit-field-এর layout C standard-এ প্রায় পুরোটাই implementation-defined, তাই hardware register বা ফাইল-ফরম্যাটের জন্য bit-field-এ নির্ভর করা ঝুঁকিপূর্ণ। আর Rust-এর compiler “niche” কৌশলে Option<&T>-কে একটি সাধারণ pointer-এর সমান মাপে রাখে, কারণ null ঠিকানা কখনো বৈধ reference নয়, তাই সেটিকেই None-এর চিহ্ন বানানো যায়; পর্ব ২৪-এর (Algebraic data type) tag-এর ধারণার একটি চতুর বাস্তবায়ন।
পরীক্ষা ও ইন্টারভিউতে: বিশ্ববিদ্যালয়, চাকরি বা ইন্টারভিউর পরীক্ষায় এই ধরনের প্রশ্ন প্রায়ই আসে:
struct { char a; int b; char c; }-এর sizeof? সাধারণ ৩২/৬৪-বিট target-এ ১২: a 0-তে, ৩ byte padding, b 4-এ, c 8-এ, শেষে ৩ byte. সাজালে (int, char, char) ৮.- Tail padding কেন? Array-র প্রতিটি উপাদান যেন ঠিক alignment-এ শুরু হয়; sizeof সবসময় alignment-এর গুণিতক।
- Little আর big endian-এ 0x12345678? Little:
78 56 34 12; big:12 34 56 78(ছোট ঠিকানা থেকে)। - Packed struct-এর অসুবিধা? ভুল-ঠিকানার access: কিছু CPU-তে ধীর বা trap, আর field-এর pointer নেওয়া বিপজ্জনক; সঙ্গে ABI-র সঙ্গে অমিল।
- C compiler কি field-এর ক্রম বদলাতে পারে? না, ঘোষণার ক্রম বাধ্যতামূলক; Rust-এর সাধারণ struct-এ পারে,
#[repr(C)]-এ পারে না।
৯ · AI-এর যুগে memory layout
Layout-এর প্রশ্নে AI assistant-এর উত্তর শুনতে খুব নিশ্চিত লাগে, কারণ সংখ্যাগুলো ছোট আর হিসাব সরল মনে হয়। কিন্তু উত্তর নির্ভর করে target-এর ওপর, আর সেই তথ্য প্রশ্নে প্রায়ই থাকে না। বারবার দেখা ভুল:
| AI-এর ভুল | কীভাবে ধরবেন |
|---|---|
| Field-এর মাপ যোগ করে sizeof বলা, padding ভুলে | Clang-এ sizeof, offsetof ছাপানো বা -fdump-record-layouts |
| Tail padding ভুলে যাওয়া (১৮ বলা, যেখানে ২৪) | Array-র উপাদানের দূরত্ব ছাপিয়ে দেখা; Python-এ 0q কৌশল |
| এক target-এর সংখ্যা সবখানে চাপানো (“int64 সবসময় ৮-এ align”) | -target বদলে একই কোড; i386 Linux আর Windows x86 তুলনা |
| “C compiler নিজে field সাজিয়ে মাপ কমায়” | C17 §6.7.2.1 পড়া; offsetof-এর ক্রম দেখা |
| Packed struct-কে “বিনা দামে ছোট” বলা | RISC-V-র জন্য -O2 -S দেখা; -Waddress-of-packed-member |
| Endianness গুলিয়ে byte-এর তালিকা উল্টো লেখা | struct.pack('<i') আর '>i' চালিয়ে মেলানো |
| Python বা Java object-এর মাপ নিয়ে নির্দিষ্ট সংখ্যা, version আর build না বলে | নিজের version-এ sys.getsizeof বা JOL; ৩২ আর ৬৪-বিট আলাদা রাখা |
AI-কে ভালোভাবে কাজে লাগানোর উপায়: target triple, compiler আর version বলে দেওয়া; প্রতিটি offset-এর হিসাব অ্যালগরিদমের ধাপসহ চাওয়া; আর যাচাইয়ের কোড নিজে চালানো।
AI-এর উত্তর হাতে পেলে — যাচাইয়ের চেকলিস্ট
ভাবনার প্রশ্ন
প্রতিটি প্রশ্ন নিয়ে নিজে কিছুক্ষণ ভাবুন, তারপর “→ উত্তর” চাপুন।
প্র ০১C কেন compiler-কে struct-এর field সাজাতে দেয় না, আর Rust কেন দেয়? দুটি সিদ্ধান্তের দাম কী?
C-র জন্ম ১৯৭০-এর দশকের শুরুতে, Unix লেখার ভাষা হিসেবে। সেখানে struct প্রায়ই সরাসরি বাইরের কোনো বিন্যাসের ছবি: disk-এর directory entry, device-এর register, নেটওয়ার্ক packet-এর header. প্রোগ্রামার চান যা লিখেছেন, মেমরিতে ঠিক সেই ক্রমে থাকুক। এর ওপর একটি প্রচলিত কৌশল দাঁড়িয়ে আছে: দুটি struct-এর শুরুর field এক রাখলে একটির pointer দিয়ে অন্যটির শুরুর অংশ পড়া যায় (একরকম হাতে-বানানো inheritance), আর প্রথম field-এর ঠিকানাই struct-এর ঠিকানা। C standard এই দুই অভ্যাসকে নিয়মে বেঁধেছে: ঘোষণার ক্রমে বাড়তে থাকা ঠিকানা, আর শুরুতে কোনো ফাঁক নেই। ফলে layout অনুমানযোগ্য, আর এক compiler-এর বানানো library অন্য compiler-এর program-এর সঙ্গে চলে, যদি দুজন একই ABI মানে।
দাম হলো জায়গা আর দায়িত্ব। প্রতিটি struct-এ ক্রম ঠিক রাখার দায় প্রোগ্রামারের, আর পড়ার সুবিধার জন্য সাজানো ক্রম (সম্পর্কিত field পাশাপাশি) প্রায়ই মাপের দিক থেকে খারাপ। তাই বড় C কোডে -Wpadded বা pahole দিয়ে নিয়মিত ফাঁক খোঁজার চর্চা আছে।
Rust অন্য পথ নেয়: সাধারণ struct-এর layout অনির্দিষ্ট (“repr(Rust)”), তাই compiler চাইলে field সাজাতে পারে (২০১৭ সালের দিকে Rust 1.18 থেকে সত্যিই সাজায় বলে জানা যায়), আর ভবিষ্যতে আরও চালাক কৌশল যোগ করার স্বাধীনতাও রাখে। নিরাপদ Rust কোড কখনো offset-এর ওপর নির্ভর করতে পারে না, তাই এই স্বাধীনতায় কারও অর্থ ভাঙে না। যেখানে চুক্তি দরকার, সেখানে প্রোগ্রামার স্পষ্ট লেখেন: #[repr(C)] C-র নিয়ম চায়, #[repr(packed)] ফাঁক বন্ধ করে, #[repr(transparent)] একটি field-এর মোড়ককে ভেতরের field-এর সমান layout দেয়। দাম হলো দুই জগতের সীমানায় সতর্কতা: C-র সঙ্গে কথা বলার সময় একটি repr(C) ভুলে গেলে ভুলটি compile-এ ধরা না-ও পড়তে পারে।
Swift-এর মতো ভাষা আরও এক ধাপ এগিয়ে library-র সীমানায় “resilience” রাখে বলে জানা যায়: library-র struct-এর layout বাইরে থেকে লুকানো থাকতে পারে, যাতে নতুন version-এ field যোগ করলে পুরোনো program না ভাঙে। এটি অংশ ৬-এর ABI-সমস্যার ভাষা-স্তরের সমাধান, বিনিময়ে কিছু ক্ষেত্রে পরোক্ষ access-এর খরচ।
মূল উপলব্ধি: layout হয় চুক্তি, নয় বাস্তবায়নের খুঁটিনাটি। C সব struct-কে চুক্তি ধরে, Rust ডিফল্টে খুঁটিনাটি ধরে আর চুক্তি চাইতে হয় স্পষ্ট করে। কোনটি ভালো, তা নির্ভর করে ভাষাটি কতটা বাইরের জগতের সঙ্গে byte ভাগ করে।
প্র ০২Little-endian আর big-endian দুটিই কেন টিকে আছে? “ঠিক” ক্রম বলে কিছু আছে কি?
দুই ক্রমেরই যুক্তিসংগত সুবিধা আছে, আর ইতিহাস দুটিকেই বড় বড় যন্ত্রে বসিয়ে দিয়েছে। Big-endian মানুষের লেখার ক্রম: memory dump পড়লে সংখ্যা সোজা দেখা যায়, আর দুটি সংখ্যা byte ধরে বাঁ থেকে তুলনা করলেই বড়-ছোট বোঝা যায়। IBM-এর System/360 (১৯৬০-এর দশক) আর তার উত্তরসূরি mainframe, Motorola 68000, SPARC আর পুরোনো PowerPC এই পথে গিয়েছিল। Little-endian-এর সুবিধা যন্ত্রের দিকে: একটি সংখ্যার ঠিকানা থেকে ছোট অংশ আগে পাওয়া যায়, তাই ৩২-বিট মানের ঠিকানায় দাঁড়িয়েই তার নিচের ১৬ বা ৮ বিট একই ঠিকানা থেকে পড়া যায়, আর যোগের carry ছোট byte থেকে বড় দিকে যায় বলে পুরোনো ৮-বিট যন্ত্রে byte-এর পর byte যোগ সহজ ছিল। Intel-এর x86 পরিবার এই পথে, আর PC-র জগতে তার সাফল্য little-endian-কে সবচেয়ে প্রচলিত করে দিয়েছে।
Danny Cohen ১৯৮০ সালের প্রবন্ধে ঠিক এটাই বলেন: কোনো ক্রম মৌলিকভাবে শ্রেষ্ঠ নয়; সমস্যা হলো দুই ক্রমের যন্ত্র যখন কথা বলে। ইন্টারনেট সেই প্রশ্নের উত্তর দিয়েছে একটি চুক্তি দিয়ে: IP, TCP আর UDP-র header-এর সংখ্যা big-endian, যার নাম network byte order. তাই C-র socket API-তে htonl আর ntohl (host থেকে network ক্রমে আর উল্টো), যা big-endian যন্ত্রে কিছুই করে না আর little-endian-এ byte উল্টায়।
আজকের ঝোঁক স্পষ্টতই little-endian-এর দিকে। ARM দুই ক্রমেই চলতে পারে (bi-endian), কিন্তু Linux আর Android-এর প্রচলিত রূপ little-endian; RISC-V মূলত little-endian হিসেবে নকশা করা; এমনকি PowerPC-র জগতে ৬৪-বিট Linux-এর একটি বড় অংশ little-endian (ppc64le)-এ সরে গেছে বলে জানা যায়। WebAssembly-র মেমরি নিয়ম অনুযায়ী little-endian. তবু big-endian মরেনি: s390x mainframe, নেটওয়ার্ক protocol আর অনেক ফাইল-ফরম্যাট (যেমন PNG-এর ভেতরের সংখ্যা) এখনো সেই ক্রমে।
ভাষা-নকশার শিক্ষা হলো, এক যন্ত্রের ভেতরে byte-ক্রম লুকিয়ে রাখা যায়, কিন্তু সীমানায় স্পষ্ট করতেই হয়। Python-এর struct-এর < আর >, JavaScript-এর DataView-এর littleEndian parameter, Java-র ByteBuffer.order() (যার ডিফল্ট big-endian) সবই একই নীতির রূপ।
মূল উপলব্ধি: endianness একটি রীতি, সত্য নয়; বিপদ আসে যখন byte এক রীতি থেকে অন্য রীতিতে যায় অথচ কেউ সেটি লেখে না। তাই সীমানায় byte-ক্রম সবসময় স্পষ্ট লিখুন।
প্র ০৩নেটওয়ার্কের header পড়তে struct-এর pointer cast করা এত প্রচলিত, তবু কেন বিপজ্জনক? নিরাপদ বিকল্প কী?
কৌশলটি লোভনীয়: packet-এর byte একটি buffer-এ এসেছে, আর header-এর বিন্যাসের মতো একটি struct ঘোষণা করে buffer-এর ঠিকানাকে সেই struct-এর pointer বানিয়ে নিলেই field ধরে পড়া যায়, কোনো কপি ছাড়াই। বহু পুরোনো নেটওয়ার্ক কোড এভাবেই লেখা। কিন্তু এতে অন্তত চারটি আলাদা ফাঁদ একসঙ্গে লুকিয়ে থাকে।
Padding: struct-এর layout compiler আর ABI-র, packet-এর বিন্যাস protocol-এর। অংশ ৪-এর মতো ১১ byte-এর বিন্যাসে compiler ২৪ byte বানালে প্রতিটি field ভুল offset থেকে আসবে; তাই এই কোড প্রায়ই packed struct চায়। Alignment: buffer-এর শুরু যেকোনো ঠিকানায় হতে পারে, আর packet-এর ভেতরের field-ও; C-তে ভুল-ঠিকানার pointer দিয়ে পড়া undefined behavior, x86-এ চললেও অন্য CPU-তে trap বা অদ্ভুত ফল। Endianness: নেটওয়ার্কের সংখ্যা big-endian, তাই প্রতিটি সংখ্যা উল্টাতে মনে রাখতে হয়; একটি ভুলে গেলে অংশ ৫-এর 268697600-এর মতো সংখ্যা। Aliasing নিয়ম: C-র “effective type” নিয়ম (strict aliasing) অনুযায়ী একটি char-এর buffer-কে অন্য type-এর object হিসেবে পড়া নিয়মের বাইরে যেতে পারে, আর optimizer সেই অনুমানে কোড বদলাতে পারে।
নিরাপদ বিকল্প হলো layout আর byte-ক্রম দুটিই কোডে স্পষ্ট করা: প্রতিটি field-এর জন্য buffer-এর নির্দিষ্ট offset থেকে byte পড়ে shift দিয়ে সংখ্যা বানানো, অথবা memcpy দিয়ে একটি স্থানীয় variable-এ কপি করে তারপর byte-ক্রম ঠিক করা। দেখতে বেশি কাজ মনে হয়, কিন্তু আধুনিক compiler প্রায়ই এমন কোড চিনে ফেলে একটি load আর একটি byte-উল্টানো নির্দেশে নামিয়ে আনে বলে জানা যায়। উচ্চস্তরের ভাষাগুলো এই পথটিই সহজ করেছে: Python-এর struct.unpack_from('>q', buf, 1), JavaScript-এর DataView, Rust-এর i64::from_be_bytes. আর বড় পরিসরে, Protocol Buffers-এর মতো serialization ফরম্যাট বিন্যাসটি একটি আলাদা বিবরণ থেকে কোড তৈরি করে, যাতে কেউ হাতে offset না গোনে।
এখানে Haat-এর একটি নকশা-শিক্ষাও আছে: Haat-এ pointer বা cast নেই, তাই এই ধরনের কোড লেখাই যায় না। বাইরের byte পড়তে হলে ভাষাকে স্পষ্ট function দিতে হবে (যেমন একটি কল্পিত read_be_i64(bytes, 1)), যার আচরণ সব যন্ত্রে এক।
মূল উপলব্ধি: বাইরের বিন্যাস আর ভাষার layout দুটি আলাদা চুক্তি; pointer cast দুটিকে এক ধরে নেয়। নিরাপদ কোড সীমানায় অনুবাদ করে, ধরে নেয় না।
প্র ০৪Python আর Java-তে ছোট একটি সংখ্যাও কেন এত বড়? এই নকশার যুক্তি কী, আর ভাষাগুলো দাম কমাতে কী করছে?
কারণ সেখানে একটি সংখ্যা শুধু সংখ্যা নয়, একটি object. CPython-এ প্রতিটি object-এর শুরুতে reference-এর গণনা আর type-এর pointer; ছোট int-এর জন্য তার ওপর অঙ্কের সংখ্যা আর অঙ্ক নিজে। এই header দিয়েই CPython জানে কখন object মুছতে হবে (reference counting, পর্ব ১৬-এর আলোচনা) আর x + y-এ কোন যোগ চালাতে হবে (dynamic typing). একটি list তাই আসলে pointer-এর সারি, আর প্রতিটি pointer আলাদা object-এ যায়; এই পর্বের run-এ ১০০০টি সংখ্যার list ৬৪-বিট CPython-এ list নিজে প্রায় ৮.৮ হাজার byte আর সংখ্যাগুলো আরও ২৮ হাজার, যেখানে array('q') প্রায় ৮ হাজারে সব রাখে।
Java-তে int একটি কাঁচা ৪ byte, কিন্তু generic collection-এ রাখতে হলে Integer object লাগে (generics-এর erasure-এর কারণে, পর্ব ৩৭-এ)। প্রতিটি object-এর header-এ mark word (hash, lock, GC-র বয়স) আর class pointer. এই header-এর বিনিময়ে Java পায় প্রতিটি object-এ synchronized, hashCode আর চলার সময়ের type পরীক্ষা।
দাম কমানোর চেষ্টা কয়েক দিকে। ছোট header: HotSpot-এর compressed pointer, আর সাম্প্রতিক compact object headers (JEP 450, পরে JEP 519) header ১২ থেকে ৮ byte-এ নামায় বলে জানা যায়। Boxing এড়ানো: Java-র Project Valhalla “value class” আনতে কাজ করছে, যাদের identity নেই, তাই JVM সেগুলো header ছাড়া সমতল করে রাখতে পারবে; এটি দীর্ঘদিন ধরে চলমান প্রকল্প, চূড়ান্ত রূপ নিয়ে সতর্ক থাকা ভালো। Python-এ __slots__ প্রতিটি object-এর dict সরিয়ে দেয়, আর CPython-এর সাম্প্রতিক version-গুলো object-এর ভেতরের মান রাখার কৌশল বারবার বদলেছে, তাই getsizeof-এর সংখ্যা version-ভেদে বদলায়। সমতল সারি: NumPy, array, Java-র primitive array, JavaScript-এর typed array: সংখ্যার ভারী কাজ কাঁচা মানের সারিতে।
ভাষা-নকশার চোখে এটি একটি পরিষ্কার আপস। একরূপ object (সবকিছু একই রকম header-ওয়ালা) runtime-কে সরল রাখে: GC, dynamic dispatch, debugger সবাই একই নিয়ম জানে। দাম মেমরি আর cache: অংশ ৭-এর হিসাবের মতোই, header আর pointer-এর প্রতিটি byte কাজের ডেটার জায়গা নেয়।
মূল উপলব্ধি: managed ভাষার object-এর মাপের বড় অংশ runtime-এর জন্য, প্রোগ্রামের ডেটার জন্য নয়। এটি ভুল নয়, একটি বেছে নেওয়া দাম; আর ভারী সংখ্যার কাজে কাঁচা সারি ব্যবহার করে সেই দাম এড়ানো যায়।
প্র ০৫Compiler কেন নিজে array of structs-কে struct of arrays বানিয়ে দেয় না? ভাষা কীভাবে সাহায্য করতে পারে?
রূপান্তরটি কাগজে সহজ: orders[k].total-কে totals[k] বানানো। কিন্তু compiler-কে প্রমাণ করতে হবে যে program-এর কোনো অংশ পুরোনো layout-এর ওপর নির্ভর করে না। C বা C++-এ সেটি প্রায় অসম্ভব। কেউ &orders[k] নিয়ে অন্য function-এ পাঠাতে পারে, যা সেই pointer থেকে +8 করে total পড়ে; কেউ পুরো array memcpy করে ফাইলে লিখতে পারে; কোনো library-র ABI ঠিক এই layout আশা করতে পারে। একটি pointer যদি “পালিয়ে” যায় (escape), compiler আর জানে না কে কীভাবে পড়বে। গবেষণায় whole-program বিশ্লেষণ দিয়ে কিছু ক্ষেত্রে struct ভাঙা বা field সাজানোর চেষ্টা হয়েছে বলে জানা যায়, কিন্তু সাধারণ compiler-এ এটি সীমিত।
গেম-ইঞ্জিনের জগতে এই সমস্যা হাতে সমাধান হয়ে আসছে: হাজার হাজার বস্তুর ওপর প্রতি frame-এ একই কাজ, তাই layout-এ ভুল বড় দাম নেয়। Mike Acton-এর CppCon ২০১৪-এর বক্তৃতার মতো আলোচনা “data-oriented design”-কে জনপ্রিয় করে বলে জানা যায়; Entity-Component-System-এর মতো স্থাপত্য মূলত SoA-র একটি রূপ। ডেটাবেসেও একই গল্প: row-store (AoS) লেনদেনে ভালো, column-store (SoA) বিশ্লেষণে।
ভাষা সাহায্য করতে পারে layout-কে অর্থ থেকে আলাদা করে। যদি ভাষা প্রোগ্রামারকে কোনো element-এর ঠিকানা দেখতে না দেয় (Java, Haat), তাহলে runtime বা compiler-এর হাতে layout বদলানোর স্বাধীনতা থাকে, যেমন JVM field-এর ক্রম নিজে ঠিক করে। আরেক পথ হলো লেখার ধরন AoS-এর মতো রেখে ভেতরে SoA: Zig-এর MultiArrayList এমন একটি library-সমাধান, আর Intel-এর ISPC-এর মতো কিছু ভাষা SoA-কে type-এর অংশ করার চেষ্টা করেছে বলে জানা যায়।
Haat-এর বর্ধিত রূপের জন্য শিক্ষা হলো: Haat-এ pointer নেই, তাই [Order]-এর layout প্রোগ্রাম থেকে অদৃশ্য। একটি ভবিষ্যৎ Haat compiler চাইলে [Order]-কে ভেতরে SoA হিসেবে রাখতে পারে, কোনো প্রোগ্রামের অর্থ না বদলে। কিন্তু কখন সেটি লাভজনক, তা নির্ভর করবে loop কোন field পড়ে তার ওপর, যা profile বা বিশ্লেষণ ছাড়া জানা কঠিন।
মূল উপলব্ধি: layout বদলানোর স্বাধীনতা আসে layout লুকানো থেকে। যে ভাষা ঠিকানা দেখায়, তার compiler হাত-পা বাঁধা; যে ভাষা লুকায়, তার compiler চাইলে ডেটা নতুন করে সাজাতে পারে।
অনুশীলন
প্রথমে নিজে করুন, তারপর উত্তর খুলে মেলান। প্রতিটি সংখ্যা Clang 22.1.8-এর -fdump-record-layouts বা Python-এর struct দিয়ে চালিয়ে মেলানো।
-
নকশা ও বাস্তবায়ন — Haat record-এর layout নীতি: Haat-এর বর্ধিত রূপে
record Payment { kind: Bool, amount: Int, ok: Bool }. (ক) ঘোষণার ক্রমে আর সাজানো নীতিতে প্রতিটি field-এর offset আর মোট মাপ বের করুন (Bool ১ byte, Int ৮ byte, align নিজের মাপ)। (খ) C-র সঙ্গে ডেটা ভাগের জন্য একটি চিহ্ন প্রস্তাব করুন (যেমন@c record …), আর অংশ ২-এরlayout()function কীভাবে বদলাবে লিখুন। (গ) কেন সাজানো নীতি Haat v1-এর কোনো প্রোগ্রামের অর্থ বদলায় না, এক অনুচ্ছেদে যুক্তি দিন।(ক) ঘোষণার ক্রমে: kind 0, amount align_up(1, 8) = 8 (৭ byte ফাঁক), ok 16, শেষ align_up(17, 8) = 24. সাজানো (amount, kind, ok): amount 0, kind 8, ok 9, শেষ align_up(10, 8) = 16. Clang-এ সমান C struct (
bool kind; int64_t amount; bool ok;আর সাজানো রূপ) x86-64-এ ২৪ আর ১৬ দিয়েছে, offset একই।def layout(fields, sort=False, c_order=False): if sort and not c_order: # @c records keep declaration order fields = sorted(fields, key=lambda f: -C[f[1]][1]) ... # the rest of Algorithm 25.1 unchanged record Payment -> amount@0 kind@8 ok@9, size 16 @c record Payment -> kind@0 amount@8 ok@16, size 24(খ)
@c-চিহ্নিত record-এ compiler ঘোষণার ক্রম রাখবে আর target-এর C ABI-র মাপ-alignment ব্যবহার করবে; Type checker-কে এমন record-এর field-এর type C-তে প্রকাশযোগ্য কি না পরীক্ষাও করতে হবে (যেমন Str বা function type-এর সরাসরি C-রূপ নেই)।sortedএকটি stable sort, তাই একই alignment-এর field-এর আপেক্ষিক ক্রম বদলায় না; এতে layout নির্ধারিত (deterministic) থাকে, যা আলাদা আলাদা compile-এর মধ্যে মিল রাখতে জরুরি।(গ) Haat v1-এ কোনো expression মেমরির ঠিকানা, offset বা byte দেখায় না: pointer নেই, cast নেই,
sizeofনেই। Field পড়া হয় শুধু নাম দিয়ে (p.amount), আর নাম থেকে offset-এর হিসাব compiler নিজে করে। তাই দুটি layout-এর অধীনে একই প্রোগ্রামের প্রতিটিprintএকই মান ছাপে; পার্থক্য শুধু মেমরির পরিমাণে। Evaluation order (নকশা-সিদ্ধান্ত ১২)-ও layout-এর ওপর নির্ভর করে না: record literal-এর field-গুলো source-এ লেখা ক্রমে মূল্যায়িত হবে, মেমরিতে যে ক্রমেই বসুক। -
প্রমাণ — সাজানো ক্রম সবচেয়ে ছোট: ধরুন প্রতিটি field-এর alignment ২-এর ঘাত, আর প্রতিটি মাপ নিজের alignment-এর গুণিতক। প্রমাণ করুন: field-গুলো alignment-এর বড় থেকে ছোট ক্রমে সাজালে অ্যালগরিদম ২৫.১ মাঝে কোনো padding দেয় না, আর ফলের মাপ যেকোনো বৈধ layout-এর মধ্যে সবচেয়ে ছোট।
ধরুন সাজানো field f1, …, fn, alignment a1 ≥ a2 ≥ … ≥ an, মাপ si, আর S = s1 + … + sn, A = a1 (সবচেয়ে বড় alignment).
- দাবি: fk-এর offset ঠিক s1 + … + sk−1, অর্থাৎ কোনো ফাঁক নেই। k-এর ওপর induction. k = 1: offset 0, দাবি সত্য।
- ধরুন f1 … fk−1 পর্যন্ত সত্য; তাহলে off = s1 + … + sk−1. প্রতিটি j < k-এর জন্য sj হলো aj-এর গুণিতক, আর aj ≥ ak; দুটিই ২-এর ঘাত, তাই ak ভাগ করে aj-কে, ফলে ak ভাগ করে sj-কে। তাই ak ভাগ করে off-কে, আর align_up(off, ak) = off: ফাঁক শূন্য।
- সুতরাং শেষে off = S, আর মাপ = align_up(S, A).
- সর্বনিম্নতা: যেকোনো বৈধ layout-এ field-গুলো আলাদা আলাদা byte নেয়, তাই মাপ ≥ S; আর record-এর alignment A হলে মাপ A-এর গুণিতক (অংশ ২-এর array-যুক্তি)। S-এর সমান বা বড় A-এর সবচেয়ে ছোট গুণিতক হলো align_up(S, A). তাই কোনো layout এর চেয়ে ছোট হতে পারে না। ∎
যাচাই: Order-এ S = ১১, A = ৮, align_up = ১৬, সাজানো রূপের আসল মাপ; Delivery {char, double, short, int32, char}-এ S = ১৬, A = ৮, সাজানো মাপ ১৬ (Clang). শর্ত দুটি সাধারণ C type-এ সত্য, এমনকি i386 Linux-এর
int64_t-তেও (মাপ ৮, alignment ৪, আর ৮ হলো ৪-এর গুণিতক)। Array field-ও শর্ত মানে, কারণT[n]-এর মাপ n × sizeof(T) আর alignment T-এর। ধাপ ২-এর “ভাগ করে” যুক্তিটিই শর্ত দুটির ওপর দাঁড়িয়ে। -
ভুল খুঁজুন: একজন নেটওয়ার্ক থেকে আসা ১১ byte-এর অর্ডার (status, তারপর big-endian ৮ byte-এর total, তারপর qty) পড়তে লিখেছেন:
x86-64 Linux-এ ঠিক কোন byte পড়া হবে, আর কতগুলো আলাদা ভুল আছে? একটি সঠিক রূপ লিখুন।struct Order { char status; int64_t total; short qty; }; int64_t read_total(const unsigned char *buf) { const struct Order *o = (const struct Order *)buf; return o->total; }কোন byte: struct-এ total-এর offset 8 (padding-এর কারণে), তাই কোড পড়ে buf[8] থেকে buf[15]. কিন্তু buffer মাত্র ১১ byte: buf[11]–buf[15] buffer-এর বাইরে, অর্থাৎ সীমার বাইরে পড়া। আর আসল total আছে buf[1]–buf[8]-এ।
চারটি আলাদা ভুল: (১) offset: struct-এর layout (total 8-এ) wire-বিন্যাস (total 1-এ) নয়। (২) সীমা: struct ২৪ byte, buffer ১১. (৩) endianness: wire-এ big-endian, x86-64 little-endian; offset ঠিক হলেও মান উল্টো আসত (অংশ ৫-এর 268697600-এর মতো)। (৪) alignment ও aliasing:
buf৮-এর গুণিতকে শুরু হবে এমন নিশ্চয়তা নেই, আর char-buffer-কেstruct Orderহিসেবে পড়া C-র effective-type নিয়মের বাইরে; দুটিই undefined behavior. শুধুpackedকরলে (১) আর (২) মেটে, (৩) আর (৪)-এর একটি অংশ থেকে যায়।int64_t read_total(const unsigned char *buf) { /* big-endian, offset 1 */ uint64_t v = 0; for (int k = 1; k <= 8; k++) v = (v << 8) | buf[k]; return (int64_t)v; } ~/haat $ zig cc -std=c17 -Wall -Wextra fix.c -o fix.exe && ./fix.exe 1040সত্যিকারের run (Clang 22.1.8): buffer
50 00 00 00 00 00 00 04 10 00 02থেকে সঠিক 1040. এই কোডে offset, সীমা, byte-ক্রম আর alignment চারটিই স্পষ্ট, আর এটি যেকোনো target-এ একই ফল দেয়। -
হিসাব করুন:
struct Delivery { char zone; double fee; short days; int32_t id; char paid; };(ক) x86-64 Linux-এ প্রতিটি offset আর sizeof. (খ) i386 Linux-এ (double-এর struct-ভেতরের alignment ৪)। (গ) x86-64-এ সবচেয়ে ছোট মাপের জন্য field-এর ক্রম। (ঘ)days = 2026হলে little-endian মেমরিতে তার দুটি byte.(ক) zone 0; fee align_up(1, 8) = 8 (৭ ফাঁক); days 16; id align_up(18, 4) = 20 (২ ফাঁক); paid 24; শেষ align_up(25, 8) = 32 (৭ ফাঁক)। ১৬ byte ডেটা, ১৬ byte padding.
(খ) zone 0; fee align_up(1, 4) = 4; days 12; id 16; paid 20; শেষ align_up(21, 4) = 24.
(গ) fee, id, days, zone, paid: offset 0, 8, 12, 14, 15; মাপ 16, কোনো padding নেই (S = ১৬ ইতিমধ্যে ৮-এর গুণিতক)। অনুশীলন ২ অনুযায়ী এটিই সর্বনিম্ন।
(ঘ) 2026 = 0x07EA, তাই little-endian-এ
ea 07(ছোট ঠিকানায় 0xEA). Big-endian হলে07 ea.(ক), (খ), (গ)-এর সব সংখ্যা Clang-এর
-fdump-record-layouts-এ x86_64-linux-musl আর x86-linux-musl target-এ হুবহু মিলেছে; (ঘ) Python-এর(2026).to_bytes(2, "little")দিয়ে।
নিজেকে যাচাই করুন
ভুল হলে কারণসহ ব্যাখ্যা পাবেন, আবার চেষ্টাও করতে পারবেন।
ক্রমC compiler একটি struct-এর layout হিসাব করার ধাপগুলো সঠিক ক্রমে সাজান (▲▼ চেপে সরান)
- Target-এর ABI থেকে প্রতিটি field-এর মাপ আর alignment জানা
- বর্তমান offset শূন্য আর struct-এর alignment এক ধরে শুরু করা
- ঘোষণার ক্রমে প্রতিটি field-কে তার alignment-এর পরের গুণিতকে বসানো
- সবচেয়ে বড় alignment-কে struct-এর alignment হিসেবে রাখা
- শেষের offset-কে struct-এর alignment-এর গুণিতকে গোল করে sizeof পাওয়া
x86-64 Linux-এ struct S { char a; int b; char c; };-এর sizeof কত?
- 6
- 9
- 12
- 24
struct Order { char status; int64_t total; short qty; }; x86-64-এ ২৪ byte. Field-গুলোর ক্রম বদলে সবচেয়ে ছোট কত byte করা যায়, packed না করে?
- 11
- 16
- 24, ক্রমে কিছু যায় আসে না
- 12
একটি ৪ byte-এর পূর্ণসংখ্যা 0x12345678 big-endian যন্ত্রে ঠিকানা a থেকে a+3-এ কোন ক্রমে থাকে?
- 78 56 34 12
- 87 65 43 21
- 56 78 12 34
- 12 34 56 78
Python-এ struct.calcsize("@bqh") x86-64-এ ১৮ দেয়, অথচ সমান C struct {char; int64_t; short;}-এর sizeof ২৪. কেন?
structmodule শেষে tail padding যোগ করে না@মানে padding ছাড়া packed বিন্যাস- Python-এ
q৪ byte-এর - C compiler-এর ভুল, আসল মাপ ১৮
একটি packed struct-এ int64_t field offset 1-এ আছে। সাধারণ riscv64 target-এর জন্য Clang -O2-এ field-টি পড়তে কী করে?
- একটি সাধারণ
ldনির্দেশ, x86-64-এর মতোই - Compile error দেয়, কারণ packed struct বৈধ নয়
- আটটি আলাদা byte পড়ে shift আর or দিয়ে জোড়া লাগায়
- আগে পুরো struct একটি aligned জায়গায় কপি করে
কোন বক্তব্যটি সঠিক?
- C compiler জায়গা বাঁচাতে struct-এর field নিজে সাজাতে পারে
- Rust-এর সাধারণ struct-এ compiler field সাজাতে পারে, কিন্তু
#[repr(C)]দিলে ঘোষণার ক্রম থাকে - int64_t-এর alignment সব ABI-তে ৮
- Java field-গুলোকে ঘোষণার ক্রমে মেমরিতে রাখার নিশ্চয়তা দেয়
শব্দকোষ
লেখার মধ্যে ডটেড দাগ দেওয়া শব্দে মাউস রাখুন বা চাপুন — অর্থ দেখাবে। এই পর্বের সব নতুন শব্দ এখানে একসাথে:
মনে রাখুন
- Alignment: প্রতিটি মান তার alignment-এর গুণিতক ঠিকানায়; সংখ্যাটি ABI ঠিক করে, ভাষা নয় (i386 Linux-এ int64 ৪, Windows x86-এ ৮)।
- অ্যালগরিদম: offset = align_up(off, align), শেষে size = align_up(off, সবচেয়ে বড় align). Tail padding আছে যাতে array-র প্রতিটি উপাদান ঠিক জায়গায় শুরু হয়।
- সাজানো: বড় alignment আগে রাখলে মাঝে ফাঁক নেই আর মাপ সর্বনিম্ন (Order ২৪ → ১৬)। C ক্রম বদলায় না, Rust বদলাতে পারে।
- Packed আর endianness: packed জায়গা বাঁচায় কিন্তু ভুল-ঠিকানার access আনে (RISC-V-তে আট byte-load). Byte-ক্রম সীমানায় স্পষ্ট লিখুন:
</>, DataView. - বড় ছবি: layout ABI-র অংশ; অনেক record-এ AoS বনাম SoA বিবেচনা করুন; managed ভাষায় header আর boxing-এর দাম মাথায় রাখুন।
আরও পড়ুন · ABCL TECH-এ আপনার পরবর্তী পদক্ষেপ
- পর্ব ২৬ · Expression আর evaluation order — precedence, side effect আর short-circuitপরবর্তী পর্বমডিউল ৫-এর শুরু: expression কোন ক্রমে মূল্যায়িত হয়।
- প্রোগ্রামিং ভাষা ও কম্পাইলার · কোর্স হোম৮৬টি পর্বপুরো কোর্সের মানচিত্র আর Haat প্রজেক্টের পথ।
- ডেটার বিট-রূপ — endianness আর alignment-এর hardware-এর দিকপাশের ট্র্যাকComputer Architecture কোর্সের পর্ব ০৬।
- C-তে struct, union আর enumপাশের ট্র্যাকC কোর্সের পর্ব ২২: struct হাতে-কলমে।
- Cache-বান্ধব প্রোগ্রামপাশের ট্র্যাকLayout কেন গতিতে প্রভাব ফেলে।