进程调度模拟程序
2016-02-19 21:35
最近很多朋友喜欢上设计，但是大家却不知道如何去做,别担心有图老师给你解答，史上最全最棒的详细解说让你一看就懂。
#includeiostream.h
#includestdlib.h
#includetime.h
#includestdio.h
#includestring.hconst int MAXCOMMANDLEN =50; /////////////////////////////////////////////////////////////////////////////////////
//
// PROCESS
//
/////////////////////////////////////////////////////////////////////////////////////
class Process //进程类
{
friend class CPU;
protected:
static int init_ID; //随机进程ID
int ID; //进程ID
char runText[MAXCOMMANDLEN]; //进程指令数组
int IP; //进程指令指针，保存进程指令执行到的具体位置
bool ISuseSource; //此进程是否使用资源，ture:使用中 false : 未使用
bool ISblocked; //此进程是否被阻塞 ture:阻塞 false :未阻塞
int unitTime; //进程单位被cpu执行时间, 默认 1
int blockTime; //进程被阻塞时间
public:
static void RandID(); //随机生成进程ID
Process();
int getID();
int getIP();
void setIP(int);
void Runed(); //进程被cpu执行
int getUnittime(); //得到进程单位执行时间
int getBlcoktime(); //得到进程阻塞时间
void setBlocktime(int); //设置进程阻塞时间
void setUnittime(int); //设置进程单位执行时间
char getResult(int); //得到进程执行结果
char* getRuntext(); //得到进程执行的指令
void setBlockstate(bool); //设置阻塞状态
bool getBlockstate();
bool getISusesource(); //得到资源的状态 使用 未使用
void setISusesource(bool); //设置资源的使用状态
};int Process::init_ID;void Process::RandID()
{
srand( (unsigned)time( NULL ) );
init_ID=rand();
}
Process::Process()
{
ID=init_ID++;
int commandLen;
IP=0; cout"Please input the text which process runed by CPU [#command#] : ";
cinrunText;
if( (commandLen=strlen(runText) ) MAXCOMMANDLEN )
exit(0);
runText[commandLen]='#'; // 指令结束标志 '#'
runText[commandLen+1]='';
ISuseSource=false;
ISblocked=false;
unitTime=1;
blockTime=0;
}
void Process::Runed()
int Process::getID()
{
return ID;
}int Process::getIP()
{
return IP;
}void Process::setIP(int ip)
bool Process::getISusesource()
{
return ISuseSource;
}void Process::setISusesource(bool s)
char* Process::getRuntext()
{
return runText;
}int Process::getUnittime()
{
return unitTime;
}
int Process::getBlcoktime()
{
return blockTime;
}void Process::setBlocktime(int BT)
void Process::setUnittime(int UT)
void Process::setBlockstate(bool state)
bool Process::getBlockstate()
{
return ISblocked;
}char Process::getResult(int k)
{
return runText[k];
}/////////////////////////////////////////////////////////////////////////////////////
//
// SOURCE
//
/////////////////////////////////////////////////////////////////////////////////////class Source //资源类
{
protected:
int ID; //资源 ID
bool state; //资源状态 true : 未被进程占有 false : 已被占有
int pro_ID; //使用资源的进程id
Process *pro; //使用资源的进程指针
int time; //进程使用资源的时间
public:
Source(int);
bool getState(); //得到进程状态
void setState(bool); //设置进程状态
void setTime(int); //设置进程使用资源的时间
void setPro(Process *); //设置使用该资源的进程
int getID(); //得到资源id
int getPorID(); //得到使用资源的进程id
void setProID(int); //设置使用资源的进程id
void runned(); //资源被cpu调用
};Source::Source(int id)
void Source::setProID(int id)
void Source::setTime(int t)
void Source::setState(bool s)
bool Source::getState()
{
return state;
}void Source::setPro(Process *p)
void Source::runned()
{
if(time0)
{
cout"( Source :"ID")";
time--;
}
if(time=0) //进程使用完资源释放资源，使用资源的时间到
{
pro-setISusesource(false);
int ip=pro-getIP();
pro-setIP(++ip);
Source::setState(true);
coutendl"The process "pro-getID()" relase the source!"endl;
pro=NULL;
}
}/////////////////////////////////////////////////////////////////////////////////////
//
// CPU
//
/////////////////////////////////////////////////////////////////////////////////////typedef strUCt Block //阻塞队列结构
{
Process *p_BlockProcess; //被阻塞的进程队列
int index; //被阻塞的进程在就绪队列中的索引（位置）
}Block;class CPU
{
protected:
Process *p_Process; //进程队列
Process **pp_Process; //进程就绪队列
Block *blockQueue ; //进程阻塞队列
Source *p_Source; //资源指针
int numOfprocess; //进程数量
int numOfblock; //被阻塞的进程数
int PC; //程序计数器
int allTime; //cpu运行的总时间
public :
CPU(int);
void Run(); //cpu运行进程
bool _IC(Process&); //虚拟IC,进行进程指令翻译
void useSource(Process&); //进程申请资源
void blockProcess(Process&); //阻塞进程
void releaseBlockPro(); //释放阻塞进程
int getAlltime(); //得到进程运行的总时间
void displayPro(); //显示进程的基本信息，id,指令,运行时间等
void blockTimeADD(); //阻塞时间加1
};CPU::CPU(int num)
{
p_Source=new Source(379857);
numOfprocess=num;
numOfblock=0;
allTime=0;
p_Process=new Process[numOfprocess];
pp_Process=new Process*[numOfprocess];
blockQueue=new Block[numOfprocess];
for(int i=0;inumOfprocess;i++)
}int CPU::getAlltime()
{
return allTime;
}void CPU::displayPro()
{
for(int i=0;inumOfprocess;i++)
{
cout" Process ID : "p_Process[i].getID()endl;
cout" text of runned :"p_Process[i].getRuntext()endl;
}
}void CPU::Run()
{
int numPro=numOfprocess; do
{
for(int num=0;num numOfprocess;num++)
{
if(!pp_Process[num]) //假如该指针为空，说明该进程不在就绪队列中
continue; for(int t=0;tp_Process[num].getUnittime();t++)
{
PC=p_Process[num].getIP();
if(_IC(p_Process[num]))
{
if(t==0)
cout"the process ["p_Process[num].getID()"] runed : ";
if(!p_Process[num].getISusesource())
else
{
p_Source-runned();
if( p_Source-getState() && numOfblock0 ) //释放阻塞进程
}
}
else
{
if(!p_Process[num].getBlockstate())
{
numPro--;
pp_Process[num]=NULL;
continue;
}
break;
}
allTime++;
if(numOfblock0)
blockTimeADD();
}//end for t...
if( p_Process[num].getUnittime() )
p_Process[num].setUnittime(1);
coutendl;
}//end for num... }while(numPro);
}bool CPU::_IC(Process &p)
{
//对进程中的指令进行翻译
char resultRunned;
resultRunned=p.getResult(PC);
if(resultRunned=='#')
return false;
else
{
if(resultRunned==' ) //申请资源指令
{
PC++;
p.setIP(PC);
resultRunned=p.getResult(PC);
if( resultRunned ='1' && resultRunned ='9' )
{
if(p_Source-getState())
{
//资源未被使用则使用资源
useSource(p);
cout"The process "p.getID()" take up the source!"endl;
}
else
{
//资源已被使用则阻塞进程
blockProcess(p);
cout"The process "p.getID()" is blocked !"endl;
return false; }
}
else
{
//' 后跟的不是数字，则语法错误
cout"The process ["p.getID()"] runned fail ! It has been stopped! "endl;
return false;
}
} }
return true;
}void CPU::blockTimeADD()
{
for(int i=0;inumOfblock;i++)
{
int BT=blockQueue[i].p_BlockProcess-getBlcoktime();
blockQueue[i].p_BlockProcess-setBlocktime(++BT);
}
}void CPU::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);}void CPU::blockProcess(Process& p)
{
int tempIndex=numOfprocess-( Process::init_ID-p.getID() );
blockQueue[numOfblock].p_BlockProcess=&p;
blockQueue[numOfblock].index=tempIndex;
numOfblock++;
int ip=p.getIP();
p.setIP(--ip);
p.setBlockstate(true);
p.setBlocktime(1);
p.setUnittime(0);
pp_Process[tempIndex]=NULL;}void CPU::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(int i=0;inumOfblock;i++)
}
/////////////////////////////////////////////////////////////////////////////////////
//
// The main progress
//
/////////////////////////////////////////////////////////////////////////////////////
void main()
{
int num;
cout" ********************************************************"endl
endl;
cout" The virtual CPU the process runned "endl
endl;
cout" *******************************************************"endl
endl;
cout"initialize the information of processes "endl; cout"Please input the number of process [#command#] "; try
catch(int)
{
cout"You input the numbers of process is error !"endl;
exit(1);
} Process::RandID(); // 随机生成第一个进程的ID,以后生成的进程ID顺序加1
CPU virtualCPU(num);
cout"Pocesses runed by CPU "endl;
virtualCPU.Run();
cout"Processes runned over ! "endl;
cout" ********************************************************"endl
endl;
cout" The time which processes runned by CPU : "virtualCPU.getAlltime()endl
endl;
virtualCPU.displayPro();
cout" *******************************************************"endl
endl;
}这里没有任何的API调用 只是模拟，我给进程设定了自己的语法，输入一般的字符cpu调用时只是正常输出，假如碰到' 表示该进程要调用系统资源后面必须跟一个数字表示占有的时间，假如资源闲置则占有资源否则阻塞，等资源释放在占有资源。进程的调用算法我采用的是时间片轮转算法并有所改进，当某个进程从阻塞队列释放后，他将把以前因为等待资源而被浪费的时间补回来。
希望大家多提意见
