TALLER No.

2
PROCESOS EN LINUX (2ª Parte)

Descripción:
El trabajo consta de una sección teórica y otra práctica de programación. Se deben conformar
grupos de trabajo de tres estudiantes. Pueden constituirlos inter-cursos.

Componentes calificables:
No deben entregar informe escrito, solo los programas y los videos, quienes se inscriban en ellos. El
marco teórico lo deberían estudiar todos como base para resolver los programas, pero un solo grupo
lo sustentará en un video. No hay que entregar informe escrito sobre este.
Los entregables de programación comprenden los programas descritos utilizando como base el
marco teórico. No deben entregar informe. Solo los ocho grupos que los seleccionen, los
presentarán en video, además.

Informe Oral – Sustentación en Video

Items Guía

Duración No mayor a 12 minutos.

Contenido Los programas: deben explicar su ejecución y presentar los resultados,

según entregables.

Reglas de No se aceptan fotos o imágenes de las pruebas.

presentación Todos los integrantes deben exponer.

Criterios de Orden y coherencia en la presentación, Presentación de slides,

revisión Expresión de ideas, Desarrollo de ejercicios prácticos, Ortografía y
Redacción, Tiempo de sustentación.

Evaluación La sustentación será evaluada por el profesor.

Selección de Los grupos que expondrán tendrán que inscribirse en el link Libro 2.xlsx
grupos (hoja 2). hasta agotar los videos dispuestos.

Reglas Generales
Items Guía

Sistema Linux Ubuntu

Operativo a
utilizar

Fechas de Informe escrito, videos y programas: Noviembre 3

entrega

Formato de Un archivo llamado Apellido1-Apellido2-Apellido3.zip, el cual

Entrega contendrá:
 -Archivo Apellido1-Apellido2-Apellido3.docx (Allí deben estar los
nombres de los integrantes y su curso).
-Archivos con programas de acuerdo con la regla en cada enunciado.
-Archivo video.txt con el enlace donde se pueda observar éste.

Marco teórico
Sin Video
1. Función wait()
2. Función waitpid()
3. Argumento status
3.1. Macros para revisión de status
3.2. WIFEXITED(*status)
3.3. WEXITSTATUS(*status)
4. Función exit()

Programas:

Video 1
1. Escribir un programa usando wait() y exit() llamado parimpar.c que reciba como parámetros
los números enteros inf, sup, stop. Donde inf, y sup corresponden a los límites del rango [inf,
sup] y stop es un número entero entre los límites. Un proceso padre debe crear un proceso
hijo. El padre debe generar los números pares en el rango y el hijo los impares en el mismo
rango. No importa que no se generen en la misma secuencia ordenada. Cada proceso debe
imprimir en pantalla los números generados. Cuando el proceso padre llegue al número par
n menor o igual que stop (inf < n ≤ stop), debe detenerse y esperar a que el hijo genere e
imprima sus números impares. Luego, el proceso padre puede continuar la generación e
impresión de números de n+2 en adelante. Cada listado de números impresos debe estar
encabezado por el nombre del proceso que lo ejecuta y su pid. El proceso hijo debe devolver
el último valor impreso más 100 en el status y el padre debe mostrarlo al retomar su
impresión. Debe verificar el paso de parámetros hasta que se cumpla que inf < stop < sup, de
lo contrario no se puede seguir con la ejecución.

Entrada:
./parimpar 11 30 18

Salida posible:
Proceso padre y pid 48670
12
14
16
18
Proceso hijo y pid 48671
11
13
15
17
19
21
23
25
27
29
Hijo terminado y valor status 129
20
22
24
26
28
30

Entregable: Programa parimpar.c

Video 2
2. Escribir un programa llamado suma.c que use wait(), sleep() y exit(), donde el padre genere
una cantidad de n hijos (n debe ser pasado como parámetro). El padre debe mostrar al
ejecutar su segmento de código su pid, el pidC retornado por el fork() que corresponde al
pid del hijo, y el número de iteración. Cada hijo debe mostrar en la terminal su pid y un
número entero entre inf y sup generado aleatoriamente. Los parámetros inf y sup se
comportan y deben ser validados como en el programa anterior. El número aleatorio debe
ser pasado al padre, quien debe mostrar su pid, el pid del hijo y el número entero generado
aleatoriamente. Es importante que cada proceso duerma (sleep) el número aleatorio de
segundos generado para mostrar el retraso de los procesos. Al final debe mostrar la
sumatoria de los n números aleatorios entre inf y sup generados por cada proceso. Observe
el orden en que se muestra la creación de los procesos, el orden en que se ejecutan
teniendo en cuenta la cantidad de segundos que duermen y el orden en que terminan en
el wait del padre.

Entrada:
./suma 4 10 20 (Nota: Genera 4 procesos, y números aleatorios entre 10 y 20)

Salida posible:
Entrada padre 115963, al crear HIJO 115964, iter 0
Entrada padre 115963, al crear HIJO 115965, iter 1
Entrada padre 115963, al crear HIJO 115966, iter 2
Entrada padre 115963, al crear HIJO 115967, iter 3
Hijo: PID = 115965, valor aleatorio calculado 19
Hijo: PID = 115966, valor aleatorio calculado 11
Hijo: PID = 115967, valor aleatorio calculado 13
Hijo: PID = 115964, valor aleatorio calculado 15
PADRE de PID = 115963, HIJO de PID = 115966 terminado, st = 11
PADRE de PID = 115963, HIJO de PID = 115967 terminado, st = 13
PADRE de PID = 115963, HIJO de PID = 115964 terminado, st = 15
PADRE de PID = 115963, HIJO de PID = 115965 terminado, st = 19
La suma es 58

Entregable: Programa suma.c

Video 3
3. Modificar el programa anterior y llamarlo sumapid.c de tal forma que los números enteros
aleatorios generados en cada hijo y pasados al padre sean mostrados en orden de procesos
hijos creados y luego se obtenga la suma. Use waitpid(), sleep() y exit() Observe el orden en
que se muestra la creación de los procesos, el orden en que se ejecutan teniendo en
cuenta la cantidad de segundos que duermen y el orden en que terminan en el waitpid del
padre.

Entrada:
./sumapid 4 10 20 (Nota: Genera 4 procesos, y números aleatorios entre 10 y 20)

Salida posible:
Entrada padre 116088, al crear HIJO 116089, iter 0
Entrada padre 116088, al crear HIJO 116090, iter 1
Entrada padre 116088, al crear HIJO 116091, iter 2
Entrada padre 116088, al crear HIJO 116092, iter 3
Hijo: PID = 116090, valor aleatorio calculado 15
Hijo: PID = 116091, valor aleatorio calculado 16
Hijo: PID = 116092, valor aleatorio calculado 12
Hijo: PID = 116089, valor aleatorio calculado 17
PADRE de PID = 116088, HIJO de PID = 116089 terminado, st = 17
PADRE de PID = 116088, HIJO de PID = 116090 terminado, st = 15
PADRE de PID = 116088, HIJO de PID = 116091 terminado, st = 16
PADRE de PID = 116088, HIJO de PID = 116092 terminado, st = 12
La suma es 60

Entregable: Programa sumapid.c

Video 4
4. Escribir un programa llamado sumaprim.c donde el proceso padre genere n hijos (n pasado
como parámetro). En un bucle que comprende de 0 a n-1 se generan los hijos; a su vez,
cada hijo debe producir una secuencia de números primos, siendo el primer primo de la
secuencia el que corresponda según la iteración + 1. Cada proceso debe generar hasta el
primo 2*(iteración + 1). Estos números primos se deben imprimir en la terminal con un
encabezado que indique el número del proceso hijo que corresponda y su iteración. Los
números primos generados por cada hijo se sumarán y este será el valor que cada uno debe
devolver al padre. El padre debe mostrar la suma de salida de los hijos en el orden en que se
ejecutaron con su respectivo pid.

Entrada:
./sumaprim 4
Salida posible:
Listado de primos impresos para proceso 49361, iteración 1
Proceso 49361, primo 3
Proceso 49361, primo 5
Proceso 49361, primo 7
Listado de primos impresos para proceso 49362, iteración 2
Proceso 49362, primo 5
Proceso 49362, primo 7
Proceso 49362, primo 11
Proceso 49363, primo 13
Listado de primos impresos para proceso 49363, iteración 3
Proceso 49363, primo 7
Proceso 49363, primo 11
Proceso 49363, primo 13
Proceso 49363, primo 17
Proceso 49363, primo 19
Listado de primos impresos para proceso 49360, iteración 0
Proceso 49360, primo 2
Proceso 49360, primo 3
Hijo 49360 terminó con suma: 5
Hijo 49361 terminó con suma: 15
Hijo 49362 terminó con suma: 36
Hijo 49363 terminó con suma: 67

Entregable: Programa sumaprim.c