操作系统课程设计一、作业调度

操作系统课程设计一、作业调度#

实验内容###

1、假设系统中可同时运行两道作业，给出每道作业的到达时间和运行时间，如下表所示：

||||||||||
--|:--😐:--😐:--😐:-😐:--😐:--😐
作业名 | A|B|C| D| E|F|G|H|I|J|
到达时间|0|2|5|7|12| 15| 4|6|8|10|
运行时间|7|10|20|30| 40| 8|8|20|10|12|

2、分别用先来先服务算法、短作业优先和响应比高者优先三种算法给出作业的调度顺序。

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

实验功能及设计思路###

程序功能：

1. 支持从文件读入各个作业的信息（作业名，达到时间，运行时间）
2. 支持查看先来先服务算法、短作业优先和响应比高者优先三种算法的作业调度顺序，和每一个作业的周转时间和带权周转时间。以及每一种算法的平均周转时间及平均带权周转时间。
3. 查看三种作业调度算法的性能比较表格，比较算法的优劣。
4. 导出查看原始的进程信息（作业名，达到时间，运行时间）

设计思路：

1. 首先设计一个进程的数据结构，保存进程的静态信息和动态信息。
2. 预处理，在这一步中设定文件路径，读入进程的初始数据，生成对应的数据结构使其使用进程各种变化的操作。
3. 由于存在两个程序的并行，所以设立两个cpu数据，分别表示各自的使用情况。在每次作业调度时候，选择空闲CPU使用。分别设计三个主要的功能函数。分别实现先来先服务算法、短作业优先和响应比高者优先三种算法功能，实现功能聚集。首先熟悉各个算法的思想和算法规则，分析算法的优缺点，分析算法是否存在饥饿现象。计算评价指标。分析周转时间=完成时间-到达时间。带权周转时间=周转时间/运行时间。
4. 对于FCFS算法，算法思路是出于公平的角度，类似我们生活中的排队现象，按照作业到达的先后顺序进行服务，考虑哪个作业先达到后备队列，是一个非抢占式算法。
5. SJF算法，追求的是平均等待时间最短，最短的平均周转时间，最小的平均带权周转时间，是非抢占式算法。
6. HRRN算法，是综合考虑作业的平均等待时间和要求服务的时间，每次调度时候先计算每一个作业的相应比（响应比=等待时间/运行时间+1），是非抢占式算法，只有当前运行作业主动结束时候，才需要调度，计算队列中每一个作业的响应比。
7. 设计一个输出函数，设计一个各个算法性能的比较函数。
8. 在主函数中设计运行菜单，实现功能调用。

源代码##

/*
 先来先服务
 短作业优先
 响应比高算法：响应比 =（等待时间+要求服务时间）/ 要求服务时间
*/
#include<bits/stdc++.h>
using namespace std;
const int N = 10;
const int INF = 0x3f3f3f3f;
struct  pcb
{
    int arrive;  //到达时间
    double rate;   //响应比
    string name; //名称
    int cost;    //运行时间
    int end;    //结束时间
    int turn;      //周转时间
    double tune_weight;
    pcb *next;
};
pcb *pcb_head = new pcb;//头
bool gzr;//输出控制
int cpu0 = 0;  //时钟1
int cpu1 = 0;  //时钟2
double sum_turn = 0;     //周转时间
double ave_turn_wei = 0;    //平均带权周转时间
void pre_work() {
    cpu0 = 0;
    cpu1 = 0;
    sum_turn = 0;
    ave_turn_wei = 0;
    ifstream iflie;
    iflie.open("/home/gzr/files/input/test1");
    pcb_head->next = NULL;
    pcb*t = new pcb;
    t->next = pcb_head->next;
    iflie >> t->name >> t->arrive >> t->cost;
    t->rate = 1;
    pcb_head = t;

    for (int i = 0; i <9; i++) {
        pcb *temp = new pcb;
        iflie >> temp->name >> temp->arrive >> temp->cost;
        pcb *p =pcb_head;
        temp->rate = 0x3f3f3f3f;
        while (p->next!=NULL)
        {
            p = p->next;
        }
        temp->next = p->next;
        p->next = temp;
    }
    iflie.close();
}
void out_put() {
    cout << "平均周转：     " << sum_turn /N;
    cout << "      平均带权周转： " << ave_turn_wei / N << endl;
}
void out1(pcb* p) {
    if (gzr == 0)return;
    cout << p->name << setw(15) << p->end << setw(15) << p->turn << setw(15) << p->tune_weight << endl;
}
//FIFS
void fun1() {
    cout << "先来先服务算法：" << endl;
    pre_work();
    if (gzr)cout << "进程       结束时间      周转时间        带权周转时间 " << endl;
    bool flag;
    for (int i = 0; i <N; i++) {
        pcb*p = new pcb;
        pcb*q = new pcb;
        p = pcb_head;
        flag = false;
        q->arrive = INF;
        q->next = NULL;
        while (p != NULL) {
            if (p->cost != 0 && p->arrive <= q->arrive && (p->arrive <= cpu0 || p->arrive <= cpu1))
            {
                q = p;
                flag= true;
            }
            p = p->next;
        }
        if (flag == false) {
            p = pcb_head;
            while (p!=NULL)
            {
                if (p->cost != 0 && p->arrive < q->arrive)q = p;
                p = p->next;
            }
        }
        if (cpu0 <= cpu1)
        {
            if (i == 0) cpu0 = q->arrive;
            if (!flag) cpu0 = q->arrive;
            cpu0 += q->cost;
            q->end = cpu0;
            q->turn = q->end - q->arrive;      sum_turn += q->turn;
            q->tune_weight = q->turn / (q->cost*1.0);   ave_turn_wei += q->tune_weight;
            q->cost = 0;
            out1(q);
        }
        else {
            if (i == 1 || flag == false)cpu1 = q->arrive;
            cpu1 += q->cost;
            q->end = cpu1;
            q->turn = q->end - q->arrive;      sum_turn += q->turn;
            q->tune_weight = q->turn / (q->cost*1.0);   ave_turn_wei += q->tune_weight;
            q->cost = 0;
            out1(q);

        }
    }
    out_put();
}
//短作业优先
void fun2() {
    cout << "短进程优先算法：" << endl;
    pre_work();
    if (gzr)cout << "进程       结束时间      周转时间        带权周转时间 " << endl;
    bool flag;
    for (int i = 0; i < N; i++) {
        pcb*p = new pcb;
        pcb*q = new pcb;
        p = pcb_head;
        flag = false;
        q->cost = INF;
        q->next = NULL;
        q->arrive = INF;
        while (p != NULL)
        {
            if (cpu0 <= cpu1 && p->arrive <= cpu0)
            {
                if (p->cost != 0 && p->cost <= q->cost)
                {
                    q = p;
                    flag = true;
                }
            }
            if (cpu0 > cpu1&&p->arrive <= cpu1)
            {
                if (p->cost != 0 && p->cost <= q->cost)
                {
                    q = p;
                    flag = true;
                }
            }
            p = p->next;
        }
        if (flag == false) {
            p = pcb_head;
            while (p != NULL)
            {
                if (p->cost != 0 && p->arrive < q->arrive)q = p;
                p = p->next;
            }
        }
        if (cpu0 <= cpu1)
        {
            if (i == 0||!flag) cpu0 = q->arrive;
            cpu0 += q->cost;
            q->end = cpu0;
            q->turn = q->end - q->arrive;      sum_turn += q->turn;
            q->tune_weight = q->turn / (q->cost*1.0);   ave_turn_wei += q->tune_weight;
            q->cost = 0;
            out1(q);
        }
        else {
            if (i == 1 || flag == false)cpu1 = q->arrive;
            cpu1 += q->cost;
            q->end = cpu1;
            q->turn = q->end - q->arrive;      sum_turn += q->turn;
            q->tune_weight = q->turn / (q->cost*1.0);   ave_turn_wei += q->tune_weight;
            q->cost = 0;
            out1(q);

        }
    }
    out_put();
}
//响应比高者优先
void fun3() {
    pre_work();
    cout << "响应比优先算法：" << endl;
    if (gzr)cout << "进程       结束时间      周转时间        带权周转时间 " << endl;
    //是否输出多余信息
    bool flag;
    for (int i = 0; i < N; i++) {
        pcb*p = new pcb;
        pcb*q = new pcb;
        p = pcb_head;
        flag = false;
        q->rate = -INF;
        q->next = NULL;
        q->arrive = INF;
        //选择是那个CPU计算响应比
        if (cpu0 <= cpu1 && p->arrive <= cpu0) {
            pcb*t = pcb_head;
            while (t != NULL) {
                //计算剩余响应比
                if (t->cost != 0)t->rate = (cpu0 - t->arrive) / (t->cost*1.0) + 1;
                t = t->next;
            }

        }
        else if (cpu0 > cpu1&&p->arrive <= cpu1)
        {
            pcb *t = pcb_head;
            while (t != NULL)
            {
                if (t->cost != 0)t->rate = (cpu1 - t->arrive) / (t->cost*1.0) + 1;
                t = t->next;
            }
        }
        if(p->arrive <= cpu1|| p->arrive <= cpu0)
            while (p != NULL)
        {
            if (p->cost != 0 && p->rate >= q->rate) {
                q = p;
                flag = true;
            }
            p = p->next;
        }
        if (flag == false) {
            p = pcb_head;
            while (p != NULL)
            {
                if (p->cost != 0 && p->arrive < q->arrive)q = p;
                else if (p->cost != 0 && p->arrive == q->arrive) {//考虑相等
                    if (p->cost<q->cost)q = p;
                }
                p = p->next;
            }
        }
        if (cpu0 <= cpu1)
        {
            if (i == 0 || !flag) cpu0 = q->arrive;
            cpu0 += q->cost;
            q->end = cpu0;
            q->turn = q->end - q->arrive;      sum_turn += q->turn;
            q->tune_weight = q->turn / (q->cost*1.0);   ave_turn_wei += q->tune_weight;
            q->cost = 0;
            out1(q);
        }
        else {
            if (i == 1 || flag == false)cpu1 = q->arrive;
            cpu1 += q->cost;
            q->end = cpu1;
            q->turn = q->end - q->arrive;      sum_turn += q->turn;
            q->tune_weight = q->turn / (q->cost*1.0);   ave_turn_wei += q->tune_weight;
            q->cost = 0;
            out1(q);

        }
    }
    out_put();
}
void fun4() {
    gzr = 0;
    fun1();
    fun2();
    fun3();
}
void fun5() {
        pre_work();
        cout << "进程   到达时间   运行时间" << endl;
        pcb *pp = new pcb;
        pp=pcb_head;

        while (pp != NULL)
        {
            cout << pp->name << setw(10) << pp->arrive << setw(10) << pp->cost << endl;
            pp = pp->next;
        }
        cout << endl;
}
int main() {
    while (1) {
        cout << "************选择作业调度算法************** " << endl;
        cout << "            1.FCFS算法               " << endl;
        cout << "            2.SJF算法 " << endl;
        cout << "            3.HRRN算法 " << endl;
        cout << "            4.查看各个算法性能比较表 " << endl;
        cout << "            5.查看各个进程的信息 " << endl;
        char ch;
        cin >> ch;
        cout << endl;
        switch (ch)
        {
        case '1':gzr = 1; fun1();
            break;
        case '2':gzr = 1; fun2();
            break;
        case '3':gzr = 1; fun3();
            break;
        case '4': fun4();
            break;
        case '5':fun5();
            break;
        default:
            cout << "输入有误！！" << endl;
            break;
        }
    }
}