FCFS+SJF+HRRF

概述

Simply achieved three scheduling algorithms like FCFS、SJF and HRRF in OS

详细

一、运行效果

二、实现过程

①FCFS

void FCFS(PCB pro[], int num) {
    int time,doneTime;
    int count=0,proNum=1;  //count为计数器，proNum记录当前的进程数量
    float sumTTime = 0,sumWTTime = 0; //总周转时间和总加权周转时间
    PCB pro1[100]; //用来存放当前进程的信息
    PCB *currentPro,*tempPCB;
 
    printf("\n\t先来先服务调度算法模拟\n\n");
    printf("\n");
    sortProWithArrivalTime(pro, num);  //按照进程到达时间进行排序
 
    //定义就绪队列
    PCBQueue* queue = (PCBQueue*)malloc(sizeof(PCBQueue));
    queueInit(queue); //就绪队列初始化
    enterQueue(queue, &pro[0]);   //将第一个进程送入就绪队列中
    time = pro[0].arrivalTime;    //记录第一个进程的到达时间
 
    while (queue->size > 0) {
        currentPro = poll(queue);  //从进程队列中取出一个进程
        if (time < currentPro->arrivalTime){
            time = currentPro->arrivalTime;
        }
 
        //计算进程的结束时间、周转时间，加权周转时间
        //结束时间=到达时间+运行时间
        doneTime = time + currentPro->runtime;
        currentPro->startTime = time;
        currentPro->doneTime = doneTime;
        //周转时间=结束时间-到达时间
        currentPro->turnaroundTime = doneTime - currentPro->arrivalTime;
        //加权周转时间=周转时间/运行时间
        currentPro->wTurnaroundTime = (currentPro->turnaroundTime) / (currentPro->runtime);
        sumTTime += currentPro->turnaroundTime; //计算周转时间之和
        sumWTTime += currentPro->wTurnaroundTime; //计算加权周转时间之和
 
        //模拟进程的执行过程
        for (int tt = time; tt <= doneTime && proNum < num; tt++){
            if (tt >= pro[proNum].arrivalTime) {
                enterQueue(queue, &pro[proNum]);
                proNum++;
            }
        }
        copyProcessInfo(&pro1[count],currentPro); //复制当前进程信息给一个新进程模板
        printRunningProInfo(&pro1[count]); //输出正在运行进程的信息
        count++;
 
        //输出就绪队列进程中的信息
        if(queue->size!=0) {
            printf("\t就绪队列：\n");
            printf("\t————————————————————————————————————————————————\n");
            printf("\t进程 到达时间  运行时间 \n");
            tempPCB=queue->firstProg->next;
            for(int i=queue->size; i>0; i--) {
                printf("\t%s\t%d\t%d\n",tempPCB->processName,tempPCB->arrivalTime,tempPCB->runtime);
                tempPCB=tempPCB->next;
            }
            printf("\t————————————————————————————————————————————————\n");
            printf("\n\n\n");
        }
        else {
            printf("\t无进程处于就绪状态!\n");
            printf("\t————————————————————————————————————————————————\n\n\n");
        }
        time += currentPro->runtime;
 
        //防止出现前一个进程执行完到下一个进程到达之间无进程进入
        if (queue->size == 0 && proNum < num) {
            enterQueue(queue, &pro[proNum]);
            proNum++;
        }
    }
 
    //输出所有进程的信息
    printProRunningOrder(pro1,count);
    printf("\t平均周转时间为:%.2f\n", sumTTime /num);
    printf("\t平均带权周转时间为:%.2f\n",sumWTTime/num);
}

②SJF

void SJF(PCB pro[],int num) {
    int i=0,proNum=1; //proNum记录当前的进程
    int time,done_time;
    float sumTTime=0,sumWTTime=0;
    PCBQueue *ready_queue;
    PCB *currentPro,pro1[MAXSIZE];
 
    printf("\n\t短作业优先调度算法模拟\n\n");
    printf("\n");
    sortProWithArrivalTime(pro, num);
    ready_queue = (PCBQueue*)malloc(sizeof(PCBQueue));
    if(!ready_queue) {
        printf("分配就绪队列头结点空间失败！");
        exit(1);
    }
    queueInit(ready_queue);
    enterQueueOfRuntime(ready_queue,&pro[0]);
    time = pro[0].arrivalTime;
 
    while(ready_queue->size>0) {
        //就绪队列中的队头进程入队
        currentPro=poll(ready_queue);
        //如果该进程与上一次运行的进程结束时间之间有间隔，则将CPU运行时间变为该进程到达时间
        if(time<currentPro->arrivalTime){
            time=currentPro->arrivalTime;
        }
        done_time=time+currentPro->runtime;
        currentPro->startTime=time;
        currentPro->doneTime=done_time;
        currentPro->turnaroundTime = done_time - currentPro->arrivalTime;//周转时间
        currentPro->wTurnaroundTime = currentPro->turnaroundTime / currentPro->runtime;//带权周转时间
        //打印正在运行的进程
        printRunningProInfo(currentPro);
        //将curpro的信息复制到pro1[i]中
        copyProcessInfo(&pro1[i],currentPro);
        i++;
        sumTTime += currentPro->turnaroundTime;
        sumWTTime += currentPro->wTurnaroundTime;
 
        while(proNum<num) {
            //将在CPU中的进程运行的时间内到达的进程放入就绪队列
            if(pro[proNum].arrivalTime<=done_time) {
                enterQueueOfRuntime(ready_queue,&pro[proNum]);
                proNum++;
            }
            else {
                break;
            }
        }
        printReadyQueueInfo(ready_queue);//打印就绪队列
        time=done_time;
 
        //防止出现前一个进程执行完到下一个进程到达之间无进程进入
        if(ready_queue->size==0&&proNum<num) {
            enterQueueOfRuntime(ready_queue,&pro[proNum]);
            proNum++;
        }
    }
 
    //输出所有进程的信息
    printProRunningOrder(pro1,num);
    printf("\t平均周转时间为:%.2f\n", sumTTime / num);
    printf("\t平均带权周转时间为:%.2f\n",sumWTTime/num);
}

③HRRF

void proControlBlock::HRRF(int n) {
    sortWithArrivalTime(n); //根据进程到达时间进行排序
    float t = 0;
    for (int i = 0; i < n; i++) {
        //计算前一个进程的结束时间
        if (i == 0) {
            prov[i].finishedTime = t + prov[i].runningTime + prov[i].arrivalTime;
            t = prov[i].finishedTime;
        }
        else {
            if (prov[i].arrivalTime > t)
                t = prov[i].arrivalTime;
            prov[i].finishedTime = t + prov[i].runningTime;
            t += prov[i].runningTime;
        }
        //找到在前一个进程结束之前到达且响应比最高的进程放在后一个
        if (i < n - 1) {
            //选出在前一个进程结束前到达的进程
            int j = i + 1;
            while (prov[j].arrivalTime <= prov[i].finishedTime && j < n - 1) {
                j++;
            }
            //计算响应比
            for (int k = i + 1; k <= j; k++) {
                prov[k].responseRatio = (prov[i].finishedTime - prov[k].arrivalTime + prov[k].runningTime) / prov[k].runningTime;
            }
            //选出响应比最高的进程
            unsigned index;
            index = i + 1;
            for (int k = i + 1; k <= j; k++) {
                if (prov[index].responseRatio < prov[k].responseRatio)
                    index = k;
            }
            arrElementSwap(i + 1, index);
        }
    }
 
    cout << "进程执行顺序：";
    for (int i = 0; i < n; i++) {
        cout << prov[i].proNum << " ";
    }
    cout << "\n";
    timeCalculate(n);
}

三、项目结构图

四、小结

本项目模拟实现作业调度中先来先服务、短作业优先和最高响应比调度算法。可任意选择作业数量、各作业的提交时间（时钟时刻）和运行时间（小时）。可以模拟出作业调度过程并显示，即每次作业调度时，各作业的执行情况（开始执行时间，结束时间，周转时间），最后计算并列出平均周转时间，并对相同情况下不同调度算法进行性能分析比较。