作业调度算法模拟
一．课题内容和要求
常见的作业调度算法有先来先服务算法、最短作业优先算法、响应比优先调度算法。
(1)参考操作系统教材理解这3种算法。
(2)实现这3个算法。
(3)已知若干作业的到达时间和服务时间，用实现的算法计算对该组作业进行调
度的平均周转时间和平均带权周转时间。
(4)作业的到达时间和服务时间可以存放在文本文件中。
(5)设计简单的交互界面，演示所设计的功能。(可以使用MFC进行界面的设计) 二．需求分析
class Job //作业类
{
public:
int ID; //作业编号
Time enter; //进入时间
int requesttime; //估计运行时间
int priority; //优先数
Time start; //开始时间
Time end; //结束时间
int Ttime; //周转时间
double WTtime; //带权周转时间
};
这个模块是设计作业结构（本程序是用的类Job）包括作业编号，进入时间，估计运行时间，优先数，开始时间，结束时间，周转时间，带权周转时间等。class schedule //调度类
{
private:
int size; //作业数
Job *job; //作业数组
int *r; //排序用数组
int Differ(Time t1,Time t2) //求两个时刻间的时间差
{
int borrow = (t2.minute return ((t2.hour-t1.hour-borrow)*60+(borrow*60+t2.minute-t1.minute)); } 这个模块是调度结构本程序为类scheduleb 包括作业数，作业数组，排序用数组。 void FCFS() //先来先服务(First Come First Serve) 这个模块模拟实现算法先来先服务（FCFS ）是按照各个作业进入系统的自然 次序来调度算法。按照作业提交的先后次序分派CPU ，当前作业或进程占用CPU ， 知道执行完成或阻塞，才出让CPU 。在作业或进程被唤醒后，并不立即恢复执行， 通常等到当前作业或进程出让CPU 。 void SJF() //短作业优先(Shortest Job First) 这个模块模拟实现短作业优先，按照作业运行时间从低到高排序，优先处理 短作业。所谓的短作业并不是指物理作业的长短，而是作业的运行时间短。 void HPF() //基于<外部>优先数(Highest Priority First) 这个模块模拟实现优先调度并处理优先数最高的作业。本程序仅针对外部优 先数，即用户规定优先数。 void HRN() //最高响应比优先(Highest Response_ratio Next) 这个模块模拟实现优先处理并处理响应比最高的作业。要通过一个循环找到 一个响应比响应比较高的作业。R=作业周转时间/作业处理时间。 三．概要设计 否 是 开始 初始化所有的作业 根据算法调度一个作业 作业是否处理完 计算相关数据并输出 取下一个作业地址 结束 此程序设计作业结构（本程序为类Job），包括作业编码、进入时间、估计运行时间、优先数、开始时间、结束时间、周转时间和带权周转时间等；调度结构（本程序为类schedule），包括作业数、作业数组以及排序用的数组等。 模拟实现作业调度算法，包括：FCFS（先来先服务算法）、SJF（短作业优先算法）、HRN（最高响应比优先算法）、HPF（基于优先数调度算法）。 四．详细设计 #include #include #include using namespace std; const int defMaxJobNumber = 10; //作业数量的最大值 头文件分别定义输入输出流，iomanip定义关于cin cout的调用，以及sew函数的调用，定义一个作业数量的最大值的常量。 class Time //时间类 { public: int hour; int minute; }; 定义一个时间类，包括小时和分钟。 class Job //作业类 { public: int ID; //作业编号 Time enter; //进入时间 int requesttime; //估计运行时间 int priority; //优先数 Time start; //开始时间 Time end; //结束时间 int Ttime; //周转时间 double WTtime; //带权周转时间 }; 定义一个作业类，定义作业编号，进入时间，估计运行时间，优先数，开始时间，结束时间，周转时间，带权周转时间的变量。 class schedule //调度类 { private: int size; //作业数 Job *job; //作业数组 int *r; //排序用数组 int Differ(Time t1,Time t2) //求两个时刻间的时间差 { int borrow = (t2.minute return ((t2.hour-t1.hour-borrow)*60+(borrow*60+t2.minute-t1.minute)); } 这段代码定义了一个调度类包括作业数，作业数组，排序用数组、用int Differ 球两个时刻间的时间差。 void show() //输出计算结果 { double averageTime=0.0, //平均周转时间 wAverageTime=0.0; //带权平均周转时间 cout<<"编号进入时间运行时间优先数开始时间结束时间周转时间带权周转时间"< for(int i=0;i { cout< if(job[i].enter.minute<10) cout<<"0"< else cout< cout< if(job[i].start.minute<10) cout<<"0"< else cout< cout< if(job[i].end.minute<10) cout<<"0"< else cout< cout< averageTime += job[i].Ttime; wAverageTime += job[i].WTtime; } cout<<"作业平均周转时间T="< cout<<"作业带权平均周转时间W="< } Show输出计算结果。代码首先给初始化平均周转时间和平均带权周转时间都为0.0，然后分别显示编号、进入时间、运行时间、优先数、开始时间、结束时间、周转时间、带权周转时间。然后进入一个for循环，调用sew为作业号，进入时间的显示分派间距。如果进入时间小于10，输出0和进入时间，否则输出进入时间，然后输出需求时间，优先数，开始时间（小时），如果开始时间（分钟）小于10，同理输出0和开始时间。以下类同。分别输出结束时间，平均周转时间，平均带权周转时间。For循环结束后计算作业平均周转时间和作业带权周转时间。 void readFile() //从文件读信息 { ifstream txtfile; txtfile.open("a.txt"); if(!txtfile) { cerr<<"文本文件打开失败!"< exit(1); } int i = 0; int entertime; while(!txtfile.eof()) { txtfile>>job[i].ID>>entertime>>job[i].requesttime>>job[i].priority; job[i].enter.hour = entertime / 100; job[i].enter.minute = entertime % 100; i++; size++; } txtfile.close(); 此代码段定义的是文件读取函数，并且计算出开始的小时和分钟。该函数能够直接读取一个文件，不需要在输入进去。通过i使整个进入时间分别算出小时和分钟。 void FCFS() //先来先服务(First Come First Serve) { int hour,minute,carry; cout<<"先来先服务作业调度算法计算结果:"< job[0].start = job[0].enter;//第一道作业到达的开始时间 hour = job[0].requesttime / 60; minute = job[0].requesttime % 60; job[0].end.minute = (job[0].start.minute + minute) % 60; carry = (job[0].start.minute + minute) / 60; job[0].end.hour = job[0].start.hour + hour + carry; job[0].Ttime = job[0].requesttime; job[0].WTtime = ((double)job[0].Ttime) / job[0].requesttime; for(int i=1;i { job[i].start = job[i-1].end; hour = job[i].requesttime / 60; minute = job[i].requesttime % 60; job[i].end.minute = (job[i].start.minute + minute) % 60; carry = (job[i].start.minute + minute) / 60; job[i].end.hour = job[i].start.hour + hour + carry; job[i].Ttime = Differ(job[i].enter,job[i].end); job[i].WTtime = ((double)job[i].Ttime) / job[i].requesttime; } show(); } 此代码段定义一个先来现服务的函数，第一道作业开始时间开始计算，分别计算出开始时间的小时和分钟。第一道作业的结束时间（分钟）为第一道作业的开始时间加上估计运行的时间对60取余。同理算出开始时间（小时）,第一道作业的周转时间等于估计运行时间，第一道作业的带权周转时间等于周转时间除以需求时间。然后进入一个for循环算出每一个作业的结束时间，周转时间，带权周转时间。 void SJF() //短作业优先(Shortest Job First) { int hour,minute,carry; cout<<"短作业优先作业调度算法计算结果:"< job[0].start = job[0].enter; hour = job[0].requesttime / 60; minute = job[0].requesttime % 60; job[0].end.minute = (job[0].start.minute + minute) % 60; carry = (job[0].start.minute + minute) / 60; job[0].end.hour = job[0].start.hour + hour + carry; job[0].Ttime = job[0].requesttime; job[0].WTtime = ((double)job[0].Ttime) / job[0].requesttime; for(int i=1;i r[i] = i; for(i=1;i { int index = i; for(int j=i+1;j if(job[r[j]].requesttime index = j; if(index!=i) { int w = r[i]; r[i] = r[index]; r[index] = w; } } int dest=0; for(i=1;i { int index = r[i]; job[index].start = job[dest].end; hour = job[index].requesttime / 60; minute = job[index].requesttime % 60; job[index].end.minute = (job[index].start.minute + minute) % 60; carry = (job[index].start.minute + minute) / 60; job[index].end.hour = job[index].start.hour + hour + carry; job[index].Ttime = Differ(job[index].enter,job[index].end); job[index].WTtime = ((double)job[index].Ttime) / job[index].requesttime; dest = index; } show(); } 此代码段定义了一个短作业优先函数，第一道作业的开始时间就等于进入时间，第一道作业的结束时间（分钟）为第一道作业的结束时间加上估计运行时间对60取余。第一道作业的时间同先来现服务的算法一样。然后利用for循环分别对作业从低到高进行排序。排序后短作业的优先执行，所以最短的作业以第一个作业的结束时间为开始时间，然后一次这样下去。在分别计算出周转时间和带权周转时间以及平均周转时间和平均带权周转时间。 void HRN() //最高响应比优先(Highest Response_ratio Next)作业周转时间/作业处理时间 { int hour,minute,carry; cout<<"最高响应比优先作业调度算法计算结果:"< job[0].start = job[0].enter; hour = job[0].requesttime / 60; minute = job[0].requesttime % 60; job[0].end.minute = (job[0].start.minute + minute) % 60; carry = (job[0].start.minute + minute) / 60; job[0].end.hour = job[0].start.hour + hour + carry; job[0].Ttime = job[0].requesttime; job[0].WTtime = ((double)job[0].Ttime) / job[0].requesttime; int dest=0; for(int i=1;i r[i] = i; for(i=1;i { int index = i; for(int j=i+1;j if(((double)Differ(job[r[j]].enter,job[dest].end))/job[r[j]].requesttime> ((double)Differ(job[r[index]].enter,job[dest].end))/job[r[index]].requesttime) index = j; if(index!=i) { int w = r[i]; r[i] = r[index]; r[index] = w; } index = r[i]; job[index].start = job[dest].end; hour = job[index].requesttime / 60; minute = job[index].requesttime % 60; job[index].end.minute = (job[index].start.minute + minute) % 60; carry = (job[index].start.minute + minute) / 60; job[index].end.hour = job[index].start.hour + hour + carry; job[index].Ttime = Differ(job[index].enter,job[index].end); job[index].WTtime = ((double)job[index].Ttime) / job[index].requesttime; dest = index; } show(); } }; 此代码段定义一个最高响应比优先函数，第一道作业的开始时间，结束时间，带 权周转时间，周转时间都与先来现服务的第一道作业的算法相同。 从第二道开始，进入一个for循环， 首先我们要计算出各个作业的响应比：响应比=1+（作业等待时间/作业处理时间）。然后通过循环比较找到响应比最高的那道作业首先执行，此作业的开始时间为第一道作业的结束时间，一次类推知道执行完最后一道作业为止。 int main() { schedule s; s.readFile(); //从文件读信息 s.FCFS(); //先来先服务(First Come First Serve) s.SJF(); //短作业优先(Shortest Job First) s.HRN(); //最高响应比优先(Highest Response_ratio Next) s.HPF(); //基于<外部>优先数(Highest Priority First) return 0; } 定义主函数。 五．测试数据及结果分析 六、调试过程中的问题 调试过程中，对于C++代码不是很熟，所以经常编译失败，我通过老师的帮助以及上网查询解决方法来不断修改错误，完善代码。比如我们要输入8：00时，必须输入800的形式。而且我对短作业优先算法的理解不完善，所以一度导致短作业优先算法的运行结果不正确。后来通过看书和请教老师在不断调式下终于完善了该代码。 七、参考文献和查阅的资料 黄刚、徐小龙、段卫华《操作系统教程》人民邮电出版社 朱立华朱建俞琼《面向对象程序设计及C++》人民邮电出版社 陈向群、杨芙清《操作系统教程》北京大学出版社 沈显君、杨进才、张勇《C++语言程序设计教程》清华大学出版社 八、程序设计总结 通过本次专业课程设计，使我对《操作系统》这门课程有了更深入的理解。《操作系统》是一门实践性较强的课程，为了学好这门课程，必须在掌握理论知识的同时，加强上机实践。一个人的力量是有限的，要想把课程设计做的更好，就要学会参考一定的资料，吸取别人的经验，让自己和别人的思想有机的结合起来，得出属于你自己的灵感。 在这个过程中，我也曾经因为实践经验的缺乏失落过，也曾经仿真成功而热情高涨。生活就是这样，汗水预示着结果也见证着收获。劳动是人类生存生活永恒不变的话题。虽然这只是一次的极简单的课程制作，可是平心而论，也耗费了我不少的心血，这就让我不得不佩服开发技术的前辈，才意识到老一辈对我们社会的付出，为了人们的生活更美好，他们为我们社会所付出多少心血啊！ 对我而言，知识上的收获重要，精神上的丰收更加可喜。让我知道了学无止境的道理。我们每一个人永远不能满足于现有的成就，人生就像在爬山，一座山峰的后面还有更高的山峰在等着你。挫折是一份财富，经历是一份拥有。这次课程设计必将成为我人生旅途上一个非常美好的回忆！ 通过这次的专业课程设计我对于专业课的学习有了更加深刻的认识，以为现在学的知识用不上就加以怠慢，等到想用的时候却发现自己的学习原来是那么的不扎实。以后努力学好每门专业课，让自己拥有更多的知识，才能解决更多的问题！而且老师也给我许多的帮助。在此次实验中我对作业调度算法中的短作业优先算法不是很理解，不太明白该算法的中心思想，在老师和同学的帮助下，我弄懂了。所以我觉得同学之间的合作很重要。也很感谢老师这两个星期对我的帮助。 附录 #include #include #include using namespace std; const int defMaxJobNumber = 10; //作业数量的最大值class Time //时间类 { public: int hour; int minute; }; class Job //作业类 { public: int ID; //作业编号 Time enter; //进入时间 int requesttime; //估计运行时间 int priority; //优先数 Time start; //开始时间 Time end; //结束时间 int Ttime; //周转时间 double WTtime; //带权周转时间 }; class schedule //调度类 { private: int size; //作业数 Job *job; //作业数组 int *r; //排序用数组 int Differ(Time t1,Time t2) //求两个时刻间的时间差 { int borrow = (t2.minute return ((t2.hour-t1.hour-borrow)*60+(borrow*60+t2.minute-t1.minute)); } void show() //输出计算结果 { double averageTime=0.0, //平均周转时间 wAverageTime=0.0; //带权平均周转时间 cout<<"编号进入时间运行时间优先数开始时间结束时间 周转时间带权周转时间"< for(int i=0;i { cout< if(job[i].enter.minute<10) cout<<"0"< else cout< cout< if(job[i].start.minute<10) cout<<"0"< else cout< cout< if(job[i].end.minute<10) cout<<"0"< else cout< cout< averageTime += job[i].Ttime; wAverageTime += job[i].WTtime; } cout<<"作业平均周转时间T="< cout<<"作业带权平均周转时间W="< } public: schedule() //构造函数 { size = 0; job = new Job[defMaxJobNumber]; r = new int[defMaxJobNumber-1]; } void readFile() //从文件读信息 { ifstream txtfile; txtfile.open("a.txt"); if(!txtfile) { cerr<<"文本文件打开失败!"< exit(1); } int i = 0; int entertime; while(!txtfile.eof()) { txtfile>>job[i].ID>>entertime>>job[i].requesttime>>job[i].priority; job[i].enter.hour = entertime / 100; job[i].enter.minute = entertime % 100; i++; size++; } txtfile.close(); cout<<"编号进入时间运行时间优先数"< for(i=0;i { cout< if(job[i].enter.minute<10) cout<<"0"< else cout< cout< } cout< } void FCFS() //先来先服务(First Come First Serve) { int hour,minute,carry; cout<<"先来先服务作业调度算法计算结果:"< job[0].start = job[0].enter;//第一道作业到达的开始时间 hour = job[0].requesttime / 60; minute = job[0].requesttime % 60; job[0].end.minute = (job[0].start.minute + minute) % 60; carry = (job[0].start.minute + minute) / 60; job[0].end.hour = job[0].start.hour + hour + carry; job[0].Ttime = job[0].requesttime; job[0].WTtime = ((double)job[0].Ttime) / job[0].requesttime; for(int i=1;i { job[i].start = job[i-1].end; hour = job[i].requesttime / 60; minute = job[i].requesttime % 60; job[i].end.minute = (job[i].start.minute + minute) % 60; carry = (job[i].start.minute + minute) / 60; job[i].end.hour = job[i].start.hour + hour + carry; job[i].Ttime = Differ(job[i].enter,job[i].end); job[i].WTtime = ((double)job[i].Ttime) / job[i].requesttime; } show(); } void SJF() //短作业优先(Shortest Job First) { int hour,minute,carry; cout<<"短作业优先作业调度算法计算结果:"< job[0].start = job[0].enter; hour = job[0].requesttime / 60; minute = job[0].requesttime % 60; job[0].end.minute = (job[0].start.minute + minute) % 60; carry = (job[0].start.minute + minute) / 60; job[0].end.hour = job[0].start.hour + hour + carry; job[0].Ttime = job[0].requesttime; job[0].WTtime = ((double)job[0].Ttime) / job[0].requesttime; for(int i=1;i r[i] = i; for(i=1;i { int index = i; for(int j=i+1;j if(job[r[j]].requesttime index = j; if(index!=i) { int w = r[i]; r[i] = r[index]; r[index] = w; } } int dest=0; for(i=1;i { int index = r[i]; job[index].start = job[dest].end; hour = job[index].requesttime / 60; minute = job[index].requesttime % 60; job[index].end.minute = (job[index].start.minute + minute) % 60; carry = (job[index].start.minute + minute) / 60; job[index].end.hour = job[index].start.hour + hour + carry; job[index].Ttime = Differ(job[index].enter,job[index].end); job[index].WTtime = ((double)job[index].Ttime) / job[index].requesttime; dest = index; } show(); } void HPF() //基于<外部>优先数(Highest Priority First) { int hour,minute,carry; cout<<"基于<外部>优先数作业调度算法计算结果:"< job[0].start = job[0].enter; hour = job[0].requesttime / 60; minute = job[0].requesttime % 60; job[0].end.minute = (job[0].start.minute + minute) % 60; carry = (job[0].start.minute + minute) / 60; job[0].end.hour = job[0].start.hour + hour + carry; job[0].Ttime = job[0].requesttime; job[0].WTtime = ((double)job[0].Ttime) / job[0].requesttime; for(int i=1;i r[i] = i; for(i=1;i { int index = i; for(int j=i+1;j if(job[r[j]].priority>job[r[index]].priority) index = j; if(index!=i) { int w = r[i]; r[i] = r[index]; r[index] = w; } } int dest=0; for(i=1;i { int index = r[i]; job[index].start = job[dest].end; hour = job[index].requesttime / 60; minute = job[index].requesttime % 60; job[index].end.minute = (job[index].start.minute + minute) % 60; carry = (job[index].start.minute + minute) / 60; job[index].end.hour = job[index].start.hour + hour + carry; job[index].Ttime = Differ(job[index].enter,job[index].end); job[index].WTtime = ((double)job[index].Ttime) / job[index].requesttime; dest = index; } show(); } void HRN() //最高响应比优先(Highest Response_ratio Next)作业周转时间/作业处理时间 { int hour,minute,carry; cout<<"最高响应比优先作业调度算法计算结果:"< job[0].start = job[0].enter; hour = job[0].requesttime / 60; minute = job[0].requesttime % 60; job[0].end.minute = (job[0].start.minute + minute) % 60; carry = (job[0].start.minute + minute) / 60; job[0].end.hour = job[0].start.hour + hour + carry; job[0].Ttime = job[0].requesttime; job[0].WTtime = ((double)job[0].Ttime) / job[0].requesttime; int dest=0; for(int i=1;i r[i] = i; for(i=1;i { int index = i; for(int j=i+1;j if(((double)Differ(job[r[j]].enter,job[dest].end))/job[r[j]].requesttime> ((double)Differ(job[r[index]].enter,job[dest].end))/job[r[index]].requesttime) index = j; if(index!=i) { int w = r[i]; r[i] = r[index]; r[index] = w; } index = r[i]; job[index].start = job[dest].end; hour = job[index].requesttime / 60; minute = job[index].requesttime % 60; job[index].end.minute = (job[index].start.minute + minute) % 60; carry = (job[index].start.minute + minute) / 60; job[index].end.hour = job[index].start.hour + hour + carry; 《计算机操作系统》实验报告 实验五：页面调度算法模拟 学校：╳╳╳ 院系：╳╳╳ 班级：╳╳╳ 姓名：╳╳╳ 学号：╳╳╳ 指导教师：╳╳╳ 目录 一、实验题目 (3) 二、实验学时 (4) 三、指导老师 (4) 四、实验日期 (4) 五、实验目的 (4) 六、实验原理 (4) 6.1页面的含义 (4) 6.2 页面置换算法的含义 (4) 6.3 置换算法 (4) 6.3.1最佳置换算法(Optimal) (5) 6.3.2先进先出(FIFO)页面置换算法 (5) 6.3.3 LRU置换算法 (5) 七、实验步骤及结果 (5) 7.1 验证最佳置换算法 (5) 7.1.1 实验截图 (5) 7.1.2 实验分析 (6) 7.2 验证先进先出(FIFO)页面置换算法 (7) 7.2.1 实验截图 (7) 7.2.2 实验分析 (7) 7.3 验证LRU置换算法 (8) 7.3.1 实验截图 (8) 7.3.2 实验分析 (8) 八、报告书写人 (9) 附录一最佳置换算法(Optimal) (9) 附录二先进先出(FIFO)页面置换算法 (15) 附录三LRU置换算法 (20) 实验五：页面调度算法模拟 一、实验题目 页面调度算法模拟 二、实验学时 2学时 三、指导老师 ╳╳╳ 四、实验日期 2018年12月10日星期一 五、实验目的 (1)熟悉操作系统页面调度算法 (2)编写程序模拟先进先出、LRU等页面调度算法，体会页面调度算法原理 六、实验原理 6.1页面的含义 分页存储管理将一个进程的逻辑地址空间分成若干大小相等的片，称为页面或页。 6.2 页面置换算法的含义 在进程运行过程中，若其所要访问的页面不在内存而需把它们调入内存，但内存已无空闲空间时，为了保证该进程能正常运行，系统必须从内存中调出一页程序或数据，送磁盘的对换区中。但应将哪个页面调出，须根据一定的算法来确定。通常，把选择换出页面的算法称为页面置换算法(Page_Replacement Algorithms)。 6.3 置换算法 一个好的页面置换算法，应具有较低的页面更换频率。从理论上讲，应将那些以后不再会访问的页面换出，或将那些在较长时间内不会再访问的页面调出。 实验名 称 作业调度 实验内容1、设计可用于该实验的作业控制块； 2、动态或静态创建多个作业； 3、模拟先来先服务调度算法和短作业优先调度算法。 3、调度所创建的作业并显示调度结果（要求至少显示出各作业的到达时间，服务时间，开始时间，完成时间，周转时间和带权周转时间）； 3、比较两种调度算法的优劣。 实验原理一、作业 作业(Job)是系统为完成一个用户的计算任务（或一次事物处理）所做的工作总和，它由程序、数据和作业说明书三部分组成，系统根据该说明书来对程序的运行进行控制。在批处理系统中，是以作业为基本单位从外存调入内存的。 二、作业控制块J C B(J o b C o nt r o l Bl o ck) 作业控制块ＪＣＢ是记录与该作业有关的各种信息的登记表。为了管理和调度作业，在多道批处理系统中为每个作业设置了一个作业控制块，如同进程控制块是进程在系统中存在的标志一样，它是作业在系统中存在的标志，其中保存了系统对作业进行管理和调度所需的全部信息。在JCB中所包含的内容因系统而异，通常应包含的内容有：作业标识、用户名称、用户帐户、作业类型(CPU 繁忙型、I/O 繁忙型、批量型、终端型)、作业状态、调度信息(优先级、作业已运行时间)、资源需求(预计运行时间、要求内存大小、要求I/O设备的类型和数量等)、进入系统时间、开始处理时间、作业完成时间、作业退出时间、资源使用情况等。 三、作业调度 作业调度的主要功能是根据作业控制块中的信息，审查系统能否满足用户作业的资源需求，以及按照一定的算法，从外存的后备队列中选取某些作业调入内存，并为它们创建进程、分配必要的资源。然后再将新创建的进程插入就绪队列，准备执行。 四、选择调度算法的准则 1）．面向用户的准则 (1) 周转时间短。通常把周转时间的长短作为评价批处理系统的性能、选择作业调度方式与算法的重要准则之一。所谓周转时间，是指从作业被提交给系统开始，到作业完成为止的这段时间间隔(称 福建农林大学计算机与信息学院 课程设计报告 课程名称：操作系统 实习题目：进程调度算法模拟 姓名： 系：计算机科学与技术系 专业：计算机科学与技术 年级：2012 学号： 指导教师： 职称：副教授 年月日 福建农林大学计算机与信息学院计算机类 课程设计结果评定 目录 1.本选题课程设计的目的 (4) 2.本选题课程设计的要求 (4) 3.本选题课程设计报告内容 (4) 3．1前言 (4) 3．2进程调度算法模拟的环境 (4) 3．3系统技术分析 (4) 3．4系统流程图及各模块 (5) 3．5程序调试情况 (8) 4．总结 (11) 参考文献 (11) 程序代码 (12) 1.设计目的 课程设计将课本上的理论知识和实际有机的结合起来，锻炼学生的分析系统，解决实际问题的能力。提高学生分析系统、实践编程的能力。 2.设计要求 利用学到的操作系统和编程知识，完成具有一定难度的系统分析研究或系统设计题目。其中：专题系统理论研究应包括研究目的、目标，论点和论据以及证明推导等；分析、设计系统应包括编写、调试程序以及最后写出设计报告或系统说明文档文件，系统说明文档包括系统界面、变量说明、系统功能说明、编程算法或思路、流程图和完整程序。具体要求如下： 1、对系统进行功能模块分析、控制模块分析正确； 2、系统设计要实用； 3、编程简练，可用，功能全面； 4、说明书、流程图要清楚。 3.设计方案 3.1前言 本程序包括三种算法，用C或C++语言实现，执行时在主界面选择算法（可用函数实现），进入子页面后输入进程数，（运行时间，优先数由随机函数产生），执行，显示结果。 3.2本选题设计的环境 WindowsXP下的Microsoft Visual C++ 6.0 3.3系统技术分析 （1）编程实现对N个进程采用某种进程调度算法（如动态优先权调度算法、先来先服务算法、短进程优先算法、时间片轮转调度算法）调度执行的模拟。（2）每个用来标识进程的进程控制块PCB可用结构来描述，包括以下字段：进程标识数ID。 进程优先数PRIORITY，并规定优先数越大的进程，其优先权越高。 操作系统实验报告（二） 实验题目：进程调度算法 实验环境：C++ 实验目的：编程模拟实现几种常见的进程调度算法，通过对几组进程分别使用不同的调度算法，计算进程的平均周转时间和平均带权周转时间，比较 各种算法的性能优劣。 实验内容：编程实现如下算法： 1.先来先服务算法； 2.短进程优先算法； 3.时间片轮转调度算法。 设计分析： 程序流程图： 1.先来先服务算法 开始 初始化PCB，输入进程信息 各进程按先来先到的顺序进入就绪队列 结束 就绪队列？ 运行 运行进程所需CPU时间 取消该进程 2.短进程优先算法 3.时间片轮转调度算法 实验代码： 1.先来先服务算法 #include int atime; //进程到达时间 int runtime; //进程运行时间 }fcs; void main() { int amount,i,j,diao,huan; fcs f[n]; cout<<"请输入进程个数:"< 华北科技学院计算机系综合性实验 实验报告 课程名称操作系统C 实验学期2012至2013学年第2学期学生所在系部计算机系 年级专业班级 学生姓名学号 任课教师杜杏菁 实验成绩 计算机系制 《操作系统C》课程综合性实验报告 开课实验室：基础六机房2013年6月3日 实验题目进程调度算法模拟 一、实验目的 通过对进程调度算法的模拟，进一步理解进程的基本概念，加深对进程运行状态和进程调度过程、调度算法的理解。 二、设备与环境 1.硬件设备：PC机一台 2.软件环境：安装Windows操作系统或者Linux操作系统，并安装相关的程序开发环境，如C \C++\Java等编程语言环境。 三、实验内容 （1）用C语言（或其它语言，如Java）实现对N个进程采用某种进程调度算法（如动态优先权调度）的调度。 （2）每个用来标识进程的进程控制块PCB可用结构来描述，包括以下字段： ?进程标识数ID。 ?进程优先数PRIORITY，并规定优先数越大的进程，其优先权越高。 ?进程已占用CPU时间CPUTIME。 ?进程还需占用的CPU时间ALLTIME。当进程运行完毕时，ALLTIME变为0。 ?进程的阻塞时间STARTBLOCK，表示当进程再运行STARTBLOCK个时间片后，进程将进 入阻塞状态。 ?进程被阻塞的时间BLOCKTIME，表示已阻塞的进程再等待BLOCKTIME个时间片后，将 转换成就绪状态。 ?进程状态STATE。 ?队列指针NEXT，用来将PCB排成队列。 （3）优先数改变的原则： ?进程在就绪队列中呆一个时间片，优先数增加1。 ?进程每运行一个时间片，优先数减3。 （4）为了清楚地观察每个进程的调度过程，程序应将每个时间片内的进程的情况显示出来，包括正在运行的进程，处于就绪队列中的进程和处于阻塞队列中的进程。 作业调度实验报告 Document number：NOCG-YUNOO-BUYTT-UU986-1986UT 实验二作业调度 一.实验题目 1、编写并调试一个单道处理系统的作业等待模拟程序。 作业调度算法：分别采用先来先服务（FCFS），最短作业优先（SJF）、响应比高者优先（HRN）的调度算法。 （1）先来先服务算法：按照作业提交给系统的先后顺序来挑选作业，先提交的先被挑选。 （2）最短作业优先算法：是以进入系统的作业所提出的“执行时间”为标准，总是优先选取执行时间最短的作业。 （3）响应比高者优先算法：是在每次调度前都要计算所有被选作业（在后备队列中）的响应比，然后选择响应比最高的作业执行。 2、编写并调度一个多道程序系统的作业调度模拟程序。 作业调度算法：采用基于先来先服务的调度算法。可以参考课本中的方法进行设计。 对于多道程序系统，要假定系统中具有的各种资源及数量、调度作业时必须考虑到每个作业的资源要求。 二.实验目的： 本实验要求用高级语言（C语言实验环境）编写和调试一个或多个作业调度的模拟程序，了解作业调度在操作系统中的作用，以加深对作业调度算法的理解三 .实验过程 <一>单道处理系统作业调度 1)单道处理程序作业调度实验的源程序: 执行程序: 2)实验分析： 1、由于在单道批处理系统中，作业一投入运行，它就占有计算机的一切资源直到作业完成为止，因此调度作业时不必考虑它所需要的资源是否得到满足，它所占用的 CPU 时限等因素。 2、每个作业由一个作业控制块JCB 表示，JCB 可以包含如下信息：作业名、提交时间、所需的运行时间、所需的资源、作业状态、链指针等等。作业的状态可以是等待W(Wait)、运行R(Run)和完成F(Finish)三种状态之一。每个作业的最初状态总是等待W 。 3、对每种调度算法都要求打印每个作业开始运行时刻、完成时刻、周转时间、带权周转时间，以及这组作业的平均周转时间及带权平均周转时间。 3)流程图: 二.最短作业优先算法 三.高响应比算法 图一.先来先服务流程图 4)源程序: #include <> #include <> #include <> #define getpch(type) (type*)malloc(sizeof(type)) #define NULL 0 int n; float T1=0,T2=0; int times=0; struct jcb .\n",p->name); free(p); .wait...",time); if(times>1000) 代替 代替 先来先服务FCFS和短作业优先SJF进程调度算法 1、实验目的 通过这次实验，加深对进程概念的理解，进一步掌握进程状态的转变、进程调度的策略及对系统性能的评价方法。 2、需求分析 (1) 输入的形式和输入值的范围 输入值：进程个数Num 范围：0 说明本程序中用到的所有抽象数据类型的定义、主程序的流程以及各程序模块之间的层次(调用)关系。 4、详细设计 5、调试分析 (1)调试过程中遇到的问题以及解决方法，设计与实现的回顾讨论和分析 ○1开始的时候没有判断进程是否到达，导致短进程优先算法运行结果错误，后来加上了判断语句后就解决了改问题。 ○2 基本完成的设计所要实现的功能，总的来说，FCFS编写容易，SJF 需要先找到已经到达的进程，再从已经到达的进程里找到进程服务时间最短的进程，再进行计算。 (2)算法的改进设想 改进：即使用户输入的进程到达时间没有先后顺序也能准确的计算出结果。（就是再加个循环，判断各个进程的到达时间先后，组成一个有序的序列） (3)经验和体会 通过本次实验，深入理解了先来先服务和短进程优先进程调度算法的思想，培养了自己的动手能力，通过实践加深了记忆。 6、用户使用说明 （1）输入进程个数Num 操作系统课程设计报告题目：进程调度算法的模拟实现_ 专业计算机科学与技术 学生姓名 班级 学号 指导教师 发放日期2015.1.30 信息工程学院 目录 1 概述 (1) 2 设计原理 (1) 2.1先来先服务算法 (1) 3 详细设计与编码 (2) 3.1 模块设计 (2) 3.2 系统流程图 (2) 3.3 系统详细设计 (2) 4 结果与分析 (6) 4.1 测试方案 (6) 4.2 测试结果 (6) 4.3 测试结果分析 (9) 5 设计小结 (10) 6 参考文献 (10) 附录程序代码 (12) 进程调度算法的模拟实现 进程调度算法的模拟实现 1 概述 选择一个调度算法，实现处理机调度，进程调度算法包括：先来先服务算法，短进程优先算法，时间片轮转算法，动态优先级算法。可选择进程数量，本程序包括四种算法，用C或C++语言实现，执行时在主界面选择算法（可用函数实现），进入子页面后输入进程数，（运行时间，优先数由随机函数产生），执行，显示结果。 2 设计原理 2.1先来先服务(FCFS)算法 每次调度都是从后备作业队列中选择一个或多个最先进入该队列的作业，将它们调入内存，为它们分配资源创建进程，然后放入就绪队列 2.2 时间片轮转法(RR)算法 系统将所有的就绪进程按先来先服务的原则排成一个队列，每次调度时，把CPU分配给队首进程，并令其执行一个时间片。时间片的大小从几ms到几百ms。当执行的时间片用完时，由一个计时器发出时钟中断请求，调度程序便据此信号来停止该进程的执行，并将它送往就绪队列的末尾；然后，再把处理机分配给就绪队列中新的队首进程，同时也让它执行一个时间片。 2.3短作业优先(SJF)算法 短作业优先调度算法是从就绪队列中选出一个估计运行时间最短的进程，将处理机分配给它，使它立即执行并一直执行到完成，或发生某事件而被阻塞放弃处理机时再重新调度。 2.4最高优先权优先(HRRN)算法 优先权调度算法是为了照顾紧迫型作业，使之在进入系统后便获得优先处理，引入最高优先权优先调度算法。动态优先权是指在创建进程时所赋予的优先权，是可以随进程的推进或随其等待时间的增加而改变的，以便获得更好的调度性能。 作业调度 一、实验目的 1、对作业调度的相关内容作进一步的理解。 2、明白作业调度的主要任务。 3、通过编程掌握作业调度的主要算法。 二、实验内容及要求 1、对于给定的一组作业, 给出其到达时间和运行时间，例如下表所示： 2、分别用先来先服务算法、短作业优先和响应比高者优先三种算法给出作业的调度顺序。 3、计算每一种算法的平均周转时间及平均带权周转时间并比较不同算法的优劣。 测试数据 workA={'作业名':'A','到达时间':0,'服务时间':6} workB={'作业名':'B','到达时间':2,'服务时间':50} workC={'作业名':'C','到达时间':5,'服务时间':20} workD={'作业名':'D','到达时间':5,'服务时间':10} workE={'作业名':'E','到达时间':12,'服务时间':40} workF={'作业名':'F','到达时间':15,'服务时间':8} 运行结果 先来先服务算法 调度顺序:['A', 'B', 'C', 'D', 'E', 'F'] 周转时间: 带权周转时间: 短作业优先算法 调度顺序:['A', 'D', 'F', 'C', 'E', 'B'] 周转时间: 带权周转时间:1. 响应比高者优先算法 调度顺序:['A', 'D', 'F', 'E', 'C', 'B'] 周转时间: 带权周转时间: 五、代码 #encoding=gbk workA={'作业名':'A','到达时间':0,'服务时间':6,'结束时间':0,'周转时间':0,'带权周转时间':0} workB={'作业名':'B','到达时间':2,'服务时间':50} workC={'作业名':'C','到达时间':5,'服务时间':20} workD={'作业名':'D','到达时间':5,'服务时间':10} workE={'作业名':'E','到达时间':12,'服务时间':40} workF={'作业名':'F','到达时间':15,'服务时间':8} list1=[workB,workA,workC,workD,workE,workF] list2=[workB,workA,workC,workD,workE,workF] list3=[workB,workA,workC,workD,workE,workF] #先来先服务算法 def fcfs(list): resultlist = sorted(list, key=lambda s: s['到达时间']) return resultlist #短作业优先算法 def sjf(list): time=0 resultlist=[] for work1 in list: time+=work1['服务时间'] listdd=[] ctime=0 for i in range(time): for work2 in list: if work2['到达时间']<=ctime: (work2) if len(listdd)!=0: li = sorted(listdd, key=lambda s: s['服务时间']) (li[0]) (li[0]) ctime+=li[0]['服务时间'] listdd=[] 实验二作业调度 一. 实验题目 1、编写并调试一个单道处理系统的作业等待模拟程序。 作业调度算法：分别采用先来先服务（FCFS,最短作业优先（SJF）、响应 比高者优先（HRN的调度算法。 （1）先来先服务算法：按照作业提交给系统的先后顺序来挑选作业, 先提交的先被挑选。 （2）最短作业优先算法：是以进入系统的作业所提出的“执行时间”为标准, 总是优先选取执行时间最短的作业。 （3）响应比高者优先算法：是在每次调度前都要计算所有被选作业（在后备队列中）的响应比,然后选择响应比最高的作业执行。 2、编写并调度一个多道程序系统的作业调度模拟程序。 作业调度算法：采用基于先来先服务的调度算法。可以参考课本中的方法进 行设计。 对于多道程序系统,要假定系统中具有的各种资源及数量、调度作业时必须考虑到每个作业的资源要求。 二. 实验目的： 本实验要求用高级语言（C语言实验环境）编写和调试一个或多个作业调度的模拟程序,了解作业调度在操作系统中的作用,以加深对作业调度算法的理解 三. 实验过程 < 一>单道处理系统作业调度 1）单道处理程序作业调度实验的源程序: zuoye.c 执行程序: zuoye.exe 2）实验分析： 1、由于在单道批处理系统中，作业一投入运行，它就占有计算机的一切资 源直到作业完成为止，因此调度作业时不必考虑它所需要的资源是否得到 满足，它所占用的CPU时限等因素。 2、每个作业由一个作业控制块JCB表示，JCB可以包含如下信息：作业名、 提交时间、所需的运行时间、所需的资源、作业状态、链指针等等。作业 的状态可以是等待W(Wait)、运行R(Run)和完成F(Finish)三种状态之一 每个作业的最初状态总是等待W 3、对每种调度算法都要求打印每个作业幵始运行时刻、完成时刻、周转时 间、带权周转时间，以及这组作业的平均周转时间及带权平均周转时间 3) 流程图: .最短作业优先算法 三.高响应比算法 图一.先来先服务流程图 4) 源程序： #in elude 一．课程概述 1.1.设计构想 程序能够完成以下操作：创建进程：先输入进程的数目，再一次输入每个进程的进程名、运行总时间和优先级，先到达的先输入；进程调度：进程创建完成后就选择进程调度算法，并单步执行，每次执行的结果都从屏幕上输出来。 1.2.需求分析 在多道程序环境下，主存中有着多个进程，其数目往往多于处理机数目，要使这多个进程能够并发地执行，这就要求系统能按某种算法，动态地把处理机分配给就绪队列中的一个进程，使之执行。分配处理机的任务是由处理机调度程序完成的。由于处理机是最重要的计算机资源，提高处理机的利用率及改善系统必（吞吐量、响应时间），在很大程度上取决于处理机调度性能的好坏，因而，处理机调度便成为操作系统设计的中心问题之一。本次实验在VC++6.0环境下实现先来先服务调度算法，短作业优先调度算法，高优先权调度算法，时间片轮转调度算法和多级反馈队列调度算法。 1.3.理论依据 为了描述和管制进程的运行，系统为每个进程定义了一个数据结构——进程控制块PCB(Process Control Block),PCB中记录了操作系统所需的、用于描述进程的当前情况以及控制进程运行的全部信息，系统总是通过PCB对进程进行控制，亦即，系统是根据进程的PCB 而不是任何别的什么而感知进程的存在的，PCB是进程存在的惟一标志。本次课程设计用结构体Process代替PCB的功能。 1.4.课程任务 一、用C语言（或C++）编程实现操作模拟操作系统进程调度子系统的基本功能；运用多 种算法实现对进程的模拟调度。 二、通过编写程序实现进程或作业先来先服务、高优先权、按时间片轮转、短作业优先、多 级反馈队列调度算法，使学生进一步掌握进程调度的概念和算法，加深对处理机分配的理解。 三、实现用户界面的开发 （1）用C语言（或其它语言，如Java）实现对N个进程采用某种进程调度算法（如动态优先权调度）的调度。 （2）每个用来标识进程的进程控制块PCB可用结构来描述，包括以下字段：?进程标识数ID。 ?进程优先数PRIORITY，并规定优先数越大的进程，其优先权越高。 ?进程已占用CPU时间CPUTIME。 ?进程还需占用的CPU时间ALLTIME。当进程运行完毕时，ALLTIME变为0。 ?进程的阻塞时间STARTBLOCK，表示当进程再运行STARTBLOCK个时间 片后，进程将进入阻塞状态。 ?进程被阻塞的时间BLOCKTIME，表示已阻塞的进程再等待BLOCKTIME 个时间片后，将转换成就绪状态。 ?进程状态STATE。 ?队列指针NEXT，用来将PCB排成队列。 （3）优先数改变的原则： ?进程在就绪队列中呆一个时间片，优先数增加1。 ?进程每运行一个时间片，优先数减3。 （4）为了清楚地观察每个进程的调度过程，程序应将每个时间片内的进程的情况显示出来，包括正在运行的进程，处于就绪队列中的进程和处于阻塞队列中的进程。 （5）分析程序运行的结果，谈一下自己的认识。 实验代码 #include "iostream.h" #include "windows.h" //#define N 3 typedef struct{ int ID; int PRIORITY; int CPUTIME; int ALLTIME; int STARTBLOCK; int BLOCKTIME; int STATE;//0-运行1-阻塞2-就绪3-结束4-未到达 int REACH; int TIME; }PROCESS; void textcolor (int color) { SetConsoleTextAttribute (GetStdHandle (STD_OUTPUT_HANDLE), color ); } void main(){ int i,time,max,l,l1,time1,flag=0,total=0,N,server[10],sum=0; PROCESS pro[10]; textcolor(13); cout<<"注意：本程序中状态代表如下"< xx大学操作系统实验报告 姓名：学号：班级： 实验日期： 实验名称：时间片轮转RR进程调度算法 实验二时间片轮转RR进程调度算法 1.实验目的：通过这次实验，理解时间片轮转RR进程调度算法的运行原理，进一步 掌握进程状态的转变、进程调度的策略及对系统性能的评价方法。 2.需求分析 (1) 输入的形式和输入值的范围； 输入：进程个数n 范围：0 (4) 测试数据，包括正确的输入及其输出结果和含有错误的输入及其输出结果。正确输入： 错误输入： 2、概要设计 所有抽象数据类型的定义： static int MaxNum=100 int ArrivalTime //到达时间 int ServiceTime //服务时间 int FinishedTime //结束时间 int WholeTime //周转时间 double WeightWholeTime //带权周转时间double AverageWT //平均周转时间double AverageWWT //平均带权周转时间主程序的流程: 变量初始化 《操作系统》实验报告 题目：作业调度算法 班级：网络工程 姓名：朱锦涛 学号：E31314037 一、实验目的 用代码实现页面调度算法，即先来先服务（FCFS）调度算法、短作业优先算法、高响应比优先调度算法。通过代码的具体实现，加深对算法的核心的理解。 二、实验原理 1.先来先服务（FCFS）调度算法 FCFS是最简单的调度算法，该算法既可用于作业调度，也可用于进程调度。当在作业调度中采用该算法时，系统将按照作业到达的先后次序来进行调度，或者说它是优先考虑在系统中等待时间最长的作业，而不管该作业所需执行的时间的长短，从后备作业队列中选择几个最先进入该队列的作业，将它们调入内存，为它们分配资源和创建进程。然后把它放入就绪队列。 2.短作业优先算法 SJF算法是以作业的长短来计算优先级，作业越短，其优先级越高。作业的长短是以作业所要求的运行时间来衡量的。SJF算法可以分别用于作业和进程调度。在把短作业优先调度算法用于作业调度时，它将从外存的作业后备队列中选择若干个估计运行时间最短的作业，优先将它们调入内存。 3、高响应比优先调度算法 高响应比优先调度算法则是既考虑了作业的等待时间，又考虑了作业的运行时间的算法，因此既照顾了短作业，又不致使长作业等待的时间过长，从而改善了处理机调度的性能。 如果我们引入一个动态优先级，即优先级是可以改变的令它随等待的时间的延长而增加，这将使长作业的优先级在等待期间不断地增加，等到足够的时间后，必然有机会获得处理机。该优先级的变化规律可以描述为： 优先权 = （等待时间 + 要求服务时间）/要求服务时间 三、实验内容 源程序： #include 实验一、进程调度实验报告 广东技术师范学院实验报告 学院：计算机科学学 院 专业： 计算机科学与 技术（师范） 班级：成绩： 姓名：学号：组别：组员： 实验地点：实验日期：指导教师签名： 实验名称：实验一、进程调度实验 一、实验目的 用高级语言编写和调试一个进程调度程序，以加深对进程的概念及进程调度算法的理解 二、实验类别 综合性实验。综合高级语言编程、进程调度模型、进程调度算法及数据结构等多方面的知识 三、实验内容和步骤 1．编写并调试一个模拟的进程调度程序，采用“最高优先数优先”调度算法对五个进程进行调度。 “最高优先数优先”调度算法的基本思想是把CPU分配给就绪队列中优先数最高的进程。 静态优先数是在创建进程时确定的，并在整个进程运行期间不再改变。 动态优先数是指进程的优先数在创建进程时可以给定一个初始值，并且可以按一定原则修改优先数。例如：在进程获得一次CPU后就将其优先数减少1。或者，进程等待的时间超过某一时限时增加其优先数的值，等等 该题根据老师给的代码用Visual C++运行，结果以及分析如下： 预习情况操作情况考勤情况数据处理情况 结果分析：根据上述输入的三个进程的信息可以得到：优先级最高的是进程cc 最先调度进程cc的状态为运行态，需要执行的时间为10当前就绪队列状态为：进程aa先级比较高，处于就绪队列前面，而进程bb先级是三者中最低的，所以处于就绪队列的最后。而此时这两个进程的状态都为就绪态。 结果分析：当进程cc了一个时间片之后而它已占用CPU时间已达到所需要的运行时间，则将它的优先级减1之后，再将三个进程按优先级的大小排列，从中选择优先级大的进程进入运行状态，则该次进入运行态的是进程aa 按照这种方式一直运行下去： 直到: FCFS和SJF进程调度算法实验报告 【实验题目】：编写程序，实现FCFS和SJF算法，模拟作 业调度过程，加深对作业调度的理解。 【实验内容】 实现FCFS和SJF调度算法。 –数据结构设计（JCB，后备作业队列） –算法实现与模拟（排序、调度） –输出调度结果，展示调度过程并解释 【实验要求】 1. 设计作业控制块(JCB)的数据结构 –应包含实验必须的数据项，如作业ID、需要的服务时间、进入系 统时间、完成时间，以及实验者认为有必要的其他数据项。 2. 实现排序算法（将作业排队） –策略1：按“进入系统时间”对作业队列排序(FCFS) –策略2：按“需要的服务时间”对作业队列排序（SJF） 3. 实现调度过程模拟 （1）每个作业用一个JCB表示，如果模拟FCFS，按策略1将作业排队，如果模拟SJF，按策略2将作业排队（2）选择队首的作业，将其从后备队列移出 （3）（作业运行过程，在本实验中，无需实现，可认为后备队列的 作业一但被调度程序选出，就顺利运行完毕，可以进入第4步） （4）计算选中作业的周转时间 （5）进行下一次调度（去往第2步） 4.实现结果输出 –输出作业状态表，展示调度过程 ?初始作业状态（未调度时） ?每次调度后的作业状态 设计作业控制块(JCB)的数据结构 每个作业由一个作业控制块JCB表示，JCB可以包含如下信息：作业名、提交时间、所需的运行时间、所需的资源、作业状态、链指针等等。具体结构如下：typedef struct jcb{ char name[10]; /* 作业名*/ char state; /* 作业状态*/ int ts; /* 提交时间*/ float super; /* 优先权*/ int tb; /* 开始运行时间*/ int tc; /* 完成时间*/ float ti; /* 周转时间*/ float wi; /* 带权周转时间*/ int ntime; /* 作业所需运行时间*/ char resource[10]; /* 所需资源*/ struct jcb *next; /* 结构体指针*/ } JCB; JCB *p,*tail=NULL,*head=NULL; 作业的状态可以是等待W(Wait)、运行R(Run)和完成F(Finish)三种状态之一。每个作业的最初状态总是等待W。，组成一个后备队列等待，总是首先调度等待队列中队首的作业。 实验二作业调度 一.实验题目 1、编写并调试一个单道处理系统的作业等待模拟程序。 作业调度算法：分别采用先来先服务（FCFS），最短作业优先（SJF）的调度算法。 （1）先来先服务算法：按照作业提交给系统的先后顺序来挑选作业，先提交的先被挑选。 （2）最短作业优先算法：是以进入系统的作业所提出的“执行时间”为标准，总是优先选取执行时间最短的作业。 二.实验目的： 本实验要求用高级语言（C语言实验环境）编写和调试一个或多个作业调度的模拟程序，了解作业调度在操作系统中的作用，以加深对作业调度算法的理解 三.实验过程 <一>单道处理系统作业调度 1)单道处理程序作业调度实验的源程序: zuoye.c 执行程序: zuoye.exe 2)实验分析： 1、由于在单道批处理系统中，作业一投入运行，它就占有计算机的一切资源直到作业 完成为止，因此调度作业时不必考虑它所需要的资源是否得到满足，它所占用的 CPU 时限等因素。 2、每个作业由一个作业控制块JCB表示，JCB可以包含如下信息：作业名、提交时间、 所需的运行时间、所需的资源、作业状态、链指针等等。作业的状态可以是等待 W(Wait)、运行R(Run)和完成F(Finish)三种状态之一。每个作业的最初状态总是等待W。 3、对每种调度算法都要求打印每个作业开始运行时刻、完成时刻、周转时间、带权周 转时间，以及这组作业的平均周转时间及带权平均周转时间。 3)流程图: 代替 二.最短作业优先算法 代替 三.高响应比算法 图一.先来先服务流程图 4)源程序: #include 操作系统 ——项目文档报告 进程调度算法 专业： 班级： 指导教师： 姓名： 学号： 一、核心算法思想 1.先来先服务调度算法 先来先服务调度算法是一种最简单的调度算法，该算法既可以用于作业调度，也可用于进程调度。当在作业调度中采用该算法时，每次调度都是从后备作业队列中选择一个或多个最先进入该队列的作业，将他们调入内存，为它们分配资源、创建进程，然后放入就绪队列。在进程调度中采用FCFS算法时，则每次调度是从就绪队列中选择一个最先进入该队列的进程，为之分配处理机，使之投入运行。该进程一直运行到完成或发生某事件而阻塞后才放弃处理机。FCFS算法比较有利于长作业（进程），而不利于短作业（进程）。 2.短作业（进程）优先调度算法 短作业（进程）优先调度算法SJ（P）F，是指对短作业或短进程优先调度的算法。它们可以分别用于作业调度和进程调度。短作业优先（SJF）的调度算法是从后备队列中选择一个或若干个估计运行时间最短的作业，将它们调入内存运行。而短进程（SPF）调度算法则是从就绪队列中选出一个估计运行时间最短的进程，将处理机分配给它，使它立即执行并一直执行到完成，或发生某事件而被阻塞放弃处理机再重新调度。SJ(P)F调度算法能有效地降低作业（进程）的平均等待时间，提高系统吞吐量。该算法对长作业不利，完全未考虑作业的紧迫程度。 3.高响应比优先调度算法 在批处理系统中，短作业优先算法是一种比较好的算法，其主要不足之处是长作业的运行得不到保证。如果我们能为每个作业引人动态优先权，并使作业的优先级随着等待时间的增加而以速率a提高，则长作业在等待一定的时间后，必然有机会分配到处理机。该优先权的变化规律可描述为: 优先权=（等待时间+要求服务时间）/要求服务时间 即优先权=响应时间/要求服务时间 如果作业的等待时间相同，则要求服务的时间越短，其优先权越高，因而该算法有利于短作业。 当要球服务的时间相同时，作业的优先权决定于其等待时间，等待时间越长，优先权越高，因而它实现的是先来先服务 对于长作业，作业的优先级可以随着等待时间的增加而提高，当其等待时间足够长时，其优先级便可以升到很高，从而也可获得处理机。 4.时间片轮转算法 在时间片轮转算法中，系统将所有的就绪进程按先来先服务的原则排成一个队列，每次调度时，把CPU分配给队首进程，并令其执行一个时间片。当执行的时间片用完时，由一个计数器发出时钟中断请求，调度程序便据此信号来停止该进程的执行，并将它送往就绪队列的末尾；然后，再把处理机分配给就绪队列中新的队首进程，同时也让它执行一个时间片。这样就可以保证就绪队列中的所有进程在一给定的时间内均能获得一时间片的处理机执行时间。换言之，系统能在给定的时间内响应所有用户的请求。 二、核心算法流程图 实验项 目名称 作业调度 实验目的及要求一、实验目的： 1、通过模拟作业调度算法的设计加深对作业管理基本原理的理解。 2、深入了解批处理系统如何组织作业、管理作业和调度作业。 3、掌握作业调度算法。 二、实验要求： 1、编写程序完成实验内容； 2、对测试数据进行分析； 3、撰写实验报告。 实验内容1、设计可用于该实验的作业控制块； 2、动态或静态创建多个作业； 3、模拟先来先服务调度算法和短作业优先调度算法。 3、调度所创建的作业并显示调度结果（要求至少显示出各作业的到达时间，服务时间，开始时间，完成时间，周转时间和带权周转时间）； 3、比较两种调度算法的优劣。 实验原理一、作业 作业(Job)是系统为完成一个用户的计算任务（或一次事物处理）所做的工作总和，它由程序、数据和作业说明书三部分组成，系统根据该说明书来对程序的运行进行控制。在批处理系统中，是以作业为基本单位从外存调入内存的。 二、作业控制块J C B(J o b C o n t ro l B lo c k) 作业控制块ＪＣＢ是记录与该作业有关的各种信息的登记表。为了管理和调度作业，在多道批处理系统中为每个作业设置了一个作业控制块，如同进程控制块是进程在系统中存在的标志一样，它是作业在系统中存在的标志，其中保存了系统对作业进行管理和调度所需的全部信息。在JCB中所包含的内容因系统而异，通常应包含的内容有：作业标识、用户名称、用户帐户、作业类型(CPU 繁忙型、I/O 繁忙型、批量型、终端型)、作业状态、调度信息(优先级、作业已运行时间)、资源需求(预计运行时间、要求内存大小、要求I/O设备的类型和数量等)、进入系统时间、开始处理时间、作业完成时间、作业退出时间、资源使用情况等。 三、作业调度 作业调度的主要功能是根据作业控制块中的信息，审查系统能否满足用户作业的资源需求，以及实验五-页面调度算法模拟实验报告
作业调度_实验报告
进程调度算法模拟 (操作系统课程设计报告)
进程调度算法实验报告
进程调度算法模拟实验
作业调度实验报告
先来先服务FCFS和短作业优先SJF进程调度算法_实验报告材料
进程调度算法的模拟实现
操作系统实验报告-作业调度
作业调度实验报告
进程模拟调度算法课程设计
进程调度算法模拟程序设计C++
时间片轮转调度算法实验报告
作业调度算法(先来先服务算法,短作业算法)
实验一、进程调度实验报告
FCFS和SJF进程调度算法实验报告
操作系统作业调度实验报告
操作系统模拟进程调度算法
作业调度实验报告
相关主题
文本预览