Existe-t-il des équivalents au futex sous Linux / Unix? - c ++, c, multithreading

Je cherche quelque chose qui pourrait être utilisé pour vote (comme select, kqueue, epoll c'est-à-dire pas sondage occupé) en C / C ++. En d'autres termes, j'ai besoin de bloquer un fil, puis de le réactiver dans un autre fil avec aussi peu de frais généraux que possible.

UNE mutex + condition variable fonctionne, mais il y a beaucoup de frais généraux. UNE futex fonctionne également, mais cela ne concerne que Linux (ou peut-être pas?). Une synchronisation supplémentaire n’est pas nécessaire tant que la vote lui-même fonctionne correctement, par exemple. pas de course quand j'appelle wait et wake en deux fils.

Edit: Si une telle "installation" n’existe pas dans FreeBSD, comment en créer une avec les types intégrés C ++ 11 et les appels système?

Edit2: Depuis que cette question a migré vers SO, je voudrais la rendre plus générale (pas uniquement pour FreeBSD)

Réponses:

les sémaphores ne sont pas des mutex et fonctionneraient avec un peu moins de temps système (en évitant le verrouillage mutex + condvar, par exemple)

Notez que comme toute solution dans laquelle un thread dort jusqu’à ce qu’il soit réveillé implique un appel système du noyau, il n’en reste pas pas cher. En supposant que x86_64 et la libc FreeBSD soient des implémentations raisonnables, le coût inévitable semble être:

1. synchronisation du compte en mode utilisateur (avec un CAS ou similaire)
2. gestion du noyau de la file d'attente et des threads veille / attente

Je suppose que la surcharge mutex + condvar qui vous inquiète est la séquence cond_wait-> re-lock-> unlock, qui est en effet évitée ici.

Vous voulez des sémaphores et non des mutex pour la signalisation entre les threads ..

http://man7.org/linux/man-pages/man3/sem_wait.3.html

Les sémaphores peuvent être utilisés comme un compteur, comme sivous avez une file d'attente, vous incrémentez (post) dans le sémaphore chaque fois que vous insérez un message, et votre destinataire décrémente (attendez) sur le sémaphore pour chaque message extrait. Si le compteur atteint zéro, le récepteur bloquera jusqu'à ce que quelque chose soit écrit.

Ainsi, un schéma typique consiste à combiner un mutex et un sémaphore.

sender:
mutex.lock
insert message in shared queue
mutex.unlock
semaphore.post

receiver:
semaphore.wait
mutex.lock
dequeue message from shared structure
mutex.unlock