进程调度算法的模拟实现
2024-05-15 00:20:42
【实验目的】
1.理解和掌握课堂上讲的进程调度算法，并编程模拟实现调度过程。
2.研究进程调度算法的实现方法，并对算法性能参数进行对比。
【实验要求】
编程模拟实现传统的进程调度算法：FCFS调度算法、SPF调度算法、RR调度算法、优先级调度，高响应比优先等算法。
/*FCFS 和 SPF 调度算法*/
#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cmath>
#include<cstring>
#include<algorithm>
using namespace std;
/*进程控制块*/
typedef struct{char pname;//进程名int arrive_t;//到达时间int service_t;//服务时间int finish_t;//完成时间int turnaround_t;//周转时间double w_turnaround_t;//带权周转时间
}PCB;PCB p[20]; //声明n个进程控制块
int n=5;
/*初始化进程信息：进程名、到达时间、服务时间、状态*/
void init();
/*输出初状态*/
void original_P();
//排序
bool cmp1(PCB a,PCB b);
bool cmp2(PCB a,PCB b);
bool cmp3(PCB a,PCB b);
bool cmp4(PCB a,PCB b);
/*FCFS算法*/
void FCFS_work();
/*SPF算法*/
void SPF_work();
/*输出最终状态*/
void Print();
int main()
{init();original_P();char op;printf("请输入要使用的调度算法(<f/F-->FCFS> <s/S-->SPF>):");scanf("%c",&op);getchar();if(op=='s'||op=='S'){SPF_work();}if(op=='f'||op=='F'){FCFS_work();}Print();return 0;
}void init()//初始化进程信息：进程名、到达时间、服务时间
{p[0].pname = 'A';p[0].arrive_t = 0;p[0].service_t = 3;p[1].pname = 'B';p[1].arrive_t = 2;p[1].service_t = 6;p[2].pname = 'C';p[2].arrive_t = 4;p[2].service_t = 4;p[3].pname = 'D';p[3].arrive_t = 6;p[3].service_t = 5;p[4].pname = 'E';p[4].arrive_t = 8;p[4].service_t = 2;
}
void original_P()//输出初始状态
{printf("进程初始状态\n");printf("------------------------------------------------------------------\n");printf("进程名\t\t到达时间\t服务时间\n");int i;for(i=0;i<n;i++){printf("%c\t\t %d\t\t %d\n",p[i].pname,p[i].arrive_t,p[i].service_t);}printf("--------------------------------------------------------------------------------------------------\n");}bool cmp1(PCB a,PCB b)
{return a.arrive_t<b.arrive_t;//按到达时间从小到达排序
}void FCFS_work()
{sort(p,p+n,cmp1);p[0].finish_t=p[0].arrive_t+p[0].service_t;//第一个进程的完成时间=到达时间+服务时间for(int i=1;i<n;i++){p[i].finish_t=max(p[i].arrive_t,p[i-1].finish_t)+p[i].service_t;//完成时间=开始运行时间+服务时间}}//按先达到时间排序，再按服务时间排序bool cmp2(PCB a,PCB b){if(a.arrive_t==b.arrive_t){return a.service_t<b.service_t;}else{return a.arrive_t<b.arrive_t;}}//按服务时间排序bool cmp3(PCB a,PCB b){return a.service_t<b.service_t;}
void SPF_work()
{sort(p,p+n,cmp2);//先按到达时间排序，再按进程服务时间排序p[0].finish_t=p[0].arrive_t+p[0].service_t;//第一个进程的完成时间=到达时间+服务时间int cnt=1;//判断完成时间内到达的进程个数,设第一个进程已经到达for(int i=1;i<n;i++)//看每一个进程 {if(cnt<n){for(int j=i;j<n;j++)//看后面来的进程 {if(p[j].arrive_t<=p[i-1].finish_t)//比较到达时间和上一个进程的完成时间 {cnt++;//如果已经达到就标记 }elsebreak;}if(cnt>i)//需要排序时 sort(p+i,p+cnt,cmp3);//按服务时间排序}p[i].finish_t=max(p[i-1].finish_t,p[i].arrive_t)+p[i].service_t;//完成时间 }
}
bool cmp4(PCB a,PCB b)
{return a.pname<b.pname;//按进程名排序
}
void Print()
{printf("--------------------------------------------------------------------------------------------------\n");int i;printf("进程执行顺序为：\n");for(i=0;i<n;i++){printf("%c ",p[i].pname);}printf("\n");sort(p,p+n,cmp4);printf("--------------------------------------------------------------------------------------------------\n");printf("进程名\t\t到达时间\t服务时间\t完成时间\t周转时间\t带权周转时间\n");int sum_t1=0;//代表总的周转时间double sum_t2=0;//代表总的带权周转时间for(i=0;i<n;i++){p[i].turnaround_t=p[i].finish_t-p[i].arrive_t;//周转时间=完成时间-到达时间p[i].w_turnaround_t=(double)p[i].turnaround_t/p[i].service_t;//带权周转时间=周转时间/服务时间sum_t1=sum_t1 + p[i].turnaround_t;sum_t2=sum_t2 + p[i].w_turnaround_t;printf("%c\t\t %d\t\t %d\t\t %d\t\t %d\t\t %0.2f\n",p[i].pname,p[i].arrive_t,p[i].service_t,p[i].finish_t,p[i].turnaround_t,p[i].w_turnaround_t);}printf("平均周转时间:%0.2f\n",(double)sum_t1/n);printf("平均带权周转时间:%0.2f\n",(double)sum_t2/n);}//高响应比优先调度算法
#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cmath>
#include<cstring>
#include<algorithm>
using namespace std;
/*进程控制块*/
typedef struct{char pname;//进程名int arrive_t;//到达时间int service_t;//服务时间int finish_t;//完成时间int turnaround_t;//周转时间double w_turnaround_t;//带权周转时间double r;//响应比
}PCB;PCB p[20]; //声明进程控制块
int n=6;
void init()//初始化进程信息：进程名、到达时间、服务时间
{p[0].pname = 'A';p[0].arrive_t = 0;p[0].service_t = 3;p[1].pname = 'B';p[1].arrive_t = 2;p[1].service_t = 4;p[2].pname = 'C';p[2].arrive_t = 3;p[2].service_t = 2;p[3].pname = 'D';p[3].arrive_t = 4;p[3].service_t = 5;p[4].pname = 'E';p[4].arrive_t = 5;p[4].service_t = 3;p[5].pname = 'F';p[5].arrive_t = 6;p[5].service_t = 6;
}
void original_P()//输出初始状态
{printf("进程初始状态\n");printf("------------------------------------------------------------------\n");printf("进程名\t\t到达时间\t服务时间\n");int i;for(i=0;i<n;i++){printf("%c\t\t %d\t\t %d\n",p[i].pname,p[i].arrive_t,p[i].service_t);}}
bool cmp1(PCB a,PCB b)
{return a.arrive_t<b.arrive_t;//按到达时间从小到达排序
}
bool cmp2(PCB a,PCB b)
{return a.r>b.r;//按响应比从大到小排序
}//高响应比优先调度算法void HRRN_work(){sort(p,p+n,cmp1);//先按到达时间排序p[0].finish_t=p[0].arrive_t+p[0].service_t;//第一个进程的完成时间=到达时间+服务时间int cnt;//为了计算要排序的响应比对应的进程数for(int i=1;i<n;i++){cnt=0;for(int j=i;j<n;j++)//从当前进程的下一个进程开始看{if(p[j].arrive_t<=p[i-1].finish_t)//比较到达时间和上一个进程的完成时间{p[j].r=(double)(p[i-1].finish_t-p[j].arrive_t)/p[j].service_t+1;//计算响应比cnt++;}else //后面的进程还没到，就不计算了break;}sort(p+i,p+i+cnt,cmp2);//只需要排当前进程后面未执行的进程，按响应比由高到低排序，最大的排在前面//按响应比最高的执行p[i].finish_t=max(p[i-1].finish_t,p[i].arrive_t)+p[i].service_t;//计算进程的完成时间}}bool cmp3(PCB a,PCB b)
{return a.pname<b.pname;//按进程名排序
}void Print()
{int i;printf("进程执行顺序为：\n");for(i=0;i<n;i++){printf("%c ",p[i].pname);}printf("\n");sort(p,p+n,cmp3);printf("--------------------------------------------------------------------------------------------------\n");printf("进程名\t\t到达时间\t服务时间\t完成时间\t周转时间\t带权周转时间\n");int sum_t1=0;//代表总的周转时间double sum_t2=0;//代表总的带权周转时间for(i=0;i<n;i++){p[i].turnaround_t=p[i].finish_t-p[i].arrive_t;//周转时间=完成时间-到达时间p[i].w_turnaround_t=(double)p[i].turnaround_t/p[i].service_t;//带权周转时间=周转时间/服务时间sum_t1=sum_t1 + p[i].turnaround_t;sum_t2=sum_t2 + p[i].w_turnaround_t;printf("%c\t\t %d\t\t %d\t\t %d\t\t %d\t\t %0.2f\n",p[i].pname,p[i].arrive_t,p[i].service_t,p[i].finish_t,p[i].turnaround_t,p[i].w_turnaround_t);}printf("平均周转时间:%0.2f\n",(double)sum_t1/n);printf("平均带权周转时间:%0.2f\n",(double)sum_t2/n);}
int main()
{init();original_P();HRRN_work();Print();return 0;
}
//RR时间片轮转与HPF优先级调度算法
#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cmath>
#include<cstring>
#include<algorithm>
#include<queue>
using namespace std;
typedef struct{char pname;//进程名int arrive_t;//到达时间int service_t;//服务时间int finish_t;//完成时间int turnaround_t;//周转时间double w_turnaround_t;//带权周转时间char state;//进程状态: w：等待， m：就绪，r：运行int priority;//优先级int run_t;//运行时间int remaining_t;//剩余时间
}PCB;
PCB p[20];
int n=10;
char op;
void init()//初始化进程信息：进程名、到达时间、服务时间、状态
{p[0].pname = 'A';p[0].arrive_t = 0;p[0].service_t = 3;p[0].priority=2;p[1].pname = 'B';p[1].arrive_t = 2;p[1].service_t = 5;p[1].priority=1;p[2].pname = 'C';p[2].arrive_t = 2;p[2].service_t = 2;p[2].priority=4;p[3].pname = 'D';p[3].arrive_t = 4;p[3].service_t = 4;p[3].priority=3;p[4].pname = 'E';p[4].arrive_t = 4;p[4].service_t = 1;p[4].priority=10;p[5].pname = 'F';p[5].arrive_t = 4;p[5].service_t = 4;p[5].priority=8;p[6].pname = 'G';p[6].arrive_t = 6;p[6].service_t = 2;p[6].priority=9;p[7].pname = 'H';p[7].arrive_t = 6;p[7].service_t = 6;p[7].priority=6;p[8].pname = 'I';p[8].arrive_t = 6;p[8].service_t = 5;p[8].priority=7;p[9].pname = 'J';p[9].arrive_t = 6;p[9].service_t = 2;p[9].priority=5;for(int i=0;i<n;i++){p[i].state='w';//初始状态都设为等待p[i].run_t=0;p[i].remaining_t=p[i].service_t;}
}
void original_HPF_P()//输出HPF的初始状态
{printf("进程的初始状态\n");printf("------------------------------------------------------------------\n");printf("进程名\t\t到达时间\t服务时间\t优先级(数越大优先级越高)\n");int i;for(i=0;i<n;i++){printf("%c\t\t %d\t\t %d\t\t %d\n",p[i].pname,p[i].arrive_t,p[i].service_t,p[i].priority);}}void original_RR_P()//输出时间片轮转调度算法各进程的初始状态
{printf("进程的初始状态\n");printf("------------------------------------------------------------------\n");printf("进程名\t\t到达时间\t服务时间\n");int i;for(i=0;i<n;i++){printf("%c\t\t %d\t\t %d\n",p[i].pname,p[i].arrive_t,p[i].service_t);}}
//HPF非抢占式优先级调度算法
//比较后面的优先级
bool cmp1(PCB a,PCB b)//先按到达时间排序，再按优先级排序
{if(a.arrive_t==b.arrive_t){return a.priority>b.priority;//数越大，优先级越高}else{return a.arrive_t<b.arrive_t;}
}
bool cmp2(PCB a,PCB b)//按优先级排序
{return a.priority>b.priority;
}void HPF_work()
{sort(p,p+n,cmp1);//先按到达时间排序，再按优先级排序p[0].finish_t=p[0].arrive_t+p[0].service_t;//第一个进程的完成时间=到达时间+服务时间int cnt=1;//判断完成时间内到达的进程个数,设第一个进程已经到达for(int i=1;i<n;i++)//看每一个进程{if(cnt<n){for(int j=i;j<n;j++)//看后面来的进程{if(p[j].arrive_t<=p[i-1].finish_t)//比较到达时间和上一个进程的完成时间{cnt++;//如果已经达到就标记}elsebreak;}if(cnt>i)//需要排序时sort(p+i,p+cnt,cmp2);//按优先级排序}p[i].finish_t=max(p[i-1].finish_t,p[i].arrive_t)+p[i].service_t;//完成时间}
}bool cmp3(PCB a,PCB b)//按到达时间排序
{return a.arrive_t<b.arrive_t;//按到达时间从小到达排序
}
//时间片轮转法,新来的进程应该放在就绪队列的末尾
void RR_work()
{int q=2;//设时间片=2//先按到达时间排序sort(p,p+n,cmp3);//把这些进程编号为0-9queue<int> ready_q;//就绪队列ready_q.push(0);//先把第一个来的放到就绪队列//如果到达了，就放在就绪队列中，弹出队首元素int temp;int now_time=p[0].arrive_t;//从第一个进程到达时间开始算int cnt=1;//第一个进程已经处理了，接下来从p[1]开始看。int i;printf("进程的执行顺序：\n");while(1){if(!ready_q.empty())//如果不空，队列中有元素，就占用处理机，进入运行状态{temp=ready_q.front();//取队头元素printf("%c ",p[temp].pname);ready_q.pop();//弹出队首元素p[temp].run_t=p[temp].run_t+q;//运行时间now_time=now_time+q;//设有10个进程，下标是从0-9,按顺序排好序的，所以是按顺序到达的while(cnt<n&&p[cnt].arrive_t<=now_time){ready_q.push(cnt);//放入队尾p[cnt].state='m';//进入就绪队列cnt++;//等待下一个进程的到达}if(p[temp].run_t<p[temp].service_t)//如果这个进程还没有运行完成，就放到队列尾部{p[temp].remaining_t=p[temp].service_t-p[temp].run_t;//剩余时间=需要的服务时间-已经运行的时间ready_q.push(temp);//当前的这个再次入队，放在队尾p[temp].state='m';//状态为就绪态}else{now_time=now_time-(p[temp].run_t-p[temp].service_t);p[temp].state='f';//已经执行完了p[temp].finish_t=now_time;}}for( i=0;i<n;i++){if(p[i].state=='m'||p[i].state=='w')//如果还有进程是等待或者就绪态，就继续进行时间片轮转break;}if(i==n)//如果都执行完了break;}printf("\n");
}
bool cmp4(PCB a,PCB b)
{return a.pname<b.pname;//按进程名从小到达排序
}
void Print()
{int i;if(op=='h'||op=='H'){printf("进程执行顺序为：\n");for(i=0;i<n;i++){printf("%c ",p[i].pname);}printf("\n");}sort(p,p+n,cmp4);printf("--------------------------------------------------------------------------------------------------\n");printf("进程名\t\t到达时间\t服务时间\t完成时间\t周转时间\t带权周转时间\n");int sum_t1=0;//代表总的周转时间double sum_t2=0;//代表总的带权周转时间for(i=0;i<n;i++){p[i].turnaround_t=p[i].finish_t-p[i].arrive_t;//周转时间=完成时间-到达时间p[i].w_turnaround_t=(double)p[i].turnaround_t/p[i].service_t;//带权周转时间=周转时间/服务时间sum_t1=sum_t1 + p[i].turnaround_t;sum_t2=sum_t2 + p[i].w_turnaround_t;printf("%c\t\t %d\t\t %d\t\t %d\t\t %d\t\t %0.2f\n",p[i].pname,p[i].arrive_t,p[i].service_t,p[i].finish_t,p[i].turnaround_t,p[i].w_turnaround_t);}printf("平均周转时间:%0.2f\n",(double)sum_t1/n);printf("平均带权周转时间:%0.2f\n",(double)sum_t2/n);}int main()
{printf("请输入要使用的调度算法(<h/H:HPF> <r/R:RR>):");scanf("%c",&op);getchar();init();if(op=='h'|| op=='H'){original_HPF_P();HPF_work();Print();}if(op=='r'||op=='R'){original_RR_P();RR_work();Print();}return 0;
}
详细实验分析和实验报告下载：
https://download.csdn.net/download/QinHebtu/45045191
进程调度算法的模拟实现相关推荐
- linux下进程调度算法实验,Linux下进程调度算法的模拟实现.doc
Linux下进程调度算法的模拟实现 枣 庄 学 院 信息科学与工程学院课程设计任务书 题目: Linux下进程调度算法的模拟实现 学 生1: 学 生2: 学 生3: 专 业: 计算机应用技术 课 程: ...
- 使用动态优先权的进程调度算法的模拟_我爱OS第12讲：系统调度
操作系统必须为多个进程分配计算机资源.对于处理机而言,可分配的资源是在处理机上的执行时间.处理机是计算机系统中的重要资源,处理机调度算法不仅对处理机的利用率和用户进程的执行有影响,同时还与内存等其他资 ...
- 操作系统大作业 基于Linux的模拟进程调度算法 运用c++语言编程 在VMware虚拟机里 centos 亲自写亲自测试 代码 说明书
发布文章 博文管理我的博客退出 Trash Temp 操作系统大作业 基于Linux的模拟进程调度算法 运用c++语言编程 在VMware虚拟机里 centos 亲自写亲自测试 代码 说明书 @[TO ...
- 模拟进程调度算法（时间片轮转、优先权调度 —— 静、动态优先权）—— C/C++
1.优先权调度算法 在模拟优先权调度算法实验中,实现了 非抢占式静态优先权进程调度算法 和 非抢占式动态优先权进程调度算法.如下: (1)非抢占式静态优先权进程调度算法 #include <io ...
- 【操作系统 - 1】先来先服务FCFS和短作业优先SJF进程调度算法
操作系统系列 学习至此,发现很多学了但很久没用的知识,久而久之,慢慢遗忘.等哪天还需要的话,却发现已经忘得差不多了,即使整理了文档(word等),还是得从头再学一遍.读研第一学期,发现很多东西都可以从 ...
- python 3.0 实现多级反馈队列进程调度算法
文章目录 前言 一.操作系统课程设计任务 二.具体实现 1.多级反馈定义 2.代码 前言 写的很拉,但是可以实现多级反馈调度的python3.0代码 算法参考:「土豆洋芋山药蛋」作者的文章 参考文章的 ...
- 进程调度算法——C++实现 [ FCFS,SJF,HPR,HRN + 开源代码 + 详细解析 ]
✅ (原创,库存,第100篇博客,纪念一下) 文章目录 零.动态演示图 一.实现原理 二.实现内容: 三.算法流程图: 3.1 先来先服务算法(FCFS)的流程图: 3.2 最短作业优先算法(SJF) ...
- 进程调度算法FCFS和RR
一. 实验题目 本次试验要求编写的是进程调度中的FCFS算法和RR算法(轮转法). FCFS算法:最简单的CPU调度算法,采取先到先服务的规则,不存在进程优先级之说,也不管进程服务时间的长短,只有前面 ...
- 【操作系统之进程调度算法习题】
操作系统之进程调度算法习题 1.第一题 解答: 2. 第二题 解答: 3. 第三题 解答: 1.第一题 在一个具有三道作业的批处理系统中,作业调度采用先来先服务(FCFS) 调度算法,进程调度采用 短 ...
- 进程调度c语言 fcfs,计算机进程调度算法FCFS、RR、SJF的实现
调度算法,在Linux环境下用C语言编写程序,模拟FCFS.RR.SJF等进程调度算法,以及利用信号量等方法解决哲学家就餐问题. 在主进程中,创建 20 个子线程,分别模拟进程调度算法FCFS.RR. ...
最新文章
- 【dotnet跨平台】Visual Studio Code常见问答
- noip2016 换教室
- mysql关键字使用顺序_MySQL数据库之单表查询中关键字的执行顺序
- [二分搜索|快速选择] leetcode 4 寻找两个正序数组的中位数
- 在C++程序中调用被C编译器编译后的函数为什么要加extern“C”？
- VS编译错误与链接错误汇总
- 浅析Spring.net 中的Aop使用
- vnpy 量化交易系统 源码分析 v0.01
- Word多级标题出现黑块的解决思路
- 强化学习Q-learning简单理解
- 市场28款主流同步整流DCDC芯片横向测评预告
- ios福利部落绕过激活锁，屏幕锁/已停用界面完美隐藏工具,支持最新ios15.5系统绕过
- 怎么查看内网ip？如何分辨IP是公网IP还是内网IP？
- 《穹顶之下》全文整理
- 几何分布的期望和方差公式推导_平方差公式证明推导过程及运用详解（数学简便计算方法之一）...
- SQL数据更新、视图
- PowerPivot——DAX（函数）
- Translation网络异常问题解决
- IBM服务器配置RAID5+热备教程
- php：字符串压缩工具