Práctica 3.

Creación y manipulación de procesos

Arquitectura de Computadores 4o GIT -

Práctica 3. Creación y manipulación de procesos 2

Esta práctica se compone de dos partes, cada una a realizar en una sesión. La memoria
final debe de incluir la evaluación de las dos partes. Se puede utilizar este documento para el envio de
la memoria.
1. Creación de procesos en Linux

Ob jetivos Con este apartado de la practica se pretende:

1. Que el alumno asimile el concepto de estado de los procesos y su estructura jerárquica

en Linux.
2. Que el alumno adquiriera la capacidad de crear procesos padre.
3. Ser capaz de implementar hijos infinitos, que provocaran que el padre espere hasta su
finalización indefinidamente.

Requisitos Es conveniente la lectura del documento llasis_procesos

Tareas a realizar El alumno deberá de compilar los programas 1 y 2 correctamente y crear dos
ejecutables, llamados procesos-1 y procesos-2. Para crear los ejecutables se debe utilizar la
herramienta Make. Es conveniente crear una carpeta para cada uno de los ejecutables, e
incluir en cada una de las carpetas, el fichero makefile correspondiente.
Evaluación Una vez compilados sin errores los dos programas, el alumno los ejecutará, observará la
ejecución de los mismos y escribirá sus impresiones en la memoria de la práctica, en la que
hay que incluir también los dos ficheros makefile realizados.
Duración 1 sesión

Arquitectura de Computadores 4o GIT

Práctica 3. Creación y manipulación de procesos 3

Programa 1 Programa que contiene el código correspondiente a dos procesos, padre e hijo. El
primero de ellos creará al segundo para a continuación hacer que éste quede en estado zombie.
Para lograr este propósito se persigue que este segundo proceso únicamente muestre un mensaje por
pantalla.
#i n c l u d e < s t d i o . h>
#i n c l u d e < s t d l i b . h>
#i n c l u d e < s y s / t y p e s . h>
#i n c l u d e < u n i s t d . h>
#i n c l u d e < s y s / w a i t . h>

i n t m ain ( v o i d ) {
int pidHijo , esta do ;

i f ( ( p i d H i j o = f o r k ( ) ) != 0 ) {
/ / PADRE
p r i n t f ( ” \ n P r o c e s o h i j o c r e a d o ( PID=\ %d ) . \ n ” , p i d H i j o ) ;
p r i n t f ( ” \ nP adre , b u c l e i n f i n i t o . \ n” ) ;
s l e e p ( 1 2 0 ) ; / ∗ No p a s a d e a q uı́ ( h a s t a p a s a d o un t i e m p o ) ∗/
w h i l e ( w a i t (& e s t a d o ) != p i d H i j o ) ;
p r i n t f ( ” \ nFin d e l pa dre . \ n” ) ;
e xit ( 0 ) ;
} else {
/ / HIJO
p r i n t f ( ” \ n I n i c i o de h i j o f i n i t o . \ n” ) ;
p r i n t f ( ” \ nF in de h i j o f i n i t o . \ n” ) ;
e xit ( 0 ) ;
}
}

Programa 2 Utilizando el código fuente del programa 1, se reescriben de nuevo ambos procesos,
’invirtiendo’ su comportamiento, de manera que el proceso padre simplemente creará al otro proceso,
mostrando un mensaje que indique que éste ha sido correctamente creado, y quedará en espera de
que éste acabe. El proceso hijo, será un proceso largo (120s), evitando ası́ la conclusión del proceso
padre hasta que éste termine.
#i n c l u d e < s t d i o . h>
#i n c l u d e < s t d l i b . h>
#i n c l u d e < s y s / t y p e s . h>
#i n c l u d e < u n i s t d . h>
#i n c l u d e < s y s / w a i t . h>

i n t m ain ( v o i d ) {
i n t p i d H i j o =0 , e s t a d o = 0 ;

i f ( ( p i d H i j o = f o r k ( ) ) != 0 ) {
/ / PADRE
p r i n t f ( ” \ nP roceso h i j o crea d o . \ n” ) ;
p r i n t f ( ” \ n I n i c i o d e l P adre . \ n” ) ;
w h i l e ( w a i t ( & e s t a d o ) != p i d H i j o ) ;
p r i n t f ( ” \ nFin d e l pa dre . \ n” ) ;
e xit ( 0) ;
} else {
/ / HIJO
p r i n t f ( ” \ n h i j o en b u c l e i n f i n i t o . \ n” ) ;
s l e e p ( 1 2 0 ) ; / ∗ No p a s a d e a q uı́ ( h a s t a p a s a d o un t i e m p o ) ∗/
p r i n t f ( ” \ nF in de h i j o . \ n” ) ;
e xit ( 0 ) ;
}
}

Arquitectura de Computadores 4o GIT

Práctica 3. Creación y manipulación de procesos 4

2. Manipulación de procesos a nivel de usuario

Ob jetivos Con este apartado de la practica se pretende:

1. Que el alumno observe el comportamiento de los procesos en Linux.
2. Que el alumno conozca algunos de los comandos Linux relacionados con procesos.
Requisitos Es conveniente la lectura del documento llasis2007 procesos
Tareas a realizar Realizar las tareas y escribir el resultado en el espacio en blanco
Evaluación El alumno realizará el informe de esta parte de la práctica con las anotaciones de las
diferentes tareas.
Duración 1 sesión

Arquitectura de Computadores 4o GIT

Práctica 3. Creación y manipulación de procesos 5

Tarea 1 Hacer uso de man para obtener ayuda sobre los comandos ps y kill.
Comando ps
—————————————————————————————————
—————————————————————————————————
—————————————————————————————————
—————————————————————————————————
—————————————————————————————————
Comando Kill
—————————————————————————————————
—————————————————————————————————
—————————————————————————————————
—————————————————————————————————
—————————————————————————————————
—————————————————————————————————
—————————————————————————————————
Tarea 2 Tomando como referencia los programas 1 y 2 del apartado anterior, probar su lanza-
miento en background o segundo plano, ($comando &) siguiendo el orden descrito a continuación.
Una vez lanzados, visualizar los procesos existentes en el sistema mediante el comando ps, tratando
a continuación de eliminar alguno de ellos mediante el comando kill.

Arquitectura de Computadores 4o GIT

Práctica 3. Creación y manipulación de procesos 6

Tarea 3 Lanzar el código correspondiente a un proceso padre finito que crea un proceso hijo in-
finito (programa 2), de manera que el proceso padre quedará esperando indefinidamente el fin del
hijo. Anotar el resultado de eliminar mediante el comando kill el proceso hijo.

Tarea 4 Ejecutar el código correspondiente al padre infinito que crea un proceso hijo finito (progra-
ma 1), de manera que según se dijo anteriormente, este ultimo quedará en estado zombie. Observar
si realmente se produce esta circunstancia.

Tarea 5 Tratar de eliminar el proceso hijo - proceso zombie - anotando los resultados percibidos.

Tarea 6 Eliminar, en este mismo ejemplo, el proceso padre, tomando nota de los resultados que
se obtengan.

Arquitectura de Computadores 4o GIT