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 et nix.
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.

Les fonctions suivantes devront être implémentées:

• for - Créer un nouveau processus
• exec - Simuler l'exécution d'une instruction
• wait - en attente d'un événement/d'une opération d'E/S

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

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.