Cours Sys

Ecole
Superieure dIngenieurs de Poitiers

Gea 3
Initiation aux systèmes dexploitation

Laurent Signac
ii
Initiation aux systèmes dexploitation Gea 3
Table des mati`

eres
Avant Propos
1 Ordinateur et syst`
eme dexploitation
1
Quest-ce quun système dexploitation ?
2
Modèle 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ème 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ème 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
Avant Propos
e cours a pour objet lintroduction aux systèmes 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èmes temps reels. De nombreuses impasses ont donc ete faites et le resultat est très 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ès 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ès
clairs, [6] qui reste une reference en la matière, et [4] qui est recent et assez technique.
Enfin, on trouvera des exemples de code pour Linux dans [2] et une synthèse recente dans [5].
vi
Chapitre 1
Ordinateur et syst`
eme dexploitation
D
1
ans ce chapitre, nous allons evoquer le modèle theorique à la base de linformatique actuelle, et
presenter certains des elements qui composent un ordinateur. Nous decrirons brièvement comment
se deroule lexecution dun programme et aborderons le role du système dexploitation comme chef
dorchestre de lensemble de la machine.
Quest-ce quun syst`

eme dexploitation ?
Un système dexploitation est un logiciel (`

a opposer au materiel qui constitue lelectronique de lordinateur) qui
gère lordinateur et ses peripheriques, et permet à dautres logiciels detre executes.
Les systèmes 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èmes dexploitation sont destines plutot au grand public, dautres à des systèmes plus professionnels.
Ils peuvent meme etrededies `
a des types particuliers dapplications (systèmes embarques, systèmes temps reels...).
Mod`
ele de Von Neumann
Tous les ordinateurs actuels suivent le modèle de Von Neumann, elabore par le mathematicien hongrois au milieu
du siècle (figure 1.1).
Unite de
contr
ole
Unite arithmetique
Registres
Unite dentrees
sorties
Memoire contenant les programmes

et les donnes
Fig. 1.1 Modèle de Von Neumann
Nous avons dej`
a vu que les actions que peut effectuer le processeur dun ordinateur sont très simples et se resument
a des operateurs arithmetiques et logiques et à 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.
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, à 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 à 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ètres 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ès succinctement en signalant quen general on peut la considerer à plusieurs niveaux.
` mesure que les niveaux avancent, le prix diminue ainsi que la vitesse daccès. Les registres du processeur sont des
A
memoires. Ils sont très 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èmes dexploitation actuels gèrent la
memoire virtuelle. Le principe est assez simple : si la memoire vive vient à etre saturee (trop de processus en cours
1. Ordinateur et système 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
dexecution, utilisant trop de donnees), le système 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ème dexploitation est donc amene à 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ès
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 : à 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, à quelle adresse il se trouvera en memoire. Il
suppose donc quil sera charge `
a ladresse 0 et accède à ses donnees en calculant leur adresse à partir de 0. Lorsque
le programme est charge en memoire pour etre execute, il ne sera pas charge à 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èdent directement au materiel. Et le materiel nest accede que
par eux. Ils presentent donc une interface plus ou moins harmonisee au système. Il existe neanmoins differents types
de contr
oleurs. Pour chaque type de contr
oleur, le système 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ème dexploitation, et qui
savent comment sadresser aux contr
oleurs de peripheriques.
Interruptions
Les interruptions ont ete necessaires avec lutilisation massive des entrees-sorties (accès disques). Avant lutilisation des interruptions, le processeur après avoir demande à realiser une operation dentree-sortie devait contr
oler
regulièrement si la fin de loperation etait terminee (un peu comme un cuisinier, que nous retrouverons plus loin,
oblige de passer regulièrement 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 à 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ère.
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ère) 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, à 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ère etape, le processeur demande une operation dentree-sortie, puis soccupe à 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ème 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ème 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èmement 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 à 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ème, que
le système dexploitation realise pour lui la sauvegarde.
Le système 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ème dexploitation, qui nous livre une vue simplifiee
sur la machine.
Enfin, le système 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èmes, et nous venons de dire que le système dexploitation avait la
` ce titre, le système 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ède au moins deux modes de fonctionnement : le mode privilegie (ou mode superviseur ou mode
noyau) et le mode utilisateur. Le système dexploitation ((tourne)) en mode privilegie, alors que les autres processus
tournent en mode utilisateur.
Chapitre 2
Processus
orsque nous utilisons un ordinateur actuel, de nombreux programmes sont lances ((en meme temps)),
si bien que nous pouvons continuer à taper du texte dans un traitement de texte pendant que notre
machine calcule une image de synthèse 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èle
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ème dexploitation.
Notion de processus
Nous savons dej`

a quun programme est un texte ecrit en langage machine. Un processus est à peu de choses près
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ès aux peripheriques, de la memoire...
Lanalogie suivante, empruntee dans [6] et legèrement adaptee, permettra de mieux comprendre la difference entre
un processus et un programme : Supposons le cas dun chef cuisinier (le processeur), face à la recette dun g
ateau
(le programme). Le chef cuisinier doit realiser deux gateaux, cest-à-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ère realisation, puis sur la deuxième, ou bien tour à tour sur la première
et la deuxième. 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ème 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ème dexploitation dans la table des processus et cest à la charge du système
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...
table, qui varie de toutes facons selon les systèmes. 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, à la demande de
lutilisateur) en gerant lexecution au mieux de chacun des processus, leur accès aux ressources, et ceci en offrant
un certain confort dutilisation `
a lutilisateur (pas de processus bloques indefiniment etc...) revient au système
dexploitation. Nous aborderons ici uniquement le cas de machines monoprocesseur (on dit alors que le système
dexploitation fait de la pseudo-simultaneite).
2.1
Orchestration des processus
Un système 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ème 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ème dexploitation. Un processus qui cree un autre processus demande au système de le faire pour lui, par
lintermediaire dun appel système.
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ème cas correspond au processus qui pourrait etre execute par le processeur à cet instant precis, mais qui ne
lest pas, parce que le système dexploitation en a decide autrement. Enfin, letat bloque correspond à un processus
qui ne pourrait pas etre execute actuellement, parce quil est en attente dun evènement qui ne sest pas encore
produit. Reprenons notre analogie du cuisinier et supposons que ce dernier ne possède 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 à 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 à 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, à laide dune brouette, et lajouter sur le tas. Si
une seule personne fait ce travail, aucun problème 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ème 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à 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 à 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 à 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 à 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ès `
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 à la sortie en c), il remet `
a 0 la
valeur inter^
et[1].
Si deux processus demandent ((simultanement)) laccès à 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] à 0, ce qui permet
au processus 1 dentrer en d) dans sa section critique.
2 Attention,
`
a la condition
10
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ères modifications dans ce qui precède nous amène à la solution introduite par Dijkstra au milieu du siècle :
les semaphores. Selon les ouvrages, les semaphores sont decrits de facons legèrement differentes. Nous reprenons ici
une des definitions les plus simples. Un semaphore est un compteur associe à une liste dattente. Si un processus
veut acceder `
a une ressource ou entrer dans une section critique, il le demande par un appel système : down(sem)
o`
u sem est le semaphore associe `
a cette ressource ou à 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ème. Sinon, rien de particulier ne se passe et le processus accède à la ressource. Lorsque la section critique
ou laccès `
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ème reveille un des processus de la liste dattente, qui accède alors à 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ès à une valeur ou entree dans une
section critique) est appele mutex.
Ordonnancement des processus
Jusqu`
a present, nous avons souvent ecrit : le système dexploitation choisit un autre processus... Mais comment
le choisit-il ? La facon dont le système regule lexecution des processus est appelee sa methode dordonnancement.
Nous allons en exposer quelques principes. Notons tout dabord une difference fondamentale entre les systèmes
preemptifs et les systèmes non preemptifs. Dans le second cas, un processus en cours dexecution ne sera pas
interrompu par le système. Ce sera au processus lui-meme de decider de se bloquer, pour laisser le système choisir
un autre processus `
a effectuer. Dans le premier cas, un signal dhorloge provoque regulièrement une interruption
et le système peut choisir dinterrompre le processus afin den choisir un autre. Seuls des systèmes dedies à 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ème sil ne rend jamais la main. La dualite preemptif/non preemptif est parfois appelee avec
requisition/sans requisition.
Enfin, nous nous interesserons plus particulièrement ici à lordonnancement des processus vis à vis de leur execution
sur le processeur. Dans un système reel, les algorithmes dordonnancement sont presents pour laccès à 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 à 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ès 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 à executer les processus de la liste à 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 à 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ème est dote dun horloge capable de generer des interruptions `
a intervalles reguliers. Dans cette mesure, le système dexploitation peut ((reprendre la main)) regulièrement
et choisir dinterrompre le processus courant pour en executer un autre. Le système doit aussi pouvoir sauvegarder
le contexte dexecution du processus et bien s
ur le restaurer (voir section 1.2 du chapitre 2).
12
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ère les dernières 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èmes 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èdent, en plus des autres, une echeance, à 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ème
dexploitation, possedant chacun leur propre espace dadressage.
Ce système 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 à letancheite,
par exemple si les differentes ((t
aches)) utilisent les meme donnees. Lexemple donne dans [6] est tout à 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 à recalculer la mise en page (par exemple la
renumerotation de toutes les pages en cas dune suppression), et garantisse des sauvegardes automatiques regulières.
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à 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ème dexploitation lui-meme (la gestion des
threads est alors native), ou bien par un système dexecution intermediaire entre lOs et les processus (et le
système 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 à 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ère 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 à faire la première 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ède dejà une ;
il est impossible de retirer de force une ressource à 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ès `
a une
ressource, les nuds sont relies par une flèche allant du processus vers la ressource. Si le processus a obtenu laccès
a la ressource, le sens de la flèche 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ède un cycle.
A
R
S
B
Fig. 3.1 Deux processus A et B en situation dinterblocage
13
14
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ème, 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èmes qui peuvent survenir.
3.2
D
etection et reprise
La methode ne consiste pas `

a prevenir les interblocages, mais à les constater, puis à y remedier. La facon la plus
evidente pour le système 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 à 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 à 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 à 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ède deux imprimantes (lune ou lautre pouvant etre affectee à un processus desirant imprimer). Une facon de
modeliser ce problème 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ème ligne de R est inferieure ou egale1 à A
ajouter la ième ligne de C à A
marquer le processus
sil reste des processus non marques, une situation dinterblocage existe
Cet algorithme peut etre execute regulièrement, ou bien lorsque la charge du processeur diminue.
Une fois linterblocage detecte, il reste neanmoins à regler le problème. Voici quelques solutions.
Reprise par rollback Cette solution consiste à enregistrer regulièrement letat de chaque processus de facon `
a
permettre au système de revenir en arrière dans lexecution de lun deux. Si le système de points de reprise est en
place, il suffit, après 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ère 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ème permet generalement à 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 à prevoir. La
solution la plus adaptee, quoi quassez restrictive consiste à ordonner les ressources et à 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 à 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 à 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ède 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ède 3 ressources et en voudra
6 de plus, le processus B possède 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
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
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
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 à 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ème des philosophes

Lactivite des philosophes consiste `
a penser et à 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 à un interblocage.
Le processus philosophe a pour modèle :
Processus philosophe
r
ep
eter indefiniment
Penser
Prologue
Manger
Epilogue
1 Inversion
de deux lignes.
21
22
Il sagit decrire correctement les procedures Prologue et Epilogue.

Probl`
eme des lecteurs/r
edacteurs Lexemple type est laccès à une base de donnees de reservation (SNCF
par exemple) :
les lecteurs lisent le contenu de la base de donnees, et plusieurs lecteurs peuvent acceder à la base en meme
temps ;
les redacteurs ecrivent dans la base de donnees, et doivent y avoir un accès 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 à 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 à 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ère 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ème interactif, le choix dun algorithme dordonnancement des processus non preemptif est-il judicieux ?
Sur un système 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
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ème sont minimes.
Processus et s
emaphores
25
26
#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
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
Je mange...
Je mange...
Jai fini de manger...
Repose fourch droite
Repose fourch gauche
Je pense...
Je mange...
Je pense...
Je mange...
Je pense...
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
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:

Je mange...
Je pense...
Je pense...
Je mange...
Je mange...
Je pense...
Je pense...
Je mange...
Je pense...
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ègle le problème de letreinte fatale et de la
famine par lutilisation dun semaphore initialise à 4.
30
Table des figures

1.1
1.2
1.3
1.4
1.5
Modèle 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ème 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
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ègle le problème de letreinte fatale et de
la famine par lutilisation dun semaphore initialise à 4. . . . . . . . . . . . . . . . . . . . . . . . .
33
. 26
. 27
. 28
. 29
34
Bibliographie
[1] Joffroy Beauquier and Beatrice Berard. Système dexploitation : concepts et algorithmes. Ediscience International, 1990.
[2] Christophe Blaess. Programmation système en C sous Linux. Collection Blanche. Eyrolles, 2005.
[3] Laurent Bloch. Les systèmes dexploitation des ordinateurs. Vuibert, 2003.
[4] Samia Bouzefrane. Les systèmes dexploitation. Dunod, 2003.
[5] Bart Lamiroy, Laurent Najman, and Hugues Talbot. Systèmes dexploitation. Collection Synthex. Pearson
Education, 2006.
[6] Andrew Tanenbaum. Systèmes 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ème, 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

Cours Sys

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Cours Sys

Uploaded by

Copyright:

Available Formats

Ecole

Superieure dIngenieurs de Poitiers

Initiation aux syst`emes dexploitation

Initiation aux syst`emes dexploitation Gea 3

Table des mati`

Table des codes sources

Initiation aux syst`emes dexploitation Gea 3

Initiation aux syst`emes dexploitation Gea 3

Quest-ce quun syst`

Un syst`eme dexploitation est un logiciel (`

Memoire contenant les programmes

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

Initiation aux syst`emes dexploitation Gea 3

Fig. 1.2 Structure dun ordinateur

Fig. 1.3 Utilisation du pointeur ordinal

1. Ordinateur et syst`eme dexploitation

Appel proc 0x2000

Appel proc 0x2000

Appel proc 0x2000

Appel proc 0x2000

Appel proc 0x2000

Appel proc 0x2000

Fig. 1.4 Utilisation de la pile

Initiation aux syst`emes dexploitation Gea 3

Viennent enfin les differents contr

1. Ordinateur et syst`eme dexploitation

Fig. 1.5 Etapes

Initiation aux syst`emes dexploitation Gea 3

Nous savons dej`

Nous avons dej`

Initiation aux syst`emes dexploitation Gea 3

Orchestration des processus

Conditions de concurrence, sections critiques

Initiation aux syst`emes dexploitation Gea 3

Blocage des processus et s

Ordonnancement des processus

Fig. 2.3 Execution par la methode Fifo

Fig. 2.4 Plus court temps dexecution dabord

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

Plus court temps dex

Nous obtiendrons lexecution representee figure 2.4

Initiation aux syst`emes dexploitation Gea 3

Fig. 3.1 Deux processus A et B en situation dinterblocage

Initiation aux syst`emes dexploitation Gea 3

Fig. 3.2 Situation reelle avec 3 processus en phase dinterblocage

Gestion des interblocages

La methode ne consiste pas `

Un interblocage est detecte ainsi

vecteur est inf

Initiation aux syst`emes dexploitation Gea 3

Fig. 3.3 Exemple dexecution de deux processus

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

Initiation aux syst`emes dexploitation Gea 3

Fig. 3.7 Etats

Fig. 3.8 Matrices utilisees par lalgorithme du banquier

Fig. 3.9 Algorithme du banquier

Initiation aux syst`emes dexploitation Gea 3

(a) Disposition des philosophes et des couverts

(b) Les philosophes en pleine action

Fig. 4.1 Probl`eme des philosophes

Initiation aux syst`emes dexploitation Gea 3

Il sagit decrire correctement les procedures Prologue et Epilogue.

Comparaison de deux algorithmes dordonnancement avec gestion des priorit