qwertyuiopasdfghjklzxcvbnmqwerty

uiopasdfghjklzxcvbnmqwertyuiopasd
fghjklzxcvbnmqwertyuiopasdfghjklzx
cvbnmqwertyuiopasdfghjklzxcvbnmq
Tuberias
wertyuiopasdfghjklzxcvbnmqwertyui
Tuberías

opasdfghjklzxcvbnmqwertyuiopasdfg
11/03/2008

IVAN DURANGO BLANCO

hjklzxcvbnmqwertyuiopasdfghjklzxc
vbnmqwertyuiopasdfghjklzxcvbnmq
wertyuiopasdfghjklzxcvbnmqwertyui
opasdfghjklzxcvbnmqwertyuiopasdfg
hjklzxcvbnmqwertyuiopasdfghjklzxc
vbnmqwertyuiopasdfghjklzxcvbnmq
wertyuiopasdfghjklzxcvbnmqwertyui
opasdfghjklzxcvbnmqwertyuiopasdfg
hjklzxcvbnmrtyuiopasdfghjklzxcvbn
mqwertyuiopasdfghjklzxcvbnmqwert
yuiopasdfghjklzxcvbnmqwertyuiopas
 Tuberias

Análisis del Problema

En la siguiente práctica se nos propone realizar una aplicación mediante tuberías o pipes
que nos permita calcular el factorial de un número en multiproceso.
Para ello pasaremos al programa, desde la línea de comandos, el número a calcular y el
número de procesos “hijos” en los que vamos a realizar dicho calculo. Cada uno de los
procesos hijo procesara un cálculo diferente de los demás y devolverá el total al padre,
el cual uniendo todos los resultados de los hijos mostrará el resultado total.

Algoritmo a seguir para la Resolución

Tras el estudio de todas las posibilidades para la resolución de la práctica, decido
resolverla de la siguiente forma:

En la aplicación el padre será el encargado de crear el número de procesos hijo y el

número de tuberías requeridas (tantas como hijos). En la misma creación del proceso
hijo este adquirirá el numero con el que toca hacer el cálculo siendo este número *
numero -1 con lo que el padre pasará al hijo el número preciso.

Tras esto cada hijo calculará su parte y retornará al padre dicho cálculo mediante la
tubería asignada.

Por último el padre une todos los cálculos de los hijos y calcula el total.

Variables utilizadas
pid=1: Con esta variable recogemos el pid de los procesos hijos que vamos creando en
el Fork(). Después nos sirve al final del programa para controlar los hijos que van
terminando.

Status: Con la variable status, recogemos la terminacion del programa hijo.

n: Nos sirve para recoger el argumento pasado por la línea de comandos al programa,
concretamente el argumento correspondiente al número de factorial.

nprocesos: Nos sirve para recoger el argumento pasado por la línea de comandos al
programa, concretamente el argumento correspondiente al número de procesos hijos
para calcular el factorial.

Iván Durango Blanco

 Tuberias

tot=0: En esta variable guardamos el total calculado por los procesos hijos. Esta
variable es la que se mandará posteriormente por la tubería de hijo a padre y este último
va calculando el total con todas las recibidas.
totp=1: Variable que guarda el total del factorial.

numero: Nos sirve para realizar una copia de “n” y luego llevar un contador en el
proceso padre, para controlar la terminación de los hijos.

tuberia[10][2]: Array para creación de Tuberías.

Código fuente comentado

#include <sys/types.h>
#include <sys/wait.h>
#include <unistd.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>

main (int argc, char *argv[]){

int i,pid=1,status,n,nprocesos,tot=0,re,totp=1;
int numero;
int tuberia[10][2];
//10 es lo maximo

if (argc < 3){

printf ("Error en el modo de uso\n");
printf ("Forma de uso: ./factorial n nprocecos\n");
exit (1);
}

n = atoi(argv[1]);
nprocesos = atoi (argv[2]);
/*guardo los argumentos pasados por la línea de comandos y los transformo a número*/

//paso los dos argumentos a numero

printf ("Numero de procesos a crear %i \n",nprocesos);

if (n >10 || nprocesos > 10){

printf ("El factorial y el numero de procesos no puede ser > a 10\n");
exit (1);
}

for (i=0; i != nprocesos; i++) {

pipe(tuberia[i]);
/*creación de librerías*/
}
//creo tantas tuberias como procesos

numero = n;

n+=2;
//n va marcando a cada hijo los multiplos a calcular por los hijos

Iván Durango Blanco

 Tuberias

for (i=0;i != nprocesos && pid != 0;i++,n-=2){

pid=fork();
}
//creo los procesos

switch (pid){
case -1: perror ("Error al creas proceso\n");
exit(1);
case 0:
if (i == nprocesos){
//sucede cuando no hay mas procesos
close(tuberia[i][0]);
//cierro la tuberia que no voy a usar
int to,num=0;
num = n;
to = n * n-1;
n-=2;

for (;n > 0; n--){

tot = to * n;
to = tot;
}
write (tuberia[i][1],&tot,sizeof(int));
printf ("-->El proceso hijo con PID, %i calculó el producto de los
numeros \n",getpid());
for (; num > 0; num--)
printf (" , %i ",num);
printf ("y retornó es valor %i\n",tot);
write (tuberia[i][1],&tot,sizeof(int));
}else{
int tot=0;
close (tuberia[i][0]);
tot = n * n-1;
printf ("El proceso hijo con PID, %i calculó el producto de los numeros
%i,%i y retornó es valor %i\n\n",getpid(),n,n-1,tot);
write (tuberia[i][1],&tot,sizeof(int));
close(tuberia[i][1]);
}
default:

for (i=0;i != nprocesos && pid != 0;i++,n-=2){

pid=wait (&status);

close (tuberia[i][1]);
read (tuberia[i][0],&tot,sizeof(int));
totp = totp * tot;
printf ("Hijo con PID, %i calculó el producto de los numeros %i,%i y
retornó el valor %i\n", pid,numero,numero-1,tot);
close (tuberia[i][0]);
numero-=2;
}
}
printf ("Resultado total del factorial: %i\n",totp);
return 0;
}

Iván Durango Blanco