操作系统实验报告进程调度法的实现Word格式.docx
《操作系统实验报告进程调度法的实现Word格式.docx》由会员分享,可在线阅读,更多相关《操作系统实验报告进程调度法的实现Word格式.docx(18页珍藏版)》请在冰豆网上搜索。
![操作系统实验报告进程调度法的实现Word格式.docx](https://file1.bdocx.com/fileroot1/2023-1/10/194a3af3-0732-48af-b539-d3757c2fbf37/194a3af3-0732-48af-b539-d3757c2fbf371.gif)
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
Runed()//进程被CPU执行
getResult(IP++);
//输出得到的进程执行结果
getID()//得到进程ID
returnID;
getIP()//得到进行IP
returnIP;
setIP(intip)//设置进程IP
IP=ip;
boolProcess:
getISusesource()//得到资源的使用状态
returnISuseSource;
setISusesource(bools)//设置资源的使用状态
ISuseSource=s;
char*Process:
getRuntext()//得到进程执行的指令
returnrunText;
getUnittime()//得到进程的单位执行时间
returnunitTime;
getBlcoktime()//得到进程阻塞状态
returnblockTime;
setBlocktime(intBT)//设置进程阻塞时间
blockTime=BT;
setUnittime(intUT)//设置进程的单位执行时间
unitTime=UT;
setBlockstate(boolstate)//设置进程阻塞状态
ISblocked=state;
getBlockstate()//得到进程阻塞状态
returnISblocked;
charProcess:
getResult(intk)//得到程序的运行结果
returnrunText[k];
//SOURCE
classSource//资源类
//资源ID
boolstate;
//资源是否被占用状态
intpro_ID;
//使用资源的进程id
Process*pro;
//使用资源的进程指针
inttime;
//进程使用资源的时间
Source(int);
//资源类构造函数
boolgetState();
//得到资源被使用状态
voidsetState(bool);
//设置资源被使用状态
voidsetTime(int);
//设置进程使用资源的时间
voidsetPro(Process*);
//设置使用该资源的进程
//得到资源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;
setTime(intt)//设置进程使用资源的时间
time=t;
setState(bools)//设置资源使用状态
state=s;
boolSource:
getState()//得到资源使用状态
returnstate;
setPro(Process*p)//设置使用该资源的进程
pro=p;
runned()//资源被CPU调用
if(time>
0)//时间充足继续运行输出资源信息并使时间减一
{
cout<
(Source:
ID<
)"
time--;
}
if(time<
=0)//时间用完
pro->
setISusesource(false);
//资源的使用状态为未使用
intip=pro->
getIP();
//得到进程的IP
setIP(++ip);
//设置到下一个ip
Source:
setState(true);
//设置资源的使用状态为正在使用
endl<
Theprocess"
pro->
getID()<
relasethesource!
endl;
pro=NULL;
//输出资源被释放指针值赋值为空值
//CPU
typedefstructBlock//阻塞队列结构
Process*p_BlockProcess;
//被阻塞的进程队列
intindex;
//被阻塞的进程在就绪队列中的位置
}Block;
classCPU
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<
numOfprocess;
i++)
pp_Process[i]=&
p_Process[i];
//用二维数组存放进程指针数组头指针
blockQueue->
p_BlockProcess=NULL;
//阻塞队列的阻塞进程赋值为空
index=-1;
//阻塞队列的索引值置为1
intCPU:
getAlltime()//得到进程运行的总时间
returnallTime;
voidCPU:
displayPro()//显示进程的基本信息
for(inti=0;
i++)//循环输出被执行的进程的信息
\tProcessID:
"
p_Process[i].getID()<
textofrunned:
p_Process[i].getRuntext()<
Run()//cpu运行进程
intnumPro=numOfprocess;
//记录未被运行的进程个数
do
for(intnum=0;
num<
numOfprocess;
num++)
{
if(!
pp_Process[num])//就绪队列不空继续执行
continue;
for(intt=0;
t<
p_Process[num].getUnittime();
t++)
{
PC=p_Process[num].getIP();
//得到进程Ip
if(_IC(p_Process[num]))//判断进程的状态TURE进入
{
if(t==0)//时间为0运行完输出进程信息
cout<
theprocess["
p_Process[num].getID()<
]runed:
if(!
p_Process[num].getISusesource())//如果该进程未被运行过,则调用run运行
{
p_Process[num].Runed();
}
else
p_Source->
runned();
//
if(p_Source->
getState()&
&
numOfblock>
0)
{
releaseBlockPro();
////如果进程运行过,现在但未运行,说明为阻塞。
释放阻塞进程,调用它
}
}
else
p_Process[num].getBlockstate())//该进程不在阻塞状态
numPro--;
//未被运行的进程个数减一
pp_Process[num]=NULL;
//进程就绪队列该位置赋为空值
continue;
break;
//跳出循环
allTime++;
//运行总时间++
if(numOfblock>
0)//如果阻塞个数>
blockTimeADD();
}//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<
p.getID()<
takeupthesource!
else//资源已被使用则阻塞进程
blockProcess(p);
isblocked!
returnfalse;
}
else//'
后跟的不是数字,则语法错误
cout<
Theprocess["
]runnedfail!
Ithasbeenstopped!
returnfalse;
}
returntrue;
blockTimeADD()//阻塞时间加1
numOfblock;
i++)
intBT=blockQueue[i].p_BlockProcess->
getBlcoktime();
//循环得到阻塞队列中每个进程的阻塞时间
blockQueue[i].p_BlockProcess->
setBlocktime(++BT);
//每个时间+1
useSource(Process&
p)//进程申请资源
p.setISusesource(true);
//运行的资源的状态设置
p_Source->
setState(false);
//资源状态设置为不可用
setProID(p.getID());
//设置进程ID
setTime(p.getResult(PC)-'
0'
//设置资源使用时间
setPro(&
p);
//设置使用资源的进程
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处赋为空值
releaseBlockPro()//释放阻塞队列的第一个进程,阻塞时间最长
pp_Process[blockQueue[0].index]=blockQueue[0].p_BlockProcess;
//将阻塞进程的第一个进程赋值给就续队列的相应位置
blockQueue[0].index=-1;
//将阻塞队列的起始位置的索引值置为-1
blockQueue[0].p_BlockProcess->
setBlockstate(false);
//将阻塞队列的起始位置的进程阻塞状态设置为未阻塞(false)
setUnittime(blockQueue[0].p_BlockProcess->
getBlcoktime());
//得到阻塞队列首位置的进程的阻塞时间
setBlockstate(0);
blockQueue[0].p_BlockProcess=NULL;
//阻塞队列的0位置指针赋值为空
numOfblock--;
//阻塞进程个数减一
i++)//阻塞队列中的其他进程向前移动一个位置
blockQueue[i]=blockQueue[i+1];
//Themainprogress
//////////////////////