সেমাফোর, মিউটেক্স ও প্রায়োরিটি ইনভার্সন

class RTOSTask:
    def __init__(self, name, priority, ready_tick, segments):
        self.name = name
        self.base_priority = priority
        self.effective_priority = priority
        self.ready_tick = ready_tick
        self.segments = segments  # [[duration, kind], ...]; kind in {'non', 'crit'}
        self.seg_index = 0
        self.seg_remaining = segments[0][0]
        self.finished = False
        self.blocked = False

    def current_kind(self):
        return self.segments[self.seg_index][1]


class Mutex:
    def __init__(self):
        self.owner = None
        self.wait_queue = []


def make_tasks():
    # H-এর পুরো কাজটাই মিউটেক্স-সুরক্ষিত ক্রিটিক্যাল সেকশন (২ টিক)
    H = RTOSTask("High_H", priority=1, ready_tick=5, segments=[[2, 'crit']])
    # M মিউটেক্সের সাথে সম্পর্কহীন -- শুধু CPU দখল করে
    M = RTOSTask("Med_M",  priority=2, ready_tick=3, segments=[[5, 'non']])
    # L আগে থেকেই চলছে, তারপর মিউটেক্স অ্যাকোয়ার করে ক্রিটিক্যাল সেকশনে ঢোকে
    L = RTOSTask("Low_L",  priority=3, ready_tick=0, segments=[[2, 'non'], [4, 'crit'], [1, 'non']])
    return H, M, L


def run_simulation(use_inheritance, total_ticks=15):
    H, M, L = make_tasks()
    tasks = [H, M, L]
    mutex = Mutex()
    trace = []

    for tick in range(total_ticks):
        ready = [t for t in tasks if t.ready_tick <= tick and not t.finished and not t.blocked]
        ready.sort(key=lambda t: t.effective_priority)

        chosen = None
        events = []
        for t in ready:
            if t.current_kind() == 'crit' and mutex.owner not in (None, t):
                t.blocked = True
                mutex.wait_queue.append(t)
                events.append(f"{t.name} মিউটেক্স ব্লকড (হোল্ডার={mutex.owner.name})")
                if use_inheritance and mutex.owner.effective_priority > t.base_priority:
                    mutex.owner.effective_priority = t.base_priority
                    events.append(f"প্রায়োরিটি-ইনহেরিট: {mutex.owner.name}-এর effective priority "
                                  f"{t.base_priority}-এ উন্নীত হলো")
                continue
            chosen = t
            break

        if chosen is None:
            trace.append((tick, None, events))
            continue

        if chosen.current_kind() == 'crit' and mutex.owner is None:
            mutex.owner = chosen
            events.append(f"{chosen.name} মিউটেক্স অ্যাকোয়ার করলো")

        chosen.seg_remaining -= 1
        events.append(f"{chosen.name} রান করছে (effective_priority={chosen.effective_priority}, "
                       f"segment={chosen.current_kind()}, বাকি={chosen.seg_remaining})")

        if chosen.seg_remaining == 0:
            finished_kind = chosen.current_kind()
            if finished_kind == 'crit':
                mutex.owner = None
                if chosen.effective_priority != chosen.base_priority:
                    events.append(f"{chosen.name}-এর প্রায়োরিটি {chosen.base_priority}-এ ফিরিয়ে আনা হলো")
                chosen.effective_priority = chosen.base_priority
                for w in mutex.wait_queue:
                    w.blocked = False
                mutex.wait_queue = []
                events.append(f"{chosen.name} মিউটেক্স রিলিজ করলো")
            chosen.seg_index += 1
            if chosen.seg_index >= len(chosen.segments):
                chosen.finished = True
            else:
                chosen.seg_remaining = chosen.segments[chosen.seg_index][0]

        trace.append((tick, chosen.name, events))

    return trace, H


for label, use_inh in [("প্রায়োরিটি ইনহেরিটেন্স ছাড়া", False), ("প্রায়োরিটি ইনহেরিটেন্স সহ", True)]:
    print("=" * 60)
    print(label)
    print("=" * 60)
    trace, H = run_simulation(use_inh)
    h_first_block = None
    h_complete = None
    h_blocked_ticks = 0
    for tick, name, events in trace:
        if name is None:
            print(f"tick {tick:>2}: CPU আইডল")
        for e in events:
            print(f"tick {tick:>2}: {e}")
            if "High_H মিউটেক্স ব্লকড" in e and h_first_block is None:
                h_first_block = tick
            if e.startswith("High_H রান") and "বাকি=0" in e:
                h_complete = tick
        if h_first_block is not None and h_complete is None and name != "High_H":
            h_blocked_ticks += 1
    print(f"\nHigh_H প্রথম ব্লক হলো tick={h_first_block}, মোট ব্লকড ছিল {h_blocked_ticks} টিক, "
          f"সম্পন্ন হলো tick={h_complete}\n")