El proceso ligero ( en inglés light-weight process , LWP) es un medio para lograr la multitarea en un sistema operativo de computadora en el sentido tradicional del término. En Unix System V y Solaris , un proceso liviano se ejecuta en el espacio del usuario sobre un solo hilo de ejecución del kernel , compartiendo el espacio de direcciones virtuales y los recursos del sistema de hilos con otros procesos livianos dentro del mismo proceso. Múltiples subprocesos a nivel de usuario administrados por la biblioteca de subprocesos se pueden alojar en uno o más procesos livianos, lo que permite la multitarea a nivel de usuario, lo que puede tener algunos beneficios de rendimiento [1] .
Algunos sistemas operativos no tienen una capa separada de procesos ligeros entre los subprocesos del kernel y los subprocesos del usuario. Esto significa que los hilos del usuario son implementados directamente por los hilos del núcleo. En tales casos, el término "proceso ligero" generalmente significa un subproceso del kernel, y el término "subproceso" puede significar un subproceso de usuario. En el kernel de Linux , los subprocesos de usuario se implementan para permitir que ciertos procesos compartan recursos, lo que a veces permite que se aplique el término "procesos ligeros" a estos subprocesos [2] . De manera similar, en la versión 4 de SunOS (el predecesor de Solaris ), los subprocesos de usuario se denominaban procesos ligeros [1] .
Los subprocesos del kernel se manejan completamente en el kernel. No tienen que estar asociados con un proceso, el kernel puede crearlos cuando sea necesario para realizar una tarea en particular. Los subprocesos del kernel no pueden ejecutarse en modo de usuario. Los procesos livianos (en sistemas donde son una capa separada) se asocian con subprocesos del kernel y brindan contexto a nivel de usuario. Esto incluye una referencia a los recursos compartidos del proceso al que pertenece el proceso ligero. Cuando se suspende un proceso ligero, el contenido de los registros de nivel de usuario debe almacenarse hasta que se reanude, y el subproceso del kernel principal también debe almacenar sus propios registros de nivel de kernel.
[ aclarar ]
Crear un proceso ligero es más costoso y lleva más tiempo que un subproceso de usuario. Cuando se crea un proceso ligero , primero se realiza una llamada al sistema para crear el subproceso del kernel adecuado.[ aclarar ] , es decir, se realiza un cambio a modo kernel. Estos cambios de modo generalmente involucran la copia de parámetros entre el kernel y el espacio del usuario, y el kernel generalmente toma medidas adicionales para verificar que los parámetros sean correctos. Un cambio de contexto entre procesos ligeros requiere un guardado preventivo de registros, luego una transición al modo kernel, donde luego guarda los registros de subprocesos del kernel, y después de realizar toda la programación necesaria del proceso ligero, los valores de registro correspondientes se restauran en modo kernel y en modo usuario. [una]
Debido a esto, algunas bibliotecas de nivel de usuario se implementan para crear varios subprocesos de nivel de usuario además de un proceso ligero. Los subprocesos de usuario se pueden crear, destruir, sincronizar y cambiar entre sí completamente en el espacio del usuario sin necesidad de llamadas al sistema o transiciones de modo kernel. Esto proporciona una mejora significativa del rendimiento durante la creación de subprocesos y los cambios de contexto. [1] Sin embargo, existen dificultades para implementar un planificador de subprocesos a nivel de usuario que funcione bien con el núcleo.
Mientras que la biblioteca de usuario está ocupada programando subprocesos de usuario, el kernel está ocupado programando procesos ligeros subyacentes. Sin coordinación entre el kernel y la biblioteca de transmisión, el kernel puede tomar decisiones de programación subóptimas. También puede conducir a un [Bloqueo|Bloqueo] en el que los subprocesos de usuario distribuidos en varios procesos ligeros intentan adquirir los mismos recursos que utiliza otro subproceso de usuario que no se está ejecutando actualmente. [una]
Una solución a este problema es habilitar el planificador. Este es un método para coordinar el núcleo y la biblioteca de subprocesos. El núcleo notifica al programador de la biblioteca de subprocesos de ciertos eventos (como cuando un subproceso está programado para bloquearse) y la biblioteca de subprocesos puede decidir qué hacer. Esta llamada de notificación del kernel se llama "upcall".
La biblioteca de nivel de usuario no tiene control sobre el mecanismo de nivel superior, solo recibe notificaciones del núcleo y programa los subprocesos de subprocesos de usuario en los procesos ligeros existentes, no en los procesadores. El programador del kernel decide cómo programar procesos ligeros en los procesadores. Esto significa que los procesos ligeros se representan en la biblioteca de subprocesos como "procesadores virtuales" [3] .
Solaris ha implementado una capa de proceso ligera separada desde la versión 2.2. Antes de la versión 9, Solaris proporcionaba una proporción de muchos a muchos de procesos ligeros a subprocesos de usuario. Sin embargo, esto ha quedado obsoleto debido a la complejidad que causaba, lo que también mejora el rendimiento del programador del kernel [1] .
UNIX System V y sus derivados modernos, como IRIX , SCO OpenServer , HP-UX e IBM AIX , proporcionan asignaciones de muchos a muchos entre subprocesos de usuario y procesos ligeros [3] [4] .