En los sistemas operativos de computadora , un proceso liviano ( LWP ) es un medio para lograr la multitarea . En el significado tradicional del término, tal como se usa en Unix System V y Solaris , un LWP se ejecuta en el espacio del usuario sobre un único subproceso 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 subprocesos del kernel y los subprocesos del usuario. Esto significa que los subprocesos del 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 "hilos" 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 denominen "procesos livianos". [3] [4] De manera similar, en la versión 4 de SunOS en adelante (antes de Solaris ), el "proceso liviano" se refería a los subprocesos del usuario. [1]
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 vinculan 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 a nivel de usuario hasta que se reanude, y el subproceso del núcleo subyacente también debe almacenar sus propios registros a nivel de núcleo.
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 de kernel correspondiente, lo que provoca un cambio al modo de kernel. Estos cambios de modo normalmente implicarían copiar parámetros entre el kernel y el espacio del usuario; además, es posible que el kernel necesite realizar pasos adicionales para verificar los parámetros y comprobar si hay comportamientos no válidos. Un cambio de contexto entre LWP significa que el LWP que se está reemplazando tiene que guardar sus registros, luego entrar en modo kernel para que el subproceso del kernel guarde sus registros, y el LWP que se está programando debe restaurar los registros del kernel y del usuario por separado. también. [1]
Por este motivo, algunas bibliotecas de subprocesos a nivel de usuario permiten implementar múltiples subprocesos de usuario sobre los LWP. Los subprocesos de usuario se pueden crear, destruir, sincronizar y alternar completamente en el espacio del usuario sin llamadas al sistema ni cambios al modo kernel. Esto proporciona una mejora significativa del rendimiento en el tiempo de creación de subprocesos y 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.
Mientras que la biblioteca de subprocesos de usuario programará los subprocesos de usuario, el kernel programará los LWP subyacentes. Sin coordinación entre el núcleo y la biblioteca de subprocesos, el núcleo puede tomar decisiones de programación subóptimas. Además, es posible que se produzcan casos de interbloqueo cuando 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 cooperen el kernel y la biblioteca de subprocesos. 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 desde el kernel se llama "llamada ascendente".
Una biblioteca a nivel de usuario no tiene control sobre el mecanismo subyacente, solo recibe notificaciones del kernel y programa subprocesos de usuario en los LWP disponibles, no en los procesadores. Luego, el programador del núcleo decide cómo programar los LWP en los procesadores. Esto significa que la biblioteca de subprocesos puede ver los LWP como "procesadores virtuales". [5]
Solaris ha implementado una capa LWP independiente desde la versión 2.2. Antes de la versión 9, Solaris permitía un mapeo de muchos a muchos entre LWP y subprocesos de usuario. Sin embargo, esto se eliminó debido a las complejidades que introdujo y a las mejoras de rendimiento en el programador del kernel. [ dieciséis]
UNIX System V y sus derivados modernos IRIX , SCO OpenServer , HP-UX e IBM AIX permiten un mapeo de muchos a muchos entre subprocesos de usuario y LWP. [5] [7]
NetBSD 5.0 introdujo un nuevo modelo de subprocesamiento 1:1 escalable. Cada subproceso de usuario (pthread) tiene un subproceso del núcleo llamado proceso liviano (LWP). Dentro del kernel, tanto los procesos como los subprocesos se implementan como LWP y el programador los atiende de la misma manera. [8]
En AIX, el término proceso ligero normalmente se refiere a un subproceso del núcleo.