进程代码1.docx

进程代码1.docx

《进程代码1.docx》由会员分享，可在线阅读，更多相关《进程代码1.docx（10页珍藏版）》请在冰豆网上搜索。

进程代码1

#include

#include

#include

#include

#include

constint MAXCOMMANDLEN=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;

voidProcess:

:

RandID（）

{

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

{

 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）

{

 pro_ID=id;

}

voidSource:

:

setTime（intt）

{

 time=t;

}

voidSource:

:

setState（bools）

{

 state=s;

}

boolSource:

:

getState（）

{

 returnstate;

}

voidSource:

:

setPro（Process*p）

{

 pro=p;

}

voidSource:

:

runned（）

{

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

{

 for（inti=0;i

 {

  cout<<"\tProcessID:

"<

  cout<<"   textofrunned:

"<

 }

}

voidCPU:

:

Run（）

{

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

   }//endfort...

   if（p_Process[num].getUnittime（））

    p_Process[num].setUnittime

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

   {

    if（p_Source->getState（））

    {

     //资源未被使用则使用资源

     useSource（p）;

     cout<<"Theprocess"<

"<

    }

    else

    {

     //资源已被使用则阻塞进程

     blockProcess（p）;

     cout<<"Theprocess"<

"<

     returnfalse;

    }

   }

   else

   {

    //'$'后跟的不是数字，则语法错误

    cout<<"Theprocess["<

Ithasbeenstopped!

"<

    returnfalse;

   }

  }

 }

  returntrue;

}

voidCPU:

:

blockTimeADD（）

{

 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<<"\t            ThevirtualCPU   theprocessrunned          "<

  <

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

  <

 cout<<"initializetheinformationofprocesses"<

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

 try

 {

 cin>>num;

 if（num<=0）

  throw（num）;

 }

 catch（int）

 {

  cout<<"Youinputthenumbersofprocessiserror!

"<

  exit

（1）;

 }

 Process:

:

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

 CPUvirtualCPU（num）;        

 cout<<"PocessesrunedbyCPU"<

 virtualCPU.Run（）; 

 cout<<"Processesrunnedover!

"<

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

  <

 cout<<"\tThetimewhichprocessesrunnedbyCPU:

"<

  <

 virtualCPU.displayPro（）;

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

  <

}