125 lines
3.9 KiB
C++
125 lines
3.9 KiB
C++
#include <iostream>
|
|
#include <fstream>
|
|
#include <sstream>
|
|
#include <vector>
|
|
#include <queue>
|
|
#include <iomanip>
|
|
|
|
using namespace std;
|
|
|
|
struct Process {
|
|
int pid;
|
|
int arrival_time;
|
|
vector<int> burst_times;
|
|
int current_burst_index;
|
|
int completion_time;
|
|
int waiting_time;
|
|
int turnaround_time;
|
|
bool in_cpu;
|
|
};
|
|
|
|
vector<Process> processes;
|
|
|
|
void fifo() {
|
|
queue<Process*> ready_queue;
|
|
int current_time = 0;
|
|
int completed_processes = 0;
|
|
int process_count = processes.size();
|
|
|
|
while (completed_processes < process_count) {
|
|
// Add processes to the ready queue based on arrival time
|
|
for (auto& process : processes) {
|
|
if (process.arrival_time <= current_time && !process.in_cpu) {
|
|
ready_queue.push(&process);
|
|
process.in_cpu = true;
|
|
}
|
|
}
|
|
|
|
if (!ready_queue.empty()) {
|
|
Process* current_process = ready_queue.front();
|
|
ready_queue.pop();
|
|
|
|
// Simulate CPU execution
|
|
for (int i = current_process->current_burst_index; i < current_process->burst_times.size(); i += 2) {
|
|
int cpu_burst = current_process->burst_times[i];
|
|
current_time += cpu_burst; // Advance time by CPU burst duration
|
|
current_process->current_burst_index++;
|
|
|
|
// Handle I/O burst if there's one
|
|
if (i + 1 < current_process->burst_times.size()) {
|
|
int io_burst = current_process->burst_times[i + 1];
|
|
current_time += io_burst; // Advance time by I/O burst duration
|
|
}
|
|
}
|
|
|
|
current_process->completion_time = current_time;
|
|
current_process->turnaround_time = current_process->completion_time - current_process->arrival_time;
|
|
current_process->waiting_time = current_process->turnaround_time - (current_process->burst_times.size() / 2);
|
|
completed_processes++;
|
|
} else {
|
|
// No process is ready; advance time
|
|
current_time++;
|
|
}
|
|
}
|
|
|
|
// Calculate averages
|
|
int total_waiting_time = 0, total_turnaround_time = 0;
|
|
for (const auto& process : processes) {
|
|
total_waiting_time += process.waiting_time;
|
|
total_turnaround_time += process.turnaround_time;
|
|
}
|
|
|
|
double avg_waiting_time = static_cast<double>(total_waiting_time) / process_count;
|
|
double avg_turnaround_time = static_cast<double>(total_turnaround_time) / process_count;
|
|
|
|
// Output results
|
|
cout << "FIFO Scheduling Results:\n";
|
|
cout << "Processes:\n";
|
|
for (const auto& process : processes) {
|
|
cout << "Process ID: " << process.pid
|
|
<< ", Completion Time: " << process.completion_time
|
|
<< ", Waiting Time: " << process.waiting_time
|
|
<< ", Turnaround Time: " << process.turnaround_time << endl;
|
|
}
|
|
|
|
cout << "Average Waiting Time: " << fixed << setprecision(2) << avg_waiting_time << endl;
|
|
cout << "Average Turnaround Time: " << fixed << setprecision(2) << avg_turnaround_time << endl;
|
|
}
|
|
|
|
int main(int argc, char** argv) {
|
|
if (argc != 3) {
|
|
cout << "Usage: ./scheduler.out <path-to-workload-file> <scheduler_algorithm>\n";
|
|
return -1;
|
|
}
|
|
|
|
ifstream file(argv[1]);
|
|
string line;
|
|
int pid = 0;
|
|
|
|
while (getline(file, line)) {
|
|
if (line.empty()) continue;
|
|
Process process;
|
|
process.pid = pid++;
|
|
process.current_burst_index = 0;
|
|
process.in_cpu = false;
|
|
|
|
istringstream iss(line);
|
|
iss >> process.arrival_time;
|
|
|
|
int burst_time;
|
|
while (iss >> burst_time && burst_time != -1) {
|
|
process.burst_times.push_back(burst_time);
|
|
}
|
|
processes.push_back(process);
|
|
}
|
|
|
|
string algorithm = argv[2];
|
|
if (algorithm == "fifo") {
|
|
fifo();
|
|
} else {
|
|
cout << "Invalid scheduling algorithm. Please use 'fifo'.\n";
|
|
}
|
|
|
|
return 0;
|
|
}
|