jcbview.cpp

本程序使用VC++6.0主要完成操作系统的作业调度包括时间片轮转法,先进现出算法

// JCBView.cpp : implementation of the CJCBView class
//

#include "stdafx.h"
#include "JCB.h"

#include "JCBDoc.h"
#include "JCBView.h"

#include "JCBDlg.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif


extern int StartTime;
extern int Jobs;
extern TJCB Tjobs[];
extern int Queue[];
extern int Stack[];
extern int rTime;
extern int RunTime;

/////////////////////////////////////////////////////////////////////////////
// CJCBView

IMPLEMENT_DYNCREATE(CJCBView, CView)

BEGIN_MESSAGE_MAP(CJCBView, CView)
	//{{AFX_MSG_MAP(CJCBView)
	ON_WM_TIMER()
	ON_COMMAND(ID_MENUEDIT, OnMenuEdit)
	ON_COMMAND(ID_FCFS, OnFCFS)
	ON_COMMAND(ID_SJF, OnSJF)
	ON_COMMAND(ID_PRI, OnPri)
	//}}AFX_MSG_MAP
	// Standard printing commands
	ON_COMMAND(ID_FILE_PRINT, CView::OnFilePrint)
	ON_COMMAND(ID_FILE_PRINT_DIRECT, CView::OnFilePrint)
	ON_COMMAND(ID_FILE_PRINT_PREVIEW, CView::OnFilePrintPreview)
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// CJCBView construction/destruction

CJCBView::CJCBView()
{
	// TODO: add construction code here
	px=50;
	dx=50;
	fx=0;
	BrushNO=0;
}

CJCBView::~CJCBView()
{
}

BOOL CJCBView::PreCreateWindow(CREATESTRUCT& cs)
{
	// TODO: Modify the Window class or styles here by modifying
	//  the CREATESTRUCT cs

	
	return CView::PreCreateWindow(cs);
}

/////////////////////////////////////////////////////////////////////////////
// CJCBView drawing

void CJCBView::OnDraw(CDC* pDC)
{
	CJCBDoc* pDoc = GetDocument();
	ASSERT_VALID(pDoc);
	// TODO: add draw code for native data here
//	double dx1,dTime;
	int px1;
	CString msg;
	CRect rRect;
	CBrush rBrush;

//	if(px>=649)
//		px=51;
	rRect.top=151;
	rRect.bottom=199;
	rRect.left=dx;
	rRect.right=px;
	pDC->Draw3dRect(50,150,601,50,0x00,0x00);
	pDC->SetBkColor(0x00F0F000);
	rBrush.CreateSolidBrush(Tjobs[BrushNO].ColorRGB);
	pDC->FillRect(LPCRECT(rRect),&rBrush);

	if (Jobs==0)
		return;
//	dTime=(double(RunTime)*(double(px)-50))/600+0.75;	//调节
//	rTime=(int)dTime;
//	rTime=RunTime*px;
//	rBrush.CreateSolidBrush(Tjobs[i].ColorRGB);
	for (int i=0;i<Jobs;i++)
	{
		if (Tjobs[i].StartPos==px)
		{
			Tjobs[i].IsStart=TRUE;
			dx=px;	//调节
			BrushNO = i ;

		}
		if (Tjobs[i].InputPos==px)
		{
			Tjobs[i].IsInput=TRUE;
		
		}
		if (Tjobs[i].EndPos==px)
		{
			Tjobs[i].IsFinish=TRUE;
		}
	}

	for (i=0;i<Jobs;i++)
	{
		if (Tjobs[i].IsInput==TRUE)
		{
//			dx1=(600/(double)RunTime)*(double)(Tjobs[i].InputTime-StartTime)+50;
			px1=Tjobs[i].InputPos-1;

			if(Tjobs[i].InputMinute < 10)
				msg.Format("作业%d在%d:0%d输入",Tjobs[i].NO ,Tjobs[i].InputHour ,Tjobs[i].InputMinute );
			else
				msg.Format("作业%d在%d:%d输入",Tjobs[i].NO ,Tjobs[i].InputHour ,Tjobs[i].InputMinute );

			pDC->MoveTo(px1,150);
			pDC->LineTo(px1,Tjobs[i].NO*20);
			pDC->TextOut (px1+2,Tjobs[i].NO*20,_T(msg));
		}
		if (Tjobs[i].IsStart==TRUE)
		{
//			dx1=(600/(double)RunTime)*(double)(Tjobs[i].StartTime-StartTime)+50;
			px1=Tjobs[i].StartPos-1;

			if(Tjobs[i].StartMinute  < 10)
				msg.Format("作业%d在%d:0%d开始",Tjobs[i].NO ,Tjobs[i].StartHour  ,Tjobs[i].StartMinute  );
			else
				msg.Format("作业%d在%d:%d开始",Tjobs[i].NO ,Tjobs[i].StartHour  ,Tjobs[i].StartMinute  );

			pDC->MoveTo(px1,151);
			pDC->LineTo(px1,Tjobs[i].NO*20+185);
			pDC->TextOut(px1+2,Tjobs[i].NO*20+185,_T(msg));

		}
		if (Tjobs[i].IsFinish==TRUE)
		{
			rRect.top=151;
			rRect.bottom=199;
			rRect.left=Tjobs[i].StartPos;
			rRect.right=Tjobs[i].EndPos;
			rBrush.DeleteObject();		//Debug通过
			rBrush.CreateSolidBrush(Tjobs[i].ColorRGB);
			pDC->FillRect(LPCRECT(rRect),&rBrush);		
		}
	}


	if (px<650)
		px++;
	else
	{
		
		if(Tjobs[Jobs].FinishTime%60 < 10)
			msg.Format("全部作业在%d:0%d结束",Tjobs[Jobs].FinishTime/60  ,Tjobs[Jobs].FinishTime%60  );
		else
			msg.Format("全部作业在%d:%d结束",Tjobs[Jobs].FinishTime/60  ,Tjobs[Jobs].FinishTime%60  );


		pDC->MoveTo(650,150);
		pDC->LineTo(650,227);
		pDC->TextOut (652,205,_T(msg));

		double du1;
		du1=(double)fx/(double)Jobs;
		msg.Format("平均周转时间%7.2f分钟",du1);

		pDC->TextOut (652,222,_T(msg));

		KillTimer(1);
	}

}

/////////////////////////////////////////////////////////////////////////////
// CJCBView printing

BOOL CJCBView::OnPreparePrinting(CPrintInfo* pInfo)
{
	// default preparation
	return DoPreparePrinting(pInfo);
}

void CJCBView::OnBeginPrinting(CDC* /*pDC*/, CPrintInfo* /*pInfo*/)
{
	// TODO: add extra initialization before printing
}

void CJCBView::OnEndPrinting(CDC* /*pDC*/, CPrintInfo* /*pInfo*/)
{
	// TODO: add cleanup after printing
}

/////////////////////////////////////////////////////////////////////////////
// CJCBView diagnostics

#ifdef _DEBUG
void CJCBView::AssertValid() const
{
	CView::AssertValid();
}

void CJCBView::Dump(CDumpContext& dc) const
{
	CView::Dump(dc);
}

CJCBDoc* CJCBView::GetDocument() // non-debug version is inline
{
	ASSERT(m_pDocument->IsKindOf(RUNTIME_CLASS(CJCBDoc)));
	return (CJCBDoc*)m_pDocument;
}
#endif //_DEBUG

/////////////////////////////////////////////////////////////////////////////
// CJCBView message handlers

void CJCBView::OnTimer(UINT nIDEvent) 
{
	// TODO: Add your message handler code here and/or call default
	InvalidateRect(NULL);
	CView::OnTimer(nIDEvent);
}


//
//	First Come First Serve
//
//
int jFCFS(TJCB Fjobs[],int nJobs)
{
	int p,j,k,g,u1;		//	
	int e,d;		//	排序用变量

//	int tMAX;
	int tStartTime,tEndTime,tTemp;
	
	int PrinterNO=4;
	int TapeNO=3;
	int MEMvol=100;

//	char msg[50];
	
	p=0;
	j=0;
	k=0;
	g=0;

	tStartTime = Fjobs[0].InputTime - 1;
	tEndTime = Fjobs[0].InputTime + 1;
	tTemp = Fjobs[0].InputTime ;
		
	PrinterNO = 4 ;//- Fjobs[0].ReqPrinter ;
	TapeNO = 3 ;//- Fjobs[0].ReqTape ;
	MEMvol = 100 ;//- Fjobs[0].ReqMEM ;

	Fjobs[0].StartTime = Fjobs[0].InputTime ;
//	Fjobs[0].FinishTime = Fjobs[0].StartTime + Fjobs[0].ReqTime ;


	
	while (p<nJobs)
	{
		//	顺序处理
		g = 0;
		k = 0;
		while (g<nJobs)
		{
			if (Fjobs[g].InputTime > tStartTime && Fjobs[g].InputTime <= tEndTime)
			{
				if (Fjobs[g].ReqMEM <= MEMvol && Fjobs[g].ReqPrinter <= PrinterNO)
				{
					Queue[j]=g;
					Fjobs[g].StartTime = tTemp;
					Fjobs[g].FinishTime = Fjobs[g].StartTime + Fjobs[g].ReqTime ;
					tTemp = Fjobs[g].FinishTime ;
					j++;
		
					PrinterNO = 4 - Fjobs[g].ReqPrinter ;
					TapeNO = 3 - Fjobs[g].ReqTape ;
					MEMvol = 100 - Fjobs[g].ReqMEM ;

				}
				else
				{
					Stack[k]=g;
					k++;
				}
			}
			g++;
		}


		tStartTime = Fjobs[p].StartTime ;
		tEndTime = Fjobs[p].FinishTime ;
		//	


//	char msg[50];
//	sprintf (msg,"Queue=%d,%d,%d,%d,%d,Stack=%d,%d,%d,%d,%d",Queue[0],Queue[1],Queue[2],Queue[3],Queue[4],Stack[0],Stack[1],Stack[2],Stack[3],Stack[4]);
//	AfxMessageBox(_T(msg));
//	sprintf (msg,"[0].Start=[%d],[0].Fininsh=[%d],k=[%d]",Fjobs[0].StartTime,Fjobs[0].FinishTime,k );
//	AfxMessageBox(_T(msg));

		
		//
		g=0;
		while (g<k)
		{
					PrinterNO = 4 ;					
	
					TapeNO = 3 ;
					MEMvol = 100 ;
			d=g;
			while (d<k)
			{
				u1=Stack[d];
				if (Fjobs[u1].ReqMEM <= MEMvol && Fjobs[u1].ReqPrinter <= PrinterNO)
				{

					PrinterNO = 4 - Fjobs[u1].ReqPrinter ;
					TapeNO = 3 - Fjobs[u1].ReqTape ;
					MEMvol = 100 - Fjobs[u1].ReqMEM ;
					e=d;
					u1=Stack[d];
					while (e>g+1)
					{
						Stack[e]=Stack[e-1];
						e--;
					}
					Stack[e]=u1;
//	sprintf (msg,"Queue=%d,%d,%d,%d,%d,Stack=%d,%d,%d,%d,%d",Queue[0],Queue[1],Queue[2],Queue[3],Queue[4],Stack[0],Stack[1],Stack[2],Stack[3],Stack[4]);
//	AfxMessageBox(_T(msg));
//	sprintf (msg,"g=[%d],d=[%d],e=[%d],k=[%d]",g,d,e,k );
//	AfxMessageBox(_T(msg));
				}
				d++;
			}
			g++;

		}

		//	Stack处理
		g=0;
		while (g<k)
		{
			Queue[j]=Stack[g];
			u1=Stack[g];
			Fjobs[u1].StartTime = tTemp;
			Fjobs[u1].FinishTime = Fjobs[u1].StartTime + Fjobs[u1].ReqTime ;
			tTemp = Fjobs[u1].FinishTime ;
			j++;
			g++;
	
		}
		k=0;
		//

		p++;
	}
	
	return 0;
}

//	================================================================================
//
//	Shortest Job First
//
//	================================================================================
int jSJF(TJCB Fjobs[],int nJobs)
{
	int p,j,k,g,u1;		//	
	int e,d,i,b;		//	排序用变量

//	int tMAX;
	int tStartTime,tEndTime,tTemp;
	
	int PrinterNO=4;
	int TapeNO=3;
	int MEMvol=100;

//	char msg[50];
	
	p=0;
	j=0;
	k=0;
	g=0;

	tStartTime = Fjobs[0].InputTime - 1;
	tEndTime = Fjobs[0].InputTime + 1;
	tTemp = Fjobs[0].InputTime ;
		
	PrinterNO = 4 ;//- Fjobs[0].ReqPrinter ;
	TapeNO = 3 ;//- Fjobs[0].ReqTape ;
	MEMvol = 100 ;//- Fjobs[0].ReqMEM ;

	Fjobs[0].StartTime = Fjobs[0].InputTime ;
//	Fjobs[0].FinishTime = Fjobs[0].StartTime + Fjobs[0].ReqTime ;


	
	while (p<nJobs)
	{
		//	顺序处理
		g = 0;
		k = 0;
		while (g<nJobs)
		{
			if (Fjobs[g].InputTime > tStartTime && Fjobs[g].InputTime <= tEndTime)
			{
				if (Fjobs[g].ReqMEM <= MEMvol && Fjobs[g].ReqPrinter <= PrinterNO)
				{
					Queue[j]=g;
					Fjobs[g].StartTime = tTemp;
					Fjobs[g].FinishTime = Fjobs[g].StartTime + Fjobs[g].ReqTime ;
					tTemp = Fjobs[g].FinishTime ;
					j++;
		
					PrinterNO = 4 - Fjobs[g].ReqPrinter ;
					TapeNO = 3 - Fjobs[g].ReqTape ;
					MEMvol = 100 - Fjobs[g].ReqMEM ;

				}
				else
				{