课程设计
进程调度模拟设计——时间片题目
轮转、非强占式短进程优先算法学院计算机学院
专业
班级
姓名
指导教师吴利军
2013 年 1 月15 日
课程设计任务书
学生姓名：
指导教师：吴利军工作单位：计算机科学与技术学院
题目: 进程调度模拟设计——时间片轮转、非强占式短进程优先算法初始条件：
1．预备内容：阅读操作系统的处理机管理章节内容，对进程调度的功能以及进程调度算法有深入的理解。
2．实践准备：掌握一种计算机高级语言的使用。
要求完成的主要任务:（包括课程设计工作量及其技术要求，以及说明书撰写
等具体要求）
1．模拟进程调度，能够处理以下的情形：
⑴能够选择不同的调度算法（要求中给出的调度算法）；
⑵能够输入进程的基本信息，如进程名、到达时间和运行时间等；
⑶根据选择的调度算法显示进程调度队列；
⑷根据选择的调度算法计算平均周转时间和平均带权周转时间。
2．设计报告内容应说明：
⑴需求分析；
⑵功能设计（数据结构及模块说明）；
⑶开发平台及源程序的主要部分；
⑷测试用例，运行结果与运行情况分析；
⑸自我评价与总结：
i）你认为你完成的设计哪些地方做得比较好或比较出色；
ii）什么地方做得不太好，以后如何改正；
iii）从本设计得到的收获（在编写，调试，执行过程中的经验和教训）；
iv）完成本题是否有其他方法（如果有，简要说明该方法）；
时间安排：
设计安排一周：周1、周2：完成程序分析及设计。
周2、周3：完成程序调试及测试。
周4、周5：验收、撰写课程设计报告。
（注意事项：严禁抄袭，一旦发现，一律按0分记）
指导教师签名：年月日
系主任（或责任教师）签名：年月日
1、需求分析
1.1通过设计一个模拟进程调度的系统，来实现进程调度，对进程调度的功能以及进程调度算法有一个更加深入的理解。
进程PCB（包含进程名、到达时间、预计运行时间等）
调度算法（时间片轮转算法、非强占式短进程优先算法）
能够处理以下的情形：
（1）能够选择不同的调度算法（要求中给出的调度算法）
（2）能够输入进程的基本信息，如进程名、到达时间和运行时间等
（3）根据选择的调度算法显示进程调度队列
（4）根据选择的调度算法计算平均周转时间和平均带权周转时间
此次做的进程调度模拟系统，用户可以输入各进程信息（包含进程名、到达时间、估计运行时间）；输入完毕确认后，可选择两种调度算法中的一种执行，查看结果可得到相应算法的调度序列，每个进程的到达时间、预计运行时间、开始时间、结束时间和周转时间、带权周转时间，以及平均周转时间和平均带权周转时间。
1.2 对进程调度算法的描述与实现
进程基本信息所构成的模块作为基本单元，并且相关调度算法的侧重进程基本信息点不同，所以要根据其调度算法的特点来结合基本信息进行对应的设计。此次课程设计要求的调度算法描述如下：
（1）时间片轮转调度算法
时间片轮转法的基本思想是让每个进程在就绪队列的等待时间与享受服务成正比。基本概念是将CPU的处理时间分成固定大小的时间片。如果一个进程在被调度选中之后用完了系统规定的的时间片，但未完成要求的任务，则它释放自己所占有的CPU而排到就绪队列的末尾，等待下一次调度。同时，进程调度程序又去调度当前就绪队列中的第一个进程或作业。
原理如图所示：
1. 将系统中所有的就绪进程按照FCFS原则，排成一个队列。
2. 每次调度时将CPU分派给队首进程，让其执行一个时间片。时间片的
长度从几个ms到几百ms。
3. 在一个时间片结束时，发生时钟中断。调度程序据此暂停当前进程的
执行，将其送到就绪队列的末尾，并通过上下文切换执行当前的队首进程。
4. 进程可以未使用完一个时间片，就提前调度（如完成/阻塞）
（2）非强占式短进程优先调度算法
不可抢占式（非剥夺式）：分派程序一旦把处理机分配给某进程后便让它一直运行下去，直到进程完成或发生某事件而阻塞时，才把处理机分配给另一个进程。
短作业优先调度算法(SJF)，又称为“短进程优先”（SPN)；这是对FCFS 算法的改进，其目标是减少平均周转时间。
基本思想：对预计执行时间短的作业（进程）优先处理。通常后来的短作业不抢先正在执行的作业。一般情况下这种调度算法比先来先服务调度算法的效率要高，吞吐量要大；但执行时间的估计及算法实现相对较困难，且如果作业的到来顺序及运行时间不合适，会出现饿死现象（如果不断地有短作业到来，运行时间长的作业有可能一直得不到调度执行）。
周转时间
周转时间T
i = 完成时刻Tc
i
－提交时刻Ts
i
= 等待时间Tw
i + 运行时间 Tr
i
对于进入系统的n个作业而言，平均周转时间T为
T=1/n(T1+T2+T3......Tn)
带权周转时间
带权周转时间是作业周转时间与作业执行时间的比：
Wi=Ti/Tri
对于进入系统的n个作业而言，其平均带权周转时间为：
W=1/n(W1+W2+W3+......+Wn)
(3)算法评价
(1)时间片轮转法
1.主要受时间片长度的影响：
过长：退化为FCFS算法，进程在一个时间片内可以都执行完。
过短：一个进程需要多个时间片才能处理完，上下文切换频繁，开销增加。
2.对时间片长度的要求
(时间片长度) = R(要求的响应时间) / N (最大进程数)
3.时间片长度的影响因素
系统的响应时间：时间片越大，响应时间越长（当进程数一定时）
就绪进程的数目：数目越多，时间片越小（当响应时间一定时）
CPU运行速度：CPU运行速度快，则时间片可以短些；反之，则取长些。
(2)短作业优先法——SJF法
优点： a缩短作业的等待时间;
b.提高系统的吞吐量;
c.比FCFS平均周转时间和平均带权周转时间短。
缺点： a.对长作业非常不利，可能长时间得不到执行；
b.未能依据作业的紧迫程度来划分执行的优先级；
c.难以准确估计作业（进程）的执行时间，从而影响调度性能。
2.功能设计（数据结构及模块说明）
2.1数据结构
在本次课设中，需要对进程的基本信息进行相关的描述，进程的基本信息包括进程名、达到的时间、预计的运行时间、开始时间、进程需要的运行时间等。在程序中可用一个结构体链表来储存进程信息。数据结构定义如下：
Struct PCB
{ string name;//进程名
int ta;//进程到达时间
int ts;//进程估计运行的时间
int tb;//进程开始运行时间
int tm;//进程仍需运行的时间
int to;//进程完成的时间
int rn;//进程运行的次数
int totalTime;//周转时间
double weightTotalTime;//带权周转时间(周转时间/估计运行时间）
PCB *next;//定义指向下一个进程的指针};
}
2.2 模块说明
几个主要函数的功能如下:
void main() 程序主函数,提示用户输入相关信息并输出时间片轮转, 非强占式短进程算法的运行结果
PCB *create(PCB *head);//创建进程队列
void SJFrun(PCB *head);//非强占式短进程优先算法
void cyclerun(PCB *head);//时间片轮转算法
3. 开发平台及源程序的主要部分
本程序主要在VS2010中用C++编写，经过运行之后，得到正确结果。
源程序主要部分如下：
(1)非抢占式短进程优先算法：
void SJFrun(PCB *head)
{
sort(head);
int time=0,count;
PCB *p,*q;
string re=””;
while(head->next!=NULL)
{
count=getCount(head,time);
if(count==0)
time++;//如果当前就绪队列中没有进程，时间自增
else
{
if(count==1)//如果就绪队列中只有1个进程，则必定是第一个节点
{
p=head;
q=p->next;
cout<<"******************************************************\n"< cout<<"进程名："< cout<<"到达时间："< cout<<"进程开始运行时间："< time+=q->ts; cout<<"进程"< q->totalTime=time-q->ta; cout<<"周转时间："< q->weightTotalTime=q->totalTime/(double)q->ts; weight+=q->weightTotalTime; cout<<"带权周转时间："< cout<<"******************************************************\n"< del(p); } else //如果就绪队列中的进程数>=2，则在head后的count个 节点中进行短作业优先调度 { p=SJF(head,count); q=p->next; cout<<"******************************************************\n"< cout<<"进程名："< cout<<"到达时间："< cout<<"进程开始运行时间："< time+=q->ts; cout<<"进程"< q->totalTime=time-q->ta; cout<<"周转时间："< q->weightTotalTime=q->totalTime/(double)q->ts; weight+=q->weightTotalTime; cout<<"带权周转时间："< cout<<"******************************************************\n"< del(p); } } } cout<<"平均周转时间："< cout<<"平均带权周转时间："< cout<<"******************************************************\ n"< } (2)时间片轮转算法： void cyclerun(PCB *head)//时间片轮转算法 { sort(head); int time=0;//记录当前时间 int newarrive;//新到达进程数 PCB *rhead; rhead=new PCB; rhead->next=rhead;//创建新的循环链表，存放当前就绪队列中的进程 PCB *p,*q; p=rhead; q=p->next;//q记录当前应当运行的进程 cout<<"******************************************************\n"< cout<<"时间片的长度为："< cout<<"******************************************************\n"< while(time<=total) { newarrive=getCount(head,time); if(newarrive>0)move(head,rhead,newarrive);//将head后的newarrive个节点移动到rhead队列中 if(rhead->next==rhead) time++; else if(q==rhead) { p=q;q=q->next; } else { cout<<"进程名:"< cout<<"到达时间:"< if(q->rn==1) { cout<<"第"< q->tb=time; } if(q->tm<=QT) { time+=q->tm; q->to=time; q->totalTime=time-q->ta; cout<<"进程"< cout<<"周转时间："< q->weightTotalTime=q->totalTime/(double)q->ts; weight+=q->weightTotalTime; cout<<"带权周转时间："< cout<<"******************************************************\n"< PCB *tmp=q; q=q->next; p->next=q; free(tmp); } else { if(q->rn!=1)cout<<"第"< time+=QT; cout<<"第"< cout<<"******************************************************\n"< q->tm-=QT; q->rn++; p=q;q=q->next; } } } cout<<"平均周转时间："< cout<<"平均带权周转时间："< cout<<"******************************************************\n"< } 以上是时间片轮转、非强占式短进程优先算法的主要部分。 4. 测试用例（运行结果与运行情况分析） 在main函数中我们可以进行选择算法以及退出操作，选择完算法后输入各进程的信息来初始化PCB表。 实验结果主要以截图来说明： （1）时间片轮转算法 如图所示：首先出现界面有3个选项，选择1执行时间片轮转算法，输入进程数3。依次输入3个进程以及进程基本信息。 如图所示：时间片定长为2，根据时间片轮转法依次执行进程顺序为b-a-c-a,算出平均周转时间和平均带权周转时间。 （2）非强占式短进程优先算法 如图所示：选择2进入非强占式短进程优先算法，输入进程数，则依次输入进程名，达到时间，运行时间。 如图所示：先运行到达时间最早的进程a,然后依次比较剩下进程b、c、d 的运行时间的长短，运行时间短的优先执行，执行完；剩下的重复比较即可。依次执行进程顺序为a-c-b-d,算出平均周转时间和平均带权周转时间。 5.自我评价与总结 本次课程设计的具体思路老师在操作系统的课上已经给我们讲过，这次课设也给了我一个很好的锻炼和实践的机会，让我对时间片轮转、非强占式短进程优先算法有了更深的了解。 在课程设计中，我将进程定义的时候用了一个结构体PCB，这样一来，对进程的操作会比较简单一些，而且实现了基本信息的有效封装，充分利用链表来实现算法，因为我发现使用循环链表，对于轮转法而言，实现起来比单链表容易得多，复杂度也相对小一些，这是我比较满意的地方。 当然，这次课设我也有不足之处，比如说在处理时间片轮转法时将时间片固定为2秒，并不能根据具体的进程来具体分析，意味着如果需要处理的进程的运行时间都很长的话，会浪费比较多的系统资源来轮转处理器的执行。而对于非强占式短进程优先调度算法先执行第一个提交时间最早的进程，然后比较剩下进程的运行时间，运行时间最短的进程先进行。 通过本次课程设计，一方面提高了我的C++编写能力；同时也理解了2种调度算法之间的优缺点、共同点；另一方面从这次课设中，我对操作系统知识的理解更深了一层，而去提高了我的实践能力。在以后的学习中， 我相信操作系统要学的东西还很多很多，要不断为自己充电，才能彻底地掌握并运用不同的操作系统。 6.源代码 #include #include using namespace std; #define QT 2 struct PCB { string name;//进程名 int ta;//进程到达时间 int ts;//进程运行时间 int tb;//进程开始运行时间 int tm;//进程仍需要运行时间 int to;//进程完成时间 int rn;//进程运行次数 int totalTime;//周转时间 double weightTotalTime;//周转时间 PCB *next; }; int pronum;//进程数 int total;//记录所有进程总时间 double weight;//记录所有进程的总带权周转时间 PCB *create(PCB *head);//创建进程队列 void del(PCB *head);//删除p的下一个节点 void sort(PCB *head);//将进程按到达的先后顺序排列 int getCount(PCB *head,int time);//察看在time之前到达但未移动到运行队列的进程数量 PCB *searchEnd(PCB *head);//查找并返回循坏队列的尾节点 void move(PCB *headF,PCB *headT,int n);//将headF后的n个节点移动到循环队列headT中 void cyclerun(PCB *head);//时间片轮转算法 PCB *SJF(PCB *head,int count);//在头节点后的count个节点中选择需要时间最小的返回 void SJFrun(PCB *head);//非强占式短进程优先算法 PCB *create(PCB *head) { PCB *p1,*p2; p1=p2=new PCB; head=p1; cout<<"请输入进程数："; cin>>pronum; for(int i=0;i { p2=p1; p1=new PCB; p1->next=NULL; cout<<"请依次输入第"< cin>>p1->name>>p1->ta>>p1->ts; p1->tm=p1->ts; p1->rn=1; total+=p1->ts; p2->next=p1; } return head; } void sort(PCB *head)//将进程按到达的先后顺序排列 { PCB *p,*q,*r,*s; if(head->next!=NULL) { p=head->next->next; head->next->next=NULL; } while(p) { q=p; p=p->next; r=head; s=head->next; while(s&&s->ta<=q->ta) { r=s; s=s->next; } r->next=q; q->next=s; } } void del(PCB * p)//删除p的下一个节点 { PCB *tmp; tmp=p->next; p->next=tmp->next; free(tmp); } int getCount(PCB *head,int time)//察看在time之前到达但未移动到运行队列的进程数量{ int count=0; PCB *s,*t; s=head; t=s->next; while(t!=NULL&&t->ta<=time) { s=t; t=t->next; count++;//count记录当前时刻到达的进程数 } return count; } PCB* searchEnd(PCB *head)//查找并返回循坏队列的尾节点 { PCB *p,*q; p=head; q=head->next; while(q->next!=head) { p=q; q=q->next; } return p; } void move(PCB *headF,PCB *headT,int n)//将headF后的n个节点移动到循环队列headT中{ PCB *r,*s,*t; s=headF; t=s->next; r=t;//r记录要移动的第一个节点 while(n>1) { t=t->next; n--; } s->next=t->next;//以上完成从原队列中摘除相关节点,r,t分别为第一个和最后一个节点 s=searchEnd(headT); t->next=s->next; s->next=r; } void cyclerun(PCB *head)//时间片轮转算法 { sort(head); int time=0;//记录当前时间 int newarrive;//新到达进程数 PCB *rhead; rhead=new PCB; rhead->next=rhead;//创建新的循环链表，存放当前就绪队列中的进程 PCB *p,*q; p=rhead; q=p->next;//q记录当前应当运行的进程 cout<<"******************************************************\n"< cout<<"时间片的长度为："< cout<<"******************************************************\n"< while(time<=total) { newarrive=getCount(head,time); if(newarrive>0)move(head,rhead,newarrive);//将head后的newarrive个节点移动到rhead 队列中 if(rhead->next==rhead) time++; else if(q==rhead) { p=q;q=q->next; } else { cout<<"进程名:"< cout<<"到达时间:"< if(q->rn==1) { cout<<"第"< q->tb=time; } if(q->tm<=QT) { time+=q->tm; q->to=time; q->totalTime=time-q->ta; cout<<"进程"< cout<<"周转时间："< q->weightTotalTime=q->totalTime/(double)q->ts; weight+=q->weightTotalTime; cout<<"带权周转时间："< cout<<"******************************************************\n"< PCB *tmp=q; q=q->next; p->next=q; free(tmp); } else { if(q->rn!=1)cout<<"第"< time+=QT; cout<<"第"< cout<<"******************************************************\n"< q->tm-=QT; q->rn++; p=q;q=q->next; } } } cout<<"平均周转时间："< cout<<"平均带权周转时间："< cout<<"******************************************************\n"< } PCB *SJF(PCB *head,int count) { int min; PCB *p,*q,*f; p=head; q=p->next; min=q->ts; f=p;//记录返回指针 while(count>0) { if(q->ts { min=q->ts;f=p; } count--; p=q; q=q->next; } return f; } void SJFrun(PCB *head)// 非强占式短进程优先算法 { sort(head); int time=0,count; PCB *p,*q; string re=" "; while(head->next!=NULL) { count=getCount(head,time); if(count==0) time++;//如果当前就绪队列中没有进程，时间自增 else { if(count==1)//如果就绪队列中只有1个进程，则必定是第一个节点 { p=head; q=p->next; cout<<"******************************************************\n"< cout<<"到达时间："< cout<<"进程开始运行时间："< time+=q->ts; cout<<"进程"< q->totalTime=time-q->ta; cout<<"周转时间："< q->weightTotalTime=q->totalTime/(double)q->ts; weight+=q->weightTotalTime; cout<<"带权周转时间："< cout<<"******************************************************\n"< del(p); } else //如果就绪队列中的进程数>=2，则在head后的count个节点中进行短作业优先调度 { p=SJF(head,count); q=p->next; cout<<"******************************************************\n"< cout<<"进程名："< cout<<"到达时间："< cout<<"进程开始运行时间："< time+=q->ts; cout<<"进程"< q->totalTime=time-q->ta; cout<<"周转时间："< q->weightTotalTime=q->totalTime/(double)q->ts; weight+=q->weightTotalTime; cout<<"带权周转时间："< cout<<"******************************************************\n"< del(p); } } } cout<<"平均周转时间："< cout<<"平均带权周转时间："< cout<<"******************************************************\n"< } void main() { char choice; cout<<"进程调度模拟设计——时间片轮转、非强占式短进程优先算法"< cout<<"1.时间片轮转算法"< cout<<"2.非强占式短进程优先算法"< cout<<"3.退出"< cout<<"请输入您的选择："< cin>>choice; while(choice=='1'||choice=='2') { PCB *head=NULL; switch(choice) { case '1':head=create(head);cyclerun(head);break; case '2':head=create(head);SJFrun(head);break; case '3':break; } cout<<"进程调度模拟设计——时间片轮转、非强占式短进程优先算法"< cout<<"1.时间片轮转算法"< cout<<"2.非强占式短进程优先算法"< cout<<"3.退出"< cout<<"请输入您的选择："< cin>>choice; } } 青岛理工大学 操作系统课程设计报告 院（系）：计算机工程学院 专业：计算机科学与技术专业 学生姓名: 班级：＿＿学号: 题目：短作业优先调度算法的进程调度程序＿ 起迄日期:＿＿＿＿＿＿＿＿ 设计地点: 指导教师: 2011—2012年度第 1 学期 完成日期: 2012 年 1 月日 一、课程设计目的 进行操作系统课程设计主要是在学习操作系统课程的基础上，在完成操作系统各部分实验的基础上，对操作系统的整体进行一个模拟，通过实践加深对各个部分的管理功能的认识，还能进一步分析各个部分之间的联系，最后达到对完整系统的理解。同时，可以提高运用操作系统知识解决实际问题的能力；锻炼实际的编程能力、开发软件的能力；还能提高调查研究、查阅技术文献、资料以及编写软件设计文档的能力。 二、课程设计内容与要求 设计目的：在多道程序和多任务系统中，系统内同时处于就绪状态的进程可能有若干个，且进程之间也存在着同步与互斥的关系，要求采用指定的调度策略，使系统中的进程有条不紊地工作，通过观察诸进程的运行过程，以巩固和加深处理机调度的概念。 2、设计要求（多道、单处理机）： 1)每一个进程有一个PCB，其内容可以根据具体情况设定。 2)可以在界面设定的互斥资源（包括两种：输入设备与输出设备）的数目 3)进程数、进入内存时间、要求服务时间可以在界面上进行设定 4)进程之间存在一定的同步与互斥关系，可以通过界面进行设定，其表示方法如下： 进程的服务时间由三段组成：I2C10O5（表示进程的服务时间由2个时间片的输入，10个时间片的计算，5个时间片的输出） 进程间的同步关系用一个段表示：W2，表示该进程先要等待P2进程执行结束后才可以运行 因此，进程间的同步与互斥关系、服务时间可以统一用四段表示为：I2C10O5W2 5)可以在运行中显示各进程的状态：就绪、阻塞、执行 6)采用可视化界面，可在进程调度过程中随时暂停调度，查看当前进程的状态以及相 应的阻塞队列 7)具有一定的数据容错性 三、系统分析与设计 1、系统分析 本系统主要是采用短作业优先算法进程的进程调度过程。短作业优先调度算法，是指对短作业或短进程优先调度的算法。他们可以分别用于作业调度和进程调度，短作业优先的调度算法是从后备队列中选择一个或若干个估计运行时间最短的作业，将他们调入内存运行。而短进程优先调度算法则是从就绪队列中选出一个估计运行时间最短的进程，将处理机分配给他，，使它立即执行并一直执行到完成，或发生某事件而被阻塞放弃处理机时再度重新调度。本程序采用了非抢占式短作业优先调度。而非抢占式这种方式，一旦把处理机分配给某进程后，便让该进程一直执行，直至该进程完成或发生某事件而被阻塞时，才再把处理机分配给其它进程，决不允许某进程抢占已经分配出去的处理机。这种调度方式的优点是实现简单，系统开销小，适用于大多数的批处理系统环境。但它难以满足紧急任务的要求——立即执行，因而可能造成难以预料的后果。因此，在要求比较严格的实时系统中，不宜采用这种调度方式本系统的主要是在满足要求多道单处理机的情况下进行短作业的优先调度。 本系统在测试时输入了五个进程，按实验要求如I2C10O5（表示进程的服务时间由2个时间片的输入，10个时间片的计算，5个时间片的输出，5个时间片的计算组成）的方式输入，各进程的信息如下：（0 0 1 1 1 ）（1 2 1 2 2 ）（2 4 1 1 1 ） 《操作系统》课程实验报告实验名称：时间片轮转调度算法 班级：**************** 学号：************* 姓名：************** 指导老师：*************** 成绩： 一、实验目的： 1、测试数据可以随即输入或从文件中读入。 2、必须要考虑到进程的到达时间 3、最终能够计算每一个进程的周转时间的带权周转时间。 4、时间片大小可以不为1，但至少实现时间片大小为1的RR调度。 二、实验内容： 模拟实现时间片轮转调度算法，具体如下： 设置进程体：进程名，进程的到达时间，服务时间，，进程状态（W——等待,R ——运行,F——完成），进程间的链接指针 进程初始化：由用户输入进程名、服务时间进行初始化，同时，初始化进程的状态为W。 显示函数：在进程调度前、调度中和调度后进行显示。 排序函数：对就绪状态的进程按照进入就绪队列的时间排序，新到达的进行应优先于刚刚执行过的进程进入就绪队列的队尾。 调度函数：每次从就绪队列队首调度优一个进程执行，状态变化。并在执行一个时间片后化，服务时间变化，状态变化。当服务时间为0时，状态 变为F。 删除函数：撤销状态为F的进行。 三、实验代码 #include 《操作系统》实验报告 题目：作业调度算法 班级：网络工程 姓名：朱锦涛 学号：E31314037 一、实验目的 用代码实现页面调度算法，即先来先服务（FCFS）调度算法、短作业优先算法、高响应比优先调度算法。通过代码的具体实现，加深对算法的核心的理解。 二、实验原理 1.先来先服务（FCFS）调度算法 FCFS是最简单的调度算法，该算法既可用于作业调度，也可用于进程调度。当在作业调度中采用该算法时，系统将按照作业到达的先后次序来进行调度，或者说它是优先考虑在系统中等待时间最长的作业，而不管该作业所需执行的时间的长短，从后备作业队列中选择几个最先进入该队列的作业，将它们调入内存，为它们分配资源和创建进程。然后把它放入就绪队列。 2.短作业优先算法 SJF算法是以作业的长短来计算优先级，作业越短，其优先级越高。作业的长短是以作业所要求的运行时间来衡量的。SJF算法可以分别用于作业和进程调度。在把短作业优先调度算法用于作业调度时，它将从外存的作业后备队列中选择若干个估计运行时间最短的作业，优先将它们调入内存。 3、高响应比优先调度算法 高响应比优先调度算法则是既考虑了作业的等待时间，又考虑了作业的运行时间的算法，因此既照顾了短作业，又不致使长作业等待的时间过长，从而改善了处理机调度的性能。 如果我们引入一个动态优先级，即优先级是可以改变的令它随等待的时间的延长而增加，这将使长作业的优先级在等待期间不断地增加，等到足够的时间后，必然有机会获得处理机。该优先级的变化规律可以描述为： 优先权 = （等待时间 + 要求服务时间）/要求服务时间 三、实验内容 源程序： #include 实验一处理器调度 一、实验容 选择一个调度算法，实现处理器调度。 二、实验目的 在采用多道程序设计的系统中，往往有若干个进程同时处于就绪状态。当就绪进程个数大于处理器数时，就必须依照某种策略来决定哪些进程优先占用处理器。本实习模拟在单处理器情况下的处理器调度，帮助学生加深了解处理器调度的工作。 三、实验题目 设计一个按时间片轮转法实现处理器调度的程序。 [提示]： (1)假定系统有五个进程，每一个进程用一个进程控制块PCB来代表。进程控制块的 格式为： 其中，Q1，Q2，Q3，Q4，Q5。 指针——进程按顺序排成循环队列，用指针指出下一个进程的进程控制块的首地址最后一个进程的指针指出第一个进程的进程控制块首地址。 要求运行时间——假设进程需要运行的单位时间数。 已运行时间——假设进程已经运行的单位时间数，初始值为“0”。 状态——有两种状态，“就绪”和“结束”，初始状态都为“就绪”，用“R”表示。 当一个进程运行结束后，它的状态为“结束”，用“E”表示。 (2) 每次运行所设计的处理器调度程序前，为每个进程任意确定它的“要求运行时间”。 (3) 把五个进程按顺序排成循环队列，用指针指出队列连接情况。另用一标志单元记录轮到运行的进程。例如，当前轮到P2执行，则有： 标志单元 K1 K2 K 3 K4 K5 (4)处理器调度总是选择标志单元指示的进程运行。由于本实习是模拟处理器调度的 功能，所以，对被选中的进程并不实际的启动运行，而是执行： 已运行时间+1 来模拟进程的一次运行，表示进程已经运行过一个单位的时间。 请同学注意：在实际的系统中，当一个进程被选中运行时，必须置上该进程可以运行的时间片值，以及恢复进程的现场，让它占有处理器运行，直到出现等待事件或运行满一个时间片。在这时省去了这些工作，仅用“已运行时间+1”来表示进程已 经运行满一个时间片。 (5)进程运行一次后，应把该进程的进程控制块中的指针值送到标志单元，以指示下一 个轮到运行的进程。同时，应判断该进程的要求运行时间与已运行时间，若该进程的要求运行时间 已运行时间，则表示它尚未执行结束，应待到下一轮时再运行。若该进程的要求运行时间=已运行时间，则表示它已经执行结束，应指导它的状态修改成“结束”（E）且退出队列。此时，应把该进程的进程控制块中的指针值送到前 面一个进程的指针位置。 (6)若“就绪”状态的进程队列不为空，则重复上面的（4）和（5）的步骤，直到所有 的进程都成为“结束”状态。 (7)在所设计的程序中应有显示或打印语句，能显示或打印每次选中进程的进程名以及 运行一次后进程队列的变化。 (8)为五个进程任意确定一组“要求运行时间”，启动所设计的处理器调度程序，显示 或打印逐次被选中的进程名以及进程控制块的动态变化过程。 四. 所用数据结构及符号说明 typedef struct PNode//PCB { struct PNode *next; //定义指向下一个节点的指针 char name[10]; //定义进程名，并分配空间 int All_time; //定义总运行时间 int Runed_Time; //定义已运行时间 char state; //定义进程状态Ready/End } *Proc; //指向该PCB的指针 int ProcNum; //总进程数 课程设计 采用短作业优先调度算法调度程序 学号： 姓名： 专业： 指导老师： 日期： 目录 一、实验题目 (3) 二、课程设计的目的 (3) 三、设计内容 (3) 四、设计要求 (3) 五、主要数据结构及其说明 (4) 六、程序运行结果 (5) 七、流程图 (7) 八、源程序文件 (9) 九、实验体会 (13) 十、参考文献 (13) 摘要 在多道程序环境下，主存中有着多个进程，其数目往往多于处理机数目。这就要求系统能按某种算法，动态地把处理机分配给就绪队列中的一个进程，使之执行。分配处理机的任务是由处理机调度程序完成的。由于处理机是最重要的计算机资源，提高处理机的利用率及改善系统性能（吞吐量、响应时间），在很大程度上取决于处理机调度性能的好坏，因而，处理机调度便成为操作系统设计的中心问题之一。 在多道程序系统中，一个作业被提交后必须经过处理机调度后，方能获得处理机执行。对于批量型作业而言，通常需要经历作业调度和进程调度两个过程后方能获得处理机。作业调度是对成批进入系统的用户作业，根据作业控制块的信息，按一定的策略选取若干个作业使它们可以去获得处理器运行的一项工作。而对每个用户来说总希望自己的作业的周转时间是最小的，短作业优先（SJF）便是其中一种调度方法。本次课程设计主要是模拟短作业优先(SJF)调度算法。 一、实验题目 采用短作业优先算法的的进程调度程序 二、课程设计的目的 操作系统课程设计是计算机专业重要的教学环节，它为学生提供了一个既动手又动脑，将课本上的理论知识和实际有机的结合一起，独立分析和解决实际问题的机会。 进一步巩固和复习操作系统的基础知识。 培养学生结构化程序、模块化程序设计的方法和能力。 提高学生调试程序的技巧和软件设计的能力。 提高学生分析问题、解决问题以及综合利用C语言进行程序设计的能力。 三、设计内容 设计并实现一个采用短作业优先算的进程调度算法演示程序 四、设计要求 1. 每一个进程有一个PCB，其内容可以根据具体情况设定。 2. 进程数、进入内存时间、要求服务时间、优先级等均可以在界面上设定 3. 可读取样例数据（要求存放在外部文件中）进行进程数、进入内存时间、时间片长度、进程优先级的初始化 4. 可以在运行中显示各进程的状态：就绪、执行（由于不要求设置互斥资源与进程间同步关系，故只有两种状态） 5. 采用可视化界面，可在进程调度过程中随时暂停调度，查看当前进程的状态以及相应的阻塞队列 《操作系统》实验一实验报告 【实验题目】：先来先服务FCFS和短作业优先SJF进程调度算法【实验目的】 通过这次实验，加深对进程概念的理解，进一步掌握进程状态的转变、进程调度的策略及对系统性能的评价方法。 【实验内容】 问题描述： 设计程序模拟进程的先来先服务FCFS和短作业优先SJF调度过程。假设有n个进程分别在T1, …,T n时刻到达系统，它们需要的服务时间分别为S1, … ,S n。分别采用先来先服务FCFS和短作业优先SJF 进程调度算法进行调度，计算每个进程的完成时间，周转时间和带权周转时间，并且统计n个进程的平均周转时间和平均带权周转时间。 程序要求如下： 1）进程个数n；每个进程的到达时间T1, …,T n和服务时间S1, … ,S n；选择算法1-FCFS，2-SJF。 2）要求采用先来先服务FCFS和短作业优先SJF分别调度进程运行，计算每个进程的周转时间，带权周转时间，并且计算所有进程的平均周转时间，带权平均周转时间； 3）输出：要求模拟整个调度过程，输出每个时刻的进程运行状态，如“时刻3：进程B开始运行”等等； 4）输出：要求输出计算出来的每个进程的周转时间，带权周转时间， 所有进程的平均周转时间，带权平均周转时间。【实验过程】 #include #include 一、实验目的 （1）在单处理器情况下按时间片轮转算法实现处理器调度，输出运行动态变化过程。 （2）通过算法的实现加深了解处理器调度的工作。 二、实验内容 输入实现处理器调度的几个进程信息，任意确定一组“要求运行时间”，启动所设计的处理器调度程序，显示逐次被选中进程的进程名以及进程控制块的动态变化过程。 三、实验步骤 1、任务分析： 时间片轮转的主要思想就是按顺序为每一个进程一次只分配一个时间片的时间。算法要完成的功能就是将各个进程按照时间片轮转运行的动态过程显示出来。时间片轮转算法的主要实现过程是首先为每一个进程创建一个进程控制块，定义数据结构，说明进程控制块所包含的内容，有进程名、进程所需运行时间、已运行时间和进程的状态以及指针的信息。实现的过程即运用指针指向某一个进程，判断当前的进程是否是就绪状态“r”，如果是，则为该进程分配一个时间片，同时，已运行时间加一且要求运行的时间减一，如此循环执行，当某一个进程的所需要运行的时间减少至0时，则将该进程的状态设置为“e”。然后，将指针指向下一个未运行完成的进程，重复判断，直至所有的进程都运行结束。 2、概要设计： （1）所用数据结构及符号说明 typedef struct PCB{ char name[10]; //进程名 struct PCB *next; //循环链指针 int need_time; //要求运行时间 int worked_time; //已运行时间，初始为0 char condition; //进程状态，只有“就绪”和“结束”两种状态 int flag; //进程结束标志，用于输出 }PCB; PCB *front,*rear; //循环链队列的头指针和尾指针 int N; //N为进程数 （2）主程序的流程图： 实验一进程调度 一、实验目的 编写并调试一个模拟的进程调度程序，以加深对进程的概念及进程调度算法的理解． 二、实验内容 1.采用“短进程优先”调度算法对五个进程进行调度。每个进程有一个进 程控制块（ PCB）表示。进程控制块可以包含如下信息：进程名、到达 时间、需要运行时间、已用CPU时间、进程状态等等。 2.每个进程的状态可以是就绪 W（Wait）、运行R（Run）、或完成F（Finish） 三种状态之一。每进行一次调度程序都打印一次运行进程、就绪队列、 以及各个进程的 PCB，以便进行检查。重复以上过程，直到所要进程都 完成为止。 三、实现思路 主函数-输入函数-短作业优先调度函数-输出函数。 这是一条最基础的思路。输入函数使用文本导入完成数据输入，输出函数输出调度结果，主函数完成各子函数连接，最主要的是短作业优先的调度函数。我想到的方法就是排序，不断选择需要运行时间最短的作业，接着进行数据输入计算输出等，遍历全部数据并完成调度。 四、主要的数据结构 struct Process_struct{ char name[MaxNum]; //进程名称 int arrivetime; //到达时间 int servertime; //开始运行时间 int finishtime; //运行结束时间 int runtime; //运行时间 int runflag; //调度标志 int order; //运行次序 double weightwholetime; //周转时间 double averagewt_FCFS,averagewt_SJF; //平均周转时间 double averagewwt_FCFS,averagewwt_SJF; //平均带权周转时间 }pro[MaxNum]; 五、算法流程图 六、运行与测试 用书上数据对程序进行测试，结果如下： 短作业（进程）优先调度算法 1.短作业（进程）优先调度算法SJ（P）F，是指对短作业或 短进程优先调度的算法。它们可以分别用于作业调度和进程调度。短作业优先（SJF）的调度算法是从后备队列中选择一个或若干个估计运行时间最短的作业，将它们调入内存运行。而短进程（SPF）调度算法则是从就绪队列中选出一个估计运行时间最短的进程，将处理机分配给它，使它立即执行并一直执行到完成，或发生某事件而被阻塞放弃处理机再重新调度。SJ(P)F 调度算法能有效地降低作业（进程）的平均等待时间，提高系统吞吐量。该算法对长作业不利，完全未考虑作业的紧迫程度。 2.流程图 3.代码 #include<> #include<> #include<> struct sjf{ char name[10]; float arrivetime; float servicetime; float starttime; float finishtime; float zztime; float dqzztime; }; sjf a[100]; void input(sjf *p,int N) { int i; printf("intput the process's name & arrivetime & servicetime:\nfor exmple: a 0 100\n"); for(i=0;i<=N-1;i++) { printf("input the %dth process's information:\n",i+1); scanf("%s%f%f",&p[i].name,&p[i].arrivetime,&p[i].servicetim e); 武汉理工大学华夏学院课程设计报告书 课程名称：操作系统原理 题目：时间片轮转进程调度模拟算法的实现系名：信息工程系 专业班级：计算机1132班 姓名：李杰 学号： 10210413209 指导教师: 司晓梅 2015年 6 月 26日 武汉理工大学华夏学院信息工程系 课程设计任务书 课程名称：操作系统原理课程设计指导教师：司晓梅 班级名称：计算机1131-2 开课系、教研室：自动化与计算机 一、课程设计目的与任务 操作系统课程设计是《操作系统原理》课程的后续实践课程，旨在通过一周的实践训练， 加深学生对理论课程中操作系统概念，原理和方法的理解，加强学生综合运用操作系统原理、 Linux系统、C语言程序设计技术进行实际问题处理的能力，进一步提高学生进行分析问题 和解决问题的能力，包含系统分析、系统设计、系统实现和系统测试的能力。 学生将在指导老师的指导下，完成从需求分析，系统设计，编码到测试的全过程。 二、课程设计的内容与基本要求 1、课程设计题目 时间片轮转进程调度模拟算法的实现 2、课程设计内容 用c/c++语言实现时间片轮转的进程调度模拟算法。要求： 1．至少要有5个以上进程 2．进程被调度占有CPU后，打印出该进程正在运行的相关信息 提示: 时间片轮转调度算法中，进程调度程序总是选择就绪队列中的第一个进程，也就是说按照先来先服务原则调度，但一旦进程占用处理机则仅使用一个时间片。在使用完一个时间片后，进程还没有完成其运行，它必须释放出处理机给下一个就绪的进程，而被抢占的进程返回到就绪队列的末尾重新排队等待再次运行。 1）进程运行时，只打印出相关提示信息，同时将它已经运行的时间片加1就可以了。 2）为进程设计出PCB结构。PCB结构所包含的内容，有进程名、进程所需运行时间、已运行时间和进程的状态以及指针的信息等。 3、设计报告撰写格式要求： 1设计题目与要求 2 设计思想 3系统结构 4 数据结构的说明和模块的算法流程图 5 使用说明书（即用户手册）：内容包含如何登录、退出、读、写等操作说明 6 运行结果和结果分析（其中包括实验的检查结果、程序的运行情况） 电子科技大学 实验报告 学生姓名：满博学号：2823103017 指导教师：罗惠琼 一、实验室名称：软件实验室A2412 二、实验项目名称：进程调度算法的设计（短进程优先调度SPF） 三、实验原理： 在多道程序系统中，一个作业被提交后必须经过处理机调度后，方能获得处理机执行。对调度的处理又都可采用不同的调度方式和调度算法。调度算法是指：根据系统的资源分配策略所规定的资源分配算法。 短进程优先调度算法是指对短进程优先调度的算法，它是从后备队列中选择一个或者若干个进程，将处理机分配给它，使它立即执行并一直执行到完成，或发生某事件而被阻塞放弃处理机时再重新调度。 四、实验目的： 通过实现SPF算法深入了解进程调度机制，加深理解。 五、实验内容： 1. 编写SPF算法： ●进程通过定义一个进程控制块的数据结构（PCB）来表示； ●每个进程需要赋予进程ID、进程到达时间、进程需要运行的总时间的属性； 2. 调试无误后运行； 3. 输入需要请求调入的页号； 4. 查看执行结果，根据执行结果判断实验是否成功； 六、实验器材（设备、元器件）： 1．基本环境要求 ①宽敞整洁专用实验室 ②必备的基本实验工具 2．最低设备要求 ①计算机CPU不小于800MHZ； ②计算机内存不小于128M； 3．软硬件要求 ①实验平台Visual c++ 6.0 七、实验步骤： 代码如下： #include 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 //平均带权周转时间主程序的流程: 变量初始化 实验短作业优先SJF进程调度算法模拟 一、实验目的 模拟单处理器系统的进程调度，采用短作业优先的进程调度算法作为进程设计算法，以加深对进程的概念及进程调度算法的理解． 二、实验内容 #include 短作业优先调度算法 学院计算机科学与技术 专业 学号 学生姓名 指导教师姓名 2014-3-18目录 九参考文献……………………………………………………………………………………………………… 实验题目 采用短作业优先算法的进程调度程序 课程设计的目的 操作系统课程设计是计算机专业重要的教学环节，它为学生提供了一个既动手又动脑，将课本上的理论知识和实际有机的结合一起，独立分析和解决实际问题的机会。 进一步巩固和复习操作系统的基础知识。 培养学生结构化程序、模块化程序设计的方法和能力。 提高学生调试程序的技巧和软件设计的能力。 提高学生分析问题、解决问题以及综合利用C语言进行程序设计的能力。 设计内容 设计并实现一个采用短作业优先算的进程调度算法演示程序 设计要求 1. 每一个进程有一个PCB，其内容可以根据具体情况设定。 2. 进程数、进入内存时间、要求服务时间、优先级等均可以在界面上设定 3. 可读取样例数据（要求存放在外部文件中）进行进程数、进入内存时间、时间片长度、进程优先级的初始化 4. 可以在运行中显示各进程的状态：就绪、执行（由于不要求设置互斥资源与进程间同步关系，故只有两种状态） 5. 具有一定的数据容错性 主要数据结构及其说明 算法的简要说明：短作业（进程）优先调度算法SJ（P）F，是指对短作业或短进程优先调度的算法。它们可以分别用于作业调度和进程调度。短作业优先（SJF）的调度算法是从后备队列中选择一个或若干个估计运行时间最短的作业，将它们调入内存运行。而短进程（SPF）调度算法则是从就绪队列中选出一个估计运行时间最短的进程，将处理机分配给它，使它立即执行并一直执行到完成，或发生某事件而被阻塞放弃处理机再重新调度。优点是SJ(P)F调度算法能有效地降低作业（进程）的平均等待时间，提高系统吞吐量。缺点是该算法对长作业不利；完全未考虑作业的紧迫程度，因而不能保证紧迫性作业（进程）长期不被调度；由于作业（进程）的长短只是根据用户所提供的估计执行时间而定的，而用户又可能会有意或无意地缩短其作业的估计运行时间，致使该算法不一定能真正做到短作业游戏那调度。 该程序定义了一个进程数据块(struct spf)，该数据块有进程名(name)、到达时间(arrivetime)、服务时间(servicetime)、开始执行时间(starttime)、完成时间 (finishtime)、周转时间(zztime)、带权周转时间(dqzztime)。用到的公式有：完成时间=到达时间+服务时间；周转时间=完成时间-到达时间；带权周转时间=周转时间/服务时间；(第一次执行的进程的完成时间=该进程的到达时间；下一个进程的开始执行时间=上一个进程的完成时间)。运行进程的顺序需要对进程的到达时间和服务时间进行比较。如果某一进程是从0时刻到达的，那么首先执行该进程；之后就比较进程的服务时间，谁的服务时间短就先执行谁（如果服务时间相同则看它们的到达时间，到达时间短的先执行）；如果到达时间和服务时间相同，则按先来先服务算法执行。 操作系统》实验一实验报告 【实验题目】：先来先服务FCFS 和短作业优先SJF进程调度算法【实验目的】 通过这次实验，加深对进程概念的理解，进一步掌握进程状态的转变、进程调度的策略及对系统性能的评价方法。 【实验内容】 问题描述： 设计程序模拟进程的先来先服务FCFS 和短作业优先SJF 调度过程。假设有n个进程分别在T1, ?,T n时刻到达系统，它们需要的服务时间分别为S1, ?,S n。分别采用先来先服务FCFS和短作业优先SJF 进程调度算法进行调度，计算每个进程的完成时间，周转时间和带权周转时间，并且统计n 个进程的平均周转时间和平均带权周转时间。 程序要求如下： 1）进程个数n；每个进程的到达时间T1, ?,T n 和服务时间S1, ?,S n；选择算法1-FCFS，2-SJF。 2）要求采用先来先服务FCFS 和短作业优先SJF分别调度进程运行，计算每个进程的周转时间，带权周转时间，并且计算所有进程的平均周转时间，带权平均周转时间； 3）输出：要求模拟整个调度过程，输出每个时刻的进程运行状态，如“时刻3：进程 B 开始运行”等等； 4）输出：要求输出计算出来的每个进程的周转时间，带权周转时间， 所有进程的平均周转时间，带权平均周转时间 【实验过程】 #include O S短作业优先调度算 法C语言 采用短作业优先调度算法调度程序 学号： 姓名： 专业： 指导老师： 日期： 目录 一、实验题目 (3) 二、课程设计的目的 (3) 三、设计内容 (3) 四、设计要求 (3) 五、主要数据结构及其说明 (4) 六、程序运行结果 (5) 七、流程图 (7) 八、源程序文件 (9) 九、实验体会 (13) 十、参考文献 (14) 摘要 在多道程序环境下，主存中有着多个进程，其数目往往多于处理机数目。这就要求系统能按某种算法，动态地把处理机分配给就绪队列中的一个进程，使之执行。分配处理机的任务是由处理机调度程序完成的。由于处理机是最重要的计算机资源，提高处理机的利用率及改善系统性能（吞吐量、响应时间），在很大程度上取决于处理机调度性能的好坏，因而，处理机调度便成为操作系统设计的中心问题之一。 在多道程序系统中，一个作业被提交后必须经过处理机调度后，方能获得处理机执行。对于批量型作业而言，通常需要经历作业调度和进程调度两个过程后方能获得处理机。作业调度是对成批进入系统的用户作业，根据作业控制块的信息，按一定的策略选取若干个作业使它们可以去获得处理器运行的一项工作。而对每个用户来说总希望自己的作业的周转时间是最小的，短作业优先（SJF）便是其中一种调度方法。本次课程设计主要是模拟短作业优先(SJF)调度算法。 一、实验题目 采用短作业优先算法的的进程调度程序 二、课程设计的目的 ●操作系统课程设计是计算机专业重要的教学环节，它为学生提供了一个既 动手又动脑，将课本上的理论知识和实际有机的结合一起，独立分析和解决实际问题的机会。 ●进一步巩固和复习操作系统的基础知识。 ●培养学生结构化程序、模块化程序设计的方法和能力。 ●提高学生调试程序的技巧和软件设计的能力。 ●提高学生分析问题、解决问题以及综合利用C语言进行程序设计的能力。 三、设计内容 设计并实现一个采用短作业优先算的进程调度算法演示程序 四、设计要求 1. 每一个进程有一个PCB，其内容可以根据具体情况设定。 2. 进程数、进入内存时间、要求服务时间、优先级等均可以在界面上设定 . 题目先来先服务FCFS和短作业优先SJF进程调度算法 姓名： 学号： 专业： 学院： 指导教师：林若宁 二零一八年十一月 一、实验目的 模拟单处理器系统的进程调度，分别采用短作业优先和先来先服务的进程调度算法作为进程设计算法，以加深对进程的概念及进程调度算法的理解． 二、实验内容 1. 短作业优先调度算法原理 短作业优先调度算法，是指对短作业或断进程优先调度的算法。它们可以分别可以用于作业调度和进程调度。短作业优先调度算法，是从后备队列中选择一个或若干个运行时间最短的作业，将它们调入内存运行。短进程优先调度算法，是从就绪队列中选出一个估计运行时间最短的进程，将处理机分配给它使它立即执行并一直执行到完成，或发生某事件而被阻塞放弃处理机时再重新调度。 2. 先来先服务调度算法原理 先来先服务(FCFS)调度算法是一种最简单的调度算法，该算法既可用于作业调度，也可用于进程调度。当在作业调度中采用该算法时，每次调度都是从后备作业队列中选择一个或多个最先进入该队列的作业，将它们调入内存，为它们分配资源、创建进程，然后放入就绪队列。在进程调度中采用FCFS算法时，则每次调度是从就绪队列中选择一个最先进入该队列的进程，为之分配处理机，使之投入运行。该进程一直运行到完成或发生某事件而阻塞后才放弃处理机。 三、程序设计 1.概要设计 程序包括主函数、FCFS算法函数、SJF算法函数、输出函数；主函数流程：输入文件中的数据—显示各进程数据—选择算法—调用相应算法的函数—输出结果 2.算法流程 SJF算法流程图： 3.详细设计 （1）定义一个结构体 typedef struct PCB { char job_id[10]; //作业ID float Arr_time; //到达时刻 float Fun_time; //估计运行时间 float Wait_time; //等待时间 float Start_time; //开始时刻 float Fin_time; //完成时刻 float Tur_time; //周转时间 float WTur_time; //带权周转时间 int Order; //优先标记 }list; （2）先来先服务算法函数 void fcfs(list *p,int count) //先来先服务算法{ list temp; //临时结构体变量int i; int j; 采用时间片轮转算法调度程序 学号： 姓名： 专业： 指导教师： 日期： 目录 一、需求分析 (3) 1、设计要求： (3) 2、解决方案： (3) 二、课程设计简介 (4) 1、课程设计题目 (4) 2、课程设计目的 (4) 3、课程设计内容 (4) 4、时间安排 (4) 三、概要设计 (4) 1、基本原理 (4) 2、算法思想设计 (5) 3、数据结构及模块说明： (5) 四、主要函数及其说明 (6) 五、调试分析 (7) 1、调试过程及步骤 (7) 2、结果分析（以三个进程数为例） (8) 六、总结及参考文献 (9) 1、总结： (9) 2、参考文献 (9) 附录：程序源代码 (9) 一、需求分析 1、设计要求： 在多道程序或多任务系统中，系统同时处于就绪状态的进程有若干个。为了使系统中各进程能有条不紊地进行，必须选择某种调度策略，以选择一进程占用处理机。要求用时间片轮转算法模拟单处理机调度，以巩固和加深处理机调度的概念。 2、解决方案： （1）、假设系统有5个进程，每个进程用一个进程控制块PCB来表示。PCB包括：进程名、链接指针、到达时间、估计运行时间和进程状态。其中，进程名即进程标识。链接指针指出下一个到达进程的进程控制块地址，按照进程到达的顺序排队，统设置一个队头和队尾指针分别指向第一个和最后一个进程，新生成的进程放队尾。估计运行时间：可由设计者任意指定一个时间值。到达时间：进程创建时的系统时间或由用户指定，调度时，总是选择到达时间最早的进程。进程状态：为简单起见，假定进程有三种状态，就绪、等待和完成，并假定进程一创建就处于就绪状态，用R表示，当一个进程运行结束时，就将其置成完成状态，用F表示。当一个进程未运行完成并且时间片不足时，就将其置成等待状态，用W表示。 （2）、为每个进程任意确定一个要求运行时间和到达时间。 （3）、按照进程到达的先后顺序排成一个循环队列。再设一队首指针指向第一个到达进程的首址。 （4）、执行处理机调度时，开始选择队首的第一个进程运行。另外再设一个当前运行进程的指针，指向当前正运行进程。 （5）、由于本实验是模拟实验，所以对被选中进程并不实际启动运行，而只是执行： a）、估计运行时间减时间片长度； b）、输出当前运行进程的名字。用这两个操作来模拟进程的一次运行（即一个时间片）。 （6）、进程运行一次后，以后的调度则将当前指针依次下移一个位置，指向下一个进程，即调整当前运行指针指向该进程的链接指针所指进程，以指示应运行进程。同时还应判断该进程的剩余运行时间是否为零。若不为零，则等待下一轮的运行；若该进程的剩余运行时间为零，则将该进程的状态置为完成状态F，并退出循环队列插入完成队列。 （7）、若就绪队列不空，则重复上述（5）和（6）步骤直到所有进程都运行完为止。 （8）、在所有设计的调度程序中，应包含显示或打印语句，以便显示或打印每次选中进程的名称及运行一次后队列的变化情况。短作业优先调度算法
时间片轮转调度算法资料
作业调度算法(先来先服务算法,短作业算法)
处理器调度(设计一个按时间片轮转法实现处理器调度的程序)
操作系统短作业优先调度算法
先来先服务和短作业优先调度算法
时间片轮转调度算法
时间片轮转算法
短作业优先调度
短作业优先算法
时间片轮转进程调度模拟算法的实现
进程调度算法设计(短进程优先算法SPF)
时间片轮转调度算法实验报告
实验 短作业优先进程调度算法模拟
短作业优先调度算法 (1)
先来先服务和短作业优先调度算法
OS短作业优先调度算法C语言知识分享
操作系统实验 FCFS和短作业优先SJF调度算法模拟
采用时间片轮转算法调度程序
相关主题
文本预览