Devoir 4 - Planificateur

Le but de ce thème 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émentation d'algorithmes de planification
• Comprendre le système de processus

1. Le code source doit être mis en retrait (-0.1p)
2. Le thème doit contenir un fichier Lisez-moi expliquant comment vous avez créé le thème (-0.1p)
3. Le thème ne vous oblige pas à avoir des fuites de mémoire (-0.5p)
4. Vous êtes autorisé à utiliser uniquement le langage C
5. Un thème qui passe tous les tests automatisés obtiendra 10 points sur 10 (s'il ne triche pas en utilisant l'API interdite, dans ce cas, il ne sera pas en pointillé).

Le thème est résolu individuellement. Toute tentative de copie entraînera 0p pour ce thème. 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:

sde_scheduler 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 Executable). Ceci est un ensemble d'instructions sur lesquelles chaque processus les exécutera dans l'ordre. Les instructions sont de deux types:

• Traitement
• Appel système

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:

• Sommeil
• Fourchette
• Sortie

Le processus informera le planificateur qu'il souhaite dormir plusieurs fois. Jusqu'à ce que cet intervalle soit surmonté, le processus ne peut pas être planifié à 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 non ensuite, envisagez le processus pour une planification ultérieure.

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

Le simulateur de processus présente les caractéristiques suivantes:

// Démarre un nouveau processus et alloue un PCB en utilisant le nom de fichier spécifié.
// si le nom de fichier est NULL, il alloue un processus EMPTY
struct sde_pcb * sde_process_start (int pid, const char *filename);
 
// Exécute le processus avec la carte électronique spécifiée et le prévient après les intervalles de traitement // quantum // ou pour un appel système.
int sde_process_run (int quantum, int pid, struct sde_pcb *pcb);
 
// Termine le processus avec le pid spécifié et libère la carte.
void sde_process_end (int pid, struct sde_pcb *pcb);

Cette fonction crée un nouveau processus et lance le circuit imprimé du processeur. La fonction renvoie SDE_PROCESS_OK si le nouveau processus est créé avec succès ou une valeur négative sinon.

Le planificateur appelle cette fonction à la suite d'un appel système SDE_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. Il obtient les paramètres suivants:

• quantum : le temps dont dispose le processus pour s'exécuter
• pid : processus pid
• pcb : Process PCB

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

• SDE_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 et annule le processus PCB.

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

La structure dans laquelle le bloc de contrôle de processus est conservé est la suivante:

struct sde_pcb 
{
// traiter le fichier exécutable
FILE *f;
 
int status; // statut du processus (SDE_STATUS_READY, SDE_STATUS_RUNNING, SDE_STATUS_WAITING)
 
// les champs suivants sont remplis avec de nouvelles valeurs après chaque appel à sde_process_run
int quantum; // la quantité d'unités restantes du processus quantique
int units; // la quantité d'unités que le processus doit encore exécuter avant de lire une nouvelle instruction
int syscall; // le numéro du processus d'appel système demandé (si nécessaire)
int sleep; // nombre d'unités que le processus a demandé de mettre en veille
char * extra; // Informations supplémentaires pour les appels système (fork: le nom de fichier du fichier exécutable du nouveau processus) doit être désalloué après utilisation
 
// ajoute vos éléments supplémentaires ici, par exemple des pointeurs vers les structures suivante et précédente (si vous utilisez des listes)
};

Cette structure est utilisée pour communiquer avec le simulateur de processus. Pour chaque processus, le simulateur alloue une structure de PCB. Chaque fois que vous exécutez un processus, vous devez l'envoyer à la structure de PCB de simulation du processus que vous souhaitez exécuter.

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

À chaque processus en orbite, les champs de la carte électronique seront stables comme suit:

• pcb→ quantum partie du quantum de temps inutilisé (par exemple, le processus a exécuté un appel système avant l'expiration du quantum)
• pcb→ unités 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)

pcb→ sleep (uniquement pour SDE_PROCESS_SYSCALL et pcb→ suscall SDE_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) * pcb→ extra (uniquement pour SDE_PROCESS_SYSCALL et pcb→ suscall SDE_PROCESS_SYSCALL_FORK ) nom du fichier à partir duquel l'exécutable sera chargé pour le nouveau processus pcb→ syscall (SDE_PROCESS_SYSCALL uniquement) sera défini sur l'une des valeurs suivantes: SDE_PROCESS_SYSCALL_SLEEP , SDE_PROCESS_SYSCALL_FORK ou SDE_PROCESS_SYSCALL_EXIT>

Le processus vide, appelé processus vide , est destiné à exécuter l'instruction hlt (arrêt) s'il ne le fait pas. il n'y a pas d'autre processus à planifier. 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:

• heure virtuelle
• la variable 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 vmchecker. Connectez-vous au site utilisateur de moodle, sélectionnez Systemes d'Explotation (FILS) et téléchargez archive de thèmes.

Le fichier lisez-moi a le format suivant:

Votre nom entier
Groupe

Description de la résolution du problème, pourquoi vous avez choisi des solutions, etc.

Pour charger le thème, suivez les étapes suivantes:

1. Créez une archive zip (pas rare, aiguilles, 7zip ou autre format) contenant:
   • tous les fichiers d'en-tête (* .h)
   • tous les fichiers sources (* .c)
   • Fichier Makefile (déjà fait dans le template de thème)
   • Fichier Lisez-moi
2. connectez-vous sur vmchecker
3. sélectionnez le cours Systemes d'Explotation (FILS)
4. sélectionnez 4. Planificateur
5. télécharger l'archive

Après avoir chargé l'archive, vmchecker s'exécutera:

unzip archive.zip homework
cd homework
make build
make run