以高响应比优先为基础的轮转调度算法

原创 2016年05月30日 14:50:33

(文章待更新)设计程序模拟进程的轮转法调度过程。假设初始状态为:有n个进程处于就绪状态,有m个进程处于阻塞状态。采用轮转法进程调度算法、高响应比优先(HRRN)进行调度(调度过程中,假设处于执行状态的进程不会阻塞),且每过t个时间片系统释放资源,唤醒处于阻塞队列队首的进程。《操作系统》课程实验教学大纲《操作系、

程序要求如下:《操作系统》课程实验教学大纲《操作系统》课程实验教学大纲课程名称

(1)    输出系统中进程的调度次序;

(2)    计算CPU利用率。

#include<iostream>
#include<cstring>
#include<cstdio>
#include<algorithm>
#include<queue>
#include<iomanip>
#define eps (1e-8)
using namespace std;
struct prog
{
    char name[100];
    int atim;  ///到达时间
    int ptim;  ///服务时间
    int pptim;
    int ftim;  ///完成时间
    int rtim;  ///周转时间
    int wtim;  ///HRRN算法等待时间
    double pror; ///优先级
    double rrtim; ///带权周转时间
    friend bool operator<(prog a,prog b)
    {
        if((a.pror-b.pror)<eps)
            return a.atim>b.atim;
        return (a.pror-b.pror)>eps;
    }
} pro[50];
bool cmp(prog a,prog b)
{
    return a.ftim<b.ftim;
}
int n,t,p=0,num=0,pp=0;///进程数 时间片 当前时刻
///模拟调度队列
priority_queue<prog>q;
void init()
{
    printf("请输入进程个数:\n");
    scanf("%d",&n);
    int cur=1;
    for(int i=1; i<=n; i++)
    {
        printf("请输入进程名%d:\n",cur++);
        scanf("%s",&pro[i].name);
        printf("请输入该进程到达时间:\n");
        scanf("%d",&pro[i].atim);
        printf("请输入该进程服务时间:\n");
        scanf("%d",&pro[i].ptim);
        pro[i].pptim=pro[i].ptim;
        pro[i].wtim=0;
        pro[i].rtim=0;
        pro[i].pror=(pro[i].wtim+pro[i].ptim)*1.0/pro[i].ptim;
    }
    printf("请输入时间片:\n");
    scanf("%d",&t);
}
void solve()
{
    for(int i=1; i<=n; i++) q.push(pro[i]);
    while(!q.empty())
    {
        prog cnt=q.top();
        if(cnt.atim>p)
        {
            p++;
            pp++;
            continue;
        }
        q.pop();
        int tmp=t;
        cnt.wtim=0;
        while(tmp--)
        {
            cout<<p<<" "<<cnt.name<<" "<<cnt.ptim<<endl;
            cnt.ptim--;
            p++;
            for(int i=1; i<=n; i++)
            {
                if(strcmp(cnt.name,pro[i].name)!=0&&pro[i].ptim!=0&&p>pro[i].atim)
                {
                    pro[i].wtim++;
                    pro[i].pror=(pro[i].wtim+pro[i].ptim)*1.0/pro[i].ptim;
                }
            }
            while(!q.empty())
            {
                q.pop();
            }
            for(int i=1; i<=n; i++)
            {
                if(strcmp(cnt.name,pro[i].name)!=0&&pro[i].ptim!=0)
                {
                    q.push(pro[i]);
                }
            }
            if(cnt.ptim==0)
            {
                num++;
                for(int i=1; i<=n; i++)
                {
                    if(strcmp(cnt.name,pro[i].name)==0)
                    {
                        pro[i].ftim=p;
                        pro[i].rtim=p-pro[i].atim;
                        pro[i].ptim=0;
                        pro[i].rrtim=(pro[i].rtim*1.0)/(pro[i].pptim*1.0);
                        break;
                    }
                }
                if(tmp!=0)
                {
                    pp+=tmp;
                    /*cnt=q.top();
                    while(cnt.atim>p)
                    {
                        p++;
                        pp++;
                    }
                    q.pop();
                    cnt.wtim=0;*/
                }
                else
                    continue;
            }
            if(tmp==0&&cnt.ptim>0)
            {
                cnt.pror=1;///这里将等待时间置零
                q.push(cnt);
            }
            if(num==n)
                return;
        }
    }
}
void output()
{
    printf("进程处理完毕\n");
    sort(pro+1,pro+n+1,cmp);
    printf("进程名\t完成时间\t周转时间\t带权周转时间\n");
    for(int i=1; i<=n; i++)
    {
        printf("%s\t\t%d\t\t%d\t\t%.2lf\n",pro[i].name,pro[i].ftim,pro[i].rtim,pro[i].rrtim);
    }
    printf("CPU的利用率为:%.2lf %%\n",(p-pp)*1.0/p*1.0*100);
}
int main()
{
    init();
    solve();
    output();
    return 0;
}
/*
5
A
0
4
B
1
3
C
2
4
D
3
2
E
4
4
1
*/
/*if(tmp==cnt.ptim)
{
    while(!q.empty()) q.pop();
    p+=t;
    for(int i=1; i<=n; i++)
    {
        if(strcmp(cnt.name,pro[i].name)==0)
        {
            pro[i].ftim=p;
            pro[i].rtim=p-pro[i].atim;
        }
        else
        {
            pro[i].wtim+=t;
            pro[i].pror=(pro[i].wtim+pro[i].ptim)*1.0/pro[i].ptim;
            q.push(pro[i]);
        }
    }
    printf("进程%s处理完毕\n",cnt.name);
}
else if(tmp>cnt.ptim)
{
    while(tmp--)
    {

    }
}
else if(tmp<cnt.ptim)
{
    cnt.ptim-=t;
    p+=t;

}
*/
/*printf("名字\t到达时间\t服务时间\t优先级\n");
while(!q.empty())
{
    prog cur=q.top();
    q.pop();
    printf("%s\t\t%d\t\t%d\t\t%.lf\n",cur.name,cur.atim,cur.ptim,cur.pror);
}*/


《操作系统》课程实验教学

版权声明:本文为博主原创文章,未经博主允许不得转载。

高响应比优先调度算法(HRRN)

BOOM,困到不行,这个写完就睡觉了,今天好像有点感冒 ,翘了晚上的课一直睡到10点起来,睡不着在写代码,现在又困了 高响应比算法,是一种动态调整优先级的算法,在上面介绍的PSA算法中,给每个作业...
  • zhaoshu01234
  • zhaoshu01234
  • 2015年12月01日 01:51
  • 7491

高响应比优先算法

这个算法很好玩,综合了短作业优先,先来先服务,以及长作业也能得到服务的特性,因此,是一种综合的调度算法。计算公式: 优先权 = (等待时间 + 要求服务时间) / 要求服务时间又因为等待时间 + 要...
  • u011240016
  • u011240016
  • 2016年08月30日 20:54
  • 4188

作业调度先来先服务短作业高响应比优先算法C语言

  • 2010年05月13日 12:04
  • 197KB
  • 下载

操作系统课设高响应比优先算法 带报告

  • 2013年07月26日 21:03
  • 5.51MB
  • 下载

先来先服务和高响应比优先调度算法C语言实现

1、进程调度与作业调度的区别: 2、单道批处理系统与多道批处理系统的区别: 3、程序设计用到的公式: 4、高响应比优先算法特点: 5、源代码示例: 6、测试用例: 7、运行结果:...
  • Remoa_Dengqinyi
  • Remoa_Dengqinyi
  • 2016年10月29日 00:58
  • 11291

非抢占的高响应比优先调度算法

模拟操作系统进程调度算法流程图测试数据进程名: A B C D E 需要运行时间: 3 6 4 5 2代码实现#include #inc...
  • qq_24489717
  • qq_24489717
  • 2017年04月30日 00:31
  • 886

高响应比优先调度算法

  • 2014年05月24日 19:16
  • 3KB
  • 下载

高响应比优先调度算法

  • 2012年04月06日 21:30
  • 41.42MB
  • 下载

轮转调度算法(RR)

RR算法是使用非常广泛的一种调度算法。 首先将所有就绪的队列按FCFS策略排成一个就绪队列,然后系统设置一定的时间片,每次给队首作业分配时间片。如果此作业运行结束,即使时间片没用完,立刻从队列中去除此...
  • zhaoshu01234
  • zhaoshu01234
  • 2015年12月03日 01:00
  • 5791

进程调度:时间片轮转调度算法

一、实验目的 (1) 加深对进程的理解 (2) 理解进程控制块的结构 (3) 理解进程运行的并发性 (4) 掌握时间片轮转法进程调度算法 二、实验原理 (1)建立进程控制块 (2)...
  • FengNingXueChen
  • FengNingXueChen
  • 2016年11月24日 14:43
  • 6280
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:以高响应比优先为基础的轮转调度算法
举报原因:
原因补充:

(最多只允许输入30个字)