CPU调度算法C++模拟实现——(FCFS,SJF,RR)

FisrtComeFirstServe——先到先服务算法

按照进程进入就绪队列的顺序，来执行进程。用一个队列维护即可。

ShortestJobFirst——短作业优先算法

我实现的是非抢占式SJF，可以通过优先队列来判断已ready且cpu burst最短的进程，但我不太熟，就写了一个getnext()来实现。

RoundRobin——轮询算法

用队列来维护，具体看代码吧。

=。=没加注释，完了补上。

#include 
#include 
#include 
#include 
#include 

using namespace std;

struct PCB{
    int id;
    int exectime;
    int readytime;
    int start;
    int end;
    int prio;

    int index;

     bool operator < (PCB a)const
    {
        return exectime > a.exectime;
    }
}pcb[10];

int pAmt;
int timeslice;

bool cmpfcfs(PCB a, PCB b){
    if(a.readytime!=b.readytime)
        return a.readytime pcb[i].exectime){
                next=i;
                temp=pcb[i].exectime;
                flag=0;
            }
        }
    }
    if(flag){
        for(int i=0;i<10;i++){
            if(pcb[i].start==-1){
                next=i;
                break;
            }
        }
    }

    return next;
}

void sjf(){
    ///sort
    ofstream f2("./outputSJF.txt", ios::app);
    f2<<"sjf-------------"< que;

    int cnt=0;
    int head[14]={};
    int cputime=0;
    int finish[16]={};

    PCB cur[10];
    for(int i=0;i<10;i++){
        cur[i].readytime=pcb[i].readytime;
        cur[i].exectime=pcb[i].exectime;
        cur[i].id=pcb[i].id;
        cur[i].prio=pcb[i].prio;
        cur[i].index=pcb[i].index;
    }

    que.push(cur[0]);
    while(cnt<10){
        PCB temp=que.front();
        int index=temp.index;
        if(head[index]==0){
            pcb[index].start=cputime;
            head[index]=1;
        }
        if(cur[index].exectime<=timeslice){
            cputime+=cur[index].exectime;
            cur[index].exectime=0;
            pcb[index].end=cputime;
            f2<cputime-timeslice){
                    que.push(cur[i]);
                    flag=0;
                }
            }
            if(flag&&que.empty()){
                for(int i=0;i<10;i++){
                    if(finish[i]==0){
                        que.push(cur[i]);
                        cputime=cur[i].readytime;
                        break;
                    }
                }
            }
        }
        else{
            cputime+=timeslice;
            cur[index].exectime-=timeslice;
            f2<cputime-timeslice ){
                    que.push(cur[i]);
                    flag=0;
                }
            }
            que.pop();
            que.push(cur[index]);

            if(flag&&que.empty()){
                for(int i=0;i<10;i++){
                    if(finish[i]==0){
                        que.push(cur[i]);
                        cputime=cur[i].readytime;
                        break;
                    }
                }
            }

        }
    }


    int sum=0;
    f2<<"<--- turn"<>cases;
    while(cases--){

        f1>>pAmt>>timeslice;
        for(int j=0;j>pcb[j].id>>pcb[j].readytime>>pcb[j].exectime>>pcb[j].prio;
            pcb[j].start=-1;
        }

        //fcfs();
        //sjf();
        rr();
     }


    return 0;
}