操作系统实验——处理器调度

来源：互联网发布：网络建设与管理方案编辑：程序博客网时间：2024/05/20 18:02

Main.c

#include "tools.h"#include "dispatch.h"/** 定义进程数据结构*/int main(){    pro myPro[5] = {{"A",0,3},{"B",2,6},{"C",4,4},{"D",6,5},{"E",8,2}};     for(int i=0;i<n;i++){        print(myPro[i]);//打印进程    }    FCFS(myPro,5);//先来先服务    RR(myPro,5);//乱转，q=1    SPN(myPro,5);//最短进程优先    SRT(myPro,5);//最短剩余时间    HRRN(myPro,5);//最高响应比    return 0;}

tools.h

#define Num 100typedef struct pro{    char name[20]; //进程名称    int arrTime; //到达时间    int serTime; //服务时间    int finTime; //结束时间    int cycTime; //周转时间    float  resRation; //响应比}pro;void printResult(pro process[], int n);void copy(pro process[], pro tempPro[], int n);void sortByArrTime(pro process[], int n);void sortOfPro(pro process[], int sort[],int n);int isFinish(pro process[], int n);void print(pro process);

tools.c

#include<stdio.h>#include<string.h>#define Num 100typedef struct pro{    char name[20]; //进程名称    int arrTime; //到达时间    int serTime; //服务时间    int finTime; //结束时间    int cycTime; //周转时间    float  resRation; //响应比}pro;void print(pro process){    printf("进程：%s\n", process.name);    printf("\t到达时间：%d\n", process.arrTime);    printf("\t服务时间：%d\n", process.serTime);    printf("\t结束时间：%d\n", process.finTime);    printf("\t周转时间：%d\n", process.cycTime);}void printResult(pro process[], int n){    for (int i = 0; i<n; i++) {        printf("进程 %s:\n", process[i].name);        //printf("\t到达时间：%d\n", process[i].arrTime);        //printf("\t服务时间：%d\n", process[i].serTime);        printf("\t完成时间：%d\n", process[i].finTime);        printf("\t周转时间：%d\n", process[i].cycTime);        printf("\t响应比： %.2f\n", process[i].resRation);    }}void copy(pro process[], pro tempPro[], int n){    for (int i = 0; i<n; i++) {        tempPro[i] = process[i];        //print(tempPro[i]);    }}void sortByArrTime(pro process[], int n){    for (int i = 0; i<n; i++) {        for (int j = 0; j<n - i - 1; j++) {            if (process[j].arrTime>process[j + 1].arrTime) {                pro temp = process[j];                process[j] = process[j + 1];                process[j + 1] = temp;            }        }    }}void sortOfPro(pro process[], int sort[],int n){    pro tempPro[Num];    copy(process, tempPro, n);        int hasSort[Num] = { 0 };    sortByArrTime(tempPro, n);    for (int i = 0; i<n; i++) {        for (int j = 0; j<n; j++) {            if (hasSort[j]) {                continue;            }            if (strcmp(process[j].name, tempPro[i].name) == 0) {                sort[j] = i;                break;            }        }    }}int isFinish(pro process[], int n){    for (int i = 0; i<n; i++) {        if (process[i].serTime>0) {            return 0;        }    }    return 1;}

dispatch.h

void FCFS(pro process[], int n);void RR(pro process[], int n);void SPN(pro process[], int n);void SRT(pro process[], int n);void HRRN(pro process[], int n);

FCFS.c

#include "tools.h"/** 先来先服务 FCFS*/void FCFS(pro process[],int n){    pro tempPro[Num];copy(process, tempPro, n);int sort[Num];sortOfPro(process,sort, n);sortByArrTime(tempPro, n);//按达到时间排序，排序后依次执行int currTime = 0;for (int i = 0; i<n; i++) {currTime += tempPro[i].serTime;process[sort[i]].finTime = currTime;process[sort[i]].cycTime = process[sort[i]].finTime - process[sort[i]].arrTime;process[sort[i]].resRation = process[sort[i]].cycTime * 1.0 / process[sort[i]].serTime;}printf("\n------ FCFS -------\n");printResult(process, n);//打印运行结果}

HRRN.c

#include "tools.h"/** 最高响应比优先*/void HRRN(pro process[],int n){    int sort[Num];//进程的对应的顺序    sortOfPro(process, sort, n);    pro tempPro[Num];//拷贝进程数组，防止该表进程数组，影响其他算法的结果    copy(process, tempPro, n);    int currTime = 0;    int maxK, maxResRation;//maxK、maxResRation分别记录最高相应比的对应的进程下标和大小    int k = 0;    int ready[Num];    int m;    while (k<n) {        m = 0;        for (int i = 0; i<n; i++) {            if (tempPro[sort[i]].serTime>0) {                if (m==0) {                    maxK = sort[i];                    maxResRation = tempPro[maxK].resRation;                }                if (tempPro[sort[i]].arrTime <= currTime) {                    tempPro[sort[i]].resRation = (currTime - tempPro[sort[i]].arrTime)*1.0 / tempPro[sort[i]].serTime;                    ready[m++] = sort[i];                }                else {                    break;                }            }        }        //若m=0，说明当前无可运行进程，更新当前时间        if (m == 0) {            currTime = process[maxK].arrTime;        }        else {                 for (int j = 0; j<m; j++) {                if (tempPro[ready[j]].resRation > maxResRation) {                    maxK = ready[j];                    maxResRation = tempPro[maxK].resRation;                }            }            k++;            currTime += process[maxK].serTime;            //记录完成时间、周转时间、响应比            process[maxK].finTime = currTime;            process[maxK].cycTime = process[maxK].finTime - process[maxK].arrTime;            process[maxK].resRation = process[maxK].cycTime * 1.0 / process[maxK].serTime;            tempPro[maxK].serTime = 0;        }    }    printf("\n------ HRRN -------\n");    printResult(process, n);}

RR.c

#include "tools.h"#include<stdio.h>/** 轮转 (轮转时间片为1)*/void RR(pro process[], int n){        int sort[Num];    sortOfPro(process, sort, n);    pro tempPro[Num];    copy(process, tempPro, n);    int currTime = 0;    int k = 1;    int stack[Num];    int m = 1;//堆栈下个运行    stack[0] = sort[0];    int p = 0;//堆栈当前指针    while (1) {        if (isFinish(tempPro, n)) break;//如果所有的进程都已经执行完毕，则终止执行        currTime++;        tempPro[stack[p]].serTime--;        while (k<n && currTime >= tempPro[sort[k]].arrTime) {//如果下一个进程已经到达，则将其加入到队列中来            if (sort[k] != stack[m]) {                stack[m++] = sort[k];                if (m == n)m = 0;            }            k++;        }        if (tempPro[stack[p]].serTime == 0) {            process[stack[p]].finTime = currTime;            process[stack[p]].cycTime = process[stack[p]].finTime - process[stack[p]].arrTime;            process[stack[p]].resRation = process[stack[p]].cycTime * 1.0 / process[stack[p]].serTime;        }        else {            stack[m++] = stack[p];            if (m == n)m = 0;        }        p++;        if (p == n)p = 0;    }    printf("\n------ RR -------\n");    printResult(process, n);//打印相关数据}

SPN.c

#include "tools.h"#include<stdio.h>/** 最短进程优先*/void SPN(pro process[], int n){    int sort[Num];    sortOfPro(process, sort, n);    pro tempPro[Num];    copy(process, tempPro, n);    int currTime = 0;    int minK, minSerTime;    int k = 0;    int ready[Num];    int m;    while (k<n) {        m = 0;        for (int i = 0; i<n; i++) {            if (tempPro[sort[i]].serTime>0) {                if (m==0) {                    minK = sort[i];                    minSerTime = tempPro[minK].serTime;                }                if (tempPro[sort[i]].arrTime <= currTime) {                    ready[m++] = sort[i];                }                else {                    break;                }            }        }        if (m == 0) {//如果ready数组为空，说明当前无可运行进程，将当前时间只为下一个可执行进程的到达时间            currTime = process[minK].arrTime;        }        else {            //找出最短进程            for (int j = 1; j<m; j++) {                if (tempPro[ready[j]].serTime < minSerTime) {                    minK = ready[j];                    minSerTime = tempPro[minK].serTime;                }            }            k++;            currTime += minSerTime;            process[minK].finTime = currTime;            process[minK].cycTime = process[minK].finTime - process[minK].arrTime;            process[minK].resRation = process[minK].cycTime * 1.0 / process[minK].serTime;            tempPro[minK].serTime = 0;        }    }    printf("\n------ SPN -------\n");    printResult(process, n);}

SRT.c

#include "tools.h"#include<stdio.h>/** 最短剩余时间*/void SRT(pro process[], int n){    int sort[Num];    sortOfPro(process, sort, n);    pro tempPro[Num];    copy(process, tempPro, n);    int currTime = 0;    int minK, minSerTime;    int k = 0;    int next = 0;    int ready[Num];    int m;    while (k<n) {        if (next < (n-1)) {            while (currTime >= process[sort[next]].arrTime) {//如果下一个进程已经到达，则将其加入到队列中来                next++;            }        }        m = 0;        for (int i = 0; i<n; i++) {            if (tempPro[sort[i]].serTime > 0) {                if (m==0) {                    minK = sort[i];                    minSerTime = tempPro[minK].serTime;                }                if (tempPro[sort[i]].arrTime <= currTime) {                    ready[m++] = sort[i];                }                else {                    break;                }            }        }        //m==0说明当前无可执行进程,更新当前时间        if (m == 0) {            currTime = process[minK].arrTime;        }        else {                  //找出最短进程            for (int j = 1; j<m; j++) {                if (tempPro[ready[j]].serTime < minSerTime) {                    minK = ready[j];                    minSerTime = tempPro[minK].serTime;                }            }            int interval = tempPro[sort[next]].arrTime - currTime;            //如果当前时间与即将到来的进程的时间间隔小于最短剩余时间，则只执行间隔时间            if (interval>0 && interval < minSerTime) {                minSerTime = interval;            }            tempPro[minK].serTime -= minSerTime;            currTime += minSerTime;            if (tempPro[minK].serTime == 0) {                k++;                process[minK].finTime = currTime;                process[minK].cycTime = process[minK].finTime - process[minK].arrTime;                process[minK].resRation = process[minK].cycTime * 1.0 / process[minK].serTime;            }        }    }    printf("\n------ SRT -------\n");    printResult(process, n);}

0 0