: REPUBLIQUE DU CAMEROUN REPUBLIC OF CAMEROON

Paix-Travail-Patrie
MINISTERE DE L’ENSEIGNEMENT Peace-Work-Fatherland
SUPERIEUR MINITRY OF HIGHER EDUCATION
******** ******
UNIVERSITE DE DSCHANG UNIVERSITY OF DSCHANG
************* ***********
FACULTE DES SCIENCES FACULTY OF SCIENCES
********* *********
DEPARTEMENT DE MATHEMATIQUES- DEPARTMENT OF MATHEMATICS-
INFORMATIQUE
COMPUTER SCIENCES

THEME : LES INTERBLOCAGES

R
REED
DIIG
GEE PPA
ARR ::

NOMS PRENOMS MATRICULES

MTOPI CHEBU Yann Brice CM-UDS-15SCI2192
TALLA TENE PIERRE CM04-10SCI1040

SSU
UPPE
ERRV
VIISSE
E PPA
ARR : Dr. KENGNE T. Vianney

ANNEE ACADEMIQUE 2015-2016

 INTRODUCTION GENERALE

Contexte du travail
La gestion des ressources par les systèmes d’exploitation est un élément crucial
pour la synchronisation et la communication interprocessus d’où des études
profondes s’avèrent nécessaires pour une efficacité dans cette gestion c’est le
cas des inters blocages dont l’étude permet de remédier aux accès concurrents
des processus aux ressources. En effet un ensemble de processus est en inter
blocages si chaque processus de l’ensemble est en attente d’événement que seul
un autre processus de l’ensemble peut engendrer, un événement étant en général
la libération d’une ressource par un autre processus de l’ensemble.

Problématique
L’exécution d’un processus nécessite un ensemble de ressources (mémoire
principale, disques, fichiers, périphériques, etc.) qui lui sont attribuées par
le système d’exploitation. L’utilisation d’une ressource passe par les étapes
suivantes : Demande de la ressource : Si l’on ne peut pas satisfaire la demande il
faut attendre. La demande sera mise dans une table d’attente des ressources.–
Utilisation de la ressource : Le processus peut utiliser la ressource.– Libération
de la ressource : Le processus libère la ressource demandée et allouée
.Lorsqu’un processus demande un accès exclusif à une ressource déjà
allouée à un autre processus, le système d’exploitation décide de le mettre
en attente jusqu’à ce que la ressource demandée devienne disponible ou lui
retourner un message indiquant que la ressource n’est pas disponible : réessayer
plus tard. Cependant la question qui se pose sont : comment le système
d’exploitation détecte t’il l’inter blocages ? et quels sont les stratégies qu’elle
met en œuvre pour y remédier ? Ses techniques de résolutions sont t’elles
parfaites ? Et enfin qu’elles sont les perspectives pour des éventuelles
améliorations ultérieures que nous pouvons suggérer ?

Plan du travail
Pour aborder cet études nous allons dans un premier temps définir et présenter
un outils de modélisation des inter blocages ,secondement présenter de façon
succinct les algorithmes de détection d’inter blocages utilises par des SE ,
troisièmement nous allons voir comment les SE traitent ce problèmes et
comment les éviter en présentant un algorithmes d’ordonnancement de djisktra
connu sur le nom d’algorithmes des banquiers qui permet de maintenir le
système dans un états sain et enfin nous allons voir comment prévenir ce
problèmes et apporter une ébauche de résolution
I-Définition
Un ensemble de processus est en interblocage si chaque processus attend un
évènement que seul un autre processus de l’ensemble peut provoquer.
Comme tous les processus attendent, aucun d’eux ne peut jamais produire un
évènement pour réveiller un autre et tous les processus continueront d’attendre
indéfiniment. Le plus souvent, l’évènement attendu est la libération d’une
ressource détenue par un autre processus. On parle donc généralement
d’interblocage des ressources. Ce qui ne peut se réaliser qu’a 4 conditions qui
sont :
Conditions d’exclusion mutuelle : chaque ressource est attribuée à un seul
processus à la fois
Un processus ayant déjà obtenu des ressources peuvent en demander de
nouvelles.
Les ressources déjà obtenues ne peuvent être retiré de force à un processus. Elles
doivent êtres explicitement libères par le processus qui les détient.
Il doit y avoir un cycle d’au moins deux processus pour produire un
interblocage.

On peut matérialiser un interblocage entre plusieurs processus de la façon

suivante :
II-gestion des inteblocages
Il existe plusieurs façons de gérer les obstacles

1. On peut les ignorer

Cette approche est la plus simple et est aussi nommer la politique de

l’autruche. Elle consiste se comporter comme s’il n’y avait pas de
problèmes.

2. Détecter les interblocages

 Détecter un interblocage dans un système avec une ressource de

chaque type

Considérons un système de 7 processus allant de A a G, et 6 ressources allant de

R a W. les processus sont demandées et procède comme suit :
Le processus A détient R et demande S
Le processus B ne détient aucune ressource mais demande T
Le processus C ne détient aucune ressource mais demande S
Le processus D détient U et demande S et T
Le processus E détient T et demande V
Le processus F détient W et demande S
Le processus G détient V et demande S
On se pose donc la question de savoir si le système est en interblocage. Si oui
quels sont les processus concernes ?
Il est aisé de voir que les processus en interblocage sont D, E et G car ses
processus forment un cycle dans le graphe.
Bien qu’il soit relativement aisé de repérer visuellement les interblocages à
partir d’un graphe simple, les processus bloqués, les systèmes actuels nécessitent
un algorithme de détection des interblocages.
L’algorithme suivant permet de détecter un cycle dans un graphe orienté.
Pour chaque nœud du graphe, suivre les étapes ci-après comme point de départ
Initialiser L a une liste vide et designer tous les arcs comme non marqués.
Ajouter le nœud en cours à la fin de la liste L et vérifier que le nœud apparait
deux fois dans L. si tel est le cas, le graphe contient un cycle et l’algorithme
prend fin.
Pour un nœud donné, voyez s’il y a des arcs non marques sortants. Dans ce cas,
rendez-vous à l’étape 5, et l’étape 6 dans le cas contraire.
Choisissez au hasard un arc sortant non marqué et marquez-le. Suivez-le
jusqu’au prochain nouveau nœud en cours et rendez-vous à l’étape 3.
Si ce nœud est le nœud initial, le graphe ne comprend pas de cycle et
l’algorithme prend fin. Dans le cas contraire, vous vous trouvez dans une
impasse. Supprimer l’arc et revenez au nœud précèdent, c’est-à-dire a celui qui
était actif juste avant celui-ci. Faites-en le nœud en cours et retourner à l’étape 3.

Cet algorithme prend à son tour chaque nœud comme racine de ce qu’il pense
être un arbre et parcours l’arbre en profondeur. S’il arrive à un nœud qu’il a déjà
rencontré. C’est qu’il a trouvé un cycle. S’il épuise tous les arcs d’un nœud
donné, il revient au nœud précèdent. S’il revient au nœud racine et ne peut
poursuivre sin chemin cela indique que le sous arbre que l’on peut atteindre
depuis le nœud en cours ne contient aucun cycle.
Exécutons cet algorithme sur notre figure.
On commence par le nœud R et on initialise une liste L à vide. On ajoute ensuite
R a la liste L et on va passer au nœud A. on ajoute également A a la liste L
(L=[R, A]) et on passe au nœud S. on ajoute le nœud S a L (L=[R, A, S]). S ne
possède aucun arc sortant ce qui nous oblige à rebrousser chemin car l s’agit
d’une impasse. Comme A ne possède aucun arc non marqué nous revenons à R
et nous finissons notre inspection de R.
On constatera qu’avec les nœuds A, C, S, F et W nous nous retrouverons avec le
même résultat.
Avec le nœud D
Initialisation de la liste à vide
Insertion du nœud D dans la liste et positionnement sur le nœud T
Insertion du nœud T dans la liste et positionnement sur le nœud E
Insertion du nœud E dans la liste et positionnement sur le nœud V
Insertion du nœud V dans la liste et positionnement sur le nœud G
Insertion du nœud G dans la liste et positionnement sur le nœud U
Insertion du nœud U dans la liste et positionnement sur le nœud D
Insertion du nœud D dans la liste
A partir de ce moment on constate que le nœud D apparait dans notre liste donc
nous sommes en présence d’un cycle. Ainsi l’algorithme prend fin.

 Détecter un interblocage dans un système avec plusieurs ressources

de chaque type

Lorsqu’il existe plusieurs exemplaires de certaines ressource son utilise un

approche différente pour la détection de interblocages. On va présenter un
algorithme utilisant des structures de données pour détecter un blocage parmi n
processus.
Pour cet algorithme nous avons besoin des structures suivantes :
Un vecteur E correspond au vecteur des ressources existantes et indiquant le
nombre de total d’instance de chaque ressources. E= (E1, E2, E3,……, En)
E1=2 indique le type de ressources 1 a 2 instances.
Un vecteur A qui va indiquer les instances de ressources disponibles. E= (A1,
A2, A3,……, An).
Une matrice C dans laquelle on retrouvera les allocations courantes des
processus. Cij représente le nombre d’instances de la ressource j détenue par le
processus i.
Une matrice R des requêtes des processus. Rij représente le nombre d’instances
de la ressource j demandée par le processus i.
Cet Algorithme est base sur le des vecteurs de comparaison. On définit la
relation A<=B sur deux vecteurs A et B pour indiquer que chaque élément de A
est inferieurs ou égal a l’élément de B correspondant.
NB : cet algorithme fait l’hypothèse selon lequel tous les processus concernent
toutes les ressource s détenues jusqu’à la fin de l’exécution.
On peut procéder comme suit :
On cherche un processus non marqué Pi pour lequel la ième range de R est
inférieur ou égal à A.
Si on trouve un tel processus, on ajoute la ieme range de C a A, on marque le
processus et on recommence avec un autre processus.
Si un tel processus n’existe pas, l’algorithme se termine.

Lorsque l’algorithme se termine, tous les processus non marques, s’il y en a sont
en interblocages.
Exécutons cet algorithme avec les données suivantes :
E= (4 2 3 1)
A= (2 1 0 0)

C= (0 0 1 0,
2 0 0 1,
0 1 2 0)
R= (2 0 0 1,
1 0 1 0,
2 1 0 0)

Les processus 1 2et 3ne peuvent pas s’exécuter car

Pour le processus 1 il manque une ressource de type 4
Pour le processus 2 il manque une ressource de type 3
Pour le processus 3 il manque une ressource de type 2

Nous sommes donc en présence d’un interblocage.

3. Reprendre après interblocage

En supposant que notre algorithme de détection des interblocages a fonctionné.

Ce qui ce passe ensuite est que nous avons besoin d’une méthode de reprise pour
faire fonctionner le système. Traitons maintenant quelques méthodes de reprise.

 Reprendre un interblocage au moyen de la préemption

Dans certains cas il est possible de retirer provisoirement une ressource à son
propriétaire pour l’attribuer à un autre processus.
Mais la possibilité de retirer une ressource à un processus pour l’attribuer à un
autre avant de la restituer au premier sans qu’ils s’en aperçoivent dépend
fortement de la nature de la ressource. De même le choix du processus à
suspendre dépend grandement des ressources susceptibles de leur être retirer
facilement. Par conséquent, effectuer une reprise de cette manière est souvent
difficile, voire impossible.

 Reprendre au moyen du rollback

Si les concepteurs de systèmes avaient connaissances des éventuels

interblocages, ils pourraient s’arranger pour que le processus passe
régulièrement par des points de reprises.
Cela signifie que l’état du processus est inscrit dans un fichier pour pouvoir être
restauré ultérieurement. Non seulement le point de reprise contient l’image de la
mémoire mais il indique l’état des ressources c’est-à-dire des ressources
actuellement attribuées à ce processus. Pour que cela soit efficace, il faut que les
nouveaux points de reprises ne remplacent pas anciens, mais qu’il soit écrits
dans de nouveaux fichiers et qu’une séquence complète de points de reprise
s’accumule pendant que le processus s’exécute.
Lorsqu’un interblocage est détecte, il est aisé de repérer les ressources sollicites.
Pour opérer un reprise, il faut le processus détenteur de la ressource sollicite soit
restaure a un état antérieur à l’acquisition de cette ressource au moyen des points
de reprises. Bien sûr tous le travail effectue par ce processus sera jeté. La
ressource est alors attribue au processus bloque et si le processus tente
d’acquérir les ressource il devra attendre.

 Reprendre au moyen de la suppression

La manière la plus simple de d’agir sur un interblocage consiste à supprimer un

ou plusieurs processus. On peut supprimer un processus du cycle avec un peu de
chance les autres processus pourront poursuivent leurs exécution. Si cette
opération ne suffit pas il est possible de recommencer jusqu’à ce que le cycle
soit détruit.
Sinon on peut prendre pour victime un processus un processus qui ne se trouve
pas dans le cycle afin de libérer une ressource. Dans cette approche le processus
supprimer est choisi avec soins car il détient des ressources dont d’autre
processus du cycle ont besoin.
Lorsque cela est possible, il est préférable de supprimer un processus qui peut
être redémarre depuis le début sans conséquences néfastes.

4. Prévenir les interblocages

La question qui se pose ici est celle de savoir comment les systèmes évitent t-il
les interblocages ?
Pour y répondre, il faut revenir aux quatre conditions mentionnes au début afin
de voir si elles peuvent nous donner un indice. Si nous pouvons garantir qu’au
moins une de ces conditions ne sera jamais satisfaite, les interblocages seront
alors structurellement impossibles.

 S’attaquer à la condition de l’exécution mutuelle

Si une ressource n’est jamais attribuée de manière exclusive nous n’aurons

jamais d’interblocage. Toutefois, il est également clair que le fait de permettre à
deux processus d’écrire vers une imprimante au même moment conduit à un
désastre, puisque le spoule de d’impression permet à plusieurs processus de
génère des résultats simultanément. Dans ce modelé, seul processus qui
demande réellement l’imprimante physique est le démon d’impression. Comme
celui-ci ne sollicite jamais une autre ressource, on peut éliminer l’interblocage
de l’imprimante.
Dans un cas ou les démons commence à imprimer avant qu’un processus ne
génèrent tous ses résultats, l’imprimante peut rester bloque pendant des heures si
le processus interrompt la sortie des résultats. C’est pourquoi les démons sont
programmes pour imprimer uniquement après que l’ensemble du fichier de
sortie est disponible. Dans ce cas, nous avons deux processus qui ont terminé
partiellement, mais pas totalement, leur sortie, et qui ne peuvent pas continuer :
aucun processus ne finira jamais. Nous avons donc un interblocage de
l’imprimante.
Toutefois, on trouve là l’ébauche d’une idée souvent applicable. Evitez
d’attribuer une ressource lorsque cela est absolument nécessaire et assurez-vous
que le nombre de processus susceptible de réclamer la ressource est aussi faible
que possible.

 S’attaquer à la condition de la détention et d’attente

Si nous pouvons empêcher que des processus qui détiennent des ressources
attendent d’autres ressources, nous pouvons éviter les interblocages. Pour ce
faire, il est possible d’exiger de tous les processus qu’ils demandent la ressource
s dont ils ont besoin avant de commencer à s’exécuter. Si elles sont toutes
disponibles le processus se verra attribuer tout ce dont il a besoin pour
s’exécuter jusqu’au bout. Si une ou plusieurs ressources sont indisponible, rien
ne pourra être attribue et le processus se contentera d’attendre.
De cette approche découle le problème suivant : bon nombre de processus ne
savent pas combien de ressources ils vont avoir besoin avant de s’exécuter.
Pour contrecarrer de manière légèrement différente la condition détente et
d’attente, on peut exiger qu’un processus qui demande une ressources qu’il
commence par libérer provisoirement toutes les ressources qu’il détient. Il peut
tenter d’obtenir tout ce dont il a besoin en une seule fois.

 S’attaquer à la condition de non préemption

Il est également possible de s’attaquer à la troisième condition. Si un processus a

été attribué à l’imprimante et qu’il se trouve à mi-chemin dans son travail
d’impression, le fait de lui retire l’imprimante de force parce qu’une autre
ressource n’est pas disponible est, au mieux très délicat, au pire, impossible.
Cependant, pour éviter cette situation, on peut vitaliser les ressources. Envoyer
les sorties imprimante sur disque et n’autoriser que les démons d’impression à
accéder à l’imprimante physique élimine les interblocages dus à l’imprimant,
mais peut engendre de problèmes de saturation de disque (risque mineur avec
tous les énormes disques qu’on a aujourd’hui).
On ne peut cependant pas vitaliser toutes les ressources. Les éléments d’une
table ou d’une base de données des systèmes d’exploitation doivent être
verrouillés au moment de l’utilisation et peuvent donc concourir à un
interblocage.

 S’attaquer à la condition de l’attente circulaire

Il existe plusieurs façons d’éliminer l’attente circulaire

On peut simplement établir la règle qui stipule qu’un processus est attribué à
tout moment une et une seule ressource à la fois.
On peut fournir un dénombrement global des ressources. Et appliquer la règle
suivante : les processus peuvent demander des ressources des qu’il le souhaite,
mais toutes les demandes doivent être effectués selon un ordre numérique. Un
processus demande deux ressources successive mais dans un seul ordre.

5. Eviter les interblocages

 Les états sûrs et non sûrs

A tout instant il existe un état compose de E, A, C et R nos ressources utilises
dans la détection.
On dit de l’état A qu’il est sure s’il existe un ordonnancement selon lequel
chaque processus peut s’exécuter jusqu’au bout, même si toutes demandent d’un
seul coup leur nombre maximum de ressources.
Dans la figure (a) nous sommes en présence d’un état ou à possède 3 instances
de la ressource mais peu avoir au final avoir besoin de 9.
On a également les processus B et C.
L’état (a) est sur car il existe une séquence d’allocations qui permet à tous les
processus de s’exécuter jusqu’au bout. Ainsi l’ordonnanceur se contentera
d’exécuter Jusqu’à ce qu’il demande et obtienne deux ressources
supplémentaires ce qui conduit à la figure (b). Lorsque (b) a fini de s’exécuter
on se retrouve à l’état (c). L’ordonnanceur peu alors exécuter C, ce qui mené
finalement à la figure (d). A présent A peu obtenir 6instances supplémentaires
dont il a besoin pour s’exécuter jusqu’au bout. Ainsi l’état de la figure (a) est
sûr. Grâce à un ordonnancement attentif on peut éviter les interblocages.
Considérons les figures suivantes.
Supposons maintenant que qu’avec l’état initial illustrée a la figure (a), A
demandé et obtient une autre ressource, nous conduisant à la figure (b).essayons
de trouver une séquence qui soit sure de fonctionner. L’ordonnanceur peut
exécuter B jusqu’à ce qu’il demande et obtienne toutes ses ressources comme le
montre la figure (c).
Finalement B s’achève et on obtient la figure (d). À ce stade nous sommes
bloqués. Il ne nous reste que 4 instances libre et chacun des processus en
demande cinq pour finir de s’exécuter. Aucune séquence n’est assure d’arriver à
son terme. Ainsi le mode d’allocation des ressources que nous avons choisi et
qui nous a conduit la figure (a) à la figure (d) nous fait passer d’un état sûr a un
état non sure. Exécuter ensuite A ou C en commençant à la figure (b) ne change
pas non plus. Rétrospectivement, la demande de N’aurai pas dû être satisfaite.
Il convient de noter qu’un état ne conduit pas nécessairement a un inter blocable.
Ainsi à partir de la figure (b), le système peut s’exécuter pendant un certain
temps. En fait un processus peut même s’achever. De plus, il est possible que A
libère une ressource avant d’en demander d’autres, ce qui permet à C de ce
terminer et d’éviter par la même un interblocage. Ainsi, la différence entre un
état sur et un état non sur tient à ce que dans un état sur, le système peut garantir
que tous les processus s’achèveront ; dans un état non sur cette garantie ne peut
pas être accordé.

 L’algorithme du banquier pour éviter un interblocage

On va directement généraliser l’algorithme du banquier à plusieurs ressources.

Son fonctionnement est illustre par la figure suivante :
Ici nous avons deux matrices. Celle de gauche illustre le nombre de ressources
attribuées à chacun des 5 processus et celle de droite montre le nombre de
ressources dont chaque processus a besoin pour se terminer. Ces matrices
correspondent aux matrices vues ci-dessus. Le vecteur E correspond aux
ressources existantes, P les ressources détenues et A les ressources disponibles.
L’algorithme qui vérifie la sureté de l’état peut maintenant être établi.
Rechercher une rangé de R dont les demandes de ressources non satisfaites sont
inférieurs ou égal a A. si cette rangée n’existe pas, le système peut finalement se
bloquer car aucun processus ne peut s’exécuter jusqu’au bout (on suppose que
les processus garde toutes les ressource acquissent jusqu’à ce qu’ils se
terminent.)
Supposons que le processus de la rangée choisi de mande toutes les ressources
dont il a besoin (nous avons la garantie que cela est possible) et qu’il se termine.
Marquez-ce processus comme achevé et ajoutez toutes ses ressources au vecteur
A.
Recommencer les étapes 1 et2, soit jusqu’à ce que tous les processus soient
marqués comme termine-auquel cas l’état initial est sur-, soit jusqu’à ce qu’il ne
reste plus de processus demandant une ressource disponible (auquel cas il y a un
interblocage.).
S’il existe plusieurs processus éligible a l’étape 1, peu importe ce que l’on
choisit : le pool des ressources disponibles s’accroit ou au pire, reste identique.
Revenons a notre exemple de figure ou l’état en cours est sure. Supposons
maintenant que le processus B demande un scanner. Cette requête peut être
satisfaite car l’état qui en résulte est toujours sur.
Apres avoir attribué à B l’un des deux scanner restant, imaginons alors que E
sollicite le dernier scanner. Le fait de satisfaire cette requête réduit ressources
disponible le vecteur de a (1 0 0 0), ce qui conduit à un interblocage. Il apparait
clairement que la requête de E doit être reporte pour un temps.

Conclusion
Au terme de notre étude il en ressort que tous les système d’exploitation utilise
des stratégies algorithmiques pour assurer la bonne gestion des ressources entre
différents processus , cette taches étant un élément cruciale qui assure
l’efficacité d’un système d’exploitation .nous pouvons dire au terme de notre
analyse que l’interblocages est un problèmes rencontrés par tous les systèmes
d’exploitation .

Bibliographie
Andrew Tanenbaum, système d’exploitation peason education France, 2008

H. Bourzoufi, cours de système D’exploitation ,les interlocages, Université de

valenciennes

Leonardo Brenner, Jean Luc Massat, système d’Exploitation , gestion des

ressources, Aix-Marseille Unive