Devoir 4 - Planificateur

Le but de ce devoir est de créer un planificateur de processus. Il doit utiliser trois algorithmes de planification:

  • Round Robin
  • Round Robin avec des priorités
  • Complete Fair Scheduler (CFS)

Informations générales

Date limite: Le 29 avril, 23h55
Note: 2 points de la note
Téléchargement du devoir: vmchecker.cs.pub.ro
Charge différée: 0,1 point / jour (maximum 4 jours)

Connaissances évaluées

  • Comprendre le fonctionnement du planificateur
  • Implémenter des algorithmes de planification
  • Comprendre le système de processus

Règles

  1. Le devoir doit contenir un fichier Readme expliquant comment vous avez créé le devoir (-0.1p)
  2. Vous êtes autorisé à utiliser uniquement le langage Python
  3. Un devoir qui passe tous les tests automatisés obtiendra 10 points sur 10 (s'il ne triche pas en utilisant l'API interdit, dans ce cas, il ne sera pas en noté).
  4. Un devoir implémenté uniquement pour réussir les tests sera pénalisé pour ces tests.

Copier

Le thème est résolu individuellement. Toute tentative de copie entraînera 0p pour ce devoir. Nous utiliserons également des systèmes de détection de copie automatique. Si nous avons des doutes, nous vous poserons des questions supplémentaires sur le sujet.

Questions

Si vous avez des questions sur le sujet, veuillez écrire un problème dans le référentiel github repository avec le titre du formulaire [scheduler] < le titre de votre question> . Vous avez besoin d'un compte github pour écrire des questions.

NE PAS PUBLIER LA SOURCE DU CODE . Ce sera considéré comme une copie et sera pénalisé avec 0p sur le devoir pour vous.

Si vous souhaitez recevoir un courrier électronique lorsque de nouvelles questions sont posées ou que des réponses sont fournies, accédez à github repository et cliquez sur Regarder .

Planificateur

L'exécution se fera avec les paramètres suivants:

python3 main.py algorithm quantum first_process 
  • algorithme : rr, rrp ou cfs
  • quantum : quantum de temps
  • first_process : le fichier exécutable du premier processus

Processus

Le planificateur fait partie du système d'exploitation. Parce que l'écriture de code dans le système d'exploitation est difficile, un simulateur de processus a été déployé dans l'espace utilisateur.

Chaque processus est basé sur un fichier portant l’extension pse (Process Exécutable). Ceci est un ensemble d'instructions que chaque processus les exécutera en ordre. Les instructions sont de deux types:

  • Traitement (p - process)
  • Appel système (f - fork, s - sleep ou exit)

Instructions d'un processus

Traitement

L'instruction de traitement est représentée par un p suivi du nombre d'intervalles de temps dans lesquels le processus sera traité. Par exemple

p 5

signifie que ce processus nécessitera 5 intervalles de traitement.

Appels système

Chaque processus dispose de trois appels système disponibles:

  • Sleep
  • Fork
  • Exit
Sleep

Le processus informera le planificateur qu'il souhaite dormir pour plusieurs intervalles de temps. Jusqu'à ce que cet intervalle soit dépassé, le processus ne peut pas être planifié de nouveau.

s 3
Fork

Le processus informe le système d'exploitation qu'il souhaite créer un autre processus en utilisant un fichier en tant que fichier exécutable. Le planificateur créera un nouveau processus et en tiendra compte pour la planification.

Dans l'exemple ci-dessous, le processus veut exécuter un nouveau processus avec le fichier fisier.pse en tant que fichier exécutable.

f fisier.pse

L'appel système fork fonctionne différemment dans cette simulation par rapport à un système d'exploitation lui-même. Dans cette simulation, l'appel système créera un nouveau processus et chargera un nouveau fichier exécutable.

Exit

Le processus informe le système d'exploitation qu'il a terminé son exécution. Le planificateur doit libérer les ressources de processus et ne plus prendre en considération le processus pour des planifications ultérieures.

L'appel système est exécuté lorsque le processus atteint la fin du fichier exécutable.

Simulateur

Le simulateur de processus (process.py) expose la classe Process qui a les méthodes suivantes:

# Constructeur: crée un nouveau processus
__init__ (pid, filename)
 
# Exécute le processus pour lequel la méthode est appelée et le devance apres //quantum// intervalles de traitement ou pour un appel de systeme
run (quantum)
 
# Termine l'exécution du processus. C'est a vous d'annuler toutes les références a ce processus (en main.py)
end ()

__init__

Le constructeur crée un nouveau processus.

Le planificateur appelle cette fonction à la suite d'un appel système PROCESS_SYSCALL_FORK.

Si le nouveau processus ne peut pas être créé, le planificateur affichera une erreur.

run

Cette fonction simule l'exécution d'un processus. Elle obtient les paramètres suivants:

  • quantum : le temps dont dispose le processus pour s'exécuter

A la sortie, la fonction retourne l'une des valeurs suivantes: * PROCESS_PREEMPTED : le processus a été exécuté avec succès et a été préempté en raison de l'expiration du quantum

  • PROCESS_SYSCALL : le processus a été exécuté avec succès et a été arrêté en raison d'un appel système
  • une valeur négative: le processus a été exécuté avec une erreur

En cas d'erreur, le planificateur affichera une erreur et fermera le processus.

end

Cette fonction arrête un processus.

Le planificateur appelle cette fonction à la suite d'un appel système PROCESS_SYSCALL_EXIT.

Apres l'exécution d'un processus, on va soustraire de process.sleep de chaque processus de la queue de sleep le numéro d'unités de traitement exécutées par le processus (la valeur est en fait quantum_temps - process.units).

Classe Process

La classe Process contient les définitions des constantes déclarées sous la forme des variables statiques, ainsi que les suivante propriétés de l'instance

  1. file - le fichier exécutable
  2. pid - process id
  3. quantum - les unités restantes le la quante du processus
  4. units - les unités que le processus doit encore exécuter avant de lire une nouvelle instruction
  5. syscall - le numéro du processus d'appel système demandé (si nécessaire)
  6. sleep - nombre d'unités que le processus a demandé de mettre en veille
  7. extra - Informations supplémentaires pour les appels système (fork: le nom de fichier du fichier exécutable du nouveau processus)

Cette structure simule la structure PCB utilisée par un système d'exploitation réel.

À chaque arret d'un processus, les champs seront définis comme suit:

  • process.quantum partie du quantum de temps non-utilisé (par exemple, le processus a exécuté un appel système avant l'expiration du quantum)
  • process.units nombre d'intervalles que le processus doit encore exécuter à partir de l'instruction (le processus a été préempté en raison de l'expiration du délai quant à la durée et n'a pas exécuté l'instruction complète)
  • process.sleep (uniquement pour PROCESS_SYSCALL et process.syscall PROCESS_SYSCALL_SLEEP ) le nombre d'intervalles dans lesquels le processus sera mis en veille (le processus ne peut pas être planifié plus rapidement par ce nombre intervalles)
  • process.extra (uniquement pour PROCESS_SYSCALL et process.syscall PROCESS_SYSCALL_FORK ) nom du fichier à partir duquel l'exécutable sera chargé pour le nouveau processus
  • process.syscall (PROCESS_SYSCALL uniquement) sera défini sur l'une des valeurs suivantes: PROCESS_SYSCALL_SLEEP , PROCESS_SYSCALL_FORK ou PROCESS_SYSCALL_EXIT

Par exemple, on a le suivant processus

p 5
s 3

Le processus sera exécuté avec un quantum de temps de 3 unités.

Apres la premiere exécution de status = process.run (3):

  1. status aura la valeur Process.PROCESS_PREEMPTED
  2. process.quantum sera 0, car le processus est resté sans d'unités du quantum de temps
  3. process.units aura la valeur 2, car le processus doit exécuter encore 2 unités de temps pour achever son traitement (il avait initialement p 5)

Apres la deuxieme exécution de status = process.run (3):

  1. status aura la valeur Process.PROCESS_SYSCALL
  2. process.syscall aura la valeur Process.PROCESS_SYSCALL_SLEEP
  3. process.quantum aura la valeur 1, car le processus a exécuté 2 unités (restées de l'exécution précédente) et apres cela il a exécuté un appel de systeme
  4. process.units aura la valeur 0, car le processus n'a aucune unité de temps a exécuter.

Le processus pourra etre planifié de nouveau seulement quant les autres processus ont exécuté minimum 3 unités de temps (a cause de l'instruction s 3).

Vous pouvez ajouter ne nouveaux attributs dans la classe si vous en avez besoin, tels que le temps virtuel d'exécution pour l'algorithme CFS, priorités pour RRP, etc.

Processus scheduler

Le processus vide, appelé scheduler , est destiné à exécuter l'instruction hlt (arrêt) au cas ou il n'y a pas un autre processus planifié.Ce type de processus existe et arrête le processeur pour une courte période. Dans cette simulation, le processus exécutera les instructions:

p 1
s 1

Le processus vide aura toujours le pid 0.

Pour le processus vide, l’appel sleep n’est pas pris en compte, le processus sera planifié dès qu’il n’y aura pas d’autre processus qui peut être planifié.

Allocation des PID

L'attribution du PID est effectuée à l'aide de l'algorithme suivant:

  1. le processus du processeur (celui à planifier s'il n'y a pas d'autre option) a le PID 0
  2. utilisez toujours le premier PID non utilisé
  3. en cas de dépassement de MAX_PID (déclaré dans sde_schedule.h), il recommence à partir de 0 et recherche le premier PID libre

Par exemple, si MAX_PID est 5:

  1. le premier processus a PID 1
  2. deuxième PID 2
  3. le premier processus s'arrête (le PID 1 devient libre)
  4. le troisième processus aura PID 3
  5. le quatrième processus aura PID 4
  6. le cinquième processus aura le PID 5
  7. le quatrième processus s'arrête
  8. Traiter 5 arrêts
  9. le sixième processus aura PID 1 (premier libre)
  10. le septième processus aura le PID 4 (c'est le premier en ordre libre)
  11. le prochain processus aura PID 5

Algorithmes de planification

Round Robin

Pour cet algorithme, tous les processus ont la même priorité et sont planifiés les uns après les autres. Après qu'un processus a été planifié, il sera placé au bout de la queue.

Les nouveaux processus seront placés à la fin de la file d'attente.

Il gardera une file d'attente avec les processus en attente (veille). Ils seront mis dans la file d'attente dans l'ordre où ils ont dormi. Avant chaque planification, vous pouvez extraire de la file d'attente les processus pouvant être exécutés et ajoutés à la fin de la file d'attente.

Le processus qui vient d'être exécuté sera ajouté en dernier dans la file d'attente.

Round Robin avec des priorités

Cet algorithme est identique au précédent, avec la modification suivante: tous les processus commencent par la priorité 5. Chaque fois qu'un processus dépasse son temps, il est pénalisé de 1. À chaque fois le processus se termine avant de dépasser son quantum, il est récompensé par 1.

Dépasser le quantum de temps suppose qu'apres l'exécution du processus, process.units est différent de 0.

La priorité ne peut être inférieure à 0 ni supérieure à 5.

Lors de la planification, seuls les processus ayant la priorité la plus élevée sont pris en compte. Si aucun d'entre eux ne peut être planifié (sont en veille), envisagez des processus moins prioritaires. S'il n'y a ni l'un ni l'autre ici être planifié, tenir compte des éléments suivants, etc.

Completely Fair Scheduler

Cet algorithme est utilisé par Linux. Vous pouvez trouver plus de détails sur CFS: une planification de processus parfaitement juste sous Linux. La variante implémentée ici prendra en compte:

  • virtualtime
  • la quante de temps variable en fonction du nombre de processus, le temps réel est le temps initial divisé par le nombre de processus, le temps de référence ne peut être inférieur à 1.

Apres chaque exécution d'un processus on va ajouter le numéro d'unités de traitement exécutées par le processus a virtualruntime (la valeur est en fait quantum_temps - process.quantum).

Pour résoudre le deovir, vous allez utiliser le schéma implémenté dans les fichiers process.py et main.py ou la fonction print est applée. Au moment de la vérification du devoir, on va comparer le texte affiché par votre devoir a des fichiers de référence. A cette raison, on vous recommande de ne pas modifier/supprimer les appels de la fonction print.

Soumettez le thème

Le thème se chargera sur vmchecker. Connectez-vous au site utilisateur de moodle, sélectionnez Systemes d'Explotation (FILS) et téléchargez archive de thèmes.

Readme

Le fichier Readme a le format suivant:

Votre nom entier
Groupe

Description de la résolution du problème, pourquoi vous avez choisi des solutions, etc.

Archive Archive

Pour charger le thème, suivez les étapes suivantes:

  1. Créez une archive zip (pas rare, aiguilles, 7zip ou autre format) contenant:
    • tous les fichiers Python (* .py)
    • Fichier Readme
  2. connectez-vous sur vmchecker
  3. sélectionnez le cours Systemes d'Explotation (FILS)
  4. sélectionnez 4. Scheduler
  5. télécharger l'archive

L'archive doit contenir tous les fichiers (principaux) à la racine, pas dans les sous-répertoires. NE PAS archiver le répertoire du thème, archiver les fichiers DIRECT.

Après avoir chargé l'archive, vmchecker s'exécutera:

unzip archive.zip homework
cd homework
make -f Makefile.check
sde/teme/tema_fr_4.txt · Last modified: 2020/04/29 21:02 by alexandru.radovici
CC Attribution-Share Alike 3.0 Unported
www.chimeric.de Valid CSS Driven by DokuWiki do yourself a favour and use a real browser - get firefox!! Recent changes RSS feed Valid XHTML 1.0