1. No category

CHAP3. Notions sur les Processus_ Gestion du processeur central
3.1. Notion de Processus séquentiel.
Les exécutions des instructions d'un programme doivent respecter un certain ordre de précédence. On peut représenter l’éxécution d’un programme
à l’aide d’un graphe de précédence .
Exemple: Soit un programme qui lit 2 variables aetb à partir d'un même fichier , puis calcule la somme de ces 2 variables et imprime ces 2
variables et leur somme sur la même imprimante.
..
1. lire a
2. écrire a
3. lire b
4. écrire b
5. calculer c=a + b
6. écrire c
L'exécution de ce programme peut être faite de plusieurs manières.
Exécution a): il < i2 < i3 < i4 < i5 < i6
Exécution b) : il < {il \ | i3) < (i5 | | i4) < i6
(< : avant; | | : en parallèle)
3.1.1 Définition d'un processus séquentiel
Dans l'exécution (a) les instructions ont été exécutées dans un ordre séquentiel strict; on appellera cette exécution séquentielle un
processus séquentiel (ou processus). L'exécution (b) ne correspond pas à un processus séquentiel car certaines instructions telles
que i2 et i3 peuvent se dérouler en parallèle (ou simultanément); on peut décomposer cette exécution en 2 processus séquentiels
concurrents: FI : il < i3 < i5 ; P2 : i2 < i4 < i6.
Différence entre programme et processus
De manière informelle, un processus est l'exécution séquentielle d'un programme. On peut dire qu'un processus est une
représentation abstraite de l'exécution d'un programme. Un processus est une entité dynamique représentant l'exécution
séquentielle d'un programme sur le processeur; l'état d'un processus évolue au cours de l'exécution de son programme. Alors qu'un
programme est une entité statique qui peut donner naissance à un ou plusieurs processus.
Exemple «non informatique»
Programme
Données
Processeur
Processus
Processus de Préparation d'un gâteau
(Tanenbaum 1994)
Recette pour préparer le gateau
Ingrédients utilisés : farine, beurre, sucre, amandes,...
Patissier
Actions de préparation du gâteau ou exécution des différentes étapes
de la recette
3.1.2 Bloc de contrôle d'un processus (PCB).
Tout processus introduit dans un système est recensé par un descripteur de processus PCB (Process Control Block) structure
représentative donnant toutes les informations nécessaires au contrôle et au suivi du processus par le système .
Les informations contenues dans un PCB peuvent être regroupées en deux classes:
_Informations nécessaires à l'exécution du processus (contexte).
_Informations nécessaires à la gestion du processus.
1. Contexte d'un processus
On appelle contexte d'un processus le sous-ensemble de la machine que les actions (instructions) du processus peuvent modifier
ou consulter. Il est défini par : le contexte du processeur : registres internes (mot d'état) et registres adressables, L'espace mémoire
utilisé par le programme et les données du processus, la Pile d'exécution.
Le contexte d'un processus est l'ensemble des données qui permettent de reprendre l'exécution d'un processus qui a été interrompu
(c'est à dire les informations sauvegardées à chaque changement d'état du processus ou commutation).
2. Informations de gestion
Ces informations permettent l'identification et la gestion des processus; on peut trouver:
• Identificateur du processus : identificateur attribué par le système (noyau).
Tout processus est identifié par un identificateur unique (non modifiable) qui lui est propre et qui le caractérise. L'identificateur
permet de distinguer tout processus de façon non ambiguë.
•
Nom symbolique (facultatif) : nom attribué par l'utilisateur,
•
Priorité,
•
Etat du processus,
•
Quantum ou temps maxi cpu restant à consommer
•
Pointeurs sur pcb des processus parents (père , fils,…)
•
Informations sur l’état des Entrées/Sorties :
•
Pointeur sur table des descripteurs des Fichiers ouverts,
•
Entrées/sorties en cours,…
•
Informations de comptabilité (temps CPU consommé, temps d’attente, nombre d'entrées/sorties effectuées, ...)
3.1.3 Etats d'un processus
Durant son existence, un processus passe à travers une suite d'états; les principaux états d'un processus sont les suivants:
1°) Etat Created (Créé): dés qu'un processus est lancé par un utilisateur il commence sa vie par cet état. A ce niveau le système
examine la disponibilité de toutes les ressources nécessaires pour démarrer l'éxécution du processus. Il ne pourra être éxécuté que
si toutes ces ressources peuvent lui être allouées.
2°) Etat Ready (Prêt): c'est l'état correspondant au fait qu'il ne manque au processus qu'un processeur pour s'éxécuter (attente du
ou d'un processeur).
3°) Etat Running (Actif ) : ici le processus dispose de toutes les ressources ( y compris un processeur) et s'éxécute.
4°) Etat Waiting (Bloqué) : le processus attend au moins une ressource autre qu'un processeur.
5°) Etat Complete (Terminé): le processus a terminé son traitement et toutes les ressources qu'il détenait doivent être récupérées
par le système.
1 : création du processus ; 2 : Préallocation Mémoire (ressources préliminaires sauf processeur) ; 3 : Election Ordonnanceur ;
4 : Réquisition ; 5 : Blocage ; 6 :Réveil (priorité processus réveillé <= priorité processus actif) ; 7 :Réveil (priorité processus
réveillé > priorité processus actif) ; 8 : fin du processus ; 9 : Destruction du processus
3.1.4 Notion de Travail
Un utilisateur soumet son problème à résoudre sous forme d'un travail ou job.
Un travail est un ensemble d'activités définies pour résoudre un problème. Un travail se décompose en un ensemble d'unités
appellées étapes ou steps qui s'éxécutent en général en série.
Chaque étape est un programme éxécutable pouvant se décomposer en un ou plusieurs processus coopérants. Un travail , une fois
accepté par le système est transformé en un ensemble de processus au niveau de chaque étape.
JOB = Step1 ------->processus: PS11 PS12 ..........PS1k
Step2 ------->processus: PS21 PS22 ..........PS1k
.......
Stepn ------->processus: PSn1 PSn2 ..........PSnk
Exemple:
Step1= Compilation d'un programme source nom.p en PASCAL = processus éxécution du compilateur PASCAL avec comme
entrée le programme source nom.p et génération d'un fichier objet nom.obj en sortie;
Step2= Edition de liens = processus éxécution de l'éditeur de liens avec comme entrée le fichier objet nom.obj généré par le Step1
et génération d'un fichier éxécutable nom.exe en sortie;
Step3= Chargement et éxécution de nom.exe = processus éxécution de nom.exe
3.1.5 Cheminement des travaux et des processus dans le système
Sachant que le système est un ensemble de programmes de gestion de ressources, un problème reste posé:
1°) Quelle est la relation entre ces programmes ?
2°) A quel moment de la vie (période d'existence) d'un travail et d'un processus , chacun de ces programmes entre -t- il en jeu ?
Pour expliquer ces relations internes et le séquencement de gestion de ressources, il faut étudier la relation entre la vie d'un travail et celle
des processus correspondants.
Etats d'un travail:
Tout travail introduit dans un système est recensé par un descripteur de job JCB (Job Control Block) structure représentative donnant
toutes les informations nécessaires à la gestion du job. Un travail va passer par une succession d'états :
1°) Etat Submit (soumis en entrée): dés qu'un travail est lancé par un utilisateur il commence sa vie par cet état. Ici ,un module Reader
(lecteur de travaux) introduit les travaux sur disque et crée un fichier de controle (pour spool) associé à chaque travail. A ce niveau le
système analyse les commandes demandées par le job sous forme d'un langage réservé à cet effet (Job control language ou encore appelé
Shell).
2°) Etat Hold (maintenu en file d'attente): si les commandes formulées par le job sont correctes, le job est converti en une forme interne
compréhensible par les autres modules du système.
A ce niveau le job est placé dans les files d'attente appropriées du régulateur (ordonnanceur) de travaux (job scheduler).
3°) Etat Running (actif ) : après l'état Hold , dès que la politique du job scheduler le permet et que les ressources préliminaires minimales
demandées par le job peuvent lui être allouées, le job passe à l'état actif. A ce niveau le Gestionnaire des étapes (Step Manager) traduit
chaque étape du job actif en processus . Il introduit ces processus dans la chaîne de micro-régulation et attend la fin de tous les processus
composant une étape pour enchaîner sur l'étape suivante du job.
4°) Etat Out (en sortie ) : Dès qu'un job termine son éxécution , son fichier de controle (image disque de son listing) est mis en file de sortie.
A ce niveau , un module Writer est chargé de la sortie sur imprimante de tous les fichiers de controle qui lui sont soumis.
Le schéma suivant montre la relation entre les états d’un travail et les états des processus correspondants :
3.1.6 Transitions d'un processus d'un état à un autre
Le changement d'état d'un processus évolue au cours du temps et peut être provoqué pour diverses raisons: Attente d'un
événement, manque de ressources, arrivé d'un événement attendu, disponibilité de ressources manquantes, arrivé ou réveil d'un
processus plus prioritaire, exécution de certaines opérations (entrées/sorties, fin d'exécution du processus...).
Les différentes transitions d'un processus sont représentées à l'aide du schéma ci-dessous.
(1) :
Création de processus;
(2) :
L'ordonnanceur choisit un processus de la file des processus prêts selon une politique d'ordonnancement (le processus est
élu).
(3) :
Le processus a consommé le quantum de temps qui lui a été attribué par l'ordonnanceur (ou un processus plus prioritaire
est arrivé); il revient dans la file des processus prêts : c'est une réquisition ou préemption; La fin du quantum est signalée à l'aide
d'une interruption horloge. L'ordonnanceur affecte le processeur à un autre processus : transition (2).
(4) :
Le processus ne peut plus progresser, il se met en attente d'une ressource (physique ou logique) ou d'un événement pour
pouvoir continuer son exécution. L'ordonnanceur affecte le processeur à un autre processus : transition (2).
(5) :
Libération d'une ressource ou arrivé d'un événement attendu: le processus réveillé passe à l'état prêt.
(6) :
Fin d'exécution du programme d'un processus (terminaison) ou erreur dans l'exécution du programme. L'ordonnanceur
affecte le processeur à un autre processus: Transition (2).
(7) :
Destruction du processus par un autre processus (le processus parent ou un processus système).
3.1.7 Structures de données correspondant aux différents états
Ces états sont représentés dans le système à l'aide de structures de donnés, en général des files ; ces structures de données
contiennent des identificateurs de processus ou des pointeurs vers les blocs de control de processus (PCB).
L'état prêt peut être représenté 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é.
L'état bloqué on peut trouver une file par événement, signal ou ressource attendu (file r processus en attente de l'imprimante, file
des processus en attente de fin d'E/S sur le disque,...).
L'état actif : un vecteur composé de un ou plusieurs éléments (machine monoprocesseur ou multiprocesseurs) contient les
identificateurs des processus actifs ou des pointeurs vers les descripteurs des processus actifs.
3.2 Opérations sur les processus
Pour le système un processus est un objet, identifié par un identificateur unique et sur lequel on peut appliquer certaines
opérations telles que:
• Création,
•
Destruction,
•
Blocage,
•
Réveil,
•
Activation (par le dispatcher),
•
Désactivation (en fin de quantum),
•
Suspension.
Re la nc e.
Un noyau de système est composé de l'ensemble des ces opérations.
3.2.1 Création d'un processus
•
Cette opération consiste à :
Allouer un descripteur au processus (PCB),
Affecter un identificateur unique au processus,
Initialiser le descripteur (PCB) :
- Programme à exécuter,
- Pile d'exécution,
- Mémoire centrale utilisée par le programme et les données du processus,
- Etat du processus,
- Priorité du processus,
- Autres ressources,...
Propriétés de la fonction « création » de processus :
La création des processus est en général dynamique:
Les processus sont créés à la demande. Dans ce cas un processus peut créer ou détruire un autre processus. Le problème qui se pose
alors est le risque de création d'un nombre illimité de processus. En réalité le nombre de créations de processus est limité par le
système : un plafond Pmax qui est le nombre maximum de processus existant simultanément dans le système est imposé aux
utilisateurs (Pmax est un paramètre modifiable du noyau) .
Le processus créé par un autre processus est appelé processus "Fils" et le processus créateur est appelé processus "Père". On établit
généralement une hiérarchie entre les processus selon les règles suivantes:
Régle 1: Un processus peut avoir plusieurs fils
Régle 2: Un processus ne peut avoir qu'un seul père .
Ceci engendre une structure arborescente entre chaque processus et ses fils:
En général à tout programme executable lancé , correspond un seul processus , qui , à son tour peut créer d’autres processus
dynamiquement.
3.2.2 Destruction de processus
La destruction d'un processus ne peut être effectuée que par le processus père ou un processus système. Cette opération consiste à:
• Libérer les ressources occupées par le processus,
• Détruire éventuellement toute la descendance du processus ; ce choix dépend du système :
_dans les systèmes de la famille Multics la destruction de la descendance est réalisée automatiquement par le noyau.
_dans les systèmes de la famille Unix quand un processus se termine ses fils (ou sa descendance) ne sont pas détruits.
• Libérer son descripteur (PCB).
Remarque : Le descripteur d'un processus (PCB) peut être réutilisé, après sa libération. Par contre, l'identificateur d'un processus
ne peut pas l'être.
3.2.3 Organisation générale du Noyau
L'éxécution des programmes du noyau est déclenchée de deux façons:
1)Par l'appel d'une fonction (primitive) de gestion des processus (création, destruction, synchronisation,...).
En général ces primitives sont réalisées sous la forme d'appel superviseur pour des raisons de protection.
2)Par une IT , car les programmes de traitement des IT font partie du noyau qui réalise ainsi la traduction de ces IT en opérations
de synchronisation. Ces IT sont ainsi invisibles aux niveaux supérieurs.
Dans tous les cas le mécanisme d'entrée dans le noyau comporte donc une sauvegarde automatique du mot d'état et éventuellement
des registres du processeur qui éxécute l'appel superviseur ou qui traite l'IT. Ces informations sont sauvegardés soit dans un
emplacement fixe (ancienne technique) , soit dans une pile (nouvelle technique).
3.3 L'ORDONNANCEMENT DES PROCESSUS
C'est un ensemble de règles définissant l'ordre d'exécution des processus en tenant compte de la disponibilité des ressources
(processeurs) nécessaires, 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. Les principaux objectifs
assignés à un ordonnanceur sont:
Occupation maximale du 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 la priorité, l'échéance (dans les
systèmes temps réel), etc…
Ces objectifs sont parfois complémentaires, parfois contradictoires : augmenter la performance par rapport à l’un d’entre eux peut
se faire au détriment d’un autre. Il est impossible de créer un algorithme qui optimise tous les critères de façon simultanée.
On distingue deux principaux types d'ordonnanceurs :
3.3.1 Ordonnanceur des travaux
Ce type d'ordonnanceurs est utilisé dans les systèmes de traitement par lot ( mode Batch , appelé mode BackGround sur Unix).
Les travaux sont soumis à travers un périphérique d’entrée (bande magnétique, lecteur de cartes, ...) et stockés en mémoire
secondaire. Ces travaux sont ensuite initialisés et rangés dans une file des « travaux en entrée ». L'ordonnanceur des travaux
choisit un travail (job) de la file et le charge en mémoire centrale. Le processus correspondant à ce travail est rangé dans la file des
« processus prêts ».
Dans les systèmes interactifs tels que les systèmes en temps partagé, les systèmes transactionnels et les systèmes en temps réel
l'activité de l'ordonnanceur des travaux est très réduite voire inexistante.
3.3.2 Ordonnanceur des processus
Son rôle consiste à choisir un processus, de la file des processus prêts, selon une stratégie d'ordonnancement et lui affecter le
processeur.
La commutation de processus (commutation des contextes des processus) est réalisée par un programme appelé commutateur de
processus (dispatcher); cette opération consiste à:
Restaurer le contexte du processus choisi.
Changer son état (de l'état prêt il passe à l'état actif ou élu).
Restaurer le contexte du processus élu.
Quand l'ordonnanceur est-il sollicité par le système ?
• Lorsque le processus actif se termine ;
• Lorsque le processus actif se bloque (par manque de ressource physique ou logique): cela suppose que d'autres processus sont
susceptibles d'être activés et donc sont présents en mémoire (ou file des processus à l'état prêt non vide);
• Lors d'une interruption d'horloge à la fin d'un quantum de temps : système en temps partagé.
• L'arrivée ou le réveil d'un processus plus prioritaire.
Schéma synoptique général de l’ordonnancement des processus
3.3.3 Structures de données nécessaires pour la gestion des files d’attente des processus
On associe généralement une file à chaque cause distincte de blocage pour regrouper les processus bloqués. De même, les
processus à l'état prêt sont généralement maintenus dans une file dont la gestion permet de mettre en oeuvre une politique
d'allocation des processeurs physiques.
Si on suppose que le prochain processus à élire est toujours le premier de la file des processus prêts, la politique d'allocation des
processeurs physiques sera définie par deux algorithmes:
1)algorithme d'entrée dans la file des processus prêts
2)algorithme qui détermine la réquisition des processeurs physiques.
L'ensemble des programmes réalisant ces algorithmes est appelé ordonnanceur ou process scheduler (régulateur de processus).
Le programme qui réalise l'élection proprement dite (choix du processeur, gestion des contextes de commutation) est appelé
distributeur ou dispatcher.
Schéma synoptique d’ordonnancement à 2 niveaux : Scheduler/Dispatcher
3.3.4 Critères de performance des algorithmes d'ordonnancement
Il existe plusieurs algorithmes d'ordonnancement, chacun d'eux a des propriétés spécifiques qui peuvent favoriser une classe de
processus par rapport à une autre. Pour le choix d'un algorithme à utiliser dans une situation particulière on doit tenir compte des
différentes propriétés de l'algorithme. Les principaux critères de performances sont:
1) Utilisation du processeur central (CPU):
a)Le taux d'utilisation du processeur central est défini par le rapport temps CPU consommé/ temps de séjour des processus . Le
taux d'utilisation du processeur doit être le plus élevé possible.
b)L’OverHead de gestion du CPU:
Soit Tc le temps de commutation de contextes, et soit Q
(quantum) la tranche de temps allouée à chaque processus avant de lui retirer le processeur , on appelle
Overhead Cpu le rapport Tc/Q : ce paramètre mesure la proportion de temps perdue par la gestion du Cpu par rapport au temps
d’allocation du CPU (paramètre d’efficacité de gestion du CPU ). L’OverHead Cpu doit être le plus faible possible.
2) Temps de résidence (turn around time ou temps de séjour: C'est le temps passé par le processus dans le système. C'est la somme
du temps d'exécution et du temps passé dans les différentes files (file des processus prêts, files des processus bloqués). Soient te:
le temps (ou date) d'entrée processus dans le système et ts: le temps (ou date) de sortie du processus.
Temps de résidence = ts - te
3)Temps d'attente (waiting time): C'est le temps passé dans la file des processus prêts; c'est-à-dire le temps total d’attente du
processeur central (cpu).
Remarque : ne pas confondre avec le temps passé dans l'état bloqué (par exemple temps d'attente des entrées/sorties ou temps
d'attente d’une ressource autre que le cpu,...).
4)Temps de réponse: Le temps de résidence n'est pas significatif pour les programmes interactifs, donc on utilise un autre critère
de performance qui est le temps de réponse. C'est le temps qui sépare le moment où le processus soumet une requête et le début de
la réponse à cette requête ; on ne tient pas compte de la durée de la réponse : le processus peut commencer à envoyer des réponses
à l'utilisateur avant qu'il soit terminé.
Soient : te: le temps (ou date) de soumission de la requête et ts: le temps (ou date) de début de la réponse à cette requête.
Temps de réponse = ts – te
Différentes stratégies d'ordonnancement
On peut classer les politiques ou stratégies d'ordonnancement en deux classes:
a)Non-préemptif (Sans réquisition) : L'exécution du processus en cours ne peut jamais être interrompue au profit d'un autre processus. Ce
sont les algorithmes utilisés dans les premiers systèmes BATCH.
b)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é (voir algorithme du tourniquet sans priorité). Ce type d'algorithmes favorise les processus courts et
assure, dans les systèmes interactifs, un temps de réponse assez bref.
3.3.5 Algorithmes non-préemptifs (sans réquisition)
1 )Premier arrivé premier servi (FCFS ou FIFO)
C'est un algorithme sans réquisition qui consiste à allouer le processeur au premier processus de la file des processus prêts.
Processus
Temps estimé
Temps d'attente
Temps de résidence
1
2
3
4
30
12
2
16
0
30
42
44
30
42
44
60
Diagramme de Gantt
Diagramme de Gantt
Inconvénient: Les travaux courts risquent d'attendre longtemps s'ils sont après des travaux longs.
2) Le plus court d'abord ( SJF: Shortest Job First)
Si l'ordonnanceur fonctionne selon la stratégie SJF, il choisit, parmi le lot de processus à exécuter, le plus court (plus petit temps
d'exécution). Cette stratégie est bien adaptée au traitement par lots (Batch) de processus dont les temps maximaux d'exécution
sont connus ou (estimés) fixés par les utilisateurs car elle offre un meilleur temps moyen de séjour.
Considérons par exemple un lot de quatre processus dont les temps respectifs d'exécution sont a,b,c, et d . Le premier processus se
termine au bout du temps a ; le deuxième processus se termine au bout du temps a+b ; le troisième processus se termine au bout
du temps a+b+c ; le quatrième processus se termine au bout du temps a+b+c+d . Le temps moyen de séjour est :
Tms = (4 a + 3 b + 2 c + d)/ 4
.
On obtient un meilleur temps de séjour pour a<b<c<d .
Toutefois, l'ordonnancement du plus court d'abord n’est optimal que si les travaux (processus) sont disponibles
simultanément.
Le processeur est alloué au travail le plus court (temps processeur demandé); la priorité d'un processus est inversement proportionnelle au temps
processeur demandé :
Priorité = F(
1 / (temps CPU demandé) )
Processus
1
2
3
4
Temps estimé
30
12
2
16
Temps d'attente
30
2
0
14
Temps de résidence
60
14
2
30
SJF est un cas particulier des algorithmes avec priorité.
Inconvénient : risque de privation (attente infinie) pour les travaux longs , surtout si un flot continu de travaux courts arrive indéfiniment.
Diagramme de Gantt
Diagramme de Gantt
3.3.6 Algorithmes préemptifs (avec réquisition)
Dans les algorithmes d'ordonnancement précédents, quand le processeur est alloué à un processus il le garde jusqu'à la fin de son exécution
ou bien jusqu'à ce qu'il lance une opération d'entrées/sorties ou il se bloque volontairement en attente d'une ressource ou d'un événement.
Dans les algorithmes préemptifs, le processeur peut être retiré à un processus avant la fin de son exécution et affecté à un autre processus.
Le processus choisi peut être plus prioritaire ou de priorité quelconque dans le cas où le processeur serait alloué par quantum de
temps (algorithme du tourniquet avec processus de même priorité).
1) Le Tourniquet (Round-robin) ou Ordonnancement circulaire
Cet algorithme est très utilisé dans les systèmes en temps partagé. Le temps est divisé en tranche de temps appelée quantum de
temps ou 'time slice'. 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 (premier processus de la file) à la fin du quantum ou si le processus actif se bloque.
Choix de la valeur du quantum :
Les performances de cet algorithme dépendent du quantum de temps(Q):
_Un quantum trop petit provoque trop de commutations de processus et abaisse l'efficacité du processeur : les processus
progressent trop lentement .
_Un quantum trop élevé augmente le temps de réponse des courtes commandes en mode interactif .
Si Q est très grand (tend vers l'infini) alors cet algorithme est équivalent à l'algorithme FIFO (avec un overhead tendant vers 0)
Si Q est très petit (tend vers 0) alors il y a une mauvaise utilisation du processeur avec un overhead tendant vers 100 % .
On doit tenir compte du temps de commutation des contextes (0.1 à 0.5 ms) pour le choix du quantum de temps (10 à 50 ms : le
quantum du système windows98 est égal à 20 ms). Actuellement on estime qu’un quantum entre 20 et 50 ms est souvent un
compromis raisonnable.
Exemple:
Un quantum = 2 unités de
temps
Processus Temps estimé
nbre de quanta
Temps d'attente
1
2
3
4
10
4
1
5
10q
8q
2q
10q
20
8
2
10
20u
16u
4u
20u
Diagramme de Gantt
Temps de
Résidence
40
24
14
30
Diagramme de Gantt
2) Ordonnancement du plus petit temps de séjour SRT
L'ordonnancement du plus petit temps de séjour ou Shortest RemainingTime est la version préemptive de l'algorithme SJF. A
chaque fois qu’un nouveau processus arrive dans la file des processus prêts, l'ordonnanceur compare la valeur espérée (estimée)
du temps CPU à consommer pour ce processus avec la valeur du processus actuellement en exécution. Si le temps du nouveau
processus est plus petit, l’ordonnanceur retire le processeur au processus actif en le ramenant à l’état prêt et active immédiatement
le nouveau processus.
Comment appliquer cette technique aux processus interactifs ?
Chaque processus interactif se comporte comme suit : il attend une commande, l'exécute, attend la commande suivante, et ainsi
de suite. Alors parmi les processus prêts, le processus élu sera celui dont la commande à exécuter est la plus courte en temps. Le
temps d'exécution de la prochaine commande de chaque processus est estimé en se basant sur le comportement passé du processus
: Si T0 est le temps d'exécution estimé pour la première commande et Ti , le temps d'exécution mesuré pour la iieme commande, les
estimations successives sont :
T0 pour la première ;
T0/2 + T1 /2 pour la seconde ;
T0/4 + T1/4 + T2 /2 pour la troisième ;
T0/8+T1/8+T2/4 +T3/2 ,...
3) Algorithmes d'ordonnancement avec priorité
La priorité: c'est une valeur numérique associée à un processus et permettant de classer les différents processus selon leur
importance. Ces priorités peuvent être statiques (si elles sont fixées à la création des processus et ne sont pas modifiées par le
système) ou dynamiques (si elles sont mises à jour périodiquement par le système). Ainsi, typiquement, dans un système temps
réel, les priorités sont fixes et reflètent le caractère critique des tâches. Dans les systèmes orientés sur le partage du temps, les
priorités sont dynamiques et modifiées par le système pour atteindre certains de ses objectifs. Par exemple, pour favoriser les
processus qui font beaucoup d'entrées/sorties et consomment, donc, très peu de temps du processeur, on doit augmenter
dynamiquement leur priorité. On peut, également, diminuer la priorité des processus qui consomment beaucoup de temps
processeur (ce qui favorisera les autres processus).
Processus
1
2
3
4
Temps estimé
30
12
2
16
Priorité
1
5
1
4
Temps d'attente
28
0
58
12
Temps de résidence
58
12
60
28
Diagramme de Gantt
1.
Diagramme de Gantt
La priorité peut être utilisée avec d'autres algorithmes d'ordonnancement.
L'algorithme round robin permet une répartition équitable du processeur. Cependant il n'est pas intéressant si certains processus
sont plus importants ou urgents que d'autres. L'ordonnanceur à priorité attribue à chaque processus une priorité. Le choix du
processus à élire dépend des priorités des processus prêts. Les processus de même priorité sont regroupés dans une file du type
FIFO. Il y a autant de files qu'il y a de niveaux de priorité. L'ordonnanceur choisit le processus le plus prioritaire qui se trouve en
tête de file. En général, les processus de même priorité sont ordonnancés selon l'algorithme du tourniquet.
Attribution et évolution des priorités
Pour empêcher les processus de priorité élevée de s'exécuter indéfiniment, l'ordonnanceur diminue régulièrement la priorité du
processus en cours d'exécution.
La priorité du processus en cours est comparée régulièrement à celle du processus prêt le plus prioritaire (en tête de file).
Lorsqu'elle devient inférieure, la commutation a lieu. Dans ce cas, le processus suspendu est inséré dans la file correspondant à sa
nouvelle priorité. L'attribution et l'évolution des priorités dépendent des objectifs fixés et de beaucoup de paramètres.
Exemple : Les processus qui font beaucoup d'E/S (qui sont souvent en attente) doivent acquérir le processeur dès qu'ils le
demandent, afin de leur permettre de lancer leur requête suivante d'E/S. Lorsqu'un processus passe de l'état élu à l'état bloqué, sa
priorité est recalculée. Sa nouvelle valeur est le rapport : quantum/temps réellement utilisé par le processus.
Les processus qui ont le plus grand rapport sont les plus prioritaires :
. Si le quantum = 100 ms et le temps utilisé = 2 ms, la nouvelle priorité est 50.
. Si le quantum = 100 ms et le temps utilisé = 50 ms, la nouvelle priorité est 2.
3.3.7 Ordonnancement avec files multiniveaux
On définit des classes de processus et on associe à chacune des classes une priorité et une stratégie d'ordonnancement.
Le processeur est alloué aux processus de la classe la plus prioritaire. On ne change de file que si la file la plus prioritaire est vide. Un
processus ne peut pas changer de classe.
Exemple: Système Unix de SUN
Dans le système Unix de SUN, il y a 3 classes de processus:
• Processus en temps réel,
• Processus système,
• Processus en temps partagés.
• Les processus en temps réel sont plus prioritaires que les processus systèmes qui sont plus prioritaires que les processus en temps
partagé.
Les files multiniveaux avec recyclage
Dans la technique précédente les processus ne pouvaient pas changer de file. Un processus d'une classe A reste dans la file de cette classe
jusqu'à ce qu'il quitte le système. Dans cette stratégie, on dispose de n files de 'processus prêts': fo, fi, ii,..., fn-i. A chaque file fi est associé
un quantum de temps qi dont la valeur croit avec le rang de la file. Un processus de la file fi n'est servi que si les files de rang inférieur à i
sont vides. Lorsqu'un processus de la file fi a épuisé son quantum de temps sans avoir terminé son exécution, il rentre dans la file fi+i. Les
processus de la dernière file (fn-i) sont recyclés dans la même file. Les nouveaux processus sont rangés dans la file fo. Cet algorithme
favorise les processus courts.
Remarque: Une autre variante de cet algorithme applique FCFS à la dernière file (f n-i).
Exemple d’application de cette technique :
Pour éviter qu'il y ait beaucoup de commutations pour les processus consommateurs de temps CPU, il est préférable d'allouer un
plus grand quantum à ces processus. Lorsqu'un processus passe à l'état élu : Pour la première fois, le processeur lui est alloué
pendant un quantum. Pour la seconde fois, le processeur lui est alloué pendant 2 quantum... Pour la Niéme fois, le processeur lui
est alloué pendant ( 2 puissance (N-1)) quantums .
Chaque processus a une priorité. Cette dernière dépend du nombre de quantum qui lui sera alloué lors de sa prochaine activation.
Les processus dont le nombre de quantum est le plus petit sont les plus prioritaires. Les processus prêts sont répartis selon leur
priorité dans des files (FIFO).
D'abord on fait l'élection du processus le plus prioritaire qui se trouve en tête de file. Lorsque l'exécution d'un processus est
suspendue pour la Nième fois, sa priorité est recalculée 2 puissance (N) puis il est inséré à la queue de la file appropriée.
Exemple : Considérons un processus qui doit effectuer des calculs pendant 100 quantum. Ce processus obtient successivement 1,
2, 4, 8, 16, 32 et 64 quantum. Mais il utilisera 37 des 64 derniers quantum. Le nombre de changements de contexte passe de 100
(cas du tourniquet) à 7. Le processeur passe moins de temps à commuter et a donc un meilleur temps de réponse. Surtout dans le
cas où la commutation nécessite des transferts sur disque.
Un processus qui descend de plus en plus dans les files à priorité s'exécute de moins en moins fréquemment et favorise ainsi les
processus courts en mode interactif. Pour ne pas défavoriser un processus qui s'était exécuté pendant assez longtemps avant de
devenir interactif, on peut lui attribuer la plus haute priorité dès qu'un retour chariot est tapé sur le terminal associé au processus
(les premières versions d'Unix utilisaient cette solution).
Ordonnancement à deux niveaux
Cet ordonnanceur se décompose en deux fonctions complémentaires : ordonnanceur haut niveau qui déplace les processus entre le
disque et la mémoire (mécanisme de SWAP ) , et ordonnanceur bas niveau qui alloue/retire le processeur aux processus résidant
en mémoire.
Lors d'une commutation, si le processus élu n'est pas en mémoire (swappé sur disque), il faut le charger en mémoire. Le temps de
commutation est alors deux à trois fois plus élevé que celui des processus qui se trouvent en mémoire centrale.
Pour éviter ces va-et-vient entre le disque et la mémoire lors d'une commutation, l'ordonnanceur à deux niveaux déplace les
processus entre le disque et la mémoire (haut niveau) et choisit le processus à exécuter parmi ceux qui sont en mémoire (bas
niveau). Périodiquement, l'ordonnanceur de haut niveau retire de la mémoire les processus qui y sont restés assez
longtemps (Swap Out ) et les remplace par des processus qui sont restés sur le disque pendant trop de temps (Swap In).
Pour élire un processus, l'ordonnanceur de bas niveau se restreint aux processus en mémoire.