操作系统高响应比优先模拟算法,实验二报告【
分类:美高梅-操作

  那学期刚起头读书操作系统,收到三个学业,百度有关高响应比优先(H昂科雷福睿斯N,Highest Response Ratio Next)的CPU进度调节模拟算法,基本思量:短作业优先调整算法 + 动态优先权机制;既考虑作业的进行时间也思量作业的守候时间,综合了先来先服务(FCFS,First Come First Served)和最短作业优先(SJF,Shortest Job First)二种算法的特色。

                                                                                 实验后生可畏、作业调节模拟程序实验

 1、什么是经过调治

  之后经过多番揣摩... ...决定分界面用命令行算了,反正啥也不会...

                                                                            13物联网工程    刘烨(liú yè卡塔尔国   二零一一06104146

  无论是在批管理类别或许分时系统中,客商进度数日常都多于管理机数、那将促成它们相互视若无睹争管理机。此外,系统经过也黄金时代致须求选用场理机。那就要求进程调治程序按一定的战术,动态地把拍卖机分配给处于就绪队列中的某四个经过,以使之施行。   

  关于响应比:

黄金时代、 实验目标

 

    讴歌ZDXENVISION =  (估摸运营时刻 + 等待时间卡塔尔国 / 臆度运维时刻 = 1 + 等候时间/推测运转时刻;

(1)加深对作业调整算法的知道;

2、管理机调整分类

  响应比高者优先开展调解;

(2)实路程序设计的教练。 

高等、中级和低等调解作业从提交起头直到落成,往往要经历下述三级调整:

 

二、 实验内容和须要

  • 高端调治:(High-Level Scheduling卡塔尔(قطر‎又称为作业调治,它调整把后备进程调入内部存款和储蓄器运转; 
  • 中低等调整:(Low-Level Scheduling卡塔尔国又叫做进程调解,它决定把就绪队列的某经过得到CPU; 
  • 高级中学档调解:(Intermediate-Level Scheduling卡塔尔(قطر‎又叫做在设想存款和储蓄器中引进,在内、外部存款和储蓄器对换区进行进度对换

  关于供给中的周转时间、带权周转时间、平均运维时间和平均带权周转时间:

用高级语言编写贰个或四个作业调治的模拟程序。

3、短过程优先

最短CPU运维期优先调解算法(SCBF--Shortest CPU Burst First)

该算法从安妥队列中选出下三个“CPU推行期最短”的进度,为之分配管理机

比方说,在就绪队列中有几个经过P1、P2、P3和P4,它们的下一个进行

期独家是16、12、4和3个单位时间,执市价况如下图:

P1、P2、P3和P4的周转时间分别为35、19、7、3,平均运维时间为16。

该算法虽可获取较好的调治品质,但难以标准地知道下一个CPU实施期,而只好依照每一个历程的举办历史来预测。

美高梅4858官方网站, 

4、C语言方式达成

  1》、常量申明和数据布局定义

#include "stdio.h"
#include <stdlib.h>
#include "string.h"
#define NULL 0

typedef struct pcb
{
    char name[10]; //进程名称
    int ArrivalTime; //到达时间 
    int StartTime;   //开始运行时间
    int FinishTime;  //结束运行时间
    int WholeTime;   //运行所需时间

    struct pcb *link; //下一个指针 
}pcb; 
int N;  //运行的进程数量 
void input();
pcb *ready=NULL,*p=NULL,*finish = NULL;  
//ready 是初始时的状态,finish 是结束时状态 
int M; 

 

  2》、输入进度音讯函数

void input()
{
    printf("请输入进程数量:");
    scanf("%d",&N);   //N为全局变量
    M = N;
    struct pcb *q = ready;
    int  i = 0;
    for( i=0 ;i<N;i++)
    {
        printf("请输入第 %d 个进程信息-----------n",i+1);
        p = (pcb *)malloc(sizeof(pcb));
        printf("请输入进程名:")    ;
        scanf("%s",p->name);
        printf("请输入进程到达时间:");
        scanf("%d",&p->ArrivalTime);
        printf("请输入进程运行时间:");
        scanf("%d",&p->WholeTime);
        p->link = NULL;
        if(NULL == ready)
        {
            ready = p;    
            q = ready;        
        }
        else
        {
            q = ready;
            while(NULL != q->link)  //将q移动到就绪队列最后一个进程 
            {
                q = q->link;
            }
            p->link = NULL;
            q->link = p;    
            q=p;
        }
        printf("n");
    }
    q= NULL;
    free(q);    
} 

 

  3》、短进度优先算法【主旨代码】

//先输入的肯定是先到达的 
//nowTime 是现在执行的时间 
pcb* sjf(int nowTime,int *after)
{
    int i = 0 ;
    pcb *nowProgress=NULL, *p = ready;
    int ProgressNum = 0; // 当前最短的是第几个线程 
    int minTime =0; // 最短运行时间

    if(NULL != ready)
    {
        while(NULL != p) //遍历整个链表,查找出最短的进程,即运行时间最短 
        {
        //    printf("n%d  %d  %d  n",p->ArrivalTime,nowTime >= p->ArrivalTime,nowTime) ;
            if(nowTime >= p->ArrivalTime)
            { 
                if(0 == minTime)  //首次赋值 
                {
                    nowProgress = p;
                    minTime = p->WholeTime;                    
                }
                else
                {
                    if(p->WholeTime < minTime)
                    {
                        nowProgress = p;
                        minTime = p->WholeTime;
                    }
                }

                *after = minTime+nowTime;
            }    
            p = p->link;
        }
    } 

    return nowProgress;    
}

 

  4》、输出种种时刻的长河音信函数

void output(pcb *p,int now_time)
{
    if(NULL == p)
    {
        printf("当前时刻:%d,暂无进程在运行!n",now_time);
    }
    else
    {
            printf("进程名:%s,运行时间:%d,到达时间:%dn",p->name,p->WholeTime,p->ArrivalTime);        
    }    
}

 

  5》、输出进度运营总体景况总计

void outputAll()
{
    pcb *p = finish;
    printf("n-----------------------统计结果:-------------------n");
    float avgRevolve = 0;
    float avgSuperRevolve = 0;

    while(NULL != p)
    {
        avgRevolve += p->StartTime+p->WholeTime-p->ArrivalTime;
        avgSuperRevolve += 1.0*(p->StartTime+p->WholeTime-p->ArrivalTime)/p->WholeTime;
        printf("n进程名:%s,开始时间%d,结束时间:%d,运行时间:%d,到达时间:%dn",p->name,p->StartTime,p->FinishTime,p->WholeTime,p->ArrivalTime);
        p = p->link;    
    }    
        printf("n----这组进程平均周转时间:%f,平均带权平均周转时间:%fn",avgRevolve/M,avgSuperRevolve/M);
} 

   

  6》、删除希图队列(ready)已经运维的进度p ,增加到产生队列(finish)队列中 

// 删除准备队列(ready)已经运行的进程p ,添加到完成队列(finish)队列中 
void destory(pcb *p,int now_time)
{

    pcb *q = ready;
    pcb *f = NULL;
    if(strcmp(p->name,ready->name) == 0)  //第一个进程 
    {
        ready = ready ->link;
    }
    else  //中间进程 
    {
        q = ready;

        while(  (strcmp(q->link->name,p->name) != 0) && NULL != q->link)  //找到p要删除的位置 
        {

            q= q->link;

        }

        q->link = p->link;    



    } 




        //将已经运行的进程添加到finish队列 
        p->StartTime = now_time-p->WholeTime;   
        p->FinishTime = now_time;

        if(NULL == finish)  //第一个完成的进程 
        {
            finish = p;
            p->link = NULL;
        }    
        else  //中间完成的进程 
        {
            f = finish;
            while(NULL != f->link )    
            {
                f = f->link;
            }
            f->link = p;
            p->link = NULL;
        }




    N--;  //等待进程减1 
}

 

  7》、主函数

int main()
{

    input();

    struct pcb *s = ready;  
    int now_time = 0 ;
    struct pcb *nowProgress = NULL;  //当前运行的进程 
    int *after = 0; //执行完一个进程之后的时间 
    int i = 0 ;   

    pcb *m = ready;

    while(N > 0)//一次运行一个进程 
    {
        nowProgress = sjf(now_time,&after);

        if(NULL != nowProgress)  //当前有进程在运行 
        {

        for(;now_time < after;now_time++)  //输出每个时刻运行的进程情况 
        {
            printf("#################################################n");
            printf("当前时刻:%dn",now_time);
             printf("n-------------当前执行进程:----------n"); 
                 output(nowProgress,now_time);
                 printf("n-------------等待执行进程:----------n");
            m=ready;
            while(NULL != m)
            {
                if(m != nowProgress)
                {
                    if(m->ArrivalTime <= now_time)
                    output(m,now_time);
                }
                m= m->link;
            }
            printf("#################################################nn");
        }

            printf("n");

            destory(nowProgress,now_time); 

        }
        else   //没有进程在运行 
        {
            output(nowProgress,now_time);
            now_time ++; 
        }

    }            
    outputAll();
    return 0;
}

 

  8》、测试

输入数据:

美高梅网站是多少 1

 

运行结果:

美高梅网站是多少 2

 

简单易行中途的截图,这里只交付最终的黄金时代共情形的截图

 

美高梅网站是多少 3

 

  实际上,进度调解有非常多样历程调解的法子,不一样的长河调节措施,他们的利害各有差异,而且她们的适用项景也不尽相通,这里只交付了短进度优先的调解情势。下边大家来比较一下,一些调治措施【只是生龙活虎对】的利弊:

1.先来先服务(FCFS, First Come First Serve),按前后相继顺序实行调节。 
(1)、适用项景:
相比平价长进度,而不便于短进程。因为长过程会长期占领管理机。
实惠CPU繁忙的历程,而不便于I/O繁忙的历程。 

(2)、优点:

惠及长进度,有助于等待时间久的经过,不会有进度长时间等待而得不到响应。有助于CPU频仍的长河。

(3)、缺点:

不便利短进程,忽略了经过的运转时刻。不平价I/O频仍的历程。

 

 

2. 响应比高者优先(H安德拉N):FCFS和SJF的的折中,动态变化昨夜的事前级。

(1)、优点:

既思索了经过的等待时间,又盘算了经过的运转时刻,是FCFS和SJF的的折中,会虚构让进度短的先实行,随着长进程等待时间的加码,优先级相应的加码,使得通过一准期期的等待,必然有时机获得管理机。

(2)、缺点:

在历次实行调解在此之前,都需求先做响应比的推测,会扩充系统的支出

3. 初期级法(Priority Scheduling):遵照进度的优先级,对经过经过调整。

(1)、分类:
静态优先级:
美高梅网站是多少,  进度调解中的静态优先级繁多按以下条件规定: 
  由顾客自身遵照进程的火急程度输入二个刚好的刚开始阶段级。 
  由系统或操作员遵照进度类型钦赐优先级。 
  系统依据进度须要能源情状鲜明优先级。 
  进度的静态优先级的规定标准: 
  按进度的档期的顺序付与差异的优先级。 
  将经过的态度优先级作为它所属进度的先行级。 
动态优先级:
  进度的动态优先级常常依据以下原则明显: 
  依据进度占用有CPU时间的长度来支配。 
  依据就绪进度等待CPU的日子长度来支配。 

(2)、优点:

能够经过事情发生前级反映进度的热切程序,使比很闷热切的历程优先运转

(3)、缺点:

须要总括进度的优先级,会产生一定的付出。
4.短进度优先法(SJF, Shortest Job First):短进度优先运转,其指标是缩减平均运转时间。 

(1) 优点: 
  比FCFS修正平均运转时间和平均带权周转时间,减少进度的等候时间; 
  升高系统的吞吐量; 
(2) 缺点: 
  对长进度特不利,大概长日子得不到实行; 
  未能依赖进度的急迫程度来划分实行的预先级; 
  难以正确正确估计进度(进度)的推行时间,从而影响调解品质。 

选拔SJF算法时,人—机交互作用无法完成

 完全未考虑进度的殷切程度,故不可能确认保证迫切性进度得到及时管理

 

 

 

 

 

 

    周转时间 =(作业做到的时间 - 作业提交时间);

单道批管理种类的学业调解程序。作业生龙活虎投运,它就占用计算机的全部财富直到作业达成收尾,因而调治作业时不要思虑它所急需的能源是或不是拿走满意,它所运维的时辰等因素。

    带权周转时间 = 作业周转时间 / 作业运行时刻;

     作业调整算法:

    平均运营时间 = (周转时间1+周转时间2+...+周转时间n)/ n;

1卡塔尔(英语:State of Qatar) 接受先来先服务(FCFS)调节算法,即按作业达到的次第次序进行调整。总是第后生可畏调解在系统中伺机时间最长的作业。

    平均带权周转时间 = (带权周转时间1+带权周转时间2+...+带权周转时间n)/ n;

2卡塔尔(قطر‎ 短作业优先 (SJF卡塔尔 调治算法,优先调整供给运转时刻最短的学业。

 

3卡塔尔国 响应比高者优先(H福特ExplorerCRUISERN卡塔尔调节算法,为每种作业设置二个优先权(响应比卡塔尔,调治此前先总结各作业的优先权,优先数高者优先调节。RP (响应比卡塔尔= 作业周转时间 / 作业运维时刻=1+作业等待时间/作业运营时刻

  开头,用vector存款和储蓄提交的作业布局体指针,自个儿安装七个系统时间,究竟模拟不或许时间流速一毛相通,接下去正是不用技艺含量的抉择了,关于测量试验数据,想了想好难输,还得要好编,于是用随便函数产生多少;再在主函数参数中提供贰个传递生成数据数量的参数。

每种作业由二个作业调整块JCB表示,JCB能够分包以下消息:作业名、提交(达到)时间、所需的运作时刻、所需的能源、作业状态、链指针等等。

  谈到此处得说一下,关于java先生(没有错,java先生)说的关于main(卡塔尔国的部分情景:

三、 实验方法、步骤及结果测量试验

1 int main(int argc, char** argv){ ////argc为参数个数, argv为接下来传的参数
2     ...
3     return 0;
4 }
  1. 源程序名:实验二 改正版.c

 

可执路程序名:改正版.exe

举例说在指令行中调用该函数,***.exe 100,那时有多个参数,三个为"***.exe", 另二个正是"100"了,分别在argv[0]和argv[1]中。

  1. 原理分析及流程图

  首先是数码变动,用为必要格式,所以要小拍卖一下,认为这种艺术能够在刷ACM题被难点玄学时接受,叁个为标准代码,三个为友好的代码,近日未试过:

   此次试验首要用了布局体数组来兑现。首先定义一个JCB模块用于寄放作业音讯,如到达时间,运转时刻等。后来逐个函数分别完毕相应的学业调节。此中用到冒泡排序将作业按达到时刻还是运转时刻排序。

 1 #include "bits/stdc++.h"
 2 using namespace std;
 3 
 4 int ch_to_int(char* s){
 5     int ans = 0, len = strlen(s);
 6     for(int i = 0; i < len; i++) ans = ans*10 + s[i]-'0';
 7     return ans;
 8 }
 9 int main(int argc, char** argv){
10     int k, N, tj/*0~23*/, ys/*0~59*/, tmp;
11     freopen("test.txt", "w", stdout);
12     srand(time(NULL));   //以系统时间为种子生成真正的随机数
13     N = k = ch_to_int(argv[1]);
14     while(k--){
15         tmp = (rand() + 24)%24 * 100 + (rand() + 6)%6*10 + (rand() + 10)%10;
16         printf("%04d %dn", tmp, (rand() + N)%N + 1);
17     }
18     return 0;
19 }

美高梅网站是多少 4

 

  1. 关键程序段及其表明:

  调解算法:

#include<stdio.h>

 1 #include "bits/stdc++.h"
 2 #include "windows.h"
 3 using namespace std;
 4 typedef long long ll; 
 5 
 6 //(所有时间以分钟为单位存储,需要时转化) 
 7 
 8 ll systemTime;    //自定义系统当前时间
 9 
10 struct Task{
11     int Tij; //提交时间 
12     int Ysi; //预计运行时间 
13     ll waitingTime;  //等待时间
14     int id; //作业号
15     
16     ll prior(){
17         return 1 + waitingTime*1.0/Ysi;
18     }
19     
20     Task(int T, int Y){
21         Tij = T;
22         Ysi = Y;
23         waitingTime = 0;
24     }
25     ll aroundTime(){
26         return systemTime - Tij + Ysi;
27     }
28     
29     double priorTime(){
30         return aroundTime()*1.0/Ysi;
31     }
32     void disp(int ord){
33         printf("--调度次序: %d --作业号: %04d --调度时间:%02d%02d --周转时间: %d min(s) --带权周转时间%.2f  ...n", 
34             ord, id, (systemTime/100 + systemTime/60)%24, systemTime%60, aroundTime(), priorTime());
35     }
36 };
37 
38 int cmp1(const Task* a, const Task* b){
39     return (a->Tij) < (b->Tij);
40 }
41 
42 int main(){
43     vector<Task*> taskArr;    ///以不定长数组存储作业队列
44     
45     int Tij, Ysi, order;
46     ll ave_aroundTime = 0;
47     double ave_prior_aroundTime = 0;
48     
49     freopen("test.txt", "r", stdin);
50     system(".\生成测试数据.exe 1024");    //调用测试数据生成程序
51     
52     while(cin>>Tij>>Ysi) taskArr.push_back(new Task(Tij%100 + Tij/100*60, Ysi));
53     
54     ////按提交时间进行排序并编号 
55     sort(taskArr.begin(), taskArr.end(), cmp1);
56     std::vector<Task*>::iterator pos;
57     for(pos = taskArr.begin(); pos != taskArr.end(); pos++){
58         (*pos)->id = pos - taskArr.begin();
59     }
60     
61     std::vector<Task*>::iterator willRun;  //指向即将运行程序 
62     systemTime = (*taskArr.begin())->Tij;    ///将系统当前时间设置为最早提交的作业时间 
63     order = -1;
64     while(!taskArr.empty()){
65         bool flag = false; ///判定是否有新的程序提交 
66         willRun = taskArr.begin();
67         for(pos = taskArr.begin(); pos != taskArr.end(); pos++){
68             if((*pos)->Tij > systemTime) break;
69             willRun = (*willRun)->prior() < (*pos)->prior() ? pos : willRun;
70             flag = true;
71         }
72         if(!flag){
73             willRun = taskArr.begin();
74             systemTime = (*willRun)->Tij;
75         }
76         
77         (*willRun)->disp(++order);
78         
79         ave_aroundTime += (*willRun)->aroundTime();  //总周转 
80         ave_prior_aroundTime += (*willRun)->priorTime();  //总带权周转 
81         
82         for(pos = taskArr.begin(); pos != taskArr.end(); pos++){  //更新等待时间 
83             if((*pos)->Tij < systemTime){
84                 (*pos)->waitingTime += (*willRun)->Ysi;
85             }
86         }
87 
88         systemTime += (*willRun)->Ysi;  //系统时间增加 
89 
90         taskArr.erase(willRun); //结束则删除 
91         
92         //Sleep(10);
93     }
94     cout<<ave_aroundTime<<' '<<ave_prior_aroundTime<<endl;
95     printf("n----平均周转时间: %.2f --平均带权周转时间: %.2f ...n作业结束..", ave_aroundTime*1.0/order, ave_prior_aroundTime/order);
96 
97     return 0;
98 } 

#include <stdlib.h>

加油( ̄▽ ̄)"

int i,k,num,m,n;

#define N  24

struct JCB{

        char name[10];      //作业名

        float arrive;           //作业提交时间  

        float run;           //作业运转时刻  

        float start;          //初阶时间       

        float finish;       //实现时刻       

        float zhouzhuan;         //周转时间       

        float weight;       //带权周转时间  

}jcb[N],temp;

void input(卡塔尔(قطر‎                //顾客输入模块

{

    int i;  

    do{

        printf("nt请输入作业数(2-24卡塔尔:"卡塔尔(قطر‎;

        scanf("%d",&num); 

        printf("n");

        if(num<2||num>24)

{

            printf("t请重新输入!n");

        }

    }

    while(num<2||num>24);

    for(i=0;i<num;i++){

        printf("t第%d个作业名:",i+1卡塔尔(英语:State of Qatar);   

        scanf("%s",&jcb[i].name);   

        printf("nt请输入作业提交时间:"卡塔尔;   

        scanf("%f",&jcb[i].arrive);   

        printf("nt请输入作业运维时刻:"卡塔尔(قطر‎;   

        scanf("%f",&jcb[i].run);   

        printf("n");

    }

}

void output(卡塔尔(قطر‎             //输出模块

{

    float   numT=0;  

float numW=0;

float avgT=0;  //平均周转时间

float avgW=0;   //平均带权作业周转时间

    printf("-----------------------------------------------------------------------n");

    printf(" 作业名  提交时间  运转时刻  起首时间  达成时间  周转时间  带权周转时间n");

    for(i=0;i<num;i++)

    {

        printf("   %-8s%-10.2f%-10.2f%-10.2f%-10.2f%-10.2f%-10.2f",jcb[i].name,jcb[i].arrive,jcb[i].run,jcb

 

        [i].start,jcb[i].finish,jcb[i].zhouzhuan,jcb[i].weight);

        printf("n");

        numT=numT+jcb[i].zhouzhuan;

        numW=numW+jcb[i].weight; 

    }

    printf("-----------------------------------------------------------------------n");

    avgT=numT/num;

    avgW=numW/num;

    printf("平均作业周转时间:%.2fn",avgT);

    printf("n");

    printf("平均带权作业周转时间:%.2fn",avgW); 

    printf("n");

}

 float addallruntime(卡塔尔(قطر‎//得到全体作业运营时刻

 {

    int i;

     float allruntime=0.0;

           for(i=0;i<num;i++)

           {             

               allruntime=allruntime+jcb[i].run;

           }

           return allruntime;

 }

 

void fcfsrunning()

{

    for(k=0;k<num;k++)

    {

        if(k==0)/*运行第叁个作业*/

        {

            jcb[k].start=jcb[k].arrive;    

            jcb[k].finish=jcb[k].arrive+jcb[k].run; 

        }

        else

        {

            if(jcb[k].arrive>=jcb[k-1].finish)/*当下功课运转完,但前面作业没达到*/

            {

                jcb[k].start=jcb[k].arrive;     

                jcb[k].finish=jcb[k].arrive+jcb[k].run;

            }

            else/*一时一刻功课没运转完,后边作业已到达*/

            {

                jcb[k].start=jcb[k-1].finish;     

                jcb[k].finish=jcb[k-1].finish+jcb[k].run; 

            }

        }

            

    }

    for(k=0;k<num;k++)

    {

        jcb[k].zhouzhuan=jcb[k].finish-jcb[k].arrive;   

        jcb[k].weight=jcb[k].zhouzhuan/jcb[k].run;

    }

}

void FCFS(卡塔尔国     //先来先服务

{

    int i,j;

    for(j=0;j<num;j++卡塔尔    //冒泡排序,按达到时刻排序

    {

        for(i=0;i<num-j-1;i++)

        {

            if(jcb[i].arrive>jcb[i+1].arrive) 

            {

                temp=jcb[i];     

                jcb[i]=jcb[i+1];     

                jcb[i+1]=temp;

操作系统高响应比优先模拟算法,实验二报告【美高梅网站是多少】。            }

        }

    } 

    fcfsrunning();  

    output();

void SJF(float allruntime)  //非抢占

{

float mintime=0; struct JCB jtemp={0};

 

    int  min=0;

int startwork=0;

float i;

int k;

for (i=0;i<allruntime;)

 

  {

         mintime=jcb[startwork].run;//如若多个剩余时间的最小值

         for(k=startwork;k<num;k++)

         {

            

             if(jcb[k].run<=mintime&&jcb[k].arrive<=i)

            {

                 mintime=jcb[k].run;

                 min=k;

             }

             

         }

         jcb[min].start=i;

        

         jcb[min].finish=jcb[min].start+jcb[min].run;

         jcb[min].zhouzhuan=jcb[min].finish-jcb[min].arrive;

         jcb[min].weight=jcb[min].zhouzhuan/jcb[min].run;

         

         jtemp=jcb[startwork];

         jcb[startwork]=jcb[min];

         jcb[min]=jtemp;

         

         startwork++;

         

         i=i+mintime;

     }

output();

}

void HRRF(float allruntime)

 { 

     float maxrb=0;

     struct  JCB  jtemp={0};  

     int z=0;

     float time=0;

     int startwork=0;

     float i;

     int k;

     for(i=0;i<allruntime;)

     {

         maxrb=(i-jcb[startwork].arrive)/jcb[startwork].run+1;//假使是参天响应比

         

         for(k=startwork;k<num;k++)

         {              

             if(jcb[k].arrive<=i&&(i-jcb[k].arrive)/jcb[k].run+1>=maxrb卡塔尔(英语:State of Qatar)//若此作业的万丈响应比越来越高,则将其记为越来越高

             {

                 time=jcb[k].run;              

                 z=k;

             }          

         }

         jcb[z].start=i;

         jcb[z].finish=jcb[z].start+jcb[z].run;

         jcb[z].zhouzhuan=jcb[z].finish-jcb[z].arrive;

         jcb[z].weight=jcb[z].zhouzhuan/jcb[z].run;

         

         jtemp=jcb[startwork];

         jcb[startwork]=jcb[z];

         jcb[z]=jtemp; 

         startwork++;

         i=i+time;

     }

 output();

 }

main()

{

    int n;

float allruntime=0.0;   

    input(); 

allruntime=addallruntime();

    do{

       printf("tt作业调节模拟程序n"); 

        printf("----------------------------------------------------------------n");   

printf("t请接纳调整算法(1~3):n"); 

        printf("tt1:FCFS(先来先服务卡塔尔国ntt2:SJF(短作业优先卡塔尔(قطر‎ntt3:H奥迪Q7EnclaveF(最高响应比优先卡塔尔(英语:State of Qatar)ntt0:exit(退出)n");  

        scanf("%d",&n);   

        if(n!=0&&n!=1&&n!=2&&n!=3)

        {

            printf("nt请重新输入!!nn");

        }

        switch(n)

        {

            case 1:FCFS(); break;    

            case 2:SJF(allruntime); break;    

            case 3:HRRF(allruntime); break;    

            case 0: break;

        }

    }

    while(n!=0);

}

  1. 运营结果及深入分析

诚如必得配运行结果截图,结果是不是顺应预期及其剖析。

   (截图需依据实际,截取有代表性的测量检验例子)

先来先服务(FCFS):

美高梅网站是多少 5

美高梅网站是多少 6 

 短作业优先(SJF):

 美高梅网站是多少 7美高梅网站是多少 8

四、实验计算:

豆蔻梢头开头毫无头绪,因为并不领悟哪些算出调解结果。后来看多一回例子,做了演习,然后老师讲课三回后,起首了然算法的进程。然则用程序表明出来仍然困难的。但是想参谋网络的,但由于超多是用链表写的,看得不太懂。后来察觉用数组的款型也是足以的。何况比较直观,没那么难精通。不过写了先来先服务后,短作业优先就没那么轻巧完结了。因为要相比较作业的运维时刻,后来用了冒泡排序算法先实行生龙活虎番排序,再逐月完结相应的须求。至于最高相应比优先,就算知情了何等算出调治结果,但程序完毕不了.

本文由美高梅网站是多少发布于美高梅-操作,转载请注明出处:操作系统高响应比优先模拟算法,实验二报告【

上一篇:第七章 鼠标(CHECKER3)美高梅网站是多少: 下一篇:Linux下字符界面与控制台相互切换【美高梅网站是
猜你喜欢
热门排行
精彩图文