收藏
下载资源下载资源 加入VIP,免费下载

操作系统上机报告.docx

上传人：b****9 文档编号：25203833 上传时间：2023-06-06 格式：DOCX 页数：17 大小：17.74KB
下载 相关 举报
操作系统上机报告.docx_第1页
第1页 / 共17页
操作系统上机报告.docx_第2页
第2页 / 共17页
操作系统上机报告.docx_第3页
第3页 / 共17页
操作系统上机报告.docx_第4页
第4页 / 共17页
操作系统上机报告.docx_第5页
第5页 / 共17页
点击查看更多>>
下载资源
资源描述

操作系统上机报告.docx

《操作系统上机报告.docx》由会员分享，可在线阅读，更多相关《操作系统上机报告.docx（17页珍藏版）》请在冰豆网上搜索。

操作系统上机报告.docx

操作系统上机报告

 

操作系统上机报告

——C++编写模拟进程调度程序

 

源程序如下：

#include

#include

#include

#include

#include

constintMAXCOMMANDLEN=50;

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

//PROCESS

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

classProcess//进程类

{

friendclassCPU;

protected:

staticintinit_ID;//随机进程ID

intID;//进程ID

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

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

boolISuseSource;//此进程是否使用资源，ture:

使用中,false:

未使用

boolISblocked;//此进程是否被阻塞ture:

阻塞false:

未阻塞

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

intblockTime;//进程被阻塞时间

public:

staticvoidRandID（）;//随机生成进程ID

Process（）;

intgetID（）;

intgetIP（）;

voidsetIP（int）;

voidRuned（）;//进程被cpu执行

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

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

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

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

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

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

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

boolgetBlockstate（）;

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

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

};

intProcess:

:

init_ID;//随机进程ID

voidProcess:

:

RandID（）//随机生成进程ID

{

srand（（unsigned）time（NULL））;

init_ID=rand（）;

}

Process:

:

Process（）

{

ID=init_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;

blockTime=0;

}

voidProcess:

:

Runed（）//进程被cpu执行

{

cout<

}

intProcess:

:

getID（）

{

returnID;

}

intProcess:

:

getIP（）

{

returnIP;

}

voidProcess:

:

setIP（intip）

{

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;//资源状态true:

未被进程占有false:

已被占有

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;

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（）;

pro->setIP（++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）;

voidRun（）;//cpu运行进程

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

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

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

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

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

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

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

};

CPU:

:

CPU（intnum）

{

p_Source=newSource（379857）;

numOfprocess=num;

numOfblock=0;

allTime=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;

}

}

intCPU:

:

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

{

returnallTime;

}

voidCPU:

:

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

{

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（）;

if（_IC（p_Process[num]））

{

if（t==0）

cout<<"theprocess["<

";

if（!

p_Process[num].getISusesource（））

{

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）

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

}//endfort...

if（p_Process[num].getUnittime（））

p_Process[num].setUnittime

（1）;

cout<

}//endfornum...

}while（numPro）;

}

boolCPU:

:

_IC（Process&p）//虚拟IC，进行进程指令翻译

{

//对进程中的指令进行翻译

charresultRunned;

resultRunned=p.getResult（PC）;

if（resultRunned=='#'）

returnfalse;

else

{

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

{

PC++;

p.setIP（PC）;

resultRunned=p.getResult（PC）;

if（resultRunned>='1'&&resultRunned<='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）;

}

}

voidCPU:

:

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

{

p.setISusesource（true）;

p_Source->setState（false）;

p_Source->setProID（p.getID（））;

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;

blockQueue[numOfblock].index=tempIndex;

numOfblock++;

intip=p.getIP（）;

p.setIP（--ip）;

p.setBlockstate（true）;

p.setBlocktime

（1）;

p.setUnittime（0）;

pp_Process[tempIndex]=NULL;

}

voidCPU:

:

releaseBlockPro（）//释放阻塞进程

{

//释放阻塞队列的第一个进程，因为它阻塞时间最长

pp_Process[blockQueue[0].index]=blockQueue[0].p_BlockProcess;

blockQueue[0].index=-1;

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

blockQueue[0].p_BlockProcess->setUnittime（blockQueue[0].p_BlockProcess->getBlcoktime（））;

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

blockQueue[0].p_BlockProcess=NULL;

numOfblock--;

for（inti=0;i

{

blockQueue[i]=blockQueue[i+1];//阻塞队列中的其他进程向前移动一个位置

}

}

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

//Themainprogress

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

voidmain（）

{

intnum;

cout<<"\t********************************************************"<

cout<<"\tThevirtualCPUtheprocessrunned"<

cout<<"\t*******************************************************"<

cout<<"initializetheinformationofprocesses"<

cout<<"Pleaseinputthenumberofprocess[#command#]>\\";

try//定义异常

{

cin>>num;

if（num<=0）

throw（num）;//当num<=0时抛出异常

}

catch（int）//捕获异常，并定义捕获后对异常的处理

{

cout<<"Youinputthenumbersofprocessiserror!

"<

exit

（1）;//异常退出程序

}

Process:

:

RandID（）;//随机生成第一个进程的ID,以后生成的进程ID顺序加1

CPUvirtualCPU（num）;//定义一个CPU类的实体

cout<<"PocessesrunedbyCPU"<

virtualCPU.Run（）;//cpu运行进程

cout<<"Processesrunnedover!

"<

cout<<"\t********************************************************"<

cout<<"\tThetimewhichprocessesrunnedbyCPU:

"<

virtualCPU.displayPro（）;//显示进程的基本信息，id，指令，运行时间等

cout<<"\t*******************************************************"<

}

展开阅读全文
相关资源
猜你喜欢
相关搜索

当前位置：首页 > 外语学习 > 英语考试

copyright@ 2008-2022 冰豆网网站版权所有

经营许可证编号:鄂ICP备2022015515号-1