操作系统作业调度实验

1、编写并调试一个单道处理系统的作业等待模拟程序。

  作业等待算法:分别采用先来先服务(FCFS),最短作业优先(SJF)、响应比高者优先(HRN)的调度算法。

  对每种调度算法都要求打印每个作业开始运行时刻、完成时刻、周转时间、带权周转时间,以及这组作业的平均周转时间及带权平均周转时间,以比较各种算法的优缺点。

#include <iostream>
#include <math.h>
#include <vector>
#include <stdlib.h>
#include <iomanip>
#include <algorithm>
using namespace std;
int n; //作业数量,全局变量
string s[3] = { "ready","running","finish" };  //表示作业的三种状态
struct jcb
{
    int num; //作业编号
    int needtime; //需要多少时间
    int allneedtime;//一共最开始是需要多长时间
    int startruntime = 0;//开始运行时间
    int status = 0; //作业状态
    float priority = 1; //优先级
};
//设置运行所需时间从小到大排列
int cmp(jcb a, jcb b)
{
    return a.needtime < b.needtime;
}
//设置优先级从高到低
int cmp1(jcb a, jcb b)
{
    return a.priority > b.priority;
}
//输出,遍历数组来输出全部的运行过程,用于FCFS和SJF算法
int run(vector <jcb> job)
{
    int runtime = 0;
    int alltime = 0;
    float allwtime = 0;
    while (!job.empty())
    {
        cout << "作业" << job[0].num
             << "\tneedtime:" << job[0].needtime
             << "\tstartruntime:" << runtime;
        runtime += job[0].needtime;
        alltime += runtime;
        allwtime += runtime * 1.0 / job[0].needtime;
        cout << "\tfinishtime:" << runtime
             << "\tround time:" << runtime
             << "\tweight round time:"
             << setiosflags(ios::fixed) << setprecision(3)
             << runtime * 1.0 / job[0].needtime << endl;
        job.erase(job.begin(), job.begin() + 1);
    }
    cout << "\n 平均周转时间:" << alltime * 1.0 / n
         << " 平均带权周转时间:" << allwtime / n << endl;
    cout << endl;
    return 1;
}
//输出数组的全部元素的状态信息
int print1(vector <jcb> job)
{
//输出就绪队列的进程
    while (!job.empty())
    {
        cout << "作业" << job[0].num
             << "\tneedtime:" << job[0].needtime
             << "\tstatus:" << s[job[0].status]
             << "\tpriority:" << job[0].priority << endl;
        job.erase(job.begin(), job.begin() + 1);
    }
    cout << endl;
    return 1;
}
int FCFS(vector <jcb> job)
{
    run(job);
    return 1;
}
int SJF(vector <jcb> job)
{
    sort(job.begin(), job.end(), cmp);
    run(job);
    return 1;
}
int HRRN(vector <jcb> job)
{
    sort(job.begin(), job.end(), cmp);
    int count = n; //未完成的作业数量
    int runtime = 0; //运行时间
    int alltime = 0;
    float allwtime = 0;
    int isstarted[100] = { 0 };
    cout << "初始的作业状态:" << endl;
    print1(job);
    cout << "运行状态:" << endl;
    while (true)//就绪队列非空
    {
        if (isstarted[job[0].num - 1] == 0)
        {
            isstarted[job[0].num - 1] = 1;
            job[0].startruntime = runtime;
        }
//运行队列的第一个作业
        job[0].status = 1;
        job[0].needtime -= 1;
        runtime++;
        for (int i = 1; i < count; i++)
        {
            job[i].priority = 1 + runtime * 1.0 / job[i].needtime;
        }
        cout << "time:" << runtime << endl;
        print1(job);//输出作业的状态
        if (job[0].needtime == 0)//当前作业完成
        {
            count--;
            job[0].status = 2;//运行结束
            alltime += runtime;
            allwtime += runtime * 1.0 / job[0].allneedtime;
            cout << "作业" << job[0].num << " 已完成!!\n" << "startruntime:" << job[0].startruntime
                 << "\tfinishtime:" << runtime << "\troundtime:" << runtime
                 << "\tround weight time:" << runtime * 1.0 / job[0].allneedtime << endl;
            cout << endl;
            job.erase(job.begin(), job.begin() + 1);
            if (job.empty())
                break;
        }
        else
            job[0].status = 0;
        sort(job.begin(), job.end(), cmp1); //按优先级排序
    }
    cout << endl;
    cout << " 平均周转时间:" << alltime * 1.0 / n
         << " 带权平均周转时间:" << allwtime / n << endl;
    return 1;
}
int main()
{
    cout << "请输入作业数量:";
    cin >> n;
    vector <jcb> job(n);
    cout << "请输入作业需要的时间:\n";
    for (int i = 0; i < n; i++)
    {
        cout << "请输入第" << i + 1 << "个作业所需要的时间:";
        job[i].num = i + 1;
        cin >> job[i].needtime;
        job[i].allneedtime = job[i].needtime;
    }
    cout << "FCFS:" << endl;
    FCFS(job);
    cout << "SJF" << endl;
    SJF(job);
    cout << "HRRN" << endl;
    HRRN(job);
    return 0;
}

 

2、编写并调度一个多道程序系统的作业调度模拟程序。

  作业调度算法:采用基于先来先服务的调度算法。可以参考课本中的方法进行设计。

  对于多道程序系统,要假定系统中具有的各种资源及数量、调度作业时必须考虑到每个作业的资源要求。 

#include <iostream>
#include <cmath>
#include <cstdlib>
using namespace std;
struct Box
{
    string ID; //作业号
    double begin_time; //提交时间
    double rtime; //已经运行时间
    double turnaround_time; //周转时间
    double cpu_service_time; //占用CPU的时间
    double io_time; //用于I/O的时间
    double finish_time; //完成时间
    double Wturnaround_time; //带权周转时间
    Box& operator = (const Box& p2) //重载 = 运算符,方便排序
    {
        this->begin_time = p2.begin_time;
        this->rtime = p2.rtime;
        this->finish_time = p2.finish_time;
        this->cpu_service_time = p2.cpu_service_time;
        this->io_time = p2.io_time;
        this->ID = p2.ID;
        this->turnaround_time = p2.turnaround_time;
        this->Wturnaround_time = p2.Wturnaround_time;
        return *this;
    }
};
typedef struct
{
    Box data[100];
} JCB;
const double CPU = 10.0; //cpu最大可运行资源数
const double index = 0.5; //时间片
JCB jcb, jcb_1;
int n, number;
void init() //初始化作业块
{
    cout << "请输入作业个数:";
    cin >> n;
    number = n;
    for (int i = 0; i < n; i++)
    {
        cout << "作业 ID:";
        cin >> jcb.data[i].ID;
        cout << jcb.data[i].ID << "提交时间:";
        cin >> jcb.data[i].begin_time;
        cout << jcb.data[i].ID << "占用cpu时间:";
        cin >> jcb.data[i].cpu_service_time;
        cout << jcb.data[i].ID << "占用I/O时间:";
        cin >> jcb.data[i].io_time;
        jcb.data[i].rtime = 0;
    }
    for (int i = 0; i < n - 1; i++) //按照提交时间从前到后排序
    {
        for (int j = i + 1; j < n; j++)
        {
            if (jcb.data[i].begin_time > jcb.data[j].begin_time)
                swap(jcb.data[i], jcb.data[j]);
        }
    }
    for (int i = 0; i < n - 1; i++) //提交时间相同,序号小的在前
    {
        for (int j = i + 1; j < n; j++)
        {
            if (jcb.data[i].begin_time == jcb.data[j].begin_time && jcb.data[i].ID > jcb.data[j].ID)
                swap(jcb.data[i], jcb.data[j]);
        }
    }
}
void FCFS() //先来先服务
{
    int j = 0;
    double running = CPU;
    double bt = jcb.data[0].begin_time;
    double gtt = 0;
    double gwtt = 0;
    double real_begin;
    double record = jcb.data[j].begin_time;
    int num = n - 1;
    cout << "ID " << "leave time " << "begin time " << "turnaround time " << "finish time " << "wighted turnaround time"
         << endl;
    while (1)
    {
        if (jcb.data[j].cpu_service_time > CPU)
        {
            cout << "超出运行范围!!!" << endl;
            exit(0);
        }
        jcb.data[j].rtime += index;
        record += index;
        if (running >= 0)
        {
            if (jcb.data[j].rtime >= jcb.data[j].cpu_service_time)
            {
                real_begin = bt;
                jcb.data[j].finish_time = record + jcb.data[j].io_time;
                jcb.data[j].turnaround_time = jcb.data[j].finish_time - jcb.data[j].begin_time;
                jcb.data[j].Wturnaround_time = jcb.data[j].turnaround_time / jcb.data[j].rtime;
                cout << jcb.data[j].ID << " " << real_begin << " "
                     << jcb.data[j].begin_time << " " << jcb.data[j].turnaround_time
                     << " " << jcb.data[j].finish_time << " "
                     << jcb.data[j].Wturnaround_time << endl;
                n--;
                running -= jcb.data[j].cpu_service_time;
                bt = record;
                gtt += jcb.data[j].turnaround_time;
                gwtt += jcb.data[j].Wturnaround_time;
            }
            else
            {
                num++;
                swap(jcb.data[num], jcb.data[j]);
            }
        }
        else
        {
            running += jcb.data[j].cpu_service_time;
            num++;
            swap(jcb.data[num], jcb.data[j]);
        }
        if (n == 0)
            break;
        j++;
    }
    cout << " 平均周转时间:" << gtt / number << endl << "平均带权周转时间:" << gwtt / number << endl;
}
int main()
{
    init();
    FCFS();
    return 0;
}

 

 3、编写并调试一个多道程序系统的作业调度模拟程序。

  作业调度算法:采用基于优先级的作业调度。

 

#include <iostream>
#include <cstdio>
#include <cstdlib>
using namespace std;
struct Box
{
    string ID; //作业号
    int priority; //优先级
    double begin_time; //提交时间
    double rtime; //已经运行时间
    double turnaround_time; //周转时间
    double cpu_service_time; //占用CPU的时间
    double io_time; //用于I/O的时间
    double finish_time; //完成时间
    double Wturnaround_time; //带权周转时间
    Box& operator = (const Box& p2) //重载 = 运算符
    {
        this->priority = p2.priority;
        this->begin_time = p2.begin_time;
        this->rtime = p2.rtime;
        this->finish_time = p2.finish_time;
        this->cpu_service_time = p2.cpu_service_time;
        this->io_time = p2.io_time;
        this->ID = p2.ID;
        this->turnaround_time = p2.turnaround_time;
        this->Wturnaround_time = p2.Wturnaround_time;
        return *this;
    }
};
typedef struct
{
    Box data[100];
} JCB;
const double CPU = 10.0;
const double index = 1.0; //时间片
JCB jcb, jcb_1;
int n, number;
void init() //初始化作业块
{
    cout << "请输入作业数量:";
    cin >> n;
    number = n;
    for (int i = 0; i < n; i++)
    {
//输入各个作业的信息初始化
        cout << "作业 ID:";
        cin >> jcb.data[i].ID;
        cout << jcb.data[i].ID << "的提交时间:";
        cin >> jcb.data[i].begin_time;
        cout << jcb.data[i].ID << "占用CPU的时间:";
        cin >> jcb.data[i].cpu_service_time;
        cout << jcb.data[i].ID << "占用I/O的时间:";
        cin >> jcb.data[i].io_time;
        cout << jcb.data[i].ID << "的优先级:";
        cin >> jcb.data[i].priority;
        jcb.data[i].rtime = 0;
    }
    for (int i = 0; i < n - 1; i++) //按照优先级从大到小排序
    {
        for (int j = i + 1; j < n; j++)
        {
            if (jcb.data[i].priority < jcb.data[j].priority)
                swap(jcb.data[i], jcb.data[j]);
        }
    }
    for (int i = 0; i < n - 1; i++)
    {
        for (int j = i + 1; j < n; j++)
        {
            if (jcb.data[i].begin_time == jcb.data[j].begin_time && jcb.data[i].ID > jcb.data[j].ID)
                swap(jcb.data[i], jcb.data[j]);
        }
    }
}
void pri() //优先级
{
    int j = 0;
    double running = CPU;
    double bt = jcb.data[0].begin_time;
    double gtt = 0;
    double gwtt = 0;
    double real_begin;
    double record = jcb.data[0].begin_time;
    int num = n - 1;
    cout << "ID " << "leave time " << "begin time " << "turnaround time " << "finish time " << "wighted turnaround time" << endl;
    while (1)
    {
        if (jcb.data[j].cpu_service_time > CPU)
        {
            cout << "超出范围!!!" << endl;
            exit(0);
        }
        jcb.data[j].rtime += index;
        record += index;
        if (running >= 0)
        {
            if (jcb.data[j].rtime >= jcb.data[j].cpu_service_time)
            {
                real_begin = bt;
                jcb.data[j].finish_time = record + jcb.data[j].io_time; //计算作业完成时间
                jcb.data[j].turnaround_time = jcb.data[j].finish_time - jcb.data[j].begin_time; //计算周转时间
                jcb.data[j].Wturnaround_time = jcb.data[j].turnaround_time / jcb.data[j].rtime;
                cout << jcb.data[j].ID << " " << real_begin << " "
                     << jcb.data[j].begin_time << " " << jcb.data[j].turnaround_time
                     << " " << jcb.data[j].finish_time << " "
                     << jcb.data[j].Wturnaround_time << endl;
                n--;
                running -= jcb.data[j].cpu_service_time;
                bt = record;
                gtt += jcb.data[j].turnaround_time; //总的周转时间
                gwtt += jcb.data[j].Wturnaround_time; //总的带权周转时间
            }
            else
            {
                num++;
                swap(jcb.data[num], jcb.data[j]);
            }
        }
        else
        {
            running += jcb.data[j].cpu_service_time;
            num++;
            swap(jcb.data[num], jcb.data[j]);
        }
        if (n == 0)
            break;
        j++;
    }
    cout << "平均周转时间:" << gtt / number << endl << "平均带权周转时间:" << gwtt / number << endl;
}
int main()
{
    init(); //初始化
    pri(); //按优先级
    return 0;
}

  • 2
    点赞
  • 17
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

打赏作者

南城`烟雨

你的鼓励将是我创作的最大动力

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

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

打赏作者

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

抵扣说明:

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

余额充值