it-swarm.com.ru

Как рассчитывать среднее время ожидания при циклическом планировании?

Учитывая эту таблицу: 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

Есть ли простой способ рассчитать среднее время ожидания? 

Спасибо 

Примечание: что для каждого процесса есть несколько времен окончания!

Примечание 2 : Этот вопрос также включал алгоритм приоритетов в качестве дополнительного упражнения, пожалуйста, не обращайте внимания на столбец приоритетов для алгоритма циклического перебора

7
ron

Давайте сначала попробуем решить простую версию этой проблемы, когда все процессы прибывают в момент времени 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.

Я думаю, что к настоящему времени у вас есть представление о том, как эта формула развивалась. В идеале хотелось бы, чтобы продолжительность расписания была равна сумме времени выполнения всех процессов. Но не все времена выполнения являются фактором временных интервалов. Так что через некоторое время мы получим дыры, в которых не запланирован ни один процесс. Таким образом, на практике длина расписания больше, чем сумма времени выполнения. Теперь у нас есть их разница как общее время ожидания.

0
arunmoezhi

Время ожидания можно рассчитать, нарисовав Gantt chart, так что время ожидания i-го процесса равно Completion time - (Arrival time + Burst time ).

7
user3919801

Для RR, Время ожидания = Время последнего запуска - Время прибытия - (приоритет * квант)

Время последнего запуска P1 - 24 (когда P1 работает в 3-й раз на диаграмме Ганна) P1 прерывается 2 раза в жизни Quantum = 4, Arrival = 0.

Время ожидания P1 = 24 - 0 - (2 * 4) = 16 :)

2
Ashis Kr. Das

| H | I | J | K | L | H | J | 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,8 м сек Это слишком долго, ваш короткий ответ таков: Вот это диаграмма Ганта алгоритма планирования RR Процесс [время пакета, квант времени, время прибытия] H [8, 4, 0] Я [4, 4, 5] J [16, 4, 8] k [12, 4, 11] L [20, постоянная = 4, 15] 

1
user2242139

Я попытался реализовать это в 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;
}
0
Mike-wei