Question

鉴于此表： enter image description here

这些是时间线（时间片= 4）：

|p1|p1|p2|p3|p4|p5|p1|p2|p3|p4|p5|p2|p3|p4|p5|p2|p3|p4|p5|p2|p3|p3|
0  4  8 12 16  20 24 28 32 36 40 44 48 52 56 60 64 68 69 72 75 79 80

有没有一种简单的方法来计算平均等待时间？

谢谢

注意：每个流程有几个完成时间！

Note2 ：此问题还涉及优先级算法作为辅助练习，请忽略循环算法的优先级列

Answer 1

您可以通过绘制Gantt chart来计算等待时间，以便第i个过程的等待时间等于Completion time - (Arrival time + Burst time )。

Answer 2

对于RR，等待时间=上次开始时间 - 到达时间 - （抢占*量子）

P1的最后开始时间是24（当甘特图表中第3次P1运行时） P1在其生命周期中抢占2次量子= 4，到达= 0。

P1的等待时间= 24 - 0 - （2 * 4）= 16：）

Answer 3

让我们首先尝试解决此问题的简单版本，其中所有进程在时间0到达。假设我们有n个进程，每个进程的执行时间为ei。设时间片为s。让每个进程所需的时间片数为NSPi。现在我们有NSPi = ceiling(ei/s)。流程所需的时间i = NSPi * s。时间表的长度= sum over i from 1 to n (NSPi)。流程的等待时间i = finish time of i - execution time of i。但是每个进程的计算完成时间很复杂，因为每个进程都有不同的执行时间。但由于您只需要针对特定实例的RR算法的平均等待时间，您可以将其计算为：(Length of the schedule - sum of execution time of all processes)/num of processes。

我想现在你已经知道这个公式是如何演变的了。理想情况下，人们希望计划的长度等于所有进程的执行时间总和。但并非所有执行时间都是时间片的一个因素。因此，在某个时间片中，我们会得到没有安排进程的漏洞。因此在实践中，计划的长度大于执行时间的总和。现在我们将他们的差异作为总等待时间。

Answer 4

| H | I | J | K | L | H | Ĵ| K | L | J | K | L | J | L | L |它过于冗长，简而言之就是： 0 4 8 12 16 20 24 28 32 36 40 44 48 52 56 60 平均等待时间=（（H - 到达时间）+（I - 到达时间）+（J - 到达时间）+（K - 到达时间）+（L - 到达时间））/ 5 =（24-0）+（ 8-5）+（52-8）+（44-11）+（60-15）/ 5 = 29.8m sec 它过于冗长，简而言之就是：这里是RR调度算法的甘特图过程[爆发时间，时间量，到达时间] H [8,4,0] 我[4,4,5] J [16,4,8] k [12,4,11] L [20，常数= 4,15]

Answer 5

我尝试在java中实现它：

public static float waitingTimieRobin(int[] arrival, int[] run, int q) {
    Queue<Integer> orderQueue = new LinkedList<>();
    orderQueue.add(0);
    Set<Integer> orderSet = new HashSet<>();
    orderSet.add(0);

    float sumTime = 0.0f;

    int curTime = 0;
    while (!isOver(run)) {

        int order = orderQueue.poll();
        orderSet.remove(order);
        int arrTime = arrival[order];
        int runtime = run[order];
        sumTime += (curTime - arrTime);
        if (runtime <= q) {
            curTime += runtime;
            run[order] = 0;
        } else {
            curTime += q;
            arrival[order] = curTime;
            run[order] = runtime - q;
        }

        for (int i = 0; i < run.length; i++) {
            if (arrival[i] > curTime) {
                break;
            } else if (i != order && run[i] != 0 && !orderSet.contains(i)) {
                orderQueue.add(i);
                orderSet.add(i);
            }
        }

        if(arrival[order] == curTime && run[order] != 0 && !orderSet.contains(order)) {
            orderQueue.add(order);
            orderSet.add(order);
        }
    }

    return sumTime / arrival.length;
}

public static boolean isOver(int[] run) {
    for (int runtime : run) {
        if (runtime > 0) {
            return false;
        }
    }
    return true;
}

Answer 6

我的答案是等待时间和周转时间

等待时间：（16 + 51 + 51 + 45 + 42）/ 5 = 41 周转时间：（28 + 70 + 72 + 58 + 57）/ 5 = 57

如何计算循环调度的平均等待时间？

6 个答案: