চূড়ান্ত প্রকল্প — একটি সম্পূর্ণ OS কার্নেল সিমুলেশন

from collections import OrderedDict

class PCB:
    """M2/L06 -- প্রতি প্রসেসের প্রোসেস কন্ট্রোল ব্লক।"""
    def __init__(self, pid, priority):
        self.pid = pid
        self.state = "New"
        self.priority = priority
        self.page_table = {}   # page_number -> frame_number (শুধু resident পেজ)

class Semaphore:
    """M5/L18 -- ঠিক সেই সেমাফোর ক্লাস, wait()/signal()।"""
    def __init__(self, value=1):
        self.value = value
        self.waiting = []
    def wait(self, pid):
        self.value -= 1
        if self.value < 0:
            self.waiting.append(pid)
            return False       # ব্লকড
        return True            # সাথে সাথে ঢুকলো
    def signal(self):
        self.value += 1
        if self.value <= 0 and self.waiting:
            return self.waiting.pop(0)   # যাকে জাগানো হলো, তার pid
        return None

class TinyKernel:
    def __init__(self, num_frames, disk_block_count):
        self.processes = {}                     # M2/L06 -- প্রসেস টেবিল
        self.ready_queue = []
        self.free_frames = list(range(num_frames))
        self.frame_table = OrderedDict()         # frame -> (pid, page) ; অর্ডার = LRU রিসেন্সি
        self.shared_counter = 0                  # M5/L18
        self.shared_mutex = Semaphore(1)
        self.files = {}                          # M9/L39 -- filename -> index_block
        self.disk = [None] * disk_block_count
        self.free_disk_blocks = list(range(disk_block_count))
        self.log = []

    def _log(self, msg):
        self.log.append(msg)

    # ---------- M2/L05-06: প্রসেস ও PCB ----------
    def create_process(self, pid, priority):
        pcb = PCB(pid, priority)
        pcb.state = "Ready"
        self.processes[pid] = pcb
        self.ready_queue.append(pid)
        self._log(f"[প্রসেস] {pid} তৈরি (priority={priority}) -> Ready")

    def schedule_next(self):
        """M3/L54 -- pluggable dispatcher, এখানে প্রায়োরিটি-ভিত্তিক।"""
        ready = [pid for pid in self.ready_queue if self.processes[pid].state == "Ready"]
        if not ready:
            self._log("[শিডিউলার] কোনো Ready প্রসেস নেই")
            return None
        chosen = min(ready, key=lambda pid: self.processes[pid].priority)
        self.processes[chosen].state = "Running"
        self._log(f"[শিডিউলার] {chosen} নির্বাচিত হলো -> Running")
        return chosen

    def terminate(self, pid):
        pcb = self.processes[pid]
        for page_number, frame in list(pcb.page_table.items()):
            del self.frame_table[frame]
            self.free_frames.append(frame)
            self._log(f"[মেমরি] {pid} টার্মিনেট -> ফ্রেম {frame} মুক্ত হলো")
        pcb.page_table.clear()
        pcb.state = "Terminated"
        self._log(f"[প্রসেস] {pid} টার্মিনেটেড")

    # ---------- M7-M8/L29,L32,L34: ডিমান্ড পেজিং + LRU ----------
    def access_page(self, pid, page_number):
        pcb = self.processes[pid]
        if page_number in pcb.page_table:
            frame = pcb.page_table[page_number]
            self.frame_table.move_to_end(frame)
            self._log(f"[মেমরি] {pid} পেজ {page_number} -> HIT (ফ্রেম {frame})")
            return frame
        self._log(f"[মেমরি] {pid} পেজ {page_number} -> PAGE FAULT")
        if self.free_frames:
            frame = self.free_frames.pop(0)
        else:
            evict_frame, (evict_pid, evict_page) = self.frame_table.popitem(last=False)
            del self.processes[evict_pid].page_table[evict_page]
            frame = evict_frame
            self._log(f"[মেমরি] LRU evict -> {evict_pid}-এর পেজ {evict_page}, ফ্রেম {frame} খালি করা হলো")
        pcb.page_table[page_number] = frame
        self.frame_table[frame] = (pid, page_number)
        self.frame_table.move_to_end(frame)
        self._log(f"[মেমরি] {pid}-এর পেজ {page_number} -> ফ্রেম {frame}-এ লোড হলো")
        return frame

    # ---------- M5/L18: সেমাফোর-সুরক্ষিত শেয়ার্ড রিসোর্স ----------
    def sem_wait(self, pid):
        proceeded = self.shared_mutex.wait(pid)
        if proceeded:
            self._log(f"[সিনক্রোনাইজেশন] {pid} সেমাফোর পেলো -> critical section-এ ঢুকলো")
        else:
            self.processes[pid].state = "Waiting"
            self._log(f"[সিনক্রোনাইজেশন] {pid} সেমাফোর না পেয়ে Waiting-এ গেলো")
        return proceeded

    def modify_shared_resource(self, pid, amount):
        self.shared_counter += amount
        self._log(f"[শেয়ার্ড রিসোর্স] {pid} কাউন্টার পরিবর্তন করলো -> এখন {self.shared_counter}")

    def sem_signal(self, pid):
        woken = self.shared_mutex.signal()
        self._log(f"[সিনক্রোনাইজেশন] {pid} সেমাফোর রিলিজ করলো")
        if woken:
            self.processes[woken].state = "Ready"
            self._log(f"[সিনক্রোনাইজেশন] {woken} জেগে উঠে Ready-তে ফিরলো")
        return woken

    # ---------- M9/L39: ইনডেক্সড ফাইল সিস্টেম ----------
    def create_file(self, filename, blocks_needed):
        if len(self.free_disk_blocks) < blocks_needed:
            self._log(f"[ফাইল সিস্টেম] {filename} ব্যর্থ -- ফ্রি ব্লক অপর্যাপ্ত")
            return False
        index_block = []
        for i in range(blocks_needed):
            block = self.free_disk_blocks.pop(0)
            self.disk[block] = f"{filename}:block{i}"
            index_block.append(block)
        self.files[filename] = index_block
        self._log(f"[ফাইল সিস্টেম] {filename} তৈরি -> ইনডেক্স ব্লক {index_block}")
        return True

    def read_file_block(self, filename, logical_block_number):
        physical_block = self.files[filename][logical_block_number]
        content = self.disk[physical_block]
        self._log(f"[ফাইল সিস্টেম] {filename} লজিক্যাল ব্লক {logical_block_number} -> ফিজিক্যাল ব্লক {physical_block} ({content})")
        return content


# ============ একটি সমন্বিত সিনারিও -- সবকটি সাবসিস্টেম একসাথে ============
kernel = TinyKernel(num_frames=3, disk_block_count=8)

kernel.create_process("P1", priority=2)
kernel.create_process("P2", priority=1)
kernel.create_process("P3", priority=3)

kernel.schedule_next()                 # প্রায়োরিটি ১ -> P2 নির্বাচিত

kernel.access_page("P2", 0)             # fault -> frame 0
kernel.access_page("P2", 1)            # fault -> frame 1
kernel.access_page("P2", 0)            # hit
kernel.access_page("P2", 2)            # fault -> frame 2 (পুল পূর্ণ)
kernel.access_page("P2", 3)            # fault -> ৩ ফ্রেমই ব্যস্ত -> LRU (পেজ ১) evict

kernel.sem_wait("P2")
kernel.modify_shared_resource("P2", 5)
kernel.sem_signal("P2")

kernel.create_file("notes_p2", 2)
kernel.read_file_block("notes_p2", 0)
kernel.read_file_block("notes_p2", 1)

kernel.terminate("P2")                 # P2-এর ৩টি ফ্রেম মুক্ত হলো

kernel.schedule_next()                 # এখন P1 (priority=2) নির্বাচিত
kernel.access_page("P1", 0)            # fault -> এখন খালি ফ্রেম পুনর্ব্যবহার

kernel.sem_wait("P1")                  # P1 সেমাফোর পেলো
kernel.schedule_next()                 # P3 (একমাত্র বাকি Ready) -> Running
kernel.sem_wait("P3")                  # সেমাফোর ইতিমধ্যে P1-এর কাছে -> P3 ব্লকড (Waiting)

kernel.modify_shared_resource("P1", 10)
kernel.sem_signal("P1")                # P3 জেগে উঠলো

kernel.modify_shared_resource("P3", 3)
kernel.sem_signal("P3")

kernel.create_file("log_p1", 3)
kernel.read_file_block("log_p1", 2)

kernel.terminate("P1")
kernel.terminate("P3")

print("=== TinyKernel সমন্বিত কার্নেল লগ ===")
for i, entry in enumerate(kernel.log, start=1):
    print(f"{i:02d}. {entry}")

print("\n--- চূড়ান্ত অবস্থা ---")
for pid, pcb in kernel.processes.items():
    print(f"{pid}: state={pcb.state}, priority={pcb.priority}")
print(f"শেয়ার্ড কাউন্টার শেষ মান: {kernel.shared_counter}")
print(f"ফাইল সিস্টেমে ফাইল: {list(kernel.files.keys())}")