Bonjour à tous
 
Je suis en train d'écrire un programme en C qui est assimilable à un échange maitre/esclave.
Dans ce programme, j'ai besoin de surveiller des sémaphores.
Concrètement j'ai un sémaphore qui va indiquer que je peux recevoir des datas et un autre sémaphore indiquant que je peux en émettre.
Le but serait de faire une attente passive et se réveiller quand l'un des 2 sémaphores est disponible.
 
Par exemple, mon esclave attend de recevoir des données du maitre. Si des données arrivent, un sémaphore est libéré côté esclave.
Parallèlement à ça, dans un thread différent, l'esclave fait un traitement des données reçues précédemment. A la fin de ce traitement, il libère un sémaphore indiquant qu'il est prêt à envoyer le résultat au maitre.
J'aimerai donc gérer le fait que des fois, je vais d'abord recevoir des nouvelles données du maitre avant de lui envoyer le résultat du calcul précédent.
Mais dans certains cas je peux aussi envoyer le résultat du calcul avant que le maitre ne m'envoie à nouveau des données à traiter.
 
Je veux donc attendre 2 sémaphores, et dès qu'une des 2 sémaphores est disponible, me réveiller pour faire la tâche associée.
 
Est-ce que quelqu'un aurait une idée de comment faire?
 
Merci à tous

Ha, ha, laisse-moi deviner, tu es sur un système posix ? Parce que sous Windows, ça aurait été torché en un appel de fonction: WaitForMultipleObjects(). Il y a pas mal de trucs moisi sous Windows, mais ça c'est vraiment bien foutu: un genre de select que tu peux appliquer sur un peu près tout: semaphore, mutex, process, thread, pipe, fichier, connexion TCP, évènement d'une fenêtre, etc....
 
Avec la lib pthread, faudra passer par des variables conditions, et le code ne sera pas spécialement trivial. Tu peux t'inspirer de ça:
http://stackoverflow.com/questions [...] ary-sleeps
 
(c.f. première réponse). Les fonctions qui t'intéresseront sont pthread_cond_signal() et pthread_cond_wait(). J'évite le détail, parce qu'il y en a potentiellement pour des pages....
 

Oui voilà il m'aurait fallu une sorte de select(), ça aurait été parfait.
Je suis sur Linux et j'espérais ne pas avoir à utiliser pthread car j'essaye de passer par OpenMP pour sa simplicité et sa meilleure portabilité pour ce que je veux en faire...
 
J'étais plutôt parti vers plusieurs sem_timedwait() imbriqués dans une boucle infinie. Mais je pense que lorsque je vais vouloir augmenter ma vitesse de traitement, je vais devoir diminuer le temps d'attente du sem_timedwait() et je vais me retrouver avec une sorte de boucle infinie faisant tourner le CPU à 100%...

Je me demande si tu ne ferais pas mieux d'utiliser autre chose que des sémaphores. J'ai un peu de mal à voir comment tout ça communique, mais de ta description, je me demande si un ou plusieurs tube de communication (via pipe()) ne ferait pas l'affaire. Au moins tu pourrais faire un select() sur les descripteurs retournées et utiliser le tube de communication pour passer des messages.

Ce n'est pas bête du tout, c'est même plutôt malin
Je vais creuser dans ce sens là, mais ça m'a l'air pas mal.
 
Merci beaucoup

Le modèle maître/esclave se rapproche du modèle producteur/consommateur, je pense. Mais ça suppose qu'il y ait un buffer partagé entre le producteur et le consommateur et donc un mutex (sémaphore) sur ce buffer pour pas écrire au même endroit qu'une lecture en cours.
 
Je dirais que si c'est dans un but pédagogique ce programme, il faut clairement l'écrire avec des sémaphores. Sinon, un pipe peut faire l'affaire.