Introducción
Los procesos deben comunicarse e interactuar entre ellos
compartiendo datos y recursos. Para ello UNIX pone mecanismos IPCs universales
(señales y tuberías). Asimismo, System V ofrece mecanismos de cola de mensajes,
memoria compartida y semáforos para realizar la intercomunicación entre
procesos.
En este trabajo consiste en un combate entre varios procesos
hijos que será arbitrada por el proceso padre.
El proceso inicial es el padre, que se encarga de crear n
hijos dado como argumento. Usando métodos de intercomunicación de procesos
(IPCs), se encargará de iniciar rondas de combate, eliminar los hijos que han
sido abatidos y proclamar al campeón o empate.
El proceso hijo es iniciado por el proceso padre. Al igual
que padre, este realizará la comunicación entre otros hijos y con el padre
mediante el uso de mecanismos IPC. El hijo establecerá una postura de ataque, y
atacará a otro hijo, o defensa. Al acabar la ronda, informará al proceso padre
en qué estado se encuentra.
Implementación
Para el desarrollo de este, se ha utilizado el editor de
texto Sublime Text, así como la máquina virtual de Ubuntu 16.04 LTS.
El encabezado common.h declara
la estructura del mensaje que se usara entre el proceso padre y los hijos.
También declara los métodos de inicializar, solicitar y liberar el semáforo
para el recurso compartido de la lista de PID que se usará.
El archivo de código fuente common.c
implementa los métodos inicializar, solicitar y liberar el semáforo.
El archivo Ejercicio2.sh es el punto de entrada del
ejercicio, ya que este compila tanto padre.c como hijo.c, crea un archivo FIFO,
ejecuta un cat en segundo plano al archivo FIFO y ejecuta PADRE con 10 hijos como argumento. Finalmente, elimina
todos los archivos creados.
El archivo padre.c implementa
el comportamiento de PADRE. Este inicia la llave para los
mecanismos IPC. Crea una nueva cola de mensajes, memoria compartida (para la
lista de PID de los hijos), un semáforo y una tubería sin nombre. Tras ello,
crea n hijos (siendo n pasado como argumento) e inicia una ronda escribiendo
por la tubería sin nombre n bytes (siendo n el número de hijos “vivos”). Los
hijos le envían el resultado de la ronda y el padre eliminar los que tengan
como estado “KO”. Repetirá el proceso hasta que quede uno o ningún hijo,
imprimiendo el resultado en el archivo FIFO. Finalmente, elimina todos los IPC
que ha creado.
El archivo hijo.c implementa
el comportamiento de HIJO. Este obtiene los IPC creados por el
proceso padre y espera a que este último mande la señal de inicio de ronda.
Tras ello, se pone aleatoriamente en modo ataque o defensa. Si ataca, elige un
hijo aleatorio (no a si mismo), y lo ataca enviándole la señal de usuario 1.
Tras ello, envía el mensaje de estado al proceso padre y espera una nueva
ronda.
Ejecución de ejemplo
El proceso se inicia con la llamada al script Ejercicio2.sh.
En la siguiente imagen se puede comprobar el estado de la
primera ronda, donde los hijos 2,8 y 9 han sido emboscados. Asimismo, el hijo 1
y 10 repelen un ataque.
En la ronda número dos, los hijos 2,8 y 9 ya no existen, y
cae en esta ronda el hijo 1. En la tercera ronda, caen los hijos 3 y 4. En la
cuarta, el hijo 6 es el emboscado. En la siguiente imagen se pueden ver los
resultados de las rondas 2 a 4.
Finalmente, en la siguiente imagen se muestra las últimas
tres rondas de este combate, donde el hijo 7 ha sido el ganado de la contienda.
Asimismo, se puede ver los IPCs del
sistema, donde se puede comprobar que los IPCs creados por PADRE
han sido eliminados.
Para finalizar
Este ejemplo se ha desarrollado en C para un trabajo de la asignatura de Diseño y Administración de Sistemas operativos del grado en Ingeniería Informática de la UNED.
Os dejo en el siguiente enlace el código fuente y la memoria que se ha presentado para el trabajo en cuestión.
¡Nos vemos Más allá del 0 y del 1!
Atentamente:
Carlos Caride Santeiro
Comentarios
Publicar un comentario