Main 4

L’ordonnancement CPU
Ordonnancement des pthreads
Système d’exploitation
Module: M18 - IRISI S3
Pr. Abdessamad EL BOUSHAKI

abdessamad.elboushaki@gmail.com
FST Marrakech
Université Cadi Ayyad
Pr. Abdessamad EL BOUSHAKI (FST Marrakech) Système d’exploitation 1/62


Introduction à l’ordonnancement : Multiprogrammation

Contrairement au mono-programmation, un ordinateur multiprogrammé
(multitâche) possède forcément plusieurs processus en concurrence pour
l’obtention du temps processeur, cette situation se produit lorsque 2 ou
plusieurs processus sont en état prêt simultanément.
Mais le processeur ne peut, à un moment donné, exécuter qu’une instruction
(d’un programme) à la fois. Le processeur travaille donc en temps partagé.
Dans ce cas le système doit gérer plusieurs processus, et les exécuter dans
les meilleurs délais possibles en partageant le temps processeur.
Comment choisir le processus qui a accès au processeur ? Comment changer cet

accès au cours de l’exécution ?
L’ordonnancement : Définition
L’ordonnancement
L’ordonnancement (scheduling) est un ensemble de règles définissant
l’ordre d’exécution des processus en tenant compte de la disponibilité des
ressources nécessaires (processeurs), de manière à optimiser un ou plusieurs
critères.
On peut dire, également, que l’ordonnancement consiste à allouer une ou
plusieurs tranches de temps processeur à chaque processus existant dans le
système.
L’ordonnancement de processus s’articule autour de 2 composantes :
I La file d’attente des processus : elle regroupe les descripteurs des processus
prêts. C’est à partir de cette file que l’ordonnanceur choisit le processus à
exécuter.
I L’algorithme d’ordonnancement à appliquer : il organise les descripteurs de
processus dans un ordre qui reflète la stratégie appliquée.
Dans ce chapitre, on utilise le terme « processus » pour désigner un processus

lourd et/ou un processus léger (thread ).
Files d’attente de l’ordonnancement
Pour gérer les processus durant leur séjour, le système d’exploitation

maintient plusieurs files d’attente.
Ces files consistent en un ensemble de descripteurs de processus ou PCB
chaînés l’un à l’autre.
Le processus passe alors, durant sa vie, par les files suivantes :
I Files d’attente des processus prêts : peuvent être représentées par une ou
plusieurs files : une file par classe de processus (processus système, processus
temps réel, processus temps partagé) ou une file par priorité.
I Files d’attente des processus bloqués : peuvent être présentées par
plusieurs files : une file par événement, signal ou ressource attendu (file des
processus en attente de l’imprimante, file des processus en attente de fin
d’E/S sur le disque,...).

Un nouveau processus est initialement placé dans la file d’attente des

processus prêts. Il attend dans cette file jusqu’à ce qu’il soit sélectionné
pour son exécution et qu’on lui accorde le processeur.
Une fois qu’on a alloué le processeur au processus et que celui-ci est en cours
d’exécution, il pourrait se produire l’un des événements suivants :
I Le processus pourrait se terminer.
I Le processus pourrait consommer le temps qui a été alloué par le processeur
(système à temps partagé). Dans ce cas, le processus est remis dans la file
d’attente des processus prêts.
I Le processus pourrait attendre un évènement (signal) arrivant d’un autre
processus. Dans ce cas, il est placé dans une file d’attente du signal.
I Le processus pourrait émettre une requête d’E/S. Dans ce cas, il est placé
dans une file d’attente d’E/S.

Les différents états de transition du processus entre les files d’attente sont
résumés comme suit:

Différents niveaux de l’ordonnancement

Il existe trois niveaux de l’ordonnancement :
L’ordonnancement de haut niveau (Long-Term scheduling)
I Sélectionne le processus qui doit aller dans la fille de processus prêts.
I S’exécute moins fréquemment : peut être lent (seconds, minutes).
I Contrôle le degré de multiprogrammation (le nombre de processus dans la
mémoire).
I Il est important que le scheduleur à long terme réalise un bon mélange de
processus tributaires de la CPU et tributaires des E/S
L’ordonnancement de bas niveau (Short-Term scheduling)
I Il permet de déterminer parmi les processus prêts celui à être exécuté par le
processeur central.
I Appelé assez fréquemment : doit être TRÈS rapide.
I Il est sollicité plusieurs fois par seconde et doit constamment résider en
mémoire.
L’ordonnancement de niveau intermédiaire (Medium-Term scheduling)
I Il gère le déplacement des processus d’une file d’attente à une autre.

I Un processus peut être réintroduit dans la mémoire et son exécution peut
reprendre là ou elle s’était arrêtée (Ce schéma est appelé swapping)
L’ordonnanceur
L’ordonnanceur (planificateur, scheduler ou dispatcher) est un

programme du système d’exploitation qui s’occupe de choisir, selon une
politique d’ordonnancement donnée, un processus parmi les processus
prêts pour lui affecter le processeur.
Autrement dit, c’est le responsable de régler les états des processus et de
gérer les transitions entre ces états.
Il agit sur la file des processus prêts (Short-Term scheduling ) et l’organise en
appliquant un algorithme donné.
L’ordonnanceur est sollicité à la fin de l’exécution de chaque processus. Il
s’exécute lui-même et sélectionne un processus pour l’exécution.
Il faut souligner à ce stade que l’ordonnanceur ne change pas de politique
d’ordonnancement. Chaque système d’exploitation applique un algorithme
choisi par les concepteurs.

Objectifs d’un ordonnanceur
Les principaux objectifs assignés à un ordonnanceur sont:

Occuper au maximum le processeur,
S’assurer que chaque processus en attente d’exécution reçoive sa part de
temps processeur.
Minimiser le temps de réponse pour les utilisateurs en mode interactif,
Satisfaire le maximum de processus des utilisateurs en respectant certaines
contraintes telles que la priorité, l’échéance (dans les systèmes temps réel),
etc...

Critères de performance d’ordonnanceur
Les divers algorithmes d’ordonnancement du processeur possèdent des

propriétés différentes et peuvent favoriser une classe de processus plutôt
qu’une autre.
Pour choisir quel algorithme utiliser dans une situation particulière, nous
devons tenir compte des propriétés des divers algorithmes.
Plusieurs critères ont été proposés pour comparer et évaluer les
performances des algorithmes d’ordonnancement du processeur.

Les critères les plus souvent utilisés sont :

Débit (Throughput): nombre de processus qui terminent leur exécution par
unité de temps.
Temps de rotation (Turnaround time) : le temps depuis le lancement du
processus jusqu’à sa terminaison.
I C’est la somme du temps d’exécution (temps CPU consommé) et du temps
passé dans les différentes files (file des processus prêts, files des processus
bloqués).
I Soient te: le temps d’entrée du processus dans le système et ts: le temps de
sortie du processus.
Temps de rotation = ts − te
Temps d’attente (Waiting time) : est le temps passé à attendre dans les
différentes files d’attente (prêts et bloqués)
I Soient : tattCPU le temps d’attente dans les files prêts et tbloques le temps
d’attente dans les files bloqués.
Temps d 0 attente = tattCPU + tbloques


Les critères les plus souvent utilisés sont :
Temps de réponse (Response time) : est le temps passé dans la file
d’attente des processus prêts avant la première exécution.
I Soient : te le temps d’entrée (instant d’arrivé) à la file et tdex le temps de
début d’exécution.
Temps de reponse = tdex − te
Le taux d’utilisation du CPU (CPU utilization) : pourcentage de temps
où le CPU est occupé
I Doit être le plus élevé possible (100%) pour éviter les moments où le
processeur ne fait rien alors qu’il existe dans le système des processus qui
n’ont pas terminé leur travaux.
I Il est calculé comme suit:
Pn
i=1 tCPUi
Taux d 0 utilisation =
tsd − tep
I tCPUi : le temps CPU consommé par le processus i,
I tsd : temps d’entrée (instant d’arrivé) du premier processus,
I tep : temps sortie du dernier processus

Optimisation des critères d’ordonnancement
Plusieurs choix possibles pour l’optimisation de ces critères

I Optimisation de la valeur moyenne des critères
I Optimisation de la valeur minimale ou maximale
Cas particulier selon système, par exemple pour interactifs
I Il est souhaitable de maximiser l’utilisation de CPU et la capacité de
traitement (i.e. Débit) et de minimiser le temps de rotation, le temps
d’attente et le temps de réponse.
Critère Optimisation
Utilisation CPU Maximiser
Débit Maximiser
Temps de rotation Minimiser
Temps d’attente Minimiser
Temps de réponse Minimiser

Stratégies d’ordonnancement
On peut classer les politiques ou stratégies d’ordonnancement en deux classes:

Non-préemptif (Sans réquisition) : L’exécution du processus en cours ne
peut jamais être interrompue au profit d’un autre processus.
I Aussi appelé coopératif
I En effet aucune décision d’ordonnancement n’intervient jusqu’à ce que le
processus se bloque ou qu’il libère volontairement le processeur.
I Ce sont les algorithmes utilisés dans les premiers systèmes BATCH.
I Exemple : Systèmes à temps réel (traitement critique non interruptible)
Préemptif (Avec réquisition) : L’exécution du processus en cours peut être
interrompue au profit d’un autre processus plus prioritaire (ou plus urgent)
ou de même priorité.
I Nécessite un timer hardware
I Un processus peut être retiré à tout moment du CPU
I Ce type d’algorithmes favorise les processus courts et assure, dans les
systèmes interactifs, un temps de réponse assez bref.
I Exemple : Systèmes à temps partagé

Algorithmes d’ordonnancement
Il existe un certain nombre d’algorithmes d’ordonnancement très utilisés
dans la gestion des processus :

First-Come First-Served (FCFS)
L’algorithme du Premier Arrivé Premier Servi

C’est un algorithme non-préemptif qui permet d’allouer le processeur au
premier processus qui le demande.
Le processeur ne peut être retiré au processus que s’il le libère
volontairement.
L’implémentation de la politique FCFS est facilement gérée avec une file
d’attente FIFO (First In First Out).
I Quand un processus entre dans la file d’attente des processus prêts, son bloc
de contrôle (PCB ou TCB) est enchaînée à la queue de la file d’attente.
I Quand le processeur devient libre, il est alloué au processus en tête de la file
d’attente.

24 3 3
Exemple : Trois processus P1 , P2 et P3 arrivent dans cet ordre au système.

Leurs durées d’exécution sont respectivement : 24, 3 et 3 unités de temps.
Calculer le temps moyen d’attente.
(27+24+0)/3
I Temps d’attente P1 : 0, P2 : 24, P3 : 27, temps d’attente moyen : 17
Si les processus étaient arrivés dans l’ordre P2 , P3 et P1 , les résultats
seraient différents :
I Temps d’attente P1 : 6, P2 : 0, P3 : 3, temps d’attente moyen : 3

(6+3+0)/3

le temps moyen d’attente avec une politique FCFS n’est généralement pas
minimal et peut varier substantiellement si les durées d’exécution des
processus varient beaucoup.
defavoriser , punir
L’algorithme FCFS tend à pénaliser les travaux courts.
I il n’effectue pas de réquisition; c’est à dire qu’une fois que le processeur a été
alloué à un processus, celui-ci le réquisitionne jusqu’à ce qu’il termine ou qu’il
se bloque.
L’algorithme FCFS n’est pas recommandé pour les systèmes à temps
partagé.
I où il est important que l’utilisateur obtienne le processeur à des intervalles
réguliers.
I Il peut paraître désastreux de permettre qu’un processus garde le processeur
pendant une période étendue.

Shortest Job First (SJF)

L’algorithme du Plus Court d’abord
Cet algorithme affecte le processeur au processus possédant le temps
d’exécution le plus court.
Si plusieurs processus ont la même durée, une politique FIFO sera alors
utilisée pour les départager.
c’est un algorithme non-préemptif qui suppose que les délais d’exécution
sont connus d’avance.
Exemple: On soumet au système quatre processus P1 , P2 , P3 et P4 dont les
durées d’exécution sont données par le tableau suivant :
I Temps d’attente P1 : 0, P2 :
8 - 2, P3 : 7 - 4, P4 : 12 - 5
I Temps d’attente moyen : 4

Shortest Job First (SJF)
Il a été prouvé que l’algorithme SJF est optimal dans le temps dans le sens
qu’il obtient le temps d’attente le plus court pour un ensemble de processus
donné.
Toutefois, cet algorithme est difficile à implémenter pour une raison simple
: Comment peut-on connaître le temps d’exécution d’un processus à l’avance
?
I l’inconvénient de la nécessité de connaissance du temps de service à priori et
le risque de privation des tâches les plus longues.
Ainsi, l’algorithme SJF nécessite le calcul des priorités périodiquement et
un réarrangement de la la file d’attente.

Shortest-Remaining-Time-First (SRTF)
L’algorithme du Temps Restant le plus Court
C’est la version préemptive de l’algorithme SJF
Lorsqu’un processus est en cours d’exécution, et qu’un nouveau processus
ayant un temps d’exécution plus court que celui qui reste pour terminer
l’exécution du processus en cours, ce processus est arrêté (préempté), et le
nouveau processus est exécuté.
Tout comme l’algorithme SJF, l’algorithme SRTF favorise les travaux courts
: les travaux longs en revanche peuvent être victimes de famine.
I Temps d’attente P1 : 11 - 2,
P2 : 5 - 4, P3 : 0, P4 : 7 - 5
I Temps d’attente moyen : 3

Round Robin (RR)
L’algorithme du Tourniquet
C’est un algorithme qui utilise la politique préemptive, qui s’adapte bien aux
systèmes à temps partagé.
Il alloue le processeur aux processus à tour de rôle, pendant une tranche de
temps appelée quantum.
Le processeur est alloué au premier processus de la file des processus prêts
pendant un quantum de temps;
Si le processus n’a pas terminé son exécution, il est recyclé dans la file des
processus prêts.
Le processeur est alloué à un autre processus :
I A la fin du quantum de temps ⇒ interruption horloge,
I Si le processus actif se bloque ⇒ attente de ressource physique ou logique,
I Fin d’exécution du processus (fin normale ou erreur ).

Round Robin (RR)
On dispose de 3 processus P1 , P2 et P3 dont les durées d’exécution sont

données par le tableau ci-dessous.
Calculer le temps moyen d’attente en utilisant un algorithme RR, avec un
quantum de 4.
20,16,12,8,4,
I Temps d’attente P1 : 10 - 4, P2 : 4, P3 : 7
I Temps d’attente moyen : 5.6

Round Robin (RR)
La performance de l’algorithme de RR dépend largement de la taille du

quantum:
I Si le quantum est très grand, la politique RR serait similaire à celle du FCFS.
I Si le quantum est très petit, la méthode RR surchargerait le système par de
fréquentes commutations de contexte.
Cependant, le quantum doit être choisi pour permettre un bon partage du
processeur (entre 10 à 50 ms)
I Chacun des utilisateurs aurait l’impression de disposer de son propre
processeur.

Highest Priority First (HPF)
L’algorithme d’ordonnancement avec priorité

La priorité est une valeur numérique (positive ou négative) associée à un
processus et permettant de le classer selon son importance dans le système.
Les priorités des processus peuvent être définies en fonction de plusieurs
paramètres : type de processus, limites de temps, limites mémoires .....
Deux types de priorités :
I Priorité statique : attribuée au processus à sa création et reste jusqu’à la fin
de l’exécution du processus.
I Priorité dynamique : à la création d’un processus, on attribut une priorité
initiale; ensuite cette priorité peut évoluer, par exemple, en fonction du temps
d’exécution, du nombre d’E/S, du nombre de ressources consommées, ....
L’algorithme HPF associe à chaque processus une priorité, et le
processeur sera affecté au processus de plus haute priorité.
En cas de priorités égales on utilise l’algorithme FIFO.

L’algorithme HPF existe en version : avec ou sans préemption.

HPF préemptif : L’exécution du processus en cours peut être interrompue
au profit d’un autre processus plus prioritaire.
5
1
0
0
4
I Temps d’attente P1 : 9 - 7, P2 : 18, P3 : 0, P4 : 0, P5 : 1 + (14 - 2)


L’algorithme HPF existe en version : avec ou sans préemption.

HPF non-préemptif : L’exécution du processus en cours ne peut jamais
être interrompue par autre processus plus prioritaire (jusqu’à ce que se
bloque ou terminé).
I Temps d’attente P1 : 6 - 2, P2 : 18, P3 : 16 - 7, P4 : 0, P5 : 1


blocage partiel de deadlock

Une situation de blocage (famine) peut survenir si les processus de basse
priorité attendent indéfiniment le processeur, alors que des processus de
haute priorité continuent à affluer.
Pour éviter une telle situation, on peut utiliser la technique dite du
vieillissement:
I Elle consiste à incrémenter graduellement la priorité des processus attendant
dans le système pendant longtemps.
I Par exemple, nous pourrions incrémenter de 1 la priorité d’un processus en
attente toutes les 15 minutes.
I En fin de compte, même un processus ayant une priorité initiale égale à 0
aurait la plus haute priorité dans le système et serait exécuté.

L’implémentation de cette politique peut être gérée avec une seule file
d’attente avec priorité (Le processus le plus prioritaire est en tête de la file)
ou avec plusieurs files d’attente des processus prêts.

Multilevel Queues (MLQ)

L’algorithme d’ordonnancement avec files d’attente multiniveaux
Une autre classe d’algorithmes d’ordonnancement a été développée pour des
situations où on peut facilement classer les processus dans des groupes
différents.
Cet algorithme découpe la file d’attente des processus prêts en plusieurs
files d’attentes séparées :
1 Définir des classes de processus (chaque classe par sa propre file d’attente).
2 Associer à chaque classe son propre algorithme d’ordonnancement (FCFS,
SJF, SRTF, RR ou HPF).
3 Définir un algorithme d’ordonnancement entre les classes

Pour définir l’algorithme d’ordonnancement entre les classes, on peut avoir deux
cas :
Cas 1 : Affecter des tranches de temps aux classes.
I Chaque file d’attente obtient une certaine partie du temps processeur,
I Cette partie du temps doit s’ordonnancer entre les différents processus qui la
composent.
Cas 2 : Chaque classe est absolument prioritaire par rapport aux autres
classes de niveau inférieur
I C1 plus prioritaire, Cn moins prioritaire.
I Le processeur est alloué aux processus de la classe la plus prioritaire;
I On ne change de classe que si la classe la plus prioritaire est vide.
I De plus, si un processus d’ une classe plus prioritaire arrive au système, alors
qu’un processus d’une classe moins prioritaire est en train de s’exécuter,
celui-ci doit être interrompu.


Exemple 1 : On peut diviser les processus en deux classes: les processus
avant-plan (interactifs) et les processus arrière-plan (batch)
Ces deux classes possèdent des besoins différents en ce qui concerne le temps
de réponse et ils pourraient donc devoir être ordonnancé différemment:
I Les processus avant-plan peuvent être prioritaires par rapport aux processus
arrière-plan.
I Ou bien, on peut attribuer 80% du temps processeur aux processus avant-plan
et 20% aux processus arrière-plan.
Exemple 2 : On peut aussi diviser les processus en quatre classes (des
processus les plus prioritaires aux processus les moins prioritaires):
I les processus systèmes, interactifs, batch et utilisateurs.


avantage: on a pas un surcharge d'une classe % une autre classe
un distrubution equitable
inconvenient :
un problem de famine
Normalement, dans un algorithme MLQ, les processus sont assignés en

permanence à une file d’attente dès qu’ils rentrent dans le système.
Les processus ne se déplacent pas entre les files d’attente.
Cette organisation possède l’avantage d’une basse surcharge due à
l’ordonnancement, mais elle manque de souplesse.

Multilevel Queues Retroactive (MLQR)

deplace les processus entre les fils d'attente
L’algorithme d’ordonnancement avec files d’attente multiniveaux
rétroactives
Avec cet algorithme (appelé aussi avec plusieurs niveaux dépendants), un
processus peut basculer entre des files.
Ceci est réalisé dans le but d’isoler les processus longs d’une part, et de
relancer les processus de faible priorité d’autre part.
Cet algorithme utilise N files d’attente avec des règles suivantes:
I Un processus qui entre dans le système est mis dans la première file.
I Après avoir reçu une tranche de temps (Quantum), il est mis dans la
deuxième file.
I Après chaque tranche reçue, il passe dans la file suivante.
I L’algorithme choisit le premier processus de la première file non vide (i.e.un
processus de la file i n’est servi que si toutes les files de rang inférieur à i sont
vides).
I Les processus de la dernière file sont recyclés dans la même file.
Il permet de favoriser les petits travaux, sans avoir besoin de savoir à
l’avance combien de temps CPU ceux-ci vont utiliser.
temps d'execution
Multilevel Queues Retroactive (MLQR)

Exemple : trois files files d’attente
I Q0 - gérer par la politique RR avec un quantum de 8.
I Q1 - gérer par la politique RR avec un quantum de 16.
I Q2 - gérer par la politique FCFS.
La politique d’ordonnancement appliquée est décrite comme suit :
I Un nouveau processus est inséré dans Q0
I Processus de Q0 : S’il ne finit pas en quantum = 8, alors il est interrompu et
placé en Q1
I Si Q0 est vide, le processus en tête de Q1 prend la CPU. S’il ne termine pas
en quantum = 16, il est interrompu et mis dans Q2
I Processus de Q2 : exécutés avec FCFS (seulement quand Q0 et Q1 sont vides)
si un processus arrive , il
va etre executer

Évaluation des algorithmes d’ordonnancement
Comment choisir un algorithme de d’ordonnancement de CPU pour un système

particulier? Il existe différentes méthodes d’évaluation:
Modélisation déterministe: Prend en compte une charge de travail
prédéterminée et définit la performance de chaque algorithme pour cette
charge de travail en se basent sur les critères de performance.
Modèles de file d’attente
Simulations
Implantation

Cas d’étude : MS-DOS
MS-DOS est un système mono-utilisateur et mono-tâche.

Il peut y avoir, à un moment donné, plusieurs processus en mémoire mais un
seul est à l’état prêt, tous les autres étant en attente de la fin d’un fils.
L’ordonnanceur des processus du système MS-DOS est très simple : il
exécute un processus jusqu’à ce qu’il se termine ou crée un fils.
Le processus créateur est suspendu jusqu’à ce que le processus créé se
termine.

Cas d’étude : Solaris
Ordonnancement par priorités avec six classes différentes

I Temps partagé (TS) I Système (SYS)
I Interactif (IA) I Juste parts (FSS)
I Temps réels (RT) I Priorité fixée (FP)
Classe Temps partagé (TS) par défaut
I File multi-niveaux avec rétroaction
I Relation inverse : priorité ↓ et time slice ↑
I Haute priorité aux tâches interactives, basse aux attaché-CPU
Classe Interactif (IA) comme TS mais avec plus haute priorité
I Plus haute priorité pour les Temps-réel (RT)
I Exécution directe d’un processus présent dans cette classe
Classe Système (SYS) pour les threads kernel
I Démon en charge de l’ordonnancement, pagination
I Exclusivement pour l’utilisation du kernel

Cas d’étude : Solaris
Priorité fixe (FP) et juste parts (FSS) depuis Solaris 9

I Threads dans FP comme TS mais sans priorité dynamique
I FSS se base sur des parts de CPU à partager
Calcul d’une priorité globale basée sur priorités dans les classes
I Ordonnancement de type RR en cas d’égalité
Thread sélectionné s’exécute jusqu’à l’un des trois conditions
I Le thread bloque
I Il a consommé toute sa time slice
I Il a été préempté par un thread de priorité plus haute
Ordonnancement et gestion des interruptions
I interruption > RT > SYS > FSS, FX, TS, IA

Cas d’étude : Windows
Ordonnancement basé sur l’algorithme préemptif à priorité dynamique

avec des files d’attente multiniveaux rétroactives.
I Le thread avec la plus haute priorité sera celui exécuté
I Exécution jusque terminaison, fin quantum, appel système bloquant (ex. E/S)
I Préemption par thread RT plus haute priorité
L’ordonnanceur utilise 32 niveaux de priorité coupés en deux classes
I la classe utilisateur (1-15) : où la priorité et le quantum de ses threads
peuvent changer au cours du temps.
I la classe temps réel (16-31) où la priorité et le quantum de ses threads sont
fixes.
I Un thread au niveau 0 gère la mémoire (videur de pages)
Une file par niveau de priorité

Cas d’étude : Windows
Chaque file est traitée par l’algorithme RR.

I Le quantum associé aux files de la classe temps réel est fixé à 20 ms.
I Le quantum associé aux files de la classe utilisateur est variable (min = 20 ms
et max = 120 ms).
A chaque passage à une file inférieure, le quantum est augmenté de 20 ms.
Priorité dans la classe utilisateur peut changer
I Priorité diminuée lorsque temps d’un thread écoulé
I Priorité augmentée lorsque attente E/S finie
I Dans tous les cas, la priorité des threads utilisateurs devra rester comprise
entre 1 et 15.
Les threads temps réel ont une priorité fixe qui ne change jamais.
I Ils resteront donc dans leur file correspondant à leur priorité.
I La priorité est toujours comprise entre 16 et 31

Cas d’étude : LINUX
Linux offre trois politiques d’ordonnancement:

I SCHED_FIFO
I SCHED_RR
I SCHED_OTHER
A la création de chaque thread :
I Le système lui attribue une politique d’ordonnancement.
I Il possède aussi une valeur de priorité, appelée priorité statique.
I La valeur de priorité varie de 1 à 40 ( 1 plus faible et 40 la plus forte).
I Par défaut, un thread utilisateur a une valeur de priorité de 20.
SCHED_FIFO, garantit au thread une utilisation illimitée du processeur. Il
ne sera interrompu que dans une des circonstances suivantes :
I Le thread se bloque sur un appel système ou se termine.
I Un autre thread de la classe SCHED_FIFO de priorité plus élevée est prêt.
I Le thread libère lui-même le processeur, en exécutant l’appel système
sched_yield().

Chaque thread de la classe SCHED_RR se voit attribuer un quantum. Il

sera interrompu dans une des circonstances suivantes :
I Le quantum de thread est écoulé.
I Un autre thread de la classe SCHED_RR de priorité plus élevée est prêt.
I Un autre thread de la classe SCHED_FIFO est prêt
I Le thread exécute l’appel système sched_yield().
SCHED_OTHER est un algorithme de tourniquet où chaque thread de
cette classe se voit attribuer un quantum. Il sera interrompu dans une des
circonstances suivantes :
I Le quantum de thread est écoulé.
I Un autre thread de la classe SCHED_FIFO ou SCHED_RR est prêt
I Le thread exécute l’appel système sched_yield().

Le quantum attribué à un thread de la classe SCHED_RR ou

SCHED_OTHER est variable et établi selon les principes suivants:
I La valeur initiale du quantum est égale à la valeur de priorité
un thread de priorité 25 aura un quantum de 25 unités de temps
I À chaque unité de temps, on diminue d’unité le quantum du thread en cours
d’exécution.
Éventuellement, on peut arriver à une situation où tous les threads de la
classe SCHED_OTHER sont dans une des deux situations suivantes :
I Son quantum est 0. Il a écoulé tout le temps qui lui était alloué.
I Il est bloqué. Il n’a pas nécessairement épuisé son quantum.
Dans ce cas, tous les quanta sont réajustés selon la formule suivante :
Quantum = Quantum/2 + priorite

Ordonnancement des
pthreads

Principe
La norme POSIX effectue l’ordonnancement à l’aide d’un algorithme

préemptif (réquisition) à priorités fixes.
Il y au moins 32 niveaux de priorité, de 0 à 31 (0 la plus faible priorité et
31 la plus forte priorité)
A tout instant, un thread moins prioritaire peut être interrompu par un autre
thread plus prioritaire que lui.
A chaque instant, l’ordonnanceur choisi le thread le plus prioritaire.

Principe
Qu’est-ce qui se passe si deux threads ont la même priorité?

Il y a une file d’attente par niveau de priorité, contenant tous les threads prêts
ayants cette priorité
I Le thread prêt de plus

haute priorité est dans la
file d’attente non vide de
plus haut niveau
I Le premier thread de la file
d’attente non vide de plus
haut niveau est sélectionné
et devient le thread en
exécution (actif)
I Le thread interrompu par un thread plus prioritaire, est inséré en tête de la
file correspondant à sa priorité.

Principe
comment sont traités les threads de même priorité (i.e de la même file d’attente)?
Les threads de même priorité peuvent être traitées selon deux politiques:
SCHED_FIFO et SCHED_RR .
SCHED_FIFO : First In First Out queueing. Cela signifie que le thread

est prévu jusqu’à ce qu’il :
I se termine,
I est annulé par un autre thread,
I s’est bloqué à la demande d’E/S par exemple,
I ou est interrompu par un thread plus prioritaire.
SCHED_RR: Round Robin queueing. Le thread est également prévu
jusqu’à ce que son quantum d’ordonnancement expire. Il sera inséré à la
queue de sa file.

Principe
La norme POSIX propose une troisième politique, appelée

SCHED_OTHER qui dépend de l’implémentation de l’ordonnanceur du
système d’exploitation.
I Souvent, il s’agit d’un algorithme classique temps partagé
tous les threads sont dans le même tourniquet,
il n’y a pas de niveau de priorité.
I Ceci permet l’absence de situation de famine (les threads de bas priorité
attendent indéfiniment) qui peut être engendrée avec la politique
SCHED_FIFO ou SCHED_RR.

Exemple

Portée
POSIX ne spécifie pas l’ordonnancement entre les threads appartenant à des

processus différents.
C’est pourquoi, il est nécessaire de spécifier la portée (ou scope en anglais)
de l’activité d’ordonnancement dans laquelle le thread participe.
En d’autres termes, la portée détermine combien des threads (et lesquels)
un thread donné doit concurrencer au moment de la sélection (par
l’ordonnanceur) pour s’exécuter sur un CPU libre.
Un Pthread peut être ordonnancé à la portée du :
I Système (PTHREAD_SCOPE_SYSTEM)
I Processus (PTHREAD_SCOPE_PROCESS)

Portée
PTHREAD_SCOPE_SYSTEM :
Lorsque l’ordonnancement s’effectue, le
thread est sélectionné parmi l’ensemble des
threads du système (des différents
processus).
I A chaque pthread est associé un thread
noyau.
PTHREAD_SCOPE_PROCESS:
Lorsque l’ordonnancement s’effectue, le
thread est sélectionné parmi l’ensemble des
threads du même processus (programme).
I Les Pthreads d’un même processus sont
prises en charge par un pool de threads
noyau.
I Un nombre maximum de threads noyau
existent pour un processus.

Domaines d’allocation
La discussion de la portée d’ordonnancement devient compliquer dans des
systèmes multiprocesseurs.
La plupart des S.E permettent aux collections de CPU d’être traitées comme
des unités séparées à des fins d’ordonnancement.
La norme Pthreads reconnaît l’existence de ces groupements que les appelle
« domaines d’allocation d’ordonnancement ».
Mais, elle ne définit pas les politiques et les interfaces qui les concernent.

Attributs
Quatre attributs d’un pthread sont associés à l’ordonnancement :

Inheritsched: ordonnancement hérité ou explicit?
Scope: portée de la compétition entre les threads (processus ou système)
Schedpolicy: politique d’ordonnancement permettant de gérer les threads
de même priorité (FIFO, RR, OTHER)
Schedparam: priorité du thread permettant de choisir la/les threads à
activer.

Attribut de héritage (Inheritsched)
Par défaut, un nouveau thread est créé avec les attributs d’ordonnancement
(portée, politique et priorité) de son créateur.
La valeur par défaut est PTHREAD_INHERIT_SCHED
Si on veut créer un thread avec des attributs d’ordonnancement spécifiques,
il faut modifier la valeur de l’attribut de l’héritage à
PTHREAD_EXPLICIT_SCHED en utilisant la fonction
pthread_attr_setinheritsched :
int pthread_attr_getinheritsched (pthread_attr_t* attr, int* valeur);

int pthread_attr_setinheritsched (pthread_attr_t* attr, int valeur);
Valeurs possibles:
I PTHREAD_INHERIT_SCHED (valeur par défaut): l’ordonnancement hérité du
thread appelant.
I PTHREAD_EXPLICIT_SCHED: l’ordonnancement spécifié à la création du thread

Attribut de la portée (Scope)
int pthread_attr_getscope (const pthread_attr_t * attr, int* valeur);

int pthread_attr_setscope (const pthread_attr_t * attr, int valeur);
Valeurs possibles:
I PTHREAD_SCOPE_SYSTEM (valeur par défaut): A chaque Pthread est associé un
thread noyau.
I PTHREAD_SCOPE_PROCESS : Les Pthreads d’un même processus sont prises en
charge par un pool de threads noyau.
La taille du pool peut être consultée / modifiée par: int
pthread_getconcurrency (void); int pthread_setconcurrency
(int valeur);

Attribut de la politique (Schedpolicy)
int pthread_attr_getschedpolicy (const pthread_attr_t * attr, int* val);

int pthread_attr_setschedpolicy (const pthread_attr_t * attr, int val);
Valeurs possibles:
I SCHED_FIFO : Les threads de même priorité sont ordonnancés en FIFO.
I SCHED_RR : Les threads de même priorité sont ordonnancés en tourniquet.
I SCHED_OTHER (valeur par défaut) : Tous les threads sont dans le même
tourniquet, il n’y a pas de niveau de priorité.

Attribut de la priorité (Schedparam)
int pthread_attr_getschedparam (const pthread_attr_t * attr, struct

schedparam* sched);
int pthread_attr_setschedparam (const pthread_attr_t * attr, struct
schedparam sched);
La structure schedparam possède le champ:

I int sched_priority : priorité du thread.
La priorité est une valeur entière
I comprise entre sched_get_priority_min (classe) et
sched_get_priority_max (classe)
I Classe: SCHED_FIFO, SCHED_RR, SCHED_OTHER

Configuration du mode d’ordonnancement
L’algorithme d’ordonnancement des pthreads est contrôlé par trois attributs:

scope (portée), policy (politique), et priority (priorité) pour chaque
thread.
Ces attributs sont définis lorsque le thread est créé.
Exemple: Création d’un thread de priorité moyenne avec la politique FIFO.

pthread_t * TID ;
pthread_attr_t attr ;
int fifomax , fifomin ;
struct sched_param param ;
p t hre a d _ a t t r_ ini t (& attr ) ;
p t h r e a d _ a t t r _ s e t i n h e r i t s c h e d (& attr , P T H R E A D _ E X P L I C I T _ S C H E D ) ;
p t h r e a d _ a t t r _ s e t s c h e d p o l i c y (& attr , SCHED_FIFO ) ;
fifomax = s c h e d _ g e t _ p r i o r i t y _ m a x ( SCHED_FIFO ) ;
fifomin = s c h e d _ g e t _ p r i o r i t y _ m i n ( SCHED_FIFO ) ;
fifomil = ( fifomin + fifomax ) /2;
param . sched_priority = fifomil ;
p t h r e a d _ a t t r _ s e t s c h e d p a r a m (& attr , & param ) ;
pthread_create ( TID , & attr , ....) ;......;
p t h r e a d _ a t t r _ d e s t r o y (& attr ) ;

Configuration du mode d’ordonnancement

Cependant, la politique (policy) et la priorité (priority) peuvent être
modifiés alors que le thread est en cours d’exécution.
int pthread_setschedparam(pthread_t thread, int policy, const struct
sched_param *param);
int pthread_getschedparam(pthread_t thread, int *policy, struct
sched_param *param);
Exemple: Modification dynamique de la priorité et la politique d’un thread

void * fct (.......) { .....
fifomax = s c h e d _ g e t _ p r i o r i t y _ m a x ( SCHED_FIFO ) ;
fifomin = s c h e d _ g e t _ p r i o r i t y _ m i n ( SCHED_FIFO ) ;
fifomil = ( fifomin + fifomax ) /2; param . sched_ priori ty = fifomil ;
p t h r e a d _ s e t s c h e d p a r a m ( pthread_self () , SCHED_FIFO , & fifomil ) ; .....}
int main () {
pthread_t * TID ; pthread_att r_t attr ; int fifomax , fifomin ; struct
sched_param param ; ...
pt h r e a d _ a tt r_ ini t (& attr ) ;
p t h r e a d _ a t t r _ s e t i n h e r i t s c h e d (& attr , P T H R E A D _ E X P L I C I T _ S C H E D ) ;
pthread_create ( TID , & attr , fct ....) ;
p t h r e a d _ a t t r _ d e s t r o y (& attr ) ;.....}

Relâchement du processeur par un thread
Demande de relâchement du processeur :
int sched_yield (void);
Le thread appelant demande à libérer le processeur.

I Il est inséré à la queue de la file d’attente correspondant à sa priorité.
I Il reprendra son exécution lorsque tous les threads de priorité supérieure ou
égale à la sienne se sont exécutées.
I S’il est le seul thread le plus prioritaire dans le système, il continuera à
fonctionner après un appel à sched_yield ().

Main 4

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Main 4

Transféré par

Droits d'auteur :

Formats disponibles

L’ordonnancement CPU

Ordonnancement des pthreads

Pr. Abdessamad EL BOUSHAKI

Pr. Abdessamad EL BOUSHAKI (FST Marrakech) Système d’exploitation 1/62

Pr. Abdessamad EL BOUSHAKI (FST Marrakech) Système d’exploitation 2/62

Introduction à l’ordonnancement : Multiprogrammation

Comment choisir le processus qui a accès au processeur ? Comment changer cet

Dans ce chapitre, on utilise le terme « processus » pour désigner un processus

Files d’attente de l’ordonnancement

Pour gérer les processus durant leur séjour, le système d’exploitation

Pr. Abdessamad EL BOUSHAKI (FST Marrakech) Système d’exploitation 5/62

Files d’attente de l’ordonnancement

Un nouveau processus est initialement placé dans la file d’attente des

Pr. Abdessamad EL BOUSHAKI (FST Marrakech) Système d’exploitation 6/62

Files d’attente de l’ordonnancement

Pr. Abdessamad EL BOUSHAKI (FST Marrakech) Système d’exploitation 7/62

Différents niveaux de l’ordonnancement

I Il gère le déplacement des processus d’une file d’attente à une autre.

L’ordonnanceur (planificateur, scheduler ou dispatcher) est un

Pr. Abdessamad EL BOUSHAKI (FST Marrakech) Système d’exploitation 9/62

Objectifs d’un ordonnanceur

Les principaux objectifs assignés à un ordonnanceur sont:

Pr. Abdessamad EL BOUSHAKI (FST Marrakech) Système d’exploitation 10/62

Critères de performance d’ordonnanceur

Les divers algorithmes d’ordonnancement du processeur possèdent des

Pr. Abdessamad EL BOUSHAKI (FST Marrakech) Système d’exploitation 11/62

Critères de performance d’ordonnanceur

Les critères les plus souvent utilisés sont :

Pr. Abdessamad EL BOUSHAKI (FST Marrakech) Système d’exploitation 12/62

Critères de performance d’ordonnanceur

Pr. Abdessamad EL BOUSHAKI (FST Marrakech) Système d’exploitation 13/62

Optimisation des critères d’ordonnancement

Plusieurs choix possibles pour l’optimisation de ces critères

Pr. Abdessamad EL BOUSHAKI (FST Marrakech) Système d’exploitation 14/62

On peut classer les politiques ou stratégies d’ordonnancement en deux classes:

Pr. Abdessamad EL BOUSHAKI (FST Marrakech) Système d’exploitation 15/62

Pr. Abdessamad EL BOUSHAKI (FST Marrakech) Système d’exploitation 16/62

First-Come First-Served (FCFS)

L’algorithme du Premier Arrivé Premier Servi

Pr. Abdessamad EL BOUSHAKI (FST Marrakech) Système d’exploitation 17/62

First-Come First-Served (FCFS)

Exemple : Trois processus P1 , P2 et P3 arrivent dans cet ordre au système.

I Temps d’attente P1 : 6, P2 : 0, P3 : 3, temps d’attente moyen : 3

Pr. Abdessamad EL BOUSHAKI (FST Marrakech) Système d’exploitation 18/62

First-Come First-Served (FCFS)

Pr. Abdessamad EL BOUSHAKI (FST Marrakech) Système d’exploitation 19/62

Shortest Job First (SJF)

Pr. Abdessamad EL BOUSHAKI (FST Marrakech) Système d’exploitation 20/62

Shortest Job First (SJF)

Pr. Abdessamad EL BOUSHAKI (FST Marrakech) Système d’exploitation 21/62

Pr. Abdessamad EL BOUSHAKI (FST Marrakech) Système d’exploitation 22/62

Round Robin (RR)

Pr. Abdessamad EL BOUSHAKI (FST Marrakech) Système d’exploitation 23/62

Round Robin (RR)

On dispose de 3 processus P1 , P2 et P3 dont les durées d’exécution sont

Pr. Abdessamad EL BOUSHAKI (FST Marrakech) Système d’exploitation 24/62

Round Robin (RR)

La performance de l’algorithme de RR dépend largement de la taille du

Pr. Abdessamad EL BOUSHAKI (FST Marrakech) Système d’exploitation 25/62

Highest Priority First (HPF)

L’algorithme d’ordonnancement avec priorité

Pr. Abdessamad EL BOUSHAKI (FST Marrakech) Système d’exploitation 26/62

Highest Priority First (HPF)