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

最新推荐文章于 2024-01-20 16:40:27 发布
最新推荐文章于 2024-01-20 16:40:27 发布
阅读量4.7k 收藏 101
点赞数 7
分类专栏： 本科课程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/gzr2018/article/details/104913268
版权

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

实验内容

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

作业名ABCDEF
到达时间02571215
运行时间7102030408

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;
        }
    }
}
操作系统课程设计——作业调度
weixin_49800246的博客
01-02 1607
操作系统课程设计——作业调度 实验目的 掌握周转时间、等待时间、平均周转时间等概念及其计算方法。 理解四种常用的作业调度算法（FCFS,SJF,HRRF,HPF），区分算法之间的差异性，用C语言模拟实现各种算法 了解操作系统中高级调度、中级调度和低级调度的区别和联系。 实验准备 掌握程序、进程、作业的基本概念。 掌握进程调度、作业调度的区别和联系。 掌握C语言基本语法和struct结构及其用法。 实验基本知识及原理 基本概念：什么是程序，什么是进程，什么是作业，什么是作业调度； 基本调
操作系统中的调度算法详解
最新发布
cang_ling的博客
02-13 379
在操作系统中，调度是指对多个进程的执行进行合理安排，以提高系统的效率和资源利用率。本文将详细介绍几种常见的调度算法：先来先服务（FCFS）、短作业优先（SJF）、时间片轮转（RR），并提供对应的 Java 实现代码。通过这些代码示例，大家可以更直观地理解调度算法的实现和应用场景。如果有任何问题，欢迎在评论区讨论！是一种最简单的调度算法，按照进程到达的顺序分配 CPU。是一种抢占式算法，每个进程按照固定的时间片轮流执行。根据进程的执行时间优先调度短任务。
操作系统课程设计（作业调度 作业调度）
07-03
关于作业调度 有算法三个（先来先服务 短作业优先 最高响应比）C编译
操作系统作业调度课设
ryh2004812的博客
01-20 1269
设计要求：编程实现一个作业模拟调度程序，计算不同调度算法下的作业平均周转周期及带权周转周期。实现调度算法：1）先来先服务；2）短作业优先；3）最高响应比优先。每个作业有一个作业控制块（JCB），主要包含信息：作业控制ID，作业名，作业达到时间，作业运行时间，作业完成时间，作业状态等。设计内容：1）作业数不得少于5个。2）演示不同算法的调度过程。3）计算不同算法下的作业平均周转周期及带权周转周期。本实训以Windows为平台，以C语言为设计语言，进行操作系统各种算法的模拟实现。
操作系统作业调度课程设计
07-25
本资源是操作系统课程设计中的作业调度设计，文档中描述了三种作业调度算法：先来先服务算法、短作业优先算法、响应比高者优先算法，并且给出了三种算法的数据分析比较。
作业调度课程设计
06-18
呵呵，方便懒人使用~~~~~~··
操作系统课程设计大作业C++进程调度算法的模拟实现源码.zip
06-17
操作系统课程设计大作业C++进程调度算法的模拟实现源码，实现了 动态优先级、先来先服务、时间片轮转 三个算法 安装教程 下载到本地，然后直接用VS打开运行即可 操作系统课程设计大作业C++进程调度算法的模拟实现...
操作系统课程设计（作业调度、内存管理、进程调度、进程阻塞等）
06-28
在“操作系统课程设计”中，我们通常会关注以下几个关键领域：作业调度、内存管理、进程调度以及进程阻塞。这些概念是理解操作系统工作原理的核心。 1. **作业调度**： 作业调度是操作系统中的第一级调度，它负责...
四川大学操作系统课程设计高分报告-第四次实验-作业调度系统.doc
08-18
操作系统中的作业调度是确保系统高效运行的关键组成部分，尤其是在四川大学的操作系统课程设计中，这个第四次实验专注于理解和实现作业调度系统。在这个实验中，学生们深入学习了调度算法、Linux进程控制以及进程间...
操作系统课程设计磁盘调度算法.doc
06-16
操作系统课程设计磁盘调度算法是计算机操作系统中的一种重要算法，用于确定磁盘读写操作的顺序，以提高磁盘的读写效率。本文将对磁盘调度算法的设计进行详细的介绍，并对其实现过程进行剖析。 1. 操作系统课程设计...
操作系统课程设计高级调度算法设计
02-01
总之，"操作系统课程设计高级调度算法设计"项目是一个集理论与实践于一体的优秀学习资源，它涵盖了操作系统中重要的调度算法，并以直观的可视化方式呈现，对于理解和掌握这些算法有着极大的帮助。通过实际操作，学习...
操作系统课设（作业调度）
12-01
该实验是实现作业调度里的不同调度算法，包括先来先服务，段作业优先，高响应比作业优先。
操作系统课程设计作业调度算法源程序
07-25
该资源是操作系统课程设计中作业调度算法的源程序，程序中主要用三种作业调度算法来实现一次作业调度，三种算法分别为：先来先服务算法、短作业优先算法、响应比高者优先算法。程序简单易懂，包含大量注释。
操作系统课程设计的作业调度
05-11
操作系统课程设计中，时间片轮转，作业调度系统的源代码和任务书和说明书
操作系统课程设计
weixin_42204713的博客
01-03 1300
一.设计目的：熟悉Linux编程环境，加强对Linux命令的理解及函数的运用 二.设计内容： 在Linux环境下模拟实现简单命令解释器（即定义一个命令使它具有Linux中某些命令的功能） 例如：定义mydir使它具有dir 的功能 即在Linux环境中 $ mydir 和 $dir 作用一样 就实现了dir命令的解释。 (1)要求实现的基本命令包括： 定义 mypwd 具有 ...
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值