SISTEMAS OPERATIVOS I
Práctica 2: Gestión de procesos
Objetivo
Manejar herramientas básicas de creación y terminación de procesos, y comprensión de la compartición
de memoria entre procesos padre e hijo.
Información útil para la práctica
Busca información sobre las variables de entorno y su visualización en un proceso con la función
getenv.
Busca información sobre las llamadas al sistema getpid, getppid, getuid, geteuid y getgid.
Las variables que se utilicen como pid de un proceso deben de nirse como tipo pid_t, en caso
contrario la compilación generará un warning. En todo caso, su utilización en el programa es
como un entero.
Recuerda que fork crea un proceso que es exactamente igual al proceso padre salvo en su PID
y en el valor devuelto por dicha función. El proceso hijo se crea literalmente como una copia
del proceso padre, incluyendo su espacio de direcciones y el contenido de los registros, pero
no comparten su espacio de memoria. Ten en cuenta que ambos procesos compiten por los
dispositivos de entrada y salida: el teclado y la consola.
La terminación de los procesos se debe hacer con la llamada al sistema exit.
Se recomienda usar el comando ps desde un terminal adicional para comprobar la presencia de
todos los procesos que se crean y su estado. Para mantener a los procesos activos mientras se
usa el comando ps, se recomienda utilizar llamadas a la función sleep o bien a scanf o getchar
para mantener a los procesos esperando el tiempo necesario.
Con la llamada al sistema wait no es posible especi car el hijo concreto por el que espera el
padre. La alternativa para ello es usar waitpid. Recuerda que para que el padre salga del wait,
el hijo debe estar en estado zombie.
Enunciado
1. Haz un programa para crear un proceso hijo usando la función de POSIX fork, y que ofrezca
información identi cativa tanto del proceso padre como del proceso hijo utilizando las llamadas
al sistema getpid, getppid, getuid, geteuid, getgid y getenv.
2. En el programa anterior, incluir comprobaciones de que las direcciones de memoria de las
variables (globales, locales y dinámicas) del padre y del hijo son las mismas virtualmente, pero
que son realmente variables físicamente diferentes (los valores de las variables son distintos).
Comprueba el valor de la posición de memoria (puntero) que ocupan. Puedes considerar una
determinada posición de memoria comprobando que inicialmente tiene el mismo contenido para
los dos procesos, pero que si uno de ellos lo modi ca, el otro proceso mantiene su valor (el original)
porque realmente la variable es diferente aunque se llame igual y el puntero que la direcciona
tenga el mismo valor.
3. Incluye una llamada a scanf para comprobar que los dos procesos compiten por el acceso al
dispositivo de entrada.
4. En el programa anterior comprueba que si el padre abre un chero antes de ejecutar el fork,
ese chero está también abierto y es compartido por el hijo. El programa que incluye todo lo
indicado hasta ahora constituye el ENTREGABLE 1.
5. Haz otro programa que genere dos procesos hijos, uno de ellos debe alcanzar el estado zombie
pronto. El padre, pasado un tiempo, debe ejecutar un wait y acabar. Para identi car al hijo
que hace que el padre salga de la función wait, recoge el parámetro del exit del proceso hijo y
muéstralo en el terminal (para ello hay que usar la macro WEXITSTATUS). El segundo hijo
debe permanecer activo durante un tiempo más largo, quedando huérfano. Comprueba con el
comando ps lo que pasa con los tres procesos a lo largo del tiempo.
6. Al nal del código del segundo de los procesos hijo, cambia su imagen con una llamada a alguna
de las funciones del grupo (execl, execv, execle, execve, execlp, execvp ) para que ejecute otro
código seguida de un printf que muestre un texto en la consola. Comprueba si se muestra dicho
texto en la consola. El ENTREGABLE 2 es el programa que incluye lo pedido en estos dos
últimos apartados.
7. Comprueba con ps lo que sucede con un proceso zombie cuando su padre acaba la ejecución sin
ejecutar el wait.
8. Visualiza el vídeo sobre la medición de tiempos de ejecución usando gettimeofday o clock_gettime.
9. Haz un programa para calcular de dos maneras la media en doble precisión de las tangentes
de las raíces cuadradas de los primeros N números naturales (considerándo que dichos números
son ángulos en radianes).
Por un lado, el cálculo se debe hacer usando P procesos hijo trabajando al mismo tiempo.
Cada proceso hijo realiza el cálculo para un bloque de N/P números. Además el último de ellos
también hará el cálculo para el posible resto N %P . Cada uno de ellos debe mostrar su resultado
en la consola y posteriormente copiarlo en un chero auxiliar compartido. Debe haber una forma
de identi car en el propio chero quien escribe cada resultado. Los valores de N y P deben ser
argumentos de la línea comando (argv ) del programa. Cuando acaben los P hijos otro hijo
adicional, el P + 1 debe calcular el resultado en base a las P contribuciones, leyéndolas del chero
auxiliar, y añadiendo el resultado nal obtenido en ese mismo chero.
Por otro lado, y paralelamente a todos los anteriores, un nuevo hijo, el P + 2, debe realizar el
cálculo completo para los N números, y también almacenar el resultado en el chero auxiliar.
Todos los P +2 procesos hijo deben además escribir los tiempos de ejecución de sus cálculos
en el mismo chero compartido. Finalmente, cuando todos acaben, el padre debe calcular y
mostrar la diferencia entre los resultados calculados de las dos formas (es decir, los obtenidos por
los hijos P +1 y P + 2) y mostrar en consola los tiempos de ejecución de todos y cada uno de
los hijos. Este código constituye el ENTREGABLE 3.
