Existe-t-il des équivalents au futex sous Linux / Unix?

Je cherche quelque chose qui pourrait être utilisé pour polling (tel que select , kqueue , epoll ie polling non occupé ) en C / C ++. En d’autres termes, j’ai besoin de bloquer un thread, puis de le réactiver dans un autre thread avec le moins de temps système possible .

Une condition variable mutex + condition variable fonctionne, mais il y a beaucoup de frais généraux. Un futex fonctionne également, mais c’est uniquement pour Linux (ou peut-être pas?). Une synchronisation supplémentaire n’est pas nécessaire tant que l’ interrogation elle-même fonctionne correctement, par exemple, aucune course lorsque j’appelle l’ wait et l’ wake dans deux threads.

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

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

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

Notez que dans la mesure où toute solution dans laquelle un thread dort jusqu’à ce qu’il soit réveillé implique un appel système du kernel, elle n’est toujours pas bon marché . En supposant que x86_64 et la libc FreeBSD soient des implémentations raisonnables, le coût inévitable semble être le suivant:

  1. synchronisation du compte en mode utilisateur (avec un CAS ou similaire)
  2. gestion du kernel de la queue et du thread veille / attente

Je suppose que la surcharge mutex + condvar qui vous inquiète est la séquence cond_wait-> re-lock-> unlock, ce qui est effectivement évité 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, par exemple si vous avez une queue, vous incrémentez (post) dans le sémaphore à chaque fois que vous insérez un message et votre destinataire décrémente (attend) 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