Discussion :

[prgasp77]

Bonjour à tous.
Mon titre est un peu trompeur, ce que je cherche à faire est un poil plus compliqué.

Un processus A crée un processus B.
Le processus B a deux tâches à accomplir.
Le processus A doit attendre que le processus B ait achevé sa tâche 1 avant de reprendre là où il en était avant de créer le processus B.

Je code en C, mais c'est sûrement un détail. J'ai pensé à plusieurs solutions dont une presque parfaite :
Lorsque B a terminé sa tâche 1, il envoie à A (via kill) le signal SIGUSR1 puis commence sa tâche 2. Avant cela, A avait pris soin d'intercepter SIGUSR1 via un handler. Ainsi, lorsque A recevra SIGUSR1, la fonction handler (user-defined) s'exécutera ... oui mais il est question de continuer sa tâche, pas d'en commencer une nouvelle.

Je peux donner plus de précisions (ou du code) si nécessaire.
En vous remerciant,

[Qwert]

Compliqué toussa....
Pourquoi ne pas utiliser les threads plutôt?

[ram-0000]

• Un sémaphore créé par le père
• puis le père lance le fils
• et attends que le sémaphore se libère
• le fils fait sa tâche 1 puis libère le sémaphore
• le père continue là ou il était en attente bloquante
• le fils continue sa vie (et meurt éventuellement)

[prgasp77]

Bonjour à vous deux

Compliqué toussa....
Pourquoi ne pas utiliser les threads plutôt?

Je tente de faire avec ce que je connais ... Si ça n'est pas possible, je me renseignerai sur les threads, merci.

• Un sémaphore créé par le père
• puis le père lance le fils
• et attends que le sémaphore se libère
• le fils fait sa tâche 1 puis libère le sémaphore
• le père continue là ou il était en attente bloquante
• le fils continue sa vie (et meurt éventuellement)

Cela me semble intéressant, mais qu'entends-tu par "attendre que le sémaphore se libère" ? Je n'ai pas encore mis en place le système de sémaphore dont aura besoin mon application, et je ne sais pas encore comment cela fonctionne en détail. S'agit-il de faire des while(sémaphore pas libéré) sleep(1) ? Si c'est le cas, cela ne me convient pas (à moins que l'on puisse dormir une milliseconde), j'ai en effet msi en place le système de processus parallèles afin d'économiser de précieuses millisecondes ...

Cordialement,

[ram-0000]

un sémaphore est un objet qui sert à synchroniser des processus.

Il a 2 états, pris ou libéré
2 actions sont possibles dessus, Prendre et Libérer. Pour info, il y a en plus les 2 opérations de Création et de Destruction.

On ne peut prendre un sémaphore que si celui ci est libre. S'il n'est pas libre, l'opération Prendre est bloquante. C'est un blocage géré au niveau du système, nul besoin de boucle de test active du genre "while(1) ..."

Si est process A est bloqué sur un Prendre et que l'autre process B qui avait pris le sémaphore le sémaphore le libère, le process A est immédiatement libéré.

Regarde ce tuto : LES SEMAPHORES SOUS UNIX

[prgasp77]

Merci beaucoup.
J'ai implémenté la solution 2<-S;[P(S);Z(S)] (deux processus). Cela fonctionne à emrveille ... mais ... Y a-t-il une solution de limiter Z ? c'est à dire que si le fils meurt par erreur, le père reste bloqué ad eternum, ce qui pose un gros problème étant donné qu'il est chargé d'une part de supprimer l'ensemble de sémaphores utilisés, mais aussi de libérer la mémoire partagée.

Donc, j'aimerais que si Z bloque A pendant plus de n (mili)secondes, A passe en mode dégénéré et se termine en urgence.

Merci.

[ram-0000]

Normallement, si le noyau fait bien son boulot, si un un process qui a pris un sémaphore meurt, le sémaphore devrait être automatiquement libéré (ce qui va par conséquent autoriser le père à continuer).

A tester donc avec un gros "kill -9" sur le fils pendant qu'il a pris le sémaphore

[prgasp77]

Bonjour.
De fil en aiguille, mon problème s'est compliqué. je me retrouve avec un processus père et deux fils.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
 
Père  : I ; P(1)                ; _    ; V(2) ; _     ; exit
Fils1 : _ ; V(0) ; P(2)                       ; _     ; V(3) ; exit
Fils2 : _ ; P(0) ; _     ; V(1) ; _     ; P(3)               ; _ ; exit

Où _ désigne une tâche qui prend un certain temps et I l'initialisation de tous les sémaphores à 0 (zéro).

L'ensemble fonctionne à merveille. Mais dans 1.4% des cas, un des fils se retrouve bloqué. Le fait qu'il n'effectue pas sa tâche ne me gêne pas plus que cela. En revanche, le processus reste en attente indéfiniement et prend une ligne dans la table des processus.
Est-il possible de tuer automatiquement tout processus qui attend la libération d'un sémaphore pendant plus de n secondes ?

Je suis aussi preneur pour toute autre solution. Merci beaucoup, vous m'avez déjà beaucoup aidé.

Cordialement,

[prgasp77]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

int semtimedop(int semid, struct sembuf *sops, unsigned nsops, struct timespec *timeout);

man semtimedop

[Ubiquité]

Ca m'a tout l'air d'être ce qu'on appel un hack ta solution à base de semtimedop.

Tu veux faire quoi exactement maintenant que t'as 3 processus ?

[prgasp77]

Non, il s'agit d'une solution parfaitement adaptée.

Il s'agit d'un cache. Lorsqu'on demande au père un élément dudit cache,
s'il a déjà été inséré il le retourne,
sinon si le cache est plein, il invoque un fils qui le vide partiellement
puis invoque un fils qui remplie le cache de la valeur demandée et adjassantes.

Avec le schéma du message du 8, tu peux devinier comment cela fonctionne

[Ubiquité]

J'aurai préféré avoir une présentation du problème comme t'as fait dans le premier poste.

En déchiffrant le poste 8 on peut voir ce que ton programme fait mais pas forcément ce que tu veux qu'il face. Enfin soit.

[prgasp77]

Mais ça y est, mon problème est résolu