web-dev-qa-db-fra.com

Comment calculer le temps d'attente moyen de la planification du tournoi à la ronde?

Étant donné ce tableau: enter image description here

Ce sont les lignes de temps (tranche de temps = 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

Existe-t-il un moyen simple de calculer le temps d’attente moyen?

Merci

Remarque: qu'il existe plusieurs temps d'arrivée pour chaque processus!

Note2 : Cette question concernait également l'algorithme de priorité en tant qu'exercice parallèle. Veuillez ne pas tenir compte de la colonne de priorité de l'algorithme Round Robin.

processschedulinggantt-chart
7
ron

Essayons d’abord de résoudre la version simple de ce problème dans laquelle tous les processus arrivent à l’heure 0. Supposons que nous avons n processus chacun avec une durée d’exécution égale à ei. Laissez la tranche de temps être s. Laissez le nombre de tranches de temps nécessaires pour chaque processus être NSPi. Nous avons maintenant NSPi = ceiling(ei/s). Temps nécessaire pour un processus i = NSPi * s. Durée de la planification = sum over i from 1 to n (NSPi). Temps d'attente pour le processus i = finish time of i - execution time of i. Mais le temps de traitement de chaque processus est compliqué car chaque processus a un temps d'exécution différent. Mais comme vous avez juste besoin du délai d'attente moyen de l'algorithme RR pour une instance spécifique, vous pouvez le calculer comme suit: (Length of the schedule - sum of execution time of all processes)/num of processes.

Je suppose que vous avez maintenant une idée de la façon dont cette formule a évolué. Idéalement, on souhaiterait que la durée de la planification soit égale à la somme du temps d'exécution de tous les processus. Mais tous les temps d'exécution ne sont pas un facteur des tranches de temps. Donc, à un moment donné, nous obtenons des trous pour lesquels aucun processus n'est planifié. Donc, dans la pratique, la durée de la planification est supérieure à la somme des temps d'exécution. Nous avons maintenant leur différence en tant que temps d'attente total.

0
arunmoezhi

Vous pouvez calculer le temps d'attente en sélectionnant Gantt chart. Le temps d'attente du processus est donc égal à Completion time - (Arrival time + Burst time ).

7
user3919801

Pour RR, temps d'attente = dernière heure de début - heure d'arrivée - (préemption * quantum)

La dernière heure de début de P1 est 24 (lorsque P1 s'exécute pour la troisième fois dans le diagramme de Gannt) P1 préempté 2 fois dans sa vie Quantum = 4, Arrival = 0.

WaitingTime de 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 | C'est trop long, votre réponse est la suivante: 0 4 8 12 16 20 24 28 32 36 40 44 48 52 56 60 Temps d'attente moyen = ((H - heure d'arrivée) + + I - heure d'arrivée) + (J - heure d'arrivée) + (K - heure d'arrivée) + (L - heure d'arrivée))/5 = (24- 0) + (8-5) + (52 - 8) + (44 -11) + (60 - 15)/5 = 29.8 m sec C'est trop long, votre réponse est la suivante: Ici, il s'agit du diagramme de Gantt de l'algorithme de planification RR. Processus [temps de rafale, temps quantique, heure d'arrivée] H [8, 4, 0] I [4, 4, 5] J [16, 4, 8] k [12, 4, 11] L [20, constante = 4, 15] 

1
user2242139

J'ai essayé de l'implémenter en 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