课程设计1

阅读更多

采用的是C++语言编写的，但PCB的数据结构是符合要求的。

题目1：模拟进程调度

一、设计目的

1、理解PCB

2、理解进程的并发执行

3、理解进程的FCFS、动态优先权和时间片轮转三种 调度算法，并模拟实现这三种算法

二、设计要求

1、PCB在本设计中的基本结构

Typedefstructnode

{

Char name[10]；/*进程标识符*/

Int prin；/*进程的优先级*/

Int round；/*进程轮转的时间片*/

Int needtime；/*进程还需要的cpu时间*/

Int waittime；/*进程进入系统后等待cpu的时间*/

Char state；/*进程的状态*/

Struct node *next；/*链接指针*/

}PCB

设计三个队列：就绪、 完成、运行，其中运行队列中应该只有一个进程。

创建进程，就是用户输入进程的标识符和运行所需时间，系统为其生成一个PCB，存放进程的信息，将新生成的PCB插入就绪队列。进程任务结束，系统将其PCB插入完成队列，该进程就消亡。

2、动态优先权调度算法模拟：

优先权= 1 + 等待时间/需要服务时间----最高响应比优先

(1) 输入一批作业的进程标识和估计运行时间，将其PCB插入就绪队列

(2) 当就绪队列非空、CPU空闲时，计算出每个就绪进程的优先权

(3) 将优先权最高的进程从就绪队列移入运行队列，状态改为运行

(4) 在屏幕上输出当前所有进程的状态和优先权信息(已完成进程不需此项)

(5) 让运行进程执行足够的服务时间

(6) 将运行进程移入完成队列

(7) 提示可以输入新的作业，如果有新作业输入，则转向(1) ，否则转向(2)

(8) 如果就绪队列为空，则结束

3、时间片轮转调度算法模拟

输入一批作业的进程标识和估计运行时间，由其PCB组成就绪队列。时间片轮转调度，系统要给就绪队列的第一个进程分配一个时间片，大小等于n (个时钟周期)，再将它移入运行队列。注意，时间片的大小要比大多数进程的估计运行时间短。当时间片结束的时候，要将没有运行完的进程从运行队列移到就绪队列的末尾，再次进行调度。在每次调度时将所有进程的当前情况显示出来。

4、FCFS调度算法模拟

按一定的顺序输入一批作业的进程标识和估计运行时间，由其PCB按照进程标识输入的顺序组成就绪队列。当就绪队列非空、CPU空闲时，将就绪队列的第一个进程从就绪队列移入运行队列，状态改为运行。以后个步骤类似于2。

把源码也贴下来吧！！！

/***********模拟进程调度2009.12.30biao************/
 #include"stdafx.h"
 #include
 #include
 #include
 #include
 #include
 #include
 #defineMAX10//最大进程数
 #defineROUND2//进程时间片默认为2
 intflag;
 intamount;
 intflagf=0;
 usingnamespacestd;
 classPCB
{
 stringname;/*进程标识符*/
 floatprin;/*进程的优先级*/
 intround;/*进程轮转的时间片*/
 floatneedtime;/*进程还需要的cpu时间*/
 floatwaittime;/*进程进入系统后等待cpu的时间*/
 stringstate;/*进程的状态*/
 public:
 voidsetname(){
stringm;
 cout<<"标识符:";
cin>>m;
name=m;
}
 voidsetprin(floatp){
prin=p;
}
 voidsetround(){
round=ROUND;
}
 voidsetround(intr){
round=r;
}
 voidsetneedtime(){
 floatn;
 cout<<"执行时间：";
cin>>n;
needtime=n;
}
 voidsetneedtime(floatt){
needtime=t;
}
 voidsetwaittime(floatw){
waittime=w;
}
 voidsetstate(strings){
state=s;
}
stringgetname(){
 returnname;
}
 floatgetprin(){
 returnprin;
}
 intgetround(){
 returnround;
}
 floatgetneedtime(){
 returnneedtime;
}
 floatgetwaittime(){
 returnwaittime;
}
stringgetstate(){
 returnstate;
}
};
 classpro{/*一批进程*/
 private:
PCBproready[MAX];
PCBrunpro;
PCBfinishpro[MAX];
 public:
 intinput(){
 //booltestName;//作为测试进程唯一的标志。
stringyes;
 stringst1="ready";
cout<
 cout<<"请输入进程数量(最大进程数为10):"<
cin>>amount;
 while(amount<=0||amount>21){
cin.clear();
 cin.ignore(1000,'/n');
 cout<<"请输入合法进程数量!"<
cin>>amount;
}
 cout<<"选择调度算法：1.动态优先权2.时间片轮转3.FCFS"<
cin>>flag;
 while(flag!=1&&flag!=2&&flag!=3){
cin.clear();
 cin.ignore(1000,'/n');
 cout<<"选择调度算法：1.动态优先权2.时间片轮转3.FCFS"<
cin>>flag;
}
 if(flag==1){//动态优先权
 for(intj=0;j
proready[j].setname();
testName1(proready,j);
proready[j].setneedtime();
proready[j].setwaittime(0);
proready[j].setround(0);
proready[j].setstate(st1);
proready[j].setprin(1);
cout<
}
 cout<<"*************执行动态优先权排列插入就绪队列**************"<
dynamicsort(proready,amount);
show(proready,amount);
cout<
dynamicrun(proready,amount);
}
 elseif(flag==2){
 for(intj=0;j
proready[j].setname();
testName1(proready,j);
proready[j].setprin(j);
proready[j].setneedtime();
proready[j].setwaittime(0);
proready[j].setround();
proready[j].setstate(st1);
cout<
}
 cout<<"*************算法：时间片轮转执行调度的就绪队列**********"<
show(proready,amount);
cout<
timeround(proready,amount);
}
 elseif(flag==3){
 for(intj=0;j
proready[j].setname();
testName1(proready,j);
proready[j].setprin(j);
proready[j].setneedtime();
proready[j].setwaittime(0);
proready[j].setround(0);
proready[j].setstate(st1);
cout<
}
 cout<<"*************算法：FCFS执行调度的就绪队列**********"<
show(proready,amount);
cout<
FCFS(proready,amount);
}
cout<
 cout<<"继续？（Y/N）:";
cin>>yes;
 if(yes=="Y"||yes=="y"){
 return1;
}
 else{
 return0;
}
}
 voidtestName1(PCBproready[],intj){//判断进程名的唯一性
 booltestName=true;
 while(testName){
 if(j>0){
 for(inti=0;i
 if(proready[j].getname()==proready[i].getname()){
 cout<<"在就绪队列中，已存在该进程名，请重新输入进程名."<
proready[j].setname();
 break;
 }else{
 testName=false;
}
}
 }else
 testName=false;
}
}
 voiddynamicsort(PCBproready[],inti){//动态排列就绪队列
PCBtemp1;
 for(intj=0;j
 for(intk=0;k
 if(proready[k].getprin()
temp1=proready[k];
proready[k]=proready[k+1];
proready[k+1]=temp1;
}
}
}
}
 voidshow(PCBpro1[],inti){//显示进程信息
 cout<<"name"<"prin"<"round"<"needtime"<"waittime"<"state"<
 for(intj=0;j
 if(pro1[j].getstate()=="run"){
cout<
 }elseif(pro1[j].getstate()=="ready"){
cout<
}
 else{
cout<
}
}
}
 voidadd(intm){//在队列尾巴添加进程
 if(m+1>=MAX){
 cout<<"就绪队列已满,不能再增加进程!"<
exit(1);
}
 stringst1="ready";
proready[m+1].setstate(st1);
 if(flag==1){
proready[m+1].setname();
proready[m+1].setneedtime();
proready[m+1].setround(0);
proready[m+1].setprin(1);
 dynamicsort(proready,m+1);//加入动态分配中
}
 elseif(flag==2){
proready[m+1].setname();
proready[m+1].setneedtime();
proready[m+1].setround();
proready[m+1].setwaittime(0);
proready[m+1].setprin(m+1);
}
 elseif(flag==3){
proready[m+1].setname();
proready[m+1].setround(0);
proready[m+1].setneedtime();
proready[m+1].setwaittime(0);
proready[m+1].setprin(proready[m].getprin()+1);
}
}
 voiddynamicrun(PCBproready[],intamount){//动态优先权run
 inta1=amount;
 inti=1;
 intk=0;
 stringa,st3="finished";
PCBtemp1;
 while(a1>0){
cout<
 cout<<"进程第"<"次调度"<
runpro=proready[0];
temp1=proready[0];
 /*输出运行时的进程*/
 proready[0].setstate("run");
 cout<<"**********插入运行队列，进行处理**************"<
show(proready,1);
 for(intj=0;j//对所有的PCB的等待时间加上运行的时间同时修改优先级
proready[j]=proready[j+1];
proready[j].setwaittime(proready[j].getwaittime()+runpro.getneedtime());
proready[j].setprin(1+proready[j].getwaittime()/proready[j].getneedtime());
}
cout<
Sleep(runpro.getneedtime());
 cout<<"**********运行完成，插入完成队列**************"<
finishpro[k]=temp1;
finishpro[k].setstate(st3);
show(finishpro,k+1);
k++;
cout<
a1--;
 cout<<"是否添加新进程？(Y/N):";
cin>>a;
 if(a=="Y"||a=="y"){
add(a1-1);
a1++;
}
 if(a1>0){
dynamicsort(proready,a1);
 cout<<"******重新分配优先权后的就绪队列*******"<
show(proready,a1);
}
i++;
}
}
 voidFCFS(PCBproready[],intamount){
 inta1=amount;
 inti=1;
 intk=0;
 stringa,st3="finished";
PCBtemp1;
 while(a1>0){
 cout<<"进程第"<"次调度"<
runpro=proready[0];
temp1=proready[0];
 proready[0].setstate("run");
 cout<<"**********插入运行队列，进行处理**************"<
show(proready,1);
Sleep(runpro.getneedtime());
 for(intj=0;j
proready[j]=proready[j+1];
proready[j].setwaittime(proready[j].getwaittime()+runpro.getneedtime());
}
 cout<<"**********运行完成，插入完成队列**************"<
finishpro[k]=temp1;
finishpro[k].setstate(st3);
a1--;
show(finishpro,k+1);
k++;
cout<
 cout<<"**************就绪队列****************"<
show(proready,a1);
 cout<<"是否添加新进程？(Y/N):";
cin>>a;
 if(a=="Y"||a=="y"){
add(a1-1);
a1++;
}
i++;
}

}
 voidtimeround(PCBproready[],intamount){//时间片轮转调度算法
 inti=1;//进程调度次数
 floattime;
 floatt=0;
 inta1=amount;//记录剩余进程
 boolt1=true;
 stringst2="run",st3="finished";
 intflag1=0;
 while(t1){
PCBtemp1;
cout<
 cout<<"进程第"<"次调度"<
runpro=proready[0];
runpro.setstate(st2);
temp1=proready[0];
 proready[0].setstate("run");
 cout<<"**********插入运行队列，进行处理**************"<
show(proready,1);
Sleep(runpro.getround());
 for(intj=0;j//前移就绪队列，并修改等待时间
proready[j]=proready[j+1];
proready[j].setwaittime(proready[j].getwaittime()+runpro.getround());
}
 time=temp1.getneedtime()-temp1.getround();//减去此次CPU给的时间片，并判断。
 if(time<=0){
finishpro[flag1]=runpro;
finishpro[flag1].setneedtime(t);
finishpro[flag1].setstate(st3);
flag1++;
a1--;
 if(a1<=0)t1=false;
}
 else{
proready[a1-1]=temp1;
proready[a1-1].setwaittime(t);
proready[a1-1].setneedtime(time);
}
 if(flag1>0){//如果完成队列不为空，才打印完成队列的情况
 cout<<"****************完成队列******************"<
show(finishpro,flag1);
cout<
}
 if(a1>0){
 cout<<"****************就绪队列******************"<
show(proready,a1);
 }else{
 cout<<"就绪队列为空！"<
}

i++;
}
}

};
 intmain(intargc,char*argv[])
{
 inttest;
prop;
test=p.input();
 while(test){
 system("cls");
test=p.input();
}
 return0;
}

小结：没有用数组来表示运行队列，实际上个人也觉得没必要。因为是模拟的，直接修改了PCB的运行状态就OK了。或者当运行时写个sleep(PCB.getNeedtime())来模拟时间的长短即可！