进程调度模拟

实验平台：windows 7,vs2010

实验目标：模拟短作业优先算法，时间片轮转算法，和优先数算法，并动态画出Grant图，计算每个进程的响应时间和周转时间

数据结构：

class process
{
	vector<string>process_name;
	vector<int>arrive_time;
	vector<int>run_time;
	vector<int>priority;


	vector<string>result_name;
	vector<int>result_time;
public:
	process(void);
	process(string file)
	{
		ifstream fin(file);
		while(!fin.eof())
		{
			string name;
			int arrive_time;
			int run_time;
			int priority;
			fin>>name>>arrive_time>>run_time>>priority;
			this->process_name.push_back(name);
			this->arrive_time.push_back(arrive_time);
			this->run_time.push_back(run_time);
			this->priority.push_back(priority);
		}
		fin.close();
	}
	void SJF(void);                     
	void Preemptive_SJF();
	int get_minremaintime(int time_bar,vector<int>remain_time);
	int get_minruntime(int time_bar);               
	void RR(int time_piece);          
	void PR(void);                      
	int get_topprocess();               
	vector<int> get_response_time();    
	vector<int> get_cycle_time();      
	void display();                           
	~process(void);
};

 

1）最短作业优先算法

非抢占式代码：

int process::get_minruntime(int time_bar)
{
	int state=1;
	int min_runtime = 999;
	bool flag;
	for (int i = 1; i < process_name.size(); i++)
	{
		flag = false;
		flag=time_bar<arrive_time.at(i);              //加入time_bar判断是否在当前时间之前到达
		for (int j = 1; j < result_name.size(); j++)
		{
			if (process_name.at(i) == result_name.at(j))
			{
				flag = true;
				break;
			}
		}
		if (!flag)
		{
			if (run_time.at(i) < min_runtime)
			{
				state = i;
				min_runtime = run_time.at(i);
			}
					
		}
	}
	return state;
}
//==========================
//最短作业优先调度，默认按照到达时间排序
//作者：林欣  20151025
//在第一个到达的进程执行后，不断寻找时间最短的进程
//==========================
void process::SJF()
{
	int state;
	int time_bar=0;
	result_name.push_back(process_name.at(0));
	result_time.push_back(run_time.at(0));
	for (int i = 1; i < process_name.size(); i++)
	{
		state = this->get_minruntime(time_bar);
		result_name.push_back(process_name.at(state));
		result_time.push_back(run_time.at(state));
		time_bar+=run_time.at(state);
	}

}

 

抢占式代码：

//========================
//抢占式最短优先
//作者：林欣 20151026
//========================
int process::get_minremaintime(int time_bar,vector<int>remain_time)
{
	int state=0;
	int min_remaintime = 999;
	bool flag;
	for (int i = 0; i < process_name.size(); i++)
	{
		flag = false;
		flag=(time_bar<arrive_time.at(i));              //加入time_bar判断是否在当前时间之前到达
		if (!flag)
		{
			if (remain_time.at(i) <= min_remaintime&&remain_time.at(i)>0)
			{
				state = i;
				min_remaintime = remain_time.at(i);
			}
					
		}
	}
	return state;
}
void process::Preemptive_SJF()
{
	vector<int>remain_time(run_time);
	int state=0;
	int state_t=-1;
	int time_bar=0;
	bool flag=true;
	do
	{
		state=get_minremaintime(time_bar,remain_time);
		if(state_t!=state)
		{
			result_name.push_back(process_name.at(state));
			result_time.push_back(1);
			remain_time.at(state)--;
			time_bar++;
		}
		else
		{
			time_bar++;
			result_time.at(result_time.size()-1)++;
			remain_time.at(state)--;
		}
		state_t=state;
		flag=false;
		for(int i=0;i<process_name.size();i++)
		{
			flag=flag||remain_time.at(i)!=0;
			if(flag)
				break;
		}
	}while(flag);
}

 

2）时间片轮转算法

/========================
//时间片轮转调度
//作者：林欣 20151025
//到达时间在当前时间之前且还没有执行完的,按时间片加入结果
//========================
void process::RR(int time_piece)
{
	int round = 0;
	int time_bar = 0;
	bool flag = false;
	int total_time = 0;
	for (int i = 0; i < process_name.size(); i++)
	{
		total_time += run_time.at(i);
	}
	//cout << total_time;
	do
	{
		for (int i = 0; i < process_name.size(); i++)
		{
			if (arrive_time.at(i) <= time_bar&&run_time.at(i)>round*time_piece)//到达时间在当前时间之前且还没有执行完的
			{
				int time_left = run_time.at(i) - round*time_piece;
				if (time_left >= time_piece)
				{
					result_name.push_back(process_name.at(i));
					result_time.push_back(time_piece);
					time_bar += time_piece;
				}
				else
				{
					result_name.push_back(process_name.at(i));
					result_time.push_back(time_left);
					time_bar += time_left;
				}

			}
		}

		round++;
		if (time_bar == total_time)
			flag = true;

	} while (!flag);
}

 

3）优先数算法:

//===================
//优先级优先调度算法
//作者：林欣 20151025
//类似最短时间优先调度
//======================
int process::get_topprocess()
{
	int state = 0;
	int topprocess = 999;
	bool flag;
	for (int i = 0; i < process_name.size(); i++)
	{
		flag = false;
		for (int j = 1; j < result_name.size(); j++)
		{
			if (process_name.at(i) == result_name.at(j))
			{
				flag = true;
				break;
			}
		}
		if (!flag)
		{
			if (priority.at(i)<topprocess)
			{
				state = i;
				topprocess = priority.at(i);
			}

		}
	}
	return state;
}
void process::PR()
{
	int state;
	result_name.push_back(process_name.at(0));
	result_time.push_back(run_time.at(0));
	for (int i = 1; i < process_name.size(); i++)
	{
		state = this->get_topprocess();
		result_name.push_back(process_name.at(state));
		result_time.push_back(run_time.at(state));
	}
}

 

4)计算响应时间：

//=========================
//计算响应时间
//作者：林欣 20151025
//需紧跟调度函数后执行,与调度顺序结果对应
//=========================
vector<int> process::get_response_time()
{
	vector<int>resposetime_t;
	vector<int>resposetime;
	resposetime_t.push_back(0);
	int time = 0;
	for (int i = 1; i < process_name.size(); i++)
	{
		time += result_time.at(i - 1);
		resposetime_t.push_back(time);
	}
	for (int i = 0; i < process_name.size(); i++)
	{
		for (int j = 0; j < resposetime_t.size(); j++)
		{
			if (process_name.at(i) == result_name.at(j))
			{
				resposetime.push_back(resposetime_t.at(j));
				break;
			}
		}
	}
	return resposetime;
}

 

5）计算周转时间

//===============================
//周转时间
//作者：林欣 20151025
//==========================
vector<int> process::get_cycle_time()
{
	int time;
	int time_bar;
	vector<int>cycle_time;
	vector<int>response_time(get_response_time());
	for (int i = 0; i < process_name.size(); i++)
	{
		time = 0;
		time_bar = 0;
		for (int j = 0; j < result_name.size(); j++)
		{
			if (result_name.at(j) == process_name.at(i))
				time += result_time.at(j);
			time_bar += result_time.at(j);
			if (time == run_time.at(i))
				break;
		}
		cycle_time.push_back(time_bar-response_time.at(i));
	}
	return cycle_time;
}

 

6）显示

void process::display()
{
	for(int i=0;i<result_name.size();i++)
	{
		cout.width(result_time.at(i)*2+1);
		cout.setf(ios::left);
		cout<<result_name.at(i);
		
	}
	cout<<endl;
	for(int i=0;i<result_name.size();i++)
	{
		cout.width(result_time.at(i)*2+1);
		cout.setf(ios::left);
		cout<<result_time.at(i);
	}
	cout<<endl;
	for(int i=0;i<result_name.size();i++)               
	{
		for(int j=0;j<result_time.at(i)*2;j++)
		{
			cout<<'*';
		}
		cout<<" ";
	}
	vector<int>cycle_time(this->get_cycle_time());
	vector<int>response_time(this->get_response_time());
	cout<<"\nname:"<<"  response_time"<<"  cycle_time"<<endl;
	
	for(int i=0;i<process_name.size();i++)
	{
		
		cout<<"  "<<process_name.at(i)<<"       "<<response_time.at(i)<<"          "<<cycle_time.at(i)<<endl;
	}
}