Téléchargement CPU Scheduler - Téléchargement du code source CPU Scheduler Téléchargement

CPU Scheduler

Autre code source

1.0.0

Télécharger

Processeur

Simulation des algorithmes de planification du système d'exploitation pour les processus, par exemple, planification prioritaire, planification multi-niveaux, ...

@ ASCK-Team

Commencer

Ce référentiel exposé ici est en fait un projet universitaire du operating system du cours

Et implémenté avec la langue Java .

Documentation

L'affichage de hiérarchie des classes est démontré ici:

---- cpuscheduler

----------- |

----------- SRC

------------------ |

------------------ Processus // Données de chaque processus, par exemple, heure de début, heure d'éclatement, ...

------------------ CPU // CPU pour la simulation du calendrier

------------------ Scheduler // Classe abstraite pour les méthodes et champs primitifs

------------------ SCH_FCFS // First Come First Serve Scheduler

------------------ SCH_SJF // Le plus court emploi du travail (peut être préemptif)

------------------ SCH_PRIORITY // PRINCIPALER PRIORITÉ (peut être préemptif)

------------------ SCH_RR // Round Robin Scheduler

------------------ sch_lottery // planificateur de loterie

------------------ SCH_MULTILEVEL // Planificateur multi-niveaux (peut être préemptif)

------------------ FXMLDocumentController // Contrôleur pour l'interface graphique principale

------------------ SIMULATION Controller // Contrôleur pour GUI de simulation

---- /

Processus: Soit un processus exécute ou attend ces 2 états sont gérés:
- Exécution (Double TimeNow): consommer l'heure d'éclatement et vérifier si le processus est arrivé ou terminé.
- en attente (double minewow): Ajouter au temps d'attente
CPU:
- Tout d'abord, le processus obtient l'initialisation et ajouté à AllProc et ProCqueue ArrayList
- Ensuite, dans Simuler () CPU vérifie si un processus s'il est arrivé ou non, ajoutez-le à Readyquee
- Ensuite, dépendre du programme PROFICATE
- Puis le processeur actualise sa procqueUe et sa préparation pour éliminer les processus finis
- Enfin CPU Enregistrez le rapport pour GUI de simulation et réinitialisez toutes les données du planificateur
Planificateur:
- dépendre de la méthode du planificateur Retour suivant le processus pour aller sur CPU
- Sch_fcfs: file d'attente prioritaire à l'heure d'arrivée
- SCH_SJF: File d'attente prioritaire à l'heure d'échape si le préemptif est vrai, vérifiez toujours un temps de rafale plus court dans la file d'attente
- Sch_priority: la file d'attente prioritaire en priorité si le préemptif est vrai, vérifiez toujours un temps de rafale plus court dans la file d'attente
- Sch_rr: file d'attente prioritaire à l'heure d'arrivée et avoir une liste RR supplémentaire pour basculer entre les processus arrivés dans l'intervalle de temps quantique
- Sch_lottery: liste aléatoire des processus
- SCH_MULTILEVEL: Liste des niveaux de planificateur Retour Le processus suivant dépend de la méthode du planificateur de premier niveau non vide si la préemptive est vraie vérifiez toujours les niveaux non vides d'abord

Notes

Notez que l'unité de temps de simulation est de 0,1, donc le temps d'éclatement ou le temps de retard doit être multiple de 0,1

Notez que l'ordre de chaque ligne spécifie l'arrivée de l'ordre de processus

Notez que le format d'entrée est comme celui-ci pour chaque ligne (temps de rafale, temps de retard, priorité, niveau)

Temps de rafale: la durée pour laquelle un processus contrôle le CPU.
Temps de retard: La durée pour laquelle un processus prend à venir après le processus précédent par exemple: le premier temps de procédé est de 1, il arrivera donc au temps 1 et le deuxième temps de procédure est de 3, donc il arrivera au temps 4.
Priorité: priorité d'un processus (pour la priorité et le planificateur de loterie mais il ne peut pas être omis de la contribution)
Niveau: Niveau d'un processus (pour le planificateur multi-niveaux mais il ne peut pas être omis de l'entrée)

Notez que la durée minimale du commutateur de contexte dans cette simulation est de 0,4

Notez que la durée minimale de quantum pour le planificateur de Round Robbin dans cette simulation est de 0,2 car l'unité temporelle est de 0,1 et quantum ne peut pas être inférieure à l'unité de temps