it-swarm.com.de

Wie berechnet man die durchschnittliche Wartezeit der Round-Robin-Planung?

Angesichts dieser Tabelle: enter image description here

Das sind die Zeitlinien (Zeitscheibe = 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

Gibt es eine einfache Möglichkeit, die durchschnittliche Wartezeit zu berechnen?

Vielen Dank

Hinweis: dass es für jeden Prozess mehrere Endzeiten gibt!

Anmerkung 2 : Diese Frage betraf auch den Prioritätsalgorithmus als Nebenübung. Bitte ignorieren Sie die Prioritätsspalte für den Round-Robin-Algorithmus

7
ron

Versuchen wir zuerst, die einfache Version dieses Problems zu lösen, bei der alle Prozesse zum Zeitpunkt 0 ankommen. Angenommen, wir haben n verarbeitet, wobei jeder Prozess die Ausführungszeit als ei hat. Die Zeitscheibe sei s. Die Anzahl der für jeden Prozess benötigten Zeitscheiben sei NSPi. Nun haben wir NSPi = ceiling(ei/s). Zeit für einen Prozess i = NSPi * s. Länge des Zeitplans = sum over i from 1 to n (NSPi). Wartezeit für den Prozess i = finish time of i - execution time of i. Die Berechnungsendzeit jedes Prozesses ist jedoch kompliziert, da jeder Prozess eine andere Ausführungszeit hat. Da Sie jedoch nur die durchschnittliche Wartezeit des RR-Algorithmus für eine bestimmte Instanz benötigen, können Sie dies wie folgt berechnen: (Length of the schedule - sum of execution time of all processes)/num of processes.

Ich denke, Sie hätten jetzt eine Vorstellung davon, wie sich diese Formel entwickelt hat. Idealerweise möchte man, dass die Länge des Zeitplans der Summe der Ausführungszeit aller Prozesse entspricht. Aber nicht alle Ausführungszeiten sind ein Faktor der Zeitscheiben. In einer Zeitscheibe bekommen wir also Löcher, an denen kein Prozess geplant ist. In der Praxis ist die Länge des Zeitplans also größer als die Summe der Ausführungszeiten. Jetzt haben wir ihre Differenz als Gesamtwartezeit.

0
arunmoezhi

Sie können die Wartezeit berechnen, indem Sie Gantt chart zeichnen, sodass die Wartezeit des ith-Prozesses gleich Completion time - (Arrival time + Burst time ) ist.

7
user3919801

Für RR Wartezeit = Letzter Startzeitpunkt - Ankunftszeit - (Preemption * Quantum)

Der letzte Startzeitpunkt von P1 ist 24 (wenn P1 zum dritten Mal in der Gannt-Tabelle läuft) P1 wurde während seiner Lebensdauer 2 Mal vorzeitig Quantum = 4, Ankunft = 0.

Wartezeit von 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 | Es ist zu lang, Ihre Antwort ist in Kürze: 0 4 8 12 16 20 24 28 32 36 40 44 48 52 56 60 Durchschnittliche Wartezeit = ((H - Ankunftszeit) + ( I - Ankunftszeit) + (J - Ankunftszeit) + (K - Ankunftszeit) + (L - Ankunftszeit))/5 = (24-0) + (8-5) + (52 - 8) + (44) -11) + (60 - 15)/5 = 29,8 ms Ihre Antwort ist zu lang und kurz: Hier ist das Gantt-Diagramm des RR-Scheduling-Algorithmus Prozess [Burst-Zeit, Zeitquantum, Ankunftszeit] H [8, 4, 0] I [4, 4, 5] J [16, 4, 8] k [12, 4, 11] L [20, konstant = 4, 15] 

1
user2242139

Ich habe versucht, es in Java zu implementieren:

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