Initial commit
This commit is contained in:
435
CPUScheduler.cpp
Normal file
435
CPUScheduler.cpp
Normal file
@@ -0,0 +1,435 @@
|
||||
#include <iostream>
|
||||
#include <vector>
|
||||
#include <queue>
|
||||
#include <algorithm>
|
||||
#include <iomanip>
|
||||
#include <climits>
|
||||
using namespace std;
|
||||
|
||||
// 进程结构体
|
||||
struct Process {
|
||||
int pid; // 进程ID
|
||||
int arrivalTime; // 到达时间
|
||||
int burstTime; // 服务时间
|
||||
int priority; // 优先级(数值越小优先级越高)
|
||||
int remainingTime; // 剩余时间
|
||||
int finishTime; // 完成时间
|
||||
int turnaroundTime; // 周转时间
|
||||
int waitingTime; // 等待时间
|
||||
double responseRatio; // 响应比(用于HRRN)
|
||||
|
||||
Process(int p, int a, int b, int pr = 0) {
|
||||
pid = p;
|
||||
arrivalTime = a;
|
||||
burstTime = b;
|
||||
priority = pr;
|
||||
remainingTime = b;
|
||||
finishTime = 0;
|
||||
turnaroundTime = 0;
|
||||
waitingTime = 0;
|
||||
responseRatio = 0.0;
|
||||
}
|
||||
};
|
||||
|
||||
class CPUScheduler {
|
||||
private:
|
||||
vector<Process> processes;
|
||||
vector<Process> originalProcesses;
|
||||
|
||||
public:
|
||||
// 添加进程
|
||||
void addProcess(int pid, int arrivalTime, int burstTime, int priority = 0) {
|
||||
processes.push_back(Process(pid, arrivalTime, burstTime, priority));
|
||||
originalProcesses.push_back(Process(pid, arrivalTime, burstTime, priority));
|
||||
}
|
||||
|
||||
// 重置进程状态
|
||||
void resetProcesses() {
|
||||
processes = originalProcesses;
|
||||
for (auto& p : processes) {
|
||||
p.remainingTime = p.burstTime;
|
||||
p.finishTime = 0;
|
||||
p.turnaroundTime = 0;
|
||||
p.waitingTime = 0;
|
||||
p.responseRatio = 0.0;
|
||||
}
|
||||
}
|
||||
|
||||
// 先来先服务(FCFS)算法
|
||||
void FCFS() {
|
||||
cout << "\n========== 先来先服务(FCFS)调度算法 ==========\n";
|
||||
resetProcesses();
|
||||
|
||||
// 按到达时间排序
|
||||
sort(processes.begin(), processes.end(),
|
||||
[](const Process& a, const Process& b) {
|
||||
return a.arrivalTime < b.arrivalTime;
|
||||
});
|
||||
|
||||
int currentTime = 0;
|
||||
cout << "执行顺序: ";
|
||||
|
||||
for (auto& p : processes) {
|
||||
// 如果当前时间小于进程到达时间，CPU空闲
|
||||
if (currentTime < p.arrivalTime) {
|
||||
currentTime = p.arrivalTime;
|
||||
}
|
||||
|
||||
cout << "P" << p.pid << " ";
|
||||
currentTime += p.burstTime;
|
||||
p.finishTime = currentTime;
|
||||
p.turnaroundTime = p.finishTime - p.arrivalTime;
|
||||
p.waitingTime = p.turnaroundTime - p.burstTime;
|
||||
}
|
||||
cout << "\n";
|
||||
|
||||
printResults();
|
||||
}
|
||||
|
||||
// 最短作业优先(SJF)算法
|
||||
void SJF() {
|
||||
cout << "\n========== 最短作业优先(SJF)调度算法 ==========\n";
|
||||
resetProcesses();
|
||||
|
||||
vector<Process> readyQueue;
|
||||
vector<Process> completed;
|
||||
int currentTime = 0;
|
||||
cout << "执行顺序: ";
|
||||
|
||||
while (completed.size() < processes.size()) {
|
||||
// 将已到达的进程加入就绪队列
|
||||
for (auto& p : processes) {
|
||||
if (p.arrivalTime <= currentTime && p.finishTime == 0) {
|
||||
bool inQueue = false;
|
||||
for (const auto& q : readyQueue) {
|
||||
if (q.pid == p.pid) {
|
||||
inQueue = true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (!inQueue) {
|
||||
readyQueue.push_back(p);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (!readyQueue.empty()) {
|
||||
// 选择服务时间最短的进程
|
||||
auto shortestJob = min_element(readyQueue.begin(), readyQueue.end(),
|
||||
[](const Process& a, const Process& b) {
|
||||
return a.burstTime < b.burstTime;
|
||||
});
|
||||
|
||||
cout << "P" << shortestJob->pid << " ";
|
||||
currentTime += shortestJob->burstTime;
|
||||
|
||||
// 更新原进程信息
|
||||
for (auto& p : processes) {
|
||||
if (p.pid == shortestJob->pid) {
|
||||
p.finishTime = currentTime;
|
||||
p.turnaroundTime = p.finishTime - p.arrivalTime;
|
||||
p.waitingTime = p.turnaroundTime - p.burstTime;
|
||||
completed.push_back(p);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
// 从就绪队列中移除已完成的进程
|
||||
readyQueue.erase(shortestJob);
|
||||
} else {
|
||||
currentTime++;
|
||||
}
|
||||
}
|
||||
cout << "\n";
|
||||
|
||||
printResults();
|
||||
}
|
||||
|
||||
// 最短剩余时间优先(SRTF)算法
|
||||
void SRTF() {
|
||||
cout << "\n========== 最短剩余时间优先(SRTF)调度算法 ==========\n";
|
||||
resetProcesses();
|
||||
|
||||
int currentTime = 0;
|
||||
int completed = 0;
|
||||
vector<int> executionOrder;
|
||||
|
||||
while (completed < processes.size()) {
|
||||
int shortestIdx = -1;
|
||||
int shortestTime = INT_MAX;
|
||||
|
||||
// 找到当前时间已到达且剩余时间最短的进程
|
||||
for (int i = 0; i < processes.size(); i++) {
|
||||
if (processes[i].arrivalTime <= currentTime &&
|
||||
processes[i].remainingTime > 0 &&
|
||||
processes[i].remainingTime < shortestTime) {
|
||||
shortestTime = processes[i].remainingTime;
|
||||
shortestIdx = i;
|
||||
}
|
||||
}
|
||||
|
||||
if (shortestIdx == -1) {
|
||||
currentTime++;
|
||||
continue;
|
||||
}
|
||||
|
||||
// 执行选中的进程1个时间单位
|
||||
executionOrder.push_back(processes[shortestIdx].pid);
|
||||
processes[shortestIdx].remainingTime--;
|
||||
currentTime++;
|
||||
|
||||
// 如果进程完成
|
||||
if (processes[shortestIdx].remainingTime == 0) {
|
||||
processes[shortestIdx].finishTime = currentTime;
|
||||
processes[shortestIdx].turnaroundTime =
|
||||
processes[shortestIdx].finishTime - processes[shortestIdx].arrivalTime;
|
||||
processes[shortestIdx].waitingTime =
|
||||
processes[shortestIdx].turnaroundTime - processes[shortestIdx].burstTime;
|
||||
completed++;
|
||||
}
|
||||
}
|
||||
|
||||
// 输出执行顺序(去重连续相同的进程)
|
||||
cout << "执行顺序: ";
|
||||
if (!executionOrder.empty()) {
|
||||
cout << "P" << executionOrder[0];
|
||||
for (int i = 1; i < executionOrder.size(); i++) {
|
||||
if (executionOrder[i] != executionOrder[i-1]) {
|
||||
cout << " P" << executionOrder[i];
|
||||
}
|
||||
}
|
||||
}
|
||||
cout << "\n";
|
||||
|
||||
printResults();
|
||||
}
|
||||
|
||||
// 最高响应比优先(HRRN)算法
|
||||
void HRRN() {
|
||||
cout << "\n========== 最高响应比优先(HRRN)调度算法 ==========\n";
|
||||
resetProcesses();
|
||||
|
||||
vector<Process> completed;
|
||||
int currentTime = 0;
|
||||
cout << "执行顺序: ";
|
||||
|
||||
while (completed.size() < processes.size()) {
|
||||
vector<int> readyQueue;
|
||||
|
||||
// 找到所有已到达且未完成的进程
|
||||
for (int i = 0; i < processes.size(); i++) {
|
||||
if (processes[i].arrivalTime <= currentTime && processes[i].finishTime == 0) {
|
||||
readyQueue.push_back(i);
|
||||
}
|
||||
}
|
||||
|
||||
if (!readyQueue.empty()) {
|
||||
// 计算响应比并选择最高的
|
||||
int selectedIdx = -1;
|
||||
double highestRatio = 0.0;
|
||||
|
||||
for (int idx : readyQueue) {
|
||||
int waitTime = currentTime - processes[idx].arrivalTime;
|
||||
processes[idx].responseRatio =
|
||||
(double)(waitTime + processes[idx].burstTime) / processes[idx].burstTime;
|
||||
|
||||
if (processes[idx].responseRatio > highestRatio) {
|
||||
highestRatio = processes[idx].responseRatio;
|
||||
selectedIdx = idx;
|
||||
}
|
||||
}
|
||||
|
||||
cout << "P" << processes[selectedIdx].pid << " ";
|
||||
currentTime += processes[selectedIdx].burstTime;
|
||||
processes[selectedIdx].finishTime = currentTime;
|
||||
processes[selectedIdx].turnaroundTime =
|
||||
processes[selectedIdx].finishTime - processes[selectedIdx].arrivalTime;
|
||||
processes[selectedIdx].waitingTime =
|
||||
processes[selectedIdx].turnaroundTime - processes[selectedIdx].burstTime;
|
||||
completed.push_back(processes[selectedIdx]);
|
||||
} else {
|
||||
currentTime++;
|
||||
}
|
||||
}
|
||||
cout << "\n";
|
||||
|
||||
printResults();
|
||||
}
|
||||
|
||||
// 时间片轮转(RR)算法
|
||||
void RR(int timeQuantum = 2) {
|
||||
cout << "\n========== 时间片轮转(RR)调度算法 (时间片=" << timeQuantum << ") ==========\n";
|
||||
resetProcesses();
|
||||
|
||||
queue<int> readyQueue;
|
||||
vector<bool> inQueue(processes.size(), false);
|
||||
int currentTime = 0;
|
||||
int completed = 0;
|
||||
cout << "执行顺序: ";
|
||||
|
||||
// 将时间0到达的进程加入队列
|
||||
for (int i = 0; i < processes.size(); i++) {
|
||||
if (processes[i].arrivalTime <= currentTime) {
|
||||
readyQueue.push(i);
|
||||
inQueue[i] = true;
|
||||
}
|
||||
}
|
||||
|
||||
while (completed < processes.size()) {
|
||||
if (readyQueue.empty()) {
|
||||
currentTime++;
|
||||
// 检查是否有新进程到达
|
||||
for (int i = 0; i < processes.size(); i++) {
|
||||
if (processes[i].arrivalTime <= currentTime &&
|
||||
!inQueue[i] && processes[i].remainingTime > 0) {
|
||||
readyQueue.push(i);
|
||||
inQueue[i] = true;
|
||||
}
|
||||
}
|
||||
continue;
|
||||
}
|
||||
|
||||
int currentProcess = readyQueue.front();
|
||||
readyQueue.pop();
|
||||
inQueue[currentProcess] = false;
|
||||
|
||||
cout << "P" << processes[currentProcess].pid << " ";
|
||||
|
||||
// 执行时间片或直到进程完成
|
||||
int executeTime = min(timeQuantum, processes[currentProcess].remainingTime);
|
||||
currentTime += executeTime;
|
||||
processes[currentProcess].remainingTime -= executeTime;
|
||||
|
||||
// 将在执行期间到达的进程加入队列
|
||||
for (int i = 0; i < processes.size(); i++) {
|
||||
if (processes[i].arrivalTime <= currentTime &&
|
||||
!inQueue[i] && processes[i].remainingTime > 0 && i != currentProcess) {
|
||||
readyQueue.push(i);
|
||||
inQueue[i] = true;
|
||||
}
|
||||
}
|
||||
|
||||
// 如果当前进程还未完成，重新加入队列
|
||||
if (processes[currentProcess].remainingTime > 0) {
|
||||
readyQueue.push(currentProcess);
|
||||
inQueue[currentProcess] = true;
|
||||
} else {
|
||||
// 进程完成
|
||||
processes[currentProcess].finishTime = currentTime;
|
||||
processes[currentProcess].turnaroundTime =
|
||||
processes[currentProcess].finishTime - processes[currentProcess].arrivalTime;
|
||||
processes[currentProcess].waitingTime =
|
||||
processes[currentProcess].turnaroundTime - processes[currentProcess].burstTime;
|
||||
completed++;
|
||||
}
|
||||
}
|
||||
cout << "\n";
|
||||
|
||||
printResults();
|
||||
}
|
||||
|
||||
// 优先级调度算法(非抢占)
|
||||
void PriorityScheduling() {
|
||||
cout << "\n========== 优先级调度算法(非抢占) ==========\n";
|
||||
resetProcesses();
|
||||
|
||||
vector<Process> completed;
|
||||
int currentTime = 0;
|
||||
cout << "执行顺序: ";
|
||||
|
||||
while (completed.size() < processes.size()) {
|
||||
vector<int> readyQueue;
|
||||
|
||||
// 找到所有已到达且未完成的进程
|
||||
for (int i = 0; i < processes.size(); i++) {
|
||||
if (processes[i].arrivalTime <= currentTime && processes[i].finishTime == 0) {
|
||||
readyQueue.push_back(i);
|
||||
}
|
||||
}
|
||||
|
||||
if (!readyQueue.empty()) {
|
||||
// 选择优先级最高的进程(数值最小)
|
||||
int selectedIdx = readyQueue[0];
|
||||
for (int idx : readyQueue) {
|
||||
if (processes[idx].priority < processes[selectedIdx].priority) {
|
||||
selectedIdx = idx;
|
||||
}
|
||||
}
|
||||
|
||||
cout << "P" << processes[selectedIdx].pid << " ";
|
||||
currentTime += processes[selectedIdx].burstTime;
|
||||
processes[selectedIdx].finishTime = currentTime;
|
||||
processes[selectedIdx].turnaroundTime =
|
||||
processes[selectedIdx].finishTime - processes[selectedIdx].arrivalTime;
|
||||
processes[selectedIdx].waitingTime =
|
||||
processes[selectedIdx].turnaroundTime - processes[selectedIdx].burstTime;
|
||||
completed.push_back(processes[selectedIdx]);
|
||||
} else {
|
||||
currentTime++;
|
||||
}
|
||||
}
|
||||
cout << "\n";
|
||||
|
||||
printResults();
|
||||
}
|
||||
|
||||
// 打印结果
|
||||
void printResults() {
|
||||
cout << "\n进程调度结果:\n";
|
||||
cout << "进程ID\t到达时间\t服务时间\t完成时间\t周转时间\t等待时间\n";
|
||||
cout << "--------------------------------------------------------------\n";
|
||||
|
||||
double totalTurnaround = 0, totalWaiting = 0;
|
||||
|
||||
for (const auto& p : processes) {
|
||||
cout << "P" << p.pid << "\t" << p.arrivalTime << "\t\t"
|
||||
<< p.burstTime << "\t\t" << p.finishTime << "\t\t"
|
||||
<< p.turnaroundTime << "\t\t" << p.waitingTime << "\n";
|
||||
totalTurnaround += p.turnaroundTime;
|
||||
totalWaiting += p.waitingTime;
|
||||
}
|
||||
|
||||
cout << "--------------------------------------------------------------\n";
|
||||
cout << fixed << setprecision(2);
|
||||
cout << "平均周转时间: " << totalTurnaround / processes.size() << "\n";
|
||||
cout << "平均等待时间: " << totalWaiting / processes.size() << "\n";
|
||||
}
|
||||
|
||||
// 显示所有进程信息
|
||||
void displayProcesses() {
|
||||
cout << "\n当前进程信息:\n";
|
||||
cout << "进程ID\t到达时间\t服务时间\t优先级\n";
|
||||
cout << "----------------------------------------\n";
|
||||
for (const auto& p : originalProcesses) {
|
||||
cout << "P" << p.pid << "\t" << p.arrivalTime << "\t\t"
|
||||
<< p.burstTime << "\t\t" << p.priority << "\n";
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
int main() {
|
||||
CPUScheduler scheduler;
|
||||
|
||||
cout << "处理机调度算法实验\n";
|
||||
cout << "==================\n";
|
||||
|
||||
// 示例进程数据
|
||||
cout << "使用示例进程数据进行测试:\n";
|
||||
scheduler.addProcess(1, 0, 8, 3); // 进程P1: 到达时间0, 服务时间8, 优先级3
|
||||
scheduler.addProcess(2, 1, 4, 1); // 进程P2: 到达时间1, 服务时间4, 优先级1
|
||||
scheduler.addProcess(3, 2, 2, 4); // 进程P3: 到达时间2, 服务时间2, 优先级4
|
||||
scheduler.addProcess(4, 3, 1, 2); // 进程P4: 到达时间3, 服务时间1, 优先级2
|
||||
scheduler.addProcess(5, 4, 3, 5); // 进程P5: 到达时间4, 服务时间3, 优先级5
|
||||
|
||||
scheduler.displayProcesses();
|
||||
|
||||
// 执行各种调度算法
|
||||
scheduler.FCFS();
|
||||
scheduler.SJF();
|
||||
scheduler.SRTF();
|
||||
scheduler.HRRN();
|
||||
scheduler.RR(2);
|
||||
scheduler.PriorityScheduling();
|
||||
|
||||
return 0;
|
||||
}
|
||||
Reference in New Issue
Block a user