Vous êtes sur la page 1sur 42

Ecole

Superieure dIngenieurs de Poitiers


Gea 3

Initiation aux syst`emes dexploitation


Laurent Signac

ii

Initiation aux syst`emes dexploitation Gea 3

Table des mati`


eres
Avant Propos
1 Ordinateur et syst`
eme dexploitation
1
Quest-ce quun syst`eme dexploitation ?
2
Mod`ele de Von Neumann . . . . . . . .
3
Structure materielle dun ordinateur . .
3.1
Registres du processeur . . . . .
3.2
Memoire . . . . . . . . . . . . . .
3.3
Peripheriques dentrees-sorties .
4
Interruptions . . . . . . . . . . . . . . .
5
R
ole du syst`eme dexploitation . . . . .

v
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.

1
1
1
1
2
2
4
4
5

2 Processus
1
Notion de processus . . . . . . . . . . . . . . . . . . . . . . .
1.1
Partage de lexecution . . . . . . . . . . . . . . . . . .
1.2
Sauvegarde du contexte . . . . . . . . . . . . . . . . .
2
R
ole du syst`eme dexploitation dans le controle des processus
2.1
Orchestration des processus . . . . . . . . . . . . . . .
2.2
Conditions de concurrence, sections critiques . . . . .
3
Ordonnancement des processus . . . . . . . . . . . . . . . . .
3.1
Algorithmes non preemptifs . . . . . . . . . . . . . . .
3.2
Algorithmes preemptifs . . . . . . . . . . . . . . . . .
4
Threads . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.

7
7
7
7
8
8
8
10
11
11
12

3 Interblocages
1
Conditions necessaires `
a un interblocage
2
Modelisation . . . . . . . . . . . . . . .
3
Gestion des interblocages . . . . . . . .
3.1
Ignorer les interblocages . . . . .
3.2
Detection et reprise . . . . . . .

3.3
Eviter
les interblocages . . . . .

.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.

13
13
13
14
14
14
15

.
.
.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.

4 Exercices

.
.
.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.

21

A Exemples de code
25
1
Processus et semaphores . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
2
Dner des philosophes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
Table des figures

31

Table des codes sources

33

iii

iv

Initiation aux syst`emes dexploitation Gea 3

Avant Propos

e cours a pour objet lintroduction aux syst`emes dexploitation. Ce domaine est vaste et cest `
a la
fois un champ de recherche et une manne dapplications et dinnovations technologiques. Justement
en raison du nombre important de connaissances quil serait possible de rassembler dans ce domaine,
un choix a d
u etre fait dans ce support de cours : donner quelques bases qui seront necessaires au
suivi dun cours de syst`emes temps reels. De nombreuses impasses ont donc ete faites et le resultat est tr`es loin
detre exhaustif. Le lecteur interesse pourra se reporter au nombreux ouvrages sur la question, desquels ce cours
est largement inspire. Citons [3] qui est tr`es agreablement ecrit et passe en revue beaucoup de choses sans trop
se perdre dans les details, [1] dont la presentation est un peu vieillissante mais qui presente des algorithmes tr`es
clairs, [6] qui reste une reference en la mati`ere, et [4] qui est recent et assez technique.
Enfin, on trouvera des exemples de code pour Linux dans [2] et une synth`ese recente dans [5].

vi

Initiation aux syst`emes dexploitation Gea 3

Chapitre 1

Ordinateur et syst`
eme dexploitation

D
1

ans ce chapitre, nous allons evoquer le mod`ele theorique `a la base de linformatique actuelle, et
presenter certains des elements qui composent un ordinateur. Nous decrirons bri`evement comment
se deroule lexecution dun programme et aborderons le role du syst`eme dexploitation comme chef
dorchestre de lensemble de la machine.

Quest-ce quun syst`


eme dexploitation ?

Un syst`eme dexploitation est un logiciel (`


a opposer au materiel qui constitue lelectronique de lordinateur) qui
g`ere lordinateur et ses peripheriques, et permet `a dautres logiciels detre executes.
Les syst`emes dexploitation les plus connus sont Windows, Mac OS et Linux, mais il en existe une quantite dautres,
comme par exemple : BeOS, Solaris, HP/UX, Plan 9, QNX etc1 ...
Certains syst`emes dexploitation sont destines plutot au grand public, dautres `a des syst`emes plus professionnels.
Ils peuvent meme etrededies `
a des types particuliers dapplications (syst`emes embarques, syst`emes temps reels...).

Mod`
ele de Von Neumann

Tous les ordinateurs actuels suivent le mod`ele de Von Neumann, elabore par le mathematicien hongrois au milieu
du si`ecle (figure 1.1).

Unite de
contr
ole

Unite arithmetique
Registres

Unite dentrees
sorties

Memoire contenant les programmes


et les donnes
Fig. 1.1 Mod`ele de Von Neumann
Nous avons dej`
a vu que les actions que peut effectuer le processeur dun ordinateur sont tr`es simples et se resument
a des operateurs arithmetiques et logiques et `a des communications avec la memoire (et les peripheriques). Dans
`
la section suivante, nous allons aller un peu plus dans le detail.

Structure mat
erielle dun ordinateur

Un ordinateur actuel peut etre schematise comme indique sur la figure 1.2. Le cur de lordinateur est le processeur,
qui peut acceder `
a la memoire et aux differents controleurs de peripheriques via des bus (il y en a en fait plusieurs).
1 La

page Web http ://www.operating-system.org/betriebssystem/ french/os-liste.htm en recence plus de 400.

Initiation aux syst`emes dexploitation Gea 3

Processeur

Controleur
video

Memoire

Controleur
clavier

Controleur
disque
Bus

Fig. 1.2 Structure dun ordinateur


Processeur

Programme

Pointeur ordinal

Memoire

Fig. 1.3 Utilisation du pointeur ordinal

3.1

Registres du processeur

Le processeur est la partie de la machine qui effectue les instructions elementaires dun programme (lire en memoire,
dialoguer avec les contr
oleurs etc...). Les programmes eux-memes sont ecrits en memoire et lessentiel du travail du
processeur consiste `
a lire dans la memoire la prochaine instruction du programme, `a lexecuter, etc... Il dispose donc
dun pointeur (le pointeur ordinal) qui lui indique la prochaine instruction quil devra effectuer, comme indique sur
la figure 1.3.
Un programme, meme ecrit en langage machine, contient des appels de procedures (dautres portions de programme). Imaginons que ladresse 0x1000 contienne un appel de procedure, situee `a ladresse 0x2000. Le pointeur
ordinal pointera `
a ladresse 0x2000 et executera la procedure. Une fois celle ci-terminee, lexecution doit reprendre `
a
ladresse 0x1001. Le processeur doit donc disposer dun moyen de sauvegarder ladresse depuis laquelle la procedure
a ete appelee. Ceci est realise par lintermediaire de la pile, qui contient aussi les param`etres et les variables locales
des procedures. La pile, situee en memoire, ((empile)) les differentes adresses qui seront necessaires pour continuer
lexecution du programme `
a la fin dune procedure. Le processeur a donc besoin dun nouveau registre pour lui
indiquer le sommet de la pile (cf. structure de pile du cours dalgorithmique). La figure 1.4 schematise lappel de
la procedure A depuis le programme principal, de la procedure B depuis la procedure A, ainsi que le retour au
programme principal.
Signalons ensuite un registre particulier contenant le ((mot detat)) (parfois appele Psw), qui comme son nom
lindique decrit letat du processeur en fonction des valeurs de certains bits (resultat dune comparaison, mode du
processeur etc..). Enfin, le processeur dispose aussi de registres prevus pour les donnees (des adresses, ou bien des
donnees recuperees en memoire).

3.2

M
emoire

Nous decrirons la memoire tr`es succinctement en signalant quen general on peut la considerer `a plusieurs niveaux.
` mesure que les niveaux avancent, le prix diminue ainsi que la vitesse dacc`es. Les registres du processeur sont des
A
memoires. Ils sont tr`es rapides, mais peu nombreux, en raison de leur co
ut. Puis vient la memoire cache, toujours
presente dans les processeurs actuels, qui contient une copie dune portion de la memoire vive. La memoire cache
nen contient quune portion car elle est beaucoup plus petite, mais elle est aussi beaucoup plus rapide. Ensuite,
vient la memoire vive. Cest celle que nous avons representee sur les schemas 1.3 et 1.4. Puis viennent les unites
de stockage (qui sont des formes de memoire) comme les disques. Les syst`emes dexploitation actuels g`erent la
memoire virtuelle. Le principe est assez simple : si la memoire vive vient `a etre saturee (trop de processus en cours

1. Ordinateur et syst`eme dexploitation

Processeur

Pointeur ordinal

Memoire

Appel proc 0x2000

Processeur

0x100

Pointeur de pile

Pointeur ordinal

Memoire

Appel proc 0x2000

Processeur

0x1000

Pointeur de pile

Pointeur ordinal

Memoire

Appel proc 0x2000

0x1000

Pointeur de pile

0x2000

0x2000
Appel proc 0x3000

0x2001

0x3000

0x2001
Infos
suppl
ementaires
0x1000

0x1000

Infos
suppl
ementaires

Processeur

Pointeur ordinal

Processeur

Memoire

Appel proc 0x2000

0x1000

Pointeur de pile

Pointeur ordinal

Infos
suppl
ementaires

Processeur

Memoire

Appel proc 0x2000

0x1000

Pointeur de pile

0x2001

0x2000
Appel proc 0x3000

0x2001

Fin proc
edure

0x3000
Fin proc
edure

0x2000
Appel proc 0x3000

0x3000
Fin proc
edure

0x2001

0x1000

0x1000

0x2001

Fin proc
edure

Infos
suppl
ementaires

Infos
suppl
ementaires

Appel proc 0x2000

Pointeur de pile

0x2000
Appel proc 0x3000

Pointeur ordinal

Memoire

0x1000
Infos
suppl
ementaires

Fig. 1.4 Utilisation de la pile

0x3000
Fin proc
edure

Initiation aux syst`emes dexploitation Gea 3

dexecution, utilisant trop de donnees), le syst`eme dexploitation en copie une partie sur un des disques durs de la
machine, afin de liberer de lespace. Sil a besoin dutiliser la partie sauvegardee, il la recharge en memoire vive et
sauvegarde ce qui nest pas directement utilise. Le syst`eme dexploitation est donc amene `a echanger des portions
de memoire entre la memoire vive et le disque dur2 .
Signalons que la memoire cache peut elle-meme etre decomposee en plusieurs niveaux (une memoire cache tr`es
rapide, mais petite, puis une autre memoire cache moins rapide, mais un peu plus grande etc...). Ce niveau dans les
memoires caches figure dans les caracteristiques des processeurs (memoire cache L2, pour Level 2 : `a deux niveaux).
Toujours au sujet de la memoire, signalons lexistence dun composant place entre le processeur et la memoire
nomme Mmu (Memory Management Unit : unite de gestion de la memoire). Son role est de translater les valeurs
des adresses. En effet, un programme ne sait pas, avant detre execute, `a quelle adresse il se trouvera en memoire. Il
suppose donc quil sera charge `
a ladresse 0 et acc`ede `a ses donnees en calculant leur adresse `a partir de 0. Lorsque
le programme est charge en memoire pour etre execute, il ne sera pas charge `a ladresse 0. Toutes les adresses
devront donc etre recalculees. Cest le r
ole de la Mmu.

3.3

P
eriph
eriques dentr
ees-sorties

Viennent enfin les differents contr


oleurs. Ceux-ci acc`edent directement au materiel. Et le materiel nest accede que
par eux. Ils presentent donc une interface plus ou moins harmonisee au syst`eme. Il existe neanmoins differents types
de contr
oleurs. Pour chaque type de contr
oleur, le syst`eme dexploitation doit savoir ce quil peut lui demander, et
comment le faire. Cest le r
ole des pilotes de peripheriques, qui sont des parties du syst`eme dexploitation, et qui
savent comment sadresser aux contr
oleurs de peripheriques.

Interruptions

Les interruptions ont ete necessaires avec lutilisation massive des entrees-sorties (acc`es disques). Avant lutilisation des interruptions, le processeur apr`es avoir demande `a realiser une operation dentree-sortie devait contr
oler
reguli`erement si la fin de loperation etait terminee (un peu comme un cuisinier, que nous retrouverons plus loin,
oblige de passer reguli`erement devant son four pour verifier letat de cuisson du plat). Dans les ordinateurs actuels,
le mecanisme est different : le processeur demande une operation dentree-sortie, puis soccupe `a autre chose. Cest
au contr
oleur de peripherique de prevenir le processeur lorsque loperation sera finie (comme si le four du cuisinier
etait equipe dun capteur verifiant la cuisson et sonnait lorsque celle-ci est terminee). Le processeur dispose donc
de certaines broches, les entrees dinterruptions, sur lesquelles des signaux emis par dautres organes de la machine
peuvent arriver. Il est alors averti dune situation particuli`ere.
Toujours dans les ordinateurs actuels, les interruptions sont divisees en plusieurs niveaux. Ces niveaux changent
avec le materiel et nous ne les detaillerons donc pas. Voyons comment se deroule une interruption de niveau n :
1 Sauvegarde du compteur ordinal dans un emplacement specifique.
2 Branchement `
a une adresse fixe dependant du niveau de linterruption.
3 Sauvegarde du reste du contexte (autres registres du processeur).
4 Traitement de linterruption.
5 Restauration du contexte.
6 Restauration du compteur ordinal.
Cest le gestionnaire dinterruptions (une puce particuli`ere) qui decide ou non de transmettre linterruption au processeur, selon son niveau de priorite (une interruption ne peut elle-meme etre interrompue que par une interruption
plus prioritaire). Les etapes 1, 2 et 6 de la liste precedente sont realisees par le materiel. Les etapes 3, 4 et 5 sont
generalement `
a la charge du traitant de linterruption.
Le branchement `
a une adresse specifique consiste, `
a partir du niveau dinteruption, `a calculer une adresse, donnee par
le vecteur dinterruption (une sorte de tableau). Par consequent, deux interruptions de meme niveau provoqueront
un branchement `
a la meme procedure de traitement.
Le mecanisme dune entree-sortie qui utilise les interruptions est schematise sur la figure 1.5.
Durant la premi`ere etape, le processeur demande une operation dentree-sortie, puis soccupe `a autre chose. Lorsque
loperation est terminee, le contr
oleur dentrees-sorties envoie un signal dinterruption qui est traite par le controleur
dinterruptions, qui decide ou non de faire suivre au processeur.
Certains types dinterruptions, selon leur niveau de priorite sont appeles deroutements (cest le cas pour une erreur
due `
a une division par 0, par exemple). Sous Unix, les interruptions portent le nom de signaux.
2 Sous Windows, le fichier du disque dur qui contient des portions de m
emoire est dailleurs appel
e fichier d
echange. Sous Linux, ce
peut
etre une partition du disque, appel
ee swap.

1. Ordinateur et syst`eme dexploitation


1

Processeur

Controleur
dinterruptions

Controleur
dentrees sortie

Fig. 1.5 Etapes


dune operation dentree sortie utilisant les interruptions
Enfin, la fameuse valeur Irq quil fallait regler lors de linstallation de nouveaux peripheriques sur PC, du temps
o`
u le plug and play nexistait pas, correspondait au numero de la broche du controleur dinterruptions qui etait
utilisee par ce peripherique (do`
u la fameuse possibilite de conflit dIrq).

R
ole du syst`
eme dexploitation

Le syst`eme dexploitation construit une machine ((virtuelle)) sur la machine physique. Cette machine ((virtuelle)) est
plus facile demploi pour le programmeur et lutilisateur. Du point de vue du programmeur, par exemple, realiser
le stockage dun fichier sur une disquette serait extr`emement complexe. La procedure serait differente selon le type
de contr
oleur de peripheriques. Pour faire un programme qui fonctionne sur toutes les machines, le programmeur
devrait ecrire du code specifique `
a chacun de ces controleurs. Il devrait posseder les documentations de tous ces
contr
oleurs pour connatre la liste des operations `a effectuer (et elles sont nombreuses) pour faire une simple
sauvegarde. Le programmeur peut saffranchir de cette tache en demandant, par le biais dun appel syst`eme, que
le syst`eme dexploitation realise pour lui la sauvegarde.
Le syst`eme dexploitation prend en charge la gestion complexe des ressources de lordinateur (processeur, memoire,
peripheriques). Ce point rejoint un peu le precedent. On peut simplement considerer que tous les details techniques
des differents circuits integres sont pris en charge par le syst`eme dexploitation, qui nous livre une vue simplifiee
sur la machine.
Enfin, le syst`eme dexploitation optimise lutilisation de lordinateur entre differents processus et differents utilisateurs (simultanes). Plusieurs imperatifs tentent detre satisfaits :
assurer le fonctionnement correct de lordinateur ;
distribuer les ressources de la machine de facon coherente entre les differents processus ;
assurer la securite de lensemble des processus, en etablissant une protection etanche entre chacun deux.
Nous avons parle plus haut des appels syst`emes, et nous venons de dire que le syst`eme dexploitation avait la
` ce titre, le syst`eme dexploitation doit pouvoir faire
((garde)) de la machine et des processus qui sy executent. A
des choses que les processus ordinaires ne peuvent pas faire. Cette distinction de ((droits)) est faite par le processeur
lui-meme qui poss`ede au moins deux modes de fonctionnement : le mode privilegie (ou mode superviseur ou mode
noyau) et le mode utilisateur. Le syst`eme dexploitation ((tourne)) en mode privilegie, alors que les autres processus
tournent en mode utilisateur.

Initiation aux syst`emes dexploitation Gea 3

Chapitre 2

Processus

orsque nous utilisons un ordinateur actuel, de nombreux programmes sont lances ((en meme temps)),
si bien que nous pouvons continuer `a taper du texte dans un traitement de texte pendant que notre
machine calcule une image de synth`ese et essaie detablir une connexion avec un site Web. Or nous
avons dej`
a dit que meme les ordinateurs actuels (monoprocessseurs) fonctionnaient en suivant le mod`ele
de larchitecture de Von Neuman et quun processeur ne pouvait donc effectuer quune seule operation `
a la fois.
Do`
u provient cette illusion que la machine execute plusieurs operations simultanees ?
Le secret reside dans la rapidite dexecution des operations elementaires, dans la notion de processus, et dans
lorchestration de ces processus par le syst`eme dexploitation.

Notion de processus

Nous savons dej`


a quun programme est un texte ecrit en langage machine. Un processus est `a peu de choses pr`es
ce qui resulte de lexecution dun tel programme. Si nous lancons deux fois un programme, nous obtenons ainsi
deux processus, qui sont des instances ((dynamiques)) du programme ecrit en langage machine. Ce sont des entites
actives, qui reclament du temps dexecution sur le processeur, des acc`es aux peripheriques, de la memoire...
Lanalogie suivante, empruntee dans [6] et leg`erement adaptee, permettra de mieux comprendre la difference entre
un processus et un programme : Supposons le cas dun chef cuisinier (le processeur), face `a la recette dun g
ateau
(le programme). Le chef cuisinier doit realiser deux gateaux, cest-`a-dire realiser deux fois lactivite decrite dans la
recette (deux processus).

1.1

Partage de lex
ecution

` moins que notre cuisinier soit dune habilete hors du commun, il ne realisera pas vraiment les deux g
A
ateaux en
meme temps. Il se concentrera sur une premi`ere realisation, puis sur la deuxi`eme, ou bien tour `a tour sur la premi`ere
et la deuxi`eme. Cest-`
a-dire quil pourra choisir de finir le premier gateau avant de commencer le second, ou bien
choisir dalterner entre les deux realisations (dabord soccuper des ufs pour les deux gateaux, puis soccuper de
la farine pour les deux g
ateaux etc...). La methode quil choisira pour realiser ((pseudo-simultanement)) ses deux
g
ateaux lui sera dictee par sa connaissance du metier de cuisinier (le syst`eme dexploitation). Sil alterne son activite
entre les deux g
ateaux, il devra, lorsquil soccupe du gateau 2, se souvenir de letat dans lequel il a laisse le g
ateau 1,
afin de ne pas lui rajouter deux fois du sucre par exemple. Il doit donc disposer dun moyen de sauvegarder le
((contexte dexecution)) de chacun de ses g
ateaux1 . Le fait que plusieurs processus puissent progresser ensemble et
utiliser tour `
a tour le processeur sappelle la multiprogrammation.

1.2

Sauvegarde du contexte

Nous avons dej`


a vu qu`
a un programme en cours dexecution correspondait un certain nombre de donnees : les
registres du processeur, les bornes dadresses de la Mmu, ladresse de sommet de la pile etc...
Lorsque le processeur interrompt lexecution dun processus A pour continuer lexecution dun processus B, toutes
les donnees concernant A doivent etre sauvegardees, et les donnees concernant B doivent etre restaurees. Ces
donnees sont stockees par le syst`eme dexploitation dans la table des processus et cest `a la charge du syst`eme
de sauvegarder et restaurer correctement le contexte dexecution des processus. Nous nallons pas decrire cette
1 Lanalogie est ici un peu tir
ee par les cheveux dans la mesure o`
u il est souvent possible, rien quen regardant l
etat davancement
du g
ateau, de d
ecider `
a quel endroit de la recette celui-ci a
et
e laiss
e...

Initiation aux syst`emes dexploitation Gea 3

table, qui varie de toutes facons selon les syst`emes. Citons neanmoins quelques entrees : les registres du processeur,
le compteur ordinal, le mot detat, le pointeur de pile, letat du processus (voir plus loin), sa priorite (voir la
section 3)...

R
ole du syst`
eme dexploitation dans le contr
ole des processus

La lourde t
ache qui consiste `
a charger un programme en memoire (creant ainsi un processus, `a la demande de
lutilisateur) en gerant lexecution au mieux de chacun des processus, leur acc`es aux ressources, et ceci en offrant
un certain confort dutilisation `
a lutilisateur (pas de processus bloques indefiniment etc...) revient au syst`eme
dexploitation. Nous aborderons ici uniquement le cas de machines monoprocesseur (on dit alors que le syst`eme
dexploitation fait de la pseudo-simultaneite).

2.1

Orchestration des processus

Un syst`eme dexploitation generaliste (ceux que nous utilisons sur des ordinateurs de bureau) doit pouvoir creer
des processus `
a la demande ou automatiquement : des processus sont demarres lorsque le syst`eme dexploitation
est lance, un processus peut lui-meme en creer plusieurs autres et enfin, lutilisateur peut, en cliquant sur un
programme provoquer la creation de nouveaux processus. La creation dun processus passe dans tous les cas par
le syst`eme dexploitation. Un processus qui cree un autre processus demande au syst`eme de le faire pour lui, par
lintermediaire dun appel syst`eme.
De la meme facon, un processus peut sarreter pendant que la machine fonctionne : soit parce quil est termine,
soit parce quune erreur fatale sest produite (erreur de programmation par exemple), soit parce que lutilisateur a
demande larret du processus (cf. le gestionnaire de taches sous Windows ou la commande kill sous Unix).
Les processus ((potentiellement en execution)) peuvent se trouver dans differents etats : en cours dexecution, bloques
ou prets. Le premier cas correspond au processus qui est effectivement en train detre execute par le processeur. Le
troisi`eme cas correspond au processus qui pourrait etre execute par le processeur `a cet instant precis, mais qui ne
lest pas, parce que le syst`eme dexploitation en a decide autrement. Enfin, letat bloque correspond `a un processus
qui ne pourrait pas etre execute actuellement, parce quil est en attente dun ev`enement qui ne sest pas encore
produit. Reprenons notre analogie du cuisinier et supposons que ce dernier ne poss`ede quun seul verre doseur pour
mesurer la quantite de farine, mais plusieurs recipients pour faire ses deux gateaux simultanement. Au moment
o`
u le cuisinier a rempli son verre doseur de farine pour faire le gateau A, le processus associe au gateau A est en
cours dexecution. Celui associe au g
ateau B est bloque en ce sens que la prochaine chose `a faire est dajouter la
farine, ce qui ne pourrait pas etre fait puisque le verre doseur est occupe. Une fois le verre doseur vide, lorsque le
cuisinier melange la farine du g
ateau A dans un recipient, le processus associe au gateau B nest plus bloque, mais
simplement pret : on ne soccupe toujours pas de lui, mais il serait possible de le faire avancer si le cuisinier sen
preoccupait. Cest le r
ole de lordonnanceur (que nous reverrons plus loin) que de selectionner, parmi les processus
prets, lequel doit passer en execution, et pendant combien de temps.

2.2

Conditions de concurrence, sections critiques

Une condition de concurrence survient lorsque deux processus (ou plus) tentent par exemple dacceder `a une meme
ressource, ou plus generalement `
a une variable. Lexecution alternative des deux processus peut faire emerger une
situation non souhaitee qui ne se produirait pas si chaque processus etait execute sequentiellement.
Essayons lanalogie suivante : deux personnes ont pour fonction de remplir un camion de sable en se servant dans
un tas. Lorsque le tas est fini, il faut aller chercher dautre sable, `a laide dune brouette, et lajouter sur le tas. Si
une seule personne fait ce travail, aucun probl`eme ne peut arriver. Pour modeliser le fait que les deux personnes
alternent leur travail, nous pouvons supposer quune seule pelle est disponible. Que se passe-t-il si deux personnes
travaillent ensemble ? Si la personne A constate quil ny a plus de sable, elle va poser la pelle et partir avec sa
` ce moment, la personne B va se saisir de la pelle pour continuer le
brouette chercher du sable supplementaire. A
travail, et constater quil ny a plus de sable. Elle va donc poser la pelle et partir avec une brouette chercher dautre
sable. La personne A va revenir et vider son sable sur le tas vide, puis la personne B va revenir et ajouter son
sable, ce qui nest pas la situation souhaitee, surtout si le tas doit avoir une taille maximum.
La solution employee, pour eviter les conditions de concurrence est la notion de section critique. Une section critique
est un groupe dinstructions pendant lesquelles le processus ne peut pas etre interrompu par un autre entrant aussi
dans une section critique. Autrement dit, on ne peut pas avoir un processus pret dans une section critique, en
meme temps quun autre processus en execution dans une section critique.

2. Processus
turn
0
interet[0] 0
interet[1] 0

a)

turn
1
interet[0] 0
interet[1] 1

b)

section
critique
de 1

c)

turn
1
interet[0] 0
interet[1] 0

Fig. 2.1 Gestion des sections critiques par la methode de Peterson : cas simple
Dans notre analogie, cela signifierait que la personne B ne peut pas entamer la section critique, qui consiste `
a aller
chercher du sable et `
a le vider sur le tas, si la personne A est elle-meme dans sa section critique. Le probl`eme est
ainsi regle.
Si le processus execute est dans une section critique et quil ny a quun autre processus desirant etre execute,
et que celui-ci doit entrer dans une section critique, il passera alors dans letat bloque, jusqu`a ce que le premier
processus ait termine sa section critique.
Nous allons `
a present voir comment le principe dexclusion mutuelle des sections critiques peut etre implante. Il
existe des solutions plus ou moins bonnes, et envisageables dans certains cas uniquement.
2.2.1

Attente active

Variable de verrou Une variable est mise `a 1 par un processus pour indiquer quil entre dans une section
critique. Les conditions de concurrence sont evitees, sauf pour le verrou lui-meme.
Alternance stricte Implantee pour deux processus ou plus, cette methode permet `a chacun des processus
deffectuer chacun leur tour leur propre section critique. Si cette solution evite les situations de concurrence, un
processus peut se retrouver bloque (en attente dentrer dans sa section critique) alors que le processus ayant la
main sur la section critique peut ne pas avoir `a y entrrer (famine).
M
ethode de Peterson Proposee en 1981 pour deux processus, cette methode repose sur une variable (turn) et
un tableau (nomme inter^
et) comportant une case par processus :
turn : entier
interet[] : tableau de 2 entiers
Entrer (n :entier)
interet[n]=1
turn=n
r
ep
eter tant que turn=n et interet[1-n]=12
Attendre

Sortir(n : entier)
interet[n]=0
Lorsquun processus veut entrer dans une section critique, il doit indiquer dans le tableau quil est interesse pour
entrer dans une section critique et stocker dans turn son numero de processus. Puis le processus doit attendre, pour
entrer reellement dans sa section critique, que turn soit different de son numero de processus, ou bien quaucun
autre processus nait indique quil etait interesse par lentree dans une section critique. Au sortir de la section
critique, le processus indique simplement quil nest plus interesse.
Le cas simple (une seule demande `
a une section critique) est illustre figure 2.1. En a), le processus 1 demande
lacc`es `
a une section critique. En b), il attend detre le seul interesse ou bien de ne pas avoir son numero dans turn.
Puisquil est le seul interesse, il entre immediatement dans sa section critique et `a la sortie en c), il remet `
a 0 la
valeur inter^
et[1].
Si deux processus demandent ((simultanement)) lacc`es `a une section critique (figure 2.2), chacun des deux indique
son interet et met son numero de processus dans turn a). Un seul peut avoir son numero dans turn, naturellement
(cest 1 dans notre exemple). Le processus 0, puisquil na pas son numero dans turn entre donc dans la section
critique tandis que lautre attend. Lorsque le processus 0 a fini, en c), il fait repasser int
er^
et[0] `a 0, ce qui permet
au processus 1 dentrer en d) dans sa section critique.
2 Attention,

`
a la condition

10

Initiation aux syst`emes dexploitation Gea 3

b)

turn
0
interet[0] 0
interet[1] 0

a)

turn
1
interet[0] 1
interet[1] 1

section
critique
de 0

c)

turn
1
interet[0] 0
interet[1] 1

d)
processus 1 bloque

section
critique
de 1

e)

turn
1
interet[0] 0
interet[1] 0

Fig. 2.2 Gestion des sections critiques par la methode de Peterson : deux processus en concurrence
Gestion par le processeur Les processeurs actuels disposent dune instruction permettant de gerer les sections
critiques. Lidee est que la lecture et le changement de valeur dune variable peut etre fait en une instruction
indivisible.
2.2.2

Blocage des processus et s


emaphores

Les methodes decrites ci-dessus (attente active) ont pour defaut quun processus en attente dentree dans une
section critique consomme du temps processeur dans une boucle qui ne se terminera que lorsquil aura obtenu ce
quil souhaite.
De leg`eres modifications dans ce qui prec`ede nous am`ene `a la solution introduite par Dijkstra au milieu du si`ecle :
les semaphores. Selon les ouvrages, les semaphores sont decrits de facons leg`erement differentes. Nous reprenons ici
une des definitions les plus simples. Un semaphore est un compteur associe `a une liste dattente. Si un processus
veut acceder `
a une ressource ou entrer dans une section critique, il le demande par un appel syst`eme : down(sem)
o`
u sem est le semaphore associe `
a cette ressource ou `a la section critique. Le compteur associe au semaphore :
sem.count est decremente puis teste, en une seule operation processeur par la fonction down. Sil est strictement
negatif, le numero du processus est mis dans la liste dattente sem.wait et le processus lui-meme est endormi3 par
le syst`eme. Sinon, rien de particulier ne se passe et le processus acc`ede `a la ressource. Lorsque la section critique
ou lacc`es `
a la ressource sont terminees, le processus doit appeler la fonction up(sem). Le compteur sem.count est
alors incremente puis teste. Sil est negatif ou nul, cela signifie que la liste sem.wait nest pas vide. Dans ce cas, le
syst`eme reveille un des processus de la liste dattente, qui acc`ede alors `a la ressource.
Notons que linitialisation de la variable sem.count permet de faire plus que de lexclusion mutuelle avec les
semaphores (si on dispose dune ressource pouvant etre accedee par 3 processus au plus, par exemple, on initialisera
count `
a 3). Un semaphore utilise uniquement pour de lexclusion mutuelle (acc`es `a une valeur ou entree dans une
section critique) est appele mutex.

Ordonnancement des processus

Jusqu`
a present, nous avons souvent ecrit : le syst`eme dexploitation choisit un autre processus... Mais comment
le choisit-il ? La facon dont le syst`eme regule lexecution des processus est appelee sa methode dordonnancement.
Nous allons en exposer quelques principes. Notons tout dabord une difference fondamentale entre les syst`emes
preemptifs et les syst`emes non preemptifs. Dans le second cas, un processus en cours dexecution ne sera pas
interrompu par le syst`eme. Ce sera au processus lui-meme de decider de se bloquer, pour laisser le syst`eme choisir
un autre processus `
a effectuer. Dans le premier cas, un signal dhorloge provoque reguli`erement une interruption
et le syst`eme peut choisir dinterrompre le processus afin den choisir un autre. Seuls des syst`emes dedies `a des
t
aches bien precises devraient utiliser une gestion non preemptive des processus. En effet, sur un poste bureautique
par exemple, o`
u de nombreuses applications plus ou moins bien ecrites sont executees, un processus pourrait
bloquer tout le syst`eme sil ne rend jamais la main. La dualite preemptif/non preemptif est parfois appelee avec
requisition/sans requisition.
Enfin, nous nous interesserons plus particuli`erement ici `a lordonnancement des processus vis `a vis de leur execution
sur le processeur. Dans un syst`eme reel, les algorithmes dordonnancement sont presents pour lacc`es `a tout type
de ressource (processeur en particulier, mais aussi memoire, peripheriques etc...). Dans presque tous les cas, les
identifiants des processus en attente de la ressource sont stockes dans une liste dattente. Lalgorithme dordonnancement aura donc pour t
ache de choisir, dans la liste dattente, quel sera le prochain processus `a executer. Notons
que, puisquil y a plusieurs listes dattentes, certaines peuvent etre gerees de facon preemptive et dautres non.
3 Cest-`
a-dire

quil ne consommera plus de temps processeur. Pour cela, il est simplement bloqu
e par le syst`
eme.

11

2. Processus
P1

P2

P3

13

19

P4

21

Fig. 2.3 Execution par la methode Fifo

P4

P2

P1

10

15

P3

21

Fig. 2.4 Plus court temps dexecution dabord

3.1

Algorithmes non pr
eemptifs

Dans le cas dalgorithmes sans requisition du processeur, si un processus passe en execution, tous les processus en
attente devront attendre quil se termine (ou quil decide lui-meme de se bloquer).
Listes Fifo La facon la plus evidente dordonnancer est de gerer les processus en attente dans une file (liste
Fifo du cours dalgorithmique). Cette solution est tr`es simple mais assez peu satisfaisante, meme si elle garantit
lexecution de tous les processus (si aucun ne sexecute indefiniment). Pour avoir une mesure de la performance
de lalgorithme dordonnancement, nous nous interesserons au temps de traitement moyen. Il sera defini comme la
difference des dates de fin dexecution et dentree dans la liste. Nous utiliserons le tableau suivant, indiquant la
duree dexecution i et la date dentree dans la liste ti :
P1
P2
P3
P4

i
5
4
6
2

ti
0
2
3
4

Dans le tableau precedent, le processus P3 necessite 6 quanta de temps processeur pour sexecuter et il est arrive
dans la liste dattente `
a la date 3. Si le processeur commence `a executer les processus de la liste `a la date 4 (une
fois que tous sont dans la structure Fifo), nous obtiendrons lexecution representee figure 2.3.
Le temps de traitement moyen dun processus sera alors :
t=

9 + (13 2) + (19 3) + (21 4)


= 13, 25
4

Plus court temps dex


ecution Afin de favoriser les processus courts, lordonnanceur peut choisir dexecuter
les processus qui ont les temps dexecution les plus courts. Si `a linstant 4, les taches suivantes sont dans la liste :
P1
P2
P3
P4

i
5
4
6
2

ti
0
2
3
4

Nous obtiendrons lexecution representee figure 2.4


Et le temps de traitement moyen sera :
t=

(6 4) + (10 2) + 15 + (21 3)
= 10, 75
4

Lalgorithme dordonnancement du plus court temps dexecution dabord est optimal, mais uniquement si la liste
des t
aches est connue `
a lavance, comme dans notre exemple.

3.2

Algorithmes pr
eemptifs

Les algorithmes preemptifs peuvent etre utilises si le syst`eme est dote dun horloge capable de generer des interruptions `
a intervalles reguliers. Dans cette mesure, le syst`eme dexploitation peut ((reprendre la main)) reguli`erement
et choisir dinterrompre le processus courant pour en executer un autre. Le syst`eme doit aussi pouvoir sauvegarder
le contexte dexecution du processus et bien s
ur le restaurer (voir section 1.2 du chapitre 2).

12

Initiation aux syst`emes dexploitation Gea 3

Algorithme du tourniquet (Round robin) La structure contenant les informations sur les processus est de
type liste Fifo. Le processus de tete est execute pendant 1 quantum de temps. Puis il est mis en queue de liste et
lalgorithme it`ere les derni`eres operations. Il y a des versions du tourniquet comportant plusieurs files dattente.
Gestion avec priorit
es Une certaine priorite est donnee aux differents processus. Cest cette priorite qui influera
sur leur ordre dexecution. Cest ce principe qui est repris sous les syst`emes dexploitation Unix.
Loterie Un autre algorithme consiste `
a tirer simplement au sort le prochain processus qui sera execute. Un moyen
de ((biaiser)) les tirages au sort (pour favoriser des processus de haute priorite par exemple) est de distribuer plus
de billets aux processus prioritaires. Ils auront ainsi plus de chances detre choisis.
Cas des processus temps r
eels Les processus temps reels poss`edent, en plus des autres, une echeance, `a partir
de laquelle ils doivent avoir termine leur execution. De plus certains processus doivent etre periodiques, et dautres
non. Le cas particulier dordonnancement des processus temps reel sera aborde durant le cours de temps-reel.

Threads

Nous venons de voir que les processus peuvent etre vus comme differents fils dexecution, geres par le syst`eme
dexploitation, possedant chacun leur propre espace dadressage.
Ce syst`eme permet en particulier dassurer une certaine (impression de) simultaneite dans lexecution de differents
programmes, et donc daccrotre la souplesse et le confort dutilisation. De plus, letancheite des processus assure
la bonne sante et la stabilite de lensemble.
Il est cependant des cas o`
u lon souhaiterait profiter de la simultaneite et de la souplesse, en renoncant `a letancheite,
par exemple si les differentes ((t
aches)) utilisent les meme donnees. Lexemple donne dans [6] est tout `a fait parlant :
supposons que lon utilise un traitement de texte moderne (Wysiwyg) et que lon travaille sur un gros document. On
peut esperer que le logiciel soit reactif aux entrees clavier, soit rapide `a recalculer la mise en page (par exemple la
renumerotation de toutes les pages en cas dune suppression), et garantisse des sauvegardes automatiques reguli`eres.
Ces trois fils dexecution : gestion du clavier, calcul de la mise en page et sauvegarde automatique gagneront
evidemment `
a etre executes (pseudo)simultanement, comme le seraient des processus. En revanche, ils doivent tous
les trois acceder `
a la meme donnee : le document. L`a interviennent les threads.
Les threads sont donc differents fils dexecution, `
a linterieur dun meme processus (autrement dit, nous navions
considere jusque l`
a que des processus monothread). Chaque thread dispose de sa propre pile (variables locales et
appels de procedures), mais tous les threads dun meme processus partagent le meme espace dadressage et donc
les meme variables globales4 .
Lordonnancement de tous les thread peuvent etre faits par le syst`eme dexploitation lui-meme (la gestion des
threads est alors native), ou bien par un syst`eme dexecution intermediaire entre lOs et les processus (et le
syst`eme dexploitation na alors pas connaissance des threads).
On retiendra que les threads, appeles parfois processus legers, sont utilises dans le cas o`
u les donnees doivent etre
partages par les differents fils dexecution et/ou dans le cas o`
u la vitesse de creation des differents fils dexecution
est primordiale (la creation et la suppression dun thread `a linterieur dun processus est souvent bien plus rapide
que la creation et la suppression dun processus).
Un exemple de programmation de threads et de processus sous Unix est donne en A.1.

4 et rien nemp
eche a priori quun thread aille
ecrire dans la pile dun autre thread du m
eme processus, ce qui entranerait sans
doute un fonctionnement hasardeux.

Chapitre 3

Interblocages

our se rendre compte de ce quest une situation dinterblocage (parfois appelee etreinte fatale ou
deadlock), nous pouvons reprendre lexemple du cuisinier. Celui-ci realise deux recettes differentes (deux
processus en cours, mais issus de deux programmes differents). Il a un nombre limite de ressources (un
seul verre doseur, et un seul fait-tout). La premi`ere recette lui indique quil faut dabord mettre du
beurre dans le fait-tout, puis mesurer de la farine avec le verre doseur, et enfin melanger dans le fait-tout. La
seconde lui indique quil doit mesurer de leau dans le verre doseur, mettre des oeufs dans le fait-tout et y verser
leau. Il est bien s
ur possible de realiser les deux recettes, la solution triviale consiste `a faire la premi`ere puis la
seconde. Mais dans le cadre de lordonnancement de processus, chaque execution de recette peut etre interrompue
par une autre. Supposons que le cuisinier ait verse leau dans le verre doseur comme indique dans la recette 2, puis
quil ait ensuite mis du beurre dans le fait-tout comme indique dans la recette 1. Lexecution des deux recettes est
alors bloquee : le fait-tout est necessaire pour continuer la recette 2, car il faut y mettre les oeufs, or il est occupe
par le beurre. De meme, la recette 1 est bloquee car le cuisinier a besoin du verre doseur pour mesurer la farine, or
celui-ci contient de leau...

Conditions n
ecessaires `
a un interblocage

Les conditions suivantes doivent etre remplies pour quun interblocage soit possible :
une ressource est soit attribuee `
a un seul processus, soit disponible ;
un processus peut demander une ressource alors quil en poss`ede dej`a une ;
il est impossible de retirer de force une ressource `a un processus ;
les processus doivent former un cycle dau moins deux elements, chacun attendant une ressource detenue par un
autre processus du cycle.
Malheureusement, ces conditions sont souvent remplies et les interblocages sont donc a priori possibles.

Mod
elisation

Il existe une methode, basee sur les graphes, permettant de modeliser les interblocages. Chaque processus est
represente par un nud rond, et chaque ressource par un nud carre. Si un processus demande lacc`es `
a une
ressource, les nuds sont relies par une fl`eche allant du processus vers la ressource. Si le processus a obtenu lacc`es
a la ressource, le sens de la fl`eche est inverse. Ainsi, le graphe de la figure 3.1 represente deux processus A et B
`
et deux ressource R et S. Les deux processus sont en situation dinterblocage. Ceci est facilement reperable car le
graphe poss`ede un cycle.
A
R

S
B

Fig. 3.1 Deux processus A et B en situation dinterblocage

13

14

Initiation aux syst`emes dexploitation Gea 3

E
V

Fig. 3.2 Situation reelle avec 3 processus en phase dinterblocage

3
3.1

Gestion des interblocages


Ignorer les interblocages

Selon le type de syst`eme, on peut tout simplement ignorer les interblocages, si ceux-ci sont suffisamment peu
critiques et rares. Si une machine de bureau se retrouve bloquee au bout de 1000h de travail en moyenne, cela
restera negligeable compare `
a tous les autres probl`emes qui peuvent survenir.

3.2

D
etection et reprise

La methode ne consiste pas `


a prevenir les interblocages, mais `a les constater, puis `a y remedier. La facon la plus
evidente pour le syst`eme est de construire un graphe et dy rechercher des cycles (voir le cours dalgorithmique),
afin de deduire sil y a ou pas interblocage, et si cest le cas, quels sont les processus bloques, et `a cause de quelles
ressources. Voici un exemple :
le processus A detient la ressource R et demande S ;
le processus B demande la ressource T :
le processus C demande la ressource S ;
le processus D detient la ressource U et demande T et S ;
le processus E detient la ressource R et demande V ;
le processus F detient la ressource W et demande S ;
le processus G detient la ressource V et demande U .
Sil nest pas a priori facile de detecter les interblocages `a partir dune telle liste, cela devient plus simple avec le
graphe associe de la figure 3.2. Nous constatons sur ce graphe quil y a un cycle, et donc une situation dinterblocage
mettant en cause les processus G, D et E.
Cette methode reste valide sil ny a quune ressource de chaque type (par exemple une seule imprimante, et un
processus desirant imprimer devra necessairement acceder `a une ressource precise, la seule imprimante). Il existe
une autre methode, basee cette fois sur des matrices, permettant de reperer les interblocages dans le cas o`
u certaines
ressources existent en plusieurs exemplaires.

Cas de ressources multiples Le methode basee sur les graphes ne fonctionne plus si, par exemple, la machine
poss`ede deux imprimantes (lune ou lautre pouvant etre affectee `a un processus desirant imprimer). Une facon de
modeliser ce probl`eme est dutiliser des vecteurs et des matrices (ici dans le cas de m processus et n ressources de
nature differente) :
E est le vecteur de taille n des ressources existantes. Ei est le nombre dexemplaires de la ressource i.
A est le vecteur de taille n des ressources disponibles. Ai est le nombre dexemplaires de la ressource i qui ne
sont pas actuellement utilises.
C est la matrice m n des ressources allouees. Cij est le nombre dexemplaires de la ressource j actuellement
detenus par le processus i.
R est la matrice m n des ressources demandees. Rij est le nombre dexemplaires de la ressource j demandes
par le processus i.

3. Interblocages

15

Un interblocage est detecte ainsi


demarquer les processus executes
r
ep
eter tant quil existe un processus non marque i tel que
la i`eme ligne de R est inferieure ou egale1 `a A
ajouter la i`eme ligne de C `a A
marquer le processus
sil reste des processus non marques, une situation dinterblocage existe
Cet algorithme peut etre execute reguli`erement, ou bien lorsque la charge du processeur diminue.
Une fois linterblocage detecte, il reste neanmoins `a regler le probl`eme. Voici quelques solutions.
Reprise par rollback Cette solution consiste `a enregistrer reguli`erement letat de chaque processus de facon `
a
permettre au syst`eme de revenir en arri`ere dans lexecution de lun deux. Si le syst`eme de points de reprise est en
place, il suffit, apr`es avoir detecte un processus en situation dinterblocage, de le faire reprendre avant quil nait
acquis la ressource qui est mise en cause. Lautre processus bloque pourra alors lacquerir et le processus revenu en
arri`ere patientera jusqu`
a ce quelle soit liberee. Notons cependant que lenregistrement des points de reprise est
une methode relativement lourde.
Suppression de processus Le syst`eme permet generalement `a lutilisateur de supprimer un processus (le kill
dUnix ou le gestionnaire de t
aches de Windows). Supprimer un processus peut supprimer un interblocage, meme si
le processus supprime netait pas directement en cause (dans le cas de ressources existant en plusieurs exemplaires).
Le plus difficile est de choisir quel processus sacrifier sans que les consequences soient nefastes.

3.3

Eviter
les interblocages

Eviter
un interblocage est difficile dans la mesure o`
u le comportement des processus est difficile `a prevoir. La
solution la plus adaptee, quoi quassez restrictive consiste `a ordonner les ressources et `a ne permettre au processus
de ne les demander que dans un ordre croissant. Il ne peut alors pas se produire dinterblocage. La plupart des
autres methodes reposent sur la notion detats s
urs que nous allons developper.
3.3.1

Trajectoires de ressources

Sans encore parler dalgorithme, nous allons aborder la representation graphique des etats. La figure 3.3 montre un
exemple dexecution de deux processus sur une machine (processus A en abcisse et B en ordonnee). Le chemin nous
indique `
a chaque instant quel processus est execute (I1 `a I4 sont des instructions du processus A et I5 `
a I8 sont
des instructions du processus B). Lorsquaucun des processus nest demarre, letat est en p. Les deux processus se
terminent en z. Un ordre dexecution particulier des processus est un chemin de p `a z.
Supposons que le processus A a besoin de limprimante entre I1 et I3, et de la table tracante entre I2 et I4. De
son c
ote, B a besoin de la table tracante entre I5 et I7 et de limprimante entre I6 et I8. Nous representerons la
situation comme indique figure 3.4. Les zone hachurees sont naturellement interdites.
Au point s de la figure 3.4, lordonnanceur a le choix entre executer A ou B. Sil execute B, on se retrouve dans la
situation de la figure 3.5 (interblocage). Sil execute A (figure 3.6), alors, lordonnanceur aura la possibilite deviter
les interblocages.
3.3.2

Etats
s
urs et non s
urs

Un etat s
ur peut etre defini ainsi : il existe un moyen dordonnancer les processus sans quil y ait de blocage, meme
si tous les processus demandent toutes leurs ressources en meme temps.
Un exemple est donne figure 3.7. Les matrices indiquent pour chacun des trois processus A, B, et C, le nombre de
ressources quil poss`ede et le nombre de ressources maximum quil voudra eventuellement posseder. Nous supposons
quil y a 10 ressources au total. Dans le cas de la matrice de gauche, le prossessus A poss`ede 3 ressources et en voudra
6 de plus, le processus B poss`ede 2 ressources et en voudra deux de plus... En tout, 7 ressources sont occupees, et
il en reste donc 3. Cet etat est s
ur car il existe un ordre dexecution garantissant quaucun processus ne se bloque
(partie superieure de la figure 3.7 : executer B, puis C, puis A). En revanche, si lordonnanceur executait A et que
celui-ci prenait une ressource supplementaire, alors letat ne serait plus s
ur (partie inferieure de la figure 3.7).
1 Un

vecteur est inf


erieur ou
egal `
a un autre si cette relation est vraie pour chacun des coefficients.

16

Initiation aux syst`emes dexploitation Gea 3

processus B

z
I8
I7
I6
I5

processus A

I1

I2

I3

I4

Fig. 3.3 Exemple dexecution de deux processus

processus B

I8
table tra
cante

Imprimante

z
I7
I6
I5

processus A

I1

I2

I3

I4

imprimante
table tra
cante

Fig. 3.4 Exemple dexecution de deux processus avec usage de ressources

17

3. Interblocages

processus B

I8
table tra
cante

Imprimante

z
I7
I6

I5

processus A

I1

I2

I3

I4

imprimante
table tra
cante

Fig. 3.5 Exemple dexecution de deux processus avec usage de ressources : situation dinterblocage

processus B

I8
table tra
cante

Imprimante

I7
I6
I5

processus A

I1

I2

I3

I4

imprimante
table tra
cante

Fig. 3.6 Exemple dexecution de deux processus avec usage de ressources : pas dinterblocage

18

Libre : 1

A 3 9

Libre : 3

Etat
s
ur

Max

B 2 4
C 2 7

A 4 9
B 4 4
B?

A 4 9
B 2 4

A?

C 2 7
Libre : 2

Etat
non s
ur

A 3 9
C
B 0 -

A 3 9
C
B 0 -

A 3 9
A
B 0 -

C 2 7

C 7 7

C 0

Libre : 5

B?

C 2 7
Libre : 0

Libre : 0

Libre : 7

A 9 9
A
B 0 C 0

Libre : 1

Max

Poss`
ede

Max

Poss`
ede

Max

Poss`
ede

Max

Poss`
ede

Max

Poss`
ede

C 2 7

Poss`
ede
A

Poss`
ede

Max

Libre : 2

Etat
s
ur

A 0

B 0

C 0

Libre : 10

Max

B 4 4

C 2 7
B

Max

A 3 9

Poss`
ede

B 3 4

Max

A 3 9

Poss`
ede

Poss`
ede

Max

Poss`
ede

Initiation aux syst`emes dexploitation Gea 3

A 4 9
B 0 C 2 7
Libre : 4

C?

ro
Im ce
s
T pri su
ab m s
S le an
ca s t
L nn tr es
ec e ac
te r an
u
te
rs
P
s
ro
C
D
Im ce
s
T pri su
ab m s
S le an
ca s t
L nn tr es
ec e ac
te r an
u
te
rs
s
C
D

Fig. 3.7 Etats


s
urs et non s
urs

A 3 0 1 1

A 1 1 0 0

B 0 1 0 0

B 0 1 1 2

C 1 1 1 0

C 3 1 0 0

D 1 1 0 1

D 0 0 1 0

E 0 0 0 0

E 2 1 1 0

6 3 4 2

5 3 2 2

1 0 2 0

R (total)

Fig. 3.8 Matrices utilisees par lalgorithme du banquier


3.3.3

Algorithme du banquier

Lalgorithme du banquier pour plusieurs ressources a ete introduit par Dijkstra. Il consiste, pour lordonnanceur,
a toujours rester dans un etat s
`
ur. Son fonctionnement necessite que chaque processus indique le nombre maximal
de ressources dont il peut avoir besoin (ce qui est rarement le cas en pratique).
Sur la figure 3.8, les matrices ont la signification suivante :
C : ressources actuellement allouees au processus ;
R : ressources quil restera `
a allouer aux processus (generalement pas connue) ;
E : nombre de ressources de chaque type ;
P : nombre de ressources allouees de chaque type ;
A : nombre de ressources restantes de chaque type.
Lalgorithme du banquier consiste `
a voir sil existe un ordre dexecution pour lequel tous les processus peuvent se
terminer sils demandent toutes leurs ressources. Si cest le cas, letat est s
ur, et il sufit dexecuter en premier le
processus ainsi trouve pour rester dans un etat s
ur (voir figure 3.9).

19

3. Interblocages

A 3 0 1 1

A 1 1 0 0

B 0 1 0 0

B 0 1 1 2

C 1 1 1 0

C 3 1 0 0

D 1 1 0 1

D 0 0 1 0

E 0 0 0 0

E 2 1 1 0

A 1 1 0 0

B 0 1 0 0

B 0 1 1 2

C 1 1 1 0

C 3 1 0 0

D 1 1 0 1

D 0 0 1 0

E 0 0 0 0

E 2 1 1 0

A 3 0 1 1

A 1 1 0 0

B 0 1 0 0

B 0 1 1 2
C 3 1 0 0
D - - - -

E 0 0 0 0

E 2 1 1 0

A 3 0 1 1

A 1 1 0 0

B 0 1 0 0

B 0 1 1 2

C 1 1 1 0
D - - - -

C 3 1 0 0
D - - - -

E -

A -

E -

A -

B 0 1 1 2

C 1 1 1 0
D - - - -

C 3 1 0 0
D - - - -

E -

E -

A B -

1 0 2 0

B 0 1 0 2

C 1 1 1 0

C 3 1 0 0

D 1 1 0 1

D 0 0 1 0

E 0 0 0 0

E 2 1 1 0

6 3 4 2

5 3 2 2

1 0 2 0

6 3 4 2

4 2 2 1

2 1 2 1

6 3 4 2

4 2 2 1

2 1 2 1

6 3 4 2

1 2 1 0

5 1 3 2

6 3 4 2

0 0 0 0

6 3 5 2

Etat
s
ur
D,A,E,B,C

C D -

C D -

E -

E -

6 3 4 2

5 3 3 2

1 0 1 0

6 3 4 2

5 3 4 2

1 0 0 0

R (total)
E (R3)

A 3 0 1 1

A 1 1 0 0

B 0 1 1 0

B 0 1 0 2

C 1 1 1 0

C 3 1 0 0

D 1 1 0 1

D 0 0 1 0

E 0 0 1 0

E 2 1 0 0

Etat
non s
ur

R (total)

A B -

B (R3)

A 1 1 0 0

B 0 1 1 0

R (total)

B 0 1 0 0

5 3 2 2

A 3 0 1 1

R (total)

R (total)

C 1 1 1 0
D - - - -

6 3 4 2

R (total)

A 3 0 1 1

R (total)

Fig. 3.9 Algorithme du banquier

R (total)

20

Initiation aux syst`emes dexploitation Gea 3

Chapitre 4

Exercices
Algorithme de Peterson Que se passe-til si on modifie lalgorithme de Peterson en1 :
Entrer (n :entier)
turn=n
interet[n]=1
r
ep
eter tant que turn=n et interet[1-n]=1
Attendre

Le dner des philosophes Cinq philosophes sont assis `a table, chacun devant une assiette, et cinq fourchettes
sont disposees entre les assiettes.

(a) Disposition des philosophes et des couverts

(b) Les philosophes en pleine action

Fig. 4.1 Probl`eme des philosophes


Lactivite des philosophes consiste `
a penser et `a manger (chacune des deux activites excluant naturellement lautre).
Pour manger, un philosophe a besoin de deux fourchettes. Comment programmer les philosophes de facon `
a ce que
chacun puisse penser, manger, sans que cela conduise `a un interblocage.
Le processus philosophe a pour mod`ele :
Processus philosophe
r
ep
eter indefiniment
Penser
Prologue
Manger
Epilogue
1 Inversion

de deux lignes.

21

22

Initiation aux syst`emes dexploitation Gea 3

Il sagit decrire correctement les procedures Prologue et Epilogue.


Probl`
eme des lecteurs/r
edacteurs Lexemple type est lacc`es `a une base de donnees de reservation (SNCF
par exemple) :
les lecteurs lisent le contenu de la base de donnees, et plusieurs lecteurs peuvent acceder `a la base en meme
temps ;
les redacteurs ecrivent dans la base de donnees, et doivent y avoir un acc`es exclusif.
Probl`
eme du coiffeur endormi
Il y a N chaises dans un salon de coiffure.
Si le coiffeur na personne `
a coiffer, il sendort.
Si un client rentre dans le salon
et que les N chaises sont occupees, il repart.
et quil y a des chaises libres :
si le coiffeur dort, il le reveille pour se faire coiffer ;
si le coiffeur coiffe, il sassoit dans la salle dattente et attend (i.e. sendort).
Comment programmer les clients et le coiffeur ? Voici quelques indices :
Compteur pour les clients (pour verifier le nombre dans la salle dattente). Penser `a proteger le compteur par un
mutex.
Semaphore duboulot qui endormira, reveillera le coiffeur.
Semaphore salleattente pour endormir et reveiller les clients de la salle dattente.
Comparaison dalgorithmes dordonnancement
Liste FIFO (non preemptif) : FCFS
Plus court temps dexecution (non preemptif) : SJF
Plus court temps restant (preemptif) : SRT
Tourniquet (preemptif) quantum=2
Tourniquet (preemptif) quantum=1
Nous allons calculer le temps de rotation moyen pour une sequence donnee de processus. Le temps de rotation est
la duree qui secoule de lentree du processus dans la file `a la fin de son execution.
A
B
C
D

Date entree
0
1.001
4.001
6.001

Temps dexecution
3
6
4
2

Donnez les sequences dexecution et les temps de rotation moyen de chacun des algorithmes.
Exemple FCFS :
0
T =

D
13 15

1
[(3 0) + (9 1.001) + (13 4.001) + (15 6.001)] = 7.25
4

Comparaison de deux algorithmes dordonnancement avec gestion des priorit


es On consid`ere un
algorithme non preemptif et un preemptif (preemption lors de la fin dun processus ou de larrivee dun nouveau
dans la file dattente)
A
B
C
D

Date entree
0
1
2
3

Temps dexecution
4
3
3
5

Priorite
3
4
6
5

Indiquez lordre dexecution des processus et leur temps moyen dexecution.

4. Exercices

23

Questions diverses
Sur un syst`eme interactif, le choix dun algorithme dordonnancement des processus non preemptif est-il judicieux ?
Sur un syst`eme multiprocesseur `
a n processeurs, quel est le nombre maximum de processus en
execution ?
bloques ?
prets ?
La multiprogrammation est le fait davoir plusieurs processus qui sexecutent pseudo-simultanement. Trouvez
des avantages et des inconvenients `
a la multiprogrammation.

24

Initiation aux syst`emes dexploitation Gea 3

Annexe A

Exemples de code
Les programmes suivants peuvent etre compiles avec le compilateur gcc sous Gnu/Linux. Il est probable que les
adaptations necessaires au bon fonctionnement de ces programmes sous un autre syst`eme sont minimes.

Processus et s
emaphores

25

26

Initiation aux syst`emes dexploitation Gea 3

#include
#include
#include
#include

<pthread.h>
<stdio.h>
<stdlib.h>
<unistd.h>
// Variable globale modifi
ee
// par les deux threads
int compt;
// Fonction principale de chacun des threads
void *fonc(void * param)
{
int num=(int)param;
while(compt<10)
{
compt++;
printf("T %d : compt=%d\n",num,compt);
usleep(100*num);
}
pthread_exit(NULL);
}

#include <stdio.h>
#include <sys/types.h>
#include <unistd.h>
int compt;
void fonc()
{
pid_t fpid=getpid();
while(compt<10)
{
compt++;
printf("P %d : compt=%d\n",fpid,compt);
sleep(1);
}
}

int main(void)
{

compt=0;
// Cr
eation des fils
while(pid!=0 && i<2)
{
pid=fork();
if (pid==0) fonc();
i++;
}
// Il nest pas n
ecessaire dattendre
// la fin des fils. Chaque processus
// se terminera `
a son tour
return 0;

int main(void)
{
pthread_t thread[2];
compt=0;
// Creation des deux threads
pthread_create(&thread[0],NULL,fonc,(void*)1);
pthread_create(&thread[1],NULL,fonc,(void*)2);
// On attend la fin de lex
ecution des deux
// threads. Si on attend pas, le processus
// se termine et les threads ne comptent pas.
pthread_join(thread[0],NULL);
pthread_join(thread[1],NULL);
return 1;
}
>
T
T
T
T
T
T
T
T
T
T

./threads1
1 : compt=1
2 : compt=2
1 : compt=3
1 : compt=4
2 : compt=5
1 : compt=6
2 : compt=7
1 : compt=8
1 : compt=9
2 : compt=10

int i=0,pid=-1;

}
>
P
P
P
P
P
P
P
P
P
P
P
P
P
P
P
P
P
P
P
P

./processus1
419 : compt=1
420 : compt=1
419 : compt=2
420 : compt=2
419 : compt=3
420 : compt=3
419 : compt=4
420 : compt=4
419 : compt=5
420 : compt=5
419 : compt=6
420 : compt=6
419 : compt=7
420 : compt=7
419 : compt=8
420 : compt=8
419 : compt=9
420 : compt=9
419 : compt=10
420 : compt=10

Src. A.1: Creation et utilisation de processus ou de threads

27

A. Exemples de code

Dner des philosophes

#include
#include
#include
#include
#include

<pthread.h>
<semaphore.h>
<stdio.h>
<stdlib.h>
<unistd.h>

// Diner des philosophes


// Cette version nemp^
eche pas les interblocages
sem_t fourchette[5];

void penser(int i)

void epilogue(int i)
{
printf("Philo %d : Repose fourch droite \n",i);
sem_post(&fourchette[i+1 % 5]);
printf("Philo %d : Repose fourch gauche \n",i);
sem_post(&fourchette[i]);
}

void* philosophe(void * param)


{

int i=(int)param;

printf("Philo %d : Je pense...\n",i);
sleep(rand()%5+2);
printf("Philo %d : Jai fini de penser...\n",i);

while(1)

void manger(int i)

penser(i);
prologue(i);
manger(i);
epilogue(i);

{
printf("Philo %d : Je mange...\n",i);
sleep(rand()%5+3);
printf("Philo %d : Jai fini de manger...\n",i);

}
pthread_exit(NULL);

void prologue(int i)

int main(void)

{
printf("Philo %d : Tentative prise \...
fourchette gauche\n",i);
sem_wait(&fourchette[i]);
printf("Philo %d : Tentative prise \...
fourchette droite \n",i);
sem_wait(&fourchette[(i+1) % 5]);

pthread_t philo[5];
int i;
for (i=0;i<5;i++) sem_init(&fourchette[i],0,1);
for (i=0;i<5;i++) pthread_create(&philo[i], \...
NULL, philosophe,(void*)i);
for (i=0;i<5;i++) pthread_join(philo[i],NULL);
return 0;

}
}

Src. A.2: Programmation du dner des philosophes. Cette version nempeche pas letreinte fatale (comme le montre
la capture dexecution)

28

Philo
Philo
Philo
Philo
Philo
Philo
Philo
Philo
Philo
Philo
Philo
Philo
Philo
Philo
Philo
Philo
Philo
Philo
Philo
Philo
Philo
Philo
Philo
Philo
Philo
Philo
Philo
Philo
Philo
Philo
Philo
Philo
Philo
Philo
Philo
Philo
Philo
Philo
Philo
Philo
Philo
Philo
Philo
Philo
Philo
Philo

Initiation aux syst`emes dexploitation Gea 3

0
1
2
3
4
3
3
3
3
1
1
1
1
2
2
0
0
0
4
4
3
3
4
3
3
1
1
1
0
1
2
2
3
3
1
1
2
2
2
2
3
0
0
0
0
4

:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:

Je pense...
Je pense...
Je pense...
Je pense...
Je pense...
Jai fini de penser...
Tentative prise fourchette
Tentative prise fourchette
Je mange...
Jai fini de penser...
Tentative prise fourchette
Tentative prise fourchette
Je mange...
Jai fini de penser...
Tentative prise fourchette
Jai fini de penser...
Tentative prise fourchette
Tentative prise fourchette
Jai fini de penser...
Tentative prise fourchette
Jai fini de manger...
Repose fourch droite
Tentative prise fourchette
Repose fourch gauche
Je pense...
Jai fini de manger...
Repose fourch droite
Repose fourch gauche
Je mange...
Je pense...
Tentative prise fourchette
Je mange...
Jai fini de penser...
Tentative prise fourchette
Jai fini de penser...
Tentative prise fourchette
Jai fini de manger...
Repose fourch droite
Repose fourch gauche
Je pense...
Tentative prise fourchette
Jai fini de manger...
Repose fourch droite
Repose fourch gauche
Je pense...
Je mange...

gauche
droite

gauche
droite

gauche
gauche
droite
gauche

droite

droite

gauche
gauche

droite

Philo
Philo
Philo
Philo
Philo
Philo
Philo
Philo
Philo
Philo
Philo
Philo
Philo
Philo
Philo
Philo
Philo
Philo
Philo
Philo
Philo
Philo
Philo
Philo
Philo
Philo
Philo
Philo
Philo
Philo
Philo
Philo
Philo
Philo
Philo
Philo
Philo
Philo
Philo
Philo
Philo
Philo
Philo
Philo
Philo

1
1
0
0
2
2
1
1
1
1
2
4
4
4
4
3
4
4
1
1
1
3
3
4
3
2
3
3
3
2
2
2
2
3
1
2
2
1
1
2
1
1
1
1
1

:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:

Tentative prise fourchette


Je mange...
Jai fini de penser...
Tentative prise fourchette
Jai fini de penser...
Tentative prise fourchette
Jai fini de manger...
Repose fourch droite
Repose fourch gauche
Je pense...
Tentative prise fourchette
Jai fini de manger...
Repose fourch droite
Repose fourch gauche
Je pense...
Je mange...
Jai fini de penser...
Tentative prise fourchette
Jai fini de penser...
Tentative prise fourchette
Tentative prise fourchette
Jai fini de manger...
Repose fourch droite
Tentative prise fourchette
Repose fourch gauche
Je mange...
Je pense...
Jai fini de penser...
Tentative prise fourchette
Jai fini de manger...
Repose fourch droite
Repose fourch gauche
Je pense...
Tentative prise fourchette
Je mange...
Jai fini de penser...
Tentative prise fourchette
Jai fini de manger...
Repose fourch droite
Tentative prise fourchette
Repose fourch gauche
Je pense...
Jai fini de penser...
Tentative prise fourchette
Tentative prise fourchette

Src. A.3: Trace de lexecution du dner des philosophes avec etreinte fatale

droite

gauche
gauche

droite

gauche
gauche
droite

droite

gauche

droite

gauche

droite

gauche
droite

29

A. Exemples de code

#include
#include
#include
#include
#include

<pthread.h>
<semaphore.h>
<stdio.h>
<stdlib.h>
<unistd.h>

void epilogue(int i)
{
printf("Philo %d : == Pose
sem_post(&fourchette[(i+1)
printf("Philo %d : == Pose
sem_post(&fourchette[i]);
printf("Philo %d : == Sors
sem_post(&antichambre);

// Diner des philosophes


// Il ny a plus dinterblocage

fourch droite \n",i);


% 5]);
fourch gauche \n",i);
antichambre \n",i);

}
sem_t fourchette[5];
sem_t antichambre;

void penser(int i)

void* philosophe(void * param)


{

int i=(int)param;

{
printf("Philo %d : == Je pense...\n",i);
usleep(1000+rand()%5000);

while(1)
{

void manger(int i)

penser(i);
prologue(i);
manger(i);
epilogue(i);

{
printf("Philo %d : == Je mange...\n",i);
usleep(1000+rand()%5000);

}
pthread_exit(NULL);

void prologue(int i)
{
printf("Philo %d : Souhaite entrer antich\n",i);
sem_wait(&antichambre);
printf("Philo %d : == Suis entr
e antich\n",i);
printf("Philo %d : Souhaite fourch gauche\n",i);
sem_wait(&fourchette[i]);
printf("Philo %d : == Fourchette gauche\n",i);
printf("Philo %d : Souhaite fourch droite \n",i);
sem_wait(&fourchette[(i+1) % 5]);
printf("Philo %d : == Fourchette droite \n",i);

int main(void)
{
pthread_t philo[5];
int i;
for (i=0;i<5;i++) sem_init(&fourchette[i],0,1);
sem_init(&antichambre,0,4);
for (i=0;i<5;i++) pthread_create(&philo[i], \...
NULL,philosophe,(void*)i);
for (i=0;i<5;i++) pthread_join(philo[i],NULL);
return 0;

}
}

Src. A.4: Programmation du dner des philosophes. Cette version r`egle le probl`eme de letreinte fatale et de la
famine par lutilisation dun semaphore initialise `a 4.

30

Initiation aux syst`emes dexploitation Gea 3

Table des figures


1.1
1.2
1.3
1.4
1.5

Mod`ele de Von Neumann . . .


Structure dun ordinateur . . .
Utilisation du pointeur ordinal
Utilisation de la pile . . . . . .

Etapes
dune operation dentree

. . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . .
sortie utilisant les interruptions .

2.1
2.2
2.3
2.4

Gestion des sections critiques par la methode de Peterson : cas simple . . . .


Gestion des sections critiques par la methode de Peterson : deux processus en
Execution par la methode Fifo . . . . . . . . . . . . . . . . . . . . . . . . . .
Plus court temps dexecution dabord . . . . . . . . . . . . . . . . . . . . . .

3.1
3.2
3.3
3.4
3.5
3.6
3.7
3.8
3.9

Deux processus A et B en situation dinterblocage . . . . . . . .


Situation reelle avec 3 processus en phase dinterblocage . . . . .
Exemple dexecution de deux processus . . . . . . . . . . . . . .
Exemple dexecution de deux processus avec usage de ressources
Exemple dexecution de deux processus avec usage de ressources :
Exemple dexecution de deux processus avec usage de ressources :

Etats
s
urs et non s
urs . . . . . . . . . . . . . . . . . . . . . . . .
Matrices utilisees par lalgorithme du banquier . . . . . . . . . .
Algorithme du banquier . . . . . . . . . . . . . . . . . . . . . . .

4.1

Probl`eme des philosophes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21

31

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

1
2
2
3
5

. . . . . . .
concurrence
. . . . . . .
. . . . . . .

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

. 9
. 10
. 11
. 11

. . . . . . . . . . . . . .
. . . . . . . . . . . . . .
. . . . . . . . . . . . . .
. . . . . . . . . . . . . .
situation dinterblocage
pas dinterblocage . . .
. . . . . . . . . . . . . .
. . . . . . . . . . . . . .
. . . . . . . . . . . . . .

.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.

13
14
16
16
17
17
18
18
19

32

Initiation aux syst`emes dexploitation Gea 3

Table des codes source


A.1 Creation et utilisation de processus ou de threads . . . . . . . . . . . . . . . . . . . . . . . . . . . .
A.2 Programmation du dner des philosophes. Cette version nempeche pas letreinte fatale (comme le
montre la capture dexecution) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
A.3 Trace de lexecution du dner des philosophes avec etreinte fatale . . . . . . . . . . . . . . . . . . .
A.4 Programmation du dner des philosophes. Cette version r`egle le probl`eme de letreinte fatale et de
la famine par lutilisation dun semaphore initialise `a 4. . . . . . . . . . . . . . . . . . . . . . . . .

33

. 26
. 27
. 28
. 29

34

Initiation aux syst`emes dexploitation Gea 3

Bibliographie
[1] Joffroy Beauquier and Beatrice Berard. Syst`eme dexploitation : concepts et algorithmes. Ediscience International, 1990.
[2] Christophe Blaess. Programmation syst`eme en C sous Linux. Collection Blanche. Eyrolles, 2005.
[3] Laurent Bloch. Les syst`emes dexploitation des ordinateurs. Vuibert, 2003.
[4] Samia Bouzefrane. Les syst`emes dexploitation. Dunod, 2003.
[5] Bart Lamiroy, Laurent Najman, and Hugues Talbot. Syst`emes dexploitation. Collection Synthex. Pearson
Education, 2006.
[6] Andrew Tanenbaum. Syst`emes dexploitation. Pearson Education, 2 edition, 2003.

35

Index
etats
non s
urs, 15
s
urs, 15
etreinte fatale, 13

preemptifs, 10
non, 10
processeur, 2
processus, 7
bloque, 8
en cours dexecution, 8
leger, voir thread
pret, 8
pseudo-simultaneite, 8
Psw, 2

alternance stricte, 9
appel syst`eme, 5, 8
coiffeur endormi, 22
concurrence, 8
contr
oleurs, 4

requisition
avec, 10
sans, 10
rollback, 15
round robin, 12

deroutements, 4
deadlock, 13
exclusion mutuelle, 9
fichier dechange, 4

semaphores, 10
section critique, 8
signaux, 4
swap, 4

interblocage, 13
detection, 14
interruption, 10
interruptions, 4
Irq, 5

thread, 12
tourniquet, 12

lecteurs, redacteurs, 22

verrou, 9

memoire, 2
cache, 2
virtuelle, 2
vive, 2
Memory Management Unit, 4
Mmu, voir Memory Management Unit
mode
noyau, 5
privilegie, 5
superviseur, 5
utilisateur, 5
mot detat, 2
multiprogrammation, 7
mutex, 10
ordonnancement, 10
ordonnanceur, 8
Peterson, 9
philosophes, 21
pile, 2
pilotes de peripheriques, 4
pointeur ordinal, 2
points de reprise, 15

36