fork et synchronisation

**mathys** · 11/02/2011, 16h13

Bonjour,

Supposons deux processus créés par des fork() s'exécutant en parallèle (dans mon cas, ils ont le même père, mais je ne sais pas si ça influe sur la réponse) : un processus doit exécuter les instructions L1, L2, L3 et L4. J'aimerais que si L2 est exécuté, alors la main ne passe pas à l'autre processus sans exécuter d'abord L3 : après L1, soit c'est l'autre processus qui s'exécute, soit L2 et L3 sont exécutés, puis soit L4 soit l'autre processus.
J'espère avoir été clair.
Merci à ceux qui prendront la peine de m'aider.

**quetzacoatl** · 11/02/2011, 19h44

je pense que c'est possible en utilisant des tubes pour que les processus puissent communiquer entre eux(et donc pouvoir échanger des informations)

**Sve@r** · 11/02/2011, 20h29

Salut

Si j'ai bien compris, soit le P1 exécute L1, L2 et L3 (et éventuellement L4) avant que P2 ne prenne la main, soit P1 n'exécute que L1 puis P2 prend la main puis P1 exécute L2 et L3. Bref, en fait, L2 et L3 sont atomiques et doivent rester ensembles quoi.

Tu ne peux pas laisser le scheduler diriger et espérer que L2 et L3 seront ensembles. Te faut imposer tes choix. Tu peux par exemple mettre P2 en pause() puis, quand L2 et L3 ont été exécutés, P1 envoie un kill à P2 qui sort alors de son sommeil. Ou alors utiliser un sémaphore pour que celui qui prend la main verrouille les accès jusqu'à ce qu'il puisse la rendre...

**mathys** · 12/02/2011, 11h46

Bonjour et merci, c'est exactement ça : L2 et L3 doivent rester ensemble. Mais j'aimerais que cela soit la seule chose que j'impose. C'est un problème théorique que je pose, c'est vrai qu'en pratique je ne vois pas où est l'inconvénient d'imposer plus, par exemple de mettre un processus en pause, mais j'aimerais savoir s'il y a un moyen pour faire en sorte que L2-L3 soit atomique.

La solution sémaphore, je ne l'ai pas comprise (les sémaphores, c'est pour l'accès à des données non? - ici, disons que L2 et L3 sont des printf), mais tu sembles dire que ça ne sera de toute façon pas une solution exacte à mon problème?

Quant aux tubes, ce serait quoi l'idée? J'ai pensé à la chose suivante. Entre L1 et L2, j'envoie dans un tube une certaine info A. Entre L3 et L4, j'envoie une autre info B. Si l'autre processus reçoit A, alors il attend d'avoir reçu B pour continuer à s'exécuter. En fait, je ne vois pas bien comment implanter ça concrètement. En revanche, ça m'a fait penser qu'avec des signaux, ça pourrait peut-être marcher : entre L1 et L2, le processus envoie un signal A, entre L3 et L4, le processus envoie un autre signal B. L'autre processus se met en pause quand il reçoit A et se réveille quand il reçoit B. C'était ça l'idée du kill?

**matafan** · 12/02/2011, 20h45

Tu as ce qu'on appèle une section critique, faite des instructions L2 et L3 : tu ne veux pas qu'un process puisse entrer dans cette section de code si un autre process est déjà en train de l'exécuter.

Tu peux utiliser un sémaphore initialisé à 1. Tu décrémentes le sémaphore avant d'exécuter L2, et tu l'incrémente après avoir exécuter L3. Le principe du sémaphore c'est qu'on ne peux plus le décrémenter une fois qu'il est à 0 : si un process essaie de décrémenter un sémaphore qui est à 0, il est mis en attente (il se bloque sur l'opération de décrémentation) jusqu'à ce que la valeur du sémaphore se soit plus nulle. Donc dans notre cas jusqu'à ce que le process qui était dans la section critique en sorte.

Avec des pipes ca serait nettement plus compliqué, en particulier parce qu'un pipe est unidirectionnel. Dans ton cas, en supposant que les instructions L1 à L4 sont exécutées plus d'une fois, il te faut pouvoir communiquer dans les deux sens, et donc deux pipes.

**Sve@r** · 13/02/2011, 11h24

Envoyé par mathys

La solution sémaphore, je ne l'ai pas comprise (les sémaphores, c'est pour l'accès à des données non? - ici, disons que L2 et L3 sont des printf), mais tu sembles dire que ça ne sera de toute façon pas une solution exacte à mon problème?

Sisi les sémaphores sont bien la solution comme l'explique Matafan. Un sémaphore initialisé à 1. Lorsque P1 et P2 arrivent à la section critique, les deux demandent le sémaphore. Seul l'un des deux l'obtient et l'autre passe en attente jusqu'à ce que le sémaphore soit rendu. Les points de suspension n'étaient qu'une façon de dire que la discussion ne s'arrêtait pas.

Envoyé par mathys

Quant aux tubes, ce serait quoi l'idée? J'ai pensé à la chose suivante. Entre L1 et L2, j'envoie dans un tube une certaine info A. Entre L3 et L4, j'envoie une autre info B. Si l'autre processus reçoit A, alors il attend d'avoir reçu B pour continuer à s'exécuter. En fait, je ne vois pas bien comment implanter ça concrètement. En revanche, ça m'a fait penser qu'avec des signaux, ça pourrait peut-être marcher : entre L1 et L2, le processus envoie un signal A, entre L3 et L4, le processus envoie un autre signal B. L'autre processus se met en pause quand il reçoit A et se réveille quand il reçoit B. C'était ça l'idée du kill?

Non. C'était simplement que P2 appelle la fonction pause() qui le met en sommeil jusqu'à ce qu'il reçoive un signal, signal envoyé par P1 via la fonction kill() quand L2-L3 est terminé...