Differences
This shows you the differences between two versions of the page.
|
sde2:teme:tema_fr_3_rust_2023 [2023/04/22 15:07] alexandru.radovici |
sde2:teme:tema_fr_3_rust_2023 [2023/04/23 12:01] (current) cristiana.andrei [Algorithmes de planification] |
||
|---|---|---|---|
| Line 10: | Line 10: | ||
| <note important> | <note important> | ||
| - | Date limite: ** Le 25 avril, 23h55 ** \\ | + | Date limite: ** Le 15 mai, 23h59 ** \\ |
| Note: ** 2 points ** de la note \\ | Note: ** 2 points ** de la note \\ | ||
| - | Téléchargement du devoir: [[https://classroom.github.com/a/m5-_C3XT| Github]] \\ | + | Lien: [[https://classroom.github.com/a/pT49MSxZ| Devoir 3]] \\ |
| + | Télécharger en retard: **1 point / jour** (maximum 4 jours) | ||
| </note> | </note> | ||
| Line 49: | Line 50: | ||
| 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. | 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''. | + | Pour chaque planificateur, vous devez **implémenter** le trait ''Scheduler''. |
| Cela signifie mettre en œuvre les trois fonctions: | Cela signifie mettre en œuvre les trois fonctions: | ||
| * ''next'' - le prochain processus à exécuter | * ''next'' - le prochain processus à exécuter | ||
| * ''stop'' - recevoir des informations sur la raison pour laquelle le processus s'est arrêté | * ''stop'' - recevoir des informations sur la raison pour laquelle le processus s'est arrêté | ||
| * ''list'' - retourner l'état des processus | * ''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''. | ||
| + | <note important> | ||
| + | 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 | ||
| + | </note> | ||
| + | |||
| + | ==== 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 | ||
| + | |||
| + | {{sde2:teme:process_states.png?500|}} | ||
| + | |||
| + | === 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 | ||
| + | <note important> | ||
| + | Le premier appel de fonction dans le planificateur doit être un **fork**, afin de créer le premier processus, sinon nous aurons une erreur. | ||
| + | </note> | ||
| ===== Algorithmes de planification ===== | ===== Algorithmes de planification ===== | ||
| + | <note> | ||
| + | Pour plus de détails sur la mise en œuvre, veuillez consulter les commentaires du fichier ''scheduler/src/lib.rs '' pour chaque algorithme. | ||
| + | </note> | ||
| === Round Robin === | === Round Robin === | ||
| Line 68: | Line 144: | ||
| === Round Robin avec des priorités === | === Round Robin avec des priorités === | ||
| - | Cet algorithme est identique au précédent, avec la modification suivante: tous les processus commencent par la priorité 5. | + | 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. | 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. | ||
| - | |||
| - | <note> | ||
| - | Dépasser le quantum de temps suppose qu'apres l'exécution du processus, ''process.units'' est différent de 0. | ||
| - | </note> | ||
| La priorité ne peut être inférieure à 0 ni supérieure à 5. | La priorité ne peut être inférieure à 0 ni supérieure à 5. | ||
| Line 89: | Line 161: | ||
| 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). | 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). | ||
| </note> | </note> | ||
| + | |||
| + | ===== Documents d'aide ===== | ||
| + | * [[:sde2:cursuri:05]] | ||
