Memory Model — manual, RAII, ownership, GC: কে manage করে আর দাম কত

প্ল্যাটফর্মটা মনে করে নিই — stack আর heap

OS লেসন থেকে তিনটা সত্য ঝালিয়ে নিই, কারণ চারটা model-ই এই তিনটার উপর দাঁড়িয়ে:

1. Stack allocation প্রায় বিনামূল্যের। Stack pointer সামান্য সরে, ব্যস — কোনো search নেই, bookkeeping নেই। Function return করলেই ফ্রেমটা মুছে যায়, কারণ stack-এর lifetime নিয়ম LIFO — যে ক্রমে allocate হলো, উল্টো ক্রমে free হয়। এই নিয়মটাই Stack Frame লেসনে দেখেছেন।
2. Heap allocation দামি হতে পারে, আর lifetime arbitrary। যেকোনো সময়, যেকোনো ক্রমে free — এই স্বাধীনতাই সমস্যার উৎস। Allocator-কে free chunk খুঁজতে হয়, fragmentation সামলাতে হয়, metadata রাখতে হয়।
3. সমস্যা তখনই শুরু যখন heap object-এর lifetime আর কোডের structure আলাদা হয়ে যায়। এক function-এ allocate, অন্যটায় release — এই দূরত্বেই dangling pointer, double free, leak ঢুকে পড়ে।

চারটা memory model আসলে এই তৃতীয় সত্যটার চারটা ভিন্ন জবাব।

Model ১: Manual — “আমি নিজেই দেখব”

Node *n = malloc(sizeof(Node));
/* ... ব্যবহার ... */
free(n);

নিয়ম মাত্র একটা: যে allocate করলে, তারই দায়িত্ব free করা। কোনো enforcement নেই — free ভুলে গেলে compiler কিছু বলবে না, দুইবার ডাকলেও না (বেশিরভাগ সময় চুপ থাকবে, তারপর একদিন production-এ crash করবে)।

এই model-এর ক্লাসিক ব্যর্থতাগুলো, প্রতিটা experiment section-এ নিজ হাতে করব:

Model ২: RAII — “scope-টাই owner”

C++-এর ভাবনা: free ডাকার দায়িত্ব programmer-এর হাত থেকে নিয়ে নিন — কিন্তু GC বানিয়ে না। বরং destructor ব্যবহার করুন:

void send_report() {
    std::string body = build_body();      // heap allocate — constructor-এ
    transmit(body);
}                                          // scope শেষ — destructor স্বয়ংক্রিয়ভাবে
                                           // body-র memory ফেরত দেয়। ঠিক এখানেই।

Compiler প্রতিটা scope-এর closing brace-এ destructor call insert করে দেয়। Pattern-টার নাম RAII — Resource Acquisition Is Initialization: resource কেনা = constructor চলা, ফেরত দেওয়া = destructor চলা। মূল জাদু: destructor-এর timing deterministic — scope exit মানেই মুক্তি। আর scope nesting সবসময় LIFO, তাই stack-এর নিয়মই heap-এ প্রয়োগ হয়ে যায়।

RAII শুধু memory-র জন্য না — একই কৌশল file descriptor, mutex lock, socket, DB transaction সবখানে কাজ করে (C++-এর std::lock_guard lock leak না, unlock ভুলে যাওয়া না — দুটোই অসম্ভব করে)।

Model ৩: Ownership — “compiler-কে proof করে দেখাও”

Rust-এর প্রশ্ন: RAII deterministic তো, কিন্তু C++-এ তো এখনও ভুল করা যায় — একই heap object-এর দুইটা raw pointer রাখা যায়, একটা দিয়ে free করে আরেকটা দিয়ে access করা যায়। Rust বলে: প্রতিটা heap object-এর ঠিক একজন owner থাকবে, আর নিয়মটা compile time-এ প্রমাণ করতে হবে। তিনটা rule:

1. প্রতিটা value-র ঠিক একটা owner আছে।
2. Assignment বা pass-by-value-তে value move হয় — পুরনো নাম invalid হয়ে যায় (ব্যবহার করলে compile error)।
3. Borrowing: হয় একসাথে অনেক immutable borrow (&T), নয় ঠিক একটা mutable borrow (&mut T) — দুটো একসাথে না।

fn main() {
    let s1 = String::from("hello");
    let s2 = s1;                  // move! s1-এর ownership s2-তে গেল
    // println!("{}", s1);        // ERROR [E0382]: borrow of moved value: `s1`
    println!("{}", s2);           // ঠিক আছে — s2-ই এখন owner

    let r1 = &s2;                 // immutable borrow
    let r2 = &s2;                 // আরেকটা immutable borrow — সমস্যা নেই
    // let r3 = &mut s2;          // ERROR [E0502]: cannot borrow `s2` as mutable
                                  //        because it is also borrowed as immutable
}

লক্ষ্য করুন — এই সব error compile time-এ। Run time-এ Rust-এর discipline আসলে RAII-রই সমান: owner-এর scope শেষ হলে destructor (Rust-এর ভাষায় Drop) চলে, সাথে সাথে। মানে Rust = RAII + একটা compiler যেটা প্রমাণ চায় আপনি rules ভাঙছেন না।

Model ৪: Tracing GC — “dead নাকি live, বলব periodic জরিপে”

Java, Go, Python, C#, JavaScript — এই পরিবারে programmer free() ডাকে না। Object allocate হয়, আর একটা collector মাঝে মাঝে জরিপ চালায়: কোন object-এ এখনো reachable কোনো reference আছে? যেগুলোতে নেই, সেগুলো reclaim।

দুটা গভীর consequence এখনই লক্ষ্য করুন (পরের লেসনের বিষয়):

• Latency deferred: মুক্তির মুহূর্তটা আর code structure-এর সাথে সম্পর্কিত না — collector যখন চলবে তখন। Determinism চলে যায়।
• Cycle সমস্যা নেই: A আর B একে অপরকে point করলেও, বাইরে থেকে কেউ না পৌঁছালে দুটোই unreachable — collector দুটোই ধরবে। (Reference counting এখানে ফাঁসে — লেসন ৮-এ দেখব।)

সময় ───────────────────────────────────────────────────────►

Manual (C):     [alloc]─────────[free]───────────────►
                         ↑ programmer ডাকলেই, যেকোনো মুহূর্তে
                           (ভুল মুহূর্তেও — UAF!)

RAII (C++):     [ctor]──────────┤scope exit├──────►
                                ↑ deterministic, compiler insert করে

Ownership(Rust):[alloc]─────────┤owner drops├─────►
                                ↑ deterministic + compiler প্রমাণ চেয়েছিল

Tracing GC:     [alloc]─────────────────────[collect]──►
                                              ↑ "যখন collector চলে" — code
                                                structure থেকে বিচ্ছিন্ন

মূল টেবিল — guarantee আর দাম