OS课程设计---模拟处理机调度算法MFC实现

课程设计报告设计题目：处理机调度算法模拟实现班级:

学号：

姓名：

指导老师：

设计时间：2012年八月

摘要

1、主要算法包括：

先来先服务、短作业优先、高优先权优先、基于时间片的轮转、多级反馈队列调度算法。

2、内容要求：

1）定义与算法相关的数据结构，如进程控制块（PCB），相关队列（队列要考虑实际应用，应采用类似于类的私有成员定义所用到的队列，并使用公有函数提供对类的操作）；

2）所设计的系统中至少需要实现三种以上调度算法，且必须包含多级反馈队列调度算法；

3）提供用户选择功能，用户可以根据需要选择采用何种调度算法；

4）算法执行结构之后，应该给出周转时间和平均周转时间。

本系统模拟操作系统处理机调度算法的实现，实现了先来先服务、短作业优先、基于时间片的轮转、多级反馈队列调度算法四种调度算法的模拟实现，可以根据需要自行选择合适的调度算法，进程用PCB来控制，队列由PCB相链接而成，分为就绪队列，阻塞队列，完成队列。进程在在运行时可以随时挂起暂停进程执行，待条件满足后，继续恢复运行，进程在运行的时候优先权是不断的变化的，运行的时间越长，优先级会相应减小。

关键词：先来先服务，短作业优先，高优先权优先，基于时间片的轮转，

多级反馈队列调度算法。

目录

1.概述 (4)

2.课程设计任务及要求

2.1 设计任务 (4)

2.2 设计要求 (4)

3.算法及数据结构

3.1算法的总体思想（流程） (5)

3.2 PCB模块

3.2.1功能（运算） (5)

3.2.2数据结构（存储结构） (5)

3.2.3算法（实现） (5)

3.3 进程队列模块

3.3.1功能 (6)

3.3.2数据结构 (6)

3.3.3算法 (6)

4.程序设计与实现

4.1 程序流程图 (7)

4.2 程序说明（代码）

4.3实验结果 (10)

5.结论 (11)

6.参考文献。 (11)

7.收获、体会和建议。 (11)

一：概述

定义与算法相关的数据结构，模拟操作系统处理机调度算法的实现，至少实现3种以上算法，且必须包含多级反馈队列调度算法；提供用户选择功能，用户可以根据需要选择采用何种调度算法；算法执行结构之后，应该给出周转时间和平均周转时间。

二：课程设计任务及要求

设计任务：

使用Visual C++ 模拟实现处理机调度算法，实现先来先服务、短作业优先、基于时间片的轮转、多级反馈队列调度算法。

设计要求：

所设计的系统中至少需要实现三种以上调度算法，且必须包含多级反馈队列调度算法；提供用户选择功能，用户可以根据需要选择采用何种调度算法；

算法执行结构之后，应该给出周转时间和平均周转时间。

三：算法及数据结构

进程控制块数据结构和相应的操作。

class PCB

{

public:

PCB(void);

PCB(PCB&);

void Creat(CString ,int );

~PCB(void);

void Update(); //剩余时间与运行时间更新

CStringShowPro(); //返回进程信息

bool IsEnd(); //判断进行是否执行完成

void Dispose(); //锁定进程

bool IsLocked(); //判断进程是否锁住

void Terminal(); //强制终止进程函数

int GetServiceT(); //获得需要服务时间

float GetPrio(); //返回进程优先级

CStringGetCurTime(); //返回当前系统时间

CStringGetName(); //获取进程名称

void UpdateGoneTime(); //更新进程周转时间

int GetGoneTime(); //返回进程周转时间

int GetRuningTime(); //返回进程运行时间

private:

CStringName; //进程名称

CStringStart; //创建时间

int ServiceT; //需要服务时间

int RunningT; //已运行时间

int RemainT; //剩余时间

int GoneTime; //消逝时间|| 周转时间

int ID; //进程标识符

CStringReadyTime; //进程成为就绪进程的时间float prio; //进程优先权

int Locked; //进程锁

staticint count ; //计数

};

#include "StdAfx.h"

#include "PCB.h"

int PCB::count =0;

PCB::PCB(void)

{

RemainT=0; //标志对象初始化时没有值，相当于为空！

Locked=1;

GoneTime=0;

}

PCB::PCB(PCB &data)

{

Name=https://www.360docs.net/doc/ad6466767.html,;

Start=data.Start;

ServiceT=data.ServiceT;

RunningT=data.RunningT;

RemainT=data.RemainT;

ID=data.ID;

ReadyTime=data.ReadyTime;

prio=data.prio;

GoneTime=data.GoneTime;

Locked=0; //解锁

}

PCB::~PCB(void)

{

}

CString PCB::GetName()

{

return Name;

}

CString PCB::GetCurTime()

{

if (Locked==1)

{

return "";

}

//(CTime::GetCurrentTime()).Format("%H:%M:%S")

SYSTEMTIME TM;

::GetSystemTime(&TM);

CString tmp;

tmp.Format(" %d:%d:%d"

,(8+TM.wHour)%24,TM.wMinute,TM.wSecond);

return tmp;

}

int PCB::GetServiceT()

{

return ServiceT;

}

float PCB::GetPrio()

{

return prio;

}

void PCB::Creat(CString name , int needtime)

{

Locked=0; //默认为锁定Locked==1，创建需解锁！

Name = name;

Start = GetCurTime();

ServiceT = needtime;

RunningT=0;

RemainT=needtime;

ID=count;

count++;

if (count>100)

{

count=0;

}

ReadyTime=GetCurTime();

GoneTime=0;

prio =(float)RemainT/ ServiceT; }

void PCB::UpdateGoneTime()

{

if (Locked==1)

{

return ;

}

GoneTime++;

}

void PCB::Update()

{

if (Locked==1)

{

return ;

}

RunningT++;

if (RemainT>0)

{

RemainT--;

}

prio =(float) RemainT/ ServiceT; }

void PCB::Dispose()

{

Locked=1;

}

CString PCB::ShowPro()

{

if (Locked==1)

{

return "";

}

CString tmp ;

tmp.Format("进程名:%s,进程ID:%d,创建时间:%s,需要时间:%d,已运行时间:%d,剩余时间:%d,优先权:%f",Name,ID,ReadyTime,ServiceT,RunningT,RemainT,prio);

return tmp;

}

bool PCB::IsEnd()

{

if (RemainT<=0)

{

return true;

}

else

{

return false;

}

}

bool PCB::IsLocked()

{

if (Locked==1)

return true;

else

return false;

}

void PCB::Terminal() {

RemainT=0;

}

int PCB::GetGoneTime() {

return GoneTime;

}

int PCB::GetRuningTime() {

return RunningT;

}

进程队列的数据结构

struct Node

{

PCBData;

Node*next;

};

class Queue

{

public:

Queue();

~Queue();

bool IsEmpty(); //判断队列是否为空void Enqueue(PCB); //进程入队

void Dequeue(); //进程出队

int GetLength(); //获取队列进程数CStringPrint(); //遍历进程信息void Update(); //进程时间更新

void UpdateGoneTime(); //更新队列中进程周转时间PCBGetFirst(); //获取队列中第一个进程void LeastFirst(); //按进程服务时间排序队列void Clear(); //队列删除

CStringGetGoneTime(); //返回进程周转时间

Node *GetFirstPtr(); //获取队列头指针private:

Node *first;

};

#include "StdAfx.h"

#include "Queue.h"

Queue::Queue()

{

first = new Node;

first->next =NULL;

}

Queue::~Queue()

{

}

//template

bool Queue::IsEmpty()

{

if (first->next == NULL)

return true;

else

return false;

}

//template

void Queue::Enqueue(PCB data) {

Node *s = new Node;

s->Data =data;

Node *p; //work Ptr

p = first;

while(p->next)

{

p=p->next;

}

p->next =s;

s->next =NULL;

}

//template

void Queue::Dequeue()

{

first->next = first->next->next; }

int Queue::GetLength()

{

int count =0;

Node *p =first->next;

while(p)

{

count++;

p=p->next;

}

return count;

}

CString Queue::Print()

{

Node *p=first;

int n =GetLength();

CString tmp ="";

for (int i=0;i

{

tmp+=p->next->Data.ShowPro();

tmp+="\r\n";

p=p->next;

}

return tmp;

}

PCB Queue::GetFirst()

{

PCB tmp = first->next->Data;

Dequeue();

return tmp;

}

void Queue::Update()

{

Node *p =first->next;

while(p)

{

p->Data.Update();

p=p->next;

}

}

void Queue::UpdateGoneTime()

{

Node *p =first->next;

while(p)

{

p->Data.UpdateGoneTime();

p=p->next;

}

}

void Queue::LeastFirst()

{

Node *p=NULL;

Node *q=NULL;

if(first->next==NULL)

{

return;

}

for(p=first->next;p->next;p=p->next)

for (q=p->next;q;q=q->next)

{

if (p->Data.GetServiceT()>q->Data.GetServiceT())

{

PCB tmp;

tmp=p->Data;

p->Data=q->Data;

q->Data=tmp;

}

}

}

void Queue::HighPrio()

{

Node *p=NULL;

Node *q=NULL;

for(p=first->next;p->next;p=p->next)

for (q=p->next;q;q=q->next)

{

if (p->Data.GetPrio()>q->Data.GetPrio())

{

PCB tmp;

tmp=p->Data;

p->Data=q->Data;

q->Data=tmp;

}

}

}

void Queue::Clear()

{

while(first->next!=NULL)

{

Node *tmp=first->next;

first->next=tmp->next;

delete tmp;

}

}

CString Queue::GetGoneTime()

{

CString tmp;

CString Ret;

Node *p =first->next;

int time=0;

while(p)

{

tmp.Format("进程名:%s,周转时间:%d\r\n",p->Data.GetName(),p->Data.GetGoneTime());

time+=p->Data.GetGoneTime();

Ret+=tmp;

p=p->next;

}

tmp.Format("平均周转时间：%.2f",(float)(time/GetLength()));

Ret+=tmp;

return Ret;

}

Node* Queue::GetFirstPtr()

{

return first;

}

四：程序设计与实现。

流程图

先来先服务调度短进程优先调度

多级反馈队列调度