shd.cpp

操作系统课程设计～处理机调度 模拟一种多任务（或多用户）（多道）批处理操作系统（包含处理器管理、存储管理、进程管理。

#include "stdafx.h"
#include "shd.h"
#include <cstdlib>	//for srand() and rand()
#include <cassert>
#define DEFAULT_RUN_PROCESS 6

CSchdQueue::CSchdQueue():n_max_run(DEFAULT_RUN_PROCESS),n_process(0),sched_kind(0),usemm(false)
{
	CMem* mp=new CMem;
	mp->begin=0;
	mp->size=64;
	mm.push_back(mp);
	mp->begin=64;
	mp->size=MM_TOTAL_SIZE-64;
	mm.push_back(mp);
	mm.head=mp;
}

Cpcb* CSchdQueue::randpcb()
{
	++n_process;
	srand(n_process);
	Cpcb* p=new Cpcb;
	p->pid=n_process;
	p->priority=rand()%MAX_PRIO+5;
	p->time_slice=(int)rand()%DEFAULT_TIME_SLICE+1;
	p->memory=rand()%MM_MAX_SIZE+42;
	return p;
}

void CSchdQueue::deletepcb(Cpcb* p)
{
	--n_process;
	delete p;
}

void CSchdQueue::add_to_reserve(Cpcb* p)
{
	if( p->state!=TASK_OVER )
	{
		reserve.push_back(p);
		p->state=TASK_RESERVE;
	}
	if( sched_kind==SCHED_PRIO )
	{
		reserve.sort();
	}
}

void CSchdQueue::add_to_reday(Cpcb* p)
{
	if( active.count<n_max_run )
	{
		if( p->state!=TASK_READY )
			p->state=TASK_READY;
		active.push_back(p);
	}
}




void CSchdQueue::add_to_over(Cpcb* p)
{
	over.push_back(p);
	p->state=TASK_OVER;
	reclaim(p);
	schedule();
}

void CSchdQueue::in_schedule_prio()
{
		active.sort();
		current=active.head;
		if( !current->run() )
		{
			Cpcb* p=active.pop_front();	
			add_to_over(p);
			schedule();
		}
}

void CSchdQueue::in_schedule_rr()
{
	current=active.head;
	if( !current->run() )
	{
		Cpcb* p=active.pop_front();	
		add_to_over(p);
		schedule();
		return;
	}
	Cpcb *newp=new Cpcb;
	newp=active.pop_front();
	active.push_back(newp);
}

/*内调度(俗语低级调度或进程调度)：负责就绪队列中进程切换*/
void CSchdQueue::in_schedule()
{
	if( active.count==0 ) return;
	if( SCHED_PRIO==sched_kind )
		in_schedule_prio();
	else if( SCHED_RR==sched_kind )
	{
		in_schedule_rr();
	}
}

/*外调度(俗语高级调度或作业调度)：负责就绪队列线程的供给*/
void CSchdQueue::schedule()
{
	if( reserve.count>0 )
	{
		int canrun=0;
		//判断后备队列是否超出规定运行线程数，是则按规定道数慢慢来，否则全部上
		if( reserve.count>n_max_run-active.count) canrun=n_max_run;
		else 
			canrun=reserve.count+active.count;
		for(int i=active.count;i<canrun;i++)
		{
			if(!alloc(reserve.head) ) 
			{			
				return;
			}
			add_to_reday(reserve.pop_front());
		}
	}
	/*当就绪队列和挂起队列中都没有进程时说明调度完成*/
}

bool CSchdQueue::alloc(Cpcb* p)
{
	CMem* mp=mm.head;
	if (mp->size<p->memory)
	{
		return false;
	}

	p->mm_begin=mp->begin;
	mp->div(p->memory);
	if( mp->size==0 && mp->begin!=MM_TOTAL_SIZE)
		mm.remove(mp);
	return true;
}

void CSchdQueue::reclaim(Cpcb* p)
{
	Cpcb *newp=active.head;   //内存资源回收
     while (newp!=active.end)
     {
		 if (newp->mm_begin>p->mm_begin)
		 {
			 newp->mm_begin-=p->memory;
		 }
		 newp=newp->nextp;
     }
	 mm.head->begin-=p->memory;
	 mm.head->size+=p->memory;
}

void CSchdQueue::clear()
{
	if( n_process )
	{
		reserve.clear();	//清空后备队列
		active.clear();		//清空就绪队列
		hang.clear();		//清空挂起队列
		over.clear();		//清空完成队列
		n_max_run=0;
		n_process=0;
		sched_kind=0;
	}
}