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)

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

1. Le devoir doit contenir un fichier Readme expliquant comment vous avez créé le devoir (-0.1p)
2. Vous pouvez utiliser seulement les fonctions de lea biblioteques std.
3. Un devoir qui passe tous les tests automatisés obtiendra 10 sur 10 si vouz ne trichez pas en utilisant un API interdit.

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écuter
• stop - 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.

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 :

• Le système simulé utilisera un temps virtuel (logique) indépendant du temps réel pour compter le temps de fonctionnement sur le processeur.
• Vous considérerez qu'une instruction dure une seule période d'horloge (unité de temps logique).
• Chacune des fonctions présentées ci-dessus représente une seule instruction exécutable par un processus à un instant donné.

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:

• Ready - Le processus attend d'être planifié
• Running - Le processus est planifié
• Waiting - Attend après un événement ou une opération d'E/S

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:

• Run {pid, timeslice} - Exécutez le processus avec PID pid pour un maximum d'unités de temps de tranche de temps
• Sleep(time_units) - Dormez le nombre d'unités de temps spécifiées
• Deadlock - Le système d'exploitation ne peut plus continuer, car tous les processus attendent des événements. Dans ce cas, aucun autre processus ne peut envoyer d'événements, ce qui signifie que tous les processus attendront indéfiniment.
• Panic - Le processus avec le PID 1 s'est arrêté.
• Done - Il n'y a plus de processus à planifier.

Cette énumération contient la raison pour laquelle un processus s'est arrêté et le système d'exploitation a appelé le planificateur:

• Syscall {syscall, remaining} - Le processus a envoyé un appel système de type Syscall; remaining represent le nombre d'unités de temps que le processus n'a pas utilisé à partir de ses quanta
• Expired - La tranche de temps allouée au processus a expiré et le processus a été préempté

Cette énumération contient les appelles système que les processus effectuent vers le planificateur:

• Fork(process_priority) - Créez un nouveau processus et renvoyez son PID.
• Sleep(amount_of_time) - Demander au planificateur de suspendre le processus pendant un certain temps
• Wait(event_number) - Le processus sera placé dans ProcessState::Waiting jusqu'à ce qu'un autre processus émette un appel système Syscall::Signal avec ce numéro d'événement.
• Signal(event_number) - Tous les processus qui attendent cet événement seront réveillés et placés dans l'état ProcessState::Ready.
• Exit - Demandez au planificateur de terminer le processus. Le processus ne sera plus jamais planifié et sera supprimé de la liste des processus dont le planificateur assure le suivi.

Cette énumération contient le résultat renvoyé par un appel système:

• Pid(pid) - Le PID du nouveau processus. Renvoyé après un appel système Syscall::Fork.
• Success - L'appel système a réussi.
• NoRunningProcess - L'appel système a été émis alors qu'aucun processus n'était planifié.

Cette bibliothèque est utilisée pour simuler le planificateur à partir de la crate scheduler.

Contient les informations suivantes sur un processus:

• Pid
• State
• Timings - temps total, temps d'appel système, running time

Le simulateur utilise les fonctions suivantes:

• fork - Envoie un appel système Syscall::Fork
• exec - Exécuter une unité de temps.
• wait - Envoie un appel système Syscall::Wait
• signal - Envoie un appel système Syscall::Signal
• sleep - Envoie un appel système Syscall::Sleep
• exit - Arrête le processus; le processus informe le système d'exploitation qu'il a terminé son exécution

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:

• 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.

• Cours 5 - Planification