我們課程設計，我選擇了一個進程調度模擬，希望大家給看看，多提意見，好久沒來發帖子了。
#include<iostream.h>
#include<stdlib.h>
#include<time.h>
#include<stdio.h>
#include<string.h> const 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 in put the text which process runed by CPU [#command#] :> ";
cin>>runText;
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(time>0)
{
cout<<"( Source :"<<ID<<")";
time--;
}
if(time<=0) //進程使用完資源釋放資源，使用資源的時間到
{
pro->setISusesource(false);
int ip=pro->getIP();
pro->setIP(++ip);
Source::setState(true);
cout<<endl<<"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;i<numOfprocess;i++)
} int CPU::getAlltime()
{
return allTime;
} void CPU::displayPro()
{
for(int i=0;i<numOfprocess;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;t<p_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() && numOfblock>0 ) //釋放阻塞進程
}
}
else
{
if(!p_Process[num].getBlockstate())
{
numPro--;
pp_Process[num]=NULL;
continue;
}
break;
}
allTime++;
if(numOfblock>0)
blockTimeADD();
}//end for t...
if( p_Process[num].getUnittime() )
p_Process[num].setUnittime(1);
cout<<endl;
}//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;i<numOfblock;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;i<numOfblock;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 in put the number of process [#command#] > "; try
catch(int)
{
cout<<"You in put 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調用時只是正常輸出，假如碰到' 表示該進程要調用系統資源後面必須跟一個數字表示占有的時間，假如資源閒置則占有資源否則阻塞，等資源釋放在占有資源。進程的調用算法我采用的是時間片輪轉算法並有所改進，當某個進程從阻塞隊列釋放後，他將把以前因為等待資源而被浪費的時間補回來。
