Process Scheduling — CPU Scheduling Algorithms Guide

class Process:
    def __init__(self, pid, burst, arrival=0):
        self.pid = pid
        self.burst = burst
        self.arrival = arrival
        self.remaining = burst
        self.completion = 0
        self.start_time = None
        self.turnaround = 0

def print_metrics(processes, algo_name):
    print(f'\n=== {algo_name} ===')
    avg_wait = sum(p.turnaround - p.burst for p in processes) / len(processes)
    avg_turn = sum(p.turnaround for p in processes) / len(processes)
    print(f'Avg waiting time: {avg_wait:.1f}')
    print(f'Avg turnaround:  {avg_turn:.1f}')
    for p in processes:
        print(f'  P{p.pid}: burst={p.burst} arrival={p.arrival} completion={p.completion} turn={p.turnaround}')

def fcfs(processes):
    time = 0
    for p in sorted(processes, key=lambda p: p.arrival):
        if time < p.arrival:
            time = p.arrival
        p.start_time = time
        p.completion = time + p.burst
        p.turnaround = p.completion - p.arrival
        time = p.completion

processes = [Process(1, 6, 0), Process(2, 8, 1), Process(3, 7, 2), Process(4, 3, 3)]
fcfs(processes)
print_metrics(processes, 'FCFS')

def sjf_nonpreemptive(processes):
    ready = []
    time = 0
    remaining = list(processes)
    completed = []
    while remaining or ready:
        for p in remaining[:]:
            if p.arrival <= time:
                ready.append(p)
                remaining.remove(p)
        if ready:
            ready.sort(key=lambda p: p.burst)
            p = ready.pop(0)
            p.start_time = time
            p.completion = time + p.burst
            p.turnaround = p.completion - p.arrival
            time = p.completion
            completed.append(p)
        else:
            time += 1
    return completed

completed = sjf_nonpreemptive(processes)
print_metrics(completed, 'SJF (Non-Preemptive)')

def srtf(processes):
    time = 0
    completed = 0
    n = len(processes)
    ready = []
    remaining = {p.pid: p.burst for p in processes}
    while completed < n:
        for p in processes:
            if p.arrival == time:
                ready.append(p)
        if ready:
            current = min(ready, key=lambda p: remaining[p.pid])
            remaining[current.pid] -= 1
            if current.start_time is None:
                current.start_time = time
            if remaining[current.pid] == 0:
                current.completion = time + 1
                current.turnaround = current.completion - current.arrival
                ready.remove(current)
                completed += 1
        time += 1

srtf(processes)
print_metrics(processes, 'SRTF (Preemptive SJF)')

from collections import deque

def round_robin(processes, quantum=4):
    queue = deque()
    time = 0
    remaining = {p.pid: p.burst for p in processes}
    ready = list(processes)
    while ready or queue:
        for p in ready[:]:
            if p.arrival <= time:
                queue.append(p)
                ready.remove(p)
        if queue:
            p = queue.popleft()
            if p.start_time is None:
                p.start_time = time
            run = min(quantum, remaining[p.pid])
            remaining[p.pid] -= run
            time += run
            for proc in ready[:]:
                if proc.arrival <= time:
                    queue.append(proc)
                    ready.remove(proc)
            if remaining[p.pid] > 0:
                queue.append(p)
            else:
                p.completion = time
                p.turnaround = p.completion - p.arrival
        else:
            time += 1

procs2 = [Process(1, 10, 0), Process(2, 5, 2), Process(3, 8, 4), Process(4, 2, 6)]
round_robin(procs2)
print_metrics(procs2, 'Round Robin (quantum=4)')

class CFSProcess:
    def __init__(self, pid, nice=0):
        self.pid = pid
        self.vruntime = 0
        self.nice = nice
        self.weight = 1024 / (1.25 ** nice)

    def run(self, time_slice):
        self.vruntime += time_slice * (1024 / self.weight)

def cfs_schedule(processes, total_time=30):
    time = 0
    while time < total_time:
        current = min(processes, key=lambda p: p.vruntime)
        sl = 6
        current.run(sl)
        time += sl
        print(f't={time:3d}: P{current.pid} run ({sl}ms) vruntime={current.vruntime:.1f}')

procs_cfs = [CFSProcess(1, nice=0), CFSProcess(2, nice=5), CFSProcess(3, nice=-5)]
cfs_schedule(procs_cfs)

class SchedulerSimulator:
    def __init__(self):
        self.algorithms = {}

    def add_algorithm(self, name, scheduler_fn):
        self.algorithms[name] = scheduler_fn

    def compare(self, processes):
        results = []
        for name, fn in self.algorithms.items():
            p_copy = [Process(p.pid, p.burst, p.arrival) for p in processes]
            fn(p_copy)
            avg_wait = sum(p.turnaround - p.burst for p in p_copy) / len(p_copy)
            results.append((name, avg_wait))
        results.sort(key=lambda x: x[1])
        print(f"{'Algorithm':<30} {'Avg Wait':<10}")
        print("-" * 40)
        for name, wait in results:
            print(f"{name:<30} {wait:<10.2f}")

sim = SchedulerSimulator()
sim.add_algorithm("FCFS", fcfs)
sim.add_algorithm("SJF Non-Preemptive", lambda p: setattr(p, '__result', sjf_nonpreemptive(p)) or print(''))
sim.add_algorithm("SRTF", srtf)
sim.add_algorithm("Round Robin (q=4)", lambda p: round_robin(p, 4))
sim.compare(processes)