Provided by: manpages-es_1.55-9_all bug

NOMBRE

       futex - Bloqueos rápidos en espacio de usuario

SINOPSIS

       #include <linux/futex.h>

DESCRIPCIÓN

       El  núcleo de Linux proporciona futexes (’Fast Userspace muTexes’) como
       un componente básico para  la  construcción  de  bloqueos  y  semáforos
       rápidos  en espacio de usuario. Los futexes son un mecanismo muy básico
       y se prestan bien para construir abstracciones de más alto  nivel  como
       mutexes POSIX.

       Esta  página no pretende documentar todas las decisiones de diseño sino
       que  se  limita  a  cuestiones  relevantes  para   el   desarrollo   de
       aplicaciones  y  bibliotecas. De hecho, la mayoría de los programadores
       no usarán futexes directamente sino que en  su  lugar  se  apoyarán  en
       bibliotecas del sistema construídas sobre ellos, como la implementación
       NPTL de pthreads.

       Un futex se identifica mediante un  trozo  de  memoria  que  puede  ser
       compartido  entre  diferentes  procesos. En estos procesos, el futex no
       necesita tener direcciones idénticas. En su forma más básica, un  futex
       tiene  la  semántica  de  un  semáforo;  es  un  contador  que se puede
       incrementar y reducir de forma atómica; los procesos pueden  esperar  a
       que el valor se vuelva positivo.

       En  el  caso  en el que no se produzca contienda, la operación futex se
       realiza enteramente en espacio de usuario. Al núcleo sólo se le implica
       para  arbitrar  el  caso  de  contienda.  Al igual que en otros diseños
       sensatos, los futexes se han optimizado para evitar la contención en la
       medida de lo posible.

       En  su  forma  más  básica,  un futex es un entero alineado que sólo se
       modifica mediante instrucciones atómicas en ensamblador.  Los  procesos
       pueden  compartir  este  entero  a  través  de mmap, mediante segmentos
       compartidos o usando el mismo espacio de memoria (en este  último  caso
       se dice comúnmente que la aplicación es multihilo).

SEMÁNTICA

       Cualquier  operación  futex  se  inicia  en el espacio de usuario, pero
       puede ser necesario comunicarse con el  núcleo  usando  la  llamada  al
       sistema futex(2).

       Para  ’subir’  un  futex,  ejecute  las  instrucciones  en  ensamblador
       adecuadas que harán que la CPU incremente  atómicamente  el  entero.  A
       continuación, compruebe si realmente ha cambiado de 0 a 1, en cuyo caso
       no había procesos esperando y la operación ha  terminado.  Este  es  el
       caso sin contienda, que es rápido y debe ser el más común.

       En el caso de contienda, el incremento atómico cambió el contador desde
       -1 (o algún otro  número  negativo).  Si  se  detecta,  había  procesos
       esperando.  Ahora, desde el espacio de usuario, se debe asignar un 1 al
       contador y ordenar al núcleo que despierte a cualquier proceso  que  se
       encuentre esperando, usando para ello la operación FUTEX_WAKE.

       Esperar  en  un  futex,  para  ’bajarlo’,  es  la  operación contraria.
       Reduzca atómicamente el contador y compruebe si ha  cambiado  a  0,  en
       cuyo  caso  no  hay contienda y la operación ha terminado. En cualquier
       otra circunstancia, el  proceso  debe  asignar  un  -1  al  contador  y
       solicitar  que el núcleo espere a que otro proceso suba el futex.  Esto
       se hace usando la operación FUTEX_WAIT.

       A la llamada al sistema futex(2) se le  puede  pasar  opcionalmente  un
       plazo  de tiempo que especifique cuánto tiempo debe esperar el núcleo a
       que el futex sea incrementado.  En  este  caso,  la  semántica  es  más
       compleja  y  se  remite  al  programador  a  futex(2)  para obtener más
       detalles. Lo mismo se aplica a las esperas asíncronas en futex.

OBSERVACIONES

       Insistimos, los futexes, en su forma más básica, no están pensados como
       abstracción  sencilla  para los usuarios finales. Es de esperar que los
       implementadores sean buenos conocedores  de  ensamblador  y  que  hayan
       leído  los  fuentes de la biblioteca de futex en espacio de usuario que
       se indica más abajo.

       Esta página de manual ilustra  el  uso  más  común  de  las  primitivas
       futex(2), aunque no es el único ni mucho menos.

AUTORES

       Los  futexes  fueron diseñados e implementados por Hubertus Franke (IBM
       Thomas J. Watson Research Center), Matthew Kirkwood, Ingo  Molnar  (Red
       Hat)  y  Rusty  Russell  (IBM Linux Technology Center). Esta página fue
       escrita por Bert Hubert.

VERSIONES

       El soporte inicial para futex se añadió a la  versión  2.5.7  de  Linux
       pero  con una semántica distinta a la descrita más arriba. La semántica
       actual se encuentra disponible desde la versión 2.5.40 de Linux.

VÉASE TAMBIÉN

       futex(2), ‘Fuss, Futexes and Furwocks: Fast Userlevel Locking in Linux’
       (actas  del  Ottawa  Linux  Symposium  2002),  biblioteca de ejemplo de
       futex,                                                  futex-*.tar.bz2
       <URL:ftp://ftp.kernel.org:/pub/linux/kernel/people/rusty/>.

                               31 diciembre 2002                      FUTEX(4)