main.cpp

#include <iostream>
#include <vector>
#include "Process.h"
#include "FCFSScheduler.h"
#include "SJFScheduler.h"
#include "RRScheduler.h"
#include "PriorityScheduler.h"
#include "MLFQScheduler.h"
#include "ProcessManager.h"
#include "MemoryManager.h"
#include "DeviceManager.h"
#include "IOManager.h"
#include "Kernel.h"

// Creates a fresh identical set of demo processes.
// (Processes get mutated as they run, so each scheduler run needs its own copy.)
std::vector<Process*> makeDemoProcesses() {
    return {
        new Process(1, "P1", 0, 8, 2),
        new Process(2, "P2", 1, 4, 1),
        new Process(3, "P3", 2, 9, 3),
        new Process(4, "P4", 3, 5, 0)
    };
}

void runWithScheduler(Scheduler* scheduler, int maxLevels = 1) {
    ProcessManager pm(scheduler, maxLevels);
    for (Process* p : makeDemoProcesses()) {
        pm.addProcess(p);
    }
    pm.run();
    pm.printReport();
}

int main() {
    // ---- Process scheduling: compare algorithms on the same workload ----
    FCFSScheduler fcfs;
    runWithScheduler(&fcfs);

    SJFScheduler sjf;
    runWithScheduler(&sjf);

    RRScheduler rr(3);
    runWithScheduler(&rr);

    PriorityScheduler priority;
    runWithScheduler(&priority);

    MLFQScheduler mlfq({2, 4, 8}); // 3 levels: quantum 2, 4, then run-to-completion-ish (8)
    runWithScheduler(&mlfq, 3);

    // ---- Kernel demo: Process + Memory + IO working together ----
    std::cout << "\n\n========== Kernel Integration Demo ==========\n";

    RRScheduler kernelScheduler(3);
    ProcessManager processManager(&kernelScheduler);
    for (Process* p : makeDemoProcesses()) {
        processManager.addProcess(p);
    }

    MemoryManager memoryManager(16); // 16 physical frames total
    DeviceManager deviceManager;
    deviceManager.registerDevice("Disk");
    deviceManager.registerDevice("Printer");
    IOManager ioManager(&deviceManager);

    Kernel kernel(&processManager, &memoryManager, &ioManager, &deviceManager);
    kernel.boot();

    // Simulate memory allocation for each process before scheduling runs
    memoryManager.allocate(1, 3);
    memoryManager.allocate(2, 2);
    memoryManager.allocate(3, 4);
    memoryManager.allocate(4, 2);

    // Simulate a couple of I/O requests
    ioManager.submitRequest(1, "Disk");
    ioManager.submitRequest(2, "Disk"); // will have to wait, Disk is busy
    ioManager.serviceNext();
    ioManager.serviceNext();

    kernel.runProcessScheduling();
    kernel.printAllReports();

    // Cleanup memory once processes are "done"
    memoryManager.deallocate(1);
    memoryManager.deallocate(2);
    memoryManager.deallocate(3);
    memoryManager.deallocate(4);
    memoryManager.printMemoryMap();

    return 0;
}