進程調度類比程式

進程調度類比程式

 我們課程設計，我選擇了一個進程調度類比，希望大家給看看，多提意見，好久沒來發文章了。

　　#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調用時只是正常輸出，假如碰到' 表示該進程要調用系統資源後面必須跟一個數字表示佔有的時間，假如資源閑置則佔有資源否則阻塞，等資源釋放在佔有資源。進程的調用演算法我採用的是時間片輪轉演算法並有所改進，當某個進程從阻塞隊列釋放後，他將把以前因為等待資源而被浪費的時間補回來。