Ordonnancement (Scheduling) Cours Système LI324 olivier.marin@lip6.fr

Ordonnancement du CPU Concepts de Base Critères d’Ordonnancement Algorithmes d’Ordonnancement Ordonnancement Multi-Processeur Ordonnancement Temps Réel Exemples d’OS Evaluation d’Algorithmes

Concepts de Base Programme = séquence d'instructions Tâche = [1] + données Processus = [2] + contexte d'exécution (PCB) Monoprogrammation Processus monopolise le processeur jusqu'à sa terminaison

Concepts de Base Cycle CPU–E/S Distribution cycles CPU Le déroulement d’un processus consiste en une suite de cycles [exécution CPU + attente d’E/S] Distribution cycles CPU Multiprogrammation => Utilisation CPU maximale

Multiprogrammation Mode batch Le processus actif rend la main : lorsqu'il se termine lorsqu'il se bloque en attente d'une E/S terminaison Elu élection création E/S Prêt Bloqué fin d'E/S

Multiprogrammation Temps partagé Le processus actif rend la main : lorsqu'il se termine lorsqu'il se bloque en attente d'une E/S lorsqu'il a épuisé son quantum de temps terminaison Elu élection création Prêt E/S fin quantum Bloqué fin d'E/S

} Ordonnanceur CPU Choisit parmi les processus prêts en mémoire -> alloue la CPU à l’un d’eux Déclenchement d'une décision d’ordonnancement 1. changement d’état : “bloqué” -> “prêt” 2. changement d’état : “élu” -> “prêt” 3. changement d’état : “élu” -> “bloqué” 4. terminaison d’un processus } préemptif

Dispatcheur Donne le contrôle de la CPU au processus élu Commutation de contexte Passage en mode utilisateur Relance à partir du PC Latence du Dispatcheur temps pris par le dispatcheur pour stopper un processus et en (re)lancer un autre

Critères d’Ordonnancement Utilisation maximale de la CPU Débit (Throughput) # de pcs qui terminent leur exécution par unité de tps Temps de rotation (Turnaround time) tps {lancement -> terminaison} du processus (attentes incluses) Temps d’attente tps d’un pcs dans la file d’attente des processus prêts Temps de réponse tps mis entre une requête émise et la première réponse

Critères d’Optimisation Utilisation maximale du CPU Débit maximum Temps de rotation minimal Temps d’attente minimal Temps de réponse minimal

Algorithmes d'ordonnancement Objectif Suivre les critères de manière optimale En particulier : guarantir l'équité (mais pas l'égalité !) éviter les famines Un grand nombre d'algorithmes eg. FIFO, SJF, RR, EDF, RMS, ... Choix du bon algo dépend de l'utilisation du système (nombre de tâches, types, ...)

Ordonnancement First Come, First Served (FCFS ou FIFO) Processus Tps CPU P1 24 P2 3 P3 3 Supposons l’ordre d'arrivée suivant : P1 , P2 , P3 Le diagramme de Gantt correspondant est : Temps d‘attente de P1 = 0; P2 = 24; P3 = 27 Temps d’attente moyen: (0 + 24 + 27)/3 = 17 P1 P2 P3 24 27 30

Ordonnancement FCFS (Cont.) Changeons l'ordre d'arrivée : P2 , P3 , P1 Le diagramme de Gantt sera alors : Temps d’attente de P1 = 6; P2 = 0; P3 = 3 Temps d’attente moyen: (6 + 0 + 3)/3 = 3 Meilleur résultat que le cas précédent Effet convoi processus courts derrière un processus long = arg ! P1 P3 P2 6 3 30

Ordonnancement Shortest Job First (SJF) Principe Associer à chq processus son prochain tps d’utilisation CPU Choisir le processus avec le temps le plus petit Deux schémas: Non préemptif Dès que le CPU est donné à un processus, ce dernier ne peut être interrompu avant la fin de son temps CPU Préemptif : Shortest-Remaining-Time-First (SRTF) Si un nouveau processus débarque avec un temps CPU plus petit que le reste du temps CPU du processus courant, on commute vers le nouveau processus. SJF est optimal Il guarantit un temps d'attente moyen minimal.

Exemple de SJF Non-Préemptif Processus Tps d’Arrivée Tps CPU P1 0.0 7 P2 2.0 4 P3 4.0 1 P4 5.0 4 SJF (non préemptif) Temps d’attente moyen = (0 + 6 + 3 + 7)/4 = 4 P1 P3 P2 7 3 16 P4 8 12

Exemple de SJF Préemptif Processus Tps d’Arrivée Tps CPU P1 0.0 7 P2 2.0 4 P3 4.0 1 P4 5.0 4 SJF (préemptif) Temps d’attente moyen = (9 + 1 + 0 +2)/4 = 3 P1 P3 P2 4 2 11 P4 5 7 16

Déterminer la Longueur du Prochain Temps CPU On peut se contenter d'estimer le temps à partir des temps d’exécution précédents, en utilisant une moyenne exponentielle tn actual length of nth CPU burst n+1 predicted value for the next burst  0 ≤  ≤ 1 n+1 =  tn + (1 - ) n

Prédiction de la Longueur du Prochain Temps CPU

Exemples d’une Moyenne Exponentielle  =0 n+1 = n Passé récent ne compte pas  =1 n+1 = tn Seul le dernier temps CPU compte L’expansion de la formule donne: n+1 =  tn+(1 - )  tn -1 + … +(1 -  )j  tn -1 + … +(1 -  )n=1 tn 0 Comme  et (1 - ) sont inférieurs ou égaux à 1, chaque terme successif a un poids plus petit que son prédécesseur

Ordonnancement avec Priorité Une priorité (nombre entier) est associée à chaque processus Le CPU est alloué au processus de plus grande priorité Préemptif Non préemptif SJF est un ordonnancement à priorité La priorité correspond au temps CPU suivant Problème  Famine Les processus de faible priorité peuvent ne jamais s’exécuter Solution  Vieillissement Avec le temps, incrémenter la priorité des processus en attente

Tourniquet/Round Robin (RR) Principe Chq processus se voit allouer le CPU pour un temps limité quantum : en général 10-100 millisecondes. Lorsque son quantum est écoulé, le processus est remis en fin de la file d’attente des processus prêts. Equité Si n processus sont dans la file d’attente des processus prêts et si le quantum est q, alors chaque processus reçoit 1/n du temps CPU en parties de q unités. Aucun processus n'attend plus de (n-1)q. Performance q large : FIFO q petit : se rapproche du temps de commutation  fort surcoût

Exemple de RR avec Q = 20 Processus Temps CPU P1 53 P2 17 P3 68 P4 24 Le diagramme de Gantt est : Typiquement, une moyenne de temps de rotation plus grande que SJF, mais un meilleur temps de réponse P1 P2 P3 P4 20 37 57 77 97 117 121 134 154 162

Quantum et Temps de Commutation de Contexte

File Multi-niveaux La file d’attente est partagée en files séparées: premier plan/foreground (interactif) arrière plan/background (batch) Chaque file a sa propre politique d’ordonnancement foreground – RR background – FCFS Un ordonnancement inter-files doit exister Ordonnancement à priorité fixe ie. servir tous les processus de la file FG puis ceux de la file BG => Possibilité de famine. Time slice chaque file obtient une partie du temps CPU qu’elle utilise pour ordonnancer ses processus en attente eg. 80% pour la file FG en RR et 20% pour la file BG en FCFS

Ordonnancement à Files Multi-niveaux

Ordonnancement avec Files Multi-niveaux à Retour Un processus peut changer de file Implémentation du vieillissement Un ordonnanceur de files multi-niveaux à retour est défini selon les paramètres suivants : Nombre de files Politique d’ordonnancement pour chaque file Méthode déterminant la promotion d’un processus vers une file d’attente plus prioritaire Méthode déterminant la destitution d’un processus dans une file moins prioritaire Méthode déterminant dans quelle file placer un nouveau processus

Exemple de File Multi-niveaux à Retour Trois files Q0 – quantum de 8 millisecondes Q1 – quantum de 16 millisecondes Q2 – FCFS Ordonnancement Un nouveau processus est placé dans Q0 au début A sa première exécution, il reçoit 8 millisecondes. S’il ne termine pas son exécution, il est déplacé dans Q1. Si un processus de la file Q1 est servi (16 msec) et ne se termine pas, il est déplacé dans Q2.

Files avec Multi-niveaux à Retour

Ordonnancement Multiprocesseur L’ordonnancement CPU est plus complexe Processeurs homogènes dans un multiprocesseur Partage de charge Multitraîtement asymétrique Un seul processeur accède aux structures de données systèmes, supprimant le besoin de partage de données

Ordonnancement Temps Réel Systèmes temps réel durs exigent la garantie qu’un processus soit terminé au bout d’un temps bien défini Systèmes temps réel souples exigent que les processus plus prioritaires soient traîtés avant ceux de moins haute priorité

Latence du Dispatcheur

Evaluation des Algorithmes Modèles déterministes prennent un échantillon définissent les performances pour cet échantillon Modèles de files d’attente Implémentation

Evaluation des Ordonnanceurs par Simulation

Ordonnancement Solaris 2

Ordonnancement Linux Deux algorithmes: temps partagé et temps réel Priorité basée sur des crédits Le processus avec le plus de crédits est choisi Crédit soustrait à l’occurrence de l’interruption horloge Quand crédit = 0, un autre processus est choisi Quand tous les processus ont un crédit = 0, on les recrédite Basé sur des facteurs de priorité et sur leur histoire Temps Réel Temps réel souple Posix.1b – deux classes FCFS and RR Le processus de priorité la plus haute s’exécute en premier