模拟实现操作系统调度算法

  之前学习操作系统的时候对操作系统的一些调度算法比较感兴趣，所以自己模拟实现了一下操作系统算法的调度，我主要模拟实现了短作业优先和先来先服务调度算法。代码有点长，加上测试代码估计有300行左右吧，放在这里的话看起来也不方便（算了，还是放在下面吧，免得看的人觉得麻烦）。我先把实现的结果截图放在下面吧，然后再附上代码，其实在我的github上面也有这些代码的，地址： https://github.com/admin-zou/DS/tree/master/scheduling







头文件： //scheduling.h

#ifndef _SCHEDULING_
#define _SCHEDULING_

#include <iostream>
#include <stdlib.h>
using namespace std;

enum Tag{UNSHD,SHD}; //标记是否被调度过

struct PCB
{
int      pcbid;			//进程号
size_t  arrtime;			//到达时间
size_t  sertime;			//服务时间
size_t  begtime;			//开始时间
size_t  endtime;			//完成时间
size_t  turntime;		//周转时间
float    weighttime;		//带权周转时间
PCB *   next;			//指向下个节点的指针
Tag     tag;				//标记是否被调度过

PCB(int n=0,size_t a=0,size_t s=0)
:pcbid(n),arrtime(a),sertime(s),begtime(0),endtime(0)
,turntime(0),weighttime(0),next(NULL),tag(UNSHD)
{}
};

class scheduling
{
public:
scheduling():_curtime(0),_tasknum(0)
{
_head = new PCB();
}

/////先来先服务算法
void FIFS()
{
if(empty())
{
cout<<"没有任务";
exit(-1);
}
_clear();  //清理一下，可重复计算
_sort_t(); //按到达时间排序
PCB* cur = _head->next;
while(NULL != cur)
{
if(_curtime < cur->arrtime)
{
_curtime = cur->arrtime;
}
cur->begtime = _curtime;
cur->endtime = _curtime + cur->sertime;		//完成时间等于开始时间加服务时间
cur->turntime = cur->endtime - cur->arrtime;	 //周转时间=完成时间-到达时间
cur->weighttime  = (float)cur->turntime / (float)cur->sertime;  //带权周转时间=周转时间/服务时间
cur->tag = SHD; //标记为已经服务
_curtime += cur->sertime;
cur = cur->next;
}
}

/////短作业

void Short()
{
if (empty())
{
cout << "没有任务";
exit(-1);
}
_clear();  //清理一下，可重复计算
_sort_t(); //按到达时间排序

PCB* cur = _head->next;
while (NULL != cur)
{
if (_curtime < cur->arrtime)
{
_curtime = cur->arrtime;
}
cur->begtime = _curtime;
cur->endtime = _curtime + cur->sertime;		//完成时间等于开始时间加服务时间
cur->turntime = cur->endtime - cur->arrtime;	 //周转时间=完成时间-到达时间
cur->weighttime = (float)cur->turntime / (float)cur->sertime; //带权周转时间=周转时间/服务时间
cur->tag = SHD; //标记为已经服务
_curtime += cur->sertime;
cur = cur->next;

//将该进程调度完的时刻已经到达的进程按短作业优先排序
_sort_l(cur,_curtime);  //从该进程开始进行短作业排序

}
}

void Init_task()
{
int tasknum=0;
size_t id=0;
size_t atime=0;
size_t stime=0;
cout<<"请输入任务的个数:";
cin>>tasknum;
for(int i = 0; i<tasknum;i++)
{
cout<<"请分别输入任务的编号,到达时间,运行时间:";
cin>>id>>atime>>stime;
push(id,atime,stime);
}
}

void Push()
{
size_t id=0;
size_t atime=0;
size_t stime=0;
cout<<"请分别输入任务的编号,到达时间,运行时间:";
cin>>id>>atime>>stime;
push(id,atime,stime);
}

void Print()
{
if(empty())
return ;
PCB* cur = _head->next;
printf("进程号 到达时间 服务时间 开始时间 完成时间 周转时间 带权周转时间 \n");
while(NULL != cur)
{
printf("%4d %6d %8d %9d %7d  %8d\t %0.2f\n",cur->pcbid, cur->arrtime ,cur->sertime ,cur->begtime, cur->endtime ,cur->turntime ,cur->weighttime);
cur = cur->next;
}
}

protected:
bool empty()
{
return _tasknum == 0;
}

bool push(int n,size_t a,size_t s) //插入到链表尾部
{
PCB * newtask = new PCB(n,a,s);
PCB * cur = _head;
while(NULL != cur->next)
cur =cur->next;
cur->next=newtask;
_tasknum++;
return true;
}

void _clear()
{
if(empty())
return ;
PCB* cur = _head->next;
while(NULL != cur)
{
cur->begtime = 0;
cur->endtime = 0;
cur->turntime = 0;
cur->weighttime = 0;
cur->tag = UNSHD;
cur = cur->next ;
}
_curtime = 0;
}

// 按照到达时间排序
void _sort_t()
{
if(empty() || _tasknum == 1)
return;
PCB* prev = _head->next;
PCB* cur = prev->next;
for(int i = 0; i< _tasknum-1; i++)
{
for(int j = 0; j<_tasknum-i-1; j++)
{
if (prev->arrtime > cur->arrtime)
{
_Swap(prev, cur);
}
prev = cur;
cur = cur->next;
}
prev=_head->next;
cur = prev->next;
}
}

// 按照作业长短排序
void _sort_l(PCB*& head,size_t curtime)
{
if (NULL == head || NULL == head->next)
return;
PCB* prev = head;
PCB* cur = prev->next;
int size = 0;  //计算进程的数目
PCB* tmp = head;
while (tmp)
{
++size;
tmp = tmp->next;
}

for (int i = 0; cur->arrtime < curtime && i < size - 1; i++)
{
if (prev->arrtime > curtime)
{//作业还没到达就不排序
return;
}
for (int j = 0; j < size - i - 1; j++)
{
if (cur && cur->arrtime <= curtime)
{
int ptime = prev->sertime;
int ctime = cur->sertime;
if (ptime > ctime)
{
_Swap(prev, cur);
}
}
prev = cur;
cur = cur->next;
}
prev = head;
cur = prev->next;
}
}

void _Swap(PCB * prev,PCB * cur)
{
swap(prev->arrtime,cur->arrtime);
swap(prev->pcbid ,cur->pcbid );
swap(prev->sertime ,cur->sertime );
}

private:
PCB *	_head;
size_t  _curtime;
size_t  _tasknum;	//作业个数
};

#endif

测试文件：

#define	_CRT_NOWANRINGS
#include"scheduling.h"

int main()
{
int select=1;
scheduling mytask;
while(select)
{
cout<<"****************************"<<endl;
cout<<"*   1.初始化               *"<<endl;
cout<<"*   2.新插入一个进程       *"<<endl;
cout<<"*   3.先来先服务调度算法   *"<<endl;
cout<<"*   4.短作业调度算法       *"<<endl;
cout<<"*   5.显示调度情况         *"<<endl;
cout<<"*   0.退出                 *"<<endl;
cout<<"****************************"<<endl;
int item=0;
cout<<"请输入:";
cin>>select;
switch(select)
{
case 1:
mytask.Init_task();
break;
case 2:
mytask.Push();
break;
case 3:
mytask.FIFS();
break;
case 4:
mytask.Short();
break;
case 5:
mytask.Print();
cout << endl;
break;
default:
break;
}
}
return 0;
}

//测试条件
/*
5
1 0 4
2 2 4
3 3 3
4 5 6
5 6 3
*/

   总结：

       1.上面的程序基于是我对操作系统调度算法的理解所写出来的，主要模拟了先来先服务和短作业优先调度两种调度算法，其中涉及到了c++，数据结构以及操作系统和算法等方面的只是，实现它确实大有所益。

       2.在上面的小项目中我是通过计算出各种调度算法的周转时间，带权周转时间等等来评价调度算法的效率的，能够在一定范围内评估调度算法的性能，以及某些场景适合于使用哪种调度算法。

      3.我是通过单链表来组织相关的作业的调度需要的数据的，这样确实有好处，也有缺陷，这和链表的优缺点相对应。不过在数据量较小的时候还是很不错的。

    其中主要的难点在于很难分析出所有可能出现的情况，以及各种情况下的行为。还有就是，需要对操作系统的调度算法有一定的理解，否则就容易出现于实际不符的结果，比如说短作业优先调度，怎样理解这种调度方式呢，我举个例子吧：一开始时只有一个作业在调度，但是其所需时间比较长，在他执行过程中来了其他作业，但是作业时间很短，先调度这个短作业可能会更优，那么我们需要怎么处理呢，这就涉及到了是否允许抢占资源的问题（当然在我的实现中是不可抢占资源的）。最后说明一下在开发的时候一定要多调试，减少bug，增加程序的健壮性。