Partie 2 : ordonnanceur
Partie A: ordonnancement avec tourniquet
On rappelle qu’un processus est l’instance d’un programme en cours d’exécution, par exemple, si vous lancez plusieurs fois le programme Word il y aura plusieurs instances ou objets programme Word en cours d'exécution sur le PC, chaque instance sera un processus différent . Un processus est identifié par un numéro unique appelé PID:
Ci_dessous, deux instances différentes de Word en cours d'exécution sur le PC:
L’ordonnanceur est la composante du noyau système d’exploitation qui gère l’accès au processeur pour les différents processus en cours d'exécution sur le PC. Nous allons nous intéresser à l’algorithme d’ordonnancement du tourniquet dont le fonctionnement est résumé ci-dessous :
Les processus prêts à être exécutés sont placés dans une file d’attente selon leur ordre d’arrivée.
L’algorithme de l'ordonnanceur alloue le processeur à chaque processus de la file d’attente un même nombre de cycles CPU appelé quantum ( 1 cycle CPU = 1 top d'horloge qui cadence le rythme de travail du processeur ).
Si le quantum est égal à 1, le temps d'accès au processeur est directement 1 cycle du cpu; si la fréquence d'horloge processeur est de 3 GHz soit 3 milliards de cycles CPU chaque seconde, chaque processus reste exécuté le temps du quantum = 1/ (3x109 ) s
Si le processus n’est pas terminé au bout du quantum, son exécution est suspendue et il est mis à la fin de la file d’attente ;
Si le processus est terminé, il sort définitivement de la file d’attente
Question 1
On considère trois processus soumis à l’ordonnanceur au même instant pour lesquels on donne les informations ci-dessous:
fig1
a) Si le quantum du tourniquet est d’un cycle CPU, recopier et compléter la suite des PID des processus dans l’ordre de leur exécution :
11, 20, 32, 11, ....................
b) Donner la composition de la suite des PID lorsque le quantum du tourniquet est de deux cycles CPU.
Question 2
L’objectif de la suite de l’exercice est de simuler en langage Python l’algorithme du tourniquet.
On définit la classe processus qui permet d'obtenir de créer des instances de processus (objets processus) , un objet processus possède 4 attributs ( pid, duree, reste_à faire et état) . Lors de la création de l'instance, le processus est mis dans la file avec l'état Prêt. A chaque cycle de cpu, l'attribut reste_à faire est décrémenté de 1 ( diminué de 1).
Tant que l'attribut reste_a_faire est > 0 , le processus retourne dans la file quand son temps d'exécution est écoulé, son état devient alors suspendu. Quand l'attribut reste_a_faire devient <= 0 , processus passe dans l'état terminé et il ne retourne pas dans la file d’attente quand son temps d'exécution est écoulé.
Les états possibles d’un processus sont : « Prêt », « En cours d’exécution », « Suspendu » et « Terminé »
Voici la création de la file d'attente et l'ajout de processus:
# création de la file d'attente
liste_attente = [ ]
# création d'un objet proc1 de PID 11 et de durée 4 cycles cpu
proc1 = Processus(11 ,4 )
# ajout de proc1 dans la file d'attente
liste_attente = [ ]
liste_attente.append( proc1 )
a) créer deux processus proc2 et proc 3, qui correspondent aux processus du tableau fig1 et les ajouter dans la file d'attente
b) Ajouter la méthode affiche_etat ci_dessous à votre classe Processus, cette méthode affiche le numéro d'un processus et son état:
def affiche_etat(self):
""" affiche le pid d'un processus et son état"""
print(f"le processus numéro {self.pid} est dans l'état {self.etat}")
c) Ajouter la méthode execute_un_cycle à la classe Processus, cette méthode met à jour la valeur de l'attribut reste_à_faire à chaque cycle d'exécution du cpu:
d) Exécuter l'instruction ci-dessous puis afficher la valeur de l'attribut reste_à_faire de proc1 pour vérifier que la méthode est fonctionnelle
proc1. execute_un_cycle()
e) Ajouter la méthode change_etat (self, nouvel_etat) à la classe Processus, cette méthode met à jour la valeur de l'attribut etat qui doit prendre la valeur de nouvel_etat
f) Ajouter la méthode est_terminé (self) à la classe Processus, cette méthode renvoie True si l'attribut reste_a_faire contient un nombre inférieur ou égal à 0.
g) La fonction tourniquet ci-dessous implémente l’algorithme décrit dans l’exercice. Elle prend en paramètre une liste d’objets Processus donnés par ordre d’arrivée et un nombre entier positif correspondant au quantum. La fonction renvoie la liste des PID dans l’ordre de leur exécution par le processeur.
Compléter le code manquant de la fonction tourniquet.
def tourniquet(liste_attente, quantum):
ordre_execution = []
while liste_attente != []:
processus = liste_attente.pop(0)
processus.change_etat("En cours d'exécution")
processus.affiche_etat()
# compteur_tourniquet contient le nombre de cycle écoulé
compteur_tourniquet = 0
while ................ < ....... and not processus.est_termine():
ordre_execution.append(processus.pid)
# à chaque exécution d'un cycle, le compteur_tourniquet est incrémenté
processus.execute_un_cycle()
compteur_tourniquet = compteur_tourniquet + 1
# quantum écoulé et processus non terminé
if ..............................:
processus.change_etat("Suspendu")
processus.affiche_etat()
liste_attente.append(processus)
else:
processus.change_etat(................)
processus.affiche_etat()
return ordre_execution
h) tester le code avec un quantum de 1 et commenter le résultat
i) tester le code avec un quantum de 2 et commenter le résultat
Created with the Personal Edition of HelpNDoc: Easily create Web Help sites