Provided by: manpages-fr_3.23.1-1_all bug

NOM

       futex - Verrouillage rapide en espace utilisateur

SYNOPSIS

       #include <linux/futex.h>

DESCRIPTION

       Le  noyau  Linux fournit des futex (« Fast Userspace muTexes ») en tant
       que brique permettant un verrouillage  et  des  sémaphores  rapides  en
       espace  utilisateur.  Les  futex  sont  très  basiques  et  se  prêtent
       facilement à la construction d’abstractions  de  verrouillage  de  plus
       haut niveau telles que les mutex POSIX.

       Cette   page   ne  prétend  pas  documenter  toutes  les  décisions  de
       conception, mais se  restreint  aux  problèmes  liés  au  développement
       d’applications   et  de  bibliothèques.  La  plupart  des  programmeurs
       n’utiliseront en fait pas les futex directement, mais  utiliseront  des
       bibliothèques  système  construites  par-dessus, comme l’implémentation
       NPTL des pthreads.

       Un futex est identifié par une zone  mémoire  qui  peut  être  partagée
       entre  plusieurs  processus.  Dans ces différents processus, il n’a pas
       forcément la même adresse. Dans  sa  forme  de  base,  un  futex  a  la
       sémantique  d’un  sémaphore ;  il  s’agit  d’un  compteur qui peut être
       incrémenté et décrémenté  de  façon  atomique.  Les  processus  peuvent
       attendre que cette valeur devienne positive.

       Une  opération sur un futex est faite entièrement en espace utilisateur
       dans le cas où il n’y a pas de contention. Le noyau n’est impliqué  que
       pour arbitrer en cas de contention. Comme toute application raisonnable
       est conçue pour éviter les contentions, les futex sont  optimisés  pour
       cette situation.

       Dans  sa  forme basique, un futex est un entier aligné qui n’est accédé
       que par des instructions assembleur atomiques.  Des  processus  peuvent
       partager  cet  entier  avec  mmap(2),  avec  des  segments  de  mémoire
       partagés, ou parce qu’ils  partagent  leur  espace  mémoire ;  dans  le
       dernier cas, l’application est dite multithreadée.

   Sémantique
       Toute  opération futex démarre en espace utilisateur, mais il peut être
       nécessaire de communiquer avec le noyau avec l’appel système  futex(2).

       Pour  incrémenter  un  futex,  exécuter les instructions assembleur qui
       causent l’incrémentation atomique de l’entier par le  processeur  hôte.
       Ensuite,  vérifier  si  sa  valeur a changé de 0 à 1, auquel cas il n’y
       avait pas de processus en  attente  et  l’opération  est  terminée.  Il
       s’agit  du cas sans contention, qui est rapide et devrait être commune.

       En cas de contention, l’incrémentation atomique a modifié le compteur à
       partir  de  -1  (ou  une autre valeur négative). Si cette situation est
       détectée, il y a des processus en attente.  L’espace  utilisateur  doit
       alors  fixer  le  compteur  à  1, et demander au noyau de réveiller les
       processus en attente avec l’opération FUTEX_WAKE.

       Attendre un futex, le décrémenter, est l’opération inverse. Décrémenter
       le compteur de façon atomique, et vérifier si sa nouvelle valeur est 0,
       auquel cas l’opération est terminée, et il n’y avait pas de contention.
       Dans  tous  les  autres  cas,  le  processus  doit attendre qu’un autre
       processus  implémente  le  futex.  Pour  cela,   utiliser   l’opération
       FUTEX_WAIT.

       On  peut  éventuellement  passer un délai en argument à l’appel système
       futex(2), qui indique combien de temps le noyau doit  attendre  que  le
       futex soit incrémenté. Dans ce cas, la sémantique est plus complexe, et
       le programmeur devrait lire futex(2) pour  plus  de  détails.  La  même
       remarque est valable pour l’attente asynchrone sur un futex.

VERSIONS

       La  gestion des futex a été intégrée à Linux 2.5.7, avec une sémantique
       différente de celle  décrite  ci-dessus.  La  sémantique  actuelle  est
       disponible depuis Linux 2.5.40.

NOTES

       Répétons‐le, les futex de base ne sont pas conçus comme une abstraction
       facile à employer pour  les  utilisateurs.  Les  implémenteurs  doivent
       maîtriser  l’assembleur  et  avoir lu les sources de la bibliothèque en
       espace utilisateur décrite ci-dessous.

       Cette page de manuel illustre l’utilisation la plus courante des appels
       futex(2) : il ne s’agit absolument pas de la seule.

VOIR AUSSI

       futex(2)

       « Fuss,  Futexes  and  Furwocks:  Fast  Userlevel  Locking  in  Linux »
       (proceedings  of  the  Ottawa  Linux  Symposium   2002),   bibliothèque
       d’exemple             de             futex,             futex-*.tar.bz2
       <URL:ftp://ftp.kernel.org/pub/linux/kernel/people/rusty/>.

COLOPHON

       Cette page fait partie de  la  publication  3.23  du  projet  man-pages
       Linux.  Une description du projet et des instructions pour signaler des
       anomalies      peuvent      être       trouvées       à       l’adresse
       http://www.kernel.org/doc/man-pages/.

TRADUCTION

       Cette page de manuel a été traduite et est maintenue par Julien Cristau
       <julien.cristau@ens-lyon.org> et l’équipe francophone de traduction  de
       Debian.

       Veuillez   signaler   toute   erreur   de   traduction  en  écrivant  à
       <debian-l10n-french@lists.debian.org> ou par un rapport de bogue sur le
       paquet manpages-fr.

       Vous  pouvez  toujours avoir accès à la version anglaise de ce document
       en utilisant la commande « man -L C <section> <page_de_man> ».