CSV Task Scheduler in C++

#include <iostream>
#include <fstream>
#include <sstream>
#include <climits>
#include <vector>

using namespace std;

const int MAX_TASKS = 100; // Adjust as needed

struct Task {
    int taskID;
    int arrivalTime;
    int burstTime;
    int priority;
    int completionTime;
    int turnaroundTime;
    int waitingTime;
};

Task tasks[MAX_TASKS];
int numTasks = 0;

// Function to read tasks from a CSV file
void readTasksFromFile(const string& filename) {
    ifstream file(filename);

    if (!file.is_open()) {
        cerr << "Error: Unable to open file " << filename << endl;
        return;
    }

    string line;
    getline(file, line); // Skip header row

    while (getline(file, line) && numTasks < MAX_TASKS) {
        stringstream ss(line);
        string token;

        getline(ss, token, ',');
        tasks[numTasks].taskID = stoi(token);

        getline(ss, token, ',');
        tasks[numTasks].arrivalTime = stoi(token);

        getline(ss, token, ',');
        tasks[numTasks].burstTime = stoi(token);

        getline(ss, token, ',');
        tasks[numTasks].priority = stoi(token);

        numTasks++;
    }

    file.close();
}

// Function to execute Round Robin scheduling
void roundRobin(int timeQuantum) {
    int time = 0;
    int remainingBurstTime[MAX_TASKS];

    for (int i = 0; i < numTasks; i++) {
        remainingBurstTime[i] = tasks[i].burstTime;
    }

    bool done;
    do {
        done = true;
        for (int i = 0; i < numTasks; i++) {
            if (remainingBurstTime[i] > 0) {
                done = false;
                if (remainingBurstTime[i] > timeQuantum) {
                    time += timeQuantum;
                    remainingBurstTime[i] -= timeQuantum;
                    cout << "Task " << tasks[i].taskID << " executed (remaining burst time: " << remainingBurstTime[i] << ")" << endl;
                } else {
                    time += remainingBurstTime[i];
                    tasks[i].completionTime = time;
                    remainingBurstTime[i] = 0;
                    cout << "Task " << tasks[i].taskID << " executed (remaining burst time: 0)" << endl;
                }
            }
        }
    } while (!done);
}

// Function to execute FCFS scheduling
void fcfs() {
    int time = 0;
    cout << "Level 2 (FCFS) Scheduling:" << endl;
    for (int i = 0; i < numTasks; i++) {
        if (time < tasks[i].arrivalTime) {
            time = tasks[i].arrivalTime;
        }
        time += tasks[i].burstTime;
        tasks[i].completionTime = time;
        cout << "Task " << tasks[i].taskID << " executed" << endl;
    }
}

// Function to execute SJF scheduling
void sjf() {
    int time = 0;
    bool completed[MAX_TASKS] = {false};

    cout << "Level 3 (SJF) Scheduling:" << endl;
    while (true) {
        int shortestTask = -1;
        int minBurstTime = INT_MAX;

        for (int i = 0; i < numTasks; i++) {
            if (!completed[i] && tasks[i].arrivalTime <= time && tasks[i].burstTime < minBurstTime) {
                minBurstTime = tasks[i].burstTime;
                shortestTask = i;
            }
        }

        if (shortestTask != -1) {
            time += tasks[shortestTask].burstTime;
            tasks[shortestTask].completionTime = time;
            completed[shortestTask] = true;
            cout << "Task " << tasks[shortestTask].taskID << " executed" << endl;
        } else {
            time++;
        }

        // Check if all tasks are completed
        bool allCompleted = true;
        for (int i = 0; i < numTasks; i++) {
            if (!completed[i]) {
                allCompleted = false;
                break;
            }
        }

        if (allCompleted) {
            break;
        }
    }
}

int main() {
    readTasksFromFile("tasks.csv");

    // Schedule tasks based on priority
    cout << "Level 1 (Round Robin) Scheduling:" << endl;
    for (int i = 0; i < numTasks; i++) {
        if (tasks[i].priority == 1) {
            roundRobin(2); // Time quantum for Level 1
        }
    }

    // Level 2 (FCFS) Scheduling
    fcfs();

    // Level 3 (SJF) Scheduling
    sjf();

    // Calculate Turnaround Time and Waiting Time
    for (int i = 0; i < numTasks; i++) {
        tasks[i].turnaroundTime = tasks[i].completionTime - tasks[i].arrivalTime;
        tasks[i].waitingTime = tasks[i].turnaroundTime - tasks[i].burstTime;
    }

    // Display results
    cout << "\nFinal Task Execution Order:" << endl;
    for (int i = 0; i < numTasks; i++) {
        cout << "Task " << tasks[i].taskID;
        if (i < numTasks - 1) cout << " -> ";
    }
    cout << endl;

    cout << "\nTask Completion Times:" << endl;
    for (int i = 0; i < numTasks; i++) {
        cout << "Task " << tasks[i].taskID << ": Completion Time = " << tasks[i].completionTime << endl;
    }

    cout << "\nTurnaround Times:" << endl;
    for (int i = 0; i < numTasks; i++) {
        cout << "Task " << tasks[i].taskID << ": Turnaround Time = " << tasks[i].turnaroundTime << endl;
    }

    cout << "\nWaiting Times:" << endl;
    for (int i = 0; i < numTasks; i++) {
        cout << "Task " << tasks[i].taskID << ": Waiting Time = " << tasks[i].waitingTime << endl;
    }

    return 0;
}