task dynamic scheduling.cpp

操作系统课程实验

#include <iostream.h>
#include <math.h>
#include <time.h>
#include <stdlib.h>
#include <stdio.h>
//declaration;
 struct process
{
   int   tnum,pnum,ps,pr,pxt,prxt;
}; 
 struct process rq[32],bq[32],sq[32],current;//,sort_temp;//readprocess;blockprocess;save the done ;the running processes;switch tempory;
 struct task
 {
	struct process r[17];
	int tnum,ts,trxt,tr;
 };
 struct task tq[17],stq[9],run_task[10];
 // declear functions
 int r_num,b_num,cpuflag,rt_num,process_num,run_task_num;
 int save_num=0;
 int tsave_num=0;
 int pri=32; //0..32
 int cutime=0;
 void sort();
 void scheduling();
void modify();
void display(); 
void whba();
void disre();
void task_sort();
void distask();
void task_schedul();
void task_disre();
void main ()
{
	int inputnum,seed;// the number of process;total number of ready process;bolck process;the status of cpu;
	r_num=0;
	b_num=0;
	cpuflag=0; process_num=0;run_task_num=0; rt_num=0;
//test part ///////////////////////////////////////////////////////////////
	cout<<"please input the total number of taskes:"<<endl;
	cin>>inputnum;
	srand( (unsigned)time( NULL ) );
	seed=rand(); 
	rt_num=inputnum;
	for (int i=1;i<=inputnum;i++)
	{	srand(seed);
		seed=rand() % 8;
		seed++;
		tq[i].tnum=i;
		tq[i].ts=0;
		tq[i].tr=seed;
		for (int j=1;j<=seed;j++)
		{	
			tq[i].r[j].tnum=i;
			tq[i].r[j].pr=(rand() % 5)+seed;
			tq[i].r[j].ps=0;
			tq[i].r[j].pnum=j;
			tq[i].r[j].pxt=(((rand() % 5)+seed)+j)/3;
			tq[i].r[0].pr=seed;  ///////////// use *.r[0].pr to be the total number of the process
		}
	}
///////////////////////////////////////////////////////////////////////////
	cout<<"  pro_num pro_status pro_pri  pro_request time "<<endl;
	for (int count_i=1;count_i<=rt_num;count_i++)
	{
		cout<<"Task "<<count_i<<"-------------------------------"<<endl;
		for (int j=1;j<=tq[count_i].r[0].pr;j++)
		{
			cout<<"        "<<tq[count_i].r[j].pnum<<"       "<<tq[count_i].r[j].ps<<"        "<<tq[count_i].r[j].pr<<"          "<<tq[count_i].r[j].pxt<<endl;
		}
	};
	task_sort();   
	//for delay///////////////////////////////////////////
	for (int ii=1;ii<=10000;ii++)
		{	
			for (int jj=1;jj<=10000;jj++)
			{
				jj++;jj--;
			}
			ii++;ii--;
		}



	int b=0;
	while ((r_num>0)||(b_num>0)||(cpuflag!=0)||(b==0))
	{	cout<<"at time "<<cutime<<" : --------------------------------"<<endl;
		
	    if (rt_num>0) {task_schedul();}

		b=1;
		sort();
		scheduling();
		modify();
		display();
		whba();
		cutime++;

	}	
		
		task_disre();

}

//////////////////////////////////////////////////////////////////////////////////////////////
// sort function
void sort()
{	struct process sort_temp;
	for (int sort_i=r_num;sort_i>=2;sort_i--)
	{
		for (int sort_j=2;sort_j<=sort_i;sort_j++)
		{
		 if ((rq[sort_j].pr)>(rq[sort_j-1].pr))
		 {
		  sort_temp=rq[sort_j-1];
		  rq[sort_j-1]=rq[sort_j];
		  rq[sort_j]=sort_temp;
		 }
		}
	}
}
//// task sort
void task_sort()
{	struct task sort_temp;
	for (int sort_i=rt_num;sort_i>=2;sort_i--)
	{
		for (int sort_j=2;sort_j<=sort_i;sort_j++)
		{
		 if ((tq[sort_j].tr)>(tq[sort_j-1].tr))
		 {
		  sort_temp=tq[sort_j-1];
		  tq[sort_j-1]=tq[sort_j];
		  tq[sort_j]=sort_temp;
		 }
		}
	}
}
// task schedul
void task_schedul()
{	
	if ((process_num)<=12)  //////////////// the running processes at most are 12
	{
		if (((process_num)+tq[1].r[0].pr)<=12)
		{	int temp_i=0;
			for (int i=(r_num+1);i<=(r_num+tq[1].r[0].pr);i++)
			{	temp_i++;
				rq[i]=tq[1].r[temp_i];
			}
		//	cout<<"lsdjaf fish "<<tq[1].r[0].pr<<endl;
			r_num=r_num+tq[1].r[0].pr;
			process_num=process_num+tq[1].r[0].pr;
			run_task_num++; 
			run_task[run_task_num]=tq[1];
			for (int j=1;j<=rt_num;j++)
			{
				tq[j]=tq[j+1];
			}
			{rt_num--;};  
		}
	}
	//srand( (unsigned)time( NULL ) );
}
//scheduling function
void scheduling()
{	struct process switch_temp;
	if (cpuflag==0)
	{
		if (r_num >0)
		{
			current=rq[1];
			cpuflag=current.pnum;
			for (int i=1;i<=r_num;i++)
			{
				rq[i]=rq[i+1];
			}
			r_num--;
		}
	}else 
		{
			if (current.pr<rq[1].pr)
			{
				switch_temp=current;
				current=rq[1];
				rq[1]=switch_temp;
			}
		}
}
//modify the data
void modify()
{
	//ready processes
	for (int i=1;i<=r_num;i++)
	{	if (rq[i].pr<pri) 
	    rq[i].pr=rq[i].pr+1;
//		rq[i].prxt=rq[i].prxt+1;
	}
//block processes
//	for (int j=1;j<=b_num;j++)
//	{
//	 bq[j].prxt=bq[j].prxt+1;
//	}
//running process
	if (cpuflag!=0)
	{
	if (current.pr>=1) current.pr=current.pr-1;
	current.prxt=current.prxt+1;
//	current.pxt=current.pxt-1;
	}
}
//display the processes
void display()
{	cout<<endl;
////for task///////////////////////////////////////
	cout<<"the running taskes are: "<<endl;
	for (int k=1;k<=run_task_num;k++)
	{
		cout<<run_task[k].tnum<<"  ";
	}
	cout<<endl;
//////////////////////////////////////////
	cout<<"the ready processes are:"<<endl;
	for (int i=1;i<=r_num;i++)
	{
		cout<<rq[i].tnum<<"->"<<rq[i].pnum<<"   ";
	}
	cout<<endl;
	cout<<"the bolcked processes are:"<<endl;
	for (int j=1;j<=b_num;j++)
	{
		cout<<bq[j].tnum<<"->"<<bq[j].pnum<<"   ";
	}
	cout<<endl;
	////////////////////////////////
	cout<<"the running process is ";
	if (cpuflag!=0) cout<<current.tnum<<"->"<<current.pnum<<"; its rxt is "<<current.prxt<<endl;
	cout<<endl;
}
//whether blocked or active ?
void whba()
{	int tempb_num=0;
	//if the running process has been done then falg and save it else block the running process?
	if ((current.prxt==current.pxt) && (cpuflag!=0))
	{
		cpuflag=0;
	// used to be 	cout<<"***************************************************************"<<endl;
	//	cout<<"num. "<<current.pnum<<" process done; Its xt is  "<<current.prxt<<endl;
	//	cout<<"***************************************************************"<<endl;
	//	cout<<"***************************************************************"<<endl;
	//	cout<<"task_num. "<<current.tnum<<"num. "<<current.pnum<<" process done; Its xt is  "<<current.prxt<<endl;
	//	cout<<"***************************************************************"<<endl;
		int ti=0;
	for (ti=1;ti<=run_task_num;ti++)
	{	
		if (run_task[ti].tnum==current.tnum)
		{
		run_task[ti].r[0].pr--;
		}
	
		if (run_task[ti].r[0].pr==0) 
		{
			run_task[ti].tr=cutime;
						
			cout<<"========================================================================"<<endl;
			cout<<"task num.  "<<run_task[ti].tnum<<" done  "<<"at time "<<run_task[ti].tr<<endl;
			cout<<"========================================================================"<<endl;
			tsave_num++;
			stq[tsave_num].tnum=run_task[ti].tnum;
			stq[tsave_num].tr=run_task[ti].tr;
////////////////// use for delay			
/*			for (int ii=1;ii<=10000;ii++)
			{	
				for (int jj=1;jj<=10000;jj++)
				{
					jj++;jj--;
				}
				ii++;ii--;
			}
*/
			for (int i=ti;i<=run_task_num;i++)
			{
				run_task[i]=run_task[i+1];
			}
			run_task_num--;
		

		};//use *.tr to save the counter number
	}
		process_num--;
		//run_task[current.tnum].r[current.pnum].pr=cutime;
		save_num++;        // cout<<"asdf766asdf"<<cutime<<endl;/////////////////////////
		sq[save_num]=current;
		sq[save_num].pr=cutime;   // use *.pr to be the counter number
		current.pnum=0;
//		for (int ii=1;ii<=10000;ii++)
//		{	
//			for (int jj=1;jj<=10000;jj++)
//			{
//				jj++;jj--;
//			}
//			ii++;ii--;
//		}
	} else
		{if (cpuflag!=0)
			{
	/////////////////////////////////////////////////////////////////////////////////// care
			srand( (unsigned)time( NULL ) );
	
			if ((rand() % 10)<2) 
				{
					b_num=b_num+1;
					cpuflag=0;
					bq[b_num]=current;
				}
			}
		}
	//block the ready process?
	for (int i=1;i<=r_num;)
	{	
			for (int ii=1;ii<=10000;ii++)
		{	
			for (int jj=1;jj<=1000;jj++)
			{
				jj++;jj--;
			}
			ii++;ii--;
		}
		srand( (unsigned)time( NULL ) );
	
		if ((rand() % 10)<3)  
		{
			b_num++;
			bq[b_num]=rq[i];
			for (int i1=i;i1<=r_num;i1++)
			{
				rq[i1]=rq[i1+1];
			}
			r_num--;
			i--;
		}
		i++;
	}
	//active  the blocked process?
	//if (tempb_num==0) tempb_num=b_num;
	for (int j=1;j<=b_num;)
	{		for (int ii=1;ii<=10000;ii++)
		{	
			for (int jj=1;jj<=1000;jj++)
			{
				jj++;jj--;
			}
			ii++;ii--;
		}
		srand( (unsigned)time( NULL ) );
	
		if ((rand() % 10)>3) 
		{
			r_num++;
			rq[r_num]=bq[j];
			for (int j1=j;j1<=b_num;j1++)
			{
				bq[j1]=bq[j1+1];
			}
			b_num--;
			//tempb_num--;
			j--;
		}
		j++;
	}
//	b_num=tempb_num;//care about the tempb_num,the next time its value is ? 
}
////////////// processes display
void disre()
{	
	for (int i=1;i<=save_num;i++)
	{
		cout<<"number "<<sq[i].pnum<<"  process done at time: "<<sq[i].pr<<" the rxt is:"<<sq[i].prxt<<endl;
	}
}
//display the results of taskes
void task_disre()
{	
	for (int i=1;i<=tsave_num;i++)
	{
		cout<<"number "<<stq[i].tnum<<"  task done at time: "<<stq[i].tr<<endl;
	}
}
// judge whether need task schedul
//void distask()
//{	//int count=1;
//	for (int i=1;i<=run_task_num;i++)
	//{	
	//	for (int j=1;j<=run_task[i].r[0].pxt;j++)
	//	{
	//		if (run_task[i].r[j].pxt==0)

	//		{	count++;}
	//	}
	/*	if (run_task[i].r[0].pr<=0)
		{	
			cout<<"========================================================================"<<endl;
			cout<<"task num.  "<<run_task[i].tnum<<" done  "<<"at time "<<run_task[i].tr<<endl;
			cout<<"========================================================================"<<endl;
			tsave_num++;
			stq[tsave_num].tnum=run_task[i].tnum;
			stq[tsave_num].tr=run_task[i].tr;
////////////////// use for delay			
/*			for (int ii=1;ii<=10000;ii++)
			{	
				for (int jj=1;jj<=10000;jj++)
				{
					jj++;jj--;
				}
				ii++;ii--;
			}
*/
//			for (int i=1;i<=run_task_num;i++)
//			{
//				run_task[i]=run_task[i+1];
//			}
//			run_task_num--;
//		}
//	}
//}*/