modelosysdlg.cpp

操作系统内存调度例子

		flagshow=NULL;
		OnShowJt();
		OnShowPt();
	    OnShowMbt();
	}
	OnShowJcb();
    OnShowPcb();
}

//按由大到小的次序插入
Pcb * CModelosysDlg::OnInsert(Pcb *first, Pcb *info)
{
	Pcb *p1,*p2;
	if(first==NULL)        //表头为空
	{
		first=info;
		first->next=NULL;
	}
	else                  //表头不为空
	{
		if(info->priority>first->priority) //在表头插入
		{
			info->next=first;
			first=info;
		}
          else
          {
          	for(p1=first,p2=first->next;;p1=p2,p2=p2->next)
          	{
          		if(p2==NULL)
          		{
          			p1->next=info;
          			info->next=NULL;
          			break;
          		}
          		if(info->priority>p2->priority)
          		{
          			p1->next=info;
          			info->next=p2;
          			break;
          		}
          	}
          }
     }
     return first;
}

//按由大到小的次序插入
Jcb * CModelosysDlg::OnInsert(Jcb *first, Jcb *info)
{
	Jcb *p1,*p2;
	if(first==NULL)        //表头为空
	{
		first=info;
		first->next=NULL;
	}
	else                  //表头不为空
	{
		if(info->rp>first->rp) //在表头插入
		{
			info->next=first;
			first=info;
		}
          else
          {
          	for(p1=first,p2=first->next;;p1=p2,p2=p2->next)
          	{
          		if(p2==NULL)
          		{
          			p1->next=info;
          			info->next=NULL;
          			break;
          		}
          		if(info->rp>p2->rp)
          		{
          			p1->next=info;
          			info->next=p2;
          			break;
          		}
          	}
          }
     }
     return first;
}

//按由大到小的顺序排序
Jcb * CModelosysDlg::OnSort(Jcb *head)
{
	Jcb *p,*head1=NULL;
	while(head!=NULL)
	{
		p=head;
		head=head->next;
		head1=OnInsert(head1,p);
	}
	return head1;
}

float CModelosysDlg::OnResponse(int waittime, int runtime)
{
	float Rp=0;
    Rp=1+(float)waittime/(float)runtime;
	return Rp;
}

//更新Jcb表
Jcb * CModelosysDlg::OnChange(Jcb *head)
{
	Jcb *p=head;
	while(p!=NULL)
	{
		if(p->state=="wait")
		{
			p->waittime++;
			p->rp=OnResponse(p->waittime,p->runtime);
		}
		p=p->next;
	}
	head=OnSort(head);
	return head;
}

//更新Pcb表
void CModelosysDlg::OnChange()
{
	Pcb* flag=OnGetPcbFlag();
	if(flag!=NULL)
	{
		flagshow=flag;
        OnBackmemory(flag);
		OnAllocmemory();
		Jcb* k=OnFindJcb(JcbHead,flag);
		k->state="finish";
		PcbHead=OnDeletePcbFlag();
	}
	if(PcbHead!=NULL)
	{
		Pcb *p1=OnFindPcb();
		if(p1!=NULL)
		{
			p1->cputime--;
			p1->priority=p1->priority-3;
			if(p1->cputime==0)
			{
				p1->state="finish";
				PcbHead=OnInsertPcbTailFlag(PcbHead,p1);
			}
			else
			{
				p1->state="ready";
			    PcbHead=OnInsert(PcbHead,p1);
			}
		}
        if(PcbHead->state=="ready") 
			PcbHead->state="run";
	}
}

//分配内存空间
void CModelosysDlg::OnAllocmemory()								
{
	int i,j;
	Jcb *p=JcbHead;
	Jt *Jtp,*Jtp1;
	Pt *Ptp,*Ptp1,*Ptp2;
	Pcb *Pcbp;
	while(p!=NULL&&p->state=="wait"&&p->memorysize<=Memorysize)
    {
		Jtp=new Jt;  //创进Jt表
		Jtp1=OnGetJtTail(JtHead);
        if(Jtp1==NULL)
			Jtp->ptaddr=0;
		else Jtp->ptaddr=Jtp1->ptaddr+Jtp1->ptlength;
		Jtp->jobid=p->jobid;
		Jtp->ptlength=p->memorysize;
		JtHead=OnInsertJtTail(JtHead,Jtp);
        
		for(i=0;i<p->memorysize;i++) //创进Pt表
		{
			Ptp1=OnGetPtTail(PtHead); 
		    Ptp=new Pt;  
			if(Ptp1==NULL)
				Ptp->address=0;
			else
				Ptp->address=Ptp1->address+1;
			Ptp->pageid=i;
			Ptp->block=0;
			PtHead=OnInsertPtTail(PtHead,Ptp);
		}

        //分配内存空间
		Memorysize=Memorysize-p->memorysize;
		Ptp2=OnGetPt(PtHead,Jtp);
		for(i=0,j=0;i<64;i++)
		{
			if(memsize[i].state==0)
			{
				memsize[i].state=p->jobid;
				Ptp2->block=memsize[i].blockid;
				Ptp2=Ptp2->next;
				j++;
				if(j==p->memorysize) break;
			}
		}

		//创进进程
		Pcbp=new Pcb;
		Pcbp->cputime=p->runtime;
		Pcbp->id=p->jobid;
        Pcbp->priority=(int)p->rp;
		Pcbp->state="ready";
		PcbHead=OnInsert(PcbHead,Pcbp);

		p->rp=0;
		p->waittime=0;
		p->state="run";
		p=p->next;
	}	
}

//回收内存
void CModelosysDlg::OnBackmemory(Pcb *info)
{
	Jt* Jtp=OnFindJt(JtHead,info);
	Pt* Ptp=OnFindPt(PtHead,Jtp),*Ptp1;
	Memorysize=Memorysize+Jtp->ptlength;
	for(int k=0;k<Jtp->ptlength;k++)
	{
		for(int j=0;j<64;j++) //修改内存表
		{
			if(memsize[j].blockid==Ptp->block)
				memsize[j].state=0;
		}
		Ptp1=Ptp; //修改Pt表
        Ptp=Ptp->next;
		PtHead=OnDeletePt(PtHead,Ptp1);
	}
	JtHead=OnDeleteJt(JtHead,Jtp);  //修改Jt表
}

//取Jt表的队尾结点
Jt* CModelosysDlg::OnGetJtTail(Jt *head)
{
	Jt *p=head;
	while(p!=NULL)
    {
		if(p->next==NULL)
			break;
		p=p->next;
	}
	return p;
}

//在Jt表的队尾加入结点
Jt* CModelosysDlg::OnInsertJtTail(Jt *head,Jt *info)
{
	Jt *p=OnGetJtTail(head);
	if(p==NULL)
	{
		head=info;
		head->next=NULL;
	}
	else
	{
		p->next=info;
		info->next=NULL;
	}
	return head;
}

//取Pt表的队尾结点
Pt* CModelosysDlg::OnGetPtTail(Pt *head)
{
	Pt *p=head;
	while(p!=NULL)
    {
		if(p->next==NULL)
			break;
		p=p->next;
	}
	return p;
}

//在Pt表的队尾加入结点
Pt* CModelosysDlg::OnInsertPtTail(Pt *head, Pt *info)
{
	Pt *p=OnGetPtTail(head);
	if(p==NULL)
	{
		head=info;
		head->next=NULL;
	}
	else
	{
		p->next=info;
		info->next=NULL;
	}
	return head;
}

//获取与Jt结点的地址相同的Pt的结点
Pt* CModelosysDlg::OnGetPt(Pt *head, Jt *info)
{
	Pt *p=head;
	while(p!=NULL&&p->address!=info->ptaddr)
	{
		p=p->next;
	}
	return p;
}

//根据Pcb表查Jt表
Jt* CModelosysDlg::OnFindJt(Jt *head, Pcb *info)
{
	Jt *p=head;
	while(p->jobid!=info->id)
		p=p->next;
	return p;
}

//删除指定的Jt结点
Jt* CModelosysDlg::OnDeleteJt(Jt *head, Jt *info)
{
	Jt *p1,*p;
	if(head->jobid==info->jobid)
	{
		p=head;
		head=head->next;
		delete p;
	}
	else
	{
		p1=head,p=head->next;
		while(p->jobid!=info->jobid)
		{
			p1=p;
			p=p->next;
		}
		p1->next=p->next;
		delete p;
	}
	return head;
}

//根据Pcb表查Jcb表
Jcb* CModelosysDlg::OnFindJcb(Jcb *head, Pcb *info)
{
	Jcb *p=head;
	while(p->jobid!=info->id)
		p=p->next;
	return p;
}

//根据Jt表查Pt表
Pt* CModelosysDlg::OnFindPt(Pt *head, Jt *info)
{
	Pt *p=head;
	while(p->address!=info->ptaddr)
		p=p->next;
	return p;
}

//删除指定的Pt结点
Pt* CModelosysDlg::OnDeletePt(Pt *head, Pt *info)
{
	Pt *p1,*p;
	if(head->address==info->address)
	{
		p=head;
		head=head->next;
		delete p;
	}
	else
	{
		p1=head,p=head->next;
		while(p->address!=info->address)
		{
			p1=p;
			p=p->next;
		}
		p1->next=p->next;
		delete p;
	}
	return head;
}

//在Pcb表的队尾找标志位结点
Pcb* CModelosysDlg::OnGetPcbFlag()
{
	Pcb* p=PcbHead,*p1=NULL;
	if(p==NULL) return NULL;
	while(p!=NULL)
	{
		p1=p;
		p=p->next;
	}
	if(p1->state=="finish") return p1;
	else return NULL;
}

//在Pcb表的队尾插入标志位结点
Pcb* CModelosysDlg::OnInsertPcbTailFlag(Pcb *PcbHead, Pcb *info)
{
	Pcb *p=PcbHead,*p1=NULL;
	if(p==NULL)
	{
		PcbHead=info;
		info->next=NULL;
		return PcbHead;
	}
	while(p!=NULL)
	{
		p1=p;
		p=p->next;
	}
	p1->next=info;
	info->next=NULL;
	return PcbHead;
}

//删除队尾的标志位
Pcb* CModelosysDlg::OnDeletePcbFlag()
{
	Pcb *p=PcbHead,*p1=NULL;
	if(p->next==NULL)
	{
		delete p;
		return NULL;
	}
	while(p->next!=NULL)
	{
		p1=p;
		p=p->next;
	}
	p1->next=NULL;
	delete p;
	return PcbHead;
}

//在表中找state="run"的结点
Pcb* CModelosysDlg::OnFindPcb()
{
	Pcb *p=PcbHead,*p1=NULL;
	while(p->next!=NULL)
	{
		if(p->state=="run") break;
		p1=p;
		p=p->next;
	}
	if(p->state=="run")
	{
		if(p==PcbHead)
			PcbHead=PcbHead->next;
		else
		    p1->next=p->next;
		return p;
	}
	else return NULL;
}

///////////////////////////////////////////////
//把链表倒个来排列
Jcb* CModelosysDlg::OnExchangeJcb(Jcb *head)
{
	Jcb* p=head,*p1=NULL;
	if(p==NULL) return NULL;
	while(p!=NULL)
	{
		head=head->next;
		p->next=p1;
		p1=p;
		p=head;
	}
	return p1;
}

//把链表倒个来排列
Jt* CModelosysDlg::OnExchangeJt(Jt *head)
{
	Jt* p=head,*p1=NULL;
	if(p==NULL) return NULL;
	while(p!=NULL)
	{
		head=head->next;
		p->next=p1;
		p1=p;
		p=head;
	}
	return p1;
}

//把链表倒个来排列
Pt* CModelosysDlg::OnExchangePt(Pt *head)
{
	Pt* p=head,*p1=NULL;
	if(p==NULL) return NULL;
	while(p!=NULL)
	{
		head=head->next;
		p->next=p1;
		p1=p;
		p=head;
	}
	return p1;
}

//把链表倒个来排列
Pcb* CModelosysDlg::OnExchangePcb(Pcb *head)
{
	Pcb* p=head,*p1=NULL;
	if(p==NULL) return NULL;
	while(p!=NULL)
	{
		head=head->next;
		p->next=p1;
		p1=p;
		p=head;
	}
	return p1;
}