操作系统 实验1【短作业优先调度算法（C++代码实现——FCFS\SJF\HRRN）】

最新推荐文章于 2023-05-09 11:50:01 发布
最新推荐文章于 2023-05-09 11:50:01 发布
阅读量1.9w 收藏 333
点赞数 47
分类专栏： 操作系统 文章标签： 操作系统 c++ FCFS SJF HRRN
希望对您有所帮助；知识共享，欢迎转载，转载时：请附上原文链接！
本文链接：https://blog.csdn.net/weixin_44949135/article/details/116242551
版权
本文档详述了操作系统实验中的四种作业调度算法——FCFS、SJF、HRRN的C++实现。实验目标是理解和掌握作业调度功能，通过模拟实现不同调度策略，计算并展示作业的周转时间、带权周转时间等关键指标。实验内容包括作业结构体定义、排序算法编写、时间值计算、调度算法实现及结果输出。测试样例展示了算法的实际应用效果，实验总结强调了理论与实践的结合对操作系统学习的重要性。
摘要由CSDN通过智能技术生成
  1. 操作系统 实验1【短作业优先调度算法（C++实现——FCFS\SJF\HRRN）】
  2. 操作系统 实验2【动态高优先权优先调度算法 C++实现】
  3. 操作系统 实验3【动态分区存储管理 Python实现】
  4. 操作系统 实验4【基本分页存储管理 C++实现】

目录

一、实验目的（目的与任务）

二、实验内容（内容、要求与安排方式）

三、实验代码

①首先需要定义一个作业结构体

②编写排序算法

③计算作业的各个时间值

④FCFS与SJF的具体实现

⑤编写函数，打印输出作业的各个时间值

完整实验代码

将程序打包为exe文件

四、实验结果

测试样例1

测试样例2

五、实验总结

一、实验目的（目的与任务）

目的：了解并掌握作业调度的功能，熟悉并掌握各种作业调度算法。

任务：模拟实现先来先服务调度算法（FCFS）或者短作业优先调度算法（SJF）。

二、实验内容（内容、要求与安排方式）

实验学时：2            实验类型：综合型

1．实验内容与要求：

（1）实验内容

模拟实现SJF调度。

设置作业体：作业名，作业的到达时间，服务时间，作业状态（W——等待,R——运行,F——完成），作业间的链接指针；

作业初始化：由用户输入作业名、服务时间、到达时间进行初始化，同时，初始化作业的状态为W。

显示函数：在作业调度前、调度中和调度后进行显示。

排序函数：对等待状态的作业按照调度算法排序（不同的调度算法排序方式不同），注意考虑到达时间。

调度函数：每次从等待队列队首调度已到达的适合的作业执行，状态变化。当服务结束时，状态变为F。

删除函数：撤销状态为F的作业。

（2）实验要求

①测试数据可以随即输入或从文件中读入；

②必须要考虑到作业的到达时间；

③最终能够计算每一个作业的周转时间、带权周转时间。

2．实验安排方式：

上机。

3．实验设备

1．所用设备：装有C/C++/JAVA等编程环境的计算机。

2．消耗性器材：无。

三、实验代码

在这里插入图片描述

①首先需要定义一个作业结构体

struct process

{

    string pid;         //作业名（作业号）

    double come_time;  //到达时

    double run_time;   //运行时

    double begin_time; //开始时

    double over_time;  //完成时

    double round_time; //周转时

    double avg_time;   //带权周转时

    double HRR;        //响应比

} pc[MAXSIZE];         //作业数

②编写排序算法

bool CmpByComeTime(process p1, process p2) // 按到达时间正序排序

{

    return p1.come_time < p2.come_time;

}

bool CmpByPid(process p1, process p2) // 按id号正序排序

{

    return p1.pid < p2.pid;

}

bool CmpByRunTime(process p1, process p2) // 按运行时长正序排序

{

    return p1.run_time == p2.run_time ? p1.come_time < p2.come_time : p1.run_time < p2.run_time;

}

bool CmpByHRR(process p1, process p2) // 按响应比逆序排序

{

    return p1.HRR > p2.HRR;

}

③计算作业的各个时间值

  1. 完成时间=开始时间+服务时间
  2. 周转时间=完成时间-到达时间
  3. 带权周转时间=周转时间/服务时间

void get_beginAndOver_time() // 计算作业的开始时间与完成时间

{

    for (int i = 0; i < number; i++)

    {

        if (i == 0)

        {

            pc[i].begin_time = pc[i].come_time; // 第一个作业的开始时即为其到达时

        }

        else

        {

            pc[i].begin_time = pc[i - 1].over_time; // 否则后一作业的开始时为前一个作业的完成时

        }

        pc[i].over_time = pc[i].begin_time + pc[i].run_time; // 作业完成时 = 开始时间 + 运行时间

    }

}

 

void get_roundAndAvg_time() // 计算作业的周转时间与带权周转时间

{

    for (int i = 0; i < number; ++i)

    {

        pc[i].round_time = pc[i].over_time - pc[i].come_time;     // 周转时 = 完成时间 - 到达时间

        pc[i].avg_time = pc[i].round_time * 1.0 / pc[i].run_time; // 平均周转时 = 周转时间 / 运行时间

    }

}

④FCFS与SJF的具体实现

void FCFS()

{

    sort(pc, pc + number, CmpByComeTime);

    get_beginAndOver_time();

    get_roundAndAvg_time();

}

 

void SJF()

{

    sort(pc, pc + number, CmpByComeTime);    // 先按到达时排序

    sort(pc + 1, pc + number, CmpByRunTime); // 再按运行时排序

    get_beginAndOver_time();

    get_roundAndAvg_time();

}

⑤编写函数，打印输出作业的各个时间值

void printResult() // 打印输出作业的各个时间值

{

    cout << "执行顺序："; // << endl

    for (int i = 0; i < number; ++i)

    {

        /* code */

        cout << pc[i].pid << " ";

    }

    cout << endl;

    cout << "作业名" << '\t' << "到达时" << '\t' << "运行时" << '\t'

         << "开始时" << '\t' << "完成时" << '\t' << "周转时" << '\t'

         << "带权周转时" << '\t' << endl;

    sort(pc, pc + number, CmpByPid);

    double sum_round_time = 0.0;

    double avg_sum_round_time = 0.0;

    double sum_avg_time = 0.0;

    double avg_sum_avg_time = 0.0;

    for (int i = 0; i < number; ++i)

    {

        sum_round_time += pc[i].round_time;

        sum_avg_time += pc[i].avg_time;

        cout << pc[i].pid << '\t' << pc[i].come_time << '\t'

             << pc[i].run_time << '\t' << pc[i].begin_time << '\t'

             << pc[i].over_time << '\t' << pc[i].round_time << '\t'

             << pc[i].avg_time << endl;

    }

    avg_sum_round_time = sum_round_time * 1.0 / number;

    avg_sum_avg_time = sum_avg_time * 1.0 / number;

    cout << "平均周转时间: " << avg_sum_round_time << endl

         << "平均带权周转时间: " << avg_sum_avg_time << endl;

}

完整实验代码

#include <iostream>
#include <algorithm>

using namespace std;

#define MAXSIZE 5 // 作业数

int number; // 用户输入的进程数量

struct process
{
    string pid;        //作业名（作业号）
    double come_time;  //到达时
    double run_time;   //运行时
    double begin_time; //开始时
    double over_time;  //完成时
    double round_time; //周转时
    double avg_time;   //带权周转时
    double HRR;        //响应比
} pc[MAXSIZE];         //作业数

bool CmpByComeTime(process p1, process p2) // 按到达时间正序排序
{
    return p1.come_time < p2.come_time;
}

bool CmpByPid(process p1, process p2) // 按id号正序排序
{
    return p1.pid < p2.pid;
}

bool CmpByRunTime(process p1, process p2) // 按运行时长正序排序
{
    return p1.run_time == p2.run_time ? p1.come_time < p2.come_time : p1.run_time < p2.run_time;
}

bool CmpByHRR(process p1, process p2) // 按响应比逆序排序
{
    return p1.HRR > p2.HRR;
}

void get_beginAndOver_time() // 计算作业的开始时间与完成时间
{
    for (int i = 0; i < number; i++)
    {
        if (i == 0)
        {
            pc[i].begin_time = pc[i].come_time; // 第一个作业的开始时即为其到达时
        }
        else
        {
            pc[i].begin_time = pc[i - 1].over_time; // 否则后一作业的开始时为前一个作业的完成时
        }
        pc[i].over_time = pc[i].begin_time + pc[i].run_time; // 作业完成时 = 开始时间 + 运行时间
    }
}

void get_roundAndAvg_time() // 计算作业的周转时间与带权周转时间
{
    for (int i = 0; i < number; ++i)
    {
        pc[i].round_time = pc[i].over_time - pc[i].come_time;     // 周转时 = 完成时间 - 到达时间
        pc[i].avg_time = pc[i].round_time * 1.0 / pc[i].run_time; // 平均周转时 = 周转时间 / 运行时间
    }
}

void get_HRR(int beg) // 计算作业的响应比
{
    for (int i = beg; i < number; i++)
    {
        pc[i].HRR = (pc[beg - 1].over_time - pc[i].come_time) * 1.0 / pc[i].run_time;
    }
}

void FCFS() // FCFS（first come first served）：先来先服务，根据到达时间依次执行
{
    sort(pc, pc + number, CmpByComeTime);
    get_beginAndOver_time();
    get_roundAndAvg_time();
}

void SJF() // SJF（short job first）：根据作业的运行时间从小到大依次执行
{
    sort(pc, pc + number, CmpByComeTime);    // 先按到达时排序
    sort(pc + 1, pc + number, CmpByRunTime); // 再按运行时排序
    get_beginAndOver_time();
    get_roundAndAvg_time();
}

void HRRN() // HRRN（highest response ratio next）：根据响应比从大到小依次执行，响应比动态计算
{
    sort(pc, pc + number, CmpByComeTime); // 先按到达时排序
    for (int i = 1; i < number; ++i)
    {
        get_HRR(i);
        sort(pc + i, pc + number, CmpByHRR);
    }
    get_beginAndOver_time();
    get_roundAndAvg_time();
}

void printResult() // 打印输出作业的各个时间值
{
    cout << "执行顺序："; // << endl
    for (int i = 0; i < number; ++i)
    {
        /* code */
        cout << pc[i].pid << " ";
    }
    cout << endl;
    cout << "作业名" << '\t' << "到达时" << '\t' << "运行时" << '\t'
         << "开始时" << '\t' << "完成时" << '\t' << "周转时" << '\t'
         << "带权周转时" << '\t' << endl;
    sort(pc, pc + number, CmpByPid);
    double sum_round_time = 0.0;
    double avg_sum_round_time = 0.0; // 平均周转时间
    double sum_avg_time = 0.0;
    double avg_sum_avg_time = 0.0; // 平均带权周转时间
    for (int i = 0; i < number; ++i)
    {
        sum_round_time += pc[i].round_time;
        sum_avg_time += pc[i].avg_time;
        cout << pc[i].pid << '\t' << pc[i].come_time << '\t'
             << pc[i].run_time << '\t' << pc[i].begin_time << '\t'
             << pc[i].over_time << '\t' << pc[i].round_time << '\t'
             << pc[i].avg_time << endl;
    }
    avg_sum_round_time = sum_round_time * 1.0 / number;
    avg_sum_avg_time = sum_avg_time * 1.0 / number;
    cout << "平均周转时间: " << avg_sum_round_time << endl
         << "平均带权周转时间: " << avg_sum_avg_time << endl;
}

int main() // 入口函数
{
    cout << "请输入进程个数：";
    cin >> number;

    cout << endl;
    cout << "请分别输入进程的名称、到达时间、服务时间：" << endl;
    for (int i = 0; i < number; i++)
    {
        cin >> pc[i].pid >> pc[i].come_time >> pc[i].run_time;
    }

    cout << endl;
    FCFS();
    cout << "the results of FCFS are：" << endl;
    printResult();

    cout << endl;
    SJF();
    cout << "the results of SJF are：" << endl;
    printResult();

    cout << endl;
    HRRN();
    cout << "the results of HRRN are：" << endl;
    printResult();

    cout << endl;
    system("pause");
    return 0;
}

将程序打包为exe文件

codeblocks下 写程序，先要建立一个工程。写好程序后，选择Build（构建），在工程目录里面就有个Debug或者Release的文件夹，里面就是打包好的exe文件。

  

四、实验结果

输入作业的个数，然后分别输入进程的名称、到达时间、服务时间，对程序进行测试。

测试样例1

测试样例2

五、实验总结

通过此次实验，对进程的常用算法有了更深的理解，知道了FCFS/SJF进程调度算法的实现过程和程序编写。对作业的完成时间、周转时间、带权周转时间等计算掌握地更加熟练。实验中，将理论和实践相结合，对操作系统的学习更加深入。

操作系统实验：FCFS调度算法（C语言）

在这里插入图片描述

  1. FCFS（first come first served）：先来先服务，根据到达时间依次执行。

  2. SJF（short job first）：根据作业的运行时间从小到大依次执行。

  3. HRRN（highest response ratio next）：根据响应比从大到小依次执行，响应比动态计算。

周转时间 = 完成时间 - 到达时间

带权周转时间 = 周转时间 / 运行时间

响应比 = （运行时间+已经等待时间） / 运行时间 = 1+已经等待时间 / 运行时间【响应比可能表达方法不同，但是意义是一样的。】

upward337
关注
专栏目录
操作系统课程设计——作业调度算法（文章内含全代码）
weixin_66990397的博客
07-16 331
主要三个算法 先来先服务 最短作业优先（非抢占） 高响应比优先。输出 到达时间 完成时间 运行时间 周转时间 带权周转时间。运行开始如图所示，输入作业个数。
短作业优先调度算法
05-12
模拟实现短作业调度算法，具体如下： 1、 设置作业体：作业名，作业的到达时间，服务时间，作业间的链接指针； 2、 进程初始化：由用户输入作业名、作业的到达时间和服务时间进行初始化； 3、 显示函数： 显示当前调度的是哪个作业，后备队列中有哪些作业； 最终显示每个作业的作业名、到达时间、服务时间、完成时间和周转时间； 4、 排序函数：对就已到达的作业按照服务时间进行排序。注意考虑到达时间； 5、 调度函数：每次从已到达的作业队列队首调度优一个作业执行； 6、 删除函数：作业结束后撤销。 注意事项： 1、 测试数据可以随即输入或从文件中读入。 2、 必须要考虑到作业的到达时间 3、 最终能够计算每一个作业的周转时间。
短作业优先算法
热门推荐
qq_38855717的博客
05-11 3万+
1、实验说明：答：本实验实现了短进程优先的进程调度操作，但因为是非抢占式，所以实现起来比较简单。短进程优先算法是以作业的长短来计算优先级，作业越短，其优先级越高。作业的长短是以作业所要求的运行时间来衡量的。在把短作业优先调度算法用于作业调度时，它将从外存的作业后备队列中选择若干个估计运行时间最短的作业，优先将它们调入内存运行。2、程序定义：（1）PCB：①作业号 ②到达时间 ③需要运行时间 ④开始...
进程调度算法 —— 短作业优先调度
chenhuangbi8480的博客
11-03 381
/* 短作业优先调度 */ #include <stdio.h> struct sjf{ char name[10]; float dt;//到达时间 float st;//服务时间 float begin_time;//开始运行时间 float wct;/...
课程设计大作业C++模拟操作系统进程调度FCFS和SJF算法实现源码.zip
06-17
课程设计大作业C++模拟操作系统进程调度FCFS和SJF算法实现源码 问题描述 设计程序模拟进程的先来先服务FCFS和短作业优先SJF调度过程。假设有n个进程分别在T1, … ,Tn时刻到达系统，它们需要的服务时间分别为S1, … ,...
操作系统实验_先来先服务FCFS和短作业优先SJF进程调度算法.doc
07-13
操作系统实验报告：先来先服务FCFS和短作业优先SJF进程调度算法 本实验报告的主要目的是通过模拟程序来实现先来先服务FCFS和短作业优先SJF进程调度算法，深入理解进程概念、进程状态的转换、进程调度的策略和系统...
操作系统 + 短作业优先调度算法 + 实验报告 + 源代码
最新发布
01-02
7. **源代码**：压缩包中的"实验一-短作业优先调度算法"很可能包含C、C++或Python等编程语言编写的源代码文件，这些代码实现了SJF算法，可以用来模拟作业调度的过程。 通过实际编写和运行代码，学生不仅可以深入...
操作系统实验报告 C++实现进程调度算法，短进程优先SJF与先来先服务FCFS算法
12-02
操作系统实验报告 C++实现进程调度算法，短进程优先SJF与先来先服务FCFS算法 本实验报告的主要目的是通过C++语言实现短进程优先SJF和先来先服务FCFS两种进程调度算法，并比较它们的性能。 第一部分：实验目的 本...
操作系统实验（一）FCFS、SJF调度方式C++代码实现
Neymessi_JR的博客
07-09 1637
问题描述：设计程序模拟进程的先来先服务FCFS和短作业优先SJF调度过程。假设有n个进程分别在T1, … ,Tn时刻到达系统，它们需要的服务时间分别为S1, … ,Sn。分别采用先来先服务FCFS和短作业优先SJF进程调度算法进行调度，计算每个进程的完成时间，周转时间和带权周转时间，并且统计n个进程的平均周转时间和平均带权周转时间。程序要求如下： 2）要求采用先来先服务FCFS和短作业优先SJF分别调度进程运行，计算每个进程的周转时间，带权周转时间，并且计算所有进程的平均周转时间，带权平均周转时间；3）输出
操作系统短作业优先进程调度算法
05-29
短作业优先进程调度算法 （1）用C语言（或其它语言，如Java）实现对N个进程采用某种进程调度算法（如动态优先权调度）的调度。 （2）每个用来标识进程的进程控制块PCB可用结构来描述，包括以下字段：  进程标识数ID。  进程优先数PRIORITY，并规定优先数越大的进程，其优先权越高。  进程已占用CPU时间CPUTIME。  进程还需占用的CPU时间ALLTIME。当进程运行完毕时，ALLTIME变为0。  进程的阻塞时间STARTBLOCK，表示当进程再运行STARTBLOCK个时间片后，进程将进入阻塞状态。  进程被阻塞的时间BLOCKTIME，表示已阻塞的进程再等待BLOCKTIME个时间片后，将转换成就绪状态。  进程状态STATE。  队列指针NEXT，用来将PCB排成队列。 （3）优先数改变的原则：  进程在就绪队列中呆一个时间片，优先数增加1。  进程每运行一个时间片，优先数减3。 （4）为了清楚地观察每个进程的调度过程，程序应将每个时间片内的进程的情况显示出来，包括正在运行的进程，处于就绪队列中的进程和处于阻塞队列中的进程。 （5）分析程序运行的结果，谈一下自己的认识。
操作系统课程设计 短作业优先调度算法
07-17
用C#开发 设计目的：在多道程序和多任务系统中，系统内同时处于就绪状态的进程可能有若干个，且进程之间也存在着同步与互斥的关系，要求采用指定的调度策略，使系统中的进程有条不紊地工作，通过观察诸进程的运行过程，以巩固和加深处理机调度的概念。 2、设计要求（多道、单处理机）： 每一个进程有一个PCB，其内容可以根据具体情况设定。 可以在界面设定的互斥资源（包括两种：输入设备与输出设备）的数目 进程数、进入内存时间、要求服务时间可以在界面上进行设定 进程之间存在一定的同步与互斥关系，可以通过界面进行设定，其表示方法如下： 进程的服务时间由三段组成：I2C10O5（表示进程的服务时间由2个时间片的输入，10个时间片的计算，5个时间片的输出） 进程间的同步关系用一个段表示：W2，表示该进程先要等待P2进程执行结束后才可以运行 因此，进程间的同步与互斥关系、服务时间可以统一用四段表示为：I2C10O5W2 可以在运行中显示各进程的状态：就绪、阻塞、执行 采用可视化界面，可在进程调度过程中随时暂停调度，查看当前进程的状态以及相应的阻塞队列 具有一定的数据容错性
短作业优先调度算法（包含C代码）
清风徐来的博客
05-16 1万+
实验内容： 模拟实现短作业调度算法，具体如下： 设置作业体：作业名，作业的到达时间，服务时间，作业间的链接指针 进程初始化：由用户输入作业名、作业的到达时间和服务时间进行初始化。 显示函数：1、显示当前调度的是哪个作业，后备队列中有哪些作业 2、最终显示每个作业的作业名、到达时间、服务时间、完成时间和周转时间 排序函数：对就已到达的作业按照服务时间进行排序。注意考虑...
操作系统——短作业优先调度算法
weixin_44620183的博客
06-02 1万+
操作系统——短作业优先调度算法 实验内容 模拟实现FCFS/SJF调度。 设置作业体：作业名，作业的到达时间，服务时间，作业状态（W——等待,R——运行,F——完成），作业间的链接指针； 作业初始化：由用户输入作业名、服务时间、到达时间进行初始化，同时，初始化作业的状态为W。 显示函数：在作业调度前、调度中和调度后进行显示。 排序函数：对等待状态的作业按照调度算法排序（不同的调度算法排序方式不同），注意考虑到达时间。 调度函数：每次从等待队列队首调度已到达的适合的作业执行，状态变化。当服务结束时，状态变为F
最短作业优先（SJF）调度算法
tugouxp的专栏
05-03 1万+
最短作业优先（SJF）调度算法将每个进程与其下次 CPU 执行的长度关联起来。当 CPU 变为空闲时，它会被赋给具有最短 CPU 执行的进程。如果两个进程具有同样长度的 CPU 执行，那么可以由FCFS来处理。 一个更为恰当的表示是最短下次CPU执行算法，这是因为调度取决于进程的下次 CPU 执行的长度，而不是其总的长度。我们使用 SJF 一词，主要由于大多数教科书和有关人员都这么称呼这种类型的调度策略。 举一个 SJF 调度的例子，假设有如下一组进程，CPU 执行长度以 ms 计： 进程 ...
短作业优先调度算法（SJF）、时间片轮转（RR）
weixin_42421252的博客
05-09 6624
调度算法。
操作系统实验：作业调度算法比较（FCFS, SJF, HRRF）
本篇文档是关于操作系统实验中的作业调度，具体涉及到的是在C++编程环境中实现三种不同的作业调度算法：先来先服务（FCFS）、短作业优先（SJF）和响应比高者优先（HRRF）。实验数据包含一组作业，如作业A到F，它们的...
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

upward337

谢谢老板~

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值