进程调度算法

进程调度

/****************************************************************************** ******************************************************

* Source File Name : LGY_CPU_Scheduler *

* Project Name: LGY_CPU_Scheduler *

* Engineer: 赖国勇*

* Date Generated: 2007-11-19 *

* Last Revision Date: 2011-04-12 *

* Brief Description:

*

* [实验内容] *

* ①、实验目的*

* a、进程调度是处理机管理的核心内容。观察、体会操作系统的进程调度方法，*

* 并通过一个简单的进程调度模拟程序的实现，加深对进程控制块、进程队列、进程调度算法，进程切换的理解，*

* 并体会和了解各种调度算法的具体实施办法。*

* b、提高实际动手编程能力，为日后从事软件开发工作打下坚实基础。*

* ②、实验内容*

* a、设计进程控制块PCB表结构，模拟实现进程调度算法：FIFO，静态优先级调度，*

* 时间片轮转调度，短进程优先调度算法，多级反馈队列调度。（实现其中之一个以上）。*

* b、编写一个进程调度程序模拟程序。模拟程序只对PCB进行相应的调度模拟操作，不需要实际程序。*

* c、由用户输入（可通过文件输入）进程名、进程状态、进程运行时间和进程优先级等数据。*

* ③、实验要求*

* a、使用模块化设计思想来设计；*

* b、给出主函数和各个算法函数的流程图。

* c、学生可按照自身条件，随意选择采用的算法，（例如：采用冒泡法编写程序，实现短进程优先调度的算法）*

* d、进程调度程序模拟程序只对PCB进行相应的调度模拟操作，不需要实际程序。

*

* ④、运行结果*

* a、给出进程的调度模拟操作排序结果。*

* ⑤、提示*

* a、每个进程可有三个状态，并假设初始状态为就绪状态。*

* b、为了便于处理，程序中的进程运行时间以纳秒为单位计算。*

* c、各进程的优先级或轮转时间数以及进程需运行的纳秒数的初始值均由用户给定。*

* d、在优先级算法中，采用静态优先级。在时间片轮转算法中，采用可变时间片，由用户给定。*

* e、对于遇到优先级一致的情况，采用FIFO策略解决。*

*

*

* 一、在WINDOWS中双击DEBUG目录中的EXE文件直接运行，可能会没有显示结果窗口就关闭了，这不是程序错误，解决方法是：*

* 1、“开始->程序->附件-命令提示符”,打开DOS命令窗口。*

* 2、改变当前目录至EXE文件所在目录；（或者将EXE文件和测试用的文本文件一并复制到当前目录）。*

* 3、输入EXE文件的完整名称（含后缀名）运行即可。（为方便输入，可以重命名EXE文件。）*

* 二、本程序包括:FIFO，优先级调度算法（静态优先级），时间片轮转调度算法，短进程优先调度算法。*

* VC++6.0调试通过项目类型：Win32 Console Application *

* 输入：进程流文件（文本文件），其中存储的是一系列要执行的进程，每个进程包括四个数据项：*

* 进程名(长度不超过20个的字符串) 进程状态(1就绪2等待3运行) 所需时间优先级(0级最高) *

* 输出: 进程执行流等待时间平均等待时间*

******************************************************************************* ******************************************************/

#include

#include

#include

const int MAXPCB=100; //定义最大进程数

//定义进程控制块PCB结构体类型

typedef struct PCB_Node{

char sName[20]; //进程名

int iStatus; //进程状态(1就绪2等待3运行) 当前程序中暂时全部默认为就绪处理

int iRunTime; //进程运行时间（纳秒）

int iPriority; //进程优先级(0级最高)

int iFinished; //进程是否执行完成标志（1：已完成；0：末完成）

int iWaitTime; //进程等待时间（纳秒）

}PCB;

PCB pcbs[MAXPCB]; //PCB数组队列

int iPCBNum; //实际进程数

char sFileName[20]; //进程流文件名

void InitPCB(); //PCB初始化函数

int ReadPCBFile(); //读进程流文件数据，存入PCB数组队列pcbs，并输出

void ReSetPCB(); //重置PCB完成标志、等待时间,以供另一个调度算法使用，并输出所读入的进程数据

void FIFO(); //先进先出调度算法

void Priority(); //优先级调度算法

void RR(); //时间片轮转调度算法

void SPF(); //短进程优先调度算法

void Hint(); //显示实验提示信息函数

void Version(); //显示版权信息函数

void InitPCB() //PCB初始化函数

{

int i;

for(i=0;i

{

strcpy(pcbs[i].sName,"");

pcbs[i].iStatus=-1;

pcbs[i].iRunTime=-1;

pcbs[i].iPriority=-1;

pcbs[i].iFinished=0;

pcbs[i].iWaitTime=0;

} //for(i=0;i

iPCBNum=0;

} //void InitPCB()

int ReadPCBFile() //读进程流文件数据，存入PCB数组队列pcbs，并输出

{

FILE *fp;

int i;

char cHead;

cout<<" 请输入进程流（文本）文件名（注意：包括后缀名）: ";

cin>>sFileName;

if((fp=fopen(sFileName,"r"))==NULL)

{

cout<<" 错误：进程流文件"<

return 0;

}

else //if((fp=fopen(sFileName,"r"))==NULL)

{

cHead=fgetc(fp);

while(cHead==' '||cHead==10||cHead==9) //过滤空格、换行和TAB字符

{

cHead=fgetc(fp);

}

if(cHead==EOF)

{

printf(" 错误：进程流文件：%s 为空!!\n",sFileName );

return 0;

}

else //if(cHead==EOF)

{

fseek( fp, -1, SEEK_CUR);

while(!feof(fp))

{

fscanf(fp,"%s %d %d %d",pcbs[iPCBNum].sName,&pcbs[iPCBNum].iStatus,&pcbs[iPCBN

um].iRunTime,&pcbs[iPCBNum ].iPriority);

iPCBNum++;

} //while(!feof(fp))

//输出所读入的进程数据

cout<

cout<<" 进程名进程状态运行时间优先级"<

for(i=0;i

{

cout<<" "<

"<

}

cout<<" 进程总数："<

return 1;

} //if(cHead==EOF)

} //if((fp=fopen(sFileName,"r"))==NULL)

}// int ReadPCBFile()

void ReSetPCB() //重置PCB完成标志、等待时间,以供另一个调度算法使用，并输出所读入的进程数据

{

int i;

//输出所读入的进程数据

cout<

cout<

cout<<" 进程名进程状态运行时间优先级"<

for(i=0;i

{

pcbs[i].iFinished=0;

pcbs[i].iWaitTime=0;

cout<<" "<

"<

}

cout<<" 进程总数："<

} //void ReSetPCB()

void FIFO() //先进先出调度算法

{

int i,j;

int iSum; //总等待时间

//输出先进先出调度算法执行流

cout<

cout<<" 先进先出调度算法执行流:"<

cout<<" 序号进程名运行时间等待时间"<

iSum=0;

for(i=0;i

{

cout<<" "<

"<

iSum+=pcbs[i].iWaitTime; //累加总等待时间

for(j=i+1;j

{

pcbs[j].iWaitTime+=pcbs[i].iRunTime;

}

}

cout<<" 总调度次数:"<

cout<<" 总等待时间:"<

printf(" 平均等待时间%.2f\n",(float)iSum / (float)iPCBNum);

cout<

} //void FIFO()

void Priority() //优先级调度算法

{

int i,j;

int iCurMin; //当前最低优先级PCB在数组pcbs中的下标

int iPassedTime=0; //已经过的时间

int iSum; //总等待时间

int iQueue[MAXPCB]; //用于存放排序后进程数组下标的数组队列

int iCurPriority=1000; //当前最低优先级

for(i=0;i

{

iCurPriority=1000;

for(j=0;j

{

if((pcbs[j].iFinished==0)&&(pcbs[j].iPriority

{

iCurMin=j;

iCurPriority=pcbs[j].iPriority;

}

} //for(j=0;j

iQueue[i]=iCurMin;

pcbs[iCurMin].iFinished=1;

pcbs[iCurMin].iWaitTime+=iPassedTime;

iPassedTime+=pcbs[iCurMin].iRunTime;

} //for(i=0;i

//输出优先级调度执行流

cout<

cout<<" 优先级调度执行流:"<

cout<<" 序号进程名优先级运行时间等待时间"<

iSum=0;

for(i=0;i

{

cout<<" "<

"<

"<

iSum+=pcbs[iQueue[i]].iWaitTime; //累加总等待时间}

cout<<" 总调度次数:"<

cout<<" 总等待时间:"<

printf(" 平均等待时间%.2f\n",(float)iSum / (float)iPCBNum);

cout<

} //void Priority()

void RR() //时间片轮转调度算法

{

int i;

int iNotEnded=1; //标志：不是所有进程都已经获得足够时间片运行完成

int iNum; //到目前为止末执行完的进程数

int iRound=0; //轮转周期数

int iSum=0; //总时间片数

float fBlockTime=10; //时间片的长度（纳秒）

cout<

cin>>fBlockTime;

cout<

cout<<" 时间片轮转调度执行流（时间片的长度为："<

while(iNotEnded==1)

{

iNotEnded=0;

iNum=0;

for(i=0;i

{

if(pcbs[i].iFinished==0)

{

iNum++;

} //if(pcbs[i].iFinished==0)

} //for(i=0;i

if(iNum>0)

{

iRound++; //累加轮转周期数

cout<

for(i=0;i

{

if(pcbs[i].iFinished==0)

{

iNotEnded=1;

cout<

iSum++; //累加总时间片数

if(pcbs[i].iRunTime<=fBlockTime*(iRound))

//i进程在本轮获得一个时间片后能够运行完成

{

pcbs[i].iFinished=1;

} //if(pcbs[i].iRunTime<=fBlockTime*(iRound+1))

}//if(pcbs[i].iFinished==0)

} //for(i=0;i

} //if(iNum>0)

} //while(iNotEnded==1)

cout<

cout<

}//void RR()

void SPF() //短进程优先调度算法

{

int i,j;

int iCurMin; //当前最短运行时间PCB在数组pcbs中的下标

int iPassedTime=0; //已经过的时间

int iSum; //总等待时间

int iQueue[MAXPCB]; //用于存放排序后进程数组下标的数组队列

int iCurRunTime; //当前最短进程运行时间

for(i=0;i

{

iCurRunTime=1000000;

for(j=0;j

{

if((pcbs[j].iFinished==0)&&(pcbs[j].iRunTime

{

iCurMin=j;

iCurRunTime=pcbs[j].iRunTime;

}

} //for(j=0;j

iQueue[i]=iCurMin;

pcbs[iCurMin].iFinished=1;

pcbs[iCurMin].iWaitTime+=iPassedTime;

iPassedTime+=pcbs[iCurMin].iRunTime;

} //for(i=0;i

//输出短进程优先调度执行流

cout<

cout<<" 短进程优先调度执行流:"<

cout<<" 序号进程名运行时间等待时间"<

iSum=0;

for(i=0;i

{

cout<<" "<

"<

iSum+=pcbs[iQueue[i]].iWaitTime; //累加总等待时间

}

cout<<" 总调度次数:"<

cout<<" 总等待时间:"<

printf(" 平均等待时间%.2f\n",(float)iSum / (float)iPCBNum);

cout<

} //void SPF ()

void Hint() //显示实验提示信息函数

{

cout<

cout<<"

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"<

cout<<" [实验内容] "<

cout<<" ①、实验目的"<

cout<<" a、进程调度是处理机管理的核心内容。观察、体会操作系统的进程调度方法，"<

cout<<" 并通过一个简单的进程调度模拟程序的实现，加深对进程控制块、进程队列、"<

cout<<" 进程调度算法，进程切换的理解，并体会和了解各种调度算法的具体实施办法。"<

cout<<" b、提高实际动手编程能力，为日后从事软件开发工作打下坚实基础。

"<

cout<<" ②、实验内容"<

cout<<" a、设计进程控制块PCB表结构，模拟实现进程调度算法：FIFO，静态优先级调度，"<

cout<<" 时间片轮转调度，短进程优先调度算法，多级反馈队列调度（实现其中之一个以上）。"<

cout<<" b、编写一个进程调度程序模拟程序。模拟程序只对PCB进行相应的调度模拟操作，不需要实际程序。"<

cout<<" c、由用户输入（可通过文件输入）进程名、进程状态、进程运行时间和进程优先级等数据。"<

cout<<" ③、实验要求"<

cout<<" a、使用模块化设计思想来设计；"<

cout<<" b、给出主函数和各个算法函数的流程图。"<

cout<<" c、学生可按照自身条件，随意选择采用的算法，（例如：采用冒泡法编写程序，实现短进程优先调度的算法）。"<

cout<<" d、进程调度程序模拟程序只对PCB进行相应的调度模拟操作，不需要实际程序。"<

cout<<" ④、运行结果"<

cout<<" a、给出进程的调度模拟操作排序结果。"<

cout<<" ⑤、提示"<

cout<<" a、每个进程可有三个状态，并假设初始状态为就绪状态。"<

cout<<" b、为了便于处理，程序中的进程运行时间以纳秒为单位计算。"<

cout<<" c、各进程的优先级或轮转时间数以及进程需运行的纳秒数的初始值均由用户给定。"<

cout<<" d、在优先级算法中，采用静态优先级。在时间片轮转算法中，采用可变时间片，由用户给定。"<

cout<<" e、对于遇到优先级一致的情况，采用FIFO策略解决。"<

cout<<" 一、在WINDOWS中双击DEBUG目录中的EXE文件直接运行，可能会没有显示结果窗口就关闭了，这不是程序错误，解决方法是："<

cout<<" 1、“开始->程序->附件-命令提示符”,打开DOS命令窗口。"<

cout<<" 2、改变当前目录至EXE文件所在目录；（或者将EXE文件和测试用的文本文件一并复制到当前目录）。"<

cout<<" 3、输入EXE文件的完整名称（含后缀名）运行即可。（为方便输入，可以重命名EXE文件。）"<

cout<<" 二、本程序包括:FIFO，优先级调度算法（静态优先级），时间片轮转调度算法，短进程优先调度算法。VC++6.0调试通过项目类型：Win32 Console Application。"<

cout<<" 输入：进程流文件（文本文件），其中存储的是一系列要执行的进程，每个进程包括四个数据项："<

cout<<" 进程名(长度不超过20个的字符串) 进程状态(1就绪2等待3运行) 所需时间优先级(0级最高) "<

cout<<" 输出: 进程执行流等待时间平均等待时间"<

cout<<"

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"<

cout<

} //void Hint()

void Version() //显示版权信息函数

{

cout<

cout<<" ┏━━━━━━━━━━━━━━━━━━━━━━━┓"<

cout<<" ┃进程调度算法模拟系统┃"<

cout<<" ┠───────────────────────┨"<

cout<<" ┃(c)All Right Reserved ┃"<

cout<<" ┃LGY 赖国勇┃"<

cout<<" ┃Version 2011 build 2.1 ┃"<

cout<<" ┗━━━━━━━━━━━━━━━━━━━━━━━┛"<

cout<

} //void Version()

void main() //主函数

{

int iInput; //用户输入的整数以选择算法

bool bGoOn; //是否继续进程调度算法模拟的标志

char sGoOn[1]; //用户输入是否继续进程调度算法模拟的字母：y、Y、N、n

Hint(); //显示实验提示信息函数

Version(); //显示版权信息函数

InitPCB(); //PCB初始化函数

bGoOn= true;

strcpy(sGoOn," ");

if(ReadPCBFile()==1) //标志读进程流文件数据函数执行是否正确

{

while (bGoOn)

{

cout<

cout<<" 1 先进先出调度算法"<

cout<<" 3 时间片轮转调度算法"<

cin>>iInput; //从标准输入获取用户输入的整数以选择算法

switch(iInput)

{

case 1:

ReSetPCB(); //重置PCB完成标志、等待时间,以供另一个调度算法使用，并输出所读入的进程数据

FIFO(); //先进先出调度算法

break;

case 2:

ReSetPCB(); //重置PCB完成标志、等待时间,以供另一个调度算法使用，并输出所读入的进程数据

Priority(); //优先级调度算法

break;

case 3:

ReSetPCB(); //重置PCB完成标志、等待时间,以供另一个调度算法使用，并输出所读入的进程数据

RR(); //时间片轮转调度算法

break;

case 4:

ReSetPCB(); //重置PCB完成标志、等待时间,以供另一个调度算法使用，并输出所读入的进程数据

SPF(); //短进程优先调度算法

break;

default:

printf("\n 输入的算法编号错误!!\n");

return;

} //switch(iInput)

bGoOn= false;

strcpy(sGoOn," ");

cout<

cin>>sGoOn;

bGoOn=(sGoOn[0]=='y'||sGoOn[0]=='Y');

}//while bGoOn

} //if(ReadPCBFile()==1)

}//void main()

建几个txt文件在这个包下像这样的内容

PA 2 58 3

PB 1 543 1

PC 1 868 2

PD 2 879 3

PE 3 366 2

PF 1 50 3

PG 2 87 4

PH 3 12 3

PI 1 50 3

PJ 1 76 2