Differences
This shows you the differences between two versions of the page.
|
sde:teme:tema_fr_4 [2020/04/26 13:04] diana.ghindaoanu [Algorithmes de planification] |
— (current) | ||
|---|---|---|---|
| Line 1: | Line 1: | ||
| - | ====== 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 ===== | ||
| - | |||
| - | <note important> | ||
| - | Date limite: ** Le 29 avril, 23h55 ** \\ | ||
| - | Note: ** 2 points ** de la note \\ | ||
| - | Téléchargement du devoir: [[https://vmchecker.cs.pub.ro | vmchecker.cs.pub.ro]] \\ | ||
| - | Charge différée: ** 0,1 point / jour ** (maximum 4 jours) \\ | ||
| - | </note> | ||
| - | |||
| - | ===== Connaissances évaluées ===== | ||
| - | |||
| - | * Comprendre le fonctionnement du planificateur | ||
| - | * Implémenter des algorithmes de planification | ||
| - | * Comprendre le système de processus | ||
| - | |||
| - | ===== Règles ===== | ||
| - | |||
| - | - Le devoir doit contenir un fichier Readme expliquant comment vous avez créé le devoir (-0.1p) | ||
| - | - Vous êtes autorisé à utiliser uniquement le langage Python | ||
| - | - 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é). | ||
| - | - 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 [[https://github.com/upb-fils/sde.git|repository]] avec le titre du formulaire // [scheduler] < le titre de votre question> //. Vous avez besoin d'un compte github pour | ||
| - | écrire des questions. | ||
| - | |||
| - | <note warning> | ||
| - | ** 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. | ||
| - | </note> | ||
| - | |||
| - | Si vous souhaitez recevoir un courrier électronique lorsque de nouvelles questions sont posées ou que des réponses sont fournies, accédez à github [[https://github.com/upb-fils/sde|repository]] et cliquez sur // Regarder //. | ||
| - | |||
| - | ===== Planificateur ===== | ||
| - | L'exécution se fera avec les paramètres suivants: | ||
| - | |||
| - | <code bash> | ||
| - | python3 main.py algorithm quantum first_process | ||
| - | </code> | ||
| - | |||
| - | * // 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 | ||
| - | <code> | ||
| - | p 5 | ||
| - | </code> | ||
| - | 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. | ||
| - | |||
| - | <code> | ||
| - | s 3 | ||
| - | </code> | ||
| - | |||
| - | == 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. | ||
| - | |||
| - | <code> | ||
| - | f fisier.pse | ||
| - | </code> | ||
| - | |||
| - | <note info> | ||
| - | 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. | ||
| - | </note> | ||
| - | |||
| - | == 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: | ||
| - | |||
| - | <code python> | ||
| - | # 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 () | ||
| - | </code> | ||
| - | |||
| - | === __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. | ||
| - | |||
| - | <note> | ||
| - | |||
| - | 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). | ||
| - | </note> | ||
| - | |||
| - | === 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 | ||
| - | - file - le fichier exécutable | ||
| - | - pid - process id | ||
| - | - quantum - les unités restantes le la quante du processus | ||
| - | - units - les unités que le processus doit encore exécuter avant de lire une nouvelle instruction | ||
| - | - syscall - le numéro du processus d'appel système demandé (si nécessaire) | ||
| - | - sleep - nombre d'unités que le processus a demandé de mettre en veille | ||
| - | - 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// | ||
| - | |||
| - | |||
| - | <note> | ||
| - | Par exemple, on a le suivant processus | ||
| - | <code bash> | ||
| - | p 5 | ||
| - | s 3 | ||
| - | </code> | ||
| - | |||
| - | Le processus sera exécuté avec un quantum de temps de 3 unités. | ||
| - | |||
| - | Apres la premiere exécution de status = process.run (3): | ||
| - | |||
| - | - ''status'' aura la valeur //Process.PROCESS_PREEMPTED// | ||
| - | - ''process.quantum'' sera 0, car le processus est resté sans d'unités du quantum de temps | ||
| - | - ''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): | ||
| - | - ''status'' aura la valeur //Process.PROCESS_SYSCALL// | ||
| - | - ''process.syscall'' aura la valeur //Process.PROCESS_SYSCALL_SLEEP// | ||
| - | - ''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 | ||
| - | - ''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. | ||
| - | </note> | ||
| - | |||
| - | === 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: | ||
| - | <code> | ||
| - | p 1 | ||
| - | s 1 | ||
| - | </code> | ||
| - | |||
| - | <note> | ||
| - | Le processus vide aura toujours le pid 0. | ||
| - | </note> | ||
| - | |||
| - | <note info> | ||
| - | 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é. | ||
| - | </note> | ||
| - | |||
| - | ==== Allocation des PID ==== | ||
| - | L'attribution du PID est effectuée à l'aide de l'algorithme suivant: | ||
| - | - le processus du processeur (celui à planifier s'il n'y a pas d'autre option) a le PID 0 | ||
| - | - utilisez toujours le premier PID non utilisé | ||
| - | - 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: | ||
| - | - le premier processus a PID 1 | ||
| - | - deuxième PID 2 | ||
| - | - le premier processus s'arrête (le PID 1 devient libre) | ||
| - | - le troisième processus aura PID 3 | ||
| - | - le quatrième processus aura PID 4 | ||
| - | - le cinquième processus aura le PID 5 | ||
| - | - le quatrième processus s'arrête | ||
| - | - Traiter 5 arrêts | ||
| - | - le sixième processus aura PID 1 (premier libre) | ||
| - | - le septième processus aura le PID 4 (c'est le premier en ordre libre) | ||
| - | - 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. | ||
| - | |||
| - | <note> | ||
| - | Dépasser le quantum de temps suppose qu'apres l'exécution du processus, ''process.units'' est différent de 0. | ||
| - | </note> | ||
| - | |||
| - | 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 [[https://opensource.com/article/19/2/fair-scheduling-linux|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. | ||
| - | |||
| - | <note> | ||
| - | 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.units). | ||
| - | </note> | ||
| - | |||
| - | <note warning> | ||
| - | 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''. | ||
| - | </note> | ||
| - | |||
| - | ===== Soumettez le thème ===== | ||
| - | Le thème se chargera sur [[https://vmchecker.cs.pub.ro | vmchecker]]. Connectez-vous au site utilisateur de moodle, sélectionnez // Systemes d'Explotation (FILS) // et téléchargez [[# archive-theme | archive de thèmes]]. | ||
| - | |||
| - | ==== Readme ==== | ||
| - | Le fichier Readme a le format suivant: | ||
| - | |||
| - | <code> | ||
| - | Votre nom entier | ||
| - | Groupe | ||
| - | |||
| - | Description de la résolution du problème, pourquoi vous avez choisi des solutions, etc. | ||
| - | </code> | ||
| - | |||
| - | |||
| - | ==== Archive Archive ==== | ||
| - | Pour charger le thème, suivez les étapes suivantes: | ||
| - | |||
| - | - Créez une archive zip (pas rare, aiguilles, 7zip ou autre format) contenant: | ||
| - | * tous les fichiers Python (* .py) | ||
| - | * Fichier Readme | ||
| - | - connectez-vous sur [[https: //vmchecker.cs.pub.ro | vmchecker]] | ||
| - | - sélectionnez le cours // Systemes d'Explotation (FILS) // | ||
| - | - sélectionnez // 4. // Scheduler | ||
| - | - télécharger l'archive | ||
| - | |||
| - | |||
| - | <note> | ||
| - | 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. | ||
| - | </note> | ||
| - | |||
| - | Après avoir chargé l'archive, vmchecker s'exécutera: | ||
| - | |||
| - | <code bash> | ||
| - | unzip archive.zip homework | ||
| - | cd homework | ||
| - | make -f Makefile.check | ||
| - | </code> | ||
| - | |||
