操作系统——进度调度之短进度优先

例如在指令行中调用该函数,***.exe
十0,此时有三个参数,2个为”***.exe”,
另一个正是”100″了,分别在argv[0]和argv[1]中。

    }

三、短进程优先

最短CPU运营期优先调度算法(SCBF–Shortest CPU Burst First)

该算法从妥帖队列中选出下三个“CPU执行期最短”的长河,为之分配处理机

譬如说,在就绪队列中有多个经过P一、P二、P3和P四,它们的下2个进行

期独家是16、12、四和2个单位时间,执市场价格况如下图:

P一、P二、P三和P四的运维时间分别为35、1玖、柒、叁,平均运营时间为1陆。

该算法虽可取得较好的调度品质,但难以规范地领略下一个CPU执行期,而只好依照每2个进程的实施历史来预测。

 

4、C语言形式完成

  一》、常量注明和数据结构定义

#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; 

 

  二》、输入进度音信函数

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);    
} 

 

  三》、短进程优先算法【宗旨代码】

//先输入的肯定是先到达的 
//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;    
}

 

  四》、输出各个时刻的长河音讯函数

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

 

  伍》、输出进度运营整体景况计算

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,到达时间:%d\n",p->name,p->StartTime,p->FinishTime,p->WholeTime,p->ArrivalTime);
        p = p->link;    
    }    
        printf("\n----这组进程平均周转时间:%f,平均带权平均周转时间:%f\n",avgRevolve/M,avgSuperRevolve/M);
} 

   

  陆》、删除准备队列(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("当前时刻:%d\n",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("#################################################\n\n");
        }

            printf("\n");

            destory(nowProgress,now_time); 

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

    }            
    outputAll();
    return 0;
}

 

  8》、测试

输入数据:

365bet体育在线网投 1

 

运营结果:

365bet体育在线网投 2

 

简简单单中途的截图,那里只交付最终的总结景况的截图

 

365bet体育在线网投 3

 

  实际上,进度调度有很多样经过调度的方式,分歧的历程调度格局,他们的优缺点各有分化,而且他们的适用场景也不尽一致,那里只交付了短进度优先的调度情势。上面大家来相比一下,壹些调度措施【只是有个别】的优缺点:

1.先来先服务(FCFS, First Come First Serve),按先后顺序举行调度。 
(一)、适用场景:
正如便利长过程,而不便利短进度。因为长进度会长期占据处理机。
造福CPU繁忙的进度,而不便宜I/O繁忙的经过。 

(2)、优点:

便宜长进度,有利于等待时间久的进度,不会有进程长时间等待而得不到响应。有利于CPU频仍的经过。

(3)、缺点:

不方便人民群众短进度,忽视了经过的运作时刻。不便于I/O频繁的进度。

 

 

二. 响应比高者优先(H奔驰G级N):FCFS和SJF的的折中,动态变化昨夜的预先级。

(1)、优点:

既思虑了经过的等候时间,又思索了经过的运营时刻,是FCFS和SJF的的折中,会设想让进度短的先进行,随着长进程等待时间的充实,优先级相应的增多,使得通过自然时间的等候,必然有机会赢得处理机。

(2)、缺点:

在历次举行调度以前,都亟需先做响应比的测算,会追加系统的付出

叁. 先行级法(Priority Scheduling):依据进度的优先级,对经过经过调度。

(1)、分类:
静态优先级:
  进程调度中的静态优先级大多按以下条件规定: 
  由用户本身依照进程的火急程度输入1个体面的先行级。 
  由系统或操作员遵照进度类型钦赐优先级。 
  系统基于进程供给财富气象分明优先级。 
  进度的静态优先级的确定标准: 
  按进度的连串给予不一致的优先级。 
  将经过的千姿百态优先级作为它所属进程的先行级。 
动态优先级:
  进程的动态优先级一般根据以下规则明显: 
  根据进度占用有CPU时间的长度来支配。 
  依据就绪进度等待CPU的大运长短来支配。 

(2)、优点:

能够透过先行级反映进度的火急程序,使相比热切的进度优先运维

(3)、缺点:

亟待计算进程的优先级,会时有产生一定的开支。
四.短进度优先法(SJF, Shortest Job First):短进度优先运转,其指标是削减平均运营时间。 

(1) 优点: 
  比FCFS改善平均运转时间和平均带权周转时间,裁减进度的等候时间; 
  进步系统的吞吐量; 
(2) 缺点: 
  对长进程非凡不利于,恐怕长日子得不到执行; 
  未能依照过程的迫切程度来划分执行的先期级; 
  难以准确预计进程(进度)的推行时间,从而影响调度品质。 

应用SJF算法时,人—机交互不能兑现

 完全未思量进度的急切程度,故不可能确认保证热切性进度取得及时处理

 

 

 

 

 

 

 一、什么是经过调度

 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 %d\n", tmp, (rand() + N)%N + 1);
17     }
18     return 0;
19 }

可执行程序名:修改版.exe

二、处理机调度分类

三、短进度优先

最短CPU运转期优先调度算法(SCBF–Shortest CPU Burst First)

该算法从妥帖队列中选出下三个“CPU执行期最短”的历程,为之分配处理机

比如说,在就绪队列中有多少个经过P壹、P二、P3和P四,它们的下2个举行

期独家是16、1二、肆和1个单位时间,执市场价格况如下图:

P一、P2、P三和P四的运营时间独家为35、1九、七、三,平均运转时间为1陆。

该算法虽可取得较好的调度质量,但麻烦准确地领悟下贰个CPU执行期,而不得不依照每三个进度的执行历史来预测。

 

四、C语言情势完结

  一》、常量声明和数据结构定义

#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; 

 

  二》、输入进度音信函数

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);    
} 

 

  三》、短进度优先算法【宗旨代码】

//先输入的肯定是先到达的 
//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,到达时间:%d\n",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,到达时间:%d\n",p->name,p->StartTime,p->FinishTime,p->WholeTime,p->ArrivalTime);
        p = p->link;    
    }    
        printf("\n----这组进程平均周转时间:%f,平均带权平均周转时间:%f\n",avgRevolve/M,avgSuperRevolve/M);
} 

   

  陆》、删除准备队列(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("当前时刻:%d\n",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("#################################################\n\n");
        }

            printf("\n");

            destory(nowProgress,now_time); 

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

    }            
    outputAll();
    return 0;
}

 

  8》、测试

输入数据:

365bet体育在线网投 4

 

运作结果:

365bet体育在线网投 5

 

大约中途的截图,那里只交付最终的累计意况的截图

 

365bet体育在线网投 6

 

  实际上,进度调度有很四种进度调度的点子,差别的经过调度措施,他们的优缺点各有差异,而且她们的适用场景也相差非常的大,那里只交付了短进度优先的调度措施。上边大家来相比较一下,1些调度措施【只是部分】的得失:

1.先来先服务(FCFS, First Come First Serve),按先后顺序进行调度。 
(壹)、适用场景:
相比较有利长进度,而不便于短进度。因为长进程会短期占据处理机。
有利CPU繁忙的长河,而不便于I/O繁忙的长河。 

(2)、优点:

便利长进度,有利于等待时间久的历程,不会有经过长时间等待而得不到响应。有利于CPU频仍的进度。

(3)、缺点:

不便于短进度,忽视了经过的运行时刻。不便利I/O频仍的长河。

 

 

二. 响应比高者优先(HTiggoN):FCFS和SJF的的折中,动态变化昨夜的事先级。

(1)、优点:

既思虑了经过的守候时间,又考虑了经过的运作时刻,是FCFS和SJF的的折中,会思虑让进程短的先举行,随着长进度等待时间的增多,优先级相应的扩充,使得通过自然时间的等候,必然有机遇取得处理机。

(2)、缺点:

在历次实行调度在此以前,都急需先做响应比的盘算,会大增系统的开支

三. 预先级法(Priority Scheduling):根据进度的优先级,对进程经过调度。

(1)、分类:
静态优先级:
  进度调度中的静态优先级大多按以下原则分明: 
  由用户本身依照进程的急切程度输入3个老少咸宜的优先级。 
  由系统或操作员依照进度类型钦定优先级。 
  系统根据进度要求能源气象鲜明优先级。 
  进度的静态优先级的规定标准: 
  按进度的花色给予不一致的预先级。 
  将经过的姿态优先级作为它所属进度的优先级。 
动态优先级:
  进度的动态优先级一般依照以下条件规定: 
  根据进程占用有CPU时间的长度来支配。 
  依照就绪进度等待CPU的年月长度来支配。 

(2)、优点:

可以透过先行级反映进度的热切程序,使相比殷切的历程优先运行

(3)、缺点:

供给总计进程的优先级,会发生一定的支出。
4.短进度优先法(SJF, Shortest Job First):短进度优先运营,其目的是缩小平均运营时间。 

(1) 优点: 
  比FCFS革新平均运维时间和平均带权周转时间,减弱进度的等待时间; 
  升高系统的吞吐量; 
(2) 缺点: 
  对长进度非凡不利,大概长日子得不到执行; 
  未能依据进度的燃眉之急程度来划分执行的事先级; 
  难以准确测度进度(进度)的履行时间,从而影响调度质量。 

利用SJF算法时,人—机交互不能达成

 完全未思量进程的热切程度,故无法确定保证火急性进程取得及时处理

 

 

 

 

 

 

1 int main(int argc, char** argv){ ////argc为参数个数, argv为接下来传的参数
2     ...
3     return 0;
4 }

 

  无论是在批处理系统恐怕分时系统中,用户进度数1般都多于处理机数、那将造成它们相互斗争处理机。其它,系统经过也一样须要选用处理机。那就要求进度调度程序按一定的策略,动态地把拍卖机分配给处于就绪队列中的某贰个经过,以使之实践。   

高级、中级和低级调度作业从提交开首直到完毕,往往要经历下述三级调度:

  这学期刚开头读书操作系统,收到2个学业,百度有关高响应比优先(H安德拉TiggoN,Highest Response Ratio Next)的CPU进程调度模拟算法,基本考虑:短作业优先调度算法
+
动态优先权机制;既怀恋作业的进行时间也怀想作业的守候时间,综合了先来先服务(FCFS,First
Come First Served)和最短作业优先(SJF,Shortest Job
First)二种算法的特色。

    printf(“\n”);

 1、什么是进程调度

  无论是在批处理系统恐怕分时系统中,用户进度数一般都多于处理机数、那将造成它们相互斗争处理机。其它,系统经过也1如既往要求利用处理机。那就供给进度调度程序按一定的策略,动态地把拍卖机分配给处于就绪队列中的某三个经过,以使之推行。   

 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 } 

}

  • 高级调度:(High-Level
    Scheduling)又称为作业调度,它决定把后备进度调入内部存款和储蓄器运营; 
  • 起码调度:(Low-Level
    Scheduling)又称之为经过调度,它控制把就绪队列的某经过取得CPU; 
  • 高级中学级调度:(Intermediate-Level
    Scheduling)又称作在虚拟存款和储蓄器中引进,在内、外部存款和储蓄器对换区进行进度对换

 

  说起那里得说一下,关于java先生(没有错,java先生)说的有关main()的某个动静:

             }

高等、中级和低级调度作业从交付先河直到达成,往往要经历下述三级调度:

  • 高等调度:(High-Level
    Scheduling)又叫做学业调度,它决定把后备进度调入内部存款和储蓄器运营; 
  • 起码调度:(Low-Level
    Scheduling)又称作经过调度,它决定把就绪队列的某经过取得CPU; 
  • 高级中学级调度:(Intermediate-Level
    Scheduling)又称为在虚拟存款和储蓄器中引进,在内、外部存款和储蓄器对换区进行进度对换

  初叶,用vector存款和储蓄提交的课业结构体指针,本人安装三个系统时间,终归模拟不可能时间流速一毛壹样,接下去正是毫不技术含量的挑选了,关于测试数据,想了想好难输,还得要好编,于是用随意函数产生多少;再在主函数参数中提供三个传递生成数据数量的参数。

    avgT=numT/num;

 

二、处理机调度分类

加油( ̄▽ ̄)”

        if(num<2||num>24)

  关于响应比:

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

  响应比高者优先开始展览调度;

         i=i+mintime;

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

         

 

        printf(“\n\t请输入作业提交时间:”);   

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

        switch(n)

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

}

  调度算法:

int startwork=0;

 

int k;

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

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

 

            case 2:SJF(allruntime); break;    

  首先是数据变动,用为要求格式,所以要小拍卖一下,感觉那种办法能够在刷ACM题被难题玄学时选择,三个为正规代码,三个为团结的代码,如今未试过:

void output()             //输出模块

    周转时间 =(作业完成的年华 – 作业提交时间);

             {

  关于要求中的周转时间、带权周转时间、平均运转时间和平均带权周转时间:

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

    RubiconXC90 =  (猜度运维时刻 + 等待时间) / 测度运转时刻 = 一 +
等待时间/推断运转时刻;

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

 

    {

         i=i+time;

{

        printf(“\t\t一:FCFS(先来先服务)\n\t\t二:SJF(短作业优先)\n\t\t三:H中华VQashqaiF(最高响应比优先)\n\t\t0:exit(退出)\n”);  

            }

    while(n!=0);

        {

 

#include <stdlib.h>

}

            printf(“\t请重新输入!\n”);

        printf(“\n”);

三、 实验艺术、步骤及结果测试

         startwork++;

               allruntime=allruntime+jcb[i].run;

    }

 { 

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

    int i;

void HRRF(float allruntime)

    for(j=0;j<num;j++)    //冒泡排序,按到达时间排序

 float addallruntime()//获得全部作业运营时刻

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

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

         jcb[z]=jtemp; 

        else

float numW=0;

{

1、 实验指标

    printf(“\n”);

{

二、 实验内容和供给

       printf(“\t\t作业调度模拟程序\365bet体育在线网投,n”); 

         jtemp=jcb[startwork];

一开端毫无头绪,因为并不知晓哪些算出调度结果。后来看多两遍例子,做了演习,然后老师讲课两回后,开首领悟算法的进度。但是用程序表达出来依旧困难的。可是想参考网上的,但由于大多是用链表写的,看得不太懂。后来察觉用数组的款型也是足以的。而且相比直观,没那么难精晓。可是写了先来先服务后,短作业优先就没那么不难达成了。因为要比较作业的运维时刻,后来用了冒泡排序算法先实行1番排序,再逐级完结相应的渴求。至于最高相应比优先,纵然知道了什么样算出调度结果,但程序完结不了.

        float finish;       //实现时刻       

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

{

    do{

float allruntime=0.0;   

发表评论

电子邮件地址不会被公开。 必填项已用*标注