操作系统调度算法实验

sourcedream
276 阅读2分钟 
# 先来先到调度算法

先来先服务调度算法FCFS

FCFS是最简单的调度算法，该算法既可用于作业调度，也可用于进程调度。当在作业调度中采用该算法时，系统将按照作业到达的先后次序来进行调度，或者说它是优先考虑在系统中等待时间最长的作业，

周转时间和带权周转时间

周转时间=完成时间-到达时间 带权周转时间=周转时间/执行时间

#include <stdio.h>
#include <string.h>
​
#define N 5
​
typedef struct JCB
{
    char name[10];
    int arriveTime;  //到达时间 
    int serveTime;   //服务时间 
    int finishTime;  //完成时间 
    int aroundTime;  //周转时间 
    float waroundTime; //带权周转时间 
}PCB;
​
​
​
void input(PCB pcb[N])
{
    strcpy(pcb[0].name,"A");
    pcb[0].arriveTime = 0;
    pcb[0].serveTime = 3;
    
    strcpy(pcb[1].name,"B");
    pcb[1].arriveTime = 2;
    pcb[1].serveTime = 6;
    
    strcpy(pcb[2].name,"C");
    pcb[2].arriveTime = 4;
    pcb[2].serveTime = 4;
    
    strcpy(pcb[3].name,"D");
    pcb[3].arriveTime = 6;
    pcb[3].serveTime = 5;
    
    strcpy(pcb[4].name,"E");
    pcb[4].arriveTime = 8;
    pcb[4].serveTime = 2;
    
    int i = 0;
    for(; i < N; ++i)
    {
        pcb[i].finishTime = 0;
        pcb[i].aroundTime = 0;
        pcb[i].waroundTime = 0;
    }
​
}
​
void output(PCB pcb[N])
{
    int i = 0;
    printf("进程\t");
    printf("完成时间\t");
    printf("周转时间\t");
    printf("带权周转时间\t\n");
    for(; i < N; ++i)
    {
        printf("%s\t",pcb[i].name);
        printf("%d\t\t",pcb[i].finishTime);
        printf("%d\t\t",pcb[i].aroundTime);
        printf("%f\t\t\n",pcb[i].waroundTime);
    }
}
​
//先来先服务调度算法 
void FCFS(PCB pcb[N])
{
    int t=pcb[0].arriveTime;
    for(int i=0;i<N;++i)
    {
        t+=pcb[i].serveTime;
        pcb[i].finishTime=t;
        pcb[i].aroundTime=t-pcb[i].arriveTime;
        pcb[i].waroundTime=(1.0*pcb[i].aroundTime)/pcb[i].serveTime;
    }
}
​
​
​
int main()
{
    PCB pcb[N];
    
    input(pcb);
    FCFS(pcb);
    printf("先来先服务FCFS:\n"); 
    output(pcb);
    printf("\n");
    
}
​

短作业优先调度算法

短作业优先调度算法SJF

SJF算法是以作业的长短来计算优先级，作业越短，其优先级越高。作业的长短是以作业所要求的运行时间来衡量的。SJF算法可以分别用于作业调度和进程调度，处理机优先选择运行时间短的作业或者进程。

周转时间和带权周转时间

周转时间=完成时间-到达时间 带权周转时间=周转时间/执行时间

#include <stdio.h>
#include <string.h>
​
#define N 5
​
typedef struct JCB
{
    char name[10];
    int arriveTime;    //到达时间
    int serveTime;     //服务时间
    int finishTime;    //完成时间
    int aroundTime;    //周转时间
    float waroundTime; //带权周转时间
} PCB;
​
void input(PCB pcb[N])
{
    strcpy(pcb[0].name, "A");
    pcb[0].arriveTime = 0;
    pcb[0].serveTime = 3;
​
    strcpy(pcb[1].name, "B");
    pcb[1].arriveTime = 2;
    pcb[1].serveTime = 6;
​
    strcpy(pcb[2].name, "C");
    pcb[2].arriveTime = 4;
    pcb[2].serveTime = 4;
​
    strcpy(pcb[3].name, "D");
    pcb[3].arriveTime = 6;
    pcb[3].serveTime = 5;
​
    strcpy(pcb[4].name, "E");
    pcb[4].arriveTime = 8;
    pcb[4].serveTime = 2;
​
    int i = 0;
    for (; i < N; ++i)
    {
        pcb[i].finishTime = 0;
        pcb[i].aroundTime = 0;
        pcb[i].waroundTime = 0;
    }
}
​
void output(PCB pcb[N])
{
    int i = 0;
    printf("进程\t");
    printf("完成时间\t");
    printf("周转时间\t");
    printf("带权周转时间\t\n");
    for (; i < N; ++i)
    {
        printf("%s\t", pcb[i].name);
        printf("%d\t\t", pcb[i].finishTime);
        printf("%d\t\t", pcb[i].aroundTime);
        printf("%f\t\t\n", pcb[i].waroundTime);
    }
}
​
//短作业优先调度算法
void SJF(PCB pcb[N])
{
    int flag[N] = {0};
    //先调度第一个
    flag[0] = 1;
    int t = pcb[0].arriveTime;
    t += pcb[0].serveTime;
    pcb[0].finishTime = t;
    pcb[0].aroundTime = pcb[0].serveTime;
    pcb[0].waroundTime = 1;
    //再调度后面的
    for (int i = 1; i < N; i++)
    {
        int min = 1, minServe = 32726;
        //找出时间最少的且未调度的
        for (int j = 1; j < N; j++)
        {
            if (pcb[j].serveTime < minServe && pcb[j].arriveTime < t && flag[j] == 0)
            {
                min = j, minServe = pcb[j].serveTime;
            }
        }
        flag[min] = 1;
        t += pcb[min].serveTime;
        pcb[min].finishTime = t;
        pcb[min].aroundTime = pcb[min].finishTime - pcb[min].arriveTime;
        pcb[min].waroundTime = (1.0 * pcb[min].aroundTime) / pcb[min].serveTime;
    }
}
​
int main()
{
    PCB pcb[N];
​
    input(pcb);
    SJF(pcb);
    printf("短作业优先SJF:\n");
    output(pcb);
    printf("\n");
}
​

高响应比优先调度算法

高响应比优先调度算法HRRN

在批处理系统中，FCFS算法所考虑的只是作业的等待时间，而忽视了作业的运行时间。而SJF算法正好与之相反，只考虑作业的运行时间，而忽视了作业的等待时间。高响应比优先调度算法则是既考虑了作业的等待时间，又考虑作业运行时间的调度算法，因此既照顾了短作业，又不致使长作业的等待时间过长，从而改善了处理机调度的性能。 高响应比优先算法引入了响应比的概念，响应比定义如下 响应比=（等待时间+运行时间）/运行时间 高响应比优先算法每次选择响应比最高的进程，进程的响应比是动态变化的，既考虑了进程的等待时间，也考虑了进程的服务时间。

周转时间和带权周转时间

周转时间=完成时间-到达时间 带权周转时间=周转时间/执行时间

#include <stdio.h>
#include <string.h>
​
#define N 5
​
typedef struct JCB
{
    char name[10];
    int arriveTime;    //到达时间
    int serveTime;     //服务时间
    int finishTime;    //完成时间
    int aroundTime;    //周转时间
    float waroundTime; //带权周转时间
} PCB;
​
void input(PCB pcb[N])
{
    strcpy(pcb[0].name, "A");
    pcb[0].arriveTime = 0;
    pcb[0].serveTime = 3;
​
    strcpy(pcb[1].name, "B");
    pcb[1].arriveTime = 2;
    pcb[1].serveTime = 6;
​
    strcpy(pcb[2].name, "C");
    pcb[2].arriveTime = 4;
    pcb[2].serveTime = 4;
​
    strcpy(pcb[3].name, "D");
    pcb[3].arriveTime = 6;
    pcb[3].serveTime = 5;
​
    strcpy(pcb[4].name, "E");
    pcb[4].arriveTime = 8;
    pcb[4].serveTime = 2;
​
    int i = 0;
    for (; i < N; ++i)
    {
        pcb[i].finishTime = 0;
        pcb[i].aroundTime = 0;
        pcb[i].waroundTime = 0;
    }
}
​
void output(PCB pcb[N])
{
    int i = 0;
    printf("进程\t");
    printf("完成时间\t");
    printf("周转时间\t");
    printf("带权周转时间\t\n");
    for (; i < N; ++i)
    {
        printf("%s\t", pcb[i].name);
        printf("%d\t\t", pcb[i].finishTime);
        printf("%d\t\t", pcb[i].aroundTime);
        printf("%f\t\t\n", pcb[i].waroundTime);
    }
}
​
//短作业优先调度算法
void SJF(PCB pcb[N])
{
    int flag[N] = {0};
    //先调度第一个
    flag[0] = 999;
    int t = pcb[0].arriveTime;
    t += pcb[0].serveTime;
    pcb[0].finishTime = t;
    pcb[0].aroundTime = pcb[0].serveTime;
    pcb[0].waroundTime = 1;
    //再调度后面的
    for (int i = 1; i < N; i++)
    {
        //计算响应比
        for (int j = 1; j < N; j++)
        {
            if (flag[j] != 999 && t > pcb[j].arriveTime)
            {
                flag[j] = (1.0 * ((t - pcb[j].arriveTime) + pcb[j].serveTime)) / pcb[j].serveTime;
            }
        }
        int max = 1, maxResponse = 0;
        //找出相应比最高的且未调度的且到达的
        for (int j = 1; j < N; j++)
        {
            if (flag[j] > maxResponse && flag[j] != 999 && t > pcb[j].arriveTime)
            {
                max = j, maxResponse = flag[j];
            }
        }
        flag[max] = 999;
        t += pcb[max].serveTime;
        pcb[max].finishTime = t;
        pcb[max].aroundTime = pcb[max].finishTime - pcb[max].arriveTime;
        pcb[max].waroundTime = (1.0 * pcb[max].aroundTime) / pcb[max].serveTime;
    }
}
​
int main()
{
    PCB pcb[N];
​
    input(pcb);
    SJF(pcb);
    printf("高响应比优先HRRN:\n");
    output(pcb);
    printf("\n");
}
​
avatar
文章
阅读
粉丝