Le but de ce devoir est de créer un planificateur de processus. Il doit utiliser trois algorithmes de planification:
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.
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.
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 .
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.
Implémentez un planificateur de processus qui contrôlera leur exécution dans l'espace utilisateur. Il simulera un planificateur de processus préemptif, dans un système monoprocesseur, qui utilise un algorithme de planification Round Robin, Round Robin avec des priorités et CFS.
Pour chaque planificateur, vous devez implémenter le trait Scheduler
.
Cela signifie mettre en œuvre les trois fonctions:
next
- le prochain processus à exécuterstop
- recevoir des informations sur la raison pour laquelle le processus s'est arrêtélist
- retourner l'état des processus
Pour cela, vous pouvez créer des fichiers séparés pour chaque planificateur et exportez-le dans scheduler/src/schedulers/mod.rs
.
Scheduler
pour les 3 algorithmes de planification et rien d'autre. Les autres informations présentées ci-dessous sont des détails de mise en œuvre du modèle existant, afin que vous compreniez mieux le fonctionnement du planificateur
Dans un système réel, pour le contrôle d'exécution, le comptage du temps d'exécution d'un processus est effectué à chaque interruption d'horloge.
Pour faciliter la mise en œuvre, le modèle de thème simulera un système réel comme celui-ci :
Cette bibliothèque fournit les traits et les structures nécessaires à la mise en œuvre d'un planificateur de processus.
Cette énumération contient les états possibles d'un processus pour notre simulation:
Cette énumération contient l'action que le planificateur demande au système d'exploitation de prendre. Il représente également la valeur renvoyée par la fonction Scheduler::next
que vous devez implementer:
Cette énumération contient la raison pour laquelle un processus s'est arrêté et le système d'exploitation a appelé le planificateur:
Cette énumération contient les appelles système que les processus effectuent vers le planificateur:
ProcessState::Waiting
jusqu'à ce qu'un autre processus émette un appel système Syscall::Signal
avec ce numéro d'événement.ProcessState::Ready
.Cette énumération contient le résultat renvoyé par un appel système:
Cette bibliothèque est utilisée pour simuler le planificateur à partir de la crate scheduler.
Contient les informations suivantes sur un processus:
Le simulateur utilise les fonctions suivantes:
Syscall::Fork
Syscall::Wait
Syscall::Signal
Syscall::Sleep
scheduler/src/lib.rs
pour chaque algorithme.
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.
Cet algorithme est identique au précédent, avec la modification suivante: la priorité initiale du processus est celle qu'il reçoit à la fork. Cette priorité ne peut jamais être surmontée. 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.
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:
virtualruntime
(la valeur est en fait quantum_temps - process.quantum).