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)

En résolvant le devoir, vous partirez du squelette que vous trouverez sur github.

• 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 êtes autorisé à utiliser uniquement le langage Python
3. Un devoir qui passe tous les tests automatisés obtiendra 10 points sur 10 (s'il ne triche pas en utilisant l'API interdit, dans ce cas, il ne sera pas en noté).
4. Un devoir implémenté uniquement pour réussir les tests sera pénalisé.

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 .

L'exécution se fera avec les paramètres suivants:

python3 main.py algorithm quantum first_process 

• algorithme : rr, rrp ou cfs
• quantum : quantum de temps
• first_process : le fichier exécutable du premier 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 Exécutable). Ceci est un ensemble d'instructions que chaque processus les exécutera en ordre. Les instructions sont de deux types:

• Traitement (p - process)
• Appel système (f - fork, s - sleep ou exit)

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

p 5

signifie que ce processus nécessitera 5 intervalles de traitement.

Chaque processus dispose de trois appels système disponibles:

• Sleep
• Fork
• Exit

Le processus informera le planificateur qu'il souhaite dormir pour plusieurs intervalles de temps. Jusqu'à ce que cet intervalle soit dépassé, le processus ne peut pas être planifié de nouveau.

s 3

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.

f fisier.pse

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 ne plus prendre en considération le processus pour des planifications ultérieures.

L'appel système est exécuté lorsque le processus atteint la fin du fichier exécutable.

Le simulateur de processus (process.py) expose la classe Process qui a les méthodes suivantes:

# Constructeur: crée un nouveau processus
__init__ (pid, filename)
 
# Exécute le processus pour lequel la méthode est appelée et le devance apres //quantum// intervalles de traitement ou pour un appel de systeme
run (quantum)
 
# Termine l'exécution du processus. C'est a vous d'annuler toutes les références a ce processus (en main.py)
end ()

Le constructeur crée un nouveau processus.

Le planificateur appelle cette fonction à la suite d'un appel système PROCESS_SYSCALL_FORK.

Si le nouveau processus ne peut pas être créé, le planificateur affichera une erreur.

Cette fonction simule l'exécution d'un processus. Elle obtient les paramètres suivants:

• quantum : le temps dont dispose le processus pour s'exécuter

A la sortie, la fonction retourne l'une des valeurs suivantes: * PROCESS_PREEMPTED : le processus a été exécuté avec succès et a été préempté en raison de l'expiration du quantum

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

Cette fonction arrête un processus.

Le planificateur appelle cette fonction à la suite d'un appel système PROCESS_SYSCALL_EXIT.

La classe Process contient les définitions des constantes déclarées sous la forme des variables statiques, ainsi que les suivante propriétés de l'instance

1. file - le fichier exécutable
2. pid - process id
3. quantum - les unités restantes le la quante du processus
4. units - les unités que le processus doit encore exécuter avant de lire une nouvelle instruction
5. syscall - le numéro du processus d'appel système demandé (si nécessaire)
6. sleep - nombre d'unités que le processus a demandé de mettre en veille
7. extra - Informations supplémentaires pour les appels système (fork: le nom de fichier du fichier exécutable du nouveau processus)

Cette structure simule la structure PCB utilisée par un système d'exploitation réel.

À chaque arret d'un processus, les champs seront définis comme suit:

• process.quantum partie du quantum de temps non-utilisé (par exemple, le processus a exécuté un appel système avant l'expiration du quantum)
• process.units 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)
• process.sleep (uniquement pour PROCESS_SYSCALL et process.syscall 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)
• process.extra (uniquement pour PROCESS_SYSCALL et process.syscall PROCESS_SYSCALL_FORK ) nom du fichier à partir duquel l'exécutable sera chargé pour le nouveau processus
• process.syscall (PROCESS_SYSCALL uniquement) sera défini sur l'une des valeurs suivantes: PROCESS_SYSCALL_SLEEP , PROCESS_SYSCALL_FORK ou PROCESS_SYSCALL_EXIT

p 5
s 3

Le processus vide, appelé scheduler , est destiné à exécuter l'instruction hlt (arrêt) au cas ou il n'y a pas un autre processus planifié.Ce type de processus existe et arrête le processeur pour une courte période. Dans cette simulation, le processus exécutera les instructions:

p 1
s 1

L'attribution du PID est effectuée à l'aide de l'algorithme suivant:

1. le processus du processeur (celui à planifier s'il n'y a pas d'autre option) a le PID 0
2. utilisez toujours le premier PID non utilisé
3. 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:

1. le premier processus a PID 1
2. deuxième PID 2
3. le premier processus s'arrête (le PID 1 devient libre)
4. le troisième processus aura PID 3
5. le quatrième processus aura PID 4
6. le cinquième processus aura le PID 5
7. le quatrième processus s'arrête
8. Traiter 5 arrêts
9. le sixième processus aura PID 1 (premier libre)
10. le septième processus aura le PID 4 (c'est le premier en ordre libre)
11. le prochain processus aura PID 5

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.

Le thème se chargera sur github.