scheme.cpp

用VC开发的操作系统的进程模拟实验

// Scheme.cpp: implementation of the CScheme class.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "Scheme.h"
#include "stdio.h"
#include "iostream.h"
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

CScheme::CScheme()
{
for(int i=1;i<=3;i++)
{
	m_Queue[i].m_ProcessNum=0; //建立邻接表的时候每队列为空
	m_Queue[i].m_QueueName=i;
	m_Queue[i].next=NULL;
}
for(int j=0;j<=200;j++)
  m_AllProcessID[j]=false;    //开始的时候所有的进程ID都没有被使用
}

CScheme::~CScheme()
{

}

bool CScheme::InsertProcess(int queue ,CProcess *newprocess)
{
 //在队列scheme中插入进程newprocess
	if(newprocess==NULL)
		return false;//插入失败
	CProcess *currptr,*ttt;
	//currptr=m_Queue[queue].next;
	if(m_Queue[queue].m_ProcessNum==0)
	{   //队列为空，把新进来的进程插入到链头中
		m_Queue[queue].next=newprocess;
		//队列中进程计算器增加一
		m_Queue[queue].m_ProcessNum++;
	
		return true;  //插入成功
	}
	else
	{   
		ttt=currptr=m_Queue[queue].next;
		  //先跟头节点比较
		  //如果比头节点优先级还高，作为头节点
		  if(newprocess->m_PRI>currptr->m_PRI)
			{
			m_Queue[queue].next=newprocess;
			newprocess->next=ttt;
			m_Queue[queue].m_ProcessNum++;
		    return true;
			}
		  else
		  { 
		   currptr=currptr->next;
		   for(int i=1;i<m_Queue[queue].m_ProcessNum;i++)//扫描队列 ，根据优先级把进程插入到队列中
			 //当前进程优先级比要插入的进程的优先级要高
			 if(newprocess->m_PRI<=currptr->m_PRI)
			 //指针往后走，检查下一个进程
			 {   ttt=ttt->next;
				 currptr=currptr->next;
			 }
			 else
				 //	找到要插入的位置,把新的进程插入到当前位置
			 {
			     break;
			 }//end else
            //end for//结束扫描
		   //插入动作ttt 与currptrz之间插入
			ttt->next=newprocess;
			newprocess->next=currptr;
			 
            //队列中进程计算器增加一
		    m_Queue[queue].m_ProcessNum++;
		    return true;
		}
	}
}

bool CScheme::DeleteProcess(int queue)
{
 //在queue队列中删除一个进程
	if(m_Queue[queue].m_QueueName==0)//是空链
		return true;
	else
	{   //把队列中优先级最高的进程删除
		m_Queue[queue].next=m_Queue[queue].next->next;
		//队列中进程计数器减1；
		m_Queue[queue].m_ProcessNum--;
        return true;
	}
}

CProcess * CScheme::AttemperOutProcess(int flag)
{
   ///调出进程
  CProcess *outprocess;
  if(m_Queue[flag].m_ProcessNum==0)
	  return NULL;
  else
  {   
	  //得到要调出的进程
	  outprocess=m_Queue[flag].next;
	  //把该进程在队列中删除
      DeleteProcess(flag);
	  //返回要调出的进程
	  return outprocess;
  }
}

void CScheme::Refresh()
{
   //更新队列中的消息
	CProcess *mediaprocess,*p;
	//对运行队列更新
 
	if(m_Queue[1].m_ProcessNum==0)
	{
     //没有进程正在运行
		//就在就绪队列中调出进程
		mediaprocess=AttemperOutProcess(2);
       if(mediaprocess==NULL)//调出失败//由于就绪队列也为空造成
       {
		   //就绪队列为空，说明cup处于空闲状态
		   //不用考虑等待队列
		   ;
	   }
	   else
		   //把调出来的进程调入运行队列
          InsertProcess(1,mediaprocess);
	}  //进行队列更新完毕

	//对就绪队列进行刷新
	if(m_Queue[2].m_ProcessNum<=10)//就绪队列不能够多于10
	{
		//从就绪队列中调出进程
		mediaprocess=AttemperOutProcess(3);
		//将调出进程插入到就绪队列
		if(!mediaprocess)
        InsertProcess(2,mediaprocess);
	}
	else
	{   mediaprocess=m_Queue[2].next;
	    p=mediaprocess->next;
		 m_Queue[2].m_ProcessNum=10;
		//就绪队列中进程太多 将多余进程调入等待队列
		//while(mediaprocess->next!=NULL)
		while(p->next!=NULL)
		{p=p->next;
		  mediaprocess=mediaprocess->next;
		  
		}
		mediaprocess->next=NULL;
        InsertProcess(3,p);
	}
	//对就绪队列更新

}


bool CScheme::CreateProcess()
{
CProcess *newproce;
//创建一个新进程
   newproce=new CProcess;
  srand( (unsigned)time( NULL ) ); //随机种子
  newproce->m_PRI=1+rand()%200;   //随机产生进程优先级
 
  newproce->m_time=1+rand()%4000; //系统进程最大不的生命周期

  int i=0;
  for(i=1;i<200;i++)
     if(!m_AllProcessID[i])
		 break;
	  //进程创建失败

  newproce->m_processID=i;
  m_AllProcessID[i]=true;             //该标识号被启用
//把新的进程插入到就绪队列中
   InsertProcess(2,newproce);

//更新邻接表中的信息
//Refresh();
return true;
}

void CScheme::OutPutProcessState()
{    
	//DOS环境下进程状态的输出
    /*CProcess *p;	
	cout<<"正在运行的进程的优先级"<<endl;
	if(m_Queue[1].next!=NULL)
	cout<<m_Queue[1].next->m_PRI<<endl;
	cout<<"\n就绪队列进程数"<<m_Queue[2].m_ProcessNum<<endl;
		
	cout<<"就绪队列中进程的信息（按照优先级排列）"<<endl;

   p=m_Queue[2].next;
	for(int l=0;l<m_Queue[2].m_ProcessNum;l++)
	{
		cout<<p->m_PRI<<"  ";
	    p=p->next;
	}

   cout<<"\n等待队列中进程的信息"<<endl;
   p=m_Queue[3].next;
    for(l=0;l<m_Queue[3].m_ProcessNum;l++)
	{
	cout<<p->m_PRI<<"      ";
	    p=p->next;
	}
	*/
}

void CScheme::DeadProcess()
{
    //进程死亡,把进程标识返还系统
	int returnID=m_Queue[1].next->m_processID;
	m_AllProcessID[returnID]=false;
    
	//进程死亡后cpu空闲
	m_Queue[1].m_ProcessNum=0;
   //更新邻接表，把就绪进程调入执行队列
	Refresh();
}

void CScheme::OninitScheme()
{
 //初始化邻接表
for(int i=1;i<=3;i++)
{
	m_Queue[i].m_ProcessNum=0; //建立邻接表的时候每队列为空
	m_Queue[i].m_QueueName=i;
	m_Queue[i].next=NULL;
}
for(int j=0;j<=200;j++)
  m_AllProcessID[i]=false;    //开始的时候所有的进程ID都没有被使用

}