精华内容
下载资源
问答
  • 平均周转时间
    千次阅读
    2021-06-22 16:36:19

    周转时间(作业周转时间)指的是从作业被提交给系统开始, 到作业完成为止的这段时间

    周转时间包括四部分:

    1. 作业在外存后备队列上等待作业调度的时间
    2. 进程在就绪队列上等待进程调度的时间
    3. 进程在cpu上执行的时间
    4. 进程等待I/O操作完成的时间

    周转时间=作业完成时间−作业提交时间

    平均周转时间=(作业1的周转时间+…+作业n的周转时间)/n

    带权周转时间=作业周转时间作业/实际运行时间

    平均带权周转时间=(作业1的带权周转时间+…+作业n的带权周转时间)/n

    更多相关内容
  • 计算出平均周转时间和平均带权周转时间 题目: 现在已知系统中有5个进程,其到达时间和要求服务时间如表所示: 进程次序: p1–p2–p3–p4–p5, 时间片大小: 4 到达时间: [0, 1, 2, 3, 4] 要求服务时间: [6, 3, 3, ...

    计算出平均周转时间和平均带权周转时间

    题目:

    现在已知系统中有5个进程,其到达时间和要求服务时间如表所示:
    进程次序: p1–p2–p3–p4–p5, 时间片大小: 4
    到达时间: [0, 1, 2, 3, 4]
    要求服务时间: [6, 3, 3, 4, 6]
    要求:
    (1) 计算出平均周转时间;
    (1) 计算出平均带权周转时间;
    注意:浮点数小数点后保留2位(四舍五入)
    参考答案:
    平均周转时间 12.6
    平均带权周转时间 2.75

    """
    此程序十分不严谨
    仅用于考试快速出答案
    """
    
    
    N = 4
    serve_time = [9,2,7,7,7]
    pro = [0, 1, 2, 3, 4]
    
    def deal_serve_time():
        ret = []
        _serve_time = serve_time.copy()
        while sum(_serve_time) > 0:
            for i in range(len(serve_time)):
                for j in range(N):
                    if _serve_time[i] > 0:
                        ret.append(i)
                        _serve_time[i] -= 1
        return ret
    
    def count_time(serve_list):
        ret = []
        serve_list_r = list(reversed(serve_list))
        for i in pro:
            lst = len(serve_list) - serve_list_r.index(i) - i
            ret.append(lst)
        return ret
    
    def count_avg_time(time):
        return sum(time) / len(time)
    
    def count_avg_quan_time(time):
        ret = []
        for i in range(len(time)):
            ret.append(time[i] / serve_time[i])
        return sum(ret) / len(ret)
    
    
    serve_list = deal_serve_time()
    time = count_time(serve_list)
    avg_time = count_avg_time(time)
    avg_quan_time = count_avg_quan_time(time)
    print(avg_time)
    print(avg_quan_time)
    
    展开全文
  • 本文介绍了计算“完成时间、周转时间、平均周转时间、带权周转时间和平均带权周转时间”的公式,并且用先来先服务(FCFS)、短作业优先(SJF)两种调度算法来分析一个例题。

    摘要:微信搜索【三桥君

    本文介绍了计算“完成时间、周转时间、平均周转时间、带权周转时间和平均带权周转时间”的公式,并且用先来先服务(FCFS)、短作业优先(SJF)两种调度算法来分析一个例题。

     一、前言


    这里要补充一些说明,方便大家理解。

    我们做这类题目时,一般都需要画表,完整的表格方式可以是如图:


    一般来说,表的所有列名就8个了,但是实际题目中,列名的个数会缺少,甚至列名的名称也会不一样。但是他们不管名称怎么变,都必须对应上原先的列名,因为每个对应的列名都是有固定的作用和含义的。

    这里举例下经常会变动的列名名称,如作业号改为“进程号”,提交时刻改为“提交时间”、“到达时间”,运行时间改为“服务时间”等等,这样子会导致一开始没看出来题目意思,或者导致混淆题意等。

    因此,这里我强调下,其实他们名称虽然变了,但是要表达的意思和作用是一样的,而且我们公式还要用到这些对应的列名。

     

    二、公式


    周转时间=完成时间-提交时刻
    平均周转时间=周转总时间/作业总个数
    带权周转时间=周转时间/运行时间
    平均带权周转时间=带权周转总时间/作业总个数

    说明:

    这类题目一般有先来先服务(FCFS)、短作业优先(SJF)两种调度算法,只有在作业的完成时间计算上有一些区别,其他时间的计算公式都是相同的。

    三、例题


    (一)题目


    假设有三道作业,它们的提交时间及运行时间由下表给出,

    作业提交时刻(时)运行时间(小时)
    1107
    2113
    3131

    采用非多道程序设计,并且采用“先来先服务”作业调度算法。指出它们的调度顺序,并分别计算平均周转时间和平均带权周转时间。


    (二)答案

    作业提交时刻运行时间完成时间周转时间平均周转时间带权周转时间平均带权周转时间
    1107177814
    21132093
    31312188

    (三)分析

    因为题目是采用“先来先服务”作业调度算法,所以服务顺序根据提交时刻来排序。

    计算步骤:

    1、找出最先到达的作业(该进程的完成时间=提交时间+运行时间);

    2、根据给出的提交时刻,找出下一个到达的作业(该作业的完成时间=上一作业的完成时间+该作业的提交时刻);

    3、重复2,直至完成所有作业的计算。

     

    作业服务顺序:1->2->3。

    作业提交时刻运行时间完成时间周转时间平均周转时间带权周转时间平均带权周转时间
    110710+7=1717-10=7(7+9+8)/3=87/7=1(1+3+8)/3=4
    211317+3=2020-11=99/3=3
    313120+1=2121-13=88/1=8

    四、举一反三

    那么问题来了,如果例题题目要求改为“短作业优先(SJF)”作业调度算法的话,该怎么做呢?

    (一)分析

    因为题目是采用“先来先服务”作业调度算法,所以服务顺序就不是根据提交时刻来排序了,但是第一个服务的作业还是以第一个提交时刻来的。

    计算步骤:

    1、找出最先到达的作业(该进程的完成时间=提交时刻+运行时间);

    2、根据上一作业的完成时间,找到提交时刻在这个完成时间内的作业,并找到这些作业中运行时间最短的那个,然后计算它的完成时间(该作业的完成时间=上一作业的完成时间+该作业运行时间);

    3、重复2,直至完成所有作业的计算。

     

    作业服务顺序:1->3->2。

    作业提交时刻运行时间完成时间周转时间平均周转时间带权周转时间平均带权周转时间
    110710+7=1717-10=7(7+10+5)/3=7.37/7=1(1+3.3+5)/3=3.1
    211318+3=2121-11=1010/3=3.3
    313117+1=1818-13=55/1=5

     

    《参考文章》

    1、完成时间,周转时间,平均周转时间以及带权周转时间和平均带权周转时间

    2、周转时间,平均周转时间,带权周转时间

    3、操作系统进程完成时间,周转时间,带权周转时间, 平均周转时间, 带权平均周转时间计算


    文章整理不易,有帮助请点赞关注支持,谢谢!微信搜索【三桥君 】,回复【关注】有我准备的一份资源大礼包。后续持续更新~~~

    展开全文
  • } cout 平均周转时间:" ; cout 平均带权周转时间:" ; } void JCB::makeJCB(int x) { if(x == 0) { bubbleSort1(x,length); startTime[x] = arriveTime[x]; makeTime(x); } else { int count = getCount(x); if...
    #include <iostream>
    
    using namespace std;
    
    class JCB
    {
    public:
        void input();
        void output();
        void bubbleSort(int start, int len);
        void bubbleSort1(int start, int len);
        int getCount(int x);
        void swap(int x, int y);
        void makeJCB(int x);
        void makeTime(int x);
        void init();
        void printCir();
    private:
        int length;
        double arriveTime[10];
        double startTime[10];
        double workTime[10];
        double finishTime[10];
        double cirTime[10];
        double dqzzTime[10];
        string name[10];
    };
    
    void JCB::input()
    {
        cout << "请输入进程数量: ";
        cin >> length;
        for(int i=0; i<length; i++)
        {
            cout << "进程" << i+1 << ": " << endl;
            cout << "请输入进程名称:"; cin >> name[i];
            cout << "请输入进程到达时间:"; cin >> arriveTime[i];
            cout << "请输入进程运行时间:"; cin >> workTime[i];
        }
    
    }
    
    void JCB::output()
    {
        cout << endl;
                cout << "进程名称  " << "到达时间  " << "处理时间  " << "开始时间  "<< "完成时间  " << "周转时间  " << "带权周转时间  " << endl;
        for(int i=0; i<length; i++)
        {
            makeJCB(i);
    
            cout << name[i] << "  \t" << arriveTime[i] << "  \t" << workTime[i] << "  \t" << startTime[i] << "  \t"
            << finishTime[i] << "  \t" << cirTime[i] << "  \t" << dqzzTime[i] << "\t  " << endl;
            cout << endl;
        }
    }
    
    void JCB::bubbleSort(int start, int len)
    {
        for(int i=start; i<start+len-1; i++)
            for(int j=start; j<start+len-1; j++)
                if(workTime[j] > workTime[j+1])
                    swap(j,j+1);
    }
    
    void JCB::bubbleSort1(int start, int len)
    {
        for(int i=start; i<start+len-1; i++)
            for(int j=start; j<start+len-1; j++)
                if(arriveTime[j] > arriveTime[j+1])
                    swap(j,j+1);
    }
    
    int JCB::getCount(int x)
    {
        int count = 0;
        int y = x-1;
        for(int i=x; i<length; i++)
            if(arriveTime[i] <= finishTime[y])
                count++;
        return count;
    }
    
    void JCB::swap(int x, int y)
    {
        double temp;
        string temp1;
        temp = arriveTime[x]; arriveTime[x] = arriveTime[y]; arriveTime[y] = temp;
        temp = workTime[x]; workTime[x] = workTime[y]; workTime[y] = temp;
        temp1 = name[x]; name[x] = name[y]; name[y] = temp1;
    }
    
    void JCB::makeTime(int x)
    {
        finishTime[x] = startTime[x] + workTime[x];
        cirTime[x] = finishTime[x] - arriveTime[x];
        dqzzTime[x] = cirTime[x] / workTime[x];
    }
    
    void JCB::printCir()
    {
        double Tcir = 0;
        double Tdqzz = 0;
        for(int i=0; i<length; i++)
        {
            Tcir = Tcir + cirTime[i];
            Tdqzz = Tdqzz + dqzzTime[i];
        }
        cout << "平均周转时间:" << Tcir/length << endl;
        cout << "平均带权周转时间:" << Tdqzz/length << endl;
    
    }
    
    void JCB::makeJCB(int x)
    {
        if(x == 0)
        {
            bubbleSort1(x,length);
            startTime[x] = arriveTime[x];
            makeTime(x);
        }
        else
        {
            int count = getCount(x);
            if(count == 0)
            {
                startTime[x] = arriveTime[x];
                makeTime(x);
            }
            else
            {
                bubbleSort(x,count);
                startTime[x] = finishTime[x-1];
                makeTime(x);
            }
        }
    }
    
    void JCB::init()
    {
        for(int i=0; i<10; i++)
        {
            arriveTime[i] = 0;
            startTime[i] = 0;
            workTime[i] = 0;
            finishTime[i] = 0;
            cirTime[i] = 0;
            dqzzTime[i] = 0;
        }
    }
    
    int main()
    {
        JCB A;
        A.init();
        A.input();
        A.output();
        A.printCir();
    }
    

    在这里插入图片描述

    展开全文
  • #include #include #include main() { char pn[10][10],t[10]; int arr[10],bur[10],... } printf("\n平均周转时间:%.2f",(float)tottat/n); printf("\n平均带权周转时间:%.2f",(float)totwt/n); getch(); return 0; }
  • 平均周转时间和平均带权周转时间怎么算?

    万次阅读 多人点赞 2020-06-03 20:17:57
    平均周转时间=作业周转总时间/作业个数 平均带权周转时间=带权周转总时间/作业个数 例题: 假定要在一台处理器上执行下表所示作业,且假定这些作业在时刻0以1、2、3、4、5的顺序到达。说明分别使用FCFS、RR(时间片=1...
  • 衡量调度策略的最常用的几个指标是:周转时间、吞吐率、响应时间以及设备利用率等。 周转时间是指将一个作业提交给计算机系统后到该作业的结果返回给用户所需要的时间。 吞吐率是指在给定的时间内,一个计算机系统所...
  • 这里仅对先来先服务(FCFS)以及短作业优先(SJF)两种调度算法的相关计算做一个说明和比较 首先我们必须明确:FCFS和SJF两种调度算法,只有在... 平均周转时间=周转时间/进程数(除法运算) 平均带权周转时间=带权
  • 平均周转时间,平均等待时间

    万次阅读 2018-07-17 22:10:46
    现有4个同时到达的作业J1,J2,J3和J4,它们的执行时间分别是1小时,3小时,5小时,7小时,系统按单道方式运行且采用短作业优先算法,则平均周转时间是()小时 平均周转时间:周转时间总时间/总的作业个数: 周转时间:...
  • 计算规则 周转时间=作业完成时刻-作业到达时刻; 带权周转时间=周转时间/服务时间; 平均周转时间=作业周转总时间/作业个数; 平均带权周转时间=带权周转总时间/作业个数; ...
  • 周转时间 = 进程完成时间 - 进程到达时间 平均周转时间 = 周转时间之和 / 进程个数 带权周转时间 = 周转时间 / 进程实际运行时间 平均带权周转时间 = 带权周转时间之和 / 进程个数 FSFS 平均周转时间 = [(4-0)+(7...
  • 对T0,T1,...,Tn-1递增排序,得Tk0 , Tk1, …… ,Tkn-1,设T'位SJF策略生成的调度方案的平均周转时间,则: T' = [ Tk0 + (Tk0 + Tk1)+……+( Tk0 + Tk1 + ……+ Tkn-1)]/n 对比构成T和T'的每个累加项,后者...
  • ** 用C语言编程实现“先来先服务(FCFS)”算法模拟作业调度,输出平均周转时间、平均带权周转时间** 要求:按作业的到达顺序输入各作业需要的运行时间,按算法调度输出平均周转时间。 例如(FCFS),输入:8(到达时间...
  • 进程平均周转时间

    千次阅读 2018-04-18 10:43:14
    设一个系统中有5个进程,它们的到达时间和...忽略I/O以及其他开销时间,若分别按先来先服务(FCFS)进行CPU调度,其平均周转时间为_______解析:平均周转时间表示,所有进程完成任务所花的所有时间除以进程的个数A:...
  • t2 平均周转时间 = (总的运行时间 + 总的等待时间)/n其中总的运行时间是定值,n为定值,因此要平均周转时间最短既要求总的等待时间最短。按照最短作业优先,设第i个作业的等待时间为ai.则a1 = 0a2 = t1a3 = t1 + t2...
  • • 输出:每个作业的编号、作业开始执行时间、作业结束时间以及该调度算法的平均等待时间、平均周转时间。 1. job.txt说明: 第一行:作业数 轮转片大小 第二行以后:作业编号 到达时间 执行时间 优先级 2. 输出说明...
  • 时间片轮转法:平均周转时间

    万次阅读 多人点赞 2018-06-06 15:03:31
    时间片轮转法(RR)算法描述:用于分时系统中的进程调度。每次调度时,总是选择就绪队列的队首进程,让其在CPU上运行一个系统预先设置好的时间片。一个时间片内没有完成运行的进程,返回到绪队列末尾重新排队,等待...
  • 平均周转时间各种算法

    万次阅读 多人点赞 2018-06-26 15:49:11
    平均周转时间各种算法有5个批处理的作业(A、B、C、D和E)几乎同时到达一个计算中心,估计的运行时间分别为2、4、6、8、10分钟,它们的优先数分别为1、2、3、4、5(1为最低优先级)。对下面的每种调度算法,分别计算...
  • 周转计算器CPU调度计算器。 仅适用于循环赛计算等待时间为0的2-3个进程的平均周转时间
  • 周转时间=作业完成时刻—...平均周转时间=作业周转总时间/作业个数; 平均带权周转时间=带权周转总时间/作业个数; 有5个批处理的作业(A、B、C、D和E)几乎同时到达一个计算中心,估计的运行时间分别为2、4、6...
  • 1、吞吐率(单位时间执行命令的个数) 具体的原理就不讲解了,下面看一下有关这几方面的题目:  2004年 若指令流水线把一条指令分为取指、分析和执行三部分,且三部分时间分别是2ns,2ns,1ns。则100条指令全部执行...
  • 周转时间,平均周转时间,带权周转时间

    万次阅读 多人点赞 2016-11-17 14:07:27
    周转时间,平均周转时间,带权周转时间@(OS)这三个概念需要特别理解清楚。周转时间=作业完成时间−作业提交时间周转时间 = 作业完成时间 - 作业提交时间特别注意作业提交时间不是作业进内存的时间,而是发出请求,...
  • 试计算在单道程序环境下,采用先来先服务调度算法和短作业优先调度算法时的平均周转时间和平均带权周转时间,并指出它们的调度顺序。 先来先服务(FCFS)调度算法: 是最简单的一种调度算法,它不仅可以用于高级...
  • 进程平均周转时间的计算

    万次阅读 2016-07-11 09:40:41
    题目: 有4个进程A,B,C,D,设它们...四个进程的平均周转时间为 ()? 分析 要理解周转时间的含义,所谓的周转时间就是进程从开始到结束所经历的时间; 平均周转时间就是所有进程的周转时间除以进程的个数就OK了。
  • 关于平均周转时间的一些题目   (1) 设一个系统中有5个进程,它们的到达时间和服务时间如下,A的到达时间为0,服务时间为3;B的到达时间为2,服务时间为6;C的到达时间为4,服务时间为4;D的到达时间为6,服务...
  • 若作业在处理机上按单道方式运行,且作业按响应比搞着优先调度算法,进程按先来先服务算法,试写出作业的执行顺序,计算响应比,作业的周转时间和平均周转时间 作业 进入输入井时间 计算时间 ...
  • 若采用高响应比优先调度算法,试问平均周转时间和平均带权周转时间为多少? 高响应比优先(HRRN)调度算法 是对FCFS调度算法和短作业优先调度算法的一种综合平衡。 FCFS算法只考虑等待时间而未考虑运行时间的长短 ...
  • 1.周转时间 2.平均周转时间 平均周转时间是对n个而言的 3.带权周转时间 真正的运行时间指的是进程占有处理机的时间 4.平均带权周转时间 即n个平均的带权周转时间

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 12,589
精华内容 5,035
关键字:

平均周转时间

友情链接: CRC计算.rar