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

设计程序模拟进程的时间片轮转RR调度过程。假设有n个进程分别在T1, … ,Tn时刻到达系统，它们需要的服务时间分别为S1, … ,Sn。分别利用不同的时间片大小q，采用时间片轮转RR进程调度算法进行调度，计算每个进程的完成时间、周转时间和带权周转时间，并且统计n个进程的平均周转时间和平均带权周转时间。

程序要求：

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

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

3）输出：要求模拟整个调度过程，输出每个时刻的进程运行状态，如“时刻3：进程B开始运行”等等；

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

完整代码

#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(){
	cout<<"请输入进程个数: ";
    cin>>n;
    
	cout<<"请输入"<<n<<"个进程的进程名字（空格隔开）：";
	for(int i=0;i<n;i++){
		cin>>PROarray[i].name;
	}
	
	cout<<"请输入"<<n<<"个进程的到达时间（空格隔开）：";
	for(int j=0;j<n;j++){
		cin>>PROarray[j].ArrivalTime;
	}
	
	cout<<"请输入"<<n<<"个进程的服务时间（空格隔开）：";
	for(int k=0;k<n;k++){
		cin>>PROarray[k].ServiceTime;
	}
	
	cout<<"请输入时间片q的大小：";
	cin>>q;
	cout<<endl; 
	
	//按照到达时间进行排序
	for(int i=0;i<n;i++){
		for(int j=i+1;j<n;j++){
			if(PROarray[i].ArrivalTime>PROarray[j].ArrivalTime){//i比j后到   交换顺序 
				temp=PROarray[i];
				PROarray[i]=PROarray[j];
				PROarray[j]=temp;
			}
		}
	} 
} 

//执行RR调度算法
void RR(){
    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;
	
	cout<<"各个时间点的执行情况如下："<<endl;
	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<<endl;
    cout<<"进程信息如下："<<endl;
	cout<<"------------------------------------------------------------------------"<<endl;
	cout<<left<<setw(12)<<"进程名"<<setw(12)<<"到达时间"<<setw(12)<<"服务时间"<<setw(12)<<"完成时间"<<setw(12)<<"周转时间"<<setw(12)<<"带权周转时间"<<endl;
	cout<<"------------------------------------------------------------------------"<<endl;
	for(int i=0;i<n;i++){
		cout<<left<<setw(12)<<PROarray[i].name;
		cout<<setw(12)<<PROarray[i].ArrivalTime;
		cout<<setw(12)<<PROarray[i].ServiceTime;
		cout<<setw(12)<<PROarray[i].FinishTime;
		cout<<setw(12)<<PROarray[i].WholeTime;
		cout<<setw(12)<<PROarray[i].WeightWholeTime<<endl;
	}
	cout<<"------------------------------------------------------------------------"<<endl;
	
	cout<<"平均周转时间："<<AverageWT<<endl;
	cout<<"平均带权周转时间："<<AverageWWT<<endl;
	cout<<endl;
}


int main(){
    Input();
    RR();
    output();
    return 0;
}

实例运行结果截图：

 

5个进程

进程名字：A B C D E

进程的到达时间：0 1 2 3 4

进程的服务时间：6 2 5 9 8

时间片q的大小：2

5个进程

进程名字：A B C D E

进程的到达时间：0 1 2 3 4

进程的服务时间：6 2 5 9 8

时间片q的大小：4