时间片轮转RR进程调度算法（操作系统实验 C＋）

已于 2023-04-03 19:37:53 修改
阅读量2.4k 收藏 36
点赞数 3
分类专栏： 操作系统 文章标签： 算法 c++ windows
于 2023-04-02 15:32:44 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_51080803/article/details/129911456
版权

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

1.实验目的

通过这次实验，加深对进程概念的理解，进一步掌握进程状态的转变、进程调度的策略及对系统性能的评价方法。

2.实验内容

问题描述：

设计程序模拟进程的时间片轮转RR调度过程。假设有n个进程分别在T1, … ,Tn时刻到达系统，它们需要的服务时间分别为S1, … ,Sn。分别利用不同的时间片大小q，采用时间片轮转RR进程调度算法进行调度，计算每个进程的完成时间、周转时间和带权周转时间，并且统计n个进程的平均周转时间和平均带权周转时间。
程序要求：
1）进程个数n；每个进程的到达时间T1, … ,Tn和服务时间S1, … ,Sn；输入时间片大小q。
2）要求时间片轮转法RR调度进程运行，计算每个进程的周转时间和带权周转时间，并且计算所有进程的平均周转时间和带权平均周转时间；
3）输出：要求模拟整个调度过程，输出每个时刻的进程运行状态，如“时刻3：进程B开始运行”等等；
4）输出：要求输出计算出来的每个进程的周转时间、带权周转时间、所有进程的平均周转时间以及带权平均周转时间。
实现提示：
用C++语言实现提示：
1）程序中进程调度时间变量描述如下：
int ArrivalTime[100];
int ServiceTime[100];
int PServiceTime[100];
int FinishTime[100];
int WholeTime[100];
double WeightWholeTime[100];
double AverageWT,AverageWWT;
bool Finished[100];
2）进程调度的实现过程如下：

  1. 变量初始化；
  2. 接收用户输入n，T1, … ,Tn，S1, … ,Sn；时间片大小q；
  3. 按照时间片轮转RR算法进行进程调度，计算进程的完成时间、周转时间和带权周转时间；
  4. 计算所有进程的平均周转时间和平均带权周转时间；
  5. 按格式输出调度结果。

实验要求：
1）上机前认真复习时间片轮转RR进程调度调度算法，熟悉进程调度的执行过程；
2）上机时独立编程、调试程序；
3）根据具体实验要求，完成好实验报告（包括实验的目的、内容、要求、源程序、实例运行结果截图、发现的问题以及解决方法）

3.程序主要构成部分及其算法说明

1.采用while循环对队列进行相应的处理，采用嵌套的for循环对q>1的情况做处理，将满足进程的到达时间小于当前时间的进程都进入队列


while(!PROqueue.empty()){
    for (int j=i;j<n;j++){ 
   if(PROarray[j].name!=NULL&&CurrentTime>= PROarray[j].ArrivalTime){
           PROqueue.push(PROarray[j]);
                i++;
} }

2.进程运行的顺序算法，分两部分处理，运行在队首的进程，当队首进程的服务时间小于或者等于0的时候，将队首元素出队列，反之，将队首元素插入到队尾（注意，要先将新到来的进程插入队尾后，再将队首元素插入队尾）。

if (PROqueue.front().ServiceTime>=q)
            tempTime = q;
        else
            tempTime = PROqueue.front().ServiceTime;         	
        PROqueue.front().ServiceTime -= q;  
        processName[a]= PROqueue.front().name;
        a++;
        Time[processNumber] = tempTime;
        processNumber++;
        if (PROqueue.front().ServiceTime <= 0)  
            PROqueue.pop();  
        else{   
            PROqueue.push(PROqueue.front());
            PROqueue.pop();
        }
         CurrentTime += tempTime;
    }

3.计算进程的完成时间：在队列过程处理中，将进程的执行时间记录在数组中，然后，在后续的处理过程中，利用while循环，按照一遇到重复的进程名就更新的原则进行处理，最后一次更新即是该进程的完成时间

for (int i=0;i<processNumber;i++)
	{
		count = 0;
		while(PROarray[count].name!=processName[i] &&count<n)
		{	
			count++ ;
		} 
		PROarray[count].FinishTime=time ;
		if (i<processNumber-1)
		{
			time += Time[i+1];
		}
	}

4.运行结果

在这里插入图片描述

在这里插入图片描述

5.实验源码

#include <iostream>
#include <queue>
#include <iomanip>
#include <fstream>
using namespace std;
 
//存放每个进程信息的结构体
typedef struct{
    char name;
    double ArrivalTime;//到达时间
    double ServiceTime;//服务时间
    double FinishTime;//完成时间
    double WholeTime;//周转时间
    double WeightWholeTime;//带权周转时间
}PRO;
 
static queue<PRO>PROqueue;  //用来模拟进程执行RR调度算法的队列
static double SumWT=0,SumWWT=0,AverageWT =0,AverageWWT=0;//平均周转时间、平均带权周转时间
static int q;  //时间片数
static int n;  //进程个数
static PRO PROarray[100];  //进程结构体
static PRO temp;  //进程结构

void Input();
void RRArithmetic() ;
void output() ;

int main(){
    Input();
    RRArithmetic();
    output();
    return 0;
}
 
//输入时间片、到达时间、服务时间等
void Input(){
    int i,j;
    cout<<"请输入进程个数: ";
    cin>>n;
    
    for (i=0;i<n;i++){
      PROarray[i].name=i+65;//自动将进程名字顺序编号为A、B、C、D、E等
    }
 
    cout<<"请输入到达时间: ";
    for (i=0;i<n;i++){
      cin>>PROarray[i].ArrivalTime;
    }
 
    cout<<"请输入服务时间: ";
    for (i=0;i<n;i++){
      cin>>PROarray[i].ServiceTime;
    }
 	
	cout<<"请输入时间片q的大小: ";
    cin>>q;
    
    //根据达时间排序
    for(i=0;i<n;i++) {
        for(j=i+1;j<n;j++) {
            if(PROarray[i].ArrivalTime > PROarray[j].ArrivalTime) {
                temp = PROarray[i];
                PROarray[i] = PROarray[j];
                PROarray[j] = temp;
            }
        }
    }
}
 
//执行RR调度算法
void RRArithmetic(){
    char processName[100];   //存储每个时间片p对应的进程名称
   	PROqueue.push(PROarray[0]);   //第一个进程进队列
    int CurrentTime=0;//当前时间 
    int tempTime;   //控制CurrentTime的累加时间，当前进程的服务时间小于时间片q的时候，起到重要作用
    int i=1;  
    int a=0; 
    int processNumber = 0;   //执行RR算法后，进程的个数 
    int Time[100] ;
    //判断第一个进程的服务时间是否大于时间片，如果大于CurrentTime=q，如果小于CurrentTime=服务时间
    if (PROarray[0].ServiceTime>=q)
        CurrentTime = q;
    else
        CurrentTime = PROarray[0].ServiceTime;
  
    while(!PROqueue.empty()){
        for (int j=i;j<n;j++){   //使得满足进程的到达时间小于当前时间的进程都进入队列
            if (PROarray[j].name!=NULL && CurrentTime >= PROarray[j].ArrivalTime){
                PROqueue.push(PROarray[j]);
                i++;
            }
        }
        //队列首进程进行执行，进程每执行一次，就将其服务时间 -q
        if (PROqueue.front().ServiceTime>=q)
            tempTime = q;
        else
            tempTime = PROqueue.front().ServiceTime;
            	
        PROqueue.front().ServiceTime -= q;  
 
        //将队首进程的名称放入数组中
        processName[a]= PROqueue.front().name;
        a++;
        Time[processNumber] = tempTime;
        processNumber++;
 
 
        if (PROqueue.front().ServiceTime <= 0)  //把执行完的进程退出队列
            PROqueue.pop();   //如果进程的服务时间小于等于，即该进程已经服务完了，将其退栈
        else{
            //将队首移到队尾
            PROqueue.push(PROqueue.front());
            PROqueue.pop();
        }
         CurrentTime += tempTime;
    }
   //进程输出处理   每个时间段对应的执行的进程
 

	int time = Time[0];
	int count = 0;

  
  //计算完成时间
	for (int i=0;i<processNumber;i++)
	{
		count = 0;
		while(PROarray[count].name!=processName[i] &&count<n)
		{	
			count++ ;
		} 
		PROarray[count].FinishTime=time ;
		if (i<processNumber-1)
		{
			time += Time[i+1];
		}
	}
 	
	//周转时间、带权周转时间、平均周转时间、带权平均周转时间的计算
    for (int i=0;i<n;i++){
        PROarray[i].WholeTime = PROarray[i].FinishTime - PROarray[i].ArrivalTime;
        PROarray[i].WeightWholeTime = (double)PROarray[i].WholeTime/PROarray[i].ServiceTime;
    }
 
    for (int i=0;i<n;i++){
        SumWT += PROarray[i].WholeTime;
        SumWWT += PROarray[i].WeightWholeTime;
    }
    AverageWT = SumWT/n;
    AverageWWT = SumWWT/n;

	for(int i=0;i<processNumber;i++){//输出
        for(int j=0;j<Time[i];j++){
            cout<<setw(3)<<count-2<<"--"<<setw(3)<<count-1<<setw(6)<<"时刻  "<<"进程"<<processName[i]<<"开始执行";
        for(int k=0;k<n;k++){
            if(PROarray[k].ArrivalTime==count){
                cout<<"   进程"<<PROarray[k].name<<"到达";
            }
            else if(PROarray[k].FinishTime==count+1&&count!=0){
                cout<<"   进程"<<PROarray[k].name<<"完成";
        }
        }
        count+=1;
        cout<<endl;
	    }
	}
   
 
}
 
//显示各时间执行情况，以及各个时间值
void output(){
    int i;
    //输出各个时间
    cout<<"ID"<<"\t";
    cout<<"到达时间"<<"\t";
    cout<<"服务时间"<<"\t";
    cout<<"完成时间"<<"\t";
    cout<<"周转时间"<<"\t";
    cout<<"带权周转时间"<<endl;
    for (i=0;i<n;i++){
        cout<<PROarray[i].name<<"\t\t";
        cout<<PROarray[i].ArrivalTime<<"\t\t";
        cout<<PROarray[i].ServiceTime<<"\t\t";
        cout<<PROarray[i].FinishTime<<"\t\t";
        cout<<PROarray[i].WholeTime<<"\t\t";
        cout<<setprecision(3)<<PROarray[i].WeightWholeTime<<"\t\t"<<endl;;
    }
    cout<<"平均周转时间 = "<<setprecision(3)<<AverageWT<<endl;
    cout<<"平均带权周转时间 = "<<setprecision(3)<<AverageWWT<<endl;
}
落灬枫
关注
  • 3
    点赞
  • 踩
  • 36
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
实验内容：进程的优先级算法和时间片段轮转算法（C++实现）
Shiny_desiger的博客
05-31 3080
文章目录前言一、进程优先级调度算法二、时间片轮转调度算法三、示例代码（注意：优先级调度算法是采用非抢占算法）1.引入库2.读入数据3.输出用例四、总结 前言 提示：了解进程优先级算法和时间片轮转算法的基本原理再进行代码学习。 提示：以下是本篇文章正文内容，下面案例可供参考 一、进程优先级调度算法 基本原理： 按照进程的优先级高低来进行调度，使高优先级进程优先得到处理机的调度算法称为优先级调度算法（即优先级数值大的先进行调度）。但在许多采用优先级调度算法的系统中，通常使用动态优先级。一个进程的优先级不
操作系统课程设计——时间片轮转法实现处理机的调度
Software_Star的博客
12-17 1848
广州大学操作系统课程设计——时间片轮转法实现处理机的调度 （1）假设系统有n个进程，每个进程用一个进程控制块（PCB）来代表。进程控制块的格式如下表所示，且参数意义也相同。 （2）按照进程到达的先后顺序排成一个循环队列，设一个队首指针指向第一个到达进程的首址。另外再设一个当前运行进程指针，指向当前正运行的进程。 （3）执行处理机调度时，首先选择队首的第一个进程运行。 （4）由于本题目是模拟实验，所以对被选中的进程并不实际启动运行，而只是执行如下操作：1）估计运行时间减1； 2）输出
记录——时间片轮转调度算法模拟程序，用Java实现
yeliner的博客
01-04 8823
1、合理设计PCB结构，设计模拟指令格式，并以文件形式存储，程序能够读取文件并自动生成指令序列。2、根据文件内容，建立模拟进程队列，并能采用时间片轮转调度算法对模拟进程进行调度。
操作系统进程调度实验（内含可成功运行C++代码）
m0_48117581的博客
05-23 9834
操作系统实验 进程调度 C++/C
操作系统进程调度模拟算法实现（C/C++）
qq_44924407的博客
11-07 7433
目录实验内容实验目的实验内容实验代码参考源码短进程优先算法--无优先级短进程优先算法--无优先级 运行结果短进程优先调度--有优先级短进程优先调度--有优先级 运行结果进程调度综合算法进程调度综合算法 运行结果参考 实验内容 实验目的 用高级语言编写和调试一个进程调度程序，以加深对进程的概念及进程调度算法的理解。 实验内容 1、设计简单的进程PCB 结构，完成进程信息记录； 2、设计一个有 N个进程并发执行的进程调度程序（以下三选一） 1）编写并调试一个模拟的进程调度程序，采用“最高优先数优先”调度算法对五
【计算机操作系统】进程调度算法的 C++ 实现（附源码）
Coder Yang
06-11 6361
文章目录一、实验目的二、实验内容2.1 优先权法和轮转法2.2 算法描述三、流程图3.1 优先权法3.2 轮转法四、实验要求五、设计思想5.1 总体思想5.2 数据结构5.3 关键代码解析六、代码实现七、源码地址 一、实验目的   多道程序设计中，经常是若干个进程同时处于就绪状态，必须依照某种策略来决定那个进程优先占有处理机。因而引起进程调度。本实验模拟在单处理机情况下的处理机调度问题，加深对进程调度的理解。 二、实验内容 2.1 优先权法和轮转法 简化假设 1）进程为计算型的（无I/O） 2）进程状态
操作系统原理与实验——实验五时间片轮转进程调度
最新发布
m0_62806440的博客
03-09 1237
①一个重要的逻辑非常重要。②链表指针的使用错误（如head->next）。③还是不能运用队列来实现该算法；需要多加学习队列。④对于这道题，有一些函数没有用上，比如void Print_Current(Queue* que,time tt,int i)；因为我对函数的调用不是很理解和熟练，今后会慢慢改进该算法的。⑤先有想法再实现，如果实在没有思路可以先写写看，不尝试就没有结果。
操作系统实验：时间片轮转RR进程调度算法.doc
05-11
时间片轮转RR进程调度算法 本文档对时间片轮转RR进程调度算法进行了详细的实现和分析。该算法是操作系统中的一种常用的进程调度算法，能够合理地分配CPU时间片，提高系统的效率和公平性。 一、需求分析 时间片...
操作系统 时间片轮转RR进程调度算法 java版.doc
05-30
操作系统时间片轮转RR进程调度算法java版.doc 本文档主要介绍了操作系统中时间片轮转RR进程调度算法的Java实现。该算法用于模拟进程的时间片轮转调度过程，计算每个进程的完成时间、周转时间和带权周转时间，并统计...
操作系统实验二 时间片轮转RR进程调度算法
02-02
操作系统实验二 时间片轮转RR进程调度算法（内含源代码和详细实验报告），详细介绍：http://blog.csdn.net/xunciy/article/details/79239096
操作系统实验-单处理器系统的时间片轮转进程调度-python实现
12-25
大学操作系统课程 综合实验 单处理器系统的时间片轮转进程调度 算法，使用python实现。带注释。
时间片轮转调度算法
05-02
操作系统用时间片轮转调度算法实现进程块的调度，按进程调度顺序打印进程执行信息
进程调度算法模拟，动态优先数及时间片轮转法
12-23
1）本程序是由Dev-C++4.9.9.2编译通过，并生成.exe执行文件，不存在逻辑上的错误。未在VC6.0等编译软件下运行。 （2）此程序作者为在校学生，转为《操作系统实验》而编写，实践能力较差，存在许多不足之处，望各位网友能够对此程序中可以优化的地方加以修改，使之成为诸位自己的优秀作品。 （3）进程调度算法模拟，用动态优先数及时间片轮转法 实现进程调度。采用数据结构单链表实现。 （4）最后祝各位学有所成。
时间片轮转算法实验报告
06-23
时间片轮转算法实验报告包括：实验题目，实验目的，实验内容及要求，实验结果（截屏），实验总结，及后附有详细C++源代码 实验内容 1.设计进程控制块PCB的结构，通常应包括如下信息： 进程名、轮转时间片数、进程已占用的CPU时间、进程到完成还需要的时间、进程的状态、当前队列指针等。 2.编写时间片轮转调度算法程序 3.按要求输出结果。
操作系统实验-模拟进程管理（时间片轮转、先来先服务、短进程优先三种调度算法）
11-14
os实验，采用C#语言模拟进程管理问题，采用了时间片轮转调度、先来先服务、短进程优先调度三种算法模拟进程调度问题，可以时时查看进程调度情况和资源变化情况
操作系统实验二报告-时间片轮转进程调度算法.doc
05-11
时间片轮转进程调度算法实验报告 本实验报告的主要目的是为了加深对进程概念的理解，进一步掌握进程状态的转变、进程调度的策略及对系统性能的评价方法。在本实验中，我们将设计程序模拟进程的时间片轮转 RR 调度...
时间片轮转RR进程调度算法
02-27
计算机操作系统实验作业，可供借鉴，互相交流，共同进步
动态调度算法实验报告
qq_45917826的博客
03-25 1269
一、实验目的 1.理解操作系统进程管理中进行进程调度的过程和编程方法，创建进程控制块PCB。 2.理解进程的状态及变化，动态显示每个进程的当前状态及进程的调度情况。掌握几种调度算法。 3.理解几种进程调度的方式。 4.用代码将几种进程调度的方式表现出来。 二、实验原理 （1）先到先服务：按照进程提交给系统的先后次序来进行调度。 （2）短作业优先：按照进程所要求的运行时间来衡量。 （3）时间片轮转：根据先来先服务排序，以一个时间片为单位，依次执行不同的进程。 （4）响应比高者优先(HRRN)
（C语言实现）进程调度—时间片轮转调度算法
热门推荐
CSDN blog of twy
07-08 3万+
一、设计目的：       本设计模拟在单处理器情况下的时间片轮转进程调度，目的是加深对进程调度工作的理解，掌握不同调度算法的优缺点。二、设计内容  设计程序模拟单处理机系统中时间片轮转进程调度算法，每个进程由一个进程控制块（PCB）表示。进程控制块包含如下信息：进程名、到达时间、需要运行时间、完成标志与否、进程状态、还需运行的时间等。进程的需要运行时间和到达时间以及进程运行的时间片人为设定。每个...
c语言实现作业调度算法实验报告,时间片轮转调度算法的实验报告.doc
06-02
很抱歉，作为AI，我没有能力提供实验报告。但是我可以为您提供一些关于时间片轮转调度算法的基本信息和C语言实现的思路。 时间片轮转调度算法是一种常用的进程调度算法，它将CPU时间分成若干个时间片，每个进程在一个时间片内获得相同数量的CPU时间，如果进程在时间片结束之前没有执行完，则将其放入就绪队列的末尾，等待下一次执行。这样可以保证每个进程都有机会获得CPU时间，避免进程长时间占用CPU的情况，提高系统的资源利用率。 在C语言中，我们可以使用结构体来表示进程的信息，包括进程ID、进程状态、执行时间和优先级等。我们可以使用一个数组来存储所有进程的信息，并使用一个循环队列来表示就绪队列，每个时间片从队首开始执行，执行完毕后将进程放到队列尾部，直到所有进程都执行完毕。 以下是时间片轮转调度算法的C语言实现参考代码： ``` #include <stdio.h> #define MAX_PROCESS_NUM 10 #define TIME_SLICE 2 struct Process { int pid; // 进程ID int status; // 进程状态，0表示未执行，1表示正在执行，2表示已完成 int priority; // 进程优先级 int execute_time; // 进程执行时间 }; int main() { struct Process processes[MAX_PROCESS_NUM]; int ready_queue[MAX_PROCESS_NUM]; int head = 0, tail = 0; int process_num, current_time = 0; int i, j; printf("请输入进程数："); scanf("%d", &process_num); // 初始化进程信息 for (i = 0; i < process_num; i++) { printf("请输入进程%d的信息（ID 优先级 执行时间）：", i + 1); scanf("%d%d%d", &processes[i].pid, &processes[i].priority, &processes[i].execute_time); processes[i].status = 0; // 所有进程初始状态均为未执行 } // 将所有进程放入就绪队列 for (i = 0; i < process_num; i++) { ready_queue[tail++] = i; } // 时间片轮转调度 while (head != tail) { // 就绪队列不为空 int current_process = ready_queue[head]; head = (head + 1) % MAX_PROCESS_NUM; // 队首出队 if (processes[current_process].execute_time > TIME_SLICE) { // 执行一个时间片 current_time += TIME_SLICE; processes[current_process].execute_time -= TIME_SLICE; // 将进程重新放入就绪队列末尾 ready_queue[tail] = current_process; tail = (tail + 1) % MAX_PROCESS_NUM; } else { // 执行剩余时间 current_time += processes[current_process].execute_time; processes[current_process].execute_time = 0; processes[current_process].status = 2; // 进程执行完毕 // 输出进程执行信息 printf("进程%d执行完毕，执行时间：%d，优先级：%d\n", processes[current_process].pid, current_time, processes[current_process].priority); // 将已完成进程从就绪队列中删除 for (i = 0; i < tail; i++) { if (ready_queue[i] == current_process) { for (j = i; j < tail - 1; j++) { ready_queue[j] = ready_queue[j + 1]; } tail--; break; } } } } return 0; } ``` 以上代码仅供参考，具体实现方式可以根据实际情况进行调整。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值