实验一 处理机调度

​ 学号： 班级： 姓名：

一、实验环境

二、实验内容

1．对于给定的一组作业,给出其到达时间和运行时间，例如下表所示：

2．每个作业用一个作业控制块JCB来代表，作业控制块的结构包括：作业名、到达时间、服务时间、开始时间、完成时间、周转时间、带权周转时间、链接指针等。

3．分别用先来先服务算法、短作业优先和响应比高者优先三种调度算法进行调度，显示逐次被选中作业的作业名以及作业后备队列的变化。调度全部完成后显示所有作业的作业名、到达时间、服务时间、开始时间、完成时间、周转时间、带权周转时间的列表。

4．计算每一种算法的平均周转时间及平均带权周转时间并比较不同算法的优劣。

三、附代码

#include<cstdio>
#include<stdlib.h>
#include<cstring>
#include<algorithm>

using namespace std;
struct jcb {
    char name[10];//作业名
    float subTime;//到达时间
    float waitTime;//等待时间
    float startTime;//开始时间
    float runTime;//服务时间
    float finishTime;//完成时间
    float cycleTime; //周转时间
    float ValueCycleTime;//带权周转时间
    float rp;//响应比
};
jcb JCB[100];


void display(int y)
{
    int i;
    printf("\n");
    printf("作业%s先开始服务\n\n", JCB[0].name);
    float AvgCycleTime, AvgValueCycleTime, k = 0, m = 0;//AvgCycleTime为平均周转时间,AvgValueCycleTime为平均带权周转时间
    for (i = 0; i < y; i++)
    {
        JCB[0].startTime = JCB[0].subTime;
        JCB[i].finishTime = JCB[i].startTime + JCB[i].runTime;//完成时间    
        JCB[i + 1].startTime = JCB[i].finishTime;
        JCB[i].waitTime = JCB[i].startTime - JCB[i].subTime;//等待时间
        JCB[i].cycleTime = JCB[i].finishTime - JCB[i].subTime;//周转时间
        JCB[i].ValueCycleTime = JCB[i].cycleTime / JCB[i].runTime;//带权周转时间
        k += JCB[i].cycleTime;
        m += JCB[i].ValueCycleTime;
    }
    AvgCycleTime = k / y;//平均周转时间
    AvgValueCycleTime = m / y;//平均带权周转时间

    printf("作业名 到达时间 服务时间 开始时间 完成时间 等待时间 周转时间 带权周转时间\n");
    for (i = 0; i < y; i++)
        printf("%s\t%.2f\t%.2f\t%4.2f\t%6.2f\t%7.2f\t%7.2f\t%8.2f\n\n", JCB[i].name, JCB[i].subTime, JCB[i].runTime, JCB[i].startTime, JCB[i].finishTime, JCB[i].waitTime, JCB[i].cycleTime, JCB[i].ValueCycleTime);

    printf("平均周转时间为：");
    printf("%.2f\n\n", AvgCycleTime);
    printf("平均带权周转时间为：");
    printf("%.2f\n\n", AvgValueCycleTime);
}

bool cmpsubTime(jcb x, jcb y) {//sort 排序 
    return x.subTime < y.subTime;
}


void FCFS(int y)//先来先服务算法
{
    sort(JCB, JCB + y, cmpsubTime);
    display(y);
}

void SJF(int y)//短作业优先算法
{
    sort(JCB, JCB + y, cmpsubTime);//先按照到达时间排序
    double subTime = 0, runTime = 0, startTime = 0, finishTime = 0, zhouzhuan = 0;//对结构进行

    int n, m;
    for (m = 0; m < y - 1; m++)
    {
        if (m == 0)
            JCB[m].finishTime = JCB[m].subTime + JCB[m].runTime;
        else
            JCB[m].finishTime = JCB[m - 1].finishTime + JCB[m].runTime;
        int i = 0;
        for (n = m + 1; n <= y - 1; n++)
        {
            if (JCB[n].subTime <= JCB[m].finishTime)//判断内存中每次完成之后有多少到达的进程
                i++;
            else break;
        }
        float min = JCB[m + 1].runTime;
        int next = m + 1;//m+1=n
        int k;
        for (k = m + 1; k < m + i; k++) //找出到达后的进程中最小的进程
        {
            if (JCB[k + 1].runTime < min)
            {
                min = JCB[k + 1].runTime;
                next = k + 1;
            }
        }
        jcb temp;
        temp = JCB[m + 1];
        JCB[m + 1] = JCB[next];
        JCB[next] = temp;
    }
    display(y);
}

void HRRN(int y)//响应比高者优先算法
{
    sort(JCB, JCB + y, cmpsubTime);//先按照到达时间排序   
    int n, m;
    for (m = 0; m < y - 1; m++)
    {
        if (m == 0)
            JCB[m].finishTime = JCB[m].subTime + JCB[m].runTime;
        else
            JCB[m].finishTime = JCB[m - 1].finishTime + JCB[m].runTime;
        int i = 0;
        for (n = m + 1; n <= y - 1; n++) {
            if (JCB[n].subTime <= JCB[m].finishTime)//判断内存中每次完成之后有多少到达的进程
                i++;
            else break;
        }
        JCB[m + 1].waitTime = JCB[m].finishTime - JCB[m + 1].subTime;//等待时间
        JCB[m + 1].rp = (JCB[m + 1].waitTime / JCB[m + 1].runTime) + 1;//响应比
        printf("%s的响应比为：%.2f\n", JCB[m + 1].name, JCB[m + 1].rp);
        float max = JCB[m + 1].rp;
        int next = m + 1;//m+1=n
        int k;
        for (k = m + 1; k < m + i; k++) //找出到达后的进程中响应比最大的进程
        {

            JCB[k + 1].waitTime = JCB[m].finishTime - JCB[k + 1].subTime;
            JCB[k + 1].rp = (JCB[k + 1].waitTime / JCB[k + 1].runTime) + 1;
            printf("%s的响应比为：%.2f\n", JCB[k + 1].name, JCB[k + 1].rp);
            if (JCB[k + 1].rp > max)
            {
                max = JCB[k + 1].rp;
                next = k + 1;
            }



        }
        printf("\n");
        jcb temp;
        temp = JCB[m + 1];
        JCB[m + 1] = JCB[next];
        JCB[next] = temp;
    }
    display(y);
}

int main()
{
    int i, x, y;
loop3:printf("-----------------请选择作业调度算法------------------\n");
    printf("1:采用先来先服务 (FCFS) 调度算法\n2:采用短作业优先 (SJF) 调度算法\n3:采用响应比高者优先 (HRRN) 调度算法\n");
loop1:printf("请选择：");
    scanf("%d", &i);
    if (i <= 0 || i > 3)
    {
        printf("输入有误，请重新输入\n");
        goto loop1;//无条件转移语句
    }
loop2:printf("请输入作业的个数(2-80):");
    scanf("%d", &y);
    if (y >= 2 && y <= 80)
    {
        printf("作业名 到达时间 服务时间\n");
        for (x = 0; x < y; x++) {
            scanf("%s\t%f\t%f", &JCB[x].name, &JCB[x].subTime, &JCB[x].runTime);
        }
    }
    else {
        printf("输入有误，请重新输入\n");
        goto loop2;
    }
    switch (i) {
    case 1: {
        FCFS(y);
        goto loop3;
        break;
    }
    case 2: {
        SJF(y);
        goto loop3;
        break;
    }
    case 3: {
        HRRN(y);
        goto loop3;
        break;
    }
    }
    return 0;
}