随机.txt

CPU调度源码分类介绍。我做课程设计是用到的。拿出分享。

		}//else
		StaAverageWaitTime[0]=AverageWaitTime;
		StaAverageRoundTime[0]=AverageRoundTime;

	}//else
	
}//if



	


void CCPUSchedule1Dlg::OnBtnPriority() 
{
	// TODO: Add your control notification handler code here
	int p=I,m,n,q=2,c=1,IWaitTime=0,IRoundTime=0;
	float AverageWaitTime,AverageRoundTime;
	int WaitTime[50],RoundTime[50];   //假设最多有50个进程
	CString str_AverageWaitTime,str_AverageRoundTime;
	CProcess turn;  

	//当没有任何进程而单击该按钮时报错

	   if(I<1)
		MessageBox("没有输入任何进程！");
        else
		{
	    //按照优先级冒泡法排序
          for(m=0;m<p;m++)
		     for(n=0;n<p-m;n++)
			 {
			    if(process[n].GetPriority()>process[n+1].GetPriority())
				{
				   turn=process[n];
				   process[n]=process[n+1];
				   process[n+1]=turn;
				}
			    else
				{
					if(process[n].GetPriority()==process[n+1].GetPriority())
					{
						if(process[n].GetArriveOrder()>process[n+1].GetArriveOrder())
						{
							turn=process[n];
				            process[n]=process[n+1];
				            process[n+1]=turn; 
						}//if
						else{}
					}//if
					else{}
				}//else
			 }//for
		
			 
			 //计算等待时间  按照非强占式优先级调度
			 //计算等待时间
	     WaitTime[1]=0;
		 while(q<=p)
		 {
			 WaitTime[q]=WaitTime[q-1]+process[q-1].GetServiceTime();
			 //第q个进程的等待时间=第q-1个进程的等待时间+第q-1个进程的服务时间
			 q++;
		 }
		 for(q=1;q<=p;q++)
			 IWaitTime=IWaitTime+WaitTime[q];
		 AverageWaitTime=(float)IWaitTime/p;
		 //计算周转时间
		/* RoundTime[1]=process[1].GetServiceTime();
		 while(c<=p)
		 {
			 RoundTime[c]=WaitTime[c]+process[c].GetServiceTime();
			 c++;
		 }
		 for(c=1;c<=p;c++)
			 IRoundTime+=RoundTime[c];
		 AverageRoundTime=(float)IRoundTime/p;*/
		 for(c=1;c<=p;c++)
		{
			RoundTime[c]=WaitTime[c]+process[c].GetServiceTime();
			IRoundTime+=RoundTime[c];
		}
		AverageRoundTime=(float)IRoundTime/p;


		 
		 //输出
		 str_AverageWaitTime.Format("优先权调度平均等待时间是:%f",AverageWaitTime);
	     m_cresultshow.AddString(str_AverageWaitTime);
	   	 str_AverageRoundTime.Format("          平均周转时间为:%f",AverageRoundTime);
	     m_cresultshow.AddString(str_AverageRoundTime);
		 
		 StringCount++;
		
		if(I<0)
		{}//无进程时不输出
		else
		{
			m_request.AddString("优先权调度算法主要用于批处理系统中,\n");
			m_request.AddString("也可用于某些对实时要求不严的实时系统中.\n");
		}//else
		StaAverageWaitTime[1]=AverageWaitTime;
		StaAverageRoundTime[1]=AverageRoundTime;
	}//else
}

	

void CCPUSchedule1Dlg::OnBtnMultQue() 
{
	// TODO: Add your control notification handler code here
	MessageBox("您无权执行此操作！");
	
}


void CCPUSchedule1Dlg::OnBtnSJF() 
{
	// TODO: Add your control notification handler code here
		int p=I,m,n,q=2,c=1,IWaitTime=0,IRoundTime=0;
	float AverageWaitTime,AverageRoundTime;
	int WaitTime[50],RoundTime[50];   //假设最多有50个进程
	CString str_AverageWaitTime,str_AverageRoundTime;
	CProcess turn;  

	//当没有任何进程而单击该按钮时报错

	   if(I<1)
		MessageBox("没有输入任何进程！");
        else
		{
	    //按照优先级冒泡法排序
          for(m=0;m<p;m++)
		     for(n=0;n<p-m;n++)
			 {
			    if(process[n].GetServiceTime()>process[n+1].GetServiceTime())
				{
				   turn=process[n];
				   process[n]=process[n+1];
				   process[n+1]=turn;
				}
			    else
				{
					if(process[n].GetServiceTime()==process[n+1].GetServiceTime())
					{
						if(process[n].GetArriveOrder()>process[n+1].GetArriveOrder())
						{
							turn=process[n];
				            process[n]=process[n+1];
				            process[n+1]=turn; 
						}//if
						else{}
					}//if
					else{}
				}//else
			 }//for
		
			 
			 //计算等待时间  按照非强占式优先级调度
			 //计算等待时间
	     WaitTime[1]=0;
		 while(q<=p)
		 {
			 WaitTime[q]=WaitTime[q-1]+process[q-1].GetServiceTime();
			 //第q个进程的等待时间=第q-1个进程的等待时间+第q-1个进程的服务时间
			 q++;
		 }
		 for(q=1;q<=p;q++)
			 IWaitTime=IWaitTime+WaitTime[q];
		 AverageWaitTime=(float)IWaitTime/p;
		 //计算周转时间
		/* RoundTime[1]=process[1].GetServiceTime();
		 while(c<=p)
		 {
			 RoundTime[c]=WaitTime[c]+process[c].GetServiceTime();
			 c++;
		 }
		 for(c=1;c<=p;c++)
			 IRoundTime+=RoundTime[c];
		 AverageRoundTime=(float)IRoundTime/p;*/
		 for(c=1;c<=p;c++)
		{
			RoundTime[c]=WaitTime[c]+process[c].GetServiceTime();
			IRoundTime+=RoundTime[c];
		}
		AverageRoundTime=(float)IRoundTime/p;


		 
		 //输出
		 str_AverageWaitTime.Format("SJF调度算法平均等待时间是:%f",AverageWaitTime);
	     m_cresultshow.AddString(str_AverageWaitTime);
	   	 str_AverageRoundTime.Format("          平均周转时间为:%f",AverageRoundTime);
	     m_cresultshow.AddString(str_AverageRoundTime);
		 
		 StringCount++;
		
		if(I<0)
		{}//无进程时不输出
		else
		{
			m_request.AddString("SJF调度算法通常平均等待时间最短,\n");
			m_request.AddString("但是不容易估计下一个作业的服务时间.\n");
		}//else
	StaAverageWaitTime[2]=AverageWaitTime;
	StaAverageRoundTime[2]=AverageRoundTime;
		}//else
}
	


void CCPUSchedule1Dlg::OnBtnRR() 
{
	// TODO: Add your control notification handler code here
	int p=I,waittime=0,int_roundtime=0,c=2,m,n;
	int mem_q,q=1,t=1;
			//int_littletime时间片，q表示第几个进程，
			//p为目前进程总数,mem_q用来记录q的位置，t
	int mem_servicetime[20];
			//mem_servicetime 该数组用来记录进程服务时间
	float AverageWaitTime,AverageRoundTime;
	CString str_averagewaittime,str_averageroundtime,str_int_littletime,
			str_allwaittime,str_allroundtime,str_allprocess,str_explain;
	CProcess test;   //注意类型不要忘了C
    
	

	if(I<1)
	MessageBox("没有输入任何进程！");
		//当没有任何进程而单击该按钮时报错
    else
	{
		while(t<=p)
			//将各个进程的服务时间保存在mem_servicetime数组中，以便后面用到
		{
			mem_servicetime[t]=process[t].GetServiceTime();
			t++;
		}//while

		//以下为用冒泡法按照到达时间对进程进行排序
		for(m=0;m<p-1;m++)
			for(n=1;n<=p-m-1;n++)
			{
				if(process[n].GetArriveOrder()>process[n+1].GetArriveOrder())
				{
					test=process[n];
					process[n]=process[n+1];
					process[n+1]=test;
				}//if
				else
				{
				}
			}//for	
		
		//计算等待时间
		while(p>=1)
			//用循环分配的方法分配时间片，并记录等待时间
		{
			for(q=1;q<=p;q++)
			{
				if(process[q].GetServiceTime()<=Littletime)
					//某进程剩余的服务时间<＝时间片
				{
					waittime=(p-1)*process[q].GetServiceTime();
					int_roundtime=process[q].GetServiceTime()*p;
					//周转时间增值
					process[q].SetServiceTime(0);
					//经过本次分配后，进程完全分配完了，将服务时间设置为0，
					//以便于下次循环
					
					mem_q=q;  //用mem_q记录q的位置
					while(q<p)
						//第q个进程之后的进程向前移动
					{
						process[q]=process[q+1];
						q++;
					}//while
					p=p-1;    //结束一个进程，目前进程总数减去1
					q=mem_q;      //q回到原来的位置 
				}//if
				else
				{
					waittime=(p-1)*Littletime;
					process[q].SetServiceTime(process[q].GetServiceTime()-Littletime);
					//每当分配一次时间片，就将服务时间减去时间片
					int_roundtime=Littletime*p;
				}//else
				WT=WT+waittime;
				RT=RT+int_roundtime;
			}//for
			if(q==p)
				q=1;    //如果到了最后一个进程还没有完全完成所有进程，还要从头重新开始分配时间片
		}//while
		AverageWaitTime=(float)WT/I;
		AverageRoundTime=(float)RT/I;
		while(t<=p)
				//还原，将各个进程的服务时间从mem_servicetime数组中取出来放回到
				//process[t].GetServiceTime()中，以便后面用到
		{
			mem_servicetime[t]=process[t].GetServiceTime();
			t++;
		}//while


		//输出结果
		str_explain.Format("为了简化算法，进程的默认到达时间都是0");
		m_cresultshow.AddString(str_explain);
//		m_cresultshow.AddString(str_int_littletime);
		str_averagewaittime.Format("RR算法的平均等待时间是：%f",AverageWaitTime);
		m_cresultshow.AddString(str_averagewaittime);
		str_averageroundtime.Format("RR算法的平均周转时间是：%f",AverageRoundTime);
		m_cresultshow.AddString(str_averageroundtime);
		StringCount++;  
		
	}//else
        StaAverageWaitTime[2]=AverageWaitTime;     ////全局评价数组
		StaAverageRoundTime[2]=AverageRoundTime;
}

//综合算法评价
void CCPUSchedule1Dlg::OnBtnComEvaluate()
{

	// TODO: Add your control notification handler code here
//	m_request.AddString();
	if(I<1)
	{
		MessageBox("警告！无进程输入！");
	}
	else
	{
		int i,w,r;
	    float Wmin,Rmin;//平均等待时间和平均周转时间的最小值
	    CString CWmin,CRmin;
   	    Wmin=StaAverageWaitTime[0];
	    Rmin=StaAverageRoundTime[0];

	    //等待时间
	    for(i=0;i<3;i++)
		{
			if(Wmin>StaAverageWaitTime[i+1])
				Wmin=StaAverageWaitTime[i+1];
		}
		

	    if(Wmin==StaAverageWaitTime[0])
			w=10;
	    if(Wmin==StaAverageWaitTime[1])
		    w=20;
	    if(Wmin==StaAverageWaitTime[2])
		    w=30;
	    if(Wmin==StaAverageWaitTime[3])
		    w=40;

	
	    switch(w)
		{
		case 10:
			m_request.AddString("综上所有算法，FCFC算法的平均等待时间最小！");
		    break;
	    case 20:
		    m_request.AddString("综上所有算法，非强占式优先级调度算法的平均等待时间最小！");
		    break;
	    case 30:
		    m_request.AddString("综上所有算法，SJF算法的平均等待时间最小！");
		    break;
	    case 40:
		    m_request.AddString("综上所有算法，RR算法的平均等待时间最小！");
		    break;
	    default:
		    m_request.AddString("警告！！出错！");
		}
		m_request.AddString("最小的平均等待时间为：");
	    CWmin.Format("%f",Wmin);
	    m_request.AddString(CWmin);
	   //周转时间
	   for(i=0;i<3;i++)
	   {
		   if(Rmin>StaAverageRoundTime[i+1])
			   Rmin=StaAverageRoundTime[i+1];
	   }
	  
	   if(Rmin==StaAverageRoundTime[0])
		   r=1;
	   if(Rmin==StaAverageRoundTime[1])
		   r=2;
	   if(Rmin==StaAverageRoundTime[2])
		   r=3;
	   if(Rmin==StaAverageRoundTime[3])
		   r=4;

	
	   switch(r)
	   {
	   case 1:
		   m_request.AddString("综上所有算法，FCFC算法的平均周转时间最小！");
		   break;
	   case 2:
		   m_request.AddString("综上所有算法，非强占式优先级调度算法的平均周转时间最小！");
		   break;
	   case 3:
		   m_request.AddString("综上所有算法，SJF算法的平均周转时间最小！");
		   break;
	   case 4:
		   m_request.AddString("综上所有算法，RR算法的平均周转时间最小！");
		   break;
	   default:
		   m_request.AddString("警告！！出错！");
	   }//switch

	    m_request.AddString("最小的平均周转时间为：");
	   CRmin.Format("%f",Rmin);
	   m_request.AddString(CRmin);

	    StringCount=StringCount+5;//只要后面的数字大于所添加的行数即可
	}//else
}

/*
问题：
1、怎样控制无进程时提醒输入？(解决)
2、不随机产生时不能输入数据(解决)
3、虽实现不随机产生时不能往里输入进程，可是自己输入进程时却提醒没添加进程(解决)
4、怎样控制输入数据的地方不能输入字符(解决)
5、怎样让优先级随机产生时不重复？怎样让产生的优先级正好与进程数目相对应？(这个无需
    考虑，优先级可以相等，优先级序号跟进程数目无关)
6、没有实现不重复输入进程
7、当自动添加进程后，随机产生的进程序号比原先大2！！！(解决)
8、删除进程时如何删除制定的进程(通过list框的SelectItem等函数取，然后删除即可，再查查函数)
9、刚开始算法有问题，第一个进程的数据不能使用，原因：I从0开始的不是从1开始的


*/