www.es-minix.org

[efutch]

El documento descriptivo del Laboratorio #1 - Corriendo con fork() s está disponible aquí.

La fecha de entrega de este laboratorio es el lunes 11 de febrero de 2008, a las 11:59PM. Sus respuestas deberán estar colocadas como respuestas a este tópico.

Respuestas posteadas después de la fecha indicada no serán aceptadas.

[rscollins]

CORRIDA FORK () SIMPLE
Esta linea es de pid 71, valor = 1, valor de x es 16838
Esta linea es de pid 71, valor = 2, valor de x es 5758
Esta linea es de pid 71, valor = 3, valor de x es 10113
Esta linea es de pid 71, valor = 4, valor de x es 17515
Esta linea es de pid 71, valor = 5, valor de x es 31051
Esta linea es de pid 71, valor = 6, valor de x es 5627
Esta linea es de pid 71, valor = 7, valor de x es 23010
Esta linea es de pid 71, valor = 8, valor de x es 7419
Esta linea es de pid 71, valor = 9, valor de x es 16212
Esta linea es de pid 71, valor = 10, valor de x es 4086
Esta linea es de pid 70, valor = 1, valor de x es 16838
Esta linea es de pid 70, valor = 2, valor de x es 5758
Esta linea es de pid 70, valor = 3, valor de x es 10113
Esta linea es de pid 70, valor = 4, valor de x es 17515
Esta linea es de pid 70, valor = 5, valor de x es 31051
Esta linea es de pid 70, valor = 6, valor de x es 5627
Esta linea es de pid 70, valor = 7, valor de x es 23010
Esta linea es de pid 70, valor = 8, valor de x es 7419
Esta linea es de pid 70, valor = 9, valor de x es 16212
Esta linea es de pid 70, valor = 10, valor de x es 4086

Explique porque si el valor de “x” en el proceso padre es igual o distinto al del proceso hijo.
R/=El valor de “x” es igual ya que en ambos procesos, padre e hijo, se van haciendo las mismas asignaciones a los procesos y ejecutan un random que al ejecutarlo varias veces genera los mismo números para ambos procesos.

¿Existe alguna forma de predecir los ID del proceso que serán asignados al proceso hijo y alproceso padre? Explique porqué si o porqué no.
R=/Si es posible, ya que el sistema operativo asigna ID de procesos correlativos, así que el ID del proceso nuevo será el siguiente del último proceso es decir (el ID del padre + 1), creado sin importar si este todavía se está ejecutando o no.

FORK() NO TAN SIMPLE

Revise el siguiente programa antes de correrlo y responda: ¿Cuántos procesos se van a crear?
/* Programa mas_o_menos */
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <stdlib.h>
#include <time.h>
#define MAX_COUNT 2
#define BUF_SIZE 120
void main(void)
{
pid_t pid;
int i;
int x=0;
char buf[BUF_SIZE];
fork();
fork();
fork();
pid = getpid();
for (i = 1; i <= MAX_COUNT; i++) {
x= rand();
sprintf(buf, "Esta linea es de pid %d, valor = %d, valor de x es %d\n", pid, i, x);
write(1, buf, strlen(buf));
}
}

R/= Para mi se crearian 6 procesos.

CORRIDA DE FORK() NO TAN SIMPLE
Esta linea es de pid 101, valor = 1, valor de x es 16838
Esta linea es de pid 101, valor = 2, valor de x es 5758
Esta linea es de pid 100, valor = 1, valor de x es 16838
Esta linea es de pid 100, valor = 2, valor de x es 5758
Esta linea es de pid 102, valor = 1, valor de x es 16838
Esta linea es de pid 102, valor = 2, valor de x es 5758
Esta linea es de pid 99, valor = 1, valor de x es 16838
Esta linea es de pid 99, valor = 2, valor de x es 5758
Esta linea es de pid 104, valor = 1, valor de x es 16838
Esta linea es de pid 104, valor = 2, valor de x es 5758
Esta linea es de pid 103, valor = 1, valor de x es 16838
Esta linea es de pid 103, valor = 2, valor de x es 5758
Esta linea es de pid 105, valor = 1, valor de x es 16838
Esta linea es de pid 105, valor = 2, valor de x es 5758
Esta linea es de pid 98, valor = 1, valor de x es 16838
Esta linea es de pid 98, valor = 2, valor de x es 5758

Compile el programa y ahora indique cuántos procesos se crearon. ¿Es igual a su respuestaanterior? Si no es, ¿por qué?[b]
R/=Se crearon 8 procesos ya que yo creia que se creaban 2 procesos por fork, pero se crean 2 procesos mas, ya que los hijos se vuelven padres y asi crean otros procesos mas.

[b]Modifique el programa para se creen tres copias únicamente
R/=
#include <stdio.h>

#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <stdlib.h>
#include <time.h>
#define MAX_COUNT 2
#define BUF_SIZE 120

void main(void)
{
pid_t pid;
int i;
int x=0;
char buf[BUF_SIZE];

if (fork() != 0){

fork();
}
pid = getpid();
for (i = 1; i <= MAX_COUNT; i++){
x = rand();
sprintf(buf, "Esta linea es pid %d, valor = %d, valor de x es %d\n", pid, i,x);
write(1,buf,strlen(buf));
}
}

Esta linea es pid 136, valor = 1, valor de x es 16838
Esta linea es pid 136, valor = 2, valor de x es 5758
Esta linea es pid 137, valor = 1, valor de x es 16838
Esta linea es pid 137, valor = 2, valor de x es 5758
Esta linea es pid 135, valor = 1, valor de x es 16838
Esta linea es pid 135, valor = 2, valor de x es 5758

FORK() MAS COMPLICADO

Explique el funcionamiento del programa “bueno”.
R/= Se tienen dos procesos creados luego de ejecutar el fork(), el proceso padre e hijo, los cuales respectivamente llaman el procedimiento "ParentProcess()" y "ChildProcess()" con la ayuda de la condicion if (pid = = 0) que indica que proceso es hijo. Estos se turnan mientras uno de ellos duerme. El procedimiento "ParentProcess()" incrementa el numero de asteriscos, mientras que el procedimiento "ChildProcess()" lo hace en decremento.

CORRIDA DE FORK() MAS COMPLICADO

p-**
p-***
p-****
p-*****
p-*
p-**
p-***
p-****
p-*****
p-*
p-**
p-***
p-****
p-*****
p-*
p-**
p-***
p-****
p-*****
p-*
*** Fin del Padre ***
h-*
h-*****
h-****
h-***
h-**
h-*
h-*****
h-****
h-***
h-**
h-*
h-*****
h-****
h-***
h-**
h-*
h-*****
h-****
h-***
h-**
*** Fin proceso hijo ***
Explique la salida que obtuvo del programa “bueno”, ¿qué muestra?[b]
R/=Se muestra la ejecución concurrente de ambos procesos, se imprime el proceso que se está ejecutando y las estrellas indican el número de segundos menos uno que este proceso se dormirá. Es interesante ver que cuando corre cada proceso se realiza la impresion en pantalla y se observa cuando corre cada uno de ellos (padre e hijo).

[b]Explique si después de ejecutar el programa “gnarls” 20 veces, considera que el manejo del procesador es justo o injusto.
R/= El manejo del procesador es justo ya que generalmente termina uno tras el otro proceso, al final no es mucha la diferencia de tiempo en que termina cada proceso.

[sosacelina]

1) Fork() simple

/* Programa muy_facil */
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <stdlib.h>
#include <time.h>
#define MAX_COUNT 10
#define BUF_SIZE 120
void main(void)
{
pid_t pid;
int i;
int x=0;
char buf[BUF_SIZE];
fork();
pid = getpid();
for (i = 1; i <= MAX_COUNT; i++) {
x= rand();
sprintf(buf, "Esta linea es de pid %d, valor = %d, valor de x es %d\n", pid, i, x);
write(1, buf, strlen(buf));
}
}



a) Explique porque si el valor de “x” en el proceso padre es igual o distinto al del proceso hijo.
R:/ el valor de x es igual por que el random se ejecuta al mismo tiempo en el proceso padre como en el proceso hijos

b) ¿Existe alguna forma de predecir los ID del proceso que serán asignados al proceso hijo y al Proceso padre? Explique porqué si o porqué no.
R:/ no se puede predecir el ID que se le asignara al proceso padre y al proceso hijo ya que estos se generan de manera aleatoria con la función random


2) Fork() no tan simple

Revise el siguiente programa antes de correrlo y responda: ¿Cuántos procesos se van a crear?
R:/ se crearan seis procesos

/* Programa mas_o_menos */
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <stdlib.h>
#include <time.h>
#define MAX_COUNT 2
#define BUF_SIZE 120
void main(void)
{
pid_t pid;
int i;
int x=0;
char buf[BUF_SIZE];
fork();
fork();
fork();
pid = getpid();
for (i = 1; i <= MAX_COUNT; i++) {
x= rand();
sprintf(buf, "Esta linea es de pid %d, valor = %d, valor de x es %d\n", pid, i, x);
write(1, buf, strlen(buf));
}
}



a) Compile el programa y ahora indique cuántos procesos se crearon. ¿Es igual a su respuesta anterior? Si no es, ¿por qué?
R:/ se crearon 8 procesos.
• Es diferente a mi respuesta anterior
• Por que con cada fork() se genera 2^n procesos por ejemplo si hay un 1 fork() es 2^1, si son dos fork() es 2^2 procesos y si es tres fork() como en el programa seria 2^3 procesos

b) Modifique el programa para se creen tres copias únicamente.

#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include<stdlib.h>
#include<time.h>
#define MAX_COUNT 2
#define BUF_SIZE 120

void main(void)
{
pid_t pid;
int i;
int x=0;
char buf[BUF_SIZE];
int bandera= fork
If(bandera)
{
fork();
}
pid = getpid();
for (i = 1; i <= MAX_COUNT; i++) {
x= rand();
sprintf(buf, "Esta linea es de pid %d, valor = %d, valor de x es %d\n", pid, i, x);
write(1, buf, strlen(buf));

}
}



3) Fork() más complicado
/* programa bueno */
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#define MAX_COUNT 20
char *barras[5] = { "*","**","***","****","*****" };
void ChildProcess(void);
void ParentProcess(void
void main(void)
{
pid_t pid;
pid = fork();
if (pid == 0)
ChildProcess();
else
ParentProcess();
}
void ChildProcess(void)
{
int i;
for (i = MAX_COUNT; i > 0 ; i--)
{
printf("\t\th-%s\n",barras[i % 5]);
sleep(i % 5);
}
printf(" *** Fin proceso hijo ***\n");
}
void ParentProcess(void)
{
int i,h;
for (i = 1; i <= MAX_COUNT; i++)
{
printf("\tp-%s\n",barras[i % 5]);
sleep(i % 5);
}
printf("*** Fin del Padre ***\n");
}






a) Explique el funcionamiento del programa “bueno”.
R:/si la condición del pid es igual a 0 el proceso padre entra en un estado dormido ya que el proceso hijo será el que se ejecute. Luego cuando el procesos hijo termina de ser ejecutado entra en estado de dormido y el proceso padre comienza a ejecutarse hasta que termina su ejecución

b) Explique la salida que obtuvo del programa “bueno”, ¿qué muestra?
R:/ muestra las veces en que el proceso padre y el proceso hijo son ejecutados

c) Explique si después de ejecutar el programa “gnarls” 20 veces, considera que el manejo del procesador es justo o injusto.
R:/ es justo ya que los dos procesos pueden ejecutarse sin ningún problema ya que mientras el procesos hijo se esta ejecutando el proceso padre entra en un estado de dormido. Cuando el proceso hijo finaliza este entra a el estado dormido para que el proceso padre comience a ejecutarse

[JULIO ORDOÑEZ]

1) Fork() Simple:

Salida fork() simple:
Esta linea es del proceso hijo pid 54, valor = 1, valor de x es 16838
Esta linea es del proceso hijo pid 54, valor = 2, valor de x es 5758
Esta linea es del proceso hijo pid 54, valor = 3, valor de x es 10113
Esta linea es del proceso hijo pid 54, valor = 4, valor de x es 17515
Esta linea es del proceso hijo pid 54, valor = 5, valor de x es 31051
Esta linea es del proceso hijo pid 54, valor = 6, valor de x es 5627
Esta linea es del proceso hijo pid 54, valor = 7, valor de x es 23010
Esta linea es del proceso hijo pid 54, valor = 8, valor de x es 7419
Esta linea es del proceso hijo pid 54, valor = 9, valor de x es 16212
Esta linea es del proceso hijo pid 54, valor = 10, valor de x es 4086
Esta linea es del proceso padre pid 53, valor = 1, valor de x es 16838
Esta linea es del proceso padre pid 53, valor = 2, valor de x es 5758
Esta linea es del proceso padre pid 53, valor = 3, valor de x es 10113
Esta linea es del proceso padre pid 53, valor = 4, valor de x es 17515
Esta linea es del proceso padre pid 53, valor = 5, valor de x es 31051
Esta linea es del proceso padre pid 53, valor = 6, valor de x es 5627
Esta linea es del proceso padre pid 53, valor = 7, valor de x es 23010
Esta linea es del proceso padre pid 53, valor = 8, valor de x es 7419
Esta linea es del proceso padre pid 53, valor = 9, valor de x es 16212
Esta linea es del proceso padre pid 53, valor = 10, valor de x es 4086

Explique por qué el valor de "x" en el proceso padre es igual o distinto al del proceso hijo.

El valor que se le da a X es igual en ambos debido a que ese valor solo cambiara cada vez que se llame al RAND().
¿Es posible predecir los ID del proceso que serán asignados al proceso hijo y al proceso padre? Explique por qué si o por qué no.

No podría ser posible por la misma funcion de rand() debido a que genera numeros al azar.


2) Fork() no tan simple:

Revise el siguiente programa antes de correrlo y responda: ¿Cuántos procesos se van a crear?

Se crearan 6 procesos ya que los hijos se convierten en padres y sucesivamente.

Compile el programa y ahora indique cuántos procesos se crearon. ¿Es igual a su respuesta anterior? Si no es, ¿por qué?.

Salida Fork() no tan simple:
Esta linea es de pid 397, valor = 1, valor de x es 16838
Esta linea es de pid 397, valor = 2, valor de x es 5758
Esta linea es de pid 396, valor = 1, valor de x es 16838
Esta linea es de pid 396, valor = 2, valor de x es 5758
Esta linea es de pid 398, valor = 1, valor de x es 16838
Esta linea es de pid 398, valor = 2, valor de x es 5758
Esta linea es de pid 395, valor = 1, valor de x es 16838
Esta linea es de pid 395, valor = 2, valor de x es 5758
Esta linea es de pid 400, valor = 1, valor de x es 16838
Esta linea es de pid 400, valor = 2, valor de x es 5758
Esta linea es de pid 399, valor = 1, valor de x es 16838
Esta linea es de pid 399, valor = 2, valor de x es 5758
Esta linea es de pid 401, valor = 1, valor de x es 16838
Esta linea es de pid 401, valor = 2, valor de x es 5758
Esta linea es de pid 394, valor = 1, valor de x es 16838
Esta linea es de pid 394, valor = 2, valor de x es 5758

Si es igual a mi respuesta.

Modifique el programa para se creen tres copias únicamente.
/* Programa bien_facil */

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



void main(void)
{
pid_t pid;
int i;
int x=0;


char buf[BUF_SIZE];
int flag = fork();
if (flag) {
fork();
/*fork();*/
}
pid = getpid();
for (i = 1; i <= MAX_COUNT; i++) {
x= rand();
sprintf(buf, "Esta linea es de pid %d, valor = %d, valor de x es %d\n", pid, i, x);
write(1, buf, strlen(buf));

}
}
Salida del programa anterior:
Código
Esta linea es de pid 417, valor = 1, valor de x es 16838
Esta linea es de pid 417, valor = 2, valor de x es 5758
Esta linea es de pid 418, valor = 1, valor de x es 16838
Esta linea es de pid 418, valor = 2, valor de x es 5758
Esta linea es de pid 416, valor = 1, valor de x es 16838
Esta linea es de pid 416, valor = 2, valor de x es 5758



3) Fork() más complicado:

Explique el funcionamiento del programa “Bueno”.

En el programa, tanto el proceso padre como el hijo, están en espera en varios pasos, por distintos intervalos de tiempos que dependen de la iteración del ciclo FOR en el que este. Antes de empezar a Reposar, imprimen una cadena que depende también de la iteración en la que estén. Al final cada uno anuncia que ha terminado.

Explique la salida que obtuvo del programa “Bueno”, ¿qué muestra?

Salida Bueno:
Código
p-**
p-***
p-****
p-*****
p-*
p-**
p-***
p-****
p-*****
p-*
p-**
p-***
p-****
p-*****
p-*
p-**
p-***
p-****
p-*****
p-*
*** Fin Padre ***
h-*
h-*****
h-****
h-***
h-**
h-*
h-*****
h-****
h-***
h-**
h-*
h-*****
h-****
h-***
h-**
h-*
h-*****
h-****
h-***
h-**
*** Fin hijo ***

Explique si después de ejecutar el programa “gnarls” 20 veces, considera que el manejo del procesador es justo o injusto.

[djchepe]

Fork Simple



Explique porque si el valor de “x” en el proceso padre es igual o distinto al del proceso hijo.
R:/Porque la función rand() con la cual le asignamos el valor a x, si le asigna un numero aleatorio, el problema es que como esta función trabaja con el reloj del sistema si no se inicializa este va a poner los mismos valores, que es lo que pasa, no se inicializa y tanto el padre como el hijo tienen los mismos valores.

¿Existe alguna forma de predecir los ID del proceso que serán asignados al proceso hijo y al proceso padre? Explique porque si o porque no.
R:/No porque el número del proceso se genera aleatoriamente, así que no se puede saber su ID.


Fork más o menos simple




Revise el siguiente programa sin correrlo y responda: ¿Cuántos procesos se van a crear?
R:/Si con cada fork cada proceso se copia y hay 3 forks esto nos daría un total de 6.

¿Es igual a su respuesta anterior? Si no es, ¿por qué?
R:/No fue igual, al parecer el programa empieza creando un proceso y desde ahí en es se empiezan a crear los demás procesos.

Modifique el programa para que se creen solamente 3 procesos.
R:/Si se le quita un fork se crearían tres.



Fork complicado



Explique el funcionamiento del programa “gnarls”.
R:/La diferencia de este programa a los otros es que los procesos padre e hijo se llaman por separado, entonces estos nunca se ejecutan al mismo tiempo. Y en este el proceso padre espera a que el proceso hijo termine.

Explique la salida que obtuvo del programa “gnarls”, ¿qué muestra?
R:/Muestra los turnos de los procesos padre e hijo.

Explique si después de ejecutar el programa “gnarls” 20 veces, considera que el manejo del procesador es justo o injusto.
R:/El manejador de procesos parece justo ya que se mira que le sede suficientes turnos tanto a padre como a hijo para que terminen su trabajo.
_________________
La muerte está tan segura de su victoria que nos da toda una vida de ventaja.

[10511122 Luis Flores]

FORK SIMPLE

Explique por qué el valor de "x" en el proceso padre es igual o distinto al del proceso hijo.

El valor de "x" es igual en ambos procesos durante la misma iteración del ciclo "for" por la función rand(). Esta función devuelve un número "pseudo-random", es decir, que no es exactamente al azar. El número es calculado por alguna fórmula en base a un número seed (semilla), el cual tiene un valor inicial predeterminado y cambia cada vez que se llama a rand(). Si el seed no se cambia antes de la llamada a rand() el programa siempre devuelve los mismos numeros "random". Como el hijo es una copia del padre, con sus propios datos, y el seed no se cambia previo a la llamada de rand(), ambos calculan los mismos números "random".

¿Es posible predecir los ID del proceso que serán asignados al proceso hijo y al proceso padre? Explique por qué si o por qué no.

Sí es posible. Para hacerlo llamamos a la aplicación "ps" para que nos muestre los procesos activos, y miramos el PID de "ps". Asumiendo que inmediatamente después llamemos a nuestra aplicación de Fork() simple, el proceso padre tendrá un PID igual al PID de ps más 1 (si el PID de ps era 20, el de nuestro programa será 21), y el proceso hijo tendrá un PID igual al PID del padre más 1.
[img][/img][/url]

FORK MAS O MENOS

R: SE CREARIAN SEIS


[img][/img][url]

Compile el programa y ahora indique cuántos procesos se crearon. ¿Es igual a su respuestaanterior? Si no es, ¿por qué?[b]
R/=Se crearon 8 procesos, ya que los hijos se vuelven padres y asi crean otros procesos mas.

Modifique el programa para se creen tres copias únicamente
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <stdlib.h>
#include <time.h>
#define MAX_COUNT 2
#define BUF_SIZE 120

void main(void)
{
pid_t pid;
int i;
int x=0;
char buf[BUF_SIZE];

if (fork() != 0){
fork();
}
pid = getpid();
for (i = 1; i <= MAX_COUNT; i++){
x = rand();
sprintf(buf, "Esta linea es pid %d, valor = %d, valor de x es %d\n", pid, i,x);
write(1,buf,strlen(buf));
}
}

Esta linea es pid 136, valor = 1, valor de x es 16838
Esta linea es pid 136, valor = 2, valor de x es 5758
Esta linea es pid 137, valor = 1, valor de x es 16838
Esta linea es pid 137, valor = 2, valor de x es 5758
Esta linea es pid 135, valor = 1, valor de x es 16838
Esta linea es pid 135, valor = 2, valor de x es 5758

[/url]

FORK COMPLICADO

p-**
p-***
p-****
p-*****
p-*
p-**
p-***
p-****
p-*****
p-*
p-**
p-***
p-****
p-*****
p-*
p-**
p-***
p-****
p-*****
p-*
*** Fin del Padre ***
h-*
h-*****
h-****
h-***
h-**
h-*
h-*****
h-****
h-***
h-**
h-*
h-*****
h-****
h-***
h-**
h-*
h-*****
h-****
h-***
h-**
*** Fin proceso hijo ***


a) Explique el funcionamiento del programa “bueno”.
R:/si la condición del pid es igual a 0 el proceso padre entra en un estado dormido ya que el proceso hijo será el que se ejecute. Luego cuando el procesos hijo termina de ser ejecutado entra en estado de dormido y el proceso padre comienza a ejecutarse hasta que termina su ejecución

b) Explique la salida que obtuvo del programa “bueno”, ¿qué muestra?
R:/ muestra las veces en que el proceso padre y el proceso hijo son ejecutados

c) Explique si después de ejecutar el programa “gnarls” 20 veces, considera que el manejo del procesador es justo o injusto.
R:/ es justo ya que los dos procesos pueden ejecutarse sin ningún problema ya que mientras el procesos hijo se esta ejecutando el proceso padre entra en un estado de dormido. Cuando el proceso hijo finaliza este entra a el estado dormido para que el proceso padre comience a ejecutarse

[JavierMontoya]

1) FORK() SIMPLE
a) Explique por qué el valor de “x” en el proceso padre es igual o distinto al del proceso hijo.

La variable x generada por la función Rand() tiene el mismo valor en el proceso padre y el proceso hijo. Según la documentación de la función Rand(), esta función guarda la información de estado en espacio de memoria reservado por la función en una base por procesos. (en este caso la semilla, la cual sobrevive a multiples invocaciones de la función). La implementación de la función Rand() no es reentrante si la implementación falla al sincronizar las invocaciones de la función y entonces se protege la información de estado. El problema es que cuando la información de estado no se protege, invocaciones concurrentes pueden interferir con otro (por ejemplo, ver el mismo valor de la semilla).
Un efecto colateral es que la función Rand() actualiza el valor de la semilla, permitiendo la secuencia para proseguir. El valor de la semilla es sostenido en una localidad estática de la memoria reservada por la libreria. En un proceso multihilado dos o más hilos pueden invocar concurrentemente la función Rand(), leer el mismo valor de la semilla y generar el mismo valor aleatorio.

b) ¿Existe alguna forma de predecir los ID del proceso que serán asignados al proceso hijo y al proceso padre? Explique por qué si o por qué no.
Al parecer Minix asigna los ID de procesos secuencialmente. Si ejecutamos el comando PS podemos ver los procesos con su PID, al ejecutar nuestro programa el siguiente proceso obtiene un PID incrementado en una unidad.

Como se puede ver el ejemplo con tres ejecuciones consecutivas el programa:



2) FORK() NO TAN SIMPLE
Al inicio calculé mal y solamente consideré 7 procesos, pero haciendo una análisis detallado observé que en la tercera llamada al Fork() se crean 4 procesos, asi:

En la primera llamada al fork() hay dos procesos: Padre, hijo1
En la segunda llamada se crea un hijo2, un hijo1.1
En la tercera llamada se crea un hijo3, un hijo1.2, un hijo 2.1, y un hijo 1.1.1
En total se crearan 8 procesos.

a) Compile el programa y ahora indique cuántos procesos se crearon. ¿Es igual a su respuesta anterior? Si no es, ¿por qué?
El programa creó ocho procesos:



b) Primero, modifiqué el programa para que creara solamente tres hijos.



La siguiente modificación solamente crea tres procesos.




3) FORK() MAS COMPLICADO

a) Explique el funcionamiento del programa “bueno”.
En el programa se crean dos procesos, cada proceso determina si es el padre o el hijo mediante la verificación de la variable PID.

El procedimiento que ejecuta el proceso hijo ejecuta un ciclo FOR en 20 iteraciones, imprime en pantalla una cadena determinada por una función de división modular y luego el proceso duerme cierto intervalo de tiempo (también determinado por un cálculo modular).

Mientras el proceso anterior duerme, entra en ejecución el proceso padre realizando instrucciones similares, solo que el incremento de la variable de control del ciclo FOR es creciente.



b) Explique la salida que obtubo del programa “bueno”, ¿Qué muestra?
Despliega en pantalla un elemento del arreglo "barras" 20 veces en el proceso hijo y otras 20 veces en el proceso padre. El indice del elemento del arreglo a mostrar depende del valor de la variable de control.

Si mandamos la salida a un archivo no se muestra la conmutación entre los procesos:



c) Me parece que el manejo del procesador es justo al tratar de aprovechar el tiempo en que un proceso duerme.
Aunque al modificar el tiempo en que uno y otro proceso dormia (incrementar tiempo de sleep al hijo y quitar la instruccion sleep al padre) iniciaba a ejecutar el hijo, luego secuencialmente ejecutaba las iteraciones del padres y terminaba. Luego regresaba al estado de comandos $, me permitió ejecutar el vi y en plena ejecución del vi, aparecía el despliegue de las barras correspondiente al proceso hijo:


_________________
ID UNITEC: 10011077
www.javieralberto.com

La tecnología se desarrolla cuando tenemos un comprador, por eso cada día, 2.000 niños africanos mueren de malaria.

[jcardenas]

1) Fork() simple

/* Programa muy_facil */
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <stdlib.h>
#include <time.h>
#define MAX_COUNT 10
#define BUF_SIZE 120
void main(void)
{
pid_t pid;
int i;
int x=0;
char buf[BUF_SIZE];
fork();
pid = getpid();
for (i = 1; i <= MAX_COUNT; i++) {
x= rand();
sprintf(buf, "Esta linea es de pid %d, valor = %d, valor de x
es %d\n", pid, i, x);
write(1, buf, strlen(buf));
}
}



a) Explique porque si el valor de “x” en el proceso padre es igual o distinto al del proceso hijo.

R// Los valores de “x” que toman los dos procesos (padre e hijo) son iguales ya que estos dos procesos utilizan el rand(), por lo que al momento de irse generando un valor es el mismo, ya que ambos procesos pasan por la funcion rand() al mismo tiempo.


b) ¿Existe alguna forma de predecir los ID del proceso que serán asignados al proceso hijo y al proceso padre? Explique porqué si o porqué no.

R// No se puede llegar a predecir el ID de los procesos padre e hijo, ya que este ID es asignado por el sistema operativo y según pude observar el proceso hijo siempre tiende a tener un valor mas que el del padre, pero el valor del padre no se va a llegar a conocer con exactitud por la causa antes mencionada.


2) Fork() no tan simple

Revise el siguiente programa antes de correrlo y responda: ¿Cuántos procesos se van a crear?

R// Creo que se van a crear 16 procesos.
/* Programa mas_o_menos */
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <stdlib.h>
#include <time.h>
#define MAX_COUNT 2
#define BUF_SIZE 120
void main(void)
{
pid_t pid;
int i;
int x=0;
char buf[BUF_SIZE];
fork();
fork();
fork();
pid = getpid();
for (i = 1; i <= MAX_COUNT; i++) {
x= rand();
sprintf(buf, "Esta linea es de pid %d, valor = %d, valor de x
es %d\n", pid, i, x);
write(1, buf, strlen(buf));
}
}



a) Compile el programa y ahora indique cuántos procesos se crearon. ¿Es igual a su respuesta anterior? Si no es, ¿por qué?

R// Según se puede observar en la corrida del programa se crearon 8 procesos, que no fue igual a mi respuesta anterior porque yo pense que se creaban 16 procesos y no fue asi. Según comprendi primero se crea el padre, luego al ocurrir el fork se crea el hijo de este, al seguir el siguiente fork se crea un segundo hijo y un hijo del primer proceso y asi sucesivamente para el siguiente fork se va agregando un hijo al padre y un hijo para los hijos existentes.




b) Modifique el programa para se creen tres copias únicamente.

R// Fork() no tan simple

/* Programa mas o menos */

#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <stdlib.h>
#include <time.h>
#define MAX_COUNT 2
#define BUF_SIZE 120
void main(void)
{
pid_t pid;
int i;
int x=0;
char buf[BUF_SIZE];
fork();
fork();
//fork();Solamente tenemos que quitar este fork para que se creen 3 copias
pid = getpid();
for (i = 1; i < = MAX_COUNT; i++) {
x= rand();
sprintf(buf, "Esta linea es de pid %d, valor = %d, valor de x es %d\n", pid, i, x);
write(1, buf, strlen(buf));
}
}


3) Fork() más complicado

/* programa bueno */
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#define MAX_COUNT 20
char *barras[5] = { "*","**","***","****","*****" };
void ChildProcess(void); /* prototipo proceso hijo */
void ParentProcess(void); /* prototipo proceso padre */
void main(void)
{
pid_t pid;
pid = fork();
if (pid == 0)
ChildProcess();
else
ParentProcess();
}
void ChildProcess(void)
{
int i;
for (i = MAX_COUNT; i > 0 ; i--)
{
printf("\t\th-%s\n",barras[i % 5]);
sleep(i % 5);
}
printf(" *** Fin proceso hijo ***\n");
}
void ParentProcess(void)
{
int i,h;
for (i = 1; i <= MAX_COUNT; i++)
{
printf("\tp-%s\n",barras[i % 5]);
sleep(i % 5);
}
printf("*** Fin del Padre ***\n");
}



a) Explique el funcionamiento del programa “bueno”.

R// Cuando el pid sea cero se ejecuta el proceso hijo sino el padre sera el que este en funcionamiento, y asi sucesivamente si el proceso hijo esta en ejecución se duerme mientras el padre se ejecuta, ambos van casi a la par no llevan mucha diferencia.

b) Explique la salida que obtuvo del programa “bueno”, ¿qué muestra?

R// Muestra lo que va ocurriendo entre el padre y el hijo, ademas se mira como los dos van a la par. Como tambien pude observar por medio de las estrellas lo que se esta demorando el proceso.

c) Explique si después de ejecutar el programa “gnarls” 20 veces, considera que el manejo del procesador es justo o injusto.

R// Me parece que es justo porque el tiempo en que se van creando es muy parecido y no va variando mucho, creo que se les brinda a ambos el tiempo necesario para ejecutarse.

[rteruel]

1. Fork simple
a) Explique porque si el valor de “x” en el proceso padre es igual o distinto al del proceso hijo.
Estudie la página del manual de la función rand().
R: El valor de x es el mismo ya que el random se ejecuta al mismo tiempo en ambos procesos
b) ¿Existe alguna forma de predecir los ID del proceso que serán asignados al proceso hijo y al
proceso padre? Explique porqué si o porqué no.
R: no se puede predecir ya que no se puede saber cuantos procesos se están corriendo en ese momento a menos que el programa se corra mas de una vez de manera seguida asi los pid iran incrementándose de uno en uno de otra forma no es posible a menos que podamos saber cuantos procesos se están ejecutando en ese momento

[img]C:\Users\TERUEL\Documents\fork1.jpg [/img]
2. Fork no tan simple
Mi opinión es que va a crear 8 procesos

[img]C:\Users\TERUEL\Documents\fork2.jpg [/img]

a) Compile el programa y ahora indique cuántos procesos se crearon. ¿Es igual a su respuesta
anterior? Si no es, ¿por qué?
R: Si se crearon 8 procesos porque por cada fork crea dos procesos entonces con el primer fork hace 2 con el segundo fork hace 4 osea dos de cada uno de los anteriores y con el tercero crea 8 dos por cada uno de los 4 anteriores
b) Modifique el programa para se creen tres copias únicamente.
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <stdlib.h>
#include <time.h>
#define MAX_COUNT 2
#define BUF_SIZE 120

void main(void)
{
pid_t pid;
int i;
int x=0;
char buf[BUF_SIZE];
if (fork() != 0){
fork();
}
pid = getpid();
for (i = 1; i <= MAX_COUNT; i++){
x = rand();
sprintf(buf, "Esta linea es pid %d, valor = %d, valor de x es %d\n", pid, i,x);
write(1,buf,strlen(buf));
}
}

[img]C:\Users\TERUEL\Documents\fork3.jpg [/img]

3. Fork complicado

[img]C:\Users\TERUEL\Documents\fork4.jpg [/img]
[img]C:\Users\TERUEL\Documents\fork5.jpg [/img]
[img]C:\Users\TERUEL\Documents\fork6.jpg [/img]

a) Explique el funcionamiento del programa “bueno”.
En este programa se ejecutan dos procesos un proceso padre y un proceso hijo luego se llama a la función Padre o Hijo dependiendo del valor de la variable PID si se llama al proceso padre se imprime una p y una serie de otros caracteres mientras si se llama al proceso hijo se imprime una h y una serie de otros caracteres
b) Explique la salida que obtuvo del programa “bueno”, ¿qué muestra?
En la salida de este programa se muestra el numero de veces que se ejecuto el proceso padre y el proceso hijo de manera intercalada
c) Explique si después de ejecutar el programa “gnarls” 20 veces, considera que el manejo del
procesador es justo o injusto.
Me parece que si es justo ya que concede el uso del cpu masomenos con los mismos intervalos a cada proceso de manera que los procesos terminan casi al mismo tiempo

[aaer83]

FORK() SIMPLE




a) Explique porque si el valor de “x” en el proceso padre es igual o distinto al del proceso hijo.
Estudie la página del manual de la función rand().

Para este caso los valores que toman los procesos tanto los padres como los hijos son iguales porque los valores son generados por la funcion rand() y como esta no hace cambio de la semilla los valores van a ser iguales siempre sin importar el numero de ejecuciones, entonces para que los valores sean distintos se debe de cambiar la semilla de la funcion rand() en cada corrida.

b) ¿Existe alguna forma de predecir los ID del proceso que serán asignados al proceso hijo y al
proceso padre? Explique porqué si o porqué no.

Desde mi punto de vista y con lo observado durante las corridas del programa considero de que no se puede predecir porque es el sistema operativo mismo quien se encarga de asignar los ID a cada proceso que corre.


FORK() NO TAN SIMPLE

Se van a crear 6 procesos



[/b]

a) Compile el programa y ahora indique cuántos procesos se crearon. ¿Es igual a su respuesta
anterior? Si no es, ¿por qué?

No, no es igual a mi respuesta anterior, porque yo estaba considerando los 2 procesos que levanta cada uno de los fork() tanto el proceso padre como el hijo, pero la verdad no se por que se crean 8 procesos.

b) Modifique el programa para se creen tres copias únicamente


FORK() MAS COMPLICADO



a) Explique el funcionamiento del programa “bueno”.

En el programa, tanto el proceso padre como el hijo, “duermen” varias veces, por distintos intervalos de tiempos que dependen de la iteración del ciclo “for” en la que estén (i es la iteración, duermen i módulo 5 segundos). Antes de empezar a dormir, imprimen una cadena que depende también de la iteración en la que estén. Al final cada uno anuncia que ha terminado.

b) Explique la salida que obtuvo del programa “bueno”, ¿qué muestra?

La salida del programa fue el comportamiento que tuvieron los procesos padres y los procesos hijos con respecto a sus tiempos y ordenes de ejecucion, se pudo observar los intervalos en que corrieron cada uno de los procesos.

c) Explique si después de ejecutar el programa “gnarls” 20 veces,
considera que el manejo del
procesador es justo o injusto.

En terminos generales se puede considerar que el procesador es justo con los procesos ya que se les asigna o se les interrumpe los tiempos de ejecucion dependiendo de sus respectivos estados, es decir, si estan durmiendo o no, pero por otro lado tambien hay poco de ineficiencia porque hay momentos en que ambos procesos pueden estar dormidos.

[MARTINEZBAYRON]

/* Programa mas_o_menos */
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <stdlib.h>
#include <time.h>
#define MAX_COUNT 2
#define BUF_SIZE 120
void main(void)
{
pid_t pid;
int i;
int x=0;
char buf[BUF_SIZE];
fork();
fork();
fork();
pid = getpid();
for (i = 1; i <= MAX_COUNT; i++) {
x= rand();
sprintf(buf, "Esta linea es de pid %d, valor = %d, valor de x
es %d\n", pid, i, x);
write(1, buf, strlen(buf));
}
}
a) Compile el programa y ahora indique cuántos procesos se crearon. ¿Es igual a su respuesta
anterior? Si no es, ¿por qué?
R. X es igual por que el random se ejecuta al mismo tiempo en el proceso padre como en el proceso hijos

b) ¿Existe alguna forma de predecir los ID del proceso que serán asignados al proceso hijo y al Proceso padre? Explique porqué si o porqué no.

R. El sistema operativo asigna ID de procesos correlativos, así que el ID del proceso nuevo será el siguiente del último proceso es decir (el ID del padre + 1), creado sin importar si este todavía se está ejecutando o no;

2) Fork() no tan simple

/* Programa mas_o_menos */
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <stdlib.h>
#include <time.h>
#define MAX_COUNT 2
#define BUF_SIZE 120
void main(void)
{
pid_t pid;
int i;
int x=0;
char buf[BUF_SIZE];
fork();
fork();
fork();
pid = getpid();
for (i = 1; i <= MAX_COUNT; i++) {
x= rand();
sprintf(buf, "Esta linea es de pid %d, valor = %d, valor de x es %d\n", pid, i, x);
write(1, buf, strlen(buf));
}
}

2) Fork() no tan simple:

Revise el siguiente programa antes de correrlo y responda: ¿Cuántos procesos se van a crear?

R. Se crearan 6 procesos ya que los hijos se convierten en padres y sucesivamente.

Compile el programa y ahora indique cuántos procesos se crearon. ¿Es igual a su respuesta anterior? Si no es, ¿por qué?.

Salida Fork() no tan simple:
Esta linea es de pid 397, valor = 1, valor de x es 16812
Esta linea es de pid 397, valor = 2, valor de x es 5732
Esta linea es de pid 396, valor = 1, valor de x es 16812
Esta linea es de pid 396, valor = 2, valor de x es 57312
Esta linea es de pid 398, valor = 1, valor de x es 16832
Esta linea es de pid 398, valor = 2, valor de x es 5712
Esta linea es de pid 395, valor = 1, valor de x es 16832
Esta linea es de pid 395, valor = 2, valor de x es 5712
Esta linea es de pid 400, valor = 1, valor de x es 16832
Esta linea es de pid 400, valor = 2, valor de x es 5712
Esta linea es de pid 399, valor = 1, valor de x es 16832
Esta linea es de pid 399, valor = 2, valor de x es 5712
Esta linea es de pid 401, valor = 1, valor de x es 16832
Esta linea es de pid 401, valor = 2, valor de x es 5712
Esta linea es de pid 394, valor = 1, valor de x es 16832
Esta linea es de pid 394, valor = 2, valor de x es 5712

R. Igual que mi resultado

Modifique el programa para se creen tres copias únicamente.
/* Programa bien_facil */

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



void main(void)
{
pid_t pid;
int i;
int x=0;


char buf[BUF_SIZE];
int flag = fork();
if (flag) {
fork();
/*fork();*/
}
pid = getpid();
for (i = 1; i <= MAX_COUNT; i++) {
x= rand();
sprintf(buf, "Esta linea es de pid %d, valor = %d, valor de x es %d\n", pid, i, x);
write(1, buf, strlen(buf));

}
}
Salida del programa anterior:
Código
Esta linea es de pid 401, valor = 1, valor de x es 16812
Esta linea es de pid 401, valor = 2, valor de x es 5732
Esta linea es de pid 407, valor = 1, valor de x es 16812
Esta linea es de pid 407, valor = 2, valor de x es 5732
Esta linea es de pid 403, valor = 1, valor de x es 16812
Esta linea es de pid 403, valor = 2, valor de x es 5732


R. Si es posible.

3) Fork() más complicado

p-**
p-***
p-****
p-*****
p-*
p-**
p-***
p-****
p-*****
p-*
p-**
p-***
p-****
p-*****
p-*
p-**
p-***
p-****
p-*****
p-*
*** Fin del Padre ***
h-*
h-*****
h-****
h-***
h-**
h-*
h-*****
h-****
h-***
h-**
h-*
h-*****
h-****
h-***
h-**
h-*
h-*****
h-****
h-***
h-**
*** Fin proceso hijo ***
Explique el funcionamiento del programa “gnarls”.
R:/El proceso padre, e hijo se llaman por separado, entonces estos nunca se ejecutan al mismo tiempo. Este proceso padre espera que el proceso hijo terminne.

b) Explique la salida que obtuvo del programa “bueno”, ¿qué muestra?

R. Se puede observar como ambos se comportan similar. El indicador grafico nos muestra como se va demorando el proceso.

c) Explique si después de ejecutar el programa “gnarls” 20 veces, considera que el manejo del procesador es justo o injusto.
R:/ La ejeucion de ambos procesos se desarrolan sin ningun problema ya que mientras el procesos hijo se esta ejecutando el proceso padre entra en un estado de dormido. Cuando el proceso hijo finaliza este entra a el estado dormido para que el proceso padre comiencede nuevo su ejecucion

[Mario Henriquez]

/* Programa muy_facil */
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <stdlib.h>
#include <time.h>
#define MAX_COUNT 10
#define BUF_SIZE 120
void main(void)
{
pid_t pid;
int i;
int x=0;
char buf[BUF_SIZE];
fork();
pid = getpid();
for (i = 1; i <= MAX_COUNT; i++) {
x= rand();
sprintf(buf, "Esta linea es de pid %d, valor = %d, valor de x
es %d\n", pid, i, x);
write(1, buf, strlen(buf));
}
}

a) Explique porque si el valor de “x” en el proceso padre es igual o distinto al del proceso hijo.


R:// El valor de la variable "X" en el proceso padre es igual a la del proceso hijo debido a que ambos procesos ejecutan al mismo tiempo la funcion rand() esto quiere decir que la funcion rand() no esta actualizando al valor de la variable porque al momento de la nueva invocacion puede causar un error esto indica que los valores ya contenidos en la variable x quedan intactos.


b) ¿Existe alguna forma de predecir los ID del proceso que serán asignados al proceso hijo y al
proceso padre? Explique porqué si o porqué no.

R:// si existe una manera de saber cual es el ID que recibe el hijo creado de un fork debido a que los procesos creados en un sistema operativo unix son asignados con nuevo PID (Process ID) incrementado un valor mayor al que tiene el padre para poder observar los ID de los procesos levantados en linux podemos usar la sentencia TOP que muestra los procesos en ejecucion en ese momento con su cantidad de espacio en memoria y el ID de cada uno

puede haber circunstacias en las que el proceso creado aumente mas de una unidad al momento de que se cree debido a que el sistema antes de crear dicha instancia del programa pueda haber ingresado un nuevo proceso con el identificador del proceso aumentado en 1


/* Programa mas_o_menos */
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <stdlib.h>
#include <time.h>
#define MAX_COUNT 2
#define BUF_SIZE 120
void main(void)
{
pid_t pid;
int i;
int x=0;
char buf[BUF_SIZE];
fork();
fork();
fork();
pid = getpid();
for (i = 1; i <= MAX_COUNT; i++) {
x= rand();
sprintf(buf, "Esta linea es de pid %d, valor = %d, valor de x
es %d\n", pid, i, x);
write(1, buf, strlen(buf));
}
}



Compile el programa y ahora indique cuántos procesos se crearon. ¿Es igual a su respuesta
anterior? Si no es, ¿por qué?

R//Despues de haber compilado el programa se crean ocho procesos debido a que el padre crea tres procesos hijos el hijo mas izquierdo del padre crea a su ves dos procesos de esto procesos el hijo izquiedo crea una proceso mas el hermano derecho del primer hijo izquierdo crea un proceso mas de esta manera pude concluir que se crean ocho procesos.

Modifique el programa para se creen tres copias únicamente.

R//
* Programa bien_facil */

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



void main(void)
{
pid_t pid;
int i;
int x=0;


char buf[BUF_SIZE];
int flag = fork();
if (flag) {
fork();
/*fork();*/
}
pid = getpid();
for (i = 1; i <= MAX_COUNT; i++) {
x= rand();
sprintf(buf, "Esta linea es de pid %d, valor = %d, valor de x es %d\n", pid, i, x);
write(1, buf, strlen(buf));

}
}


3) Fork() más complicado
/* programa bueno */
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#define MAX_COUNT 20
char *barras[5] = { "*","**","***","****","*****" };
void ChildProcess(void); /* prototipo proceso hijo */
void ParentProcess(void); /* prototipo proceso padre */
void main(void)
{
pid_t pid;
pid = fork();
if (pid == 0)
ChildProcess();
else
ParentProcess();
}
void ChildProcess(void)
{
int i;
for (i = MAX_COUNT; i > 0 ; i--)
{
printf("\t\th-%s\n",barras[i % 5]);
sleep(i % 5);
}
printf(" *** Fin proceso hijo ***\n");
}
void ParentProcess(void)
{
int i,h;
for (i = 1; i <= MAX_COUNT; i++)
{
printf("\tp-%s\n",barras[i % 5]);
sleep(i % 5);
}
printf("*** Fin del Padre ***\n");

A// los procesos padre he hijo se llaman cada uno por diferentes lados nunca se ejecutan al mismo tiempo esto obliga al proceso padre a tener un espera para que el hijo termine y asi poder seguir con su ejecucion.
_________________
Mario Roberto Henriquez 10011241

[allamtz]

1) Fork() simple



a) Explique porque si el valor de “x” en el proceso padre es igual o distinto al del proceso hijo. Estudie la página del manual de la función rand().
R//: el valor de x se mantiene igual tanto en el proceso padre como en el proceso hijo, este valor de x se conserva ya que el hijo es una copia exacta al padre y por tanto los dos hacen las mismas llamadas a la funcion rand() obteniendo los mismos resultados.

b) ¿Existe alguna forma de predecir los ID del proceso que serán asignados al proceso hijo y al proceso padre? Explique porqué si o porqué no.
R//: según el ejemplo anterior si existe una forma.
Por lo que se observa el id del hijo es el siguiente numero Id después del padre, es decir, IDhijo = IDpadre + 1 por consecuencia el del IDpadre seria: IDpadre = IDhijo – 1.
Cabe mensionar que podemos predecir el Id de cualquiera de los procesos si tenemos al menos un Id (el del hijo o el del padre) sin embargo, sino conocemos ninguno de estos datos es poco probable que sepamos ID de cualquiera de los procesos.


2) Fork() no tan simple

Revise el siguiente programa antes de correrlo y responda: ¿Cuántos procesos se van a crear?

[efutch]

No se aceptan más tareas después de la fecha establecida.

[10511122 Luis Flores]

francisco javier zuniga 10311087

1) Fork() Simple:

Salida fork() simple:
Esta linea es del proceso hijo pid 54, valor = 1, valor de x es 16838
Esta linea es del proceso hijo pid 54, valor = 2, valor de x es 5758
Esta linea es del proceso hijo pid 54, valor = 3, valor de x es 10113
Esta linea es del proceso hijo pid 54, valor = 4, valor de x es 17515
Esta linea es del proceso hijo pid 54, valor = 5, valor de x es 31051
Esta linea es del proceso hijo pid 54, valor = 6, valor de x es 5627
Esta linea es del proceso hijo pid 54, valor = 7, valor de x es 23010
Esta linea es del proceso hijo pid 54, valor = 8, valor de x es 7419
Esta linea es del proceso hijo pid 54, valor = 9, valor de x es 16212
Esta linea es del proceso hijo pid 54, valor = 10, valor de x es 4086
Esta linea es del proceso padre pid 53, valor = 1, valor de x es 16838
Esta linea es del proceso padre pid 53, valor = 2, valor de x es 5758
Esta linea es del proceso padre pid 53, valor = 3, valor de x es 10113
Esta linea es del proceso padre pid 53, valor = 4, valor de x es 17515
Esta linea es del proceso padre pid 53, valor = 5, valor de x es 31051
Esta linea es del proceso padre pid 53, valor = 6, valor de x es 5627
Esta linea es del proceso padre pid 53, valor = 7, valor de x es 23010
Esta linea es del proceso padre pid 53, valor = 8, valor de x es 7419
Esta linea es del proceso padre pid 53, valor = 9, valor de x es 16212
Esta linea es del proceso padre pid 53, valor = 10, valor de x es 4086

Explique por qué el valor de "x" en el proceso padre es igual o distinto al del proceso hijo.

El valor que se le da a X es igual en ambos debido a que ese valor solo cambiara cada vez que se llame al RAND().
¿Es posible predecir los ID del proceso que serán asignados al proceso hijo y al proceso padre? Explique por qué si o por qué no.

No podría ser posible por la misma funcion de rand() debido a que genera numeros al azar.


2) Fork() no tan simple:

Revise el siguiente programa antes de correrlo y responda: ¿Cuántos procesos se van a crear?

Se crearan 6 procesos ya que los hijos se convierten en padres y sucesivamente.

Compile el programa y ahora indique cuántos procesos se crearon. ¿Es igual a su respuesta anterior? Si no es, ¿por qué?.

Salida Fork() no tan simple:
Esta linea es de pid 397, valor = 1, valor de x es 16838
Esta linea es de pid 397, valor = 2, valor de x es 5758
Esta linea es de pid 396, valor = 1, valor de x es 16838
Esta linea es de pid 396, valor = 2, valor de x es 5758
Esta linea es de pid 398, valor = 1, valor de x es 16838
Esta linea es de pid 398, valor = 2, valor de x es 5758
Esta linea es de pid 395, valor = 1, valor de x es 16838
Esta linea es de pid 395, valor = 2, valor de x es 5758
Esta linea es de pid 400, valor = 1, valor de x es 16838
Esta linea es de pid 400, valor = 2, valor de x es 5758
Esta linea es de pid 399, valor = 1, valor de x es 16838
Esta linea es de pid 399, valor = 2, valor de x es 5758
Esta linea es de pid 401, valor = 1, valor de x es 16838
Esta linea es de pid 401, valor = 2, valor de x es 5758
Esta linea es de pid 394, valor = 1, valor de x es 16838
Esta linea es de pid 394, valor = 2, valor de x es 5758

Si es igual a mi respuesta.

Modifique el programa para se creen tres copias únicamente.
/* Programa bien_facil */

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



void main(void)
{
pid_t pid;
int i;
int x=0;


char buf[BUF_SIZE];
int flag = fork();
if (flag) {
fork();
/*fork();*/
}
pid = getpid();
for (i = 1; i <= MAX_COUNT; i++) {
x= rand();
sprintf(buf, "Esta linea es de pid %d, valor = %d, valor de x es %d\n", pid, i, x);
write(1, buf, strlen(buf));

}
}
Salida del programa anterior:
Código
Esta linea es de pid 417, valor = 1, valor de x es 16838
Esta linea es de pid 417, valor = 2, valor de x es 5758
Esta linea es de pid 418, valor = 1, valor de x es 16838
Esta linea es de pid 418, valor = 2, valor de x es 5758
Esta linea es de pid 416, valor = 1, valor de x es 16838
Esta linea es de pid 416, valor = 2, valor de x es 5758



3) Fork() más complicado:

Explique el funcionamiento del programa “Bueno”.

En el programa, tanto el proceso padre como el hijo, están en espera en varios pasos, por distintos intervalos de tiempos que dependen de la iteración del ciclo FOR en el que este. Antes de empezar a Reposar, imprimen una cadena que depende también de la iteración en la que estén. Al final cada uno anuncia que ha terminado.

Explique la salida que obtuvo del programa “Bueno”, ¿qué muestra?

Salida Bueno:
Código
p-**
p-***
p-****
p-*****
p-*
p-**
p-***
p-****
p-*****
p-*
p-**
p-***
p-****
p-*****
p-*
p-**
p-***
p-****
p-*****
p-*
*** Fin Padre ***
h-*
h-*****
h-****
h-***
h-**
h-*
h-*****
h-****
h-***
h-**
h-*
h-*****
h-****
h-***
h-**
h-*
h-*****
h-****
h-***
h-**
*** Fin hijo ***