Systèmes d’exploitation des

ordinateurs

Gestion des Processus

ENIS – DGIMA – GI1

Fadoua DRIRA 1
 Plan
• Introduction

• Modèle de Von Neumann :Rappel

– Introduction
– Pseudo-Parallélisme

• Notion de processus
– Définitions
– Graphe d’états
– Processus vs thread

• Ordonnancement des processus

– Introduction
– Mécanisme de commutation
– stratégies préemptives vs non préemptives

• Coopération des processus = Communication et Synchronisation

– Introduction
– Outils de synchronisation
– Exemples

ENIS – DGIMA – GI1

Fadoua DRIRA 2
 Introduction

• Nous avons défini le système d'exploitation comme un logiciel destiné à

faciliter l'utilisation d'un ordinateur, puis comme un programme dont la
fonction principale est de déclencher l'exécution d'autres programmes.
Nous allons le définir maintenant comme un programme qui permet à un
ordinateur de faire plusieurs choses à la fois.

• Pour pouvoir élaborer et nuancer cette définition, et comprendre notamment

ce qu'elle comporte de paradoxe, il nous faut approfondir un peu notre
vision de l'ordinateur que nous avons défini comme un automate capable
d'effectuer des actions selon l'énumération qu'en donne le texte d'un
programme.

• Le modèle de fonctionnement de la plupart des ordinateurs actuels est basé

sur l’architecture de Von Neumann

ENIS – DGIMA – GI1

Fadoua DRIRA 3
 Modèle de Van Neumann : Rappel
Dans le modèle de von Neumann, les différents blocs fonctionnels sont :
• le processeur ou l’unité centrale constitué par l’unité de contrôle (cherche
les instructions en mémoire, les reconnaît et indique à l’UAL ce qu’elle doit
effectuer), l’unité arithmétique ou de traitement (assure les opérations
élémentaires que demande l’UC) et l’unité d’entrée/sortie.
• la mémoire qui stocke les informations et les programmes.
• le bus transfère les informations entre processeur/mémoire.

Figure : Structure de l'ordinateur

ENIS – DGIMA – GI1
Fadoua DRIRA 4
Modèle de Van Neumann:Pseudo-Parallélisme

• Un ordinateur conforme au modèle de von

Neumann exécute une instruction, et une seule, à
la fois (principe d'exécution séquentielle).

• Plusieurs programmes en mémoire

• Le processeur exécute les instructions tantôt pour

l’un tantôt pour l’autre

• Coté utilisateur , exécution en parallèle

• Coté Système, une Gestion complexe, difficile à
appréhender

Programme de supervision

ENIS – DGIMA – GI1

Fadoua DRIRA 5
Modèle de Van Neumann:Pseudo-Parallélisme

Figure : Concurrence et parallélisme

ENIS – DGIMA – GI1

Fadoua DRIRA 6
Modèle de Van Neumann:Pseudo-Parallélisme
La mise en œuvre d’un système multi-tâches implique que les processus puissent :

o s’exécuter comme s’ils étaient seuls sur la machine (monopole)

→Concurrence d’accès aux ressources
o Coopérer avec d’autres processus s’exècutant simultanément
→Communication
→Echange de données
→Nécessité de synchronisation

Les systèmes multi-tâches sont ainsi des exemples de systèmes concurrents

→ Les tâches sont en compétitions les unes par rapport aux autres pour
l’obtention des ressources physiques.

ENIS – DGIMA – GI1

Fadoua DRIRA 7
 Notion de processus : Définitions
• Programmes : Définition
– Les programmes sont des instructions informatiques écrites dans un langage de programmation
spécifique. Ils définissent des séquences d'opérations à effectuer par un ordinateur pour accomplir
une tâche particulière.
– Les programmes peuvent être de différentes tailles et complexités, allant des petits scripts aux
applications logicielles complètes.

• Programme : Ensemble de Modules Sources :

– Il s'agit de la collection des fichiers source qui contiennent le code écrit par un programmeur.
– Ces fichiers sont généralement écrits dans un langage de programmation lisible par l'humain et
doivent être traduits en langage machine par un compilateur ou un interpréteur pour être exécutés
par un ordinateur.

• Programme : Ensemble de Modules Objets :

– L'ensemble de modules objets comprend les fichiers résultant de la compilation des fichiers source.
– Ces fichiers contiennent le code binaire (représentation sous forme de 0 et de 1) qui peut être
exécuté directement par un ordinateur. Cependant, ils ne sont pas encore liés ensemble pour former
un programme exécutable complet.

• Programme : Résultat de l'édition de lien :

– L'édition de lien est le processus par lequel les modules objets sont combinés pour créer un
programme exécutable complet. Le résultat de l'édition de lien est un fichier exécutable ou une
application qui peut être lancée sur un ordinateur. C'est à ce stade que les références entre les
différents modules objets sont résolues, permettant au programme de fonctionner correctement.
ENIS – DGIMA – GI1
Fadoua DRIRA 8
 Notion de processus : Définitions
• Processus comme une entité dynamique :
– Un processus représente l'exécution d'une suite d'instructions de manière active.
– Un processus est une unité d'exécution qui peut être chargée dans la mémoire de
l'ordinateur et exécutée par le processeur.

• Processus comme un concept abstrait :

– D'un point de vue conceptuel, un processus est une abstraction; c'est une idée ou
un concept qui représente une tâche ou un programme en cours d'exécution.
– Chaque processus a sa propre mémoire, son propre espace d'adressage, et il
fonctionne comme s'il était le seul programme en cours d'exécution sur
l'ordinateur, même s'il partage les ressources avec d'autres processus.

• Le processeur fait évoluer le processus :

– Lorsqu'un processus est actif, le processeur est responsable de faire évoluer
l'exécution de ce processus. Cela signifie que le processeur exécute les
instructions du processus une par une, passant d'une instruction à l'autre.
– Le processus peut être mis en pause, relancé, interrompu, ou planifié pour
l'exécution en fonction de la gestion des processus du système d'exploitation.

ENIS – DGIMA – GI1

Fadoua DRIRA 9
 Notion de processus : Définitions

• Processeur comme entité matérielle :

– Un processeur est une entité matérielle d'un ordinateur capable d'exécuter des
instructions.
– Il est souvent appelé le "cerveau" de l'ordinateur, car il effectue les calculs et les
opérations nécessaires pour exécuter les programmes.
– Le processeur peut être considéré comme le composant principal qui exécute les
tâches de l'ordinateur, y compris le traitement des données et l'exécution des
programmes.

• Processeur comme entité logicielle :

– Parfois, le terme "processeur" peut également désigner une entité logicielle, telle
qu'un interpréteur ou un émulateur.
– Dans ce contexte, un processeur logiciel est un programme informatique qui
simule le comportement d'un processeur matériel.
– Par exemple, un émulateur de console de jeux vidéo peut inclure un processeur
logiciel qui permet d'exécuter des jeux conçus pour une console spécifique sur un
ordinateur.

ENIS – DGIMA – GI1

Fadoua DRIRA 10
 Notion de processus : Définitions

Système
- Les systèmes d'exploitation doivent être capables de différencier les différents
processus en leur attribuant des identifiants uniques, appelés identifiants de processus
(PID). Cela permet au système de suivre chaque processus de manière distincte et de
gérer ses ressources et son état de manière appropriée.

- Un système d'exploitation doit suivre et gérer l'état de chaque processus. Cela signifie
qu'il doit savoir si un processus est en cours d'exécution, en attente d'une ressource,
en attente de terminaison, ou dans d'autres états possibles. Cette représentation de
l'état des processus est essentielle pour la gestion des ressources et la prise de
décision.

ENIS – DGIMA – GI1

Fadoua DRIRA 11
 Notion de processus : Définitions

• État
– L'état d'un système d'exploitation fait référence à l'ensemble des informations
actuelles ou des conditions qui décrivent la situation d'un programme ou d'un
processus à un moment donné. Cela peut inclure la mémoire utilisée, les registres
du processeur, le contenu des variables, et d'autres informations nécessaires pour
reprendre l'exécution du programme à partir de cet instant.

• Localisation du programme (instructions)

– Il s'agit de la position actuelle dans le code d'un programme où son exécution est
en cours.
– Le système d'exploitation maintient généralement un compteur de programme
(program counter) qui pointe vers l'instruction actuellement exécutée.

• Données propres
– Les données propres font référence aux informations ou aux données spécifiques
à un processus ou à un programme donné.
– Chaque processus a son propre espace de mémoire où il stocke ses données
propres, qui ne sont généralement pas accessibles par d'autres processus sans
une synchronisation appropriée.
ENIS – DGIMA – GI1
Fadoua DRIRA 12
 Notion de processus : Définitions

• Variables
– Les variables sont des emplacements de mémoire utilisés pour stocker des
données temporaires ou des valeurs qui peuvent être modifiées pendant
l'exécution d'un programme. Les variables sont utilisées pour stocker des données
telles que des nombres, des chaînes de caractères, des résultats intermédiaires,
etc.

• Registre, dont le conteneur ordinal

– Les registres sont des emplacements de mémoire très rapides situés dans le
processeur lui-même. Ils sont utilisés pour stocker des données et effectuer des
opérations rapidement. Le "conteneur ordinal" peut faire référence à un registre
spécial utilisé pour stocker des informations sur l'état des opérations de
comparaison, généralement pour évaluer des conditions comme "plus grand",
"plus petit" ou "égal".

ENIS – DGIMA – GI1

Fadoua DRIRA 13
 Notion de processus : Exemple

• Informaticien fait un gâteau pour sa fille

– Programme => recette de cuisine
– Données entrées=>ingrédients
– Ressources nécessaires=>instruments
– Processeur => informaticien
– Processus=> activité de transformation des ingrédients en gâteau

• Fils de l’informaticien se fait piquer par une abeille

– Interruption de travail=> sauvegarde de l’état des processus
– Programme => livre de première urgence
– Processus=> soin à apporter, calmer son fils

• Reprise du travail de cuisinier

– Restitution de l’état du processus

ENIS – DGIMA – GI1

Fadoua DRIRA 14
 Notion de processus : Définitions

Les processus des utilisateurs sont lancés par un interprète de commande.

Ils peuvent eux-mêmes lancer ensuite d’autres processus.
On appelle le processus créateur, le père, et les processus créés, les fils.
Les processus peuvent donc se structurer sous la forme d’une arborescence.
Au lancement du système, il n’existe qu’un seul processus, qui est l’ancêtre
de tous les autres.
P1

P2 P3

P4 P5 P6

Figure: La hiérarchie des processus

ENIS – DGIMA – GI1

Fadoua DRIRA 15
 Notion de processus : Définitions

Création de processus
Une activité (sur votre PC) est réalisée lorsqu’il y a
• Initialisation du système
• Exécution d’un appel système provoquant la création d’un processus
• Activité de l’utilisateur qui provoque cette création

Terminaison de processus
Un arrêt est
• Volontaire (encodé)
• Involontaire (dû à une erreur fatale, dû à une demande)

ENIS – DGIMA – GI1

Fadoua DRIRA 16
 Notion de processus : Définitions

Implémentation du modèle de processus Identificateur processus

via une structure de données propre à Etat du processus
l’OS, soit:
Compteur instructions
o une table des processus, reprenant
une entrée par processus Contexte pour reprise
(registres et pointeurs,
piles,…)
o une entrée ou bloc de contrôle
Pointeur sur file d’attente et
→ PCB (Process Control bloc) est une priorité (ordonnancement)
fiche signalétique liée au processus Information mémoire
permettant au système d'exploitation Information sur les E/S,
de disposer des informations liées à périphériques alloués,
fichiers ouverts, ...
ce processus.
Figure : Bloc de contrôle de
processus PCB

ENIS – DGIMA – GI1

Fadoua DRIRA 17
 Notion de processus : Graphe d’état

Trois états sont possibles pour un processus:

• actif quand le processeur est en train

d'exécuter une de ses instructions.

→ Dans un système monoprocesseur, un

seul processus peut être actif à la fois ;

• bloqué quand il est en attente d'un

événement ou d’une synchronisation,

→ i.e. la fin d’une entrée-sortie ou plus

généralement en attente d’un autre
processus.

• prêt s’il n'est ni actif ni bloqué.

ENIS – DGIMA – GI1

Fadoua DRIRA 18
Notion de processus : Graphe d’état

ENIS – DGIMA – GI1

Fadoua DRIRA 19
Notion de processus : Graphe d’état

ENIS – DGIMA – GI1

Fadoua DRIRA 20
Notion de processus : Graphe d’état

ENIS – DGIMA – GI1

Fadoua DRIRA 21
 Notion de processus : Graphe d’état
Un processus est dit bloqué :
• si la prochaine instruction à exécuter se trouve dans une page non chargée en
mémoire centrale.
• Si pour un travail réalisé par coopération de processus, un processus est dans
l’attente d’un signal d’un autre processus. Par exemple, un processus P fait un calcul
et range le résultat dans le tampon, le processus Q est chargé d’imprimer le contenu
du tampon : le processus Q ne peut s’exécuter que lorsque P remplit le tampon.
• si chaque processus Pi est bloqué en attente d'une ressource détenue par un
processus Pj différent. Cette situation est le cas d'étreinte fatale. Aucun processus
n'est en mesure de progresser dans son exécution, sauf si une entité extérieure est
en mesure d'intervenir pour interrompre un des processus.

Processus P1 Processus P2
Allocation de la ressource A Allocation de la ressource B
Tentative d'allocation de la Tentative d'allocation de la
ressource B : échec, blocage ressource A : échec, blocage

ENIS – DGIMA – GI1

Fadoua DRIRA 22
 Processus vs thread

Processus :
• Un processus est un programme en cours d'exécution sur un système
d'exploitation.

• Chaque processus a sa propre mémoire et ses propres ressources, ce qui

signifie qu'ils sont isolés les uns des autres.

• Les processus sont lourds en termes de consommation de ressources, car

ils nécessitent une allocation séparée de la mémoire.

• Les processus communiquent entre eux via des mécanismes tels que les
sockets ou les signaux.

• En cas de défaillance d'un processus, les autres processus ne sont

généralement pas affectés.

ENIS – DGIMA – GI1

Fadoua DRIRA 23
 Processus vs thread
Google Chrome utilise une architecture multi-processus et multi-thread pour améliorer la
stabilité, la sécurité et les performances de votre navigation sur le Web. Cette
architecture offre de nombreux avantages, mais elle nécessite une gestion efficace des
ressources et de la mémoire. Chrome est conçu pour fonctionner de manière optimale
sur des systèmes disposant de plusieurs cœurs de processeur et d'une quantité
suffisante de mémoire vive (RAM).

Architecture multi-processus : Dans Chrome, chaque onglet, chaque extension et même

certains plug-ins s'exécutent dans des processus distincts. Cela signifie que chaque site
Web que vous ouvrez s'exécute dans un environnement isolé appelé "sandbox". Les
avantages de cette approche sont les suivants :

• Stabilité : Si un onglet ou un processus plante, cela n'affecte pas les autres onglets. Vous ne
perdez donc pas votre session de navigation complète.

• Sécurité : L'isolation des processus limite les attaques potentielles entre les onglets et les
extensions. Un site Web malveillant ou une extension corrompue ne peut pas accéder aux
données d'autres onglets ou compromettre la sécurité du navigateur.

• Performances : Même si chaque onglet s'exécute dans un processus distinct, Chrome gère
efficacement les ressources système. Ainsi, votre ordinateur peut profiter pleinement de ses
capacités multi-cœur.
ENIS – DGIMA – GI1
Fadoua DRIRA 24
 Processus vs thread
Google Chrome utilise une architecture multi-processus et multi-thread pour améliorer la
stabilité, la sécurité et les performances de votre navigation sur le Web.

Architecture multi-thread : À l'intérieur de chaque processus, Chrome utilise des threads

pour gérer différentes tâches. Voici quelques exemples de threads couramment utilisés :

• Thread principal (Main Thread) : C'est le cœur du navigateur. Il gère l'interface utilisateur, le
chargement des onglets, la gestion des entrées utilisateur et de nombreuses autres tâches
importantes.

• Rendu des threads (Rendering Threads) : Chaque onglet possède un ou plusieurs threads de
rendu pour afficher le contenu Web. Cela inclut le traitement du HTML, CSS, JavaScript, etc.

• Thread de réseau (Network Thread) : Il gère les communications réseau, les téléchargements de
contenu et les requêtes vers les serveurs.

• Thread de GPU (GPU Thread) : Chrome utilise le processeur graphique (GPU) pour accélérer le
rendu des pages web. Le thread GPU gère ces opérations.

• Autres threads : Il existe de nombreux autres threads dédiés à des tâches spécifiques, comme la
gestion des extensions, la gestion des signets, etc.
ENIS – DGIMA – GI1
Fadoua DRIRA 25
 Processus vs thread
La manière dont un logiciel antivirus gère l'analyse de fichiers peut varier d'une solution à
l'autre. Certains antivirus peuvent utiliser un thread unique pour gérer l'analyse, tandis
que d'autres peuvent opter pour une approche multithread pour une analyse plus rapide.
Le but est d'accélérer l'analyse de fichiers, d'utiliser efficacement les ressources de
l'ordinateur et de garantir une réactivité continue tout en maintenant la protection contre
les menaces.
• Analyse multithread des fichiers : Lorsqu'Avast analyse des fichiers, il peut utiliser plusieurs
threads pour analyser plusieurs fichiers en même temps. Cela accélère le processus d'analyse,
car plusieurs fichiers peuvent être vérifiés simultanément, plutôt que de manière séquentielle.

• Mises à jour de la base de données de virus : Les antivirus doivent régulièrement mettre à jour
leur base de données de virus pour détecter les menaces les plus récentes. Cette mise à jour
peut être effectuée dans un thread séparé pour éviter d'interrompre les analyses en cours.

• Surveillance en temps réel : Les antivirus surveillent continuellement l'activité du système à la

recherche de comportements suspects. Cette surveillance peut être effectuée en temps réel grâce
à l'utilisation de threads dédiés.

• Interface utilisateur : L'antivirus a généralement une interface utilisateur avec laquelle l'utilisateur
interagit. Les actions de l'interface utilisateur, telles que le lancement d'une analyse, peuvent être
gérées dans un thread distinct
ENIS – DGIMA – GI1
Fadoua DRIRA 26
 Ordonnancement : introduction

o L'ordonnanceur (scheduler) est la partie du système qui gère la commutation

entre processus : ensemble de procédures, module (sous-système)…

o L'ordonnanceur se décompose en deux parties : la partie basse : mécanisme

de commutation entre les processus, la partie haute : le choix du processus à
activer parmi l’ensemble des processus prêts

o Objectifs de l'ordonnanceur : efficacité de la commutation (minimiser le temps

système) satisfaction des utilisateurs (minimiser le temps de réponse)

ENIS – DGIMA – GI1

Fadoua DRIRA 27
Ordonnancement : introduction

ENIS – DGIMA – GI1

Fadoua DRIRA 28
 Ordonnancement : Introduction

Objectifs d’ordonnancement

1. Maximiser le nombre de processus exécutés par unité de temps.

2. Minimiser le temps d’attente d’exécution de chaque processus.
3. Maximiser les temps d’utilisation des processeurs et autres ressources.
4. Respecter les échéanciers (terminer l’exécution avant leurs deadlines).
5. Éviter le problème de famine (attente infinie).
6. Favoriser les processus les plus prioritaires (éviter le problème d’inversion
des priorités).
7. Minimiser le nombre et la durée des changements de contexte.

Difficile de les satisfaire à la fois (exemple objectifs 1 et 4).

Prioriser les objectifs.

ENIS – DGIMA – GI1

Fadoua DRIRA 29
 Ordonnancement : Introduction

Objectifs d’ordonnancement : Critères de performances :

– Temps de séjour d’un processus (temps de rotation ou de virement) :

temps entre l’admission du processus et sa sortie.
– Temps d'attente d’un processus : somme des périodes que le
processus passe à l'état prêt
– Temps de réponse: temps qui s'écoule entre l'entrée d'un processus et
le moment où il commence à être traité
– Capacité de traitement : nombre de processus traités par unité de
temps.
– Taux d’utilisation d’un processeur.

ENIS – DGIMA – GI1

Fadoua DRIRA 30
 Ordonnancement : Introduction

Politique d’ordonnancement

• Choix du processus à exécuter ?

– Premier arrivé, premier servi.
– Plus prioritaire (priorités statiques ou dynamiques).
– Plus court temps ….

• Le temps d’allocation du processeur au processus choisi :

– Allocation jusqu’à terminaison ou libération volontaire (ordonnanceur non
préemptifs).
– Temps d’allocation limité fixe ou variable (ordonnanceur préemptifs).

• Quand appeler l’ordonnanceur ?

– Le processus en cours se termine, se bloque on cède le processeur,
– Le temps alloué a expiré.
– L’arrivée d’un processus plus prioritaire…

ENIS – DGIMA – GI1

Fadoua DRIRA 31
Ordonnancement :Mécanisme de commutation

Commutation de contexte :

– Cette opération, préalable au changement de processus actif (le

basculement de l'activité, entre deux processus), est l'enchaînement
indivisible des deux opérations suivantes:

• rangement du mot d'état du processus actif à un emplacement

particulier de la mémoire et copie du contexte du processus.

• chargement du mot d'état d'un autre processus, depuis un

emplacement spécifique de la mémoire, vers le processeur et
récupération du contexte du processus correspondant.

ENIS – DGIMA – GI1

Fadoua DRIRA 32
Ordonnancement :Mécanisme de commutation

Figure : Mise en œuvre de la commutation

ENIS – DGIMA – GI1
Fadoua DRIRA 33
Ordonnancement :Mécanisme de commutation
• La commutation de contexte ne peut être effectuée que lorsque le
processeur se trouve dans un état observable, c'est à dire entre deux
instructions. Le temps d'exécution de ces instructions élémentaires
représente le quantum de temps minimum pendant lequel le processeur ne
peut être stoppé. Les points d'arrêt sont donc les instants entre les
instructions. Ils sont désignés sous le nom de point interruptible.

• La commutation de contexte est liée à l'état d'un certain nombre

d'indicateurs que le processeur doit consulter en chacun de ces points
interruptibles. On distingue deux mécanismes de commutation de contexte,
suivant la signification de ces indicateurs :
– Interruptions
– Déroutements, appels au superviseur

ENIS – DGIMA – GI1

Fadoua DRIRA 34
Ordonnancement :Mécanisme de commutation
• Les interruptions :

– signaux envoyés de façon asynchrone au processeur qui le forcent à

suspendre l'activité en cours au profit d'une autre.
– La source d’interruption peut être un contrôleur d'entrées-sorties ou +
tout autre dispositif physique externe. Le programme en cours Erreurs
d'exécution suspend son activité au premier point interruptible. matérielles
– Les causes d'interruption sont multiples mais chaque interruption lui Horloge
est affectée une priorité différente, le SE traite l’interruption la plus Requêtes
prioritaire. disque
– Par convention le niveau de priorité le plus élevé est 0. Requêtes
– La priorité décroît lorsque sa valeur augmente. réseau

– La hiérarchie des interruptions dans un système d'exploitation (SE) Terminaux

est un concept qui définit l'ordre de priorité des interruptions Interruptions
matérielles et logicielles gérées par le SE. Cette hiérarchie garantit logicielles
que les interruptions importantes sont traitées en premier, tandis que -
les moins critiques sont mises en attente si nécessaire. Figure :Hiérarchie
des interruptions

ENIS – DGIMA – GI1

Fadoua DRIRA 35
Ordonnancement :Mécanisme de commutation

Déroutements, appels au superviseur :

– ils sont déclenchés par une cause interne au programme en cours, à la différence
des interruptions qui sont d'origine externe, autre processus ou par le matériel.
– Ils sont synchrones parce que le processeur ne les produit qu'après avoir terminé
l'exécution d'une instruction.
– Un déroutement se produit, en particulier, lorsqu'un programme effectue une
opération interdite, comme dans le cas de débordement de tableaux hors de la
zone d'adresses allouée au programme, lorsque des données sont incorrectes,
division par zéro par exemple, ou lorsque l'instruction ne correspond pas à un
code exécutable.
– Un appel au superviseur provoque toujours une commutation de contexte pour
faire appel à la commande appropriée. Il déclenche des mécanismes de sécurité
qui interdisent les opérations illicites afin de préserver l'intégrité du fonctionnement
de la machine.

ENIS – DGIMA – GI1

Fadoua DRIRA 36
Ordonnancement : préemptif/nonpréemptif

Les moments d’une prise de décision pour le choix d’un autre

processus à exécuter sont les suivants:

1. Il y a demande d’opération d’E/S, ou demande d’une ressource non

disponible, par le processus en cours d’exécution et celui-ci se bloque.
2. Une interruption intervient et doit être gérée.
3. Un nouveau processus est créé.
4. L’exécution du processus qui détenait le CPU est terminée.

ENIS – DGIMA – GI1

Fadoua DRIRA 37
Ordonnancement : nonpréemptif

ENIS – DGIMA – GI1

Fadoua DRIRA 38
Ordonnancement : nonpréemptif

ENIS – DGIMA – GI1

Fadoua DRIRA 39
Ordonnancement : nonpréemptif

ENIS – DGIMA – GI1

Fadoua DRIRA 40
Ordonnancement : préemptif

ENIS – DGIMA – GI1

Fadoua DRIRA 41
Ordonnancement : préemptif

ENIS – DGIMA – GI1

Fadoua DRIRA 42
Ordonnancement : préemptif

ENIS – DGIMA – GI1

Fadoua DRIRA 43
Ordonnancement : préemptif

ENIS – DGIMA – GI1

Fadoua DRIRA 44
Ordonnancement : préemptif

ENIS – DGIMA – GI1

Fadoua DRIRA 45
Ordonnancement : préemptif

ENIS – DGIMA – GI1

Fadoua DRIRA 46
Ordonnancement : préemptif

ENIS – DGIMA – GI1

Fadoua DRIRA 47
 Ordonnancement : préemptif

Ordonnanceur à priorité avec files multiples : 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 (priorité dynamique) et augmente progressivement celles des
processus en attente.
– 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é en queue de file correspondant à
sa nouvelle priorité.
– Pour favoriser les processus qui font beaucoup d’E/S, ils doivent acquérir le
processeur dès qu’ils le demandent, afin de leur permettre de lancer leurs
requêtes suivantes d’E/S.
– 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 (quantum variable).

ENIS – DGIMA – GI1

Fadoua DRIRA 48
 Ordonnancement : préemptif

Dans l’algorithme d’ordonnancement par files multiples, les

paramètres suivants doivent être définis:
– Le nombre de niveaux
– Les algorithmes de sélection utilisés pour sélectionner un processus à
l’intérieur de chaque file
– La ou les conditions qui vont provoquer un passage d’un processus
dans un niveau inférieur ou supérieur
– Le fait que l’arrivée d’un processus dans un niveau supérieur préempte
ou non un processus d’un niveau inférieur
– Le mécanisme pour déterminer dans quel niveau se situe un nouveau
processus

ENIS – DGIMA – GI1

Fadoua DRIRA 49
 Coopération : Introduction
Coopération = synchronisation + communication

• Interactions inévitables entre entités

– Volontaire : résolution collective d’un problème
– Involontaire : utilisation concurrente de ressources
• En l’absence d’interaction
– Exécution dans n’importe quel ordre donc, possibilité de (pseudo)
parallélisme
• En présence d’interactions
– Nécessité de synchroniser
– Influer sur l’ordre dans lequel elles s’exécutent
– L’exclusion mutuelle est une forme de synchronisation involontaire, qui
sérialise l’exécution des Sections Critiques: force l’exécution en série

ENIS – DGIMA – GI1

Fadoua DRIRA 50
 Coopération : Introduction

• Exclusion mutuelle :
– Dès qu’un processus a commencé à exécuter du code qui manipule
une ressource partagée, il exclut de fait les autres: ils ne doivent pas
pouvoir atteindre la portion de leur code dans laquelle ils utilisent aussi
cette même ressource
– On appelle section critique la partie d'un programme où la ressource est
seulement accessible par le processus en cours. Les processus dans
ce cas sont en exclusion mutuelle.
• Synchronisation conditionnelle :
– Une certaine condition doit être vérifiée pour que l’exécution d’un
processus puisse progresser : la condition porte en général sur l’état
d’une ressource et on espère qu’une exécution concurrente rende la
condition vraie

ENIS – DGIMA – GI1

Fadoua DRIRA 51
 Coopération : Introduction

Figure : Synchronisation : Les symboles S indiquent les points de

synchronisation nécessaires et le sens de celle-ci. P envoie un message à Q
pour lui demander d'attendre pendant que lui-même remplit le tampon.

• La synchronisation revient à imposer des contraintes aux deux

processus de l’exemple ci-dessus :
– précédence des processus : Q ne peut lire que si P a écrit.
– conditions de franchissement de certains points critiques : P ne peut
écrire à nouveau que si Q a terminé le transfert.
ENIS – DGIMA – GI1
Fadoua DRIRA 52
 Coopération : Introduction

• Certaines propriétés doivent être vérifiées pour toute solution au

problème d’exclusion mutuelle:
– A tout instant, un processus au plus peut se trouver en section
critique.
– Aucun blocage mutuel des processus ne doit durer indéfiniment. Si
plusieurs processus sont bloqués en attente de la ressource critique
alors qu’aucun ne se trouve en SC, l’un d’eux doit pouvoir entrer au
bout d’un temps fini.
– Si un processus est bloqué hors sa SC, ce blocage ne doit pas
empêcher l’entrée d’un autre processus en sa SC.
– La solution doit être la même pour tous les processus, c’est-à-dire
qu’aucun processus ne doit jouer de rôle privilégié.

ENIS – DGIMA – GI1

Fadoua DRIRA 53
 Coopération : Introduction

Une instruction de type exclusion mutuelle se décompose en 3 étapes :

Début
Entrée
Section critique
Sortie
Fin
– Les deux procédures Entrée et Sortie ont donc pour objet de contrôler
l’obtention et la libération du droit d’accès en exclusion mutuelle par un
processus donné.
– Plusieurs schémas de réalisation d’exclusion mutuelle sont possibles.

ENIS – DGIMA – GI1

Fadoua DRIRA 54
 Coopération : outils de synchronisation

• Doivent permettre de faire attendre

– L’occurrence d’un événement particulier qui permettrait d’arrêter
d’attendre
– Evénement qui pourrait être notifié par un signal : attente active
– De préférence de manière passive
• Sémaphore : disponibilité d’un jeton
• Variable de condition de Moniteur : réveil car condition change
• Attente bloquante sur réception de message
– De permettre l’échange d’informations
• Interaction volontaire = besoin d’échanger une information (en général)
• Variable partagée, lue ou écrite
• Fichier dans lequel on lit ou écrit
• Contenu d’un message émis puis reçu

ENIS – DGIMA – GI1

Fadoua DRIRA 55
 Coopération : outils de synchronisation
Solution avec attente active
• Cette solution consiste à déclarer une variable p accessible par les
processus, de valeur 1 ou 0 suivant que la ressource est occupée ou non ;
un processus doit consulter p pour pouvoir entrer en section critique et
remettre p à 0 en sortant. Cette solution fait appel à une instruction spéciale
Test And Set (TAS) agissant sur une variable p

Instruction TAS(p)
début
Bloquer l’accès à la
cellule de mémoire p ;
Lire le contenu de p ;
si p=0 alors
Début
p :=1 ;
Fin
Libérer l’accès à la
cellule de mémoire p ;
fin
ENIS – DGIMA – GI1
Fadoua DRIRA 56
 Coopération : outils de synchronisation
Solution avec attente active
• L’emploi de TAS (solution matérielle) conduit à la solution suivante :

ENIS – DGIMA – GI1

Fadoua DRIRA 57
 Coopération : outils de synchronisation
Solution avec attente active

• Pour cette solution, tant que la SC n’est pas libre, le processus bloqué sur p
boucle sur l’instruction de test et monopolise un processeur en attendant la
libération de p, d’où le nom d’attente active. Cette solution est acceptable
dans un système multiprocesseur si l’exclusion mutuelle survient rarement
et dure peu.

• Sur une machine multi-processeurs à mémoire partagée, plusieurs

exécutions de TAS peuvent s’entrelacer => L’Exclusion Mutuelle n’est plus
garantie =>Remède (matériel aussi) : verrouillage du bus mémoire pendant
l’instruction TAS

• Solutions avec attente active gourmandes en temps CPU

ENIS – DGIMA – GI1

Fadoua DRIRA 58
 Coopération : outils de synchronisation
Solution avec les verrous

• Le verrou est un objet sur lequel sont définies deux méthodes verrouiller et
déverrouiller et un attribut qui est une liste des processus en queue
d’attente.
• Verrouiller : bloque un processus en queue si la SC est déjà occupée.
• Déverrouiller : débloque le processus en tête de la liste.
• Si un processus ne peut pas entrer en SC, il entre dans la file d’attente ;
lorsqu’un processus sort de la SC, un des processus de la file d’attente est
activé.
– verrouiller(p) : si p=0 alors p :=1 sinon mettre le processus dans la file d’attente
f(p), ce qui le fait passer à l’état bloqué
– déverrouiller(p) : si f(p) n’est pas vide alors sortir un processus de f(p) ce qui le
rend actif sinon p :=0 ;

ENIS – DGIMA – GI1

Fadoua DRIRA 59
 Coopération : outils de synchronisation
Solution avec les sémaphores

• Un sémaphore s est un verrou généralisé.

– Verrouiller est remplacée par une opération appelée P(s) et l’opération
déverrouiller par V(s). P et V sont des SC.
– Le sémaphore contient une variable e(s) (notée valeur du sémaphore) qui peut
prendre des valeurs entières positives, négatives ou nulles. Si e <= 0, alors la
valeur absolue | e | représente le nombre de processus dans la queue du
sémaphore.

ENIS – DGIMA – GI1

Fadoua DRIRA 60
 Coopération : outils de synchronisation
Solution avec les sémaphores

// on suppose que le processus r est // on suppose que le processus q est celui

celui qui sera placé à la file d’attente f(s) qui sera retiré de la file d’attente f(s)

P(s) : Début V(s) : Début

e(s) :=e(s)-1 ; e(s) :=e(s)+1 ;
si e(s)<0 alors si e(s)<=0 alors
Début Début

état(r) :=bloqué; sortir q de f(s);

mettre r dans f(s); état(q) :=actif;

Fin Fin
Fin
Fin

ENIS – DGIMA – GI1

Fadoua DRIRA 61
 Coopération : outils de synchronisation
Solution avec les sémaphores

Propriétés des sémaphores :

un sémaphore ne peut pas être initialisé à une valeur négative mais il peut
devenir négatif après un certain nombre d’opérations P.
Soit np(s) le nombre d’instructions P exécutées sur le sémaphore s
nv(s) le nombre d’instructions V exécutées sur le sémaphore s
e0(s) la valeur initiale du sémaphore s
 e(s)= e0(s) - np(s) + nv(s)

ENIS – DGIMA – GI1

Fadoua DRIRA 62
 Coopération : outils de synchronisation
Solution avec les sémaphores

Sémaphores d’exclusion mutuelle

• Une exclusion mutuelle se résout par un sémaphore mutex initialisé à 1 selon le
programme suivant :
début
P(mutex)
Section critique
V(mutex)
Suite d’instructions
Fin
• Pour établir la validité de cette solution, il faut montrer :
- qu’à tout instant, un processus au plus se trouve dans sa SC.
- que lorsqu’aucun processus ne se trouve dans sa SC, l’entrée en SC se fait au d’un
temps fini.

ENIS – DGIMA – GI1

Fadoua DRIRA 63
 Coopération : outils de synchronisation
Solution avec les moniteurs

• Sémaphores  gère bien l’exclusion mutuelle, mais en cas de problème de

programmation ou de synchronisation : risques d’interblocage.
• Les moniteurs sont proposés comme une structure de synchronisation de plus
haut niveau pour faciliter l’écriture de programmes corrects.
• Ils simplifient la mise en place de sections critiques
• Ils sont définis par
-des données internes (appelées aussi variables d'état)
-des primitives d'accès aux moniteurs (points d'entrée)
- wait : qui libère l'accès au moniteur et bloque le processus appelant sur une condition
- signal : qui réveille sur une condition un des processus en attente à l'intérieur du moniteur (un
wait sur la même condition)

ENIS – DGIMA – GI1

Fadoua DRIRA 64
Coopération : outils de synchronisation
Solution avec les moniteurs

-des primitives internes (uniquement accessibles depuis l'intérieur du moniteur)

-une ou plusieurs files d'attente

Type m = moniteur
Début
Déclaration des variables locales (ressources partagées);
Déclaration et corps des procédures du moniteur (points d’entrée);
Initialisation des variables locales;
Fin

ENIS – DGIMA – GI1

Fadoua DRIRA 65
Coopération : outils de synchronisation
Solution avec les moniteurs
• Moniteur = { variables globales + sections critiques d’un même problème}
• Pour assurer l’exclusion mutuelle, à tout moment un processus au plus est
actif dans le moniteur.
• Si un processus est actif dans le moniteur et un autre demande à y accéder
(appel une procédure du moniteur), ce dernier est mis en attente.
• C’est le compilateur qui se charge de cette tâche. Pour ce faire, il rajoute au
moniteur le code nécessaire pour assurer l’exclusion mutuelle.
• Cette solution est plus simple que les sémaphores et les compteurs
d’événements, puisque le programmeur n’a pas à se préoccuper de contrôler
les accès aux sections critiques.
• La majorité des compilateurs utilisés actuellement ne supportent pas les
moniteurs (à l’exception de JAVA).
ENIS – DGIMA – GI1
Fadoua DRIRA 66
Coopération : outils de synchronisation
Solution avec les messages
Pour communiquer, deux processus peuvent utiliser la communication
directe (type téléphonique) ou la communication indirecte (type poste).

Communication directe
• Les processus désirant communiquer sont explicitement nommés :
- Envoyer(destination, message)
- Recevoir(source, message)
Propriétés :
- Une liaison est affectée à exactement 2 processus.
- Les processus communicants doivent être nommés
- Il existe au plus une liaison entre chaque paire de processus
- La liaison est en général bidirectionnelle
- Chaque processus voulant communiquer n’a besoin de connaître que
l’identité de celui avec lequel il veut communiquer.
ENIS – DGIMA – GI1
Fadoua DRIRA 67
Coopération : outils de synchronisation
Solution avec les messages
Communication indirecte :
• Messages envoyés et reçus dans des boîtes aux lettres.
• Deux processus peuvent alors communiquer à partir du moment qu’il
partagent une boîte aux lettres.
Primitives de communication :
- Envoyer(A, message) : Envoie un message dans la boite aux lettres
- Recevoir(A, message) : Retire un message de la boite aux lettres A
Propriétés:
- Une liaison n’est établie entre 2 processus que s’ils partagent une boîte
aux lettres
- Il peut exister plusieurs liaisons (boîtes aux lettres) entre 2 processus
- Une boîte aux lettres peut être partagée par plus que 2 processus
- La liaison peut-être soit unidirectionnelle, soit bidirectionnelle.

ENIS – DGIMA – GI1

Fadoua DRIRA 68
 Coopération : Exemples
Problème des producteurs/consommateurs

Ce problème permet de représenter les principaux problèmes de communication entre

processus par accès à des variables communes avec synchronisation. Soient deux
processus, le producteur et le consommateur, qui se communiquent de l’information à
travers une zone de mémoire, dans les conditions suivantes :
• La zone mémoire commune ou tampon a une capacité de n messages (n>0).
• Le tampon est géré comme une file circulaire ayant deux pointeurs (un pour les
dépôts et l’autre pour les retraits).

L’activité des deux processus se déroule schématiquement suivant le schéma suivant :

Producteur //dépose des informations dans le tampon
ip=0 ;
Prod : Produire_un_message;
S’il y a au moins une entrée libre dans le tampon
Alors
début
Déposer_message(ip);
ip=(ip+1)%N ;
fin
Sinon
Attendre jusqu’à ce qu’une entrée se libère ;
Aller à Prod ; ENIS – DGIMA – GI1
Fadoua DRIRA 69
 Coopération : Exemples
Problème des producteurs/consommateurs

Consommateur //retire les informations déposées

ic=0 ;
Cons : S’il y a au moins une entrée occupée dans le tampon
Alors
début
Consommer_message(ic);
ic=(ic+1)%N ;
fin
Sinon
Attendre jusqu’à ce qu’une entrée devienne occupée ;
Aller à Cons

On souhaite que la communication se déroule suivant les règles suivantes :

• le producteur ne peut pas placer un message dans le tampon si celui-
ci est plein : le producteur doit alors attendre ;
•le consommateur doit prélever un message une fois et une seule
• si le producteur est en attente parce que le tampon est plein, il doit
être prévenu dès que cette condition cesse d’être vrai, il en est de
même pour le consommateur pour la condition « tampon vide »
ENIS – DGIMA – GI1
Fadoua DRIRA 70
 Coopération : Exemples
Problème des producteurs/consommateurs

ENIS – DGIMA – GI1

Fadoua DRIRA 71
 Coopération : Exemples
Problème des producteurs/consommateurs

3 sémaphores :

• plein: compte le nombre de places occupées, aucun emplacement n’est occupé au début.
• vide : compte le nombre de places libres, la file est toute vide au début.
• mutex : assure que le producteur et le consommateur n'accèdent jamais en même moment
à la mémoire tampon : sémaphore d’exclusion mutuelle, initialisé à 1 (un seul processus en
section critique)

On suppose que le tampon possède deux pointeurs l’un (noté queue) qui pointe sur la
première case vide, l’autre (noté tête) pointe sur la première case contenant un message à
prélever. Les messages sont consommés dans l’ordre de leur apparition.

ENIS – DGIMA – GI1

Fadoua DRIRA 72
 Coopération : Exemples
Problème des producteurs/consommateurs
Contexte commun : Sémaphore plein :=0, vide :=N , mutex:=1 ; entier ip=0,ic=0 ;
Processus Producteur :
Prod : Produire_objet() ; /*Produire objet*/
P(vide) ; /*Besoin d’une place vide*/
P(mutex) ; /*Bloquer la file*/
Déposer_message(o,ip); /*Mettre l’objet en file */
ip :=(ip+1)%N ;
V(mutex) ; /*Libération de la file */
V(plein) ; /*Un objet à prendre*/
Aller à Prod ;

Processus Consommateur :
Cons: P(plein) ; /* Attente d’un objet*/
P(mutex) ; /*Bloquer la file */
Retirer_objet(o,ic) ; /*Consommer l’objet courant*/
ic=(ic+1)%N ;
V(mutex) ; /*Libération de la file */
V(vide) ; /*Une place à prendre*/
Aller à Cons ;
ENIS – DGIMA – GI1
Fadoua DRIRA 73
 Coopération : Exemples
Problème des lecteurs/rédacteurs
Ce problème schématise la situation rencontrée dans la gestion des fichiers
partageables. Dans ce modèle, on considère des processus parallèles divisés en
deux classes : les lecteurs et les rédacteurs. Ces processus peuvent se partager
une ressource unique : le fichier. Ce fichier peut être lu simultanément par plusieurs
lecteurs tandis que les rédacteurs doivent y avoir un accès exclusif (un seul
rédacteur peut y écrire et aucun lecteur ne peut lire pendant ce temps).

Le programme des lecteurs et des rédacteurs est donné par :

Lecteurs Rédacteurs
demande de lecture ; demande d’écriture ;
lecture ; écriture ;
fin de lecture ; fin d’écriture ;

ENIS – DGIMA – GI1

Fadoua DRIRA 74
 Coopération : Exemples
Problème des lecteurs/rédacteurs
Les procédures demande d’écriture et fin d’écriture devront assurer l’exclusion mutuelle entre
deux rédacteurs. Les procédures demande de lecture et fin de lecture doivent assurer les
règles de coopération entre la classe des lecteurs et la classe des rédacteurs.
On suppose que les lecteurs sont prioritaires par rapport aux rédacteurs : le seul cas où un
lecteur doit attendre est celui où un rédacteur occupe le fichier. Un rédacteur ne peut accéder
au fichier que si aucun lecteur n’est en attente ou en cours de lecture.

entier nl=0 ; // le nombre de lecteurs occupant le fichier

sémaphore mutex1=1, //sémaphore d’exclusion mutuelle pour tous les lecteurs. Si un
// lecteur est bloqué sur w, tous les lecteurs le seront par mutex1,
//protège le compte de lecteurs nl
mutex2=1, //permet de garantir la priorité des lecteurs, sans mutex2 on
//pourrait avoir plusieurs rédacteurs en attente sur w, avant le
//premier lecteur bloqué par w
w=1 ; //sémaphore d’exclusion mutuelle pour tous les rédacteurs. Il sert
//au premier lecteur qui occupe le fichier et au dernier qui le libère
ENIS – DGIMA – GI1
Fadoua DRIRA 75
 Coopération : Exemples
Problème des lecteurs/rédacteurs

Processus lecteurs
début
P(mutex1) ;
nl:=nl+1 ;
Si (nl =1) //S’il y a un premier lecteur,
alors P(w) ;// verrouiller l’accès au fichier

V(mutex1) ; // fin section critique

Lire ;
P(mutex1) ; //section critique
nl:=nl-1 ; //lecteur de moins
Si (nl =0) // Pour le dernier lecteur
alors V(w) ; //déverrouiller le fichier
V(mutex1) ; // fin section critique
fin

ENIS – DGIMA – GI1

Fadoua DRIRA 76
 Coopération : Exemples
Problème des lecteurs/rédacteurs

Processus rédacteurs
début
P(mutex2) ;
P(w) ;
…
Ecrire ;
…
V(w) ;
V(mutex2) ;

fin

ENIS – DGIMA – GI1

Fadoua DRIRA 77
 Coopération : Exemples
Problème des philosophes
• Il s'agit d'un problème largement utilisé pour illustrer les problèmes posés par le
partage de ressources en programmation parallèle.
• Ce problème est usuellement décrit comme suit.
– Un certain nombre (soit 5) de philosophes sont assis autour d'une table circulaire.
– Chaque philosophe partage son temps entre deux activités : penser et manger.
– Pour penser le philosophe n'a besoin de rien, pour manger il lui faut des couverts.
– Or, la table est dressée de façon très particulière : entre chaque paire d'assiettes ne
se trouve qu'une fourchette.
– Un philosophe lui faut deux fourchettes pour manger : celle qui se trouve à sa droite
et celle qui se trouve à sa gauche.
– Un philosophe ne peut donc pas manger en même temps que ses deux voisins : les
fourchettes sont des ressources partagées pour lesquelles les philosophes sont en
concurrence.
– Le problème est de régler l'accès à ces ressources partagées pour que tout se passe
harmonieusement. Initialement, tous les philosophes pensent et tout philosophe qui
mange cesse de manger au bout d’un temps fini.
ENIS – DGIMA – GI1
Fadoua DRIRA 78
 Coopération : Exemples
Problème des philosophes

Il s’agit d’élaborer un mécanisme qui permette à ces cinq processus de coopérer sans
étreinte fatale, notons que tous les philosophes jouent le même rôle, le mécanisme de
synchronisation sera donc identique pour tous.

Associons 3 états à chaque philosophe i :

• c[i]=0 lorsqu’il pense
• c[i]=1 lorsqu’il voudrait bien manger mais il ne peut pas par manque de fourchette
• c[i]=2 lorsqu’il mange

Le passage de l’état c[i]=0 à c[i]=2 n’est possible que si (c[(i+N-1)%N]<>2) et

(c[(i+1)%N]<>2) (Condition1). Si cette condition n’est pas vérifiée, le philosophe passe
dans l’état c[i]=1 et se bloque. (N=5)

Cette impossibilité d’évolution du processus i est obtenue en introduisant un sémaphore

privé, noté sempriv[i] initialisé à 0. Le test de Condition1 et les conséquences qui en
résultent constituent une section critique à protéger par un sémaphore d’exclusion
mutuelle, noté mutex.

ENIS – DGIMA – GI1

Fadoua DRIRA 79
 Coopération : Exemples
Problème des philosophes

Le passage de i de l’état c[i]=2 à l’état c[i]=0 entraîne le réveil de ses voisins à gauche et à
droite si :
• d’une part ces derniers ont décidé de manger, autrement dit c[k]=1 pour k=(i+N-1)%N et
k=(i+1)%N
• d’autre part il faut s’assurer qu’ils disposeront de l’autre fourchette c-à-d c[k]<>2 pour
k=(i+N-2)%N et k=(i+2)%N

ENIS – DGIMA – GI1

Fadoua DRIRA 80
 Coopération : Exemples
Problème des philosophes

Entier tableau c[0 :4] ; (valeur initiales=0):/*Etat des philosophes*/

Sémaphore tableau sempriv[0 :4] ; (valeur initiales=0) /*Un sémaphore par philosophe*/
Sémaphore mutex ; (valeur initiales=1) /*Exclusion mutuelle*/
Processus philosophe i (i de 0 à N-1)
début
Li : penser;
prendre_fourchettes(i) /*Le philosophe prend les 2 fourchettes ou se bloque*/
manger ;
poser_fourchettes(i)
Aller à Li;
fin
Procédure prendre_fourchettes(i)
début
P(mutex) ; /*Section critique*/
c[i] :=1 ; /*demande les fourchettes*/
test(i) ; /*Essaie de les prendre*/
V(mutex) ; /*fin section critique*/
P(sempriv[i]) ; /* s’endort si les fourchettes sont non prises*/
fin
ENIS – DGIMA – GI1
Fadoua DRIRA 81
 Coopération : Exemples
Problème des philosophes

Procédure poser_fourchettes(i)
début
P(mutex) ; /*Section critique*/
c[i] :=0 ; /*Le philosophe ne veut plus manger*/
test((i+N-1)%N) ; /*propose au philosophe de droite*/
test((i+1)%N) ; /*propose au philosophe de gauche*/
V(mutex) ; /*fin section critique*/
fin
Procédure test(i)
début
Si (c[i]=1) et (c[(i+N-1)%N]<>2) et (c[(i+1)%N]<>2)
Alors /* Si i demande les fourchettes et quelles sont toutes libres*/
début
c[i] :=2 ; /*récupère implicitement les fourchettes*/
V(sempriv[i]) ; /*réveille le philosophe i s’il dormait */
fin
fin

ENIS – DGIMA – GI1

Fadoua DRIRA 82