Differences
This shows you the differences between two versions of the page.
|
sde:teme:tema_fr_4 [2019/04/13 22:27] alexandru.radovici |
— (current) | ||
|---|---|---|---|
| Line 1: | Line 1: | ||
| - | ====== Devoir 4 - Planificateur ====== | ||
| - | |||
| - | |||
| - | Le but de ce thème 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 28 avril, 23h55 ** \\ | ||
| - | Note: ** 2 points ** de la note \\ | ||
| - | Téléchargement du thème: [[https: //vmchecker.cs.pub.ro | vmchecker.cs.pub.ro]] \\ | ||
| - | Charge différée: ** 0,1 point / jour ** (maximum 4 jours) \\ | ||
| - | </note> | ||
| - | |||
| - | ===== Connaissances précieuses ===== | ||
| - | |||
| - | * Comprendre le fonctionnement du planificateur | ||
| - | * Implémentation d'algorithmes de planification | ||
| - | * Comprendre le système de processus | ||
| - | |||
| - | ===== Règles ===== | ||
| - | |||
| - | - Le code source doit être mis en retrait (-0.1p) | ||
| - | - Le thème doit contenir un fichier Lisez-moi expliquant comment vous avez créé le thème (-0.1p) | ||
| - | - Le thème ne vous oblige pas à avoir des fuites de mémoire (-0.5p) | ||
| - | - Vous êtes autorisé à utiliser uniquement le langage C | ||
| - | - Un thème qui passe tous les tests automatisés obtiendra 10 points sur 10 (s'il ne triche pas en utilisant l'API interdite, dans ce cas, il ne sera pas en pointillé). | ||
| - | |||
| - | |||
| - | ===== Copier ===== | ||
| - | |||
| - | Le thème est résolu individuellement. Toute tentative de copie entraînera ** 0p ** pour ce thème. 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 thème 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> | ||
| - | sde_scheduler 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 Executable). Ceci est un ensemble d'instructions sur lesquelles | ||
| - | chaque processus les exécutera dans l'ordre. Les instructions sont de deux types: | ||
| - | * Traitement | ||
| - | * Appel système | ||
| - | |||
| - | ==== 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: | ||
| - | |||
| - | * Sommeil | ||
| - | * Fourchette | ||
| - | * Sortie | ||
| - | |||
| - | == sommeil == | ||
| - | Le processus informera le planificateur qu'il souhaite dormir plusieurs fois. Jusqu'à ce que cet intervalle soit surmonté, | ||
| - | le processus ne peut pas être planifié à nouveau. | ||
| - | |||
| - | <code> | ||
| - | s 3 | ||
| - | </code> | ||
| - | |||
| - | == Fourchette == | ||
| - | 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> | ||
| - | |||
| - | == Quitter == | ||
| - | 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 non | ||
| - | ensuite, envisagez le processus pour une planification ultérieure. | ||
| - | |||
| - | L'appel système est exécuté lorsque le processus atteint la fin du fichier exécutable. | ||
| - | |||
| - | ==== Simulateur ==== | ||
| - | Le simulateur de processus présente les caractéristiques suivantes: | ||
| - | |||
| - | <code c> | ||
| - | // Démarre un nouveau processus et alloue un PCB en utilisant le nom de fichier spécifié. | ||
| - | // si le nom de fichier est NULL, il alloue un processus EMPTY | ||
| - | struct sde_pcb * sde_process_start (int pid, const char *filename); | ||
| - | |||
| - | // Exécute le processus avec la carte électronique spécifiée et le prévient après les intervalles de traitement // quantum // ou pour un appel système. | ||
| - | int sde_process_run (int quantum, int pid, struct sde_pcb *pcb); | ||
| - | |||
| - | // Termine le processus avec le pid spécifié et libère la carte. | ||
| - | void sde_process_end (int pid, struct sde_pcb *pcb); | ||
| - | </code> | ||
| - | |||
| - | === sde_process_start === | ||
| - | Cette fonction crée un nouveau processus et lance le circuit imprimé du processeur. La fonction renvoie SDE_PROCESS_OK si le nouveau processus | ||
| - | est créé avec succès ou une valeur négative sinon. | ||
| - | |||
| - | Le planificateur appelle cette fonction à la suite d'un appel système SDE_PROCESS_SYSCALL_FORK. | ||
| - | |||
| - | Si le nouveau processus ne peut pas être créé, le planificateur affichera une erreur. | ||
| - | |||
| - | === sde_process_run === | ||
| - | Cette fonction simule l'exécution d'un processus. Il obtient les paramètres suivants: | ||
| - | * // quantum //: le temps dont dispose le processus pour s'exécuter | ||
| - | * // pid //: processus pid | ||
| - | * // pcb //: Process PCB | ||
| - | |||
| - | A la sortie, la fonction retourne l'une des valeurs suivantes: | ||
| - | * // SDE_PROCESS_PREEMPTED //: le processus a été exécuté avec succès et a été préempté en raison de l'expiration du quantum | ||
| - | * // SDE_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. | ||
| - | |||
| - | |||
| - | === sde_process_end === | ||
| - | Cette fonction arrête un processus et annule le processus PCB. | ||
| - | |||
| - | Le planificateur appelle cette fonction à la suite d'un appel système SDE_PROCESS_SYSCALL_EXIT. | ||
| - | |||
| - | === Structure de la PCB === | ||
| - | La structure dans laquelle le bloc de contrôle de processus est conservé est la suivante: | ||
| - | <code c> | ||
| - | struct sde_pcb | ||
| - | { | ||
| - | // traiter le fichier exécutable | ||
| - | FILE *f; | ||
| - | |||
| - | int status; // statut du processus (SDE_STATUS_READY, SDE_STATUS_RUNNING, SDE_STATUS_WAITING) | ||
| - | |||
| - | // les champs suivants sont remplis avec de nouvelles valeurs après chaque appel à sde_process_run | ||
| - | int quantum; // la quantité d'unités restantes du processus quantique | ||
| - | int units; // la quantité d'unités que le processus doit encore exécuter avant de lire une nouvelle instruction | ||
| - | int syscall; // le numéro du processus d'appel système demandé (si nécessaire) | ||
| - | int sleep; // nombre d'unités que le processus a demandé de mettre en veille | ||
| - | char * extra; // Informations supplémentaires pour les appels système (fork: le nom de fichier du fichier exécutable du nouveau processus) doit être désalloué après utilisation | ||
| - | |||
| - | // ajoute vos éléments supplémentaires ici, par exemple des pointeurs vers les structures suivante et précédente (si vous utilisez des listes) | ||
| - | }; | ||
| - | </code> | ||
| - | |||
| - | Cette structure est utilisée pour communiquer avec le simulateur de processus. Pour chaque processus, le simulateur alloue une structure de PCB. | ||
| - | Chaque fois que vous exécutez un processus, vous devez l'envoyer à la structure de PCB de simulation du processus que vous souhaitez exécuter. | ||
| - | |||
| - | Cette structure simule la structure du circuit imprimé utilisée par un système d'exploitation réel. | ||
| - | |||
| - | À chaque processus en orbite, les champs de la carte électronique seront stables comme suit: | ||
| - | * // pcb-> quantum // partie du quantum de temps inutilisé (par exemple, le processus a exécuté un appel système avant l'expiration du quantum) | ||
| - | * // pcb-> unités // 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) | ||
| - | // // pcb-> sleep // (uniquement pour // SDE_PROCESS_SYSCALL // et pcb-> suscall // SDE_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) | ||
| - | * // pcb-> extra // (uniquement pour // SDE_PROCESS_SYSCALL // et pcb-> suscall // SDE_PROCESS_SYSCALL_FORK //) nom du fichier à partir duquel l'exécutable sera chargé pour le nouveau processus | ||
| - | // // pcb-> syscall // (SDE_PROCESS_SYSCALL // uniquement) sera défini sur l'une des valeurs suivantes: // SDE_PROCESS_SYSCALL_SLEEP //, // SDE_PROCESS_SYSCALL_FORK // ou // SDE_PROCESS_SYSCALL_EXIT> | ||
| - | |||
| - | |||
| - | <note> | ||
| - | Vous pouvez ajouter des éléments dans la structure si vous avez besoin, tels que des pointeurs vers la structure suivante et précédente (si vous utilisez des listes), | ||
| - | temps d'exécution virtuel pour l'algorithme CFS, etc. | ||
| - | </note> | ||
| - | |||
| - | === Processus vide === | ||
| - | Le processus vide, appelé // processus vide //, est destiné à exécuter l'instruction // hlt // (arrêt) s'il ne le fait pas. | ||
| - | il n'y a pas d'autre processus à planifier. 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 // veille // système 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. | ||
| - | |||
| - | 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. | ||
| - | |||
| - | === Planificateur complètement juste === | ||
| - | 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: | ||
| - | * heure virtuelle | ||
| - | * la variable 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. | ||
| - | |||
| - | ===== 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]]. | ||
| - | |||
| - | ==== Lisez-moi ==== | ||
| - | Le fichier lisez-moi 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 d'en-tête (* .h) | ||
| - | * tous les fichiers sources (* .c) | ||
| - | * Fichier Makefile (déjà fait dans le template de thème) | ||
| - | * Fichier Lisez-moi | ||
| - | - connectez-vous sur [[https: //vmchecker.cs.pub.ro | vmchecker]] | ||
| - | - sélectionnez le cours // Systemes d'Explotation (FILS) // | ||
| - | - sélectionnez // 4. // Planificateur | ||
| - | - 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. | ||
| - | |||
| - | NE PAS inclure les fichiers objets (* .o) et l'exécutable. (Astuce: utilisez // make clean // pour les supprimer avant d’archiver le thème) | ||
| - | </note> | ||
| - | |||
| - | Après avoir chargé l'archive, vmchecker s'exécutera: | ||
| - | |||
| - | <code bash> | ||
| - | unzip archive.zip homework | ||
| - | cd homework | ||
| - | make build | ||
| - | make run | ||
| - | </code> | ||
| - | |||
