Wiki Sistemas

Antes de comenzar con fork, repasemos un poco procesos e hilos . Dos conceptos muy parecidos y relacionados, pero con un conjunto de pequeñas diferencias.

Si queremos que nuestro programa empiece a ejecutar varias cosas “a la vez”, tenemos dos opciones. Por un lado podemos crear un nuevo proceso y por otro lado podemos crear uno o varios hilos de ejecución (threads).

En realidad una computadora, salvo que tenga varias CPU’s, no ejecutará varias tareas a la vez esto se refiere a que el sistema operativo, es este caso Linux, irá ejecutando los threads según la política del mismo, siendo lo mas usual ejecutar porciones de código de procesos alternadamente (multitarea), haciendolo tan rápido que dan la sensación de simultaneidad.

Un proceso es un concepto manejado por el sistema operativo que consiste en el conjunto formado por:

• Las instrucciones de un programa destinadas a ser ejecutadas por el procesador.

• Su estado de ejecución en un momento dado, esto es, los valores de los registros de la CPU para dicho programa.

• Su memoria de trabajo, es decir, la memoria que ha reservado y sus contenidos.

• Otra información que permite al sistema operativo su planificación.

• etc

En Linux, que como todos sabemos es multitarea (sistema operativo multithread), se pueden estar ejecutando distintas acciones a la vez, y cada acción es un proceso que consta de uno o más hilos, memoria de trabajo compartida por todos los hilos e información de planificación. Cada hilo consta de instrucciones y estado de ejecución.

Cuando ejecutamos un comando en el shell, sus instrucciones se copian en memoria RAM (¡repasar ciclo de instrucción visto en orga!) del sistema para ser ejecutadas. Cuando las instrucciones se ejecutaron en su totalidad, el proceso es borrado de la memoria del sistema, dejándola libre para que más programas se puedan ejecutar a la vez.

Los procesos son creados y destruidos por el sistema operativo. El mecanismo por el cual un proceso crea otro proceso se denomina bifurcación (fork). Los nuevos procesos son independientes y no comparten memoria (es decir, información) con el proceso que los ha creado.

En definitiva, es posible crear tanto hilos como procesos. La diferencia estriba en que un proceso solamente puede crear hilos para sí mismo y en que dichos hilos comparten toda la memoria reservada para el proceso.

Los hilos son similares a los procesos ya que ambos representan una secuencia simple de instrucciones ejecutada en “paralelo” con otras secuencias. Los hilos son una forma de dividir un programa en dos o más tareas que corren simultáneamente, compitiendo, en algunos casos, por la CPU.

La diferencia más significativa entre los procesos y los hilos, es que los primeros son típicamente independientes, llevan bastante información de estados, e interactúan sólo a través de mecanismos de comunicación dados por el sistema.

Por otra parte, los hilos generalmente comparten la memoria, es decir, acceden a las mismas variables globales o dinámicas, por lo que no necesitan costosos mecanismos de comunicación para sincronizarse (IPC )). Por ejemplo un hilo podría encarguese de la interfaz gráfica (iconos, botones, ventanas), mientras que otro hace una larga operación internamente. De esta manera el programa responde más ágilmente a la interacción con el usuario.

En sistemas operativos que proveen facilidades para el uso de hilos, es más rápido cambiar de un hilo a otro dentro del mismo proceso, que cambiar de un proceso a otro (recordar qué es Context switch). Es posible que los hilos requieran de operaciones atómicas para impedir que los datos comunes sean cambiados o leídos mientras estén siendo modificados. El descuido de esto puede generar “estancamiento” mmm… me suena a algo que ya vimos .

La tabla de abajo resume algunas diferencias entre procesos e hilos,

A la hora de crear procesos linux provee de dos funciones para dicho cometido, la función clone() y la función fork(). Ambas crean un nuevo proceso a partir del proceso padre pero de una manera distinta.

Cuando utilizamos la llamada al sistema con fork(), el proceso hijo creado es una copia exacta del padre (salvo por el PID y la memoria que ocupa). Al proceso hijo se le facilita una copia de las variables del proceso padre y de los descriptores de archivo. Es importante destacar que las variables del proceso hijo son una copia de las del padre (no se refieren físicamente a la misma variable), por lo que modificar una variable en uno de los procesos no se refleja en el otro.

La llamada al sistema clone es mucho más genérica y flexible que el fork, ya que nos permite definir qué van a compartir los procesos padre e hijo.

Las llamadas al sistema fork y clone tienen la misma funcionalidad, pero distintas características:

Fork: En el momento de la llamada a fork el proceso hijo:

• Es una copia exacta del padre excepto el PID.
• Tiene las mismas variables y archivos abiertos.
• Las variables son independientes (padre e hijo tienen distintas memorias).
• Los archivos son compartidos (heredan el descriptor).

Clone: Permite especificar qué queremos que compartan padre e hijo.

• Espacio de direccionamiento
• Información de control del sistema de archivos (file system)
• Descriptores de archivos abiertos.
• Gestores de señales o PID.

En la tabla podemos ver cómo trabajan las llamadas a fork y clone. A la derecha, en vertical, se muestra una representación de la memoria. Tanto al hacer un fork como un clone en su modalidad por defecto (se puede cambiar el comportamiento de clone con una serie de flags), el proceso padre se copia en la zona de memoria del proceso hijo.

En el fork() el hijo creado obtiene una copia de todos los campos del task_struct del padre y su propio identificador. En el clone el hijo en principio dispondrá de exactamente los mismos campos del task_struct del padre y sólo realizará una copia de estos en caso de modificar alguno de ellos. Si esto ocurre debe asignarsele al hijo su propio PID. recomiendo leer libro: El lenguaje de programación C Brian Kernighan - Dennis Ritchie)