En los sistemas operativos de computadora , un proceso ligero ( LWP ) es un medio para lograr la multitarea . En el significado tradicional del término, como se usa en Unix System V y Solaris , un LWP se ejecuta en el espacio de usuario sobre un único hilo del kernel y comparte su espacio de direcciones y recursos del sistema con otros LWP dentro del mismo proceso . Se pueden colocar varios subprocesos a nivel de usuario , administrados por una biblioteca de subprocesos, encima de uno o varios LWP, lo que permite realizar múltiples tareas a nivel de usuario, lo que puede tener algunos beneficios de rendimiento. [1]
En algunos sistemas operativos no existe una capa LWP separada entre los hilos del kernel y los hilos del usuario. Esto significa que los subprocesos de usuario se implementan directamente sobre los subprocesos del kernel. En esos contextos, el término "proceso ligero" normalmente se refiere a subprocesos del núcleo y el término "subprocesos" puede referirse a subprocesos de usuario. [2] En Linux , los subprocesos de usuario se implementan permitiendo que ciertos procesos compartan recursos, lo que a veces lleva a que estos procesos se llamen "procesos ligeros". [3] [4] De manera similar, en la versión 4 de SunOS en adelante (antes de Solaris ), el "proceso ligero" se refería a los subprocesos del usuario. [1]
Hilos de kernel
Los subprocesos del kernel son manejados completamente por el kernel . No es necesario que estén asociados con un proceso; un kernel puede crearlos siempre que necesite realizar una tarea en particular. Los subprocesos del kernel no se pueden ejecutar en modo de usuario. Los LWP (en sistemas donde son una capa separada) se unen a los subprocesos del kernel y proporcionan un contexto a nivel de usuario. Esto incluye un enlace a los recursos compartidos del proceso al que pertenece el LWP. Cuando se suspende un LWP, necesita almacenar sus registros de nivel de usuario hasta que se reanude, y el hilo del kernel subyacente también debe almacenar sus propios registros de nivel de kernel.
Actuación
Los LWP son más lentos y más costosos de crear que los subprocesos de usuario. Siempre que se crea un LWP, primero se debe realizar una llamada al sistema para crear un hilo del kernel correspondiente, lo que provoca un cambio al modo kernel. Estos cambios de modo normalmente implican la copia de parámetros entre el kernel y el espacio de usuario, también el kernel puede necesitar pasos adicionales para verificar los parámetros y verificar un comportamiento no válido. Un cambio de contexto entre LWP significa que el LWP que está siendo reemplazado tiene que guardar sus registros, luego entrar en modo kernel para que el hilo del kernel guarde sus registros, y el LWP que se está programando debe restaurar el kernel y los registros de usuario por separado. además. [1]
Por esta razón, algunas bibliotecas de subprocesos a nivel de usuario permiten que se implementen múltiples subprocesos de usuario sobre LWP. Los subprocesos de usuario se pueden crear, destruir, sincronizar y cambiar entre ellos completamente en el espacio del usuario sin llamadas al sistema y sin cambios al modo kernel. Esto proporciona una mejora significativa del rendimiento en el tiempo de creación de subprocesos y los cambios de contexto. [1] Sin embargo, existen dificultades para implementar un programador de subprocesos a nivel de usuario que funcione bien junto con el kernel.
Activación del programador
Mientras que la biblioteca de subprocesos del usuario programará los subprocesos del usuario, el kernel programará los LWP subyacentes. Sin coordinación entre el kernel y la biblioteca de subprocesos, el kernel puede tomar decisiones de programación subóptimas. Además, es posible que se produzcan casos de interbloqueo cuando los subprocesos de usuario distribuidos en varios LWP intentan adquirir los mismos recursos que utiliza otro subproceso de usuario que no se está ejecutando actualmente. [1]
Una solución a este problema es la activación del programador. Este es un método para que el núcleo y la biblioteca de subprocesos cooperen. El kernel notifica al programador de la biblioteca de subprocesos sobre ciertos eventos (como cuando un subproceso está a punto de bloquearse) y la biblioteca de subprocesos puede tomar una decisión sobre qué acción tomar. La llamada de notificación del kernel se llama "upcall".
Una biblioteca de nivel de usuario no tiene control sobre el mecanismo subyacente, solo recibe notificaciones del kernel y programa los subprocesos de usuario en los LWP disponibles, no en los procesadores. El programador del kernel decide cómo programar los LWP en los procesadores. Esto significa que la biblioteca de subprocesos puede ver los LWP como "procesadores virtuales". [5]
Sistemas operativos compatibles
Solaris ha implementado una capa LWP separada desde la versión 2.2. Antes de la versión 9, Solaris permitía un mapeo de varios a varios entre LWP y subprocesos de usuario. Sin embargo, esto se retiró debido a las complejidades que introdujo y las mejoras de rendimiento del programador del kernel. [1] [6]
UNIX System V y sus derivados modernos IRIX , SCO OpenServer , HP-UX e IBM AIX permiten un mapeo de varios a varios entre subprocesos de usuario y LWP. [5] [7]
Implementaciones
- Extensiones paralelas (Microsoft)
- Hilos portátiles GNU
- Hilos verdes (Java)
- Hilos de grano livianos
Ver también
Referencias
- ↑ a b c d e f Vahalia, Uresh (1996). "Hilos y procesos ligeros". Componentes internos de UNIX: las nuevas fronteras . Prentice-Hall Inc. ISBN 0-13-101908-2.
- ^ "Compiladores de IBM AIX" . IBM . 2004. Archivado desde el original el 14 de julio de 2012 . Consultado el 24 de enero de 2010 .
En AIX, el término proceso ligero generalmente se refiere a un subproceso del kernel.
- ^ Bovet, Daniel P .; Cesati, Marco (2005). "3.1. Procesos, procesos ligeros e hilos". Comprensión del kernel de Linux (3ª ed.). O'Reilly Media .
- ^ Walton, Sean (1996). "Preguntas frecuentes sobre subprocesos de Linux (FAQ)" . Consultado el 24 de enero de 2010 .
- ^ a b Silberschatz; Galvin; Gagne (2004). "Capítulo 5 - Hilos". Conceptos del sistema operativo con Java (Sexta ed.). John Wiley & Sons, Inc.
- ^ "Múltiples subprocesos en el entorno operativo SolarisTM" (PDF) . Sun Microsystems . 2002 . Consultado el 24 de enero de 2010 .
- ^ "IBM AIX 6.1 - Ajuste de subprocesos" . IBM . 2009 . Consultado el 24 de enero de 2010 .
enlaces externos
- "El grupo de procesos ligeros" de Jim Mauro
- "Procesos de Solaris" por Scott Cromar
- Modelos de subprocesos (de HP-UX Process Management: White Paper)