一、实验目的
在采用多道程序设计的系统中,往往有多个进程同时处于就绪状态。当就绪进程个数大于处理器个数时,就必须按照某种策略来决定哪些进程优先占用处理器。本实验模拟在单处理器情况下的处理器调度,加深了解处理器调度的工作。
二、实验原理与内容
1. 实验原理
(1) 先来先服务
按照作业到达时间确定。进程的优先级按作业的到达时间以此排队,使得到达时间早的作业具有较高的优先级。
(2) 静态优先级算法
按照用户给出的优先级进行依次排队,使用户规定的优先级高的作业,具有较高的优先级。
(3) 静态时间片轮转法
将处理的进程按照时间顺序进行排队,规定一段执行时间该时间称为时间片。当该进程用完这一时间片时,系统将它送至就绪队列队尾,又把处理机分配给下一进程,再执行同样大小的时间片。这样,就绪队列中的所有进程,就可以依次轮流获得一个时间片的处理时间,然后系统又回到队列的开始部分。如此不断循环。
2.实验内容
设计一个程序,根据不同的调度算法模拟操作系统对进程的调度。
先来先到算法;静态优先级算法;静态时间片轮转算法
二、实验过程
实验代码如下:
#include <iostream>
#include <queue>
#include <algorithm>
#include <cstdio>
#include <cstring>
using namespace std;
struct text
{
int num; //进程数
char text[100]; //进程名称
double arr[100]; //到达时间
double pri[100]; //优先级
double revser[100]; //服务时间
double str[100]; //开始时间
double finsh[100]; //结束时间
double turn[100]; //周转时间
double weight_turn[100] ; //带权周转时间
double last[100]; //剩余时间
double ser_last[100];
}TEX;
void input() //输入
{
int i;
printf("输入进程数量\n");
scanf("%d",&TEX.num);
printf("输入进程名称,到达时间,服务时间,优先级\n");
for(i = 0; i < TEX.num ; i++ )
{
cin>>TEX.text[i];
cin>>TEX.arr[i];
cin>>TEX.revser[i];
cin>>TEX.pri[i];
}
}
void output(int i)
{
cout<<"进程名称\t到达时间\t服务时间\t优先级\t开始时间\t结束时间\t周转时间\t带权周转时间\n";
cout<<TEX.text[i]<<"\t\t"<<TEX.arr[i]<<"\t\t"<<TEX.revser[i]<<"\t\t"<<TEX.pri[i]<<"\t"<<TEX.str[i]<<"\t\t"<<TEX.finsh[i]<<"\t\t"<<TEX.turn[i]<<"\t\t"<<TEX.weight_turn[i]<<"\n";
}
void output1(int i)
{
cout<<"进程名称\t到达时间\t已服务时间\t剩余时间\n";
cout<<TEX.text[i]<<"\t\t"<<TEX.arr[i]<<"\t\t"<<TEX.ser_last[i]<<"\t\t"<<TEX.last[i]<<"\n";
}
void output2(int i)
{
cout<<"正在运行的程序: ";
cout<<TEX.text[i]<<"\n";
}
void FCFS() //先来先到
{
int i,j;
double start;
double end;
double point;
input();
start = 0;
end = 0;
for(i = 0 ; i < 100 ; i++)
{
for(j = 0 ; j < TEX.num ; j++)
{
if(TEX.arr[j] == i)
{
if(end <= TEX.arr[j]) //下个进程到达预计
{
start = TEX.arr[j];
end = start + TEX.revser[j];
}
else
{
start = end;
end = TEX.revser[j] + start;
}
TEX.str[j] = start;
TEX.finsh[j] = end;
TEX.turn[j] = TEX.finsh[j] - TEX.arr[j];
TEX.weight_turn[j] = TEX.turn[j]/TEX.revser[j];
output(j);
}
}
}
}
void CIS() //固定优先级
{
int i,j;
double start;
double end;
double point;
input();
start = 0;
end = 0;
for(i = 0 ; i < 100 ; i++)
{
for(j = 0 ; j < TEX.num ; j++)
{
if(TEX.pri[j] == i)
{
if(end <= TEX.arr[j]) //下个进程到达预计
{
start = TEX.arr[j];
end = start + TEX.revser[j];
}
else
{
start = end;
end = TEX.revser[j] + start;
}
TEX.str[j] = start;
TEX.finsh[j] = end;
TEX.turn[j] = TEX.finsh[j] - TEX.arr[j];
TEX.weight_turn[j] = TEX.turn[j]/TEX.revser[j];
output(j);
}
}
}
}
void FCFSS() //时间片
{
int time=3;
int i,j,k,m,n,o;
double start;
double end;
int point;
double a_arr[100];
input();
start = 0;
end = 0;
k = 0;
for(i = 0 ; i < 100 ; i++) //进程排序
{
for(j = 0 ; j < TEX.num ; j++)
{
if(TEX.arr[j] == i)
{
a_arr[k] = j;
k++;
}
}
}
k=0;o=0;n=TEX.num;point=a_arr[0];start=TEX.arr[point];end=start;m=point; //数据初始化
for(i=0;i<TEX.num;i++)
{
TEX.last[i]=TEX.revser[i];
}
for(i = 0 ; i < 500 ; i++)
{
output2(m);
if(i<TEX.num) //接受进程
{
TEX.str[m]=start;
TEX.last[m]=TEX.revser[m];
}
if(TEX.last[m]<=3) //进程判断
{
TEX.finsh[m]=start+TEX.last[m];
TEX.ser_last[m]=TEX.ser_last[m]+TEX.last[m];
TEX.last[m]=0;
for(j=0;j<n-o;j++)
{
a_arr[o+j]=a_arr[o+j+1];
}
output1(m);
n--;
o--;
}
start=start+3; //时间加3
if(TEX.last[m]>3)
{
TEX.ser_last[m]=TEX.ser_last[m]+3;
TEX.last[m]=TEX.last[m]-3;
TEX.finsh[m]=TEX.str[m]+3;
}
for(k=0;k<n;k++) //打印
{
point=a_arr[k];
output1(point);
}
cout<<n;
cout<<"\n"<<"\n";
o++;
if(o==n)
{
o=0;
}
m=a_arr[o];
if(n==0)
{
break;
}
}
for(i=0;i<TEX.num;i++) //打印
{
output(i);
}
}
int main()
{
int a;
cout<<"请选择服务:"<<endl<<"1.先来先服务算法"<<endl<<"2.静态优先级服务算法"<<endl<<"3.静态时间片轮转"<<endl<<"4.退出"<<endl;
while(a<4)
{
cout<<"please input serve:";
cin>>a;
switch(a)
{
case(1):FCFS();break;
case(2):CIS();break;
case(3):FCFSS();break;
default:break;
}
}
*程序运行结果如下:
(1)先来先服务算法
(2)静态优先级算法
(3)时间片轮转法
四、实验总结
本次实验了解了多道进程的处理过程,进一步感受了CPU的运行,有利于我们更好的了解操作系统。
五、实验体会及改进建议
加强对算法及数据结构的了解,在实验过程中对于数据结构的不熟悉,导致我在实验过程中出现了很多问题。