操作系统实验（一）——进程调度模拟

一个班（20信安）的同学搜到这篇别直接copy我的，代码仅供参考

一、轮转调度算法　RR

代码

#include<bits/stdc++.h>
using namespace std;
// 总时间
int clk_t = 0;


// 额外记录的量
float ave_aroundtime=0; // 平均周转时间
float ave_weight_aroundtime=0; // 平均带权周转时间


//pcb结构体
struct pcb{
    int pno;// 进程号
    char state = 'W';// 状态，就绪W，运行R
    int arrivetime;// 到达时间
    int runtime = 0;// 已经运行的时间
    int needtime;// 服务时间

    int achievetime;// 完成时间
    int aroundtime;// 周转时间
    float weight_aroundtime;// 带权周转时间
    int waittime;// 等待时间
}pro[10];

// 创建进程就绪队列
vector<pcb> process_que;

// 进程数
int n;

// 时间片长度
int age;

// 完成进程标志数组
int hash_pro[10]={0};
int flag=0;

//声明
void init_print();
void run_print();
void rightmove();



void init_print(){
    cout << "\n##################当前初始化进程###################" << endl;
	cout << "name \t state \t needtime runtime" << endl;
    for(int i=0; i<n; i++){
        cout << "|" << pro[i].pno << "\t";
        cout << "|" << pro[i].state << "\t";
        cout << "|" << pro[i].needtime << "\t";
        cout << "|" << pro[i].runtime << "\t" << endl;
    } 
    cout << "################################################\n" << endl;
}


void run_print(){
    cout << "\n##################当前执行进程###################" << endl;
	cout << "name \t state \t needtime runtime " << endl;
    if(!process_que.empty()){
        cout << "|" << process_que[0].pno << "\t";
        cout << "|" << process_que[0].state << "\t";
        cout << "|" << process_que[0].needtime << "\t";
        cout << "|" << process_que[0].runtime << "\t";
    } else {
        cout << "process_queue is none now!";
    }
	cout  << endl;
    for(int i=1; i<process_que.size(); i++){
        cout << "|" << process_que[i].pno << "\t";
        cout << "|" << process_que[i].state << "\t";
        cout << "|" << process_que[i].needtime << "\t";
        cout << "|" << process_que[i].runtime << "\t" << endl;
    } 
    cout << "################################################\n" << endl;
}


void end_print(){
    cout << "\n##################进程完成总览###################" << endl;
	cout << "name \t state \t arrivetime \t needtime \t achievetime \t aroundtime \t weight_aroundtime \t waittime"  << endl;
    if(!process_que.empty()){
        cout << "|" << process_que[0].pno << "\t";
        cout << "|" << process_que[0].state << "\t";
        cout << "|" << process_que[0].arrivetime << "\t";
        cout << "|" << process_que[0].needtime << "\t";
        cout << "|" << process_que[0].achievetime << "\t";
        cout << "|" << process_que[0].aroundtime << "\t";
        cout << "|" << process_que[0].weight_aroundtime << "\t";
        cout << "|" << process_que[0].waittime << "\t";
    } else {
        cout << "process_queue is none now!";
    }
	cout  << endl;
    for(int i=0; i<n; i++){
        cout << "|" << pro[i].pno << "\t";
        cout << "|" << pro[i].state << "\t";
        cout << "|" << pro[i].arrivetime << "\t\t";
        cout << "|" << pro[i].needtime << "\t\t";
        cout << "|" << pro[i].achievetime << "\t\t";
        cout << "|" << pro[i].aroundtime << "\t\t";
        cout << "|" << pro[i].weight_aroundtime << "\t\t\t";
        cout << "|" << pro[i].waittime << "\t" << endl;//3 20 1 30 50 2 40 30 3 50 100
    } 
    cout << "################################################\n" << endl;
}


void leftmove(){
    process_que.push_back(process_que.front());// 插入队首元素
    for(int i=0; i<process_que.size(); i++){
        process_que[i] = process_que[i+1];
    }
    process_que.pop_back();// 弹出插入队尾的多出的队首元素
}


//主函数
int main(){
    cout << "请输入进程数:";
    cin >> n;// 输入进程数1~10
    cout << "请输入时间片长度:";
    cin >> age;// 时间片长度

    // 初始化队列
    for(int i=0; i<n; i++){
        cout << "第" << i+1 << "个进程的进程号，到达时间，服务时间:";
        cin >> pro[i].pno >> pro[i].arrivetime >> pro[i].needtime;
        // process_que.push_back(pro[i]);
    }
    init_print();// 打印
    
    // 核心代码
    while(flag != n){

        for(int i=0; i<n; i++){
            //判断是否有新抵达的进程
            if(pro[i].arrivetime <= clk_t && hash_pro[i]==0)
            {
                process_que.push_back(pro[i]);
                hash_pro[i] = 1;
            } 
        }

        if(!process_que.empty()){
        // 如果进程队列还有待调度进程
            process_que[0].state = 'R';
            process_que[0].runtime = min(process_que[0].runtime+age, process_que[0].needtime);
            run_print();
            process_que[0].state = 'W';
            
            leftmove();
            if(process_que.back().runtime==process_que.back().needtime){
                struct pcb *node = &pro[process_que.back().pno-1];
                node->achievetime = clk_t;//计算完成进程的完成时间点
                node->aroundtime = clk_t-node->arrivetime;//计算完成进程的周转时间
                node->weight_aroundtime = node->aroundtime/node->needtime;//计算完成进程的带权周转时间(周转时间/服务时间)
                node->waittime = node->aroundtime-node->needtime;//完成进程的等待时间(周转时间-服务时间)
                process_que.pop_back();
                flag++;
            }
        }
        clk_t += age;//时间片结束，系统时间增加
    }
    end_print();
    cout << n <<"条进程执行完毕";
    for(int i=0; i<n; i++){
        ave_aroundtime += pro[i].aroundtime; // 平均周转时间
        ave_weight_aroundtime += pro[i].weight_aroundtime; // 平均带权周转时间    
    }
    
    ave_aroundtime/=n;
    ave_weight_aroundtime/=n;
    
    cout << "平均周转时间:" << ave_aroundtime << endl;
    cout << "平均带权周转时间:" << ave_weight_aroundtime << endl;
    
    return 0;
}

运行截图

分析

只要不断地对就绪队列队首的进程改变状态，执行一个时间片，并且取增加一个时间片和服务时间的最小值确保不会超过服务时间，然后执行完毕就leftmove，，整个队列移动，然后这时该进程已经跑到队尾，此时判断.back()的队尾进程，判断执行时间是否等于服务时间，是就说明执行完毕可以弹出。最后结束的时候不能只判断队列是否为空，还要确认所有进程是否已经到达，因为可能有的进程还在到达的路上，还没有进队，所以最终判断的条件应该是是否所有进程都已经结束，或者说完成的进程数是否等于创建的进程数n

二、优先级调度算法PSA

代码

#include<bits/stdc++.h>
using namespace std;
// 总时间
int clk_t = 0;


// 额外记录的量
float ave_aroundtime=0; // 平均周转时间
float ave_weight_aroundtime=0; // 平均带权周转时间


// pcb结构体
struct pcb{
    int pno;// 进程号
    char state = 'W';// 状态，就绪W，运行R
    int arrivetime;// 到达时间
    int runtime = 0;// 已经运行的时间
    int needtime;// 服务时间
    int rank;// 优先级


    int achievetime;// 完成时间
    int aroundtime;// 周转时间
    float weight_aroundtime;// 带权周转时间
    int waittime;// 等待时间
}pro[10];

// 创建进程就绪队列
vector<pcb> process_que;

// 进程数
int n;

// 时间片长度
int age;

// 完成进程标志数组
int hash_pro[10]={0};
int flag=0;

// 声明
void init_print();
void run_print();
void rightmove();

void init_print(){
    cout << "\n##################当前初始化进程###################" << endl;
	cout << "name \t state \t needtime \t runtime \t rank" << endl;
    for(int i=0; i<n; i++){
        cout << "|" << pro[i].pno << "\t";
        cout << "|" << pro[i].state << "\t";
        cout << "|" << pro[i].needtime << "\t\t";
        cout << "|" << pro[i].runtime << "\t\t" ;
        cout << "|" << pro[i].rank << "\t" << endl;
    } 
    cout << "################################################\n" << endl;
}

void run_print(){
    cout << "\n##################当前运行进程###################" << endl;
	cout << "name \t state \t needtime rank runtime" << endl;
    if(!process_que.empty()){
        cout << "|" << process_que[0].pno << "\t";
        cout << "|" << process_que[0].state << "\t";
        cout << "|" << process_que[0].rank << "\t";
        cout << "|" << process_que[0].needtime << "\t";
        cout << "|" << process_que[0].runtime << "\t";
    } else {
        cout << "process_queue is none now!";
    }
	cout  << endl;
    for(int i=1; i<process_que.size(); i++){
        cout << "|" << process_que[i].pno << "\t";
        cout << "|" << process_que[i].state << "\t";
        cout << "|" << process_que[i].rank << "\t";
        cout << "|" << process_que[i].needtime << "\t";
        cout << "|" << process_que[i].runtime << "\t" << endl;
    } 
    cout << "################################################\n" << endl;
}


void end_print(){
    cout << "\n##################进程完成总览###################" << endl;
	cout << "name \t state \t arrivetime \t needtime \t rank \t achievetime \t aroundtime \t weight_aroundtime \t waittime"  << endl;
    if(!process_que.empty()){
        cout << "|" << process_que[0].pno << "\t";
        cout << "|" << process_que[0].state << "\t";
        cout << "|" << process_que[0].arrivetime << "\t";
        cout << "|" << process_que[0].needtime << "\t";
        cout << "|" << process_que[0].rank << "\t";
        cout << "|" << process_que[0].achievetime << "\t";
        cout << "|" << process_que[0].aroundtime << "\t";
        cout << "|" << process_que[0].weight_aroundtime << "\t";
        cout << "|" << process_que[0].waittime << "\t";
    } else {
        cout << "process_queue is none now!";
    }
	cout  << endl;
    for(int i=0; i<n; i++){
        cout << "|" << pro[i].pno << "\t";
        cout << "|" << pro[i].state << "\t";
        cout << "|" << pro[i].arrivetime << "\t\t";
        cout << "|" << pro[i].needtime << "\t\t";
        cout << "|" << pro[i].rank << "\t\t";
        cout << "|" << pro[i].achievetime << "\t\t";
        cout << "|" << pro[i].aroundtime << "\t\t";
        cout << "|" << pro[i].weight_aroundtime << "\t\t\t";
        cout << "|" << pro[i].waittime << "\t" << endl;//3 20 1 30 50 2 40 30 3 50 100
    } 
    cout << "################################################\n" << endl;
}

void leftmove(){
    struct pcb node = process_que.front();
    int j;
    for(j=0; j<process_que.size();){
        if(process_que[j].rank >= node.rank) j++;
        else break;
    }
    process_que.insert(process_que.begin()+j,node);

    for(int i=0; i<process_que.size(); i++){
        process_que[i] = process_que[i+1];
    }
    process_que.pop_back();// 弹出插入队尾的多出的队首元素
}

int first_search(vector<pcb> a){
    int ret=0;
    for(int i=0; i<a.size(); i++){
        if(a[i].rank>a[ret].rank) ret = i;
    }
    return ret;
}

// 主函数
int main(){
    cout << "请输入进程数:";
    cin >> n;// 输入进程数1~10
    cout << "请输入时间片长度:";
    cin >> age;// 时间片长度

    // 初始化队列
    for(int i=0; i<n; i++)
    { 
        cout << "第" << i+1 << "个进程的进程号，到达时间，服务时间,优先级:";
        cin >> pro[i].pno >> pro[i].arrivetime >> pro[i].needtime >> pro[i].rank;
        // process_que.push_back(pro[i]);
    }
    init_print();// 打印
    
    // 核心代码
    while(flag != n){

        for(int i=0; i<n; i++){
            // 判断是否有新抵达的进程
            if(pro[i].arrivetime <= clk_t && hash_pro[i]==0)
            {
                hash_pro[i] = 1;
                if(process_que.empty())
                {
                    process_que.push_back(pro[i]);
                    continue;
                } 
                int j;
                for(j=0; j<process_que.size();)
                {
                    if(process_que[j].rank >= pro[i].rank) j++;
                    else break;
                }
                process_que.insert(process_que.begin()+j,pro[i]);

            } 
        }

        if(!process_que.empty()){
        // 如果进程队列还有待调度进程
            process_que[0].state = 'R';
            process_que[0].runtime = min(process_que[0].runtime+age, process_que[0].needtime);
            run_print();
            process_que[0].state = 'W';
            if(process_que[0].runtime==process_que[0].needtime){
                struct pcb *node = &pro[process_que[0].pno-1];
                node->achievetime = clk_t;// 计算完成进程的完成时间点
                node->aroundtime = clk_t-node->arrivetime;// 计算完成进程的周转时间
                node->weight_aroundtime = node->aroundtime/node->needtime;// 计算完成进程的带权周转时间(周转时间/服务时间)
                node->waittime = node->aroundtime-node->needtime;// 完成进程的等待时间(周转时间-服务时间)
                process_que.pop_back();
                flag++;
            }
            
            leftmove();

        }
        clk_t += age;// 时间片结束，系统时间增加
    }
    end_print();
    cout << n <<"条进程执行完毕";

    for(int i=0; i<n; i++){
        ave_aroundtime += pro[i].aroundtime; // 平均周转时间
        ave_weight_aroundtime += pro[i].weight_aroundtime; // 平均带权周转时间    
    }
    
    ave_aroundtime/=n;
    ave_weight_aroundtime/=n;
    
    cout << "平均周转时间:" << ave_aroundtime << endl;
    cout << "平均带权周转时间:" << ave_weight_aroundtime << endl;
    return 0;
}

运行截图

分析

在时间片基础上，只需要增加pcb块的内容，即优先级rank，然后在leftmove的时候通过遍历判断优先级，确保不会插入到低优先级的就绪进程后，然后在弹出的时候也需要修改们不能弹出队尾了，要在leftmove前就判断是否可以弹出，如果可以弹出直接弹出，不能再进行leftmove。

三、小结

算法本身不难，只要细心去确认判断条件，RR进程调度算法做出来了优先级进程调度算法也就是增加一些判断条件，主要是对算法本身的理解要透彻，具体实现起来就是时间问题了。