130 lines
3.1 KiB
C++
130 lines
3.1 KiB
C++
#ifndef _SJTU_CPP_FINAL_CPU_HPP_
|
|
#define _SJTU_CPP_FINAL_CPU_HPP_
|
|
|
|
#include <cassert>
|
|
#include <vector>
|
|
|
|
#include "task.hpp"
|
|
|
|
using namespace std;
|
|
|
|
typedef unsigned int uint;
|
|
|
|
namespace sjtu {
|
|
// CPU base class, modifications is not allowed.
|
|
class CPU {
|
|
protected:
|
|
CPUState state;
|
|
vector<Task> tasks;
|
|
|
|
public:
|
|
CPU() : tasks() { state = idle; }
|
|
|
|
// Add a new task.
|
|
int addTask(const Task &t) {
|
|
tasks.push_back(t);
|
|
return 1;
|
|
}
|
|
|
|
// Change the priority of one process, return 1 if success and return 0 if
|
|
// fail.
|
|
int changePriority(uint task_id, uint priority) {
|
|
for (auto &task : tasks)
|
|
if (task.task_id == task_id) {
|
|
task.priority = priority;
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
virtual pair<CPUState, uint> run() = 0;
|
|
|
|
virtual ~CPU() = default;
|
|
};
|
|
|
|
// FCFS method based CPU.
|
|
class CPU_FCFS : public CPU {
|
|
// TODO: complete the FCFS method.
|
|
public:
|
|
pair<CPUState, uint> run() override {
|
|
bool has_opt = false;
|
|
for (int i = 0; i < tasks.size(); i++) {
|
|
if (tasks[i].time > 0) {
|
|
has_opt = true;
|
|
state = CPUState::busy;
|
|
tasks[i].time--;
|
|
return std::make_pair(CPUState::busy, tasks[i].task_id);
|
|
}
|
|
}
|
|
state = CPUState::idle;
|
|
return std::make_pair(CPUState::idle, 0);
|
|
}
|
|
~CPU_FCFS() override = default;
|
|
};
|
|
|
|
// SRTF method based CPU.
|
|
class CPU_SRTF : public CPU {
|
|
// TODO: complete the SRTF method.
|
|
public:
|
|
pair<CPUState, uint> run() override {
|
|
bool has_opt = false;
|
|
int least_time = -1;
|
|
for (int i = 0; i < tasks.size(); i++) {
|
|
if (tasks[i].time > 0) {
|
|
has_opt = true;
|
|
if (least_time == -1)
|
|
least_time = tasks[i].time;
|
|
else
|
|
least_time =
|
|
(tasks[i].time < least_time) ? tasks[i].time : least_time;
|
|
}
|
|
}
|
|
if (!has_opt) {
|
|
state = CPUState::idle;
|
|
return std::make_pair(CPUState::idle, 0);
|
|
}
|
|
for (int i = 0; i < tasks.size(); i++) {
|
|
if (tasks[i].time == least_time) {
|
|
state = CPUState::busy;
|
|
tasks[i].time--;
|
|
return std::make_pair(CPUState::busy, tasks[i].task_id);
|
|
}
|
|
}
|
|
}
|
|
~CPU_SRTF() override = default;
|
|
};
|
|
|
|
// priority method based CPU.
|
|
class CPU_PRIORITY : public CPU {
|
|
// TODO: complete the priority method.
|
|
public:
|
|
pair<CPUState, uint> run() override {
|
|
bool has_opt = false;
|
|
int highest_pri = -1;
|
|
for (int i = 0; i < tasks.size(); i++) {
|
|
if (tasks[i].time > 0) {
|
|
has_opt = true;
|
|
if (highest_pri == -1)
|
|
highest_pri = tasks[i].priority;
|
|
else
|
|
highest_pri = (tasks[i].priority < highest_pri) ? tasks[i].priority
|
|
: highest_pri;
|
|
}
|
|
}
|
|
if (!has_opt) {
|
|
state = CPUState::idle;
|
|
return std::make_pair(CPUState::idle, 0);
|
|
}
|
|
for (int i = 0; i < tasks.size(); i++) {
|
|
if (tasks[i].priority == highest_pri && tasks[i].time > 0) {
|
|
state = CPUState::busy;
|
|
tasks[i].time--;
|
|
return std::make_pair(CPUState::busy, tasks[i].task_id);
|
|
}
|
|
}
|
|
}
|
|
~CPU_PRIORITY() override = default;
|
|
};
|
|
} // namespace sjtu
|
|
|
|
#endif |