রানটাইম এনভায়রনমেন্ট ও গার্বেজ কালেকশন

১ · রানটাইম এনভায়রনমেন্ট — এখন পর্যন্ত শেখা সবকিছুর সংশ্লেষণ

রানটাইম এনভায়রনমেন্টRuntime Environmentএকটি কম্পাইল/ইন্টারপ্রেট হওয়া প্রোগ্রাম চলার সময় যে সাপোর্ট ইনফ্রাস্ট্রাকচারের উপর নির্ভর করে — শুধু জেনারেট হওয়া রও ইনস্ট্রাকশন নয়, তার সাথে সংশ্লিষ্ট মেমরি ব্যবস্থাপনাও। — এতে আছে কল স্ট্যাক (M11/L48-এ বিস্তারিত — প্রতিটি সাবপ্রোগ্রাম কলের অ্যাক্টিভেশন রেকর্ড), হিপ (M8/L39-এর হিপ-ডায়নামিক স্টোরেজ ক্যাটাগরি), এবং (এই পাঠের মূল নতুন বিষয়) স্বয়ংক্রিয় মেমরি ম্যানেজমেন্ট।

২ · ম্যানুয়াল মেমরি ম্যানেজমেন্ট — দুই ক্লাসিক বাগ

C-এর malloc/free-এর মতো ভাষায় প্রোগ্রামার নিজেই স্পষ্টভাবে হিপ মেমরি চেয়ে নেয় ও মুক্ত করে দেয় — এবং এটি সততার সাথে বলতে হয় খুবই ত্রুটিপ্রবণ। দুটো ক্লাসিক বাগ:

• মেমরি লিক (Memory Leak): এমন হিপ মেমরি যা আর reachable/ব্যবহারযোগ্য নয়, কিন্তু কখনো স্পষ্টভাবে free করা হয়নি — অনির্দিষ্টকালের জন্য মেমরি অপচয় হতে থাকে।
• ড্যাংলিং পয়েন্টার (Dangling Pointer) / use-after-free: যে মেমরি ইতিমধ্যে free হয়ে গেছে, তার একটি পয়েন্টার/রেফারেন্স এখনো থেকে যায় এবং সেটি পরে ব্যবহার করা হয় — M10/L47-এর পয়েন্টার-ডিরেফারেন্স ঝুঁকির সরাসরি বিস্তার, একটি গুরুতর ও সাধারণ বাস্তব বাগ শ্রেণি।

৩ · গার্বেজ কালেকশন ও রেফারেন্স কাউন্টিং

গার্বেজ কালেকশনGarbage Collection (GC)রানটাইম স্বয়ংক্রিয়ভাবে যে হিপ মেমরি আর কোনো সক্রিয় রেফারেন্স থেকে reachable নয়, তা চিহ্নিত করে রিক্লেইম করার প্রক্রিয়া — Python, Java, JavaScript, Go-সহ বেশিরভাগ আধুনিক ভাষার পদ্ধতি। একটি অবজেক্ট "reachable" যদি এটি বর্তমানে সক্রিয় কোনো স্কোপ/অ্যাক্টিভেশন রেকর্ডের (M11/L48) কোনো ভ্যারিয়েবল (M8/L37-এর বাইন্ডিং) থেকে সরাসরি বা পরোক্ষভাবে অন্য কোনো reachable অবজেক্টের মাধ্যমে পৌঁছানো যায়।

রেফারেন্স কাউন্টিংReference Countingপ্রতিটি হিপ অবজেক্ট নিজের একটি কাউন্ট রাখে — কতগুলো রেফারেন্স এই মুহূর্তে তাকে নির্দেশ করছে; নতুন রেফারেন্স তৈরি হলে কাউন্ট বাড়ে, রেফারেন্স মুছে গেলে/স্কোপ থেকে বেরিয়ে গেলে কাউন্ট কমে; কাউন্ট শূন্যে পৌঁছালেই অবজেক্ট সাথে সাথে রিক্লেইম হয়। Python-এর প্রকৃত প্রাইমারি GC কৌশল এটাই (M13/L55-এ আরও বিস্তারিত)।

৪ · সীমাবদ্ধতা — রেফারেন্স সাইকেল

বিশুদ্ধ রেফারেন্স কাউন্টিং-এর একটি গুরুত্বপূর্ণ সীমাবদ্ধতা আছে — পারস্পরিকভাবে একে অপরকে রেফারেন্স করা অবজেক্টের সাইকেল (অবজেক্ট A অবজেক্ট B-কে রেফারেন্স করে, B আবার A-কে রেফারেন্স করে, কিন্তু কেউই কোনো সক্রিয় স্কোপ থেকে reachable নয়) কখনোই তাদের রেফারেন্স কাউন্ট শূন্যে পৌঁছাতে দেবে না — যদিও তারা প্রকৃতপক্ষে reachable নয়, তবুও genuine garbage। বাস্তব রেফারেন্স-কাউন্টিং সিস্টেম (Python-সহ) তাই একটি পৃথক সাইকেল-ডিটেক্টিং মেকানিজম প্রয়োজন করে এই বিশেষ কেসটি হ্যান্ডেল করার জন্য।

৫ · বাস্তবায়ন — স্বাভাবিক কালেকশন বনাম রেফারেন্স সাইকেল

নিচের কোড সেলে দুটো কেস দেখানো হয়েছে — প্রথমে একটি সাধারণ, চক্রবিহীন অবজেক্ট সঠিকভাবে কালেক্ট হচ্ছে; তারপর দুটো অবজেক্ট A ও B একে অপরকে রেফারেন্স করছে (একটি সাইকেল), বাইরের একমাত্র root রেফারেন্স রিলিজ হওয়ার পরেও উভয়ের ref_count শূন্যের উপরে আটকে থাকছে — যদিও তারা কোনো root থেকে আর reachable নয়।

class RefCountedObject:
    """প্রতিটি অবজেক্ট নিজের ref_count রাখে -- কতগুলো রেফারেন্স এই মুহূর্তে তাকে নির্দেশ করছে।"""
    def __init__(self, name):
        self.name = name
        self.ref_count = 0
        self.points_to = []   # এই অবজেক্ট অন্য কাকে রেফারেন্স করছে (সাইকেল দেখানোর জন্য)
        self.collected = False

    def add_ref(self):
        self.ref_count += 1

    def remove_ref(self):
        self.ref_count -= 1
        if self.ref_count <= 0 and not self.collected:
            self.collected = True
            print(f"  [কালেক্টেড] {self.name}: ref_count শূন্যে পৌঁছেছে, মেমরি রিক্লেইম হলো")


def is_reachable_from_roots(obj, roots):
    """একটি অবজেক্ট এখনো কোনো root (সক্রিয় স্কোপের ভ্যারিয়েবল) থেকে reachable কিনা যাচাই করে।"""
    visited = set()
    def dfs(o):
        if id(o) in visited:
            return False
        visited.add(id(o))
        if o is obj:
            return True
        return any(dfs(p) for p in o.points_to)
    return any(dfs(r) for r in roots)


print("== কেস ১: স্বাভাবিক, চক্রবিহীন রেফারেন্স কাউন্টিং ==")
x = RefCountedObject("X")
x.add_ref()
print("X-এর ref_count (১টি root রেফারেন্সের পর):", x.ref_count)
x.remove_ref()
print("X-এর ref_count (root রেফারেন্স রিলিজের পর):", x.ref_count, " collected:", x.collected)

print("\n== কেস ২: ইচ্ছাকৃত রেফারেন্স সাইকেল (A <-> B), কোনো external root ছাড়া ==")
a = RefCountedObject("A")
b = RefCountedObject("B")

a.add_ref()                          # একটি root ভ্যারিয়েবল সাময়িকভাবে A-কে রেফারেন্স করছে
a.points_to.append(b); b.add_ref()   # A -> B রেফারেন্স
b.points_to.append(a); a.add_ref()   # B -> A রেফারেন্স (সাইকেল সম্পূর্ণ)

print("সাইকেল তৈরির পর: A.ref_count =", a.ref_count, " B.ref_count =", b.ref_count)

a.remove_ref()                       # একমাত্র root রেফারেন্সটি স্কোপ থেকে বেরিয়ে গেল
print("root রিলিজের পর:  A.ref_count =", a.ref_count, " B.ref_count =", b.ref_count)
print("A collected?", a.collected, " B collected?", b.collected)

roots = []   # আর কোনো root A বা B-কে নির্দেশ করছে না
print("A এখনো কোনো root থেকে reachable?", is_reachable_from_roots(a, roots))
print("B এখনো কোনো root থেকে reachable?", is_reachable_from_roots(b, roots))

print("\nউপসংহার: A ও B উভয়েরই ref_count > 0, অথচ কোনো root থেকেই তারা reachable নয়")
print("-- এটাই বিশুদ্ধ রেফারেন্স কাউন্টিং-এর সাইকেল-সীমাবদ্ধতা, কনক্রিটভাবে প্রমাণিত।")