এই পর্বে যা শিখবেন
- Lifetime আর scope-এর পার্থক্য উদাহরণ দিয়ে বলা, আর চারটি সম্ভাব্য মিলন-অমিল চেনা
- Static, stack-dynamic, explicit আর implicit heap-dynamic variable আলাদা করা, প্রতিটির সুবিধা-অসুবিধাসহ
- চলমান program-এর মেমরি এলাকা (text, data, bss, heap, stack) আর কোন variable কোথায় বসে, সত্যিকারের Clang output দিয়ে
- Dangling pointer কীভাবে তৈরি হয়, compiler কতটা ধরতে পারে, আর তিনটি নিরাপদ বিকল্প
- Closure কেন একটি variable-কে function-এর frame শেষ হওয়ার পরেও বাঁচিয়ে রাখে, আর compiler কীভাবে ঠিক করে কোন variable heap-এ যাবে
১ · Lifetime আর scope — দুটি আলাদা প্রশ্ন
পর্ব ১৪-এ (নাম, variable আর binding) দেখেছেন, একটি variable-এর ছয়টি গুণ আছে: নাম, ঠিকানা, মান, type, lifetime আর scope. পর্ব ১৫-এ (Scope — static বনাম dynamic scoping) scope নিয়ে বিস্তারিত আলোচনা। এই পর্বের বিষয় ছয়টির মধ্যে সবচেয়ে বেশি গুলিয়ে ফেলা জোড়া: scope আর lifetime. শুরুতে দুটিকে আলাদা করে নেওয়া যাক।
বাজারঘরের অফিসে কর্মীদের জন্য লকার আছে। দুটি প্রশ্ন ভাবুন। এক: “কোন ঘর থেকে ডাকলে ‘রহিমের লকার’ নামটি কেউ বুঝবে?” হয়তো শুধু তিনতলার হিসাব বিভাগে; নিচতলায় ওই নামে কেউ কিছু চেনে না। এটি scope: নামটি কোথায় অর্থ বহন করে। দুই: “লকারটি কত দিন রহিমের নামে বরাদ্দ থাকে?” যোগ দেওয়ার দিন থেকে চাকরি ছাড়ার দিন পর্যন্ত। এটি lifetime: ঘরটি কত সময় ধরে কারও জন্য রাখা। প্রথম প্রশ্নের উত্তর অফিসের নকশা দেখে দেওয়া যায়; দ্বিতীয়টির উত্তর ক্যালেন্ডার দেখে।
প্রোগ্রামিং ভাষায় একইভাবে, scope হলো লেখার ধারণা: source code-এর কোন অংশে একটি নাম একটি নির্দিষ্ট variable-কে বোঝায়। Static scoping-এর ভাষায় (C, Java, Python, Haat) এটি compile-এর সময়েই, অর্থাৎ static ভাবে, কোড পড়ে ঠিক করা যায়। Lifetime হলো সময়ের ধারণা: program চলার সময় (run time, অর্থাৎ dynamic ভাবে) কখন variable-টির জন্য মেমরির ঘর নেওয়া হয় আর কখন ফেরত যায়। ঘর নেওয়াকে বলে allocation, ফেরত দেওয়াকে deallocation. পুরোনো বইয়ে lifetime-কে “extent”-ও বলা হয়।
Scope(x) = program-এর লেখার সেই অংশ, যেখানে নাম x এই ঘোষণাটিকেই বোঝায়। এটি লাইন আর কলামের একটি এলাকা।
Lifetime(x) = চলার সময়ের সেই ব্যবধান [talloc, tfree), যেখানে x-এর ঘরটি বরাদ্দ থাকে। একই ঘোষণা চলার সময় বহুবার নতুন ঘর পেতে পারে (প্রতিটি function call-এ একবার), তাই একটি ঘোষণার অনেকগুলো lifetime থাকতে পারে; একটি scope-এর কিন্তু একটিই এলাকা।
বেশিরভাগ সাধারণ local variable-এ দুটি প্রায় মিলে যায়, তাই মানুষ গুলিয়ে ফেলে। কিন্তু দুটি চারভাবে মিলতে বা না-মিলতে পারে, আর প্রতিটি ঘটনা একটি গুরুত্বপূর্ণ ভাষা-বৈশিষ্ট্য:
| সম্পর্ক | উদাহরণ | কী ঘটে |
|---|---|---|
| প্রায় সমান | Haat বা C-র সাধারণ local | Function ঢুকলে ঘর তৈরি, বেরোলে ঘর শেষ; নামও শুধু ভেতরে দেখা যায় |
| Lifetime বড়, scope ছোট | C-র static local; closure-এ ধরা variable | নামটি function-এর বাইরে অচেনা, কিন্তু ঘরটি পরের call-এর জন্য বা closure-এর জন্য বেঁচে থাকে |
| নাম আছে, ঘর এখনো নেই | JavaScript-এর let-এর আগে; Haat-এর top-level let চলার আগে | নামটি scope-এ আছে, কিন্তু variable এখনো তৈরি বা শুরু হয়নি; ব্যবহার করলে error |
| ঘর শেষ, পথ রয়ে গেছে | C-তে local-এর ঠিকানা ফেরত দেওয়া, free-এর পরে pointer | Dangling pointer: পথটি এখনো আছে, ঘরটি নেই; ব্যবহার করা ভয়ংকর ভুল |
তৃতীয় সারিটি Haat-এ সত্যিই চালিয়ে দেখা যায়। Haat-এ top-level function hoist হয়, মানে program-এর শুরু থেকেই ডাকা যায় (reference বাস্তবায়নের নকশা-সিদ্ধান্ত ১৭)। আর function-এর ভেতর থেকে একটি top-level variable ব্যবহার করা যায়, যদি variable-টি ফাইলে function-এর আগে ঘোষিত হয় (সিদ্ধান্ত ১৮)। তাহলে এই program-টি ভাবুন:
print(early());
let k = 7;
fn early() -> Int { return k; }~/haat $ python haat.py check early.haat
ok
~/haat $ python haat.py run early.haat
3:28: runtime error: 'k' is not initialized yet
~/haat $ python haat.py vm early.haat
3:28: runtime error: 'k' is not initialized yet
সত্যিকারের run (Haat reference, CPython 3.14.4). Static check পাস করেছে, কারণ early-এর ভেতরে k নামটি scope-এ আছে: সে ফাইলে আগে ঘোষিত। কিন্তু লাইন ১-এ early() ডাকার মুহূর্তে লাইন ২ এখনো চলেনি, তাই k-এর ঘরটির lifetime তখনো শুরুই হয়নি। Scope ছিল compile-এর সময়ের উত্তর, আর এই error চলার সময়ের। দুই back end (tree-walking interpreter আর VM) একই জায়গায়, লাইন ৩ কলাম ২৮-এ, একই বার্তা দেয়। Haat-এর এই নিয়ম JavaScript-এর let-এর “temporal dead zone”-এর মতো; সেই আলোচনা পর্ব ১৫-এর।
২ · চলমান program-এর মেমরি: text, data, bss, heap আর stack
Lifetime-এর প্রতিটি ধরনের পেছনে মেমরির একটি নির্দিষ্ট এলাকা আছে। একটি C program যখন Linux-এর মতো operating system-এ চলে, তখন তার address space মোটামুটি পাঁচ ভাগে সাজানো থাকে। Operating system-এর দিক থেকে এর পুরো গল্প আছে Operating Systems কোর্সের পর্ব ০৮-এ (প্রসেস — state, PCB আর memory layout); এখানে আমরা দেখব ভাষার চোখে: কোন ধরনের variable কোন এলাকায় যায়, আর সেই এলাকার নিয়মই তার lifetime ঠিক করে।
ছবি ১৬.১ — একটি চলমান C program-এর মেমরি
ওপরে বড় ঠিকানা, নিচে ছোট। Stack নিচের দিকে বাড়ে, heap ওপরের দিকে; মাঝের খালি জায়গা দুজনেই ব্যবহার করে।
তিনটি এলাকার নিয়ম তিন রকম, আর সেটাই lifetime-এর তিন রকম নিয়ম:
- data আর bss: আকার program শুরুর আগেই জানা। Loader একবার জায়গা দেয়, program শেষ না হওয়া পর্যন্ত ফেরত নেয় না। এখানে variable-এর ঠিকানা ঠিক হয় link বা load-এর সময়, অর্থাৎ binding time চলার আগে।
- stack: শেষে ঢোকা, আগে বেরোনো (LIFO). Function ডাকলে ওপরে একটি frame বসে, ফিরলে ঠিক সেটিই সরে। ঘর নেওয়া-ফেরত দেওয়া মানে শুধু একটি stack pointer register-কে কয়েক byte সরানো, তাই খুব সস্তা।
- heap: কোনো ক্রমের বাধ্যবাধকতা নেই। যেকোনো সময় যেকোনো মাপের ঘর নেওয়া যায়, আর যেকোনো ক্রমে ফেরত দেওয়া যায়। এই স্বাধীনতার দাম: খালি জায়গার হিসাব রাখতে একটি allocator লাগে, আর কে কখন ফেরত দেবে সেই দায় কারও ঘাড়ে চাপাতে হয়।
৩ · Variable-এর চার শ্রেণি — lifetime অনুযায়ী
Robert Sebesta-র বহুল ব্যবহৃত পাঠ্যবই “Concepts of Programming Languages” variable-কে storage binding আর lifetime অনুযায়ী চার ভাগে ভাগ করে। বিশ্ববিদ্যালয় আর চাকরির পরীক্ষায় এই শ্রেণিবিভাগ খুব প্রচলিত, তাই নামগুলো হুবহু মনে রাখা ভালো।
| শ্রেণি | ঘর কখন বাঁধা হয় | Lifetime | উদাহরণ |
|---|---|---|---|
| Static | চলার আগে (compile, link বা load) | পুরো run | C-র global আর static local; Java-র static field (class load হলে) |
| Stack-dynamic | ঘোষণা চলার সময় (elaboration) | একটি call বা block | C, Java আর Haat-এর local আর parameter |
| Explicit heap-dynamic | প্রোগ্রামারের স্পষ্ট নির্দেশে | নির্দেশ থেকে free/delete বা GC পর্যন্ত | C-র malloc, C++ আর Java-র new |
| Implicit heap-dynamic | মান বসানোর সময়, নিজে থেকে | যতক্ষণ পৌঁছানো যায় | Python-এর x = [1, 2], JavaScript-এর array আর object |
প্রতিটি শ্রেণি একটি আপস। Static সবচেয়ে দ্রুত: ঠিকানা আগেই জানা, তাই machine code সরাসরি সেই ঠিকানায় পড়ে-লেখে, কোনো বাড়তি হিসাব নেই। কিন্তু একটি ঘোষণার জন্য ঘর একটিই, তাই recursion চলে না: একই function-এর দুটি চলমান ডাক একই ঘর ভাগ করে ফেলে। মেমরিও বেশি লাগে, কারণ যে function কখনো ডাকা হয় না তার variable-ও জায়গা নিয়ে বসে থাকে।
Stack-dynamic recursion সম্ভব করে, কারণ প্রতিটি ডাক নিজের frame পায়, আর ব্যবহার শেষে জায়গা সঙ্গে সঙ্গে ফেরত যায়। দাম সামান্য: ঠিকানা এখন stack pointer বা frame pointer থেকে দূরত্ব দিয়ে হিসাব করতে হয় (indirect addressing), আর frame-এর কাজ শেষে variable বাঁচিয়ে রাখা যায় না। Explicit heap-dynamic lifetime-কে call-এর কাঠামো থেকে মুক্ত করে: linked list বা গাছের node দরকারমতো তৈরি আর মুছতে পারেন। দাম হলো নির্ভরযোগ্যতা: pointer ঠিকমতো সামলাতে না পারলে memory leak বা dangling pointer. Implicit heap-dynamic সবচেয়ে নমনীয়: একই নামে আজ একটি সংখ্যা, কাল একটি list; দাম গতি (প্রতিটি মানের জন্য heap-এর ঘর আর type-এর তথ্য) আর কিছু ভুল চালানোর আগে ধরা না পড়া।
Haat কোথায় বসে? Haat v1-এ top-level let আর var হলো global: reference VM তাদের DEFINE_GLOBAL দিয়ে একটি স্থির টেবিলে রাখে, program শেষ না হওয়া পর্যন্ত। কিন্তু C-র static থেকে একটি পার্থক্য আছে: C-তে static variable program শুরুর আগেই মান পায়, আর Haat-এ তার লাইন চলার সময়; অংশ ১-এর 'k' is not initialized yet ঠিক এই পার্থক্য থেকে এসেছে। Function-এর parameter আর local হলো stack-dynamic. Haat v1-এ malloc বা new নেই, তাই explicit heap-dynamic নেই; তবে অংশ ৮-এ দেখবেন, closure-এ ধরা variable-কে বাস্তবায়ন নিজে থেকেই heap-এর একটি ঘরে তোলে।
৪ · Stack-dynamic variable — প্রতিটি call-এর নিজের ঘর
সবচেয়ে বেশি ব্যবহৃত শ্রেণি দিয়ে শুরু করি। নিচের Haat program হলো bazar.haat-এর প্রথম অংশ। এখানে price দুবার ডাকা হয়, আর প্রতিবার তার qty, unit আর p নতুন ঘর পায়। একই নাম, একই scope, কিন্তু দুটি আলাদা lifetime. ধাপে ধাপে stack frame-গুলোর জন্ম আর মৃত্যু দেখুন।
1fn price(qty: Int, unit: Int) -> Int {2 let p = qty * unit;3 if p >= 1000 { return p - p / 10; }4 return p;5}6fn delivery(total: Int) -> Int {7 if total >= 1000 { return 0; } else { return 60; }8}9let first = price(2, 520) + delivery(price(2, 520));10print(first);
| stack (ওপরেরটি আগে) | |
| জীবিত local | |
| main-এর হাতে | |
| global |
- শুরু। Top-level function দুটি program-এর শুরুতেই global টেবিলে বসে (hoisting). Stack-এ শুধু main.
firstনামটি ঘোষিত, কিন্তু তার ঘর এখনো তৈরি হয়নি। - প্রথম call.
price(2, 520): stack-এ নতুন frame, ভেতরে দুটি parameter-এর ঘর। এদের lifetime এই মুহূর্তে শুরু। - নতুন local.
let p = qty * unit;চলে,p-এর ঘরে 1040. Reference VM-এর disassembly বলেprice (arity 2, locals 3): frame-এর মাপ (৩টি ঘর) compile-এর সময়েই জানা, ঘরগুলো পাওয়া যায় call-এর সময়। - ফেরা। 1040 ≥ 1000, তাই 1040 − 104 = 936 ফেরত। Frame সরে যায়; qty, unit আর p-এর lifetime শেষ। main-এর হাতে এখন শুধু মান 936.
- আবার price. Haat বাঁ থেকে ডানে চলে: আগে callee
delivery-এর মান নেওয়া হয়, তারপর তার argumentprice(2, 520). এটি একেবারে নতুন frame (#2): আগের call-এর কোনো ঘর আর নেই, মানগুলো নতুন করে বসে। - আবার ফেরা। একই হিসাব, 936 ফেরত, frame #2 শেষ। main-এর হাতে এখন 936,
deliveryআর 936. - delivery. নতুন frame-এ
total = 936. 936 < 1000, তাই 60 ফেরত, frame শেষ। - যোগ আর global. 936 + 60 = 996,
first-এর ঘর তৈরি হয়ে মান পায়, আর ছাপা হয় 996 (reference-এরrunআরvmদুটিই)। পুরো লাইনে তিনটি frame জন্মেছে আর মরেছে; globalfirstবাঁচবে program-এর শেষ পর্যন্ত।
Stepper-এর মূল কথাটি আলাদা করে লিখি: local variable-এর ঘোষণা একটি, কিন্তু তার ঘর প্রতিটি call-এ নতুন। Compiler আগে থেকেই জানে frame-এ কয়টি ঘর থাকবে আর কোন নাম কোন ঘরে (LOAD_LOCAL 2 ; p মানে “এই frame-এর ২ নম্বর ঘর”)। কিন্তু frame-টি মেমরির কোথায় বসবে, তা ঠিক হয় চলার সময়, কে কাকে কতটা গভীরে ডেকেছে তার ওপর। এজন্যই একে “stack-dynamic” বলে: storage binding dynamic, যদিও type আর frame-এর আকার static.
কেন stack: recursion
Stack-dynamic variable ছাড়া recursion অসম্ভব। কল্পনা করুন depth(n) নিজেকে depth(n - 1) দিয়ে ডাকে। প্রতিটি চলমান ডাকের নিজের n দরকার, কারণ ভেতরের ডাক শেষ হলে বাইরের ডাক তার পুরোনো n নিয়ে কাজ চালাবে। সব ডাক যদি একটি static ঘর ভাগ করত, ভেতরের ডাক বাইরের মান মুছে দিত। ইতিহাসে ঠিক এটাই ঘটেছে: প্রথম দিকের FORTRAN-এর বাস্তবায়নগুলো সাধারণত local variable-কে static ঘরে রাখত, আর ভাষার নিয়মও recursion-এর নিশ্চয়তা দিত না। ALGOL 60 recursive procedure-কে ভাষার অংশ করে, আর Edsger Dijkstra ১৯৬০ সালে “Recursive Programming” প্রবন্ধে তার বাস্তবায়নের জন্য stack-এর ব্যবহার বর্ণনা করেন। Fortran-এ RECURSIVE keyword এসেছে Fortran 90-এ।
Stack-এর একটি সীমাও আছে: এটি অসীম নয়। Haat reference দুই back end-এই সর্বোচ্চ ১০০০টি nested call মেনে চলে (নকশা-সিদ্ধান্ত ২৬)। সত্যিকারের run:
fn depth(n: Int) -> Int {
if n == 0 { return 0; }
return 1 + depth(n - 1);
}
print(depth(999));
print(depth(1000));~/haat $ python haat.py run deep.haat
999
3:16: runtime error: stack overflow
~/haat $ python haat.py vm deep.haat
999
3:16: runtime error: stack overflow
depth(999)-এ মোট ১০০০টি frame একসঙ্গে বেঁচে থাকে (n = 999 থেকে 0), যা সীমার ভেতরে। depth(1000)-এ ১০০১টি, তাই ১০০১তম call-এর জায়গায়, callee depth-এর শুরুতে (কলাম ১৬), error. বাস্তব C program-এ সীমা ঠিক করে operating system-এর দেওয়া stack-এর মাপ, আর পার হলে সাধারণত segmentation fault হয়। Frame-এর ভেতরে ঠিক কী কী থাকে (ফেরার ঠিকানা, আগের frame-এর খোঁজ, saved register), সেই পূর্ণ নকশা হলো activation record, যা পর্ব ৩০-এ (Subprogram-এর বাস্তবায়ন) আসবে; হার্ডওয়্যারের দিক আছে Computer Architecture কোর্সের পর্ব ৩০-এ। আর tail call দিয়ে কীভাবে stack না বাড়িয়ে recursion চালানো যায়, তা পর্ব ৩২-এ।
৫ · Static variable — scope ছোট, lifetime পুরো run
এবার উল্টো দিক। C-তে function-এর ভেতরে static লিখলে নামটির scope থাকে শুধু সেই function-এর ভেতরে, কিন্তু ঘরটি static: program শুরুর আগে তৈরি, শেষে মুছে যায়। ফলে function প্রতিবার আগের মান মনে রাখে। বাজারঘরের অর্ডার নম্বর দেওয়ার একটি function:
1int next_order_id(void) {2 static int count = 0;3 int step = 1;4 count = count + step;5 return count;6}7int main(void) {8 int a = next_order_id();9 int b = next_order_id();10 int c = next_order_id();11 printf("%d %d %d\n", a, b, c);
| count (static) | |
| step (automatic) | |
| main-এর local | |
| stack |
- main-এর আগেই।
count-এর ঘর program load হওয়ার সময়েই তৈরি, মান 0. এটি stack-এ নয়; লাইন ২ main চলার সময় “চলে” না, এর কাজ load-এর সময়েই শেষ। - প্রথম ডাক। Stack-এ next_order_id-এর frame, ভেতরে
step-এর নতুন ঘর, মান 1.countআগের মতোই 0. - প্রথম ফেরা।
count= 0 + 1 = 1, ফেরত 1, তাই a = 1. Frame সরে যায়,step-এর lifetime শেষ; কিন্তুcount-এর ঘরে 1 রয়ে গেল। - দ্বিতীয় ডাক। আবার নতুন frame, আবার নতুন
step= 1. লাইন ২-এর= 0আবার চলে না: static-এর initializer শুধু একবার, program-এর শুরুতে। - দ্বিতীয় ফেরা।
count= 1 + 1 = 2, তাই b = 2. - তৃতীয় ডাক। একই চক্র সংক্ষেপে:
stepজন্মায় আর মরে,count= 3, c = 3. - আউটপুট।
1 2 3. তিনটি ডাকেstep-এর তিনটি আলাদা lifetime, আরcount-এর একটিই, পুরো run জুড়ে। অথচ main-এর ভেতরেcountনামটি লিখলে compile error: scope ছোট, lifetime বড়।
সত্যিকারের run — Clang কোথায় রাখল count
এই পর্বের সব C run সত্যিকারের: PyPI-র ziglang 0.17.1 (MIT licence), যার ভেতরে Clang 22.1.8; এখানে zig মানে python -m ziglang. Wandbox সার্ভার এই সময়ে কাজ করছিল না, তাই C কোড পাতায় চালানো যায় এমন ব্লক হিসেবে রাখা হয়নি; নিচের আউটপুট লেখকের যন্ত্রে নেওয়া।
#include <stdio.h>
int next_order_id(void) {
static int count = 0; /* static: one box for the whole run */
int step = 1; /* automatic: new box on every call */
count = count + step;
return count;
}
int main(void) {
int a = next_order_id();
int b = next_order_id();
int c = next_order_id();
printf("%d %d %d\n", a, b, c);
return 0;
}~/haat $ zig cc -std=c17 -Wall -Wextra counter.c -o counter.exe && ./counter.exe
1 2 3
~/haat $ zig cc -std=c17 -O2 -g0 -S --target=x86_64-linux-musl \
-fno-asynchronous-unwind-tables -fomit-frame-pointer counter.c -o c2.s
~/haat $ cat c2.s # trimmed
next_order_id:
movl next_order_id.count(%rip), %eax
addl $1, %eax
movl %eax, next_order_id.count(%rip)
retq
...
.local next_order_id.count
.comm next_order_id.count,4,4
Assembly-তে তিনটি জিনিস পড়া যায়। এক, count stack-এ নেই: তার নিজের একটি নাম আছে, next_order_id.count, আর .comm … 4,4 মানে ৪ byte-এর একটি শূন্যে ভরা স্থির ঘর (bss-এর মতো), .local মানে অন্য ফাইল থেকে এই নাম দেখা যাবে না। নামের সামনে function-এর নাম জুড়ে দেওয়া হয়েছে, যাতে অন্য function-এর count-এর সঙ্গে না মেলে; এভাবেই compiler “scope ছোট, lifetime বড়” বাস্তবায়ন করে। দুই, ঘরটি পড়া-লেখা হয় সরাসরি নাম ধরে ((%rip)-এর সঙ্গে দূরত্ব), stack pointer-এর হিসাব ছাড়া। তিন, step কোথাও নেই: -O2-এ compiler বুঝেছে তার মান সবসময় 1, তাই সরাসরি addl $1 লিখেছে। Stack-dynamic variable-এর ঘর থাকা ভাষার অর্থ (semantics)-এর কথা; বাস্তবায়ন চাইলে সেটি register-এ রাখতে বা পুরো মুছে দিতে পারে, যদি আচরণ না বদলায়।
C-র storage class (auto, static, extern, register) আর C11-এর _Thread_local-এর পূর্ণ বিবরণ আছে C কোর্সের পর্ব ১৪-এ (স্কোপ ও স্টোরেজ ক্লাস); এখানে শুধু ভাষা-নকশার দিকটি। Static local-এর একটি লুকানো দাম আছে: function আর reentrant থাকে না। একই সময়ে দুটি thread next_order_id ডাকলে দুজনেই একই count পড়ে-লিখে একই নম্বর পেতে পারে। C library-র পুরোনো strtok ঠিক এই কারণে বিপজ্জনক, আর POSIX তার জন্য আলাদা strtok_r দেয়, যেখানে অবস্থা রাখার ঘরটি ডাকা-পক্ষ নিজে দেয়।
৬ · Heap — call-এর কাঠামো থেকে মুক্ত lifetime
Stack-এর নিয়ম কড়া: যে frame পরে এসেছে, সে আগে যাবে। কিন্তু বাজারঘরের একটি অর্ডার এক function-এ তৈরি হয়ে অন্য function-এ পাঠানো, পরে ডেলিভারির সময় মুছে ফেলার মতো কাজে lifetime কোনো call-এর সঙ্গে বাঁধা নয়। তখন heap দরকার। নিচের ছোট simulator একটি run-এর সময়রেখা দেখায়: frame কখন উঠল-নামল, heap-এর বাক্স কখন তৈরি হলো-মুছল, আর একটি “ঠিকানা” কখন অচল হয়ে গেল। এটি একটি মডেল, আসল মেমরি নয়; সময় t মানে ঘটনার ক্রমিক নম্বর।
from itertools import count
clock, stack, heap, ids = 0, [], {}, count(1)
def tick(msg):
global clock
clock += 1
print(f"t={clock:<2}", msg)
def call(fn, **vars):
stack.append({"fn": fn, "vars": vars, "no": next(ids), "born": clock + 1})
tick(f"push {fn} {vars} depth={len(stack)}")
def ret(value):
f = stack.pop()
tick(f"pop {f['fn']} -> {value} frame lived t={f['born']}..{clock + 1}")
return value
def new(value):
hid = f"#{len(heap) + 1}"
heap[hid] = {"value": value, "born": clock + 1}
tick(f"new {hid} = {value} on the heap")
return hid
def free(hid):
box = heap.pop(hid)
tick(f"free {hid} box lived t={box['born']}..{clock + 1}")
def alive(no): # is frame number `no` still on the stack?
return any(f["no"] == no for f in stack)
call("main")
call("price", qty=2, unit=520)
v = stack[-1]["vars"]; v["p"] = v["qty"] * v["unit"] # a new local p
first = ret(v["p"] - v["p"] // 10 if v["p"] >= 1000 else v["p"])
call("save", amount=first)
order = new(first) # a heap box made inside save
ptr = (stack[-1]["no"], "amount") # "address" of a local of save
ret(order)
print(" heap:", list(heap), "| ptr to save.amount dangling?", not alive(ptr[0]))
free(order)
ret(0)আসল আউটপুট (ব্রাউজারের Python):
t=1 push main {} depth=1
t=2 push price {'qty': 2, 'unit': 520} depth=2
t=3 pop price -> 936 frame lived t=2..3
t=4 push save {'amount': 936} depth=2
t=5 new #1 = 936 on the heap
t=6 pop save -> #1 frame lived t=4..6
heap: ['#1'] | ptr to save.amount dangling? True
t=7 free #1 box lived t=5..7
t=8 pop main -> 0 frame lived t=1..8
Frame-এর lifetime-গুলো একটির ভেতরে আরেকটি বসানো: price-এর [2..3] আর save-এর [4..6] দুটিই main-এর [1..8]-এর ভেতরে; কোনোটি আধাআধি ছেদ করে না। এটিই LIFO-র চিহ্ন। Heap-এর বাক্স #1-এর lifetime [5..7] এই নিয়ম ভাঙে: জন্ম save-এর ভেতরে, কিন্তু save শেষ হওয়ার পরেও বেঁচে থাকে, কারণ main-এর হাতে তার handle আছে। অন্যদিকে ptr দেখাচ্ছিল save-এর frame-এর একটি local-কে; save ফেরার পরে সেটি dangling. আর free না ডাকলে #1 program-এর শেষ পর্যন্ত পড়ে থাকত: memory leak. Heap-এ lifetime কে শেষ করবে, এটিই এখন আসল প্রশ্ন।
সেই প্রশ্নের তিনটি বড় উত্তর আছে। প্রোগ্রামার: C-র malloc/free, C++-এর new/delete; পূর্ণ নিয়ন্ত্রণ, পূর্ণ দায় (বিস্তারিত C কোর্সের পর্ব ২০-এ)। Runtime: garbage collection; Java, Python, JavaScript, Go আর Haat-এর মতো ভাষায় যে বস্তুতে আর পৌঁছানো যায় না, তার lifetime শেষ বলে ধরা হয় (পর্ব ৭৫)। Compiler-এর নিয়ম: C++-এর RAII আর Rust-এর ownership; মালিকের scope শেষ হলে ঘর ফেরত যায়, আর Rust compile-এর সময় যাচাই করে যে কোনো reference মালিকের চেয়ে বেশি দিন বাঁচবে না (পর্ব ৭৬)।
Implicit heap-dynamic ভাষায় lifetime কেমন দেখায়, CPython-এ সরাসরি দেখা যায়। CPython মূলত reference counting ব্যবহার করে: একটি object-কে কতগুলো reference দেখাচ্ছে তার গণনা শূন্য হলেই object মুছে যায়। নিচের কোড weakref.finalize দিয়ে প্রতিটি object-এর মৃত্যুর মুহূর্তে একটি বার্তা ছাপে:
import gc, sys, weakref
print("CPython", sys.version.split()[0])
class Order:
def __init__(self, no): self.no = no
def note(msg): print(" finalizer:", msg)
def local_only():
o = Order(1) # only a local name refers to it
weakref.finalize(o, note, "order 1 freed")
print("inside local_only: order", o.no)
local_only()
print("local_only returned")
def escapes():
o = Order(2)
weakref.finalize(o, note, "order 2 freed")
return o # the object escapes the frame
kept = escapes()
print("escapes returned; still using order", kept.no)
del kept # last reference gone
print("after del kept")
a = Order(3); a.me = a # a cycle: it refers to itself
weakref.finalize(a, note, "order 3 freed")
del a
print("cycle dropped, nothing freed yet")
print("cycle collector freed something:", gc.collect() > 0)
def make_counter(start):
nxt = start
def take():
nonlocal nxt
nxt += 1
return nxt
return take
dhaka = make_counter(100); dhaka(); dhaka()
print("cell after 2 calls:", dhaka.__closure__[0].cell_contents)
print(make_counter.__code__.co_cellvars, dhaka.__code__.co_freevars)আসল আউটপুট (ব্রাউজারের Python, Pyodide-এর CPython 3.14.2; লেখকের যন্ত্রের CPython 3.14.4-এ প্রথম লাইন ছাড়া বাকি সব হুবহু এক):
CPython 3.14.2
inside local_only: order 1
finalizer: order 1 freed
local_only returned
escapes returned; still using order 2
finalizer: order 2 freed
after del kept
cycle dropped, nothing freed yet
finalizer: order 3 freed
cycle collector freed something: True
cell after 2 calls: 102
('nxt',) ('nxt',)
Order 1: object-টি heap-এ, কিন্তু তাকে দেখায় শুধু একটি local নাম। Function ফেরার সময় frame যায়, গণনা শূন্য হয়, আর “local_only returned” ছাপার আগেই object মুছে যায়। এখানে heap-এর object-এর lifetime কার্যত stack frame-এর সমান। Order 2: object ফেরত গেছে (escape করেছে), তাই frame শেষ হলেও বেঁচে থাকে; শেষ reference del করার মুহূর্তে মরে। Order 3: object নিজেকেই দেখায়, তাই নাম মুছলেও গণনা শূন্য হয় না; CPython-এর আলাদা cycle collector (gc.collect()) চলার পরে তবেই মুছে। অর্থাৎ “পৌঁছানো যায় না” আর “মুছে ফেলা হয়েছে” এক মুহূর্ত নয়; কখন মুছবে তা বাস্তবায়নের ব্যাপার, Python ভাষার নিশ্চয়তা নয়। Java বা PyPy-র মতো tracing GC-তে order 1-ও সঙ্গে সঙ্গে মুছবে, এমন কোনো কথা নেই। শেষ দুই লাইন: make_counter-এর frame শেষ, তবু nxt বেঁচে আছে একটি cell-এর ভেতরে, যার মান এখন 102; CPython-এর compiler আগেই জানে nxt একটি cell variable (co_cellvars) আর take-এর কাছে free variable (co_freevars). এই কৌশলের কথা অংশ ৮-এ।
৭ · Dangling reference — ঘর শেষ, ঠিকানা রয়ে গেল
Lifetime-এর ভুলের মধ্যে সবচেয়ে বিপজ্জনক হলো dangling pointer: একটি pointer বা reference এমন ঘর দেখায় যার lifetime শেষ। দুটি প্রচলিত পথে এটি তৈরি হয়: heap-এর ঘর free করার পরেও পুরোনো pointer ব্যবহার করা (use-after-free), আর function থেকে তার local variable-এর ঠিকানা ফেরত দেওয়া। দ্বিতীয়টি সরাসরি এই পর্বের বিষয়, কারণ এখানে ভুলটি stack-এর LIFO নিয়ম থেকেই আসে।
#include <stdio.h>
int *make_total(int qty, int unit) {
int total = qty * unit; /* automatic: lives in this call's frame */
return &total; /* address of a local escapes */
}
int main(void) {
int *p = make_total(2, 520);
printf("%d\n", *p); /* undefined behavior: frame is gone */
return 0;
}~/haat $ zig cc -std=c17 -Wall -Wextra -c dangling.c -o dangling.o
dangling.c:5:13: warning: address of stack memory associated with local variable 'total' returned [-Wreturn-stack-address]
5 | return &total; /* address of a local escapes */
| ^~~~~
1 warning generated.
~/haat $ zig cc -std=c17 -O2 -g0 -S --target=x86_64-linux-musl \
-fno-asynchronous-unwind-tables -fomit-frame-pointer dangling.c -o d2.s
~/haat $ cat d2.s # trimmed
make_total:
leaq -4(%rsp), %rax
retq
main:
pushq %rax
movl $.L.str, %edi
xorl %eax, %eax
callq printf
...
সত্যিকারের run, Clang 22.1.8. Warning: Clang এই সরল ক্ষেত্রটি ধরেছে, কিন্তু এটি error নয়: object file তৈরি হয়েছে। C17-এর নিয়মে (§6.2.4) কোনো object-এর lifetime শেষ হলে তাকে দেখানো pointer-এর মান “indeterminate” হয়ে যায়, আর সেই pointer দিয়ে পড়া undefined behavior. Assembly: make_total-এ কোনো গুণ বা লেখা নেই, শুধু stack-এর একটি ঠিকানা (-4(%rsp)) ফেরত দেয়। আরও লক্ষ করুন main: printf-এর দ্বিতীয় argument-এর register %esi-তে কিছুই বসানো হয়নি; *p পড়াটাই compiler মুছে দিয়েছে, কারণ UB-র ওপর কোনো আচরণের দায় তার নেই। এই program চালালে কী ছাপবে, তা আমরা ইচ্ছে করে দেখাইনি: যেকোনো সংখ্যা আসতে পারে, আর একবার “ঠিক” উত্তর এলেও তা কোনো প্রমাণ নয়। ভুলটির নিরাপত্তা-দিক আছে Cybersecurity কোর্সের পর্ব ৪৭-এ।
সমাধান একটিই প্রশ্নের উত্তর: “ফলটির lifetime কার সঙ্গে বাঁধা থাকা উচিত?” তিনটি নিরাপদ উত্তর আছে। এক, pointer নয়, মান ফেরত দিন (int make_total(…)); মানটি কপি হয়ে ডাকা-পক্ষের ঘরে যায়। দুই, ঘরটি ডাকা-পক্ষ দিক: void make_total(int qty, int unit, int *out); এখন ঘরের lifetime ডাকা-পক্ষের frame-এর সঙ্গে বাঁধা, যা callee-র চেয়ে বেশি দিন বাঁচে। তিন, heap থেকে নিন, আর কে free করবে তা স্পষ্ট লিখে দিন। তৃতীয় পথ লেখকের যন্ত্রে চালানো (-Wall -Wextra-এ কোনো warning ছাড়া, আউটপুট 1040):
int *make_total(int qty, int unit) {
int *total = malloc(sizeof *total); /* explicit heap-dynamic */
if (total == NULL) return NULL;
*total = qty * unit;
return total; /* heap box outlives this frame */
}
/* caller: int *p = make_total(2, 520); ... printf("%d\n", *p); free(p); */অন্য ভাষাগুলো একই সমস্যার তিন রকম উত্তর দেয়। Java আর Python-এ local variable-এর ঠিকানা নেওয়ার কোনো উপায়ই নেই, আর সব object heap-এ, GC-র অধীনে; তাই এই ভুল লেখাই যায় না। Go-তে return &total সম্পূর্ণ বৈধ: compiler দেখে যে ঠিকানাটি function-এর বাইরে যাচ্ছে, আর total-কে নিজে থেকেই heap-এ রাখে (অংশ ৮-এর escape analysis). Rust উল্টো পথে যায়: local-এর reference ফেরত দেওয়ার চেষ্টা compile error, কারণ borrow checker প্রমাণ করতে পারে না যে reference-টি মালিকের চেয়ে বেশি দিন বাঁচবে না (উদাহরণ, এখানে চালানো হয়নি; বিস্তারিত পর্ব ৭৬-এ)। C একমাত্র ভাষা যেখানে দায় পুরোটাই প্রোগ্রামারের, আর compiler শুধু সরল ক্ষেত্রে সতর্ক করে।
৮ · Closure — lifetime যখন frame-কে ছাড়িয়ে যায়
অংশ ৭-এ local-এর ঠিকানা বাইরে যাওয়া ছিল ভুল। কিন্তু first-class function আছে এমন ভাষায় একই ঘটনা স্বাভাবিক আর দরকারি: একটি function ভেতরের আরেকটি function ফেরত দেয়, আর ভেতরেরটি বাইরের local variable ব্যবহার করে। এমন function আর তার ধরা variable-এর জোড়াকে বলে closure; এর পুরো আলোচনা পর্ব ১৭-এ। এখানে শুধু lifetime-এর দিকটি: ধরা variable-টি function-এর frame-এর চেয়ে বেশি দিন বাঁচতে বাধ্য। JavaScript-এ সরাসরি দেখুন:
function makeCounter(start) {
let next = start; // a local of makeCounter
return function take() { // closure: keeps `next` alive
next = next + 1;
return next;
};
}
const dhaka = makeCounter(100); // makeCounter has returned...
const ctg = makeCounter(500);
console.log(dhaka(), dhaka(), ctg(), dhaka());
try {
console.log(next); // ...but `next` is out of scope here
} catch (e) {
console.log(e.name + ": " + e.message);
}
{
try {
console.log(rate); // in scope, but not yet alive
} catch (e) {
console.log(e.name + ": " + e.message);
}
let rate = 10;
console.log("rate =", rate);
}আসল আউটপুট (ব্রাউজারের JavaScript):
101 102 501 103
ReferenceError: next is not defined
ReferenceError: Cannot access 'rate' before initialization
rate = 10
প্রথম লাইন: makeCounter দুবার ফিরে গেছে, তবু দুটি আলাদা next বেঁচে আছে, একটি 100 থেকে, একটি 500 থেকে, আর প্রতিটি নিজের হিসাব রাখে। দ্বিতীয় লাইন: বাইরে থেকে next নামটি অচেনা। ঘর বেঁচে আছে, নাম scope-এর বাইরে: lifetime > scope. তৃতীয় লাইন উল্টো ঘটনা: rate নামটি পুরো block-এর scope-এ আছে, কিন্তু let লাইন চলার আগে variable-টি শুরু হয়নি, অংশ ১-এর Haat উদাহরণের মতো। এই block-scope আর temporal dead zone-এর বিস্তারিত পর্ব ১৫-এ আর JavaScript কোর্সের পর্ব ২২-এ।
এখন প্রশ্ন: বাস্তবায়ন এটি করে কীভাবে, যখন stack-এর frame তো ফেরার সময় সরে যায়? উত্তর: যে local কোনো ভেতরের function ধরে, compiler সেটিকে আর frame-এর ঘরে রাখে না; heap-এ একটি ছোট বাক্স (cell) বানিয়ে সেখানে রাখে, আর frame ও closure দুজনেই সেই বাক্সের দিকে নির্দেশ করে। Haat-এর reference ঠিক এটাই করে। নিচের program আর তার সত্যিকারের bytecode দেখুন:
// বাজারঘর: অর্ডার নম্বর দেওয়ার যন্ত্র
fn make_counter(start: Int) -> () -> Int {
var next = start;
fn take() -> Int {
next = next + 1;
return next;
}
return take;
}
let dhaka = make_counter(100);
let ctg = make_counter(500);
print(dhaka());
print(dhaka());
print(ctg());
print(dhaka());~/haat $ python haat.py run tickets.haat
101
102
501
103
~/haat $ python haat.py dis tickets.haat # main part trimmed
== make_counter (arity 1, locals 3) ==
0 LOAD_LOCAL 0 ; start
1 MAKE_CELL 1 ; next
2 MAKE_CLOSURE 0 ; <fn take> captures next
3 STORE_LOCAL 2 ; take
4 LOAD_LOCAL 2 ; take
5 RETURN
== take (arity 0, locals 0) ==
0 LOAD_FREE 0 ; next
1 CONST 0 ; 1
2 ADD
3 STORE_FREE 0 ; next
4 LOAD_FREE 0 ; next
5 RETURN
সত্যিকারের run (Haat reference; vm দিয়েও একই চারটি লাইন)। price-এর p ছিল সাধারণ STORE_LOCAL; এখানে next-এর জন্য MAKE_CELL, কারণ reference-এর resolver (নাম খোঁজার ধাপ, resolver.py) compile-এর সময়েই দেখেছে যে take এই variable ধরে। take-এর নিজের কোনো local নেই (locals 0); সে next-কে পড়ে-লেখে LOAD_FREE আর STORE_FREE দিয়ে, অর্থাৎ নিজের closure-এর cell-তালিকা থেকে। Stepper-এ ঘরগুলোর জীবন দেখুন:
1fn make_counter(start: Int) -> () -> Int {2 var next = start;3 fn take() -> Int {4 next = next + 1;5 return next;6 }7 return take;8}9let dhaka = make_counter(100);10let ctg = make_counter(500);11print(dhaka());12print(dhaka());13print(ctg());14print(dhaka());
| stack | |
| frame-এর ঘর | |
| cell A (heap) | |
| cell B (heap) |
- Call.
make_counter(100): stack-এ নতুন frame, ঘর ০-তে parameterstart = 100. Disassembly বলে frame-এ মোট ৩টি ঘর। - MAKE_CELL.
next-এর মান সাধারণ ঘরে নয়, heap-এর একটি নতুন cell-এ (A) বসে, মান 100; frame-এর ঘর ১ শুধু cell A-র দিকে নির্দেশ করে। - MAKE_CLOSURE.
take-এর closure তৈরি হয়, যা cell A-র একটি reference নিজের ভেতরে রাখে (“captures next”). Closure নিজেও heap-এর একটি object. - RETURN. Frame সরে যায়:
start-এর lifetime শেষ, frame-এর ঘর ১-ও শেষ। কিন্তু cell A বেঁচে থাকে, কারণ closure তাকে দেখায়, আর closure-টিকে দেখায় globaldhaka. এখানেই lifetime scope-কে ছাড়িয়ে গেল। - দ্বিতীয় counter.
make_counter(500)আগের তিন ধাপ আবার করে, কিন্তু নতুন frame আর নতুন cell B (500) নিয়ে।ctgতার closure. দুটি closure-এর ঘর আলাদা, তাই হিসাবও আলাদা। - dhaka()।
take-এর frame, যার নিজের ঘর নেই।LOAD_FREE 0cell A থেকে 100 পড়ে, যোগ 1,STORE_FREE 0cell A-তে 101 লেখে; ছাপা হয় 101. - আবার dhaka()। একই cell A, 101 থেকে 102.
- ctg()। অন্য closure, তাই cell B: 500 থেকে 501. Cell A ছোঁয়াও হয়নি।
- আবার dhaka()। Cell A: 102 থেকে 103. আউটপুট reference-এর
runআরvmদুটির সঙ্গে হুবহু মেলে। Cell A বাঁচবে যতক্ষণdhakaবাঁচে, অর্থাৎ এখানে program-এর শেষ পর্যন্ত।
Escape analysis — কোন variable heap-এ যাবে, compiler ঠিক করে
Haat-এর resolver যা করল, সেটি একটি সাধারণ কৌশলের ছোট রূপ: escape analysis. প্রশ্নটি হলো, “এই variable বা object কি তৈরি হওয়া function-এর বাইরে পৌঁছাতে পারে (escape করে)?” না পারলে stack-এ রাখা নিরাপদ আর সস্তা; পারলে heap লাগে। Haat-এ নিয়মটি সরল: কোনো ভেতরের function একটি local ধরলেই সেটি cell হয়, closure সত্যিই বাইরে যাক বা না যাক। CPython-ও একই রকম: অংশ ৬-এর আউটপুটে দেখেছেন, nxt-কে compile-এর সময়েই cell variable ধরা হয়েছে।
বড় compiler-গুলো এটি আরও সূক্ষ্মভাবে করে। Go-র compiler প্রতিটি variable-এর জন্য ঠিক করে সেটি stack-এ থাকবে নাকি heap-এ “moved” হবে, আর go build -gcflags=-m দিলে সেই সিদ্ধান্তগুলো ছাপে বলে Go-র documentation-এ উল্লেখ আছে (এখানে চালানো হয়নি)। Java-র HotSpot JVM-এর JIT compiler উল্টো দিক থেকে ব্যবহার করে: Java-তে প্রতিটি new ভাষার অর্থে heap-এ, কিন্তু JIT যদি প্রমাণ করতে পারে যে একটি object method-এর বাইরে যায় না, তাহলে object না বানিয়ে তার field-গুলো সরাসরি register বা stack-এ রাখতে পারে (“scalar replacement”); কখন এটি ঘটে তা JVM-এর version আর চলার সময়ের তথ্যের ওপর নির্ভর করে। JVM-এর heap আর GC-র পুরো ছবি আছে Java কোর্সের পর্ব ৪৪-এ। মূল শিক্ষাটি এক: ভাষা বলে lifetime কতক্ষণ হওয়া উচিত; ঘরটি stack-এ, heap-এ নাকি register-এ বসবে, তা বাস্তবায়নের স্বাধীনতা, যতক্ষণ আচরণ না বদলায়।
৯ · Compiler-এর চোখে lifetime আর storage
এই কোর্সে Haat-এর compiler বানানোর সময় lifetime-এর প্রশ্ন বারবার ফিরে আসবে। একটি মানচিত্র:
| প্রশ্ন | Compiler-এ কী হয় | কোথায় |
|---|---|---|
| কোন নাম কোন ঘোষণা, কোনটি cell হবে | Symbol table আর name resolution; captured variable চিহ্নিত করা | পর্ব ৫১, ৫৭ |
| Frame-এ কয়টি ঘর, কোনটি কোথায় | Activation record-এর নকশা, slot বরাদ্দ | পর্ব ৩০, ৫৯ |
| কোন মান কতক্ষণ দরকার | Liveness analysis: variable-এর “মান-জীবন”, যা lifetime-এর চেয়েও ছোট হতে পারে | পর্ব ৬৪ |
| একই register বা ঘর কি দুজনে ভাগ করতে পারে | Register allocation: যাদের মান-জীবন ছেদ করে না, তারা একই register পায় | পর্ব ৭০ |
| Heap-এর ঘর কখন ফেরত যাবে | Garbage collector বা ownership-এর নিয়ম | পর্ব ৭৫, ৭৬ |
তৃতীয় সারিটি খেয়াল করার মতো। ভাষার lifetime বলে ঘরটি কতক্ষণ থাকার অধিকার রাখে; কিন্তু optimizer দেখে মানটি আসলে কতক্ষণ দরকার। অংশ ৫-এ step-এর ঘর পুরো মুছে যাওয়া এরই ফল। Compiler-এর ভাষায় এই দ্বিতীয় ধারণার নাম liveness: একটি মান “live” যতক্ষণ পরে কেউ তাকে পড়তে পারে।
আরও গভীরে: Stack আর heap-এর মাঝামাঝি একটি পথ হলো region-based memory management: একসঙ্গে মরবে এমন সব object একটি “region”-এ রাখা, আর region শেষ হলে সব একবারে ফেরত দেওয়া। Mads Tofte আর Jean-Pierre Talpin ১৯৯০-এর দশকে Standard ML-এর জন্য এমন একটি type-ভিত্তিক পদ্ধতি দেখান, যেখানে compiler নিজেই region আর তার lifetime অনুমান করে। Rust-এর lifetime annotation ('a) এই চিন্তার একটি দূরবর্তী আত্মীয়: reference কোন region-এর চেয়ে বেশি দিন বাঁচবে না, তা type-এর অংশ। দৈনন্দিন C আর C++-এ “arena allocator” একই ভাবনার হাতে-কলমে রূপ।
পরীক্ষা ও ইন্টারভিউতে: বিশ্ববিদ্যালয়, চাকরি বা ইন্টারভিউর পরীক্ষায় এই ধরনের প্রশ্ন প্রায়ই আসে:
- Scope আর lifetime-এর পার্থক্য? Scope লেখার এলাকা (কোথায় নাম দেখা যায়), lifetime চলার সময়ের ব্যবধান (কখন ঘর বরাদ্দ); C-র
staticlocal-এ scope ছোট, lifetime পুরো run. - Variable-এর চার শ্রেণি? Static, stack-dynamic, explicit heap-dynamic, implicit heap-dynamic; প্রতিটির একটি উদাহরণ আর একটি অসুবিধা বলতে পারা দরকার।
- Static local দিয়ে recursion কেন চলে না? সব চলমান ডাক একটিই ঘর ভাগ করে, ভেতরের ডাক বাইরের মান মুছে দেয়।
- Local-এর ঠিকানা ফেরত দিলে কী হয়? Dangling pointer; ব্যবহার C-তে undefined behavior; সমাধান মান ফেরত, ডাকা-পক্ষের ঘর, বা heap.
- Closure-এর variable কোথায় থাকে? সাধারণত heap-এর একটি cell বা environment object-এ, যাতে function-এর frame শেষ হলেও বাঁচে।
১০ · AI-এর যুগে lifetime আর memory
Memory-সংক্রান্ত প্রশ্নে AI assistant খুব আত্মবিশ্বাসী উত্তর দেয়, আর ভুলগুলোও সেই আত্মবিশ্বাসে মোড়া থাকে। এই বিষয়ে বারবার দেখা ভুল:
| AI-এর ভুল | কীভাবে ধরবেন |
|---|---|
| Scope আর lifetime-কে এক বলা, যেমন “static local-এর scope পুরো program” | Function-এর বাইরে নামটি লিখে compile করে দেখা |
| UB-র ফল নিশ্চিত বলে দেওয়া, যেমন “dangling pointer পুরোনো মানই দেবে” | C standard-এর নিয়ম পড়া; -O0 আর -O2-এর assembly তুলনা করা |
| এক ভাষার নিয়ম সবখানে চাপানো, যেমন “local সবসময় stack-এ” (Go-তে নয়, closure-এ নয়) | ভাষা আর version ধরে documentation; Python-এ co_cellvars, Haat-এ dis |
| GC নিয়ে ভুল নিশ্চয়তা, যেমন “Python-এ object সঙ্গে সঙ্গে মুছে যায়” | Cycle দিয়ে পরীক্ষা; CPython আর ভাষার নিশ্চয়তা আলাদা করা |
| Thread-এর মধ্যে static local-কে নিরাপদ বলা | Reentrancy আর thread-safety আলাদা করে প্রশ্ন করা; sanitizer দিয়ে চালানো |
| বানানো compiler flag বা warning-এর নাম | নিজের compiler-এ flag-টি চালিয়ে দেখা; warning-এর নাম আসল output থেকে নেওয়া |
AI-কে ভালোভাবে কাজে লাগানোর উপায়: ভাষা আর version বলে দেওয়া, প্রতিটি variable-এর শ্রেণি আর lifetime আলাদা করে চাওয়া, আর কোন দাবি নিজে চালিয়ে যাচাই করতে হবে তা জিজ্ঞেস করা।
AI-এর উত্তর হাতে পেলে — যাচাইয়ের চেকলিস্ট
ভাবনার প্রশ্ন
প্রতিটি প্রশ্ন নিয়ে নিজে কিছুক্ষণ ভাবুন, তারপর “→ উত্তর” চাপুন।
প্র ০১প্রথম দিকের FORTRAN-এর variable static ছিল কেন, আর ALGOL 60-এর stack কী বদলে দিল?
১৯৫০-এর দশকের শেষে FORTRAN-এর দলের সবচেয়ে বড় লক্ষ্য ছিল দক্ষতা: প্রমাণ করা যে compiler-এর লেখা machine code হাতে লেখা assembly-র কাছাকাছি দ্রুত হতে পারে। তখনকার যন্ত্রে মেমরি ছিল খুব কম, আর অনেক যন্ত্রে stack-এর জন্য বিশেষ নির্দেশ বা সুবিধাজনক indirect addressing ছিল না। Static allocation-এ প্রতিটি variable-এর ঠিকানা compile-এর সময়েই জানা, তাই প্রতিটি নির্দেশ সরাসরি একটি স্থির ঠিকানায় কাজ করে; কোনো base register বা দূরত্বের হিসাব লাগে না। দামটা ছিল recursion: একই subroutine-এর দুটি চলমান ডাক একই ঘর ভাগ করত, তাই ভাষার নিয়মও recursion-এর নিশ্চয়তা দিত না। দীর্ঘদিন ধরে Fortran-এর মান (standard) এই অবস্থান রেখেছে; RECURSIVE keyword আসে Fortran 90-এ।
ALGOL 60 একটি ভিন্ন দর্শন থেকে আসে: ভাষাটি গণিতের মতো পরিষ্কার হবে, আর recursive procedure ও nested block তার স্বাভাবিক অংশ। এটি বাস্তবায়নের জন্য একটি stack-ভিত্তিক runtime লাগল। Edsger Dijkstra-র ১৯৬০ সালের প্রবন্ধ “Recursive Programming” (Numerische Mathematik-এ প্রকাশিত) এই কৌশলের একটি প্রভাবশালী বর্ণনা দেয়: প্রতিটি ডাকে stack-এ নতুন জায়গা, ফেরার সময় তা ছেড়ে দেওয়া। Dijkstra আর Jaap Zonneveld-এর ALGOL 60 compiler (X1 যন্ত্রের জন্য) প্রথম পূর্ণাঙ্গ বাস্তবায়নগুলোর একটি হিসেবে পরিচিত।
এই পরিবর্তনের প্রভাব শুধু recursion নয়। Stack-dynamic variable মানে একটি function-এর কাজ শেষে তার সব জায়গা সঙ্গে সঙ্গে ফেরত, তাই একই মেমরি হাজারো function পালা করে ব্যবহার করতে পারে। Block-কাঠামো (nested scope) আর stack-এর LIFO স্বাভাবিকভাবে মেলে: যে block পরে খোলে, সে আগে বন্ধ হয়। আজকের C, Java, Python বা Haat, সবার function call এই ALGOL-ঐতিহ্যের ওপর দাঁড়িয়ে, আর হার্ডওয়্যারও (stack pointer register, call/return নির্দেশ) এই মডেলকে সমর্থন করতে বদলেছে। Fortran নিজেও সময়ের সঙ্গে এগিয়েছে; Fortran 2018-এ procedure ডিফল্টে recursive ধরা হয় বলে জানা যায়।
মূল উপলব্ধি: storage-এর নীতি ভাষার প্রকাশক্ষমতা ঠিক করে। Static allocation দক্ষতা দিয়েছিল কিন্তু recursion কেড়ে নিয়েছিল; stack-dynamic allocation সামান্য খরচে দুটোই দিল, আর সেই কারণে আধুনিক ভাষার ভিত্তি হয়ে গেল।
প্র ০২Local variable-এর ঠিকানা ফেরত দেওয়া C-তে error নয়, শুধু warning কেন? Compiler কি সব ক্ষেত্রে ধরতে পারত না?
প্রথম কারণ C-র নকশার দর্শন। C standard বলে কোন কাজের অর্থ নির্ধারিত; এর বাইরের কাজকে undefined behavior বলে ছেড়ে দেয়, আর compiler-কে সেটি ধরতে বাধ্য করে না। C17-এর §6.2.4 অনুযায়ী object-এর lifetime শেষ হলে তার দিকের pointer-এর মান indeterminate, কিন্তু pointer তৈরি বা ফেরত দেওয়াটা নিজে বাক্য-গঠনের ভুল নয়। তাই Clang-এর -Wreturn-stack-address একটি সহায়তা, ভাষার নিয়ম নয়।
দ্বিতীয় আর গভীর কারণ: সাধারণ ক্ষেত্রে এই প্রশ্নের সঠিক উত্তর গণনাযোগ্যই নয়। অংশ ৭-এর উদাহরণে return &total; সরাসরি দেখা যায়। কিন্তু ঠিকানাটি যদি একটি struct-এর field-এ রেখে, অন্য function-এ পাঠিয়ে, শর্তসাপেক্ষে একটি global pointer-এ বসানো হয়, তখন compiler-কে পুরো program-এর সব সম্ভাব্য পথ জানতে হবে। “এই pointer কি কখনো মৃত ঘর দেখাবে” প্রশ্নটি program-এর আচরণ নিয়ে একটি অ-তুচ্ছ প্রশ্ন, আর Rice-এর theorem বলে এমন প্রশ্ন সব program-এর জন্য নির্ভুলভাবে উত্তর দেওয়ার কোনো algorithm নেই। বাস্তব tool তাই আপস করে: হয় কিছু ভুল ছেড়ে দেয় (warning-এর মতো), নয়তো কিছু সঠিক program-কেও সন্দেহ করে।
অন্য ভাষাগুলো সেই আপসের দুই প্রান্ত বেছে নিয়েছে। Rust রক্ষণশীল প্রান্তে: borrow checker যা প্রমাণ করতে পারে না, তা প্রত্যাখ্যান করে, এমনকি কিছু নিরাপদ program-ও; প্রোগ্রামারকে lifetime annotation দিয়ে সাহায্য করতে হয়। Go আর Java ভিন্ন পথে: ভাষায় local-এর ঠিকানা হয় নেওয়া যায় না (Java), নয়তো নিলে compiler নিজেই variable-কে heap-এ সরায় (Go), আর GC নিশ্চিত করে যে পৌঁছানো যায় এমন ঘর মুছবে না। C সবচেয়ে কম বাধ্যবাধকতার প্রান্তে, আর তার জন্য sanitizer (যেমন AddressSanitizer-এর stack-use-after-return পরীক্ষা) আর static analyzer-এর মতো বাড়তি tool-এর ওপর নির্ভর করতে হয়।
মূল উপলব্ধি: lifetime-এর ভুল ধরা মৌলিকভাবে কঠিন। ভাষা হয় নিয়ম কড়া করে প্রমাণযোগ্য করে (Rust), নয়তো runtime-কে দায় দেয় (GC), নয়তো প্রোগ্রামারকে (C); compiler-এর warning শুধু সহজ ক্ষেত্রগুলো ধরে।
প্র ০৩Heap-এ lifetime কে শেষ করবে: প্রোগ্রামার, garbage collector, নাকি compiler-এর নিয়ম? প্রতিটির দাম কী?
প্রোগ্রামার (C-র malloc/free): সবচেয়ে সোজা বাস্তবায়ন, সবচেয়ে কম runtime খরচ, আর ঘর ঠিক কখন ফেরত যাবে তা পুরোপুরি জানা। এজন্যই operating system, embedded কোড আর উচ্চ-গতির library এখনো এই পথে লেখা হয়। দাম হলো দুই ধরনের ভুল: ফেরত দিতে ভুলে গেলে memory leak, আর আগে ফেরত দিয়ে পরে ব্যবহার করলে use-after-free. দ্বিতীয়টি বহু নিরাপত্তা-ত্রুটির উৎস, কারণ ততক্ষণে ঘরটি অন্য ডেটার হাতে।
Garbage collector: lifetime-এর সংজ্ঞা বদলে দেয়: যতক্ষণ কোনো পথে পৌঁছানো যায়, ততক্ষণ বেঁচে থাকে। McCarthy ১৯৬০ সালের LISP প্রবন্ধে এমন একটি ব্যবস্থা বর্ণনা করেন। এতে use-after-free অসম্ভব হয়ে যায়। দাম হলো সময় আর পূর্বানুমান: collector চালাতে CPU লাগে, কিছু collector program-কে কিছুক্ষণ থামায়, আর ঠিক কখন একটি object মুছবে তা বলা যায় না। অংশ ৬-এর run-এ দেখেছেন, CPython-এর reference counting সাধারণ ক্ষেত্রে সঙ্গে সঙ্গে মুছলেও cycle-এর জন্য আলাদা collector লাগে। আর GC-ভাষাতেও leak সম্ভব: অপ্রয়োজনীয় object-এর reference কোথাও (যেমন একটি global cache-এ) রয়ে গেলে collector তাকে জীবিত ধরে।
Compiler-এর নিয়ম (C++-এর RAII, Rust-এর ownership): lifetime-কে আবার scope-এর সঙ্গে বাঁধে, কিন্তু কৌশলে। প্রতিটি heap-ঘরের একজন মালিক, যা সাধারণত একটি stack variable; মালিকের scope শেষ হলে destructor ঘরটি ফেরত দেয়। মালিকানা অন্য variable-এ “move” করা যায়, তাই ঘর function-এর বাইরেও যেতে পারে। C++-এ নিয়মটি কিছুটা স্বেচ্ছায় মানতে হয়; Rust compile-এর সময় তা বাধ্য করে। দাম হলো শেখার কষ্ট আর কিছু নকশার (যেমন দুই দিকে link থাকা গঠন) জটিলতা।
বাস্তবে বহু ভাষা মিশ্রণ ব্যবহার করে: Swift reference counting, Go escape analysis আর GC, Java JIT-এর scalar replacement আর GC. Haat-এর পরের দিকের পর্বে (পর্ব ৭৫) আপনি নিজে একটি mark-sweep collector বানাবেন।
মূল উপলব্ধি: heap-এর lifetime-এর প্রশ্নটি আসলে দায় ভাগের প্রশ্ন। মানুষ, runtime নাকি compiler, কে দায় নেবে তা ঠিক করে নিরাপত্তা, গতি আর সরলতার মধ্যে কোন আপস আপনি মেনে নিচ্ছেন।
প্র ০৪Closure থাকলে variable-কে আর শুধু stack-এ রাখা যায় না কেন? এই সমস্যার ইতিহাস কী?
সমস্যাটির পুরোনো নাম funarg problem (“function argument” থেকে)। দুটি দিক আছে। “Downward” funarg: একটি function আরেকটি function-কে argument হিসেবে পাঠায়, যেমন একটি sort-কে তুলনার function দেওয়া। এখানে ভেতরের function চলে বাইরের frame বেঁচে থাকতেই, তাই stack-এই কাজ হয়ে যায়; ALGOL আর Pascal-এর nested procedure এভাবেই চলত। “Upward” funarg: একটি function ভেতরের function ফেরত দেয়, যেমন আমাদের make_counter. এখানে ভেতরের function চলে বাইরের frame মারা যাওয়ার পরে, তাই তার free variable-গুলো stack-এ রাখা যায় না।
LISP-এর প্রথম দিকের বাস্তবায়নগুলো dynamic scope ব্যবহার করত, আর এই প্রশ্নে অদ্ভুত ফল দিত। ১৯৭০ সালে Joel Moses-এর একটি MIT memo (“The Function of FUNCTION in LISP”) সমস্যাটি স্পষ্ট করে বর্ণনা করে বলে প্রায়ই উদ্ধৃত হয়। Peter Landin আগেই (১৯৬৪) “closure” শব্দটি ব্যবহার করেছিলেন: function-এর কোড আর তার তৈরির সময়ের environment মিলে একটি মান। ১৯৭৫ সালের Scheme lexical scope আর পূর্ণ closure-কে ভাষার কেন্দ্রে বসায়, আর পরে সেই চিন্তা ML, JavaScript, Python আর প্রায় সব আধুনিক ভাষায় ছড়ায়।
বাস্তবায়নের কৌশল তিনটি মোটা দাগে। এক, পুরো frame-কে heap-এ রাখা আর GC-কে দায় দেওয়া (কিছু Scheme বাস্তবায়ন)। দুই, শুধু ধরা variable-গুলোকে আলাদা heap-cell-এ তোলা, বাকিদের stack-এ রাখা; Haat reference-এর MAKE_CELL আর CPython-এর cell variable এই পথের। তিন, ধরা variable যদি কখনো বদলায় না, তাহলে closure তৈরির সময় মানটিই কপি করে নেওয়া; C++-এর lambda-র [=] capture বা Java-র “effectively final” নিয়ম এর কাছাকাছি, যা পর্ব ১৭-এ আসবে। দ্বিতীয় আর তৃতীয় কৌশলে compiler-কে compile-এর সময়েই জানতে হয় কোন variable ধরা হয়েছে আর কোনটি বদলায়: অর্থাৎ escape analysis-এর একটি সরল রূপ।
মূল উপলব্ধি: first-class function আর শুধু-stack storage একসঙ্গে টেকে না। Closure-ওয়ালা ভাষা হয় heap-এ environment রাখে, নয়তো মান কপি করে; আর কোন variable-এর কী দরকার, তা ঠিক করা compiler-এর name resolution-এর কাজ।
প্র ০৫আধুনিক যুগেও static allocation কোথায় পছন্দের, আর তার ঝুঁকি কী?
Microcontroller-এ চলা embedded software-এ (ধরুন একটি ডিজিটাল ওজন মাপার যন্ত্র বা গাড়ির brake-নিয়ন্ত্রক) মেমরি কয়েক কিলোবাইট, আর program বছরের পর বছর না থেমে চলে। এখানে heap বিপজ্জনক: বহু ছোট-বড় ঘর নেওয়া-ফেরত দেওয়ার পরে খালি জায়গা টুকরো টুকরো (fragmentation) হয়ে যেতে পারে, আর একদিন যথেষ্ট বড় ঘর না পেয়ে malloc ব্যর্থ হতে পারে, এমন সময়ে যা আগে থেকে বলা যায় না। এজন্য নিরাপত্তা-সংবেদনশীল C কোডের নির্দেশিকা, যেমন MISRA C, সাধারণভাবে dynamic memory allocation এড়াতে বলে বলে জানা যায়। পছন্দের ধরন: সব buffer আর টেবিল static, মাপ compile-এর সময়েই নির্দিষ্ট, আর linker-এর হিসাবেই বোঝা যায় program মেমরিতে আঁটবে কি না।
Static allocation-এর আরেকটি সুবিধা সময়ের পূর্বানুমান: ঠিকানা স্থির, কোনো allocator-এর খোঁজাখুঁজি নেই, কোনো GC-বিরতি নেই। Real-time ব্যবস্থায়, যেখানে একটি কাজ নির্দিষ্ট মাইক্রোসেকেন্ডের মধ্যে শেষ হতেই হবে, এটি বড় গুণ।
ঝুঁকিগুলো অংশ ৫-এ দেখা গেছে। এক, reentrancy: static local থাকা function interrupt handler বা অন্য thread থেকে একই সময়ে ডাকা হলে দুই ডাক একই ঘর ভাগ করে; C library-র strtok আর কিছু পুরোনো সময়-ফাংশন (যেমন localtime) এভাবে একটি ভাগ করা static buffer ফেরত দেয়, আর POSIX তাদের _r-যুক্ত বিকল্প দেয়। দুই, recursion চলে না। তিন, লুকানো state: function-এর বাইরে থেকে দেখা যায় না যে সে আগের ডাক মনে রাখছে, তাই পরীক্ষা কঠিন হয়; একই ইনপুটে আলাদা উত্তর আসে, পর্ব ০৭-এর side effect-এর মতো। C11 এর একটি আংশিক সমাধান দিয়েছে _Thread_local দিয়ে: প্রতিটি thread-এর নিজের static ঘর, lifetime সেই thread-এর জীবন।
Haat-এর ক্ষেত্রেও এই আপস চোখে পড়ে: Haat v1-এ static local নেই, তার বদলে top-level var বা closure-এর cell দিয়ে একই কাজ হয়, আর অনুশীলন ১-এ আপনি নিজে একটি static var নকশা করবেন।
মূল উপলব্ধি: static allocation পুরোনো হলেও বাতিল নয়। যেখানে পূর্বানুমান আর নির্ভরযোগ্যতা সবচেয়ে দামি, সেখানে এটিই প্রথম পছন্দ; কিন্তু ভাগ করা ঘরের দাম, reentrancy আর লুকানো state, মাথায় রেখেই।
অনুশীলন
প্রথমে নিজে করুন, তারপর উত্তর খুলে মেলান। প্রতিটি আউটপুট সত্যিকারের Haat reference বা Clang 22.1.8-এ চালিয়ে মেলানো।
-
নকশা ও বাস্তবায়ন — Haat-এর বর্ধিত রূপ
static var: ধরুন Haat-এ function-এর ভেতরেstatic var count = 0;লেখা যাবে, C-র static local-এর মতো। (ক) এর scope, lifetime আর initializer কখন চলবে, নিয়ম লিখুন। (খ) এটিকে Haat v1-এর কোডে desugar করার (ছোট core-এ নামানোর) একটি নিয়ম দিন, যাতে নতুন VM নির্দেশ না লাগে। (গ) নিচের program desugar করে reference-এ চালান।fn next_id() -> Int { static var count = 0; // Haat-এর বর্ধিত রূপ count = count + 1; return count; } print(next_id()); print(next_id()); print(next_id());(ক) নিয়ম: scope C-র মতো: ঘোষণার পর থেকে সেই block-এর শেষ পর্যন্ত, function-এর বাইরে অচেনা। Lifetime পুরো run, সব call একটিই ঘর ভাগ করে। Initializer একবারই চলে, program-এর শুরুতে, অন্য সব top-level লাইনের আগে; তাই C-র মতো initializer-কে একটি constant expression হতে হবে (কোনো variable বা call নয়), নইলে “কখন চলবে” প্রশ্নটি আবার জটিল হয়।
(খ) Desugar: প্রতিটি
static var x = c;-কে program-এর একেবারে শুরুতে একটি top-levelvarবানান, আর function-এর ভেতরে x-এর প্রতিটি ব্যবহার সেই নতুন নামে বদলান। নতুন নাম এমন হতে হবে যা ব্যবহারকারীর কোনো নামের সঙ্গে না মেলে; এখানেnext_id__countনেওয়া হলো, কিন্তু Haat-এর identifier-এ__বৈধ, তাই বাস্তব compiler-কে আগে পরীক্ষা করতে হবে যে নামটি খালি আছে (বা ব্যবহারকারীর জন্য নিষিদ্ধ একটি prefix রাখতে হবে)। নতুনvarফাইলের শুরুতে বসানোয় নকশা-সিদ্ধান্ত ১৮-এর শর্তও মেটে: function-এর আগে ঘোষিত, আর অন্য কোনো লাইন চলার আগেই শুরু হয়, তাইnot initialized yetহতে পারে না।// Haat-এর বর্ধিত রূপ static var, desugar করার পরে var next_id__count = 0; fn next_id() -> Int { next_id__count = next_id__count + 1; return next_id__count; } print(next_id()); print(next_id()); print(next_id()); ~/haat $ python haat.py run static_desugar.haat 1 2 3(গ) সত্যিকারের run,
runআরvmদুটিতেই 1, 2, 3. একটি সীমা খেয়াল করুন: desugar-এর পরে নামটির scope বড় হয়ে গেছে (পুরো ফাইল), যদিও ব্যবহারকারী তা লিখতে পারবেন না বলে ধরে নিচ্ছি। আরেকটি বিকল্প হলো closure দিয়ে desugar: একটি বাইরের function-এvar countরেখে ভেতরের function ফেরত দেওয়া, অংশ ৮-এরmake_counter-এর মতো; তখন scope ঠিক থাকে, কিন্তু প্রতিটি call-এ cell-এর একটি বাড়তি পথ লাগে। -
ভুল খুঁজুন: একজন বাজারঘরের রসিদের জন্য নিচের C17 function লিখেছেন।
-Wall -Wextraদিয়ে compile করলে কী হবে? ভুলটি কী, আর তিনটি সমাধানের মধ্যে কোনটি কখন ভালো?const char *order_label(int no) { char buf[16]; snprintf(buf, sizeof buf, "BG-%05d", no); return buf; }bufএকটি stack-dynamic array; function ফেরার সঙ্গে সঙ্গে তার lifetime শেষ, অথচ তার ঠিকানা ফেরত যাচ্ছে (array-এর নাম এখানে প্রথম ঘরের ঠিকানা হয়ে যায়)। ডাকা-পক্ষ যা পাবে তা dangling pointer, আর পড়া undefined behavior. Clang 22.1.8-এর সত্যিকারের বার্তা:label.c:6:12: warning: address of stack memory associated with local variable 'buf' returned [-Wreturn-stack-address] 6 | return buf; | ^~~তিনটি সমাধান: (১)
static char buf[16];: lifetime পুরো run, তাই আর dangling নয়; কিন্তু সব call একই buffer ভাগ করে, তাইprintf("%s %s", order_label(1), order_label(2))দুবার একই লেবেল দেখাতে পারে, আর thread-এর মধ্যে নিরাপদ নয়। ছোট, single-thread program-এ চলে। (২) ডাকা-পক্ষ buffer দিক:void order_label(int no, char *out, size_t size); lifetime ডাকা-পক্ষের হাতে, কোনো ভাগাভাগি নেই। লেখকের যন্ত্রে এই রূপ-Wall -Wextra-এ কোনো warning ছাড়া চলে আরBG-00042ছাপে। সাধারণভাবে এটিই সবচেয়ে ভালো, C library-ও (snprintfনিজেই) এই নিয়ম মানে। (৩)mallocকরে ফেরত দেওয়া: যেকোনো মাপের লেবেল সম্ভব, কিন্তু ডাকা-পক্ষকেfreeমনে রাখতে হবে, নইলে leak. -
আউটপুট অনুমান করুন: নিচের Haat program কী ছাপবে? শেষে
x-এর কয়টি ঘর (cell) বেঁচে আছে?fn make_box(v: Int) -> () -> Int { var x = v; fn get() -> Int { x = x * 2; return x; } return get; } let a = make_box(3); let b = a; print(a()); print(b()); let c = make_box(3); print(c()); print(a());ছাপা হবে
6,12,6,24; Haat reference-এরrunআরvmদুটিতেই হুবহু এই চারটি লাইন। কারণ:let b = a;নতুন closure বানায় না, একই closure-এর দ্বিতীয় নাম (aliasing), তাইa()আরb()একই cell বদলায়: 3 → 6 → 12.make_box(3)আবার ডাকলে নতুন frame, নতুনMAKE_CELL, তাইc-এর cell আলাদা আর 3 থেকে শুরু: 6. শেষেa()প্রথম cell-কে 12 থেকে 24 করে। শেষেx-এর ২টি cell বেঁচে আছে: একটিaআরbদুজনের ভাগে, একটিc-এর।vআর দুটিmake_boxframe-এর বাকি সব ঘরের lifetime অনেক আগেই শেষ। -
প্রমাণ — কখন dangling অসম্ভব: ধরুন একটি ভাষায় শুধু static আর stack-dynamic variable আছে; কোনো pointer বা reference নেই, function first-class নয় (argument বা ফেরত মান হিসেবে যায় না), কিন্তু nested function থাকতে পারে, আর static scoping. প্রমাণ করুন: এই ভাষায় কোনো নাম কখনো এমন ঘর দেখায় না যার lifetime শেষ।
প্রমাণের রূপরেখা। দেখাতে হবে: চলার সময় যে মুহূর্তে কোনো কোড নাম x ব্যবহার করে, সেই মুহূর্তে x-এর ঘোষণার ঘরটি জীবিত।
- Static x: lifetime পুরো run, তাই যেকোনো ব্যবহারের সময় জীবিত।
- Stack-dynamic x, ঘোষিত function F-এ: static scoping অনুযায়ী x ব্যবহার করতে পারে শুধু F-এর লেখার ভেতরের কোড, অর্থাৎ F নিজে বা F-এর ভেতরে লেখা nested function G.
- F নিজে x ব্যবহার করলে F-এর একটি ডাক তখন চলছে, আর সেই ডাকের frame stack-এ আছে, তাই x জীবিত (ঘোষণার আগে ব্যবহার ভাষার নিয়মে নিষিদ্ধ ধরে নিচ্ছি)।
- G ব্যবহার করলে: G-কে ডাকা যায় শুধু তার নামে, আর নামটি scope-এ আছে শুধু F-এর ভেতরে। Function first-class নয়, তাই G-কে F-এর বাইরে পাঠানো বা ফেরত দেওয়া যায় না। কাজেই G-এর যেকোনো ডাক এমন একটি call-শৃঙ্খলের ভেতরে ঘটে যা F-এর কোনো চলমান ডাক থেকে শুরু; সেই F-এর frame LIFO নিয়মে G ফেরার আগে সরতে পারে না।
- Pointer বা reference নেই, তাই x-এর ঘরে পৌঁছানোর একমাত্র পথ তার নাম; ধাপ ১–৪ সব নাম-ব্যবহারকে ঢেকে দেয়। ∎
প্রতিটি শর্ত কেন লাগল, তা উল্টো দিক থেকে দেখুন: pointer যোগ করলে C-র
return &total(অংশ ৭); first-class function যোগ করলে upward funarg, যা Haat closure-এর cell দিয়ে সমাধান করে (অংশ ৮); dynamic scope নিলে ধাপ ২ ভেঙে যায়। Pascal মোটামুটি এই নকশাই নিয়েছিল: nested procedure আছে, procedure-কে argument হিসেবে পাঠানো যায় (downward), কিন্তু ফেরত দেওয়া যায় না, আর pointer শুধু heap-এর দিকে।
নিজেকে যাচাই করুন
ভুল হলে কারণসহ ব্যাখ্যা পাবেন, আবার চেষ্টাও করতে পারবেন।
ক্রমHaat-এ fn make_counter(start: Int) -> () -> Int { var next = start; fn take() -> Int { next = next + 1; return next; } return take; } আর let dhaka = make_counter(100); print(dhaka()); চলার ঘটনাগুলো সঠিক ক্রমে সাজান (▲▼ চেপে সরান)
- make_counter-এর frame stack-এ ওঠে, start = 100
- MAKE_CELL: next-এর মান 100 heap-এর একটি cell-এ
- MAKE_CLOSURE: take সেই cell ধরে রাখে
- RETURN: frame সরে যায়, cell বেঁচে থাকে
- dhaka() চলে, cell-এ 101 লেখা হয় আর ছাপা হয়
একটি variable-এর scope আর lifetime-এর পার্থক্য কোনটি সঠিকভাবে বলে?
- Scope চলার সময়ের ব্যবধান, lifetime source code-এর এলাকা
- Scope কোডের কোন অংশে নামটি দেখা যায়; lifetime চলার সময় ঘরটি কতক্ষণ বরাদ্দ থাকে
- দুটি একই জিনিসের দুই নাম, সব ভাষায় সবসময় সমান
- Scope শুধু global variable-এর থাকে, lifetime শুধু heap-এর
C17-এ int f(void) { static int n = 0; n = n + 1; return n; } তিনবার পরপর ডাকলে ফেরত মানগুলো কী, আর n কোন শ্রেণির variable?
- 1, 1, 1; stack-dynamic
- 1, 2, 3; stack-dynamic
- 1, 2, 3; static
- 0, 1, 2; explicit heap-dynamic
Python-এ x = 5 আর পরে x = [1, 2] লিখলে x-এর মানের ঘরগুলো কোন শ্রেণির, Sebesta-র শ্রেণিবিভাগে?
- Static
- Stack-dynamic
- Explicit heap-dynamic
- Implicit heap-dynamic
C17-এ একটি function তার local int total-এর ঠিকানা return &total; দিয়ে ফেরত দেয়, আর ডাকা-পক্ষ *p পড়ে। কোনটি সঠিক?
- এটি undefined behavior; compiler warning দিতে পারে, কিন্তু কোনো ফলের নিশ্চয়তা নেই
- সবসময় পুরোনো মান পাওয়া যায়, কারণ stack-এর byte মোছা হয় না
- C standard অনুযায়ী এটি একটি compile error
- Compiler নিজে থেকেই total-কে heap-এ সরিয়ে নিরাপদ করে
যে ভাষায় সব local variable static ঘরে রাখা হয় (প্রথম দিকের FORTRAN বাস্তবায়নের মতো), সেখানে কোন জিনিসটি সাধারণভাবে কাজ করে না?
- While loop
- Recursion
- Global variable
- Function থেকে মান ফেরত দেওয়া
Haat program: fn make_counter(start: Int) -> () -> Int { var next = start; fn take() -> Int { next = next + 1; return next; } return take; } তারপর let d = make_counter(100); let c = make_counter(500); print(d()); print(d()); print(c()); কী ছাপবে?
- 101, 101, 501
- 101, 102, 103
- 101, 102, 501
- Type error, কারণ Haat-এ function ফেরত দেওয়া যায় না
Escape analysis বলতে compiler-এর কোন কাজ বোঝায়?
- String-এর ভেতরের escape sequence বুঝে নেওয়া
- কোন exception function থেকে বেরিয়ে যাবে তা খোঁজা
- Loop থেকে বেরোনোর সব পথ খুঁজে বের করা
- কোনো variable বা object function-এর বাইরে পৌঁছাতে পারে কি না দেখে stack না heap ঠিক করা
শব্দকোষ
লেখার মধ্যে ডটেড দাগ দেওয়া শব্দে মাউস রাখুন বা চাপুন — অর্থ দেখাবে। এই পর্বের সব নতুন শব্দ এখানে একসাথে:
মনে রাখুন
- Scope লেখার এলাকা, lifetime চলার সময়ের ব্যবধান। চার সম্পর্ক: প্রায় সমান, lifetime বড় (static local, closure), নাম আছে ঘর নেই (
let-এর আগে), ঘর নেই পথ আছে (dangling). - চার শ্রেণি: static (পুরো run, recursion নয়), stack-dynamic (প্রতি call নতুন ঘর), explicit heap-dynamic (malloc/new থেকে free বা GC), implicit heap-dynamic (মান বসালেই ঘর)।
- মেমরির এলাকা: text, data, bss, heap, stack. Clang 22.1.8-এ
static int countবসেছে একটি স্থির, নাম-দেওয়া ঘরে, আর-O2-এ stack-dynamicstepপুরো মুছে গেছে। - Local-এর ঠিকানা ফেরত দেওয়া dangling pointer: Clang-এর
-Wreturn-stack-addresswarning, ব্যবহার undefined behavior. সমাধান: মান ফেরত, ডাকা-পক্ষের ঘর, অথবা heap আর স্পষ্টfree. - Closure ধরা variable-কে heap-এর cell-এ তোলে (Haat-এ
MAKE_CELL,LOAD_FREE), তাই frame শেষ হলেও বাঁচে; কোন variable কোথায় বসবে, তা escape analysis-এর মতো বিশ্লেষণ দিয়ে compiler ঠিক করে।
আরও পড়ুন · ABCL TECH-এ আপনার পরবর্তী পদক্ষেপ
- পর্ব ১৭ · Closure — lexical environment ধরে রাখা functionপরবর্তী পর্বFunction আর তার পরিবেশ: capture-এর নিয়ম আর বাস্তবায়ন।
- প্রোগ্রামিং ভাষা ও কম্পাইলার · কোর্স হোম৮৬টি পর্বপুরো কোর্সের মানচিত্র আর Haat প্রজেক্টের পথ।
- স্কোপ ও স্টোরেজ ক্লাস — কোথায় দেখা যায়, কতক্ষণ বাঁচেপাশের ট্র্যাকC-র auto, static, extern আর register হাতে-কলমে।
- প্রসেস — state, PCB আর memory layoutপাশের ট্র্যাকOperating system-এর চোখে text, data, heap আর stack.
- JVM মেমরি আর garbage collectionপাশের ট্র্যাকHeap, GC root আর আধুনিক collector.