প্রায়োরিটি শিডিউলিং ও Round Robin

# Round Robin শিডিউলার -- সত্যিকারের অ্যালগরিদম, টয় প্রসেস ডেটার উপর
from collections import deque

processes = [
    # (নাম, arrival_time, burst_time)
    ("P1", 0, 5),
    ("P2", 1, 4),
    ("P3", 2, 2),
]
quantum = 2

def round_robin(processes, quantum):
    remaining = {name: burst for name, arrival, burst in processes}
    arrival_of = {name: arrival for name, arrival, burst in processes}
    order_by_arrival = sorted(processes, key=lambda p: p[1])

    time = 0
    queue = deque()
    schedule = []
    completion = {}
    i = 0

    def admit_new_arrivals(current_time):
        nonlocal i
        while i < len(order_by_arrival) and order_by_arrival[i][1] <= current_time:
            queue.append(order_by_arrival[i][0])
            i += 1

    admit_new_arrivals(time)
    if not queue:
        time = order_by_arrival[0][1]
        admit_new_arrivals(time)

    while queue:
        name = queue.popleft()
        start = max(time, arrival_of[name])
        run_time = min(quantum, remaining[name])
        end = start + run_time
        schedule.append((name, start, end))
        remaining[name] -= run_time
        time = end
        admit_new_arrivals(time)          # রান শেষে নতুন arrival যোগ, তারপরই বর্তমান প্রসেস (যদি বাকি থাকে) ফেরত
        if remaining[name] > 0:
            queue.append(name)
        else:
            completion[name] = time

    waiting = {}
    for name, arrival, burst in processes:
        turnaround = completion[name] - arrival
        waiting[name] = turnaround - burst
    return schedule, completion, waiting

schedule, completion, waiting = round_robin(processes, quantum)

print(f"--- Round Robin (quantum={quantum}) ---")
print("এক্সিকিউশন অর্ডার (নাম, শুরু, শেষ):")
for name, start, end in schedule:
    print(f"  {name}: [{start} -> {end}]")

print("\nপ্রতিটি প্রসেসের completion ও waiting time:")
for name, arrival, burst in processes:
    print(f"  {name}: completion={completion[name]}, waiting={waiting[name]}")

avg_wait = sum(waiting.values()) / len(waiting)
print(f"\nগড় waiting time = {avg_wait:.2f}")

# প্রায়োরিটি শিডিউলিং + aging -- কম সংখ্যা = বেশি প্রায়োরিটি
# প্রতি রাউন্ডে একটি নতুন উচ্চ-প্রায়োরিটি জব (priority 3) আসে -- aging ছাড়া C কখনোই CPU পেতো না
c_priority = 8
aging_step = 2
new_job_priority = 3
round_num = 0

while True:
    round_num += 1
    new_job = f"J{round_num}"
    ready = {new_job: new_job_priority, "C": c_priority}
    chosen = min(ready, key=lambda n: ready[n])
    print(f"রাউন্ড {round_num}: রেডি -> {ready}  |  নির্বাচিত: {chosen}")
    if chosen == "C":
        print(f"\n{round_num} রাউন্ড পর C-এর aged priority ({c_priority}) নতুন জবের priority "
              f"({new_job_priority})-এর চেয়ে ভালো হয়ে গেলো -> C অবশেষে CPU পেলো (স্টার্ভেশন প্রতিরোধ হলো)")
        break
    c_priority -= aging_step
    print(f"   C স্কিপড হলো -> aging প্রয়োগ, C-এর নতুন effective priority = {c_priority}")
    if round_num > 10:
        print("সেফটি লিমিট -- থামানো হলো")
        break