UNIVERSITE AUBE NOUVELLE - ISIG INTERNATIONAL

Filière : Technologie des Réseaux et Systèmes

2ième année

COURS : SYSTEMES D’EXPLOITATION

Serge Landry SAWADOGO

Ingénieur des Réseaux et Systèmes Informatiques
Formateur Agrée Microsoft

1
CHAPITRE 2 : GESTION DES PROCESSUS

2
Table des matières
CHAPITRE 2 : GESTION DES PROCESSUS ........................................................................................ 2
OBJECTIFS DU COURS : ...................................................................................................................... 4
I. DEFINITIONS ET GENENRALITES ................................................................................................ 5
II. TYPES DE PROCESSUS ................................................................................................................. 8
II.1. Les processus interactifs ................................................................................................... 8
II.2. Les processus automatiques ........................................................................................... 9
II.3. Les daemons ....................................................................................................................... 9
III. LES ETATS D’UN PROCESSUS ................................................................................................ 10
IV. ORDONNANCEMENT DE PROCESSUS ............................................................................... 10
IV.1. Ordonnancement préemptif : ................................................................................. 10
IV.2. Ordonnancement non-préemptif :......................................................................... 10
V. QUELQUES ALGORITHMES D’ORDONNANCEMENT ........................................................... 11
V.1. FIFO (First In First Out) ou Premier arrivé, premier servi : ......................................... 11
V.2. Exécution du job le plus court en premier (Shortest Job First : STF) .................... 12
V.3. Exécution du temps restant le plus court (Shortest Remaining First : SRF) ........ 12
V.4. Ordonnancement de type tourniquet (Round Robin).......................................... 12
V.5. Ordonnancement par priorité...................................................................................... 13

3
OBJECTIFS DU COURS :

Donner aux étudiants les connaissances sur les systèmes d’exploitation, leurs
composants et leurs structures et leurs fonctionnalités de base.

A l’issue des enseignements, les étudiants devraient être capables de :

 Comprendre les architectures des systèmes d’exploitation
 Utiliser les techniques et stratégies de gestion mises en œuvre par les systèmes
d’exploitation.

4
 I. DEFINITIONS ET GENENRALITES

La conception d’un système d’exploitation est intimement liée à la notion de

processus. Un processus représente une abstraction d’un programme en cours
d’exécution. L’exécution d’un processus suppose l’utilisation de ressources machines.
Ces dernières étant limitées, l’intention d’y accéder à plusieurs crée la concurrence.

Mots-clés

Processus : Un processus est un programme en cours d’exécution

auquel est associé un environnement processeur (Compteur Ordinal,
Registre d’Etat, registres généraux) et un environnement mémoire
appelés contexte du processus

Ressource : Une désigne toute entité dont a besoin un processus pour

s’exécuter

Programme : C’est une suite ordonnée d’instructions élémentaires en

vue d’accomplir une tâche donnée.

Concurrence : Les faits que deux ou plusieurs processus concourent à

l’accès à une même ressource.

Ordonnancement : L’Ordonnancement est le fait d’agencer les

processus par ordre de priorité.

Interblocage : C’est un état qui se produit lorsque deux processus

concurrentes s’attendent mutuellement (l’un détenant la ressource que
l’autre a besoin)

Processus et Programme

5
Par définition, un processus est une abstraction d’un programme en cours
d’exécution. Le processus est représenté dans le système par un PCB (Process Control
Block), possède un état, peut communiquer des informations avec d’autres processus
et peut concourir avec d’autres processus pour l’obtention d’une ressource.

Conceptuellement, un processus modélise l’exécution d’un programme sur un

processeur virtuel disposant :

 D’un compteur ordinal ;

 D’un jeu de registre ;
 De mémoire ;
 etc.

Le processeur physique commute entre les processus sous la direction d’un

ordonnanceur.

Dans le cas de systèmes à temps partagé, tous les processus progressent dans le
temps, mais un seul s’exécute à la fois. Lorsque le processeur passe d’un processus à
un autre la vitesse de traitement de processus n’est pas uniforme, ni même
reproductible si le même processus s’exécutait une autre fois. Mais Quelle est la
différence entre un processus et un programme ?

L’analogie ci-dessous peut aider à mieux les différencier. Prenons un informaticien en

train de confectionner un gâteau d’anniversaire. Il dispose de :

 Une cuisine équipée ;

 La recette du gâteau ;
 Tous les ingrédients nécessaires : farine, œufs, etc.

Dans cette métaphore, la recette représente le programme, (algorithme exprimé

dans la notation appropriée), l’informaticien représente le processeur (l’unité
centrale) et les ingrédients sont des données d’entrée. Le processus est l’activité qui
consiste à confectionner le gâteau : lecture de la recette, mélange des ingrédients,
cuisson.

Soupons que notre informaticien se mette à hurler car piqué d’une guêpe. Son
cerveau enregistre le point où il s’est arrêté dans la préparation du gâteau (l’état dans
lequel le processus en cours est enregistré). Il commence à suivre les instructions de
premiers secours. De ce fait, le processeur bascule du processus (confection gâteau)

6
vers un autre processus de priorité supérieure (administrer antidote). Chaque
processus découle d’un programme différent (recette et brochure sur les premiers
soins). Une fois le problème de piqure résolu, l’informaticien retourne au point où il
avait laissé la préparation du gâteau. En résumé un processus est une activité. Il inclut
un programme, une entrée, une sortie et un état. Un processeur peut être partagé par
plusieurs processus à l’aide d’un algorithme d’ordonnancement intervenant pour
déterminer à quel moment arrêter de travailler sur un processus pour en servir un autre.

Les SE ont besoin de savoir que tous les processus nécessaires existent bel et bien. Le
SE doit permettre l’exécution concurrentielle de processus, et a besoin d’une
méthode pour créer, et arrêter les processus au cours de leur activité.

Il existe essentiellement quatre événements provoquant la création d’un processus :

 Initialisation du système : Lors de l’amorçage du SE, plusieurs processus sont

créés. Certains sont des processus de premiers plans (processus qui
interagissent avec l’utilisateur et accomplissent des tâches pour eux), d’autres
sont des processus d’arrière-plan, non associés à une utilisation particulière de
l’ordinateur. Ex : les processus d’arrière-plan conçu pour accepter les courriers
électroniques entrant, ceux conçus pour accepter les requêtes entrantes de
pages web hébergées sur l’ordinateur ; etc.

 Exécution d’un appel système de création de processus par un processus en

cours d’exécution : Un processus en exécution peut émettre des appels
systèmes pour créer un ou plusieurs nouveaux processus. Cela est
particulièrement utile lorsque la tâche à accomplir peut-être divisée en
plusieurs processus qui interagissent entre eux tout en étant indépendants.

 Requête utilisateur sollicitant la création d’un nouveau processus : Un nouveau

processus peut également être créé à la demande d’un utilisateur. Cela passe
par la saisie d’une commande ou dans le mode graphique le clic sur une icône.
Ces deux cas de figures lancent un nouveau processus qui exécute le
programme concerné.

7
  Initiation d’un travail en traitement par lots : Ce cas de figure concerne les gros
mainframes. Les utilisateurs peuvent soumettre des tâches de traitement par
lots au système. Lorsque le SE constate qu’il dispose des ressources nécessaires
à l’exécution d’un job supplémentaire, il crée un nouveau processus et exécute
le job suivant de la file d’attente.

Une fois qu’un processus a été créé, il commence à s’exécuter quelle que soit sa
tâche et il finira à s’arrêter pour diverses raisons :

 Arrêt normal (fin de la tâche qui leur incombait) ;

 Arrêt pour erreur (demande d’exécution d’un programme qui n’existe pas) ;
 Arrêt pour erreur fatale (bogue du programme) ;
 Le processus est arrêté par un autre processus.

II. TYPES DE PROCESSUS

II.1. Les processus interactifs

Les processus interactifs sont démarrés par l’utilisateur connecté au système. Ils sont
initialisés et contrôlés via une session terminale. Ces processus peuvent s’exécuter en
avant plan du terminal qui a lancé le programme. Dans ce cas aucune autre
application ne peut être lancée aussi longtemps que le processus est en train de
s’exécuter en avant plan.

Lorsque ces processus s’exécutent en arrière-plan, de nouvelles commandes peuvent

être acceptées par le terminal pendant l’exécution du programme. Lors de
l’exécution des programmes en arrière-plan, le système n’interdit pas l’utilisateur à
faire autre chose sur le terminal utilisé pour lancer le programme. Le job control du
noyau du SE offre une gestion aisée de plusieurs processus. Ce mécanisme fait passer
les processus de l’avant plan à l’arrière-plan. En utilisant ce système, des programmes
peuvent également être lancés immédiatement en arrière-plan.

8
II.2. Les processus automatiques

Les processus automatiques ou processus par lot sont des processus non connectés
au terminal. Ce sont plutôt de tâches mises dans une file d’attente pour être
exécutées. Cette file d’attente est gérée selon le mode du premier entré- premier sorti
(First in, First out : FIFO). De telles tâches sont exécutées selon les critères suivants :

 A une certaine période (date et heure)

 Au moment où le système est suffisamment moins occupé pour accepter

d’autres travaux (jobs) : exécutées en utilisant la commande par lot (batch
command). Par défaut les tâches sont mises dans une file dans laquelle elles
vont attendre l’exécution jusqu’au moment où le système de chargement est
en-dessous de 0.8. Dans les environnements plus larges, le traitement par lots
peut être privilégié lorsque de grandes quantités de données doivent être
traitées ou lorsque des tâches gourmandes en ressources sont en attente alors
que le système est suffisamment chargé. Le traitement par lots est aussi utilisé
dans l’optimisation des performances du système.

II.3. Les daemons

Les daemons sont des processus serveurs exécutés continuellement. La plupart de

temps, ils sont initialisés au démarrage du système et attendent en arrière-plan jusqu’à
ce qu’une demande de leur service soit faite. Un exemple est le daemon, xinetd,
démarré dans presque toutes les procédures de démarrage. Après le démarrage du
système, ce daemon réseau attend qu’un programme client, le client ftp par
exemple, ait besoin de se connecter.

9
III. LES ETATS D’UN PROCESSUS

Un processus peut prendre un de ces 3 états :

 En cours d’exécution (le programme utilise le processeur)

 Prêt (exécutable, temporairement arrêté pour laisser un autre processus)
 Bloqué (ne peut pas s’exécuter tant qu’un événement externe ne se produit
pas)

IV. ORDONNANCEMENT DE PROCESSUS

La fonction d’ordonnancement gère le partage du CPU entre les différents processus.

En effet, lorsque deux ou plusieurs processus sont dans un état prêt et qu’il n’y a qu’un
seul processeur, un choix doit être fait quant au prochain processus à exécuter. Cette
tâche revient à l’ordonnanceur. Pour ce faire il utilise un algorithme
d’ordonnancement. On distingue deux principales catégories d’ordonnancement :
l’ordonnancement préemptif et l’ordonnancement non-préemptif.

On peut dire que pour qu’il ait l’ordonnancement, il faut avoir un système
multiprogrammé c’est-à-dire plusieurs processus sont exécutés simultanément mais un
seul processus à la fois a accès au CPU.

IV.1. Ordonnancement préemptif :

C’est la sélection d’un processus qui s’exécute pendant un délai déterminé.

Si le processus est toujours en cours d’exécution après ces délais, il est suspendu et un
autre processus est choisi. L’ordonnancement préemptif nécessite une interruption à
la fin du délai afin de donner le contrôle du processeur à l’ordonnanceur.

IV.2. Ordonnancement non-préemptif :

Ici, on la sélection d’un processus qui s’exécute jusqu’à ce qu’il se bloque ou qu’il
libère volontairement le processeur. En effet aucune décision d’ordonnancement
n’intervient pendant les interruptions d’horloge. Une fois le traitement de l’interruption
terminé, le processus qui était en cours d’exécution avant l’interruption est toujours
relancé.

10
V. QUELQUES ALGORITHMES D’ORDONNANCEMENT

Il existe un certain nombre d’algorithmes d’ordonnancement très utilisés dans la

gestion des processus. Comme par exemple FIFO (FCFS : First Come First Serve),
Shortest Job First (SJF), Round Robin (Tourniquet), File de priorité, etc.

Les deux principaux facteurs qui permettent d’évaluer un algorithme

d’ordonnancement sont en générale : Le temps moyen d’attente (moyenne de tous
les temps d’attente) et le temps moyen d’exécution (moyenne de tous les temps
d’exécution).

V.1. FIFO (First In First Out) ou Premier arrivé, premier servi :

Il est sans doute le plus simple des algorithmes d’ordonnancement. Pour ce cas, les
processus se voient attribuer le temps processeur selon leur ordre d’arrivée. Il existe
une seule file d’attente des processus prêts. Le premier processus arrivé dans la file
d’attente est exécuté aussi longtemps qu’il le souhaite. Au fur et à mesure que les
autres jobs arrivent, ils prennent place dans la file d’attente. Lorsque le processus en
cours d’exécution se bloque, le processus suivant s’exécute. Quand il redevient prêt,
il est placé à la queue de la file d’attente comme si c’était un nouveau processus qui
arrive.

La grande force de cet algorithme est sa simplicité de mise en œuvre.

Malheureusement, le mécanisme du premier arrivé, premier sorti (First In First Out)
souffre d’un inconvénient majeur. Prenons un cas de figure dans lequel un processus
de traitement s’exécute à raison d’une seconde à la fois, et où de nombreux
processus d’Entrée-sortie (E/S) utilisent peu de temps processus, mais doivent chacun
effectuer 1.000 lectures disque pour se terminer. Le processus de traitement s’exécute
pendant une seconde, puis il lit un bloc de disque. Tous les processus d’E/S s’exécutent
alors et commencent à faire des lectures disque. Lorsque le processus de traitement
récupère son bloc de disque, il s’exécute encore une fois pendant une seconde, suivi
de tous les processus d’E/S en rapide succession.

11
Il en résulte que chaque processus d’E/S arrive à lire un bloc par seconde et prend 1
000 secondes pour se terminer. Avec un algorithme d’ordonnancement qui
préempterait le processus de traitement toutes les 10 millisecondes, les processus d’E/S
se termineraient en 10 secondes au lieu de 1 000, et ce sans ralentir le processus de
traitement de façon palpable.

V.2. Exécution du job le plus court en premier (Shortest Job First : STF)

Ici, les processus les plus courants sont exécutés en premier. Pas de notion de priorité,
c’est un algorithme non-préemptif qui suppose que les délais d’exécution sont connus
d’avance. Le principe consiste à choisir le processus dans le prochain cycle d’horloge
et le plus petit. Remarque : Cet algorithme demande une connaissance à priori de la
longueur du prochain cycle d’horloge du CPU. Cet algorithme existe en version avec
ou sans préemption.

V.3. Exécution du temps restant le plus court (Shortest Remaining First : SRF)

Ici, les processus dont le reste de temps d’exécution le plus court sont exécutés en
premier. Pas de file d’attente. C’est un algorithme préemptif qui nécessite de
connaître la durée des processus. Lorsqu’un nouveau job arrive, son temps total est
comparé au temps restant pour le processus en cours. Si le nouveau job a un temps
d’exécution plus court que celui en cours d’exécution, ce dernier est suspendu au
profit du nouveau processus. Cela favorise les services des jobs courts.

V.4. Ordonnancement de type tourniquet (Round Robin)

Le principe du Round Robin est que le CPU obtenu pour une durée limitée (un
quantum de temps prédéfinis). Un intervalle de temps d’exécution est accordé à
chaque processus (quantum). A la fin du quantum de temps, si le processus est en
cours d’exécution le processeur est préempté au profit d’un autre processus. Si le
processus a bloqué ou terminé avant la fin du quantum, le basculement du
processeur se fait naturellement.

12
V.5. Ordonnancement par priorité

Le principe consiste à associer au processus une priorité et choisir le processus donc,

la priorité est la plus élevée.

Une priorité peut se définir en fonction de :

 L’espace mémoire utilisé ;

 L’importance relative au processus ;
 Ou l’instant du dernier accès au CPU.

13