CPU 스케줄링

#include <stdio.h>
#include <string.h>

#define N       4
#define QUANTUM 2

typedef struct {
    char  id[4];
    int   arrival;   // 도착 시간
    int   burst;     // CPU 버스트 시간
    int   remaining; // 남은 실행 시간
    int   finish;    // 완료 시간
} Process;

int main() {
    Process procs[N] = {
        { "P1", 0, 6, 6, 0 },
        { "P2", 1, 3, 3, 0 },
        { "P3", 2, 4, 4, 0 },
        { "P4", 3, 2, 2, 0 },
    };

    int  queue[64];     // Ready Queue (원형 배열 대신 단순 배열로 시뮬레이션)
    int  head = 0, tail = 0;
    int  enqueued[N];
    memset(enqueued, 0, sizeof(enqueued));

    int  t    = 0;
    int  done = 0;

    while (done < N) {
        // 현재 시각에 도착한 프로세스를 Ready Queue에 삽입
        for (int i = 0; i < N; i++) {
            if (!enqueued[i] && procs[i].arrival <= t && procs[i].remaining > 0) {
                queue[tail++] = i;
                enqueued[i]   = 1;
            }
        }

        if (head == tail) { t++; continue; }  // CPU 유휴

        int  idx  = queue[head++];            // Dequeue
        int  run  = (procs[idx].remaining < QUANTUM)
                   ? procs[idx].remaining : QUANTUM;

        printf("T=%2d ~ T=%2d : %s 실행\n", t, t + run, procs[idx].id);
        t                    += run;
        procs[idx].remaining -= run;

        // 실행 후 도착한 프로세스 먼저 삽입 (선점 직후 도착 처리)
        for (int i = 0; i < N; i++) {
            if (!enqueued[i] && procs[i].arrival <= t && procs[i].remaining > 0) {
                queue[tail++] = i;
                enqueued[i]   = 1;
            }
        }

        if (procs[idx].remaining > 0) {
            queue[tail++] = idx;  // 아직 남아 있으면 Ready Queue 끝에 재삽입
        } else {
            procs[idx].finish = t;
            done++;
        }
    }

    printf("\n%-4s %7s %7s %7s %7s %11s\n",
           "PID", "도착", "버스트", "완료", "대기", "반환시간");
    float sumW = 0, sumT = 0;
    for (int i = 0; i < N; i++) {
        int tat     = procs[i].finish - procs[i].arrival;
        int waiting = tat - procs[i].burst;
        sumW += waiting; sumT += tat;
        printf("%-4s %7d %7d %7d %7d %11d\n",
               procs[i].id, procs[i].arrival, procs[i].burst,
               procs[i].finish, waiting, tat);
    }
    printf("평균 대기: %.1f   평균 반환: %.1f\n", sumW / N, sumT / N);
    return 0;
}

import java.util.*;

public class SJFScheduler {

    record Process(String id, int arrival, int burst) {}

    public static void main(String[] args) {
        List<Process> procs = List.of(
            new Process("P1", 0, 6),
            new Process("P2", 1, 3),
            new Process("P3", 2, 4),
            new Process("P4", 3, 2)
        );

        // PriorityQueue: 도착한 프로세스 중 burst 최소 → 우선순위 큐
        PriorityQueue<Process> ready = new PriorityQueue<>(
            Comparator.comparingInt(Process::burst)
                      .thenComparingInt(Process::arrival)
        );

        List<Process> remaining = new ArrayList<>(procs);
        Map<String, Integer> finishMap = new LinkedHashMap<>();
        int t = 0;

        while (!remaining.isEmpty() || !ready.isEmpty()) {
            // 현재 시각에 도착한 프로세스를 Ready Queue에 투입
            Iterator<Process> it = remaining.iterator();
            while (it.hasNext()) {
                Process p = it.next();
                if (p.arrival() <= t) { ready.add(p); it.remove(); }
            }

            if (ready.isEmpty()) {
                // CPU 유휴: 다음 도착 시각으로 점프
                t = remaining.stream()
                    .mapToInt(Process::arrival).min().orElse(t + 1);
                continue;
            }

            // 가장 짧은 버스트 프로세스를 선택 (비선점: 완료까지 실행)
            Process sel = ready.poll();
            System.out.printf("T=%2d ~ T=%2d : %s 실행%n",
                t, t + sel.burst(), sel.id());
            t += sel.burst();
            finishMap.put(sel.id(), t);

            // 실행하는 동안 도착한 프로세스도 큐에 추가
            remaining.removeIf(p -> {
                if (p.arrival() <= t) { ready.add(p); return true; }
                return false;
            });
        }

        printStats(procs, finishMap);
    }

    static void printStats(List<Process> procs, Map<String, Integer> finishMap) {
        System.out.printf("%n%-4s %6s %6s %6s %6s%n",
            "PID", "Arr", "Burst", "Wait", "TAT");
        double sumW = 0, sumT = 0;
        for (Process p : procs) {
            int finish = finishMap.get(p.id());
            int tat    = finish - p.arrival();
            int wait   = tat    - p.burst();
            sumW += wait; sumT += tat;
            System.out.printf("%-4s %6d %6d %6d %6d%n",
                p.id(), p.arrival(), p.burst(), wait, tat);
        }
        System.out.printf("평균 대기: %.1f   평균 반환: %.1f%n",
            sumW / procs.size(), sumT / procs.size());
    }
}