FFI ও ABI — ভিন্ন ভাষারা একে অপরকে ডাকে যেভাবে

লক্ষ্য: hood-এর ownership matrix-এর তৃতীয় সারি (hand-off) পুরোপুরি বাস্তবে — দুই জগতের কেউ কারো মেমরি না চুরি করে একই object share করবে।

/* libhandle.c — refcounted handle-এর C পাশ */
/* compile: gcc -shared -fPIC -o libhandle.so libhandle.c */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

typedef struct {
    int  id;
    int  refs;
    char tag[24];
} Handle;

static int next_id = 1;

Handle *handle_new(const char *tag) {
    Handle *h = malloc(sizeof(Handle));
    h->id = next_id++;
    h->refs = 1;                      /* caller-এর হাতে ঠিক ১টা reference */
    snprintf(h->tag, sizeof(h->tag), "%s", tag);
    fprintf(stderr, "[C] new     id=%d refs=%d (%s)\n", h->id, h->refs, h->tag);
    return h;
}

void handle_retain(Handle *h) {
    h->refs++;
    fprintf(stderr, "[C] retain  id=%d refs=%d\n", h->id, h->refs);
}

void handle_release(Handle *h) {
    h->refs--;
    fprintf(stderr, "[C] release id=%d refs=%d\n", h->id, h->refs);
    if (h->refs == 0) {
        fprintf(stderr, "[C] FREE    id=%d — হিসাব শেষ\n", h->id);
        free(h);
    }
}

int handle_id(const Handle *h) { return h->id; }

"""handle.py — ownership handoff মেনে চলা ctypes wrapper"""
import ctypes
import os

_lib = ctypes.CDLL(os.path.join(os.path.dirname(os.path.abspath(__file__)),
                                "libhandle.so"))


class CHandle(ctypes.Structure):
    _fields_ = [("id", ctypes.c_int),
                ("refs", ctypes.c_int),
                ("tag", ctypes.c_char * 24)]


_lib.handle_new.restype = ctypes.POINTER(CHandle)
_lib.handle_new.argtypes = [ctypes.c_char_p]
_lib.handle_retain.argtypes = [ctypes.POINTER(CHandle)]
_lib.handle_release.argtypes = [ctypes.POINTER(CHandle)]
_lib.handle_id.argtypes = [ctypes.POINTER(CHandle)]
_lib.handle_id.restype = ctypes.c_int


class Handle:
    """Python-পাশের owner: release-এর একমাত্র দরজা __del__"""

    def __init__(self, tag):
        self._ptr = _lib.handle_new(tag.encode())

    def share(self):
        """hand-off: নতুন owner — তাই retain আবশ্যক, নইলে ভবিষ্যতে
        দুইজন release করবে = double-free"""
        _lib.handle_retain(self._ptr)
        twin = Handle.__new__(Handle)
        twin._ptr = self._ptr
        return twin

    @property
    def id(self):
        return _lib.handle_id(self._ptr)

    def __del__(self):
        ptr = getattr(self, "_ptr", None)
        if ptr is not None:
            _lib.handle_release(ptr)
            self._ptr = None        # resurrection-এর বিরুদ্ধে বীমা


if __name__ == "__main__":
    a = Handle("database")            # refs 1
    b = a.share()                     # refs 2 — এখন দুই owner
    print("ids:", a.id, b.id)
    del b                             # refs 2 → 1 — a এখনো বাঁচিয়ে আছে
    print("a alive after del b:", a.id)
    del a                             # refs 1 → 0 — C-side FREE log দেখুন
    print("end — কোনো leak না, কোনো double-free না")

gcc -shared -fPIC -o libhandle.so libhandle.c
python3 handle.py

Output (pipe-এ: stderr unbuffered, stdout block-buffered — তাই [C] log আগে; terminal-এ interleave হবে):

[C] new     id=1 refs=1 (database)
[C] retain  id=1 refs=2
[C] release id=1 refs=1
[C] release id=1 refs=0
[C] FREE    id=1 — হিসাব শেষ
ids: 1 1
a alive after del b: 1
end — কোনো leak না, কোনো double-free না

শেষের release refs=0 + FREE টা interpreter shutdown-এ a-র __del__ থেকে — refcount-এর deterministic finalization, GC লেসনের স্মৃতি। দুইবার release হয়নি, leak হয়নি — protocol কাজ করেছে।

নিজে বাড়ান:

1. share()-এ retain লাইনটা মুছে দিন আর দুই del করুন — double-free-এর crash/glibc abort message-টা পড়ুন। এটাই protocol-ভাঙার দাম।
2. Context manager (__enter__/__exit__) যোগ করুন — scope-borrowed pattern-এর Python রূপ।
3. Weakref registry যোগ করুন: একই C pointer-এ দ্বিতীয় Python wrapper বানানো ঠেকান (identity map) — নইলে দুই wrapper-ই __del__-এ release করবে।
4. valgrind (valgrind --leak-check=full python3 handle.py) চালিয়ে প্রমাণ করুন zero leaks — তারপর একটা release comment করে আবার চালিয়ে leak report পড়ুন।