কেস স্টাডি: একটি CPU শিডিউলার সিমুলেটর বানানো

from collections import deque

processes_base = [
    {"pid": "P1", "arrival": 0, "burst": 8, "priority": 4},
    {"pid": "P2", "arrival": 1, "burst": 4, "priority": 3},
    {"pid": "P3", "arrival": 2, "burst": 9, "priority": 1},
    {"pid": "P4", "arrival": 3, "burst": 5, "priority": 2},
]

def avg(values):
    return sum(values) / len(values)

def fcfs(procs):
    order = sorted(procs, key=lambda p: (p["arrival"], p["pid"]))
    time, result = 0, []
    for p in order:
        start = max(time, p["arrival"])
        finish = start + p["burst"]
        result.append({"pid": p["pid"], "finish": finish,
                        "wait": start - p["arrival"], "turnaround": finish - p["arrival"]})
        time = finish
    return result

def sjf(procs):
    remaining = sorted(procs, key=lambda p: p["arrival"])
    time, done = 0, []
    while remaining:
        ready = [p for p in remaining if p["arrival"] <= time]
        if not ready:
            time = remaining[0]["arrival"]
            ready = [p for p in remaining if p["arrival"] <= time]
        nxt = min(ready, key=lambda p: (p["burst"], p["arrival"], p["pid"]))
        start = time
        finish = start + nxt["burst"]
        done.append({"pid": nxt["pid"], "finish": finish,
                      "wait": start - nxt["arrival"], "turnaround": finish - nxt["arrival"]})
        time = finish
        remaining.remove(nxt)
    return done

def priority_scheduling(procs):
    remaining = sorted(procs, key=lambda p: p["arrival"])
    time, done = 0, []
    while remaining:
        ready = [p for p in remaining if p["arrival"] <= time]
        if not ready:
            time = remaining[0]["arrival"]
            ready = [p for p in remaining if p["arrival"] <= time]
        nxt = min(ready, key=lambda p: (p["priority"], p["arrival"], p["pid"]))
        start = time
        finish = start + nxt["burst"]
        done.append({"pid": nxt["pid"], "finish": finish,
                      "wait": start - nxt["arrival"], "turnaround": finish - nxt["arrival"]})
        time = finish
        remaining.remove(nxt)
    return done

def round_robin(procs, quantum):
    order = sorted(procs, key=lambda p: p["arrival"])
    remaining_burst = {p["pid"]: p["burst"] for p in procs}
    arrival = {p["pid"]: p["arrival"] for p in procs}
    burst_total = {p["pid"]: p["burst"] for p in procs}
    finish_time = {}
    queue = deque()
    i, n, time = 0, len(order), 0
    while i < n and order[i]["arrival"] <= time:
        queue.append(order[i]["pid"]); i += 1
    while queue:
        pid = queue.popleft()
        run = min(quantum, remaining_burst[pid])
        time += run
        remaining_burst[pid] -= run
        while i < n and order[i]["arrival"] <= time:
            queue.append(order[i]["pid"]); i += 1
        if remaining_burst[pid] > 0:
            queue.append(pid)
        else:
            finish_time[pid] = time
    result = []
    for p in procs:
        pid = p["pid"]
        turnaround = finish_time[pid] - arrival[pid]
        result.append({"pid": pid, "finish": finish_time[pid],
                        "wait": turnaround - burst_total[pid], "turnaround": turnaround})
    return result

def run_scheduler(processes, algorithm, quantum=3):
    """একক dispatcher -- algorithm অনুযায়ী সঠিক শিডিউলারে কল পাঠায়।"""
    procs = [dict(p) for p in processes]   # মূল ডেটা অপরিবর্তিত রাখতে কপি
    if algorithm == "FCFS":
        return fcfs(procs)
    if algorithm == "SJF":
        return sjf(procs)
    if algorithm == "Priority":
        return priority_scheduling(procs)
    if algorithm == "RoundRobin":
        return round_robin(procs, quantum)
    raise ValueError(f"অজানা অ্যালগরিদম: {algorithm}")

summary = []
for algo in ["FCFS", "SJF", "Priority", "RoundRobin"]:
    result = run_scheduler(processes_base, algo, quantum=3)
    avg_wait = avg([r["wait"] for r in result])
    avg_turnaround = avg([r["turnaround"] for r in result])
    summary.append((algo, avg_wait, avg_turnaround))

print(f"{'অ্যালগরিদম':12} | {'গড় ওয়েটিং টাইম':18} | গড় টার্নঅ্যারাউন্ড টাইম")
print("-" * 60)
for algo, w, t in summary:
    print(f"{algo:12} | {w:18.2f} | {t:.2f}")