cours_sys

Ecole Superieure d’Ingenieurs de PoitiersGea 3

Initiation aux systemes d’exploitation

Laurent Signac

ii Initiation aux systemes d’exploitation – Gea 3–

Table des matieres

Avant Propos v

1 Ordinateur et systeme d’exploitation 11 Qu’est-ce qu’un systeme d’exploitation ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12 Modele de Von Neumann . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13 Structure materielle d’un ordinateur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1

3.1 Registres du processeur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23.2 Memoire . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23.3 Peripheriques d’entrees-sorties . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4

4 Interruptions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45 Role du systeme d’exploitation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5

2 Processus 71 Notion de processus . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7

1.1 Partage de l’execution . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71.2 Sauvegarde du contexte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7

2 Role du systeme d’exploitation dans le controle des processus . . . . . . . . . . . . . . . . . . . . . . 82.1 Orchestration des processus . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82.2 Conditions de concurrence, sections critiques . . . . . . . . . . . . . . . . . . . . . . . . . . . 8

3 Ordonnancement des processus . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 103.1 Algorithmes non preemptifs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 113.2 Algorithmes preemptifs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11

4 Threads . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12

3 Interblocages 131 Conditions necessaires a un interblocage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 132 Modelisation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 133 Gestion des interblocages . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14

3.1 Ignorer les interblocages . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 143.2 Detection et reprise . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 143.3 Eviter les interblocages . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15

4 Exercices 21

A Exemples de code 251 Processus et semaphores . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 252 Dıner des philosophes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27

Table des figures 31

Table des codes sources 33

iii

iv Initiation aux systemes d’exploitation – Gea 3–

Avant Propos

Ce cours a pour objet l’introduction aux systemes d’exploitation. Ce domaine est vaste et c’est a lafois un champ de recherche et une manne d’applications et d’innovations technologiques. Justementen raison du nombre important de connaissances qu’il serait possible de rassembler dans ce domaine,un choix a du etre fait dans ce support de cours : donner quelques bases qui seront necessaires au

suivi d’un cours de systemes temps reels. De nombreuses impasses ont donc ete faites et le resultat est tres loind’etre exhaustif. Le lecteur interesse pourra se reporter au nombreux ouvrages sur la question, desquels ce coursest largement inspire. Citons [3] qui est tres agreablement ecrit et passe en revue beaucoup de choses sans tropse perdre dans les details, [1] dont la presentation est un peu vieillissante mais qui presente des algorithmes tresclairs, [6] qui reste une reference en la matiere, et [4] qui est recent et assez technique.Enfin, on trouvera des exemples de code pour Linux dans [2] et une synthese recente dans [5].

v

vi Initiation aux systemes d’exploitation – Gea 3–

Chapitre 1

Ordinateur et systeme d’exploitation

Dans ce chapitre, nous allons evoquer le modele theorique a la base de l’informatique actuelle, etpresenter certains des elements qui composent un ordinateur. Nous decrirons brievement commentse deroule l’execution d’un programme et aborderons le role du systeme d’exploitation comme chefd’orchestre de l’ensemble de la machine.

1 Qu’est-ce qu’un systeme d’exploitation ?

Un systeme d’exploitation est un logiciel (a opposer au materiel qui constitue l’electronique de l’ordinateur) quigere l’ordinateur et ses peripheriques, et permet a d’autres logiciels d’etre executes.Les systemes d’exploitation les plus connus sont Windows, Mac OS et Linux, mais il en existe une quantite d’autres,comme par exemple : BeOS, Solaris, HP/UX, Plan 9, QNX etc1...Certains systemes d’exploitation sont destines plutot au grand public, d’autres a des systemes plus professionnels.Ils peuvent meme etrededies a des types particuliers d’applications (systemes embarques, systemes temps reels...).

2 Modele de Von Neumann

Tous les ordinateurs actuels suivent le modele de Von Neumann, elabore par le mathematicien hongrois au milieudu siecle (figure 1.1).

Registres

Unite arithmetiqueUnite decontrole

Unite d’entreessorties

Memoire contenant les programmeset les donnes

Fig. 1.1 – Modele de Von Neumann

Nous avons deja vu que les actions que peut effectuer le processeur d’un ordinateur sont tres simples et se resumenta des operateurs arithmetiques et logiques et a des communications avec la memoire (et les peripheriques). Dansla section suivante, nous allons aller un peu plus dans le detail.

3 Structure materielle d’un ordinateur

Un ordinateur actuel peut etre schematise comme indique sur la figure 1.2. Le cœur de l’ordinateur 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).

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

1

2 Initiation aux systemes d’exploitation – Gea 3–

Processeur Memoire Controleurvideo

Controleurclavier

Controleurdisque

Bus

Fig. 1.2 – Structure d’un ordinateur

Memoire

Pointeur ordinal

ProcesseurP

rogramm

e

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 d’un programme (lire en memoire,dialoguer avec les controleurs etc...). Les programmes eux-memes sont ecrits en memoire et l’essentiel du travail duprocesseur consiste a lire dans la memoire la prochaine instruction du programme, a l’executer, etc... Il dispose doncd’un pointeur (le pointeur ordinal) qui lui indique la prochaine instruction qu’il devra effectuer, comme indique surla figure 1.3.Un programme, meme ecrit en langage machine, contient des appels de procedures (d’autres portions de pro-gramme). Imaginons que l’adresse 0x1000 contienne un appel de procedure, situee a l’adresse 0x2000. Le pointeurordinal pointera a l’adresse 0x2000 et executera la procedure. Une fois celle ci-terminee, l’execution doit reprendre al’adresse 0x1001. Le processeur doit donc disposer d’un moyen de sauvegarder l’adresse depuis laquelle la procedurea ete appelee. Ceci est realise par l’intermediaire de la pile, qui contient aussi les parametres et les variables localesdes procedures. La pile, situee en memoire, ((empile)) les differentes adresses qui seront necessaires pour continuerl’execution du programme a la fin d’une procedure. Le processeur a donc besoin d’un nouveau registre pour luiindiquer le sommet de la pile (cf. structure de pile du cours d’algorithmique). La figure 1.4 schematise l’appel dela procedure A depuis le programme principal, de la procedure B depuis la procedure A, ainsi que le retour auprogramme principal.Signalons ensuite un registre particulier contenant le ((mot d’etat)) (parfois appele Psw), qui comme son noml’indique decrit l’etat du processeur en fonction des valeurs de certains bits (resultat d’une comparaison, mode duprocesseur etc..). Enfin, le processeur dispose aussi de registres prevus pour les donnees (des adresses, ou bien desdonnees recuperees en memoire).

3.2 Memoire

Nous decrirons la memoire tres succinctement en signalant qu’en general on peut la considerer a plusieurs niveaux.A mesure que les niveaux avancent, le prix diminue ainsi que la vitesse d’acces. Les registres du processeur sont desmemoires. Ils sont tres rapides, mais peu nombreux, en raison de leur cout. Puis vient la memoire cache, toujourspresente dans les processeurs actuels, qui contient une copie d’une portion de la memoire vive. La memoire cachen’en contient qu’une portion car elle est beaucoup plus petite, mais elle est aussi beaucoup plus rapide. Ensuite,vient la memoire vive. C’est celle que nous avons representee sur les schemas 1.3 et 1.4. Puis viennent les unitesde stockage (qui sont des formes de memoire) comme les disques. Les systemes d’exploitation actuels gerent lamemoire virtuelle. Le principe est assez simple : si la memoire vive vient a etre saturee (trop de processus en cours

1. Ordinateur et systeme d’exploitation 3

Appel proc 0x2000Pointeur ordinal

Pointeur de pile

Processeur Memoire

0x100 Appel proc 0x2000Pointeur ordinal

Pointeur de pile

Processeur Memoire

0x1000

0x2000

0x1000

Infossupplementaires


Pointeur de pile

Processeur Memoire

0x1000

0x2000

0x1000


Appel proc 0x3000 0x2001

0x3000

0x2001



Pointeur de pile

Processeur Memoire

0x1000

0x2000

0x1000



0x3000

0x2001


Fin procedure


Pointeur de pile

Processeur Memoire

0x1000

0x2000

0x1000



0x3000

Fin procedure


Pointeur de pile

Processeur Memoire

0x1000

0x2000


0x3000

Fin procedure

Fin procedureFin procedure

Fig. 1.4 – Utilisation de la pile


d’execution, utilisant trop de donnees), le systeme d’exploitation en copie une partie sur un des disques durs de lamachine, afin de liberer de l’espace. S’il a besoin d’utiliser la partie sauvegardee, il la recharge en memoire vive etsauvegarde ce qui n’est pas directement utilise. Le systeme d’exploitation est donc amene a echanger des portionsde 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 tresrapide, mais petite, puis une autre memoire cache moins rapide, mais un peu plus grande etc...). Ce niveau dans lesmemoires caches figure dans les caracteristiques des processeurs (memoire cache L2, pour Level 2 : a deux niveaux).Toujours au sujet de la memoire, signalons l’existence d’un composant place entre le processeur et la memoirenomme Mmu (Memory Management Unit : unite de gestion de la memoire). Son role est de translater les valeursdes adresses. En effet, un programme ne sait pas, avant d’etre execute, a quelle adresse il se trouvera en memoire. Ilsuppose donc qu’il sera charge a l’adresse 0 et accede a ses donnees en calculant leur adresse a partir de 0. Lorsquele programme est charge en memoire pour etre execute, il ne sera pas charge a l’adresse 0. Toutes les adressesdevront donc etre recalculees. C’est le role de la Mmu.

3.3 Peripheriques d’entrees-sorties

Viennent enfin les differents controleurs. Ceux-ci accedent directement au materiel. Et le materiel n’est accede quepar eux. Ils presentent donc une interface plus ou moins harmonisee au systeme. Il existe neanmoins differents typesde controleurs. Pour chaque type de controleur, le systeme d’exploitation doit savoir ce qu’il peut lui demander, etcomment le faire. C’est le role des pilotes de peripheriques, qui sont des parties du systeme d’exploitation, et quisavent comment s’adresser aux controleurs de peripheriques.

4 Interruptions

Les interruptions ont ete necessaires avec l’utilisation massive des entrees-sorties (acces disques). Avant l’utilisa-tion des interruptions, le processeur apres avoir demande a realiser une operation d’entree-sortie devait controlerregulierement si la fin de l’operation etait terminee (un peu comme un cuisinier, que nous retrouverons plus loin,oblige de passer regulierement devant son four pour verifier l’etat de cuisson du plat). Dans les ordinateurs actuels,le mecanisme est different : le processeur demande une operation d’entree-sortie, puis s’occupe a autre chose. C’estau controleur de peripherique de prevenir le processeur lorsque l’operation sera finie (comme si le four du cuisinieretait equipe d’un capteur verifiant la cuisson et sonnait lorsque celle-ci est terminee). Le processeur dispose doncde certaines broches, les entrees d’interruptions, sur lesquelles des signaux emis par d’autres organes de la machinepeuvent arriver. Il est alors averti d’une situation particuliere.Toujours dans les ordinateurs actuels, les interruptions sont divisees en plusieurs niveaux. Ces niveaux changentavec 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 l’interruption.– 3 Sauvegarde du reste du contexte (autres registres du processeur).– 4 Traitement de l’interruption.– 5 Restauration du contexte.– 6 Restauration du compteur ordinal.C’est le gestionnaire d’interruptions (une puce particuliere) qui decide ou non de transmettre l’interruption au pro-cesseur, selon son niveau de priorite (une interruption ne peut elle-meme etre interrompue que par une interruptionplus prioritaire). Les etapes 1, 2 et 6 de la liste precedente sont realisees par le materiel. Les etapes 3, 4 et 5 sontgeneralement a la charge du traitant de l’interruption.Le branchement a une adresse specifique consiste, a partir du niveau d’interuption, a calculer une adresse, donnee parle vecteur d’interruption (une sorte de tableau). Par consequent, deux interruptions de meme niveau provoquerontun branchement a la meme procedure de traitement.Le mecanisme d’une entree-sortie qui utilise les interruptions est schematise sur la figure 1.5.Durant la premiere etape, le processeur demande une operation d’entree-sortie, puis s’occupe a autre chose. Lorsquel’operation est terminee, le controleur d’entrees-sorties envoie un signal d’interruption qui est traite par le controleurd’interruptions, qui decide ou non de faire suivre au processeur.Certains types d’interruptions, selon leur niveau de priorite sont appeles deroutements (c’est le cas pour une erreurdue a une division par 0, par exemple). Sous Unix, les interruptions portent le nom de signaux.

2Sous Windows, le fichier du disque dur qui contient des portions de memoire est d’ailleurs appele fichier d’echange. Sous Linux, cepeut etre une partition du disque, appelee swap.

1. Ordinateur et systeme d’exploitation 5

Processeur Controleurd’interruptions

Controleurd’entrees sortie

1

23

Fig. 1.5 – Etapes d’une operation d’entree sortie utilisant les interruptions

Enfin, la fameuse valeur Irq qu’il fallait regler lors de l’installation de nouveaux peripheriques sur PC, du tempsou le plug and play n’existait pas, correspondait au numero de la broche du controleur d’interruptions qui etaitutilisee par ce peripherique (d’ou la fameuse possibilite de conflit d’Irq).

5 Role du systeme d’exploitation

Le systeme d’exploitation construit une machine ((virtuelle)) sur la machine physique. Cette machine ((virtuelle)) estplus facile d’emploi pour le programmeur et l’utilisateur. Du point de vue du programmeur, par exemple, realiserle stockage d’un fichier sur une disquette serait extremement complexe. La procedure serait differente selon le typede controleur de peripheriques. Pour faire un programme qui fonctionne sur toutes les machines, le programmeurdevrait ecrire du code specifique a chacun de ces controleurs. Il devrait posseder les documentations de tous cescontroleurs pour connaıtre la liste des operations a effectuer (et elles sont nombreuses) pour faire une simplesauvegarde. Le programmeur peut s’affranchir de cette tache en demandant, par le biais d’un appel systeme, quele systeme d’exploitation realise pour lui la sauvegarde.Le systeme d’exploitation prend en charge la gestion complexe des ressources de l’ordinateur (processeur, memoire,peripheriques). Ce point rejoint un peu le precedent. On peut simplement considerer que tous les details techniquesdes differents circuits integres sont pris en charge par le systeme d’exploitation, qui nous livre une vue simplifieesur la machine.Enfin, le systeme d’exploitation optimise l’utilisation de l’ordinateur entre differents processus et differents utilisa-teurs (simultanes). Plusieurs imperatifs tentent d’etre satisfaits :– assurer le fonctionnement correct de l’ordinateur ;– distribuer les ressources de la machine de facon coherente entre les differents processus ;– assurer la securite de l’ensemble des processus, en etablissant une protection etanche entre chacun d’eux.Nous avons parle plus haut des appels systemes, et nous venons de dire que le systeme d’exploitation avait la((garde)) de la machine et des processus qui s’y executent. A ce titre, le systeme d’exploitation doit pouvoir fairedes choses que les processus ordinaires ne peuvent pas faire. Cette distinction de ((droits)) est faite par le processeurlui-meme qui possede au moins deux modes de fonctionnement : le mode privilegie (ou mode superviseur ou modenoyau) et le mode utilisateur. Le systeme d’exploitation ((tourne)) en mode privilegie, alors que les autres processustournent en mode utilisateur.

Chapitre 2

Processus

Lorsque 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 notremachine calcule une image de synthese et essaie d’etablir une connexion avec un site Web. Or nousavons deja dit que meme les ordinateurs actuels (monoprocessseurs) fonctionnaient en suivant le modele

de l’architecture de Von Neuman et qu’un processeur ne pouvait donc effectuer qu’une seule operation a la fois.D’ou provient cette illusion que la machine execute plusieurs operations simultanees ?Le secret reside dans la rapidite d’execution des operations elementaires, dans la notion de processus, et dansl’orchestration de ces processus par le systeme d’exploitation.

1 Notion de processus

Nous savons deja qu’un programme est un texte ecrit en langage machine. Un processus est a peu de choses presce qui resulte de l’execution d’un tel programme. Si nous lancons deux fois un programme, nous obtenons ainsideux processus, qui sont des instances ((dynamiques)) du programme ecrit en langage machine. Ce sont des entitesactives, qui reclament du temps d’execution sur le processeur, des acces aux peripheriques, de la memoire...L’analogie suivante, empruntee dans [6] et legerement adaptee, permettra de mieux comprendre la difference entreun processus et un programme : Supposons le cas d’un chef cuisinier (le processeur), face a la recette d’un gateau(le programme). Le chef cuisinier doit realiser deux gateaux, c’est-a-dire realiser deux fois l’activite decrite dans larecette (deux processus).

1.1 Partage de l’execution

A moins que notre cuisinier soit d’une habilete hors du commun, il ne realisera pas vraiment les deux gateaux enmeme temps. Il se concentrera sur une premiere realisation, puis sur la deuxieme, ou bien tour a tour sur la premiereet la deuxieme. C’est-a-dire qu’il pourra choisir de finir le premier gateau avant de commencer le second, ou bienchoisir d’alterner entre les deux realisations (d’abord s’occuper des œufs pour les deux gateaux, puis s’occuper dela farine pour les deux gateaux etc...). La methode qu’il choisira pour realiser ((pseudo-simultanement)) ses deuxgateaux lui sera dictee par sa connaissance du metier de cuisinier (le systeme d’exploitation). S’il alterne son activiteentre les deux gateaux, il devra, lorsqu’il s’occupe du gateau 2, se souvenir de l’etat dans lequel il a laisse le gateau 1,afin de ne pas lui rajouter deux fois du sucre par exemple. Il doit donc disposer d’un moyen de sauvegarder le((contexte d’execution)) de chacun de ses gateaux1. Le fait que plusieurs processus puissent progresser ensemble etutiliser tour a tour le processeur s’appelle la multiprogrammation.

1.2 Sauvegarde du contexte

Nous avons deja vu qu’a un programme en cours d’execution correspondait un certain nombre de donnees : lesregistres du processeur, les bornes d’adresses de la Mmu, l’adresse de sommet de la pile etc...Lorsque le processeur interrompt l’execution d’un processus A pour continuer l’execution d’un processus B, toutesles donnees concernant A doivent etre sauvegardees, et les donnees concernant B doivent etre restaurees. Cesdonnees sont stockees par le systeme d’exploitation dans la table des processus et c’est a la charge du systemede sauvegarder et restaurer correctement le contexte d’execution des processus. Nous n’allons pas decrire cette

1L’analogie est ici un peu tiree par les cheveux dans la mesure ou il est souvent possible, rien qu’en regardant l’etat d’avancementdu gateau, de decider a quel endroit de la recette celui-ci a ete laisse...

7


table, qui varie de toutes facons selon les systemes. Citons neanmoins quelques entrees : les registres du processeur,le compteur ordinal, le mot d’etat, le pointeur de pile, l’etat du processus (voir plus loin), sa priorite (voir lasection 3)...

2 Role du systeme d’exploitation dans le controle des processus

La lourde tache qui consiste a charger un programme en memoire (creant ainsi un processus, a la demande del’utilisateur) en gerant l’execution au mieux de chacun des processus, leur acces aux ressources, et ceci en offrantun certain confort d’utilisation a l’utilisateur (pas de processus bloques indefiniment etc...) revient au systemed’exploitation. Nous aborderons ici uniquement le cas de machines monoprocesseur (on dit alors que le systemed’exploitation fait de la pseudo-simultaneite).

2.1 Orchestration des processus

Un systeme d’exploitation generaliste (ceux que nous utilisons sur des ordinateurs de bureau) doit pouvoir creerdes processus a la demande ou automatiquement : des processus sont demarres lorsque le systeme d’exploitationest lance, un processus peut lui-meme en creer plusieurs autres et enfin, l’utilisateur peut, en cliquant sur unprogramme provoquer la creation de nouveaux processus. La creation d’un processus passe dans tous les cas parle systeme d’exploitation. Un processus qui cree un autre processus demande au systeme de le faire pour lui, parl’intermediaire d’un appel systeme.De la meme facon, un processus peut s’arreter pendant que la machine fonctionne : soit parce qu’il est termine,soit parce qu’une erreur fatale s’est produite (erreur de programmation par exemple), soit parce que l’utilisateur ademande l’arret 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 d’execution, bloquesou prets. Le premier cas correspond au processus qui est effectivement en train d’etre execute par le processeur. Letroisieme cas correspond au processus qui pourrait etre execute par le processeur a cet instant precis, mais qui nel’est pas, parce que le systeme d’exploitation en a decide autrement. Enfin, l’etat bloque correspond a un processusqui ne pourrait pas etre execute actuellement, parce qu’il est en attente d’un evenement qui ne s’est pas encoreproduit. Reprenons notre analogie du cuisinier et supposons que ce dernier ne possede qu’un seul verre doseur pourmesurer la quantite de farine, mais plusieurs recipients pour faire ses deux gateaux simultanement. Au momentou le cuisinier a rempli son verre doseur de farine pour faire le gateau A, le processus associe au gateau A est encours d’execution. Celui associe au gateau B est bloque en ce sens que la prochaine chose a faire est d’ajouter lafarine, ce qui ne pourrait pas etre fait puisque le verre doseur est occupe. Une fois le verre doseur vide, lorsque lecuisinier melange la farine du gateau A dans un recipient, le processus associe au gateau B n’est plus bloque, maissimplement pret : on ne s’occupe toujours pas de lui, mais il serait possible de le faire avancer si le cuisinier s’enpreoccupait. C’est le role de l’ordonnanceur (que nous reverrons plus loin) que de selectionner, parmi les processusprets, 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 d’acceder a une memeressource, ou plus generalement a une variable. L’execution alternative des deux processus peut faire emerger unesituation non souhaitee qui ne se produirait pas si chaque processus etait execute sequentiellement.Essayons l’analogie suivante : deux personnes ont pour fonction de remplir un camion de sable en se servant dansun tas. Lorsque le tas est fini, il faut aller chercher d’autre sable, a l’aide d’une brouette, et l’ajouter sur le tas. Siune seule personne fait ce travail, aucun probleme ne peut arriver. Pour modeliser le fait que les deux personnesalternent leur travail, nous pouvons supposer qu’une seule pelle est disponible. Que se passe-t-il si deux personnestravaillent ensemble ? Si la personne A constate qu’il n’y a plus de sable, elle va poser la pelle et partir avec sabrouette chercher du sable supplementaire. A ce moment, la personne B va se saisir de la pelle pour continuer letravail, et constater qu’il n’y a plus de sable. Elle va donc poser la pelle et partir avec une brouette chercher d’autresable. La personne A va revenir et vider son sable sur le tas vide, puis la personne B va revenir et ajouter sonsable, ce qui n’est 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 critiqueest un groupe d’instructions pendant lesquelles le processus ne peut pas etre interrompu par un autre entrant aussidans une section critique. Autrement dit, on ne peut pas avoir un processus pret dans une section critique, enmeme temps qu’un autre processus en execution dans une section critique.

2. Processus 9

interet[1]interet[0]turn 0

00 interet[1]

interet[0]turn 1

01 interet[1]

interet[0]turn 1

00

sectioncritique

de 1

a) b) c)

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 allerchercher du sable et a le vider sur le tas, si la personne A est elle-meme dans sa section critique. Le probleme estainsi regle.Si le processus execute est dans une section critique et qu’il n’y a qu’un autre processus desirant etre execute,et que celui-ci doit entrer dans une section critique, il passera alors dans l’etat bloque, jusqu’a ce que le premierprocessus ait termine sa section critique.Nous allons a present voir comment le principe d’exclusion mutuelle des sections critiques peut etre implante. Ilexiste 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 qu’il entre dans une sectioncritique. 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 processusd’effectuer chacun leur tour leur propre section critique. Si cette solution evite les situations de concurrence, unprocessus peut se retrouver bloque (en attente d’entrer dans sa section critique) alors que le processus ayant lamain sur la section critique peut ne pas avoir a y entrrer (famine).

Methode de Peterson Proposee en 1981 pour deux processus, cette methode repose sur une variable (turn) etun tableau (nomme interet) comportant une case par processus :

turn : entier

interet[] : tableau de 2 entiers

Entrer (n :entier)

interet[n]=1

turn=n

repeter tant que turn=n et interet[1-n]=12

Attendre

Sortir(n : entier)

interet[n]=0

Lorsqu’un processus veut entrer dans une section critique, il doit indiquer dans le tableau qu’il est interesse pourentrer dans une section critique et stocker dans turn son numero de processus. Puis le processus doit attendre, pourentrer reellement dans sa section critique, que turn soit different de son numero de processus, ou bien qu’aucunautre processus n’ait indique qu’il etait interesse par l’entree dans une section critique. Au sortir de la sectioncritique, le processus indique simplement qu’il n’est plus interesse.Le cas simple (une seule demande a une section critique) est illustre figure 2.1. En a), le processus 1 demandel’acces a une section critique. En b), il attend d’etre le seul interesse ou bien de ne pas avoir son numero dans turn.Puisqu’il est le seul interesse, il entre immediatement dans sa section critique et a la sortie en c), il remet a 0 lavaleur interet[1].Si deux processus demandent ((simultanement)) l’acces a une section critique (figure 2.2), chacun des deux indiqueson interet et met son numero de processus dans turn a). Un seul peut avoir son numero dans turn, naturellement(c’est 1 dans notre exemple). Le processus 0, puisqu’il n’a pas son numero dans turn entre donc dans la sectioncritique tandis que l’autre attend. Lorsque le processus 0 a fini, en c), il fait repasser interet[0] a 0, ce qui permetau processus 1 d’entrer en d) dans sa section critique.

2Attention, a la condition



00 interet[1]

interet[0]turn 1

11


01

sectioncritique

de 0

a)

b) c)


00

sectioncritique

de 1

e)processus 1 bloque

d)

Fig. 2.2 – Gestion des sections critiques par la methode de Peterson : deux processus en concurrence

Gestion par le processeur Les processeurs actuels disposent d’une instruction permettant de gerer les sectionscritiques. L’idee est que la lecture et le changement de valeur d’une variable peut etre fait en une instructionindivisible.

2.2.2 Blocage des processus et semaphores

Les methodes decrites ci-dessus (attente active) ont pour defaut qu’un processus en attente d’entree dans unesection critique consomme du temps processeur dans une boucle qui ne se terminera que lorsqu’il aura obtenu cequ’il souhaite.De legeres modifications dans ce qui precede nous amene a la solution introduite par Dijkstra au milieu du siecle :les semaphores. Selon les ouvrages, les semaphores sont decrits de facons legerement differentes. Nous reprenons iciune des definitions les plus simples. Un semaphore est un compteur associe a une liste d’attente. Si un processusveut acceder a une ressource ou entrer dans une section critique, il le demande par un appel systeme : down(sem)ou 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. S’il est strictementnegatif, le numero du processus est mis dans la liste d’attente sem.wait et le processus lui-meme est endormi3 parle systeme. Sinon, rien de particulier ne se passe et le processus accede a la ressource. Lorsque la section critiqueou l’acces a la ressource sont terminees, le processus doit appeler la fonction up(sem). Le compteur sem.count estalors incremente puis teste. S’il est negatif ou nul, cela signifie que la liste sem.wait n’est pas vide. Dans ce cas, lesysteme reveille un des processus de la liste d’attente, qui accede alors a la ressource.Notons que l’initialisation de la variable sem.count permet de faire plus que de l’exclusion mutuelle avec lessemaphores (si on dispose d’une ressource pouvant etre accedee par 3 processus au plus, par exemple, on initialiseracount a 3). Un semaphore utilise uniquement pour de l’exclusion mutuelle (acces a une valeur ou entree dans unesection critique) est appele mutex.

3 Ordonnancement des processus

Jusqu’a present, nous avons souvent ecrit : le systeme d’exploitation choisit un autre processus... Mais commentle choisit-il ? La facon dont le systeme regule l’execution des processus est appelee sa methode d’ordonnancement.Nous allons en exposer quelques principes. Notons tout d’abord une difference fondamentale entre les systemespreemptifs et les systemes non preemptifs. Dans le second cas, un processus en cours d’execution ne sera pasinterrompu par le systeme. Ce sera au processus lui-meme de decider de se bloquer, pour laisser le systeme choisirun autre processus a effectuer. Dans le premier cas, un signal d’horloge provoque regulierement une interruptionet le systeme peut choisir d’interrompre le processus afin d’en choisir un autre. Seuls des systemes dedies a destaches bien precises devraient utiliser une gestion non preemptive des processus. En effet, sur un poste bureautiquepar exemple, ou de nombreuses applications plus ou moins bien ecrites sont executees, un processus pourraitbloquer tout le systeme s’il ne rend jamais la main. La dualite preemptif/non preemptif est parfois appelee avecrequisition/sans requisition.Enfin, nous nous interesserons plus particulierement ici a l’ordonnancement des processus vis a vis de leur executionsur le processeur. Dans un systeme reel, les algorithmes d’ordonnancement sont presents pour l’acces a tout typede ressource (processeur en particulier, mais aussi memoire, peripheriques etc...). Dans presque tous les cas, lesidentifiants des processus en attente de la ressource sont stockes dans une liste d’attente. L’algorithme d’ordonnan-cement aura donc pour tache de choisir, dans la liste d’attente, quel sera le prochain processus a executer. Notonsque, puisqu’il y a plusieurs listes d’attentes, certaines peuvent etre gerees de facon preemptive et d’autres non.

3C’est-a-dire qu’il ne consommera plus de temps processeur. Pour cela, il est simplement bloque par le systeme.

2. Processus 11

94 13 19 21P1 P3P2 P4

Fig. 2.3 – Execution par la methode Fifo

64 10 15 21P1 P3P2P4

Fig. 2.4 – Plus court temps d’execution d’abord

3.1 Algorithmes non preemptifs

Dans le cas d’algorithmes sans requisition du processeur, si un processus passe en execution, tous les processus enattente devront attendre qu’il se termine (ou qu’il decide lui-meme de se bloquer).

Listes Fifo La facon la plus evidente d’ordonnancer est de gerer les processus en attente dans une file (listeFifo du cours d’algorithmique). Cette solution est tres simple mais assez peu satisfaisante, meme si elle garantitl’execution de tous les processus (si aucun ne s’execute indefiniment). Pour avoir une mesure de la performancede l’algorithme d’ordonnancement, nous nous interesserons au temps de traitement moyen. Il sera defini comme ladifference des dates de fin d’execution et d’entree dans la liste. Nous utiliserons le tableau suivant, indiquant laduree d’execution τi et la date d’entree dans la liste ti :

τi tiP1 5 0P2 4 2P3 6 3P4 2 4

Dans le tableau precedent, le processus P3 necessite 6 quanta de temps processeur pour s’executer et il est arrivedans la liste d’attente a la date 3. Si le processeur commence a executer les processus de la liste a la date 4 (unefois que tous sont dans la structure Fifo), nous obtiendrons l’execution representee figure 2.3.Le temps de traitement moyen d’un processus sera alors :

t =9 + (13− 2) + (19− 3) + (21− 4)

4= 13, 25

Plus court temps d’execution Afin de favoriser les processus courts, l’ordonnanceur peut choisir d’executerles processus qui ont les temps d’execution les plus courts. Si a l’instant 4, les taches suivantes sont dans la liste :

τi tiP1 5 0P2 4 2P3 6 3P4 2 4

Nous obtiendrons l’execution representee figure 2.4Et le temps de traitement moyen sera :

t =(6− 4) + (10− 2) + 15 + (21− 3)

4= 10, 75

L’algorithme d’ordonnancement du plus court temps d’execution d’abord est optimal, mais uniquement si la listedes taches est connue a l’avance, comme dans notre exemple.

3.2 Algorithmes preemptifs

Les algorithmes preemptifs peuvent etre utilises si le systeme est dote d’un horloge capable de generer des interrup-tions a intervalles reguliers. Dans cette mesure, le systeme d’exploitation peut ((reprendre la main)) regulierementet choisir d’interrompre le processus courant pour en executer un autre. Le systeme doit aussi pouvoir sauvegarderle contexte d’execution du processus et bien sur le restaurer (voir section 1.2 du chapitre 2).


Algorithme du tourniquet (Round robin) La structure contenant les informations sur les processus est detype liste Fifo. Le processus de tete est execute pendant 1 quantum de temps. Puis il est mis en queue de liste etl’algorithme itere les dernieres operations. Il y a des versions du tourniquet comportant plusieurs files d’attente.

Gestion avec priorites Une certaine priorite est donnee aux differents processus. C’est cette priorite qui influerasur leur ordre d’execution. C’est ce principe qui est repris sous les systemes d’exploitation Unix.

Loterie Un autre algorithme consiste a tirer simplement au sort le prochain processus qui sera execute. Un moyende ((biaiser)) les tirages au sort (pour favoriser des processus de haute priorite par exemple) est de distribuer plusde billets aux processus prioritaires. Ils auront ainsi plus de chances d’etre choisis.

Cas des processus temps reels Les processus temps reels possedent, en plus des autres, une echeance, a partirde laquelle ils doivent avoir termine leur execution. De plus certains processus doivent etre periodiques, et d’autresnon. Le cas particulier d’ordonnancement des processus temps reel sera aborde durant le cours de temps-reel.

4 Threads

Nous venons de voir que les processus peuvent etre vus comme differents fils d’execution, geres par le systemed’exploitation, possedant chacun leur propre espace d’adressage.Ce systeme permet en particulier d’assurer une certaine (impression de) simultaneite dans l’execution de differentsprogrammes, et donc d’accroıtre la souplesse et le confort d’utilisation. De plus, l’etancheite des processus assurela bonne sante et la stabilite de l’ensemble.Il est cependant des cas ou l’on souhaiterait profiter de la simultaneite et de la souplesse, en renoncant a l’etancheite,par exemple si les differentes ((taches)) utilisent les meme donnees. L’exemple donne dans [6] est tout a fait parlant :supposons que l’on utilise un traitement de texte moderne (Wysiwyg) et que l’on travaille sur un gros document. Onpeut esperer que le logiciel soit reactif aux entrees clavier, soit rapide a recalculer la mise en page (par exemple larenumerotation de toutes les pages en cas d’une suppression), et garantisse des sauvegardes automatiques regulieres.Ces trois fils d’execution : gestion du clavier, calcul de la mise en page et sauvegarde automatique gagnerontevidemment a etre executes (pseudo)simultanement, comme le seraient des processus. En revanche, ils doivent tousles trois acceder a la meme donnee : le document. La interviennent les threads.Les threads sont donc differents fils d’execution, a l’interieur d’un meme processus (autrement dit, nous n’avionsconsidere jusque la que des processus monothread). Chaque thread dispose de sa propre pile (variables locales etappels de procedures), mais tous les threads d’un meme processus partagent le meme espace d’adressage et doncles meme variables globales4.L’ordonnancement de tous les thread peuvent etre faits par le systeme d’exploitation lui-meme (la gestion desthreads est alors native), ou bien par un systeme d’execution intermediaire entre l’Os et les processus (et lesysteme d’exploitation n’a alors pas connaissance des threads).On retiendra que les threads, appeles parfois processus legers, sont utilises dans le cas ou les donnees doivent etrepartages par les differents fils d’execution et/ou dans le cas ou la vitesse de creation des differents fils d’executionest primordiale (la creation et la suppression d’un thread a l’interieur d’un processus est souvent bien plus rapideque la creation et la suppression d’un processus).Un exemple de programmation de threads et de processus sous Unix est donne en A.1.

4et rien n’empeche a priori qu’un thread aille ecrire dans la pile d’un autre thread du meme processus, ce qui entraınerait sansdoute un fonctionnement hasardeux.

Chapitre 3

Interblocages

Pour se rendre compte de ce qu’est une situation d’interblocage (parfois appelee etreinte fatale oudeadlock), nous pouvons reprendre l’exemple du cuisinier. Celui-ci realise deux recettes differentes (deuxprocessus en cours, mais issus de deux programmes differents). Il a un nombre limite de ressources (unseul verre doseur, et un seul fait-tout). La premiere recette lui indique qu’il faut d’abord mettre du

beurre dans le fait-tout, puis mesurer de la farine avec le verre doseur, et enfin melanger dans le fait-tout. Laseconde lui indique qu’il doit mesurer de l’eau dans le verre doseur, mettre des oeufs dans le fait-tout et y verserl’eau. Il est bien sur possible de realiser les deux recettes, la solution triviale consiste a faire la premiere puis laseconde. Mais dans le cadre de l’ordonnancement de processus, chaque execution de recette peut etre interrompuepar une autre. Supposons que le cuisinier ait verse l’eau dans le verre doseur comme indique dans la recette 2, puisqu’il ait ensuite mis du beurre dans le fait-tout comme indique dans la recette 1. L’execution des deux recettes estalors bloquee : le fait-tout est necessaire pour continuer la recette 2, car il faut y mettre les oeufs, or il est occupepar le beurre. De meme, la recette 1 est bloquee car le cuisinier a besoin du verre doseur pour mesurer la farine, orcelui-ci contient de l’eau...

1 Conditions necessaires a un interblocage

Les conditions suivantes doivent etre remplies pour qu’un interblocage soit possible :– une ressource est soit attribuee a un seul processus, soit disponible ;– un processus peut demander une ressource alors qu’il en possede deja une ;– il est impossible de retirer de force une ressource a un processus ;– les processus doivent former un cycle d’au 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.

2 Modelisation

Il existe une methode, basee sur les graphes, permettant de modeliser les interblocages. Chaque processus estrepresente par un nœud rond, et chaque ressource par un nœud carre. Si un processus demande l’acces a uneressource, les nœuds sont relies par une fleche allant du processus vers la ressource. Si le processus a obtenu l’accesa la ressource, le sens de la fleche est inverse. Ainsi, le graphe de la figure 3.1 represente deux processus A et Bet deux ressource R et S. Les deux processus sont en situation d’interblocage. Ceci est facilement reperable car legraphe possede un cycle.

A

B

SR

Fig. 3.1 – Deux processus A et B en situation d’interblocage

13


AR B

C S D T E

F U V

W G

Fig. 3.2 – Situation reelle avec 3 processus en phase d’interblocage

3 Gestion des interblocages

3.1 Ignorer les interblocages

Selon le type de systeme, on peut tout simplement ignorer les interblocages, si ceux-ci sont suffisamment peucritiques et rares. Si une machine de bureau se retrouve bloquee au bout de 1000h de travail en moyenne, celarestera negligeable compare a tous les autres problemes qui peuvent survenir.

3.2 Detection et reprise

La methode ne consiste pas a prevenir les interblocages, mais a les constater, puis a y remedier. La facon la plusevidente pour le systeme est de construire un graphe et d’y rechercher des cycles (voir le cours d’algorithmique),afin de deduire s’il y a ou pas interblocage, et si c’est le cas, quels sont les processus bloques, et a cause de quellesressources. 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 .S’il n’est pas a priori facile de detecter les interblocages a partir d’une telle liste, cela devient plus simple avec legraphe associe de la figure 3.2. Nous constatons sur ce graphe qu’il y a un cycle, et donc une situation d’interblocagemettant en cause les processus G, D et E.Cette methode reste valide s’il n’y a qu’une ressource de chaque type (par exemple une seule imprimante, et unprocessus desirant imprimer devra necessairement acceder a une ressource precise, la seule imprimante). Il existeune autre methode, basee cette fois sur des matrices, permettant de reperer les interblocages dans le cas ou certainesressources existent en plusieurs exemplaires.

Cas de ressources multiples Le methode basee sur les graphes ne fonctionne plus si, par exemple, la machinepossede deux imprimantes (l’une ou l’autre pouvant etre affectee a un processus desirant imprimer). Une facon demodeliser ce probleme est d’utiliser des vecteurs et des matrices (ici dans le cas de m processus et n ressources denature differente) :– E est le vecteur de taille n des ressources existantes. Ei est le nombre d’exemplaires de la ressource i.– A est le vecteur de taille n des ressources disponibles. Ai est le nombre d’exemplaires de la ressource i qui ne

sont pas actuellement utilises.– C est la matrice m × n des ressources allouees. Cij est le nombre d’exemplaires de la ressource j actuellement

detenus par le processus i.– R est la matrice m × n des ressources demandees. Rij est le nombre d’exemplaires de la ressource j demandes

par le processus i.

3. Interblocages 15

Un interblocage est detecte ainsi

demarquer les processus executes

repeter tant qu’il existe un processus non marque i tel que

la ieme ligne de R est inferieure ou egale1 a A

ajouter la ieme ligne de C a A

marquer le processus

s’il reste des processus non marques, une situation d’interblocage existe

Cet algorithme peut etre execute regulierement, ou bien lorsque la charge du processeur diminue.Une fois l’interblocage detecte, il reste neanmoins a regler le probleme. Voici quelques solutions.

Reprise par rollback Cette solution consiste a enregistrer regulierement l’etat de chaque processus de facon apermettre au systeme de revenir en arriere dans l’execution de l’un deux. Si le systeme de points de reprise est enplace, il suffit, apres avoir detecte un processus en situation d’interblocage, de le faire reprendre avant qu’il n’aitacquis la ressource qui est mise en cause. L’autre processus bloque pourra alors l’acquerir et le processus revenu enarriere patientera jusqu’a ce qu’elle soit liberee. Notons cependant que l’enregistrement des points de reprise estune methode relativement lourde.

Suppression de processus Le systeme permet generalement a l’utilisateur de supprimer un processus (le killd’Unix ou le gestionnaire de taches de Windows). Supprimer un processus peut supprimer un interblocage, meme sile processus supprime n’etait 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 ou le comportement des processus est difficile a prevoir. Lasolution la plus adaptee, quoi qu’assez restrictive consiste a ordonner les ressources et a ne permettre au processusde ne les demander que dans un ordre croissant. Il ne peut alors pas se produire d’interblocage. La plupart desautres methodes reposent sur la notion d’etats surs que nous allons developper.

3.3.1 Trajectoires de ressources

Sans encore parler d’algorithme, nous allons aborder la representation graphique des etats. La figure 3.3 montre unexemple d’execution de deux processus sur une machine (processus A en abcisse et B en ordonnee). Le chemin nousindique a chaque instant quel processus est execute (I1 a I4 sont des instructions du processus A et I5 a I8 sontdes instructions du processus B). Lorsqu’aucun des processus n’est demarre, l’etat est en p. Les deux processus seterminent en z. Un ordre d’execution particulier des processus est un chemin de p a z.Supposons que le processus A a besoin de l’imprimante entre I1 et I3, et de la table tracante entre I2 et I4. Deson cote, B a besoin de la table tracante entre I5 et I7 et de l’imprimante entre I6 et I8. Nous representerons lasituation comme indique figure 3.4. Les zone hachurees sont naturellement interdites.Au point s de la figure 3.4, l’ordonnanceur a le choix entre executer A ou B. S’il execute B, on se retrouve dans lasituation de la figure 3.5 (interblocage). S’il execute A (figure 3.6), alors, l’ordonnanceur aura la possibilite d’eviterles interblocages.

3.3.2 Etats surs et non surs

Un etat sur peut etre defini ainsi : il existe un moyen d’ordonnancer les processus sans qu’il y ait de blocage, memesi 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 deressources qu’il possede et le nombre de ressources maximum qu’il voudra eventuellement posseder. Nous supposonsqu’il y a 10 ressources au total. Dans le cas de la matrice de gauche, le prossessus A possede 3 ressources et en voudra6 de plus, le processus B possede 2 ressources et en voudra deux de plus... En tout, 7 ressources sont occupees, etil en reste donc 3. Cet etat est sur car il existe un ordre d’execution garantissant qu’aucun processus ne se bloque(partie superieure de la figure 3.7 : executer B, puis C, puis A). En revanche, si l’ordonnanceur executait A et quecelui-ci prenait une ressource supplementaire, alors l’etat ne serait plus sur (partie inferieure de la figure 3.7).

1Un vecteur est inferieur ou egal a un autre si cette relation est vraie pour chacun des coefficients.


I1 I2 I3 I4

I5

I6

I7

I8

pq

r s

z

processus A

processus B

Fig. 3.3 – Exemple d’execution de deux processus

I1 I2 I3 I4

I5

I6

I7

I8

pq

r s

z

processus A

processus B

Impri

mante

table

tracante

imprimante

table tracante

Fig. 3.4 – Exemple d’execution de deux processus avec usage de ressources

3. Interblocages 17

I1 I2 I3 I4

I5

I6

I7

I8

pq

r s

z

processus A

processus B

Impri

mante

table

tracante

imprimante

table tracante

t

Fig. 3.5 – Exemple d’execution de deux processus avec usage de ressources : situation d’interblocage

I1 I2 I3 I4

I5

I6

I7

I8

pq

r s

z

processus A

processus B

Impri

mante

table

tracante

imprimante

table tracante

Fig. 3.6 – Exemple d’execution de deux processus avec usage de ressources : pas d’interblocage


A

B

C

3 9

2 4

2 7

Poss

ede

Max

Libre : 3Etat sur

A

B

C

3 9

3 4

2 7P

oss

ede

Max

Libre : 2Etat sur

A

B

C

3 9

4 4

2 7

Poss

ede

Max

Libre : 1

A

B

C

3 9

0 -

2 7

Poss

ede

Max

Libre : 5

A

B

C

3 9

0 -

7 7

Poss

ede

Max

Libre : 0

A

B

C

3 9

0 -

0 -

Poss

ede

Max

Libre : 7

A

B

C

9 9

0 -

0 -

Poss

ede

Max

Libre : 1

A

B

C

0 -

0 -

0 -

Poss

ede

Max

Libre : 10

A

B

C

4 9

2 4

2 7

Poss

ede

Max

Libre : 2Etat non sur

A

B

C

4 9

4 4

2 7

Poss

ede

Max

Libre : 0

A

B

C

4 9

0 -

2 7

Poss

ede

Max

Libre : 4

B?

B?

A?

C?

B

B B C C A A

A

Fig. 3.7 – Etats surs et non surs

A

B

C

D

E

3 0 1 1

0 1 0 0

1 1 1 0

1 1 0 1

0 0 0 0

C

E 6 3 4 2A

B

C

D

E

1 1 0 0

0 1 1 2

3 1 0 0

0 0 1 0

2 1 1 0

P 5 3 2 2

A 1 0 2 0

R (total)

Pro

cessus

Impr

iman

tes

Tabl

estrac

ante

s

Scan

ner

Lect

eurs

CD

Pro

cessus

Impr

iman

tes

Tabl

estrac

ante

s

Scan

ner

Lect

eurs

CD

Fig. 3.8 – Matrices utilisees par l’algorithme du banquier

3.3.3 Algorithme du banquier

L’algorithme du banquier pour plusieurs ressources a ete introduit par Dijkstra. Il consiste, pour l’ordonnanceur,a toujours rester dans un etat sur. Son fonctionnement necessite que chaque processus indique le nombre maximalde 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 qu’il 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.L’algorithme du banquier consiste a voir s’il existe un ordre d’execution pour lequel tous les processus peuvent seterminer s’ils demandent toutes leurs ressources. Si c’est le cas, l’etat est sur, et il sufit d’executer en premier leprocessus ainsi trouve pour rester dans un etat sur (voir figure 3.9).

3. Interblocages 19

A

B

C

D

E

3 0 1 1

0 1 0 0

1 1 1 0

1 1 0 1

0 0 0 0

E 6 3 4 2A

B

C

D

E

1 1 0 0

0 1 1 2

3 1 0 0

0 0 1 0

2 1 1 0

P 5 3 2 2

A 1 0 2 0

C R (total)

A

B

C

D

E

3 0 1 1

0 1 0 0

1 1 1 0

1 1 0 1

0 0 0 0

E 6 3 4 2A

B

C

D

E

1 1 0 0

0 1 1 2

3 1 0 0

0 0 1 0

2 1 1 0

P 5 3 2 2

A 1 0 2 0

C R (total)

A

B

C

D

E

3 0 1 1

0 1 0 0

1 1 1 0- - - -

0 0 0 0

E 6 3 4 2A

B

C

D

E

1 1 0 0

0 1 1 2

3 1 0 0

2 1 1 0

P 4 2 2 1

A 2 1 2 1

C R (total)

- - - -

A

B

C

D

E

3 0 1 1

0 1 0 0

1 1 1 0- - - -

E 6 3 4 2A

B

C

D

E

1 1 0 0

0 1 1 2

3 1 0 0 P 4 2 2 1

A 2 1 2 1

C R (total)

- - - -

- - - - - - - -

A

B

C

D

E

0 1 0 0

1 1 1 0- - - -

E 6 3 4 2A

B

C

D

E

0 1 1 2

3 1 0 0 P 1 2 1 0

A 5 1 3 2

C R (total)

- - - -

- - - - - - - -

- - - -- - - -

A

B

C

D

E

- - - -

E 6 3 4 2A

B

C

D

E

P 0 0 0 0

A 6 3 5 2

C R (total)

- - - -

- - - - - - - -

- - - -- - - -

- - - -

- - - -

- - - -

- - - -

A

B

C

D

E

3 0 1 1

0 1 1 0

1 1 1 0

1 1 0 1

0 0 0 0

E 6 3 4 2A

B

C

D

E

1 1 0 0

0 1 0 2

3 1 0 0

0 0 1 0

2 1 1 0

P 5 3 3 2

A 1 0 1 0

C R (total)

A

B

C

D

E

3 0 1 1

0 1 1 0

1 1 1 0

1 1 0 1

0 0 1 0

E 6 3 4 2A

B

C

D

E

1 1 0 0

0 1 0 2

3 1 0 0

0 0 1 0

2 1 0 0

P 5 3 4 2

A 1 0 0 0

C R (total)

B (R3)

E (R3)

Etat surD,A,E,B,C

Etat non sur

Fig. 3.9 – Algorithme du banquier

Chapitre 4

Exercices

Algorithme de Peterson Que se passe-til si on modifie l’algorithme de Peterson en1 :

Entrer (n :entier)

turn=n

interet[n]=1

repeter tant que turn=n et interet[1-n]=1

Attendre

Le dıner des philosophes Cinq philosophes sont assis a table, chacun devant une assiette, et cinq fourchettessont disposees entre les assiettes.

(a) Disposition des philosophes et des cou-verts

(b) Les philosophes en pleine action

Fig. 4.1 – Probleme des philosophes

L’activite des philosophes consiste a penser et a manger (chacune des deux activites excluant naturellement l’autre).Pour manger, un philosophe a besoin de deux fourchettes. Comment programmer les philosophes de facon a ce quechacun puisse penser, manger, sans que cela conduise a un interblocage.Le processus philosophe a pour modele :

Processus philosopherepeter indefiniment

Penser

Prologue

Manger

Epilogue

1Inversion de deux lignes.

21


Il s’agit d’ecrire correctement les procedures Prologue et Epilogue.

Probleme des lecteurs/redacteurs L’exemple type est l’acces a une base de donnees de reservation (SNCFpar 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 acces exclusif.

Probleme du coiffeur endormi– Il y a N chaises dans un salon de coiffure.– Si le coiffeur n’a personne a coiffer, il s’endort.– Si un client rentre dans le salon

– et que les N chaises sont occupees, il repart.– et qu’il y a des chaises libres :

– si le coiffeur dort, il le reveille pour se faire coiffer ;– si le coiffeur coiffe, il s’assoit dans la salle d’attente et attend (i.e. s’endort).

Comment programmer les clients et le coiffeur ? Voici quelques indices :– Compteur pour les clients (pour verifier le nombre dans la salle d’attente). 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 d’attente.

Comparaison d’algorithmes d’ordonnancement– Liste FIFO (non preemptif) : FCFS– Plus court temps d’execution (non preemptif) : SJF– Plus court temps restant (preemptif) : SRT– Tourniquet (preemptif) quantum=2– Tourniquet (preemptif) quantum=1Nous allons calculer le temps de rotation moyen pour une sequence donnee de processus. Le temps de rotation estla duree qui s’ecoule de l’entree du processus dans la file a la fin de son execution.

Date entree Temps d’executionA 0 3B 1.001 6C 4.001 4D 6.001 2

Donnez les sequences d’execution et les temps de rotation moyen de chacun des algorithmes.

Exemple FCFS :

30 9 1513C DBA

T =14

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

Comparaison de deux algorithmes d’ordonnancement avec gestion des priorites On considere unalgorithme non preemptif et un preemptif (preemption lors de la fin d’un processus ou de l’arrivee d’un nouveaudans la file d’attente)

Date entree Temps d’execution PrioriteA 0 4 3B 1 3 4C 2 3 6D 3 5 5

Indiquez l’ordre d’execution des processus et leur temps moyen d’execution.

4. Exercices 23

Questions diverses– Sur un systeme interactif, le choix d’un algorithme d’ordonnancement des processus non preemptif est-il judi-

cieux ?– Sur un systeme multiprocesseur a n processeurs, quel est le nombre maximum de processus en

– execution ?– bloques ?– prets ?

– La multiprogrammation est le fait d’avoir plusieurs processus qui s’executent pseudo-simultanement. Trouvezdes avantages et des inconvenients a la multiprogrammation.

Annexe A

Exemples de code

Les programmes suivants peuvent etre compiles avec le compilateur gcc sous Gnu/Linux. Il est probable que lesadaptations necessaires au bon fonctionnement de ces programmes sous un autre systeme sont minimes.

1 Processus et semaphores

25


#include <pthread.h>

#include <stdio.h>

#include <stdlib.h>

#include <unistd.h>

// Variable globale modifiee

// 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);

}

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 l’execution 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;

}

> ./threads1

T 1 : compt=1

T 2 : compt=2

T 1 : compt=3

T 1 : compt=4

T 2 : compt=5

T 1 : compt=6

T 2 : compt=7

T 1 : compt=8

T 1 : compt=9

T 2 : compt=10

#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)

{

int i=0,pid=-1;

compt=0;

// Creation des fils

while(pid!=0 && i<2)

{

pid=fork();

if (pid==0) fonc();

i++;

}

// Il n’est pas necessaire d’attendre

// la fin des fils. Chaque processus

// se terminera a son tour

return 0;

}

> ./processus1

P 419 : compt=1

P 420 : compt=1

P 419 : compt=2

P 420 : compt=2

P 419 : compt=3

P 420 : compt=3

P 419 : compt=4

P 420 : compt=4

P 419 : compt=5

P 420 : compt=5

P 419 : compt=6

P 420 : compt=6

P 419 : compt=7

P 420 : compt=7

P 419 : compt=8

P 420 : compt=8

P 419 : compt=9

P 420 : compt=9

P 419 : compt=10

P 420 : compt=10

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

A. Exemples de code 27

2 Dıner des philosophes


#include <semaphore.h>

#include <stdio.h>

#include <stdlib.h>

#include <unistd.h>

// Diner des philosophes

// Cette version n’empeche pas les interblocages

sem_t fourchette[5];

void penser(int i)

{

printf("Philo %d : Je pense...\n",i);

sleep(rand()%5+2);

printf("Philo %d : J’ai fini de penser...\n",i);

}

void manger(int i)

{

printf("Philo %d : Je mange...\n",i);

sleep(rand()%5+3);

printf("Philo %d : J’ai fini de manger...\n",i);

}

void prologue(int i)

{

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]);

}

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;

while(1)

{

penser(i);

prologue(i);

manger(i);

epilogue(i);

}

pthread_exit(NULL);

}

int main(void)

{

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 dıner des philosophes. Cette version n’empeche pas l’etreinte fatale (comme le montrela capture d’execution)


Philo 0 : Je pense...





Philo 3 : J’ai fini de penser...

Philo 3 : Tentative prise fourchette gauche

Philo 3 : Tentative prise fourchette droite

Philo 3 : Je mange...












Philo 3 : J’ai fini de manger...

Philo 3 : Repose fourch droite


Philo 3 : Repose fourch gauche




































































Src. A.3: Trace de l’execution du dıner des philosophes avec etreinte fatale

A. Exemples de code 29


#include <semaphore.h>

#include <stdio.h>

#include <stdlib.h>

#include <unistd.h>

// Diner des philosophes

// Il n’y a plus d’interblocage

sem_t fourchette[5];

sem_t antichambre;

void penser(int i)

{

printf("Philo %d : == Je pense...\n",i);

usleep(1000+rand()%5000);

}

void manger(int i)

{

printf("Philo %d : == Je mange...\n",i);

usleep(1000+rand()%5000);

}

void prologue(int i)

{

printf("Philo %d : Souhaite entrer antich\n",i);

sem_wait(&antichambre);

printf("Philo %d : == Suis entre 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);

}

void epilogue(int i)

{

printf("Philo %d : == Pose fourch droite \n",i);

sem_post(&fourchette[(i+1) % 5]);

printf("Philo %d : == Pose fourch gauche \n",i);

sem_post(&fourchette[i]);

printf("Philo %d : == Sors antichambre \n",i);

sem_post(&antichambre);

}

void* philosophe(void * param)

{

int i=(int)param;

while(1)

{

penser(i);

prologue(i);

manger(i);

epilogue(i);

}

pthread_exit(NULL);

}

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 dıner des philosophes. Cette version regle le probleme de l’etreinte fatale et de lafamine par l’utilisation d’un semaphore initialise a 4.

Table des figures

1.1 Modele de Von Neumann . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11.2 Structure d’un ordinateur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21.3 Utilisation du pointeur ordinal . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21.4 Utilisation de la pile . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31.5 Etapes d’une operation d’entree sortie utilisant les interruptions . . . . . . . . . . . . . . . . . . . . . 5

2.1 Gestion des sections critiques par la methode de Peterson : cas simple . . . . . . . . . . . . . . . . . 92.2 Gestion des sections critiques par la methode de Peterson : deux processus en concurrence . . . . . . 102.3 Execution par la methode Fifo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 112.4 Plus court temps d’execution d’abord . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11

3.1 Deux processus A et B en situation d’interblocage . . . . . . . . . . . . . . . . . . . . . . . . . . . . 133.2 Situation reelle avec 3 processus en phase d’interblocage . . . . . . . . . . . . . . . . . . . . . . . . . 143.3 Exemple d’execution de deux processus . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 163.4 Exemple d’execution de deux processus avec usage de ressources . . . . . . . . . . . . . . . . . . . . 163.5 Exemple d’execution de deux processus avec usage de ressources : situation d’interblocage . . . . . . 173.6 Exemple d’execution de deux processus avec usage de ressources : pas d’interblocage . . . . . . . . . 173.7 Etats surs et non surs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 183.8 Matrices utilisees par l’algorithme du banquier . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 183.9 Algorithme du banquier . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19

4.1 Probleme des philosophes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21

31

Table des codes source

A.1 Creation et utilisation de processus ou de threads . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26A.2 Programmation du dıner des philosophes. Cette version n’empeche pas l’etreinte fatale (comme le

montre la capture d’execution) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27A.3 Trace de l’execution du dıner des philosophes avec etreinte fatale . . . . . . . . . . . . . . . . . . . . 28A.4 Programmation du dıner des philosophes. Cette version regle le probleme de l’etreinte fatale et de

la famine par l’utilisation d’un semaphore initialise a 4. . . . . . . . . . . . . . . . . . . . . . . . . . 29

33

Bibliographie

[1] Joffroy Beauquier and Beatrice Berard. Systeme d’exploitation : concepts et algorithmes. Ediscience Interna-tional, 1990.

[2] Christophe Blaess. Programmation systeme en C sous Linux. Collection Blanche. Eyrolles, 2005.

[3] Laurent Bloch. Les systemes d’exploitation des ordinateurs. Vuibert, 2003.

[4] Samia Bouzefrane. Les systemes d’exploitation. Dunod, 2003.

[5] Bart Lamiroy, Laurent Najman, and Hugues Talbot. Systemes d’exploitation. Collection Synthex. PearsonEducation, 2006.

[6] Andrew Tanenbaum. Systemes d’exploitation. Pearson Education, 2 edition, 2003.

35

Index

etatsnon surs, 15surs, 15

etreinte fatale, 13

alternance stricte, 9appel systeme, 5, 8

coiffeur endormi, 22concurrence, 8controleurs, 4

deroutements, 4deadlock, 13

exclusion mutuelle, 9

fichier d’echange, 4

interblocage, 13detection, 14

interruption, 10interruptions, 4Irq, 5

lecteurs, redacteurs, 22

memoire, 2cache, 2virtuelle, 2vive, 2

Memory Management Unit, 4Mmu, voir Memory Management Unitmode

noyau, 5privilegie, 5superviseur, 5utilisateur, 5

mot d’etat, 2multiprogrammation, 7mutex, 10

ordonnancement, 10ordonnanceur, 8

Peterson, 9philosophes, 21pile, 2pilotes de peripheriques, 4pointeur ordinal, 2points de reprise, 15

preemptifs, 10non, 10

processeur, 2processus, 7

bloque, 8en cours d’execution, 8leger, voir threadpret, 8

pseudo-simultaneite, 8Psw, 2

requisitionavec, 10sans, 10

rollback, 15round robin, 12

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

thread, 12tourniquet, 12

verrou, 9

36

cours_sys

Documents