Skip to content

MOOC NSI - fondamentaux.

Transcription de la vidéo

4.2.2.4 : Ordonnancement et non déterminisme

[00:00:01]

Dans la séquence précédente, nous avons vu que le système d'exploitation doit faire de l'ordonnancement pour décider quels processus vont s'exécuter sur les processeurs et dans quel ordre. Dans cette séquence, nous allons voir que l'ordonnancement est non déterministe, c'est à dire que du point de vue de l'utilisateur, s'il fait plusieurs exécutions, il ne sera pas à quel moment ces processus vont être un ordre annoncé et il ne saura pas comment ils vont interagir avec les autres processus. L'ordre d'exécution des processus est en effet non déterministe puisqu'il deux-ponts tout d'abord de l'algorithme de l'ordonnancement qui est utilisé par le système d'exploitation, mais aussi d'autres facteurs comme la charge de la machine, c'est à dire des processus qui sont lancés et qui s'exécutent sur la machine des conditions extérieures. On ne va pas avoir le même comportement s'il fait très froid ou s'il fait très chaud et bien sûr, du comportement des processus qui sont lancés sur la machine. Donc, dans le cas général, si nous avons un certain nombre de processus qui sont lancés, nous ne savons pas et nous ne pouvons pas prévoir dans quel ordre ils vont être hors denoncer et exécuter. Et en plus, plus il y a de processus, plus ils sont lents, plus l'entrelacement entre ces processus va être important et plus d'une exécution à une autre. Cet entrelacement va changer comme conséquence. Nous savons qu'un programme peut se comporter de différentes manières, d'une exécution à l'autre et une conséquence vraiment directe. Peut être que la durée d'exécution peut être plus ou moins longue.

[00:01:55]

Essayons d'illustrer ce cas avec un petit programme parallèle où nous créons des processus à l'aide de l'appel système fork. Je vous rappelle qu'avec Fork. Si tout se passe bien, puisque dans ce programme, encore une fois, je ne gère pas les cas d'erreur. Si tout se passe bien après le fork, nous avons un nouveau processus qui est créé, appelé processus fissent, qui est la copie conforme du processus qui vient de le créer et qui va continuer avec les instructions qui suivent le fork. Ici compte, nous lançons le programme Python, le premier processus créé va commencer par exécuter la fonction mail. Et il va faire un premier affichage qui est print. Process parents, avec mon identifiant et en appelant la fonction GET piaillent, dit ensuite ce que nous avons, c'est une boucle qui va s'exécuter 3 fois et nous avons l'appel à la fonction fork en début de boucle. Voyons ce qui se passe. Nous avons donc ce premier processus qui commence l'exécution de la boucle et y a la valeur 0. Ce processus appelle la fonction fork, qui a pour conséquence de créer un processus fixe. A partir de maintenant, donc, nous avons deux processus. Les deux processus continuent avec les instructions qui suivent l'opération fork, c'est-à-dire le print qui est marqué en rouge, le print qui est marqué en vert. Le troisième print qui est en jaune, va être exécuté que par le processus pour qui la variable Nupedia Eadie contient 0.

[00:03:57]

Je vous rappelle également que Fork renvoie deux valeurs différentes ou de processus. Donc, il envoie zéro au processus, fissent et l'on voit l'identifiant du fil au processus pair. Donc, c'est pour le processus, fissent que nu, nu piaillent, dit à la valeur 0 c'est le fils qui va exécuter le print marqué en jaune. C'est ce qui est marqué ici. Donc on bat je le premier processus qui est devenu père et en haut, j'ai le fils qui exécute les 3 prints. Les deux processus continuent, ça veut dire que les deux continuent avec la boucle avec i égal un. Et donc, les deux vont faire un fork. Ainsi, le premier premier processus va avoir un deuxième fils et son premier fils va également créer un fils. Et ensuite, nous avons vu la même chose pour les pères. Il va y avoir l'exécution du prince rouge et du print vert. Pour l'autre père haussier et pour les fils, nous allons avoir le rouge, le vert et le jaune. Les quatre processus continuent avec la boucle et avec l'itération ou i égale II. Et les quatre vents appelés fork, donc les quatre processus vont avoir un autre processus fils. Et pareil, donc les pairs vont exécuter les deux et partitions rouges et vertes alors que les fils vont exécuter la rouge, la verte et la jaune. Donc, vous voyez que nous avons un certain nombre de processus ici, plus particulièrement à la fin en A8 8 et plusieurs opérations d'affichage.

[00:05:53]

Ce que nous allons regarder, c'est l'ordre dans lequel nous observons les affichages. Alors pour faire ceci, quand je lance mon programme Python, j'ai utilisé la commande P string que nous avons vu dans la séquence précédente qui me montre exactement l'arbre des processus. Comme moi, je l'ai dessiné en dessous dans le schéma. Donc, la première ligne, si on regarde le listing de Pastré, le premier processus, c'est le premier qui commence avec Zéro et son premier fils, ça va être la deuxième ligne. Donc, un 8 7 3 2, son deuxième fils va être à 8 7 3 3 et son troisième fils va être 1 8, 7 3 4. Donc, si vous regardez bien, c'est vrai que ce n'est pas dessiné dans le même sens, mais il y a une correspondance un à un avec le schéma que j'ai mis en dessous. Nous allons donc utiliser des couleurs. Donc, je prends cet arbre et je mets différentes couleurs pour les différents processus. Et ensuite, à gauche, j'ai l'affichage de mon programme que j'ai obtenu pendant une exécution. Donc, si je remets les couleurs. De mon arbre à droite, voici ce que j'obtiens, donc j'ai un entrelacement, j'ai le processus jaune qui effectue certaines opérations et après un peu plus tard, on effectue deux autres. J'ai le processus rose, qui effectue trois opérations, est arrêtée par l'ordonnance, l'ordonnanceur et ensuite continue avec deux autres opérations rose et même plus loin, deux autres. Voici ce que nous obtenons lors d'une première exécution.

[00:07:49]

Si nous exécutons une deuxième fois, alors c'est un peu. Pas direct puisque quand on exécute un programme une deuxième fois, les numéros de processus changent. Donc, vous avez l'arbre correspondant avec P. Estrie à droite, c'est le même arbre, même si ce n'est pas les mêmes identifiant de processus et donc nous utilisons les mêmes couleurs. Donc, le perce est jaune comme sur le transparent précédent. Le premier fil, c'est rose. Le premier fichier rose, etc. Et nous obtenons l'exécution à gauche avec l'entrelacement qui est montré. Mettons les côte à côte. Voici donc à gauche l'exécution. La première. A droite, la deuxième exécution. Vous voyez bien que. Les couleurs ne se suivent pas dans le même ordre. Et c'est exactement ce que nous voulions voir, c'est que l'ordonnancement entre les différents processus change. Dans cette séquence, nous avons vu que l'ordonnancement est non déterministe du point de vue de l'utilisateur. Pour lui, le comportement du programme, surtout si c'est un programme parallèle, peut changer d'une exécution à l'autre. Cela a deux conséquences importantes. La première est qu'il est difficile de comprendre ce qui se passe, donc il est difficile de savoir si le programme s'exécute correctement ou alors s'il y a une erreur puisqu'il est difficile de reproduire les rangs. La deuxième conséquence est que si nous voulons imposer un ordre pour les processus et pour leurs interactions, alors il faudra utiliser d'autres moyens qui sont les moyens de synchronisation dont nous allons parler plus loin dans les séquences vidéo.