时间片轮转调度算法实验报告

发布时间：2017-07-19 11:43:02

xx大学　操作系统　实验报告

姓名：学号：班级：

实验日期：

实验名称：时间片轮转RR进程调度算法

实验二时间片轮转RR进程调度算法

1. 实验目的：通过这次实验，理解时间片轮转RR进程调度算法的运行原理，进一步掌握进程状态的转变、进程调度的策略及对系统性能的评价方法。

2.需求分析

(1) 输入的形式和输入值的范围；

输入：进程个数n 范围：0

时间片q

依次输入（进程名

进程到达时间

进程服务时间）

(2) 输出的形式

所有进程平均周转时间：

所有进程平均带权周转时间：

(3) 程序所能达到的功能

1）进程个数n，输入时间片大小q，每个进程的到达时间T1, … ,Tn和服务时间S1, … ,Sn。

2）要求时间片轮转法RR调度进程运行，计算每个进程的周转时间和带权周转时间，并且计算所有进程的平均周转时间和带权平均周转时间；

3）输出：模拟整个调度过程，输出每个时刻的进程运行状态；

4）输出：输出计算出来的每个进程的周转时间、带权周转时间、所有进程的平均周转时间以及带权平均周转时间。

(4) 测试数据，包括正确的输入及其输出结果和含有错误的输入及其输出结果。

正确输入：

错误输入：

2、概要设计

所有抽象数据类型的定义：

static int MaxNum=100

int ArrivalTime//到达时间

int ServiceTime//服务时间

int FinishedTime//结束时间

int WholeTime//周转时间

double WeightWholeTime//带权周转时间

double AverageWT //平均周转时间

double AverageWWT //平均带权周转时间

主程序的流程:

● 变量初始化

● 接受用户输入的n，q ，T1…..Tn,S1….Sn;

● 进行进程调度，计算进程的开始运行时间、结束时间、执行顺序、周转时间、带权周转时间；

● 计算所有进程的平均周转时间、平均带权周转时间；

● 按照格式输出调度结果。

各程序模块之间的层次(调用)关系

Main函数通过对Input函数进行调用，对函数的成员变量进行赋值，再通过RRAlgorithm函数求出题目要求的各个数据结果，最后通过display函数对结果进行格式输出。

3、详细设计

实现程序模块的具体算法。

void RRAlgorithm()

{

char processMoment[100]; //存储每个时间片p对应的进程名称

RRqueue.push(RRarray[0]);

int processMomentPoint = 0;

int CurrentTime=0;

int tempTime; //声明此变量控制CurrentTime的累加时间，当前进程的服务时间小于时间片q的时候，起到重要作用

int i=1; //指向还未处理的进程的下标

int finalProcessNumber = 0; //执行RR算法后，进程的个数

int processTime[50];

//CurrentTime的初始化

if (RRarray[0].ServiceTime>=q)

{

CurrentTime = q;

}

else

{

CurrentTime = RRarray[0].ServiceTime;

}

while(!RRqueue.empty())

{

for (int j=i;j使得满足进程的到达时间小于当前时间的进程都进入队列

{

if (RRarray[j].name!=NULL && CurrentTime >= RRarray[j].ArrivalTime)

{

RRqueue.push(RRarray[j]);

i++;

}

if (RRqueue.front().ServiceTime

{

tempTime = RRqueue.front().ServiceTime;

}

else

{

tempTime = q;

}

RRqueue.front().ServiceTime -= q; //进程每执行一次，就将其服务时间 -q

//将队首进程的名称放入数组中

processMoment[processMomentPoint] = RRqueue.front().name;

processMomentPoint++;

processTime[finalProcessNumber] = tempTime;

finalProcessNumber++;

if (RRqueue.front().ServiceTime <= 0) //把执行完的进程退出队列

{

//RRqueue.front().FinishedTime = CurrentTime;

RRqueue.pop(); //如果进程的服务时间小于等于，即该进程已经服务完了，将其退栈

}

else

{

//将队首移到队尾

RRqueue.push(RRqueue.front());

RRqueue.pop();

}

CurrentTime += tempTime;

}

//进程输出处理每个时间段对应的执行的进程

cout<<"各进程的执行时刻信息："<

cout<<" "<<"0时刻 --> "<时刻";

processTime[finalProcessNumber]=0;

int time = processTime[0];

int count = 0;

for (i=0;i

{

count = 0;

cout<

while(RRarray[count].name!=processMoment[i] && count

{

count++;

}

RRarray[count].FinishedTime = time;

if (i

{

cout<时刻"<<" --> "<时刻"<

time += processTime[i+1];

}

cout<

//周转时间、带权周转时间、平均周转时间、带权平均周转时间的计算

//1. 周转时间 = 完成时间 - 到达时间

//2. 带权周转时间 = 周转时间/服务时间

for ( i=0;i

{

RRarray[i].WholeTime = RRarray[i].FinishedTime - RRarray[i].ArrivalTime;

RRarray[i].WeightWholeTime = (double)RRarray[i].WholeTime/RRarray[i].ServiceTime;

}

double x=0,y=0;

for (i=0;i

{

x += RRarray[i].WholeTime;

y += RRarray[i].WeightWholeTime;

}

AverageWT = x/n;

AverageWWT = y/n;

}

4、调试分析

（1）调试过程中遇到的问题以及解决方法，设计与实现的回顾讨论和分析

在算法设计时，由于一开始不知道如何将位于队首的进程，在执行完后如何移至队尾进行循环，所以思考了很久，后来想到将队首进程进行重新压入队列从而解决了此问题。

（2）算法的性能分析

每个进程被分配一个时间段，即该进程允许运行的时间。如果在时间片结束时进程还在运行，则CPU将被剥夺并分配给另一个进程。如果进程在时间片结束前阻塞或结束，则CPU当即进行切换。调度程序所要做的就是维护一张就绪进程列表，当进程用完它的时间片后，它被移到队列的末尾。

（3）经验体会

通过本次实验，深入理解了时间片轮转RR进程调度算法的思想，培养了自己的动手能力，通过实践加深了记忆。

5、用户使用说明

程序的使用说明，列出每一步的操作步骤。

word/media/image3.gifword/media/image4.gifword/media/image3.gifword/media/image5.gif

word/media/image6.gifword/media/image7.gifword/media/image8.gifword/media/image9.gifword/media/image10.gif

word/media/image11.gifword/media/image12.gif

word/media/image13.gif

word/media/image14.gifword/media/image15.gif

word/media/image16.gifword/media/image17.gif

Yword/media/image14.gif

word/media/image18.gif

word/media/image19.gifN

word/media/image20.gif

word/media/image21.gif

word/media/image22.gifword/media/image23.gif

word/media/image24.gif

word/media/image25.gif

word/media/image26.gif

7、附录

带注释的源程序，注释应清楚具体

#include

#define MaxNum 100

using namespace std;

typedef struct

{

char name;

int ArrivalTime;

int ServiceTime;

int FinishedTime;

int WholeTime;

double WeightWholeTime;

}RR;

static queueRRqueue; //声明一个队列

static double AverageWT =0,AverageWWT=0;

static int q; //时间片

static int n; //进程个数

static RR RRarray[MaxNum]; //进程结构

void Input()

{

//文件读取模式

ifstream inData;

inData.open("./data4.txt");

//data.txt表示q = 4的RR调度算法

//data2.txt表示q = 1的RR调度算法

inData>>n;

inData>>q;

for (int i=0;i

{

inData>>RRarray[i].name;

}

for (i=0;i

{

inData>>RRarray[i].ArrivalTime;

}

for (i=0;i

{

inData>>RRarray[i].ServiceTime;

}

//用户输入模式

cout<<"****************************************************************"<

cout<<"请输入进程个数 n ： ";

cin>>n;

cout<<"请输入时间片 q ： ";

cin>>q;

cout<<"请按到达时间的顺序依次输入进程名:"<

for (i=0;i

{

cin>>RRarray[i].name;

}

cout<<"请从小到大输入进程到达时间:"<

for (i=0;i

{

cin>>RRarray[i].ArrivalTime;

}

cout<<"请按到达时间的顺序依次输入进程服务时间:"<

for (i=0;i

{

cin>>RRarray[i].ServiceTime;

}

cout<<"****************************************************************"<

//输出用户所输入的信息

cout<<"The information of processes is the following:"<

cout<进程名"<<" ";

cout<到达时间"<<" ";

cout<服务时间"<<" "<

for ( i=0;i

{

cout<

}

cout<<"****************************************************************"<

}

void RRAlgorithm()

{

char processMoment[100]; //存储每个时间片p对应的进程名称

RRqueue.push(RRarray[0]);

int processMomentPoint = 0;

int CurrentTime=0;

int tempTime; //声明此变量控制CurrentTime的累加时间，当前进程的服务时间小于时间片q的时候，起到重要作用

int i=1; //指向还未处理的进程的下标

int finalProcessNumber = 0; //执行RR算法后，进程的个数

int processTime[50];

//CurrentTime的初始化

if (RRarray[0].ServiceTime>=q)

{

CurrentTime = q;

}

else

{

CurrentTime = RRarray[0].ServiceTime;

}

while(!RRqueue.empty())

{

for (int j=i;j使得满足进程的到达时间小于当前时间的进程都进入队列

{

if (RRarray[j].name!=NULL && CurrentTime >= RRarray[j].ArrivalTime)

{

RRqueue.push(RRarray[j]);

i++;

}

if (RRqueue.front().ServiceTime

{

tempTime = RRqueue.front().ServiceTime;

}

else

{

tempTime = q;

}

RRqueue.front().ServiceTime -= q; //进程每执行一次，就将其服务时间 -q

//将队首进程的名称放入数组中

processMoment[processMomentPoint] = RRqueue.front().name;

processMomentPoint++;

processTime[finalProcessNumber] = tempTime;

finalProcessNumber++;

if (RRqueue.front().ServiceTime <= 0) //把执行完的进程退出队列

{

//RRqueue.front().FinishedTime = CurrentTime;

RRqueue.pop(); //如果进程的服务时间小于等于，即该进程已经服务完了，将其退栈

}

else

{

//将队首移到队尾

RRqueue.push(RRqueue.front());

RRqueue.pop();

}

CurrentTime += tempTime;

}

//进程输出处理每个时间段对应的执行的进程

cout<<"各进程的执行时刻信息："<

cout<<" "<<"0时刻 --> "<时刻";

processTime[finalProcessNumber]=0;

int time = processTime[0];

int count = 0;

for (i=0;i

{

count = 0;

cout<

while(RRarray[count].name!=processMoment[i] && count

{

count++;

}

RRarray[count].FinishedTime = time;

if (i

{

cout<时刻"<<" --> "<时刻"<

time += processTime[i+1];

}

cout<

//周转时间、带权周转时间、平均周转时间、带权平均周转时间的计算

//1. 周转时间 = 完成时间 - 到达时间

//2. 带权周转时间 = 周转时间/服务时间

for ( i=0;i

{

RRarray[i].WholeTime = RRarray[i].FinishedTime - RRarray[i].ArrivalTime;

RRarray[i].WeightWholeTime = (double)RRarray[i].WholeTime/RRarray[i].ServiceTime;

}

double x=0,y=0;

for (i=0;i

{

x += RRarray[i].WholeTime;

y += RRarray[i].WeightWholeTime;

}

AverageWT = x/n;

AverageWWT = y/n;

}

void display()

{

cout<<"******************************************************"<

cout<<"RR调度算法执行后：进程相关信息如下："<

cout<进程名（ID）"<<" ";

cout<到达时间"<<" ";

cout<服务时间"<<" ";

cout<完成时间"<<" ";

cout<周转时间"<<" ";

cout<带权周转时间"<

for (int i = 0;i

{

cout<

}

cout<<"所有进程的平均周转时间 = "<

cout<<"所有进程的平均带权周转时间 = "<

cout<<"******************************************************"<

}

int main()

{

Input();

RRAlgorithm();

display();

return 0;

}

时间片轮转调度算法实验报告

时间片轮转调度算法实验报告

实验二时间片轮转RR进程调度算法

推荐内容

相关推荐

申请出国留学程序 doc

疫情防控应急预案

参加比赛后的感悟

探讨现代户外运动服装的功能性设计

人教版小学一年级下册语文全册知识点汇总

海口实验中学高中部合唱讲座有感—美妙的合唱之旅

[参考文档]阿成《水饭》阅读答案-推荐word版（3页）

党在社会主义初级阶段的基本路线全解

《尼尔斯骑鹅旅行记》读后感5篇

雨中的回忆 - 六年级作文