操作系统实验报告进程调度法的实现.docx

操作系统实验报告进程调度法的实现.docx

《操作系统实验报告进程调度法的实现.docx》由会员分享，可在线阅读，更多相关《操作系统实验报告进程调度法的实现.docx（18页珍藏版）》请在冰豆网上搜索。

操作系统实验报告进程调度法的实现

操作系统实验报告

进程调度算法的实现

1.实验目的

进程是操作系统最重要的概念之一，本实验通过对进程调度模拟程序的运行，学习运用时间片轮转法进行进程调度，加深对进程的基本调度状态以及进程调度算法的理解。

2.算法思想

进程调度算法：

采用多级反馈队列调度算法。

其基本思想是：

当一个新进程进入内在后，首先将它放入第一个队列的末尾，按FCFS原则排队等待高度。

当轮到该进程执行时，如能在该时间片内完成，便可准备撤离系统；如果它在一个时间片结束时尚为完成，调度程序便将该进程转入第二队列的末尾，再同样地按FCFS原则等待调度执行，以此类推。

4.算法

。

5.程序代码

程序的主要代码如下：

#include

#include

#include

#include

#include

constintMAXCOMMANDLEN=50;

/////////////////////////////////////////////////////////////////////////////////////

//

//PROCESS

//

/////////////////////////////////////////////////////////////////////////////////////

classProcess

{

friendclassCPU;//友元类

protected:

staticintinit_ID;//静态初始ID

intID;//进程ID

charrunText[MAXCOMMANDLEN];//进程指令数组

intIP;//进程指令指针，保存进程指令执行到的具体位置

boolISuseSource;//进程是否使用资源（是或者否）

boolISblocked;//进程是否被阻塞（是或者否）

intunitTime;//进程被cpu执行单位时间,默认1

intblockTime;//进程被阻塞时间

public:

staticvoidRandID（）;//静态随机生成进程ID的函数

Process（）;//进程类的构造函数

intgetID（）;//得到进程ID

intgetIP（）;//获取进程指令指针IP

voidsetIP（int）;//设置IP

voidRuned（）;//进程被执行

intgetUnittime（）;//得到进程的单位执行时间

intgetBlcoktime（）;//得到进程被阻塞的时间

voidsetBlocktime（int）;//设置进程被阻塞的时间

voidsetUnittime（int）;//设置进程的单位执行时间

chargetResult（int）;//得到进程被执行的结果

char*getRuntext（）;//得到进程执行的指令

voidsetBlockstate（bool）;//设置进程阻塞状态

boolgetBlockstate（）;//得到进程阻塞状态

boolgetISusesource（）;//得到资源的使用状态

voidsetISusesource（bool）;//设置资源的使用状态

};

intProcess:

:

init_ID;//初始化静态变量

voidProcess:

:

RandID（）//随机产生一个进程ID

{

srand（（unsigned）time（NULL））;//调用srand随机生成函数

init_ID=rand（）;

}

Process:

:

Process（）//进程的构造函数

{

ID=init_ID++;//进程ID的初值为静态初始ID的值

intcommandLen;//命令行长度

IP=0;

cout<<"PleaseinputthetextwhichprocessrunedbyCPU[#command#]:

>\\";

cin>>runText;//输入命令

if（（commandLen=strlen（runText））>MAXCOMMANDLEN）

exit（0）;//输入长度超出最大长度时退出，特殊情况处理

runText[commandLen]='#';//初始指令结束标志'#'

runText[commandLen+1]='\0';//字符串结束标志

ISuseSource=false;//设置资源的使用状态为未使用

ISblocked=false;//进程的初始状态-》未被阻塞

unitTime=1;//进程被执行的单位时间为1

blockTime=0;//阻塞时间为0

}

voidProcess:

:

Runed（）//进程被CPU执行

{

cout<

}

intProcess:

:

getID（）//得到进程ID

{

returnID;

}

intProcess:

:

getIP（）//得到进行IP

{

returnIP;

}

voidProcess:

:

setIP（intip）//设置进程IP

{

IP=ip;

}

boolProcess:

:

getISusesource（）//得到资源的使用状态

{

returnISuseSource;

}

voidProcess:

:

setISusesource（bools）//设置资源的使用状态

{

ISuseSource=s;

}

char*Process:

:

getRuntext（）//得到进程执行的指令

{

returnrunText;

}

intProcess:

:

getUnittime（）//得到进程的单位执行时间

{

returnunitTime;

}

intProcess:

:

getBlcoktime（）//得到进程阻塞状态

{

returnblockTime;

}

voidProcess:

:

setBlocktime（intBT）//设置进程阻塞时间

{

blockTime=BT;

}

voidProcess:

:

setUnittime（intUT）//设置进程的单位执行时间

{

unitTime=UT;

}

voidProcess:

:

setBlockstate（boolstate）//设置进程阻塞状态

{

ISblocked=state;

}

boolProcess:

:

getBlockstate（）//得到进程阻塞状态

{

returnISblocked;

}

charProcess:

:

getResult（intk）//得到程序的运行结果

{

returnrunText[k];

}

/////////////////////////////////////////////////////////////////////////////////////

//

//SOURCE

//

/////////////////////////////////////////////////////////////////////////////////////

classSource//资源类

{

protected:

intID;//资源ID

boolstate;//资源是否被占用状态

intpro_ID;//使用资源的进程id

Process*pro;//使用资源的进程指针

inttime;//进程使用资源的时间

public:

Source（int）;//资源类构造函数

boolgetState（）;//得到资源被使用状态

voidsetState（bool）;//设置资源被使用状态

voidsetTime（int）;//设置进程使用资源的时间

voidsetPro（Process*）;//设置使用该资源的进程

intgetID（）;//得到资源id

intgetPorID（）;//得到使用资源的进程id

voidsetProID（int）;//设置使用资源的进程id

voidrunned（）;//资源被cpu调用

};

Source:

:

Source（intid）//资源类构造函数

{

ID=id;//资源ID初值为id

pro=NULL;//指针赋为空值

state=true;//状态为被使用状态

}

voidSource:

:

setProID（intid）//设置使用资源的进程id

{

pro_ID=id;

}

voidSource:

:

setTime（intt）//设置进程使用资源的时间

{

time=t;

}

voidSource:

:

setState（bools）//设置资源使用状态

{

state=s;

}

boolSource:

:

getState（）//得到资源使用状态

{

returnstate;

}

voidSource:

:

setPro（Process*p）//设置使用该资源的进程

{

pro=p;

}

voidSource:

:

runned（）//资源被CPU调用

{

if（time>0）//时间充足继续运行输出资源信息并使时间减一

{

cout<<"（Source:

"<

time--;

}

if（time<=0）//时间用完

{

pro->setISusesource（false）;//资源的使用状态为未使用

intip=pro->getIP（）;//得到进程的IP

pro->setIP（++ip）;//设置到下一个ip

Source:

:

setState（true）;//设置资源的使用状态为正在使用

cout<getID（）<<"relasethesource!

"<

pro=NULL;//输出资源被释放指针值赋值为空值

}

}

/////////////////////////////////////////////////////////////////////////////////////

//

//CPU

//

/////////////////////////////////////////////////////////////////////////////////////

typedefstructBlock//阻塞队列结构

{

Process*p_BlockProcess;//被阻塞的进程队列

intindex;//被阻塞的进程在就绪队列中的位置

}Block;

classCPU

{

protected:

Process*p_Process;//进程队列

Process**pp_Process;//进程就绪队列

Block*blockQueue;//进程阻塞队列

Source*p_Source;//资源指针

intnumOfprocess;//进程数量

intnumOfblock;//被阻塞的进程数

intPC;//程序计数器

intallTime;//cpu运行的总时间

public:

CPU（int）;//cpu构造函数

voidRun（）;//cpu运行进程

bool_IC（Process&）;//虚拟IC,进行进程指令翻译

voiduseSource（Process&）;//进程申请资源

voidblockProcess（Process&）;//阻塞进程

voidreleaseBlockPro（）;//释放阻塞进程

intgetAlltime（）;//得到进程运行的总时间

voiddisplayPro（）;//显示进程的基本信息,id,指令,运行时间等

voidblockTimeADD（）;//阻塞时间加1

};

CPU:

:

CPU（intnum）

{

p_Source=newSource（379857）;//创建一个id号为379857的资源

numOfprocess=num;//进程数

numOfblock=0;//阻塞数

allTime=0;//cpu运行的总时间初始化为0

p_Process=newProcess[numOfprocess];//进程队列申请空间

pp_Process=newProcess*[numOfprocess];//进程就绪队列申请空间

blockQueue=newBlock[numOfprocess];//阻塞队列申请空间

for（inti=0;i

{

pp_Process[i]=&p_Process[i];//用二维数组存放进程指针数组头指针

blockQueue->p_BlockProcess=NULL;//阻塞队列的阻塞进程赋值为空

blockQueue->index=-1;//阻塞队列的索引值置为1

}

}

intCPU:

:

getAlltime（）//得到进程运行的总时间

{

returnallTime;

}

voidCPU:

:

displayPro（）//显示进程的基本信息

{

for（inti=0;i

{

cout<<"\tProcessID:

"<

cout<<"textofrunned:

"<

}

}

voidCPU:

:

Run（）//cpu运行进程

{

intnumPro=numOfprocess;//记录未被运行的进程个数

do

{

for（intnum=0;num

{

if（!

pp_Process[num]）//就绪队列不空继续执行

continue;

for（intt=0;t

{

PC=p_Process[num].getIP（）;//得到进程Ip

if（_IC（p_Process[num]））//判断进程的状态TURE进入

{

if（t==0）//时间为0运行完输出进程信息

cout<<"theprocess["<

";

if（!

p_Process[num].getISusesource（））//如果该进程未被运行过，则调用run运行

{

p_Process[num].Runed（）;//

}

else

{

p_Source->runned（）;//

if（p_Source->getState（）&&numOfblock>0）

{

releaseBlockPro（）;////如果进程运行过，现在但未运行，说明为阻塞。

释放阻塞进程，调用它

}

}

}

else

{

if（!

p_Process[num].getBlockstate（））//该进程不在阻塞状态

{

numPro--;//未被运行的进程个数减一

pp_Process[num]=NULL;//进程就绪队列该位置赋为空值

continue;

}

break;//跳出循环

}

allTime++;//运行总时间++

if（numOfblock>0）//如果阻塞个数>0

blockTimeADD（）;//阻塞时间加1

}//endfort...

if（p_Process[num].getUnittime（））//该进程的执行单位时间非0

p_Process[num].setUnittime

（1）;//设置该进程执行的单位时间为1

cout<

}//endfornum...

}while（numPro）;

}

boolCPU:

:

_IC（Process&p）//对进程中的指令进行翻译

{

charresultRunned;

resultRunned=p.getResult（PC）;

if（resultRunned=='#'）//#则是命令行结束

returnfalse;

else

{

if（resultRunned=='$'）//申请资源指令

{

PC++;

p.setIP（PC）;

resultRunned=p.getResult（PC）;

if（resultRunned>='1'&&resultRunned<='9'）//资源号1-9，在这区间就进入

{

if（p_Source->getState（）//资源未被使用则使用资源

{

useSource（p）;

cout<<"Theprocess"<

"<

}

else//资源已被使用则阻塞进程

{

blockProcess（p）;

cout<<"Theprocess"<

"<

returnfalse;

}

}

else//'$'后跟的不是数字，则语法错误

{

cout<<"Theprocess["<

Ithasbeenstopped!

"<

returnfalse;

}

}

}

returntrue;

}

voidCPU:

:

blockTimeADD（）//阻塞时间加1

{

for（inti=0;i

{

intBT=blockQueue[i].p_BlockProcess->getBlcoktime（）;//循环得到阻塞队列中每个进程的阻塞时间

blockQueue[i].p_BlockProcess->setBlocktime（++BT）;//每个时间+1

}

}

voidCPU:

:

useSource（Process&p）//进程申请资源

{

p.setISusesource（true）;//运行的资源的状态设置

p_Source->setState（false）;//资源状态设置为不可用

p_Source->setProID（p.getID（））;//设置进程ID

p_Source->setTime（p.getResult（PC）-'0'）;//设置资源使用时间

p_Source->setPro（&p）;//设置使用资源的进程

}

voidCPU:

:

blockProcess（Process&p）//阻塞进程

{

inttempIndex=numOfprocess-（Process:

:

init_ID-p.getID（））;//阻塞进程的设置

blockQueue[numOfblock].p_BlockProcess=&p;//将进程p加入到阻塞队列尾部

blockQueue[numOfblock].index=tempIndex;//设置新加进程阻塞队列所在位置的索引值

numOfblock++;//阻塞进程个数+1

intip=p.getIP（）;

p.setIP（--ip）;//设置进程的ip

p.setBlockstate（true）;//设置进程的组设状态为真

p.setBlocktime

（1）;//设置进程的块阻塞时间为1

p.setUnittime（0）;//设置进程的单位执行时间为0

pp_Process[tempIndex]=NULL;//进程就绪队列tempIndex处赋为空值

}

voidCPU:

:

releaseBlockPro（）//释放阻塞队列的第一个进程，阻塞时间最长

{

pp_Process[blockQueue[0].index]=blockQueue[0].p_BlockProcess;//将阻塞进程的第一个进程赋值给就续队列的相应位置

blockQueue[0].index=-1;//将阻塞队列的起始位置的索引值置为-1

blockQueue[0].p_BlockProcess->setBlockstate（false）;//将阻塞队列的起始位置的进程阻塞状态设置为未阻塞（false）

blockQueue[0].p_BlockProcess->setUnittime（blockQueue[0].p_BlockProcess->getBlcoktime（））;//得到阻塞队列首位置的进程的阻塞时间

blockQueue[0].p_BlockProcess->setBlockstate（0）;//

blockQueue[0].p_BlockProcess=NULL;//阻塞队列的0位置指针赋值为空

numOfblock--;//阻塞进程个数减一

for（inti=0;i

{

blockQueue[i]=blockQueue[i+1];

}

}

/////////////////////////////////////////////////////////////////////////////////////

//

//Themainprogress

//

//////////////////////