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.