En los sistemas operativos de computadoras , 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 de usuario sobre un solo hilo del núcleo y comparte su espacio de direcciones y recursos del sistema con otros LWP dentro del mismo proceso . Múltiples hilos de nivel de usuario , administrados por una biblioteca de hilos, se pueden colocar sobre uno o varios LWP, lo que permite que la multitarea se realice 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 núcleo y los subprocesos del usuario. Esto significa que los subprocesos del usuario se implementan directamente sobre los subprocesos del núcleo. En esos contextos, el término "proceso liviano" generalmente se refiere a los subprocesos del núcleo y el término "subprocesos" puede referirse a los subprocesos del usuario. [2] En Linux , los subprocesos del 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 ), "proceso liviano" se refería a los subprocesos del usuario. [1]
Los subprocesos del núcleo son manejados completamente por el núcleo . No necesitan estar asociados con un proceso; un núcleo puede crearlos cuando necesite realizar una tarea en particular. Los subprocesos del núcleo no se pueden ejecutar en modo de usuario. Los LWP (en sistemas donde son una capa separada) se vinculan a los subprocesos del núcleo y proporcionan un contexto de 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 subproceso del núcleo subyacente también debe almacenar sus propios registros de 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 subproceso de kernel correspondiente, lo que provoca un cambio al modo kernel. Estos cambios de modo normalmente implicarían copiar parámetros entre el kernel y el espacio de usuario; también es posible que el kernel deba realizar pasos adicionales para verificar los parámetros y comprobar si hay un comportamiento no válido. Un cambio de contexto entre LWP significa que el LWP que se está interrumpiendo tiene que guardar sus registros, luego pasar al modo kernel para que el subproceso de kernel guarde sus registros, y el LWP que se está programando también debe restaurar los registros de kernel y de usuario por separado. [1]
Por este motivo, algunas bibliotecas de subprocesos a nivel de usuario permiten implementar múltiples subprocesos de usuario sobre LWP. Los subprocesos de usuario se pueden crear, destruir, sincronizar y cambiar entre ellos completamente en el espacio de 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 núcleo 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 bloqueo 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 en ese momento. [1]
Una solución a este problema es la activación del planificador. Este es un método para que el núcleo y la biblioteca de subprocesos cooperen. El núcleo notifica al planificador 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 núcleo se denomina "upcall".
Una biblioteca de nivel de usuario no tiene control sobre el mecanismo subyacente, solo recibe notificaciones del núcleo y programa los subprocesos de usuario en los LWP disponibles, no en los procesadores. El programador del núcleo decide entonces 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 una asignación de varios a varios entre LWP y subprocesos de usuario. Sin embargo, esta función se eliminó debido a las complejidades que introducía y a las mejoras de rendimiento del planificador del núcleo. [1] [6]
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 subprocesos escalable 1:1. Cada subproceso de usuario (pthread) tiene un subproceso de núcleo llamado proceso liviano (LWP). Dentro del núcleo, tanto los procesos como los subprocesos se implementan como LWP y el planificador los atiende de la misma manera. [8]
En AIX, el término proceso liviano generalmente se refiere a un subproceso del núcleo.