Devoir 3 - 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 15 mai, 23h59
Note: 2 points de la note
Lien: Devoir 3
Télécharger en retard: 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 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.

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

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.

Vous devez implémenter le trait 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

Temps d'exécution

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

Crate scheduler

Cette bibliothèque fournit les traits et les structures nécessaires à la mise en œuvre d'un planificateur de processus.

enum ProcessState

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

enum SchedulingDecision

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.

enum StopReason

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é

enum Syscall

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.

enum SyscallResult

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

Processor library

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

ProcessInfo struct

Contient les informations suivantes sur un processus:

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

Simulateur de processeur

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

Le premier appel de fonction dans le planificateur doit être un fork, afin de créer le premier processus, sinon nous aurons une erreur.

Algorithmes de planification

Pour plus de détails sur la mise en œuvre, veuillez consulter les commentaires du fichier scheduler/src/lib.rs pour chaque algorithme.

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

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

Documents d'aide

sde2/teme/tema_fr_3_rust_2023.txt · Last modified: 2023/04/23 12:01 by cristiana.andrei
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