JERARQUIA DE PROCESOS RESULTANTE

Estudia el siguiente codigo y escribe la jerarquia de procesos resultante.
Despues, compila y ejecuta el codigo para comprobarlo (deberas añadir llamadas al sistema getpid, getppid y wait para conseguirlo).

wait que cambia el estado del proceso padre a bloqueado hasta que el proceso hijo termine.

Se observa que los procesos terminan en el orden contrario al que se han creado, es decir, primero termina el ´ultimo proceso creado y el ´ultimo proceso en terminar es el inicial. Esto ocurre gracias a la llamada al sistema

Se observa que el proceso padre es siempre el ´ultimo en terminar. Esto es debido a que la llamada al sistema

PUBLICADO Ma. Isabel wait, que hace que el proceso padre pase a estado bloqueado hasta que un proceso hijo termine, se encuentra dentro de un bucle que va a hacer que se llame tantas veces como procesos hijos creo.

ACTIVIDAD 1

Dibuja la jerarquía de procesos que resulta de la ejecución del siguiente código. Introduce las llamadas al sistema wait para que una vez generado el árbol de procesos los hijos sean esperados por sus respectivos padres. Ademas,  haz que se informe de los tiempos de ejecución de las aplicaciones  xload y kcalc que se generen así como del tiempo total de ejecución. Para calcular el tiempo transcurrido, puedes utilizar la función´ time() de la librería estándar  time.h. La llamada time(NULL) devuelve los segundos transcurridos desde las 00:00:00 del 1/1/1970 hasta el instante de la llamada.

Código:

#include <sys/types.h>
#include <sys/wait.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
int main (int argc, char *argv[]) {
int i, j;
pid_t pid, nuevo, nuevo1;
time_t ini, fin;
ini = rand()%25+1;
for (i= 0; i< 2; i++)
{ pid= getpid();
    for (j= 0; j< i+2; j++)
    { nuevo= fork();
    if(nuevo== 0){ break;
    nuevo1= fork();
    if(nuevo1== 0)
    execlp ("xload", "xload", NULL);
    }
}
if (pid!= getpid())
execlp ("kcalc", "kcalc", NULL);
}
for (i= 0; i< 2; i++)
for (j= 0; j< i+2; j++){ wait(NULL);
printf ("Tiempo en ejecucion de kcalc: %ld\n", (rand()%50+1)-ini);
}
printf ("Tiempo total: %ld\n", (rand()%25+1)-ini);
return 0;
}

PRACTICAS 1-15

Practica 1 Matando un proceso en modo grafico

Practica 2 Matando un proceso por línea de comandos

Practica 3 Matando un proceso por medio de scripts

Practica 4 Ver los procesos de usuario desde línea de comandos

Practica 5 Mostrando los porcentajes de uso de memoria de los procesos

Practica  6 Ejecución de procesos de manera concurrente

Prac7 Uso del comando jobs (viendo estado de procesos)

Practica 8 Pausar tareas y 9 Muestra de reinicio de procesos

Practica 10 Crear una lista FIFO

Practica 11 Agregando un proceso a una lista FIFO

Practica 12 Creado listas con mknod

Practica 13 Observar listas de procesos creadas hasta ahora

Practica14  Eliminando una lista

Practica 15 Ver árbol de procesos

PRACTICA SEMAFOROS

lock_lp (tipo_flag flag)/*solicita ejecutar la seccion critica*/
{
  BOOL entrar= 0;
  while (!entrar)
  {
  lock(cerrojo_flags);
  if (flag)
 {
  unlock(cerrojo_flags);
  dormir(flag);
 }
  else
 {
entrar= 1;
flag= 1;
unlock(cerrojo_flags);
 }
  }
}

unlock_lp (tipo_flag flag)/*otro proceso puede ejecutar la seccion critica*/
{
lock(cerrojo_flags);/*Una sección crítica se protege*/
flag= 0;
despertar(flag);
unlock(cerrojo_flags);
}

El codigo de la Figura 2.15 representa una implementacion para un
multiprocesador de las primitivas de exclusion mutua de largo plazo basadas en
dormir y despertar.
(a) Analizar la estructura de las secciones criticas que contienen.
/*Un evento se implementa mediante una variable booleana o flag
y la cola asociada de procesos bloqueados en él. Los procesos que
 ejecutan dormir sobre un flag activado pasan a estado bloqueado,
 provocando un cambio de contexto. Cuando otro proceso o el propio
 sistema operativo ejecuta despertar sobre ese flag, desbloquea a todos
 los procesos dormidos en ese flag.
*/
(b) Siguiendo esta misma idea, dados los algoritmos de las primitivas de bajar y subir
sobre semaforos estudiadas, re-implementar bajar y subir sobre semaforos.

Subir () puede encargarse de liberar los cerrojos de los procesos, y bajar() de restaurarlos. En otras palabras, los procesos en estado bloqueado se consideran fuera de toda sección crítica. Un problema del esquema subir/bajar es que bajar desbloquea a todos los procesos subidos en el flag y sólo uno de ellos accederá a la sección crítica. Esto es especialmente preocupante en multiprocesadores, ya que producirían contención en el acceso al cerrojo. Sin embargo, la limitación fundamental del manejo de eventos con este mecanismo deriva de que la primitiva de bajar no almacena el evento; lo que introduce la posibilidad de condiciones de carrera en una secuencia de subir y bajar sobre un flag (importa el orden en que se ejecutan).
p wait espera
v señal.

Publicado por : Ma. Isabel Serrano Medina

DIFERENCIA DE LIFO Y FIFO

DIFERENCIA DE FIFO Y LIFO

FIFO: (First In, First Out), que son las colas.

Colas simples:

Se inserta por un sitio y se saca por otro, en el caso de la cola simple se inserta por el final y se saca por el principio. Para gestionar este tipo de cola hay que recordar siempre cual es el siguiente elemento que se va a leer  y cual es el último elemento que se ha introducido. 

Colas circulares:

En las colas circulares se considera que después del último elemento se accede de nuevo al primero. De esta forma se reutilizan las posiciones extraídas, el final de la cola es a su  vez el principio, creándose un circuito cerrado.

LIFO: (Last In, First Out), que son las pilas.

Las pilas son estructuras de datos que tienes dos operaciones básicas:

push (para insertar un elemento) y  pop (para extraer un elemento). Su característica fundamental es que al extraer se obtiene siempre el último elemento que acaba de insertarse.

Las pilas se utilizan en muchas  aplicaciones que utilizamos con frecuencia. Por ejemplo, la gestión de ventanas en Windows (cuando cerramos una ventana siempre recuperamos la que teníamos detrás). Otro ejemplo es la evaluación general de cualquier expresión matemática para evitar tener que calcular el número de variables temporales que hacen falta. Por ejemplo:

3 + 4 * (8 – 2 * 5)  

EXAMEN

Implemente utilizando semáforos una solución a esta variante del problema de los filósofos. Hay F filósofos (F mayor o igual que cinco); y hay P palillos, que se pueden tomar en cualquier orden (no están ordenados circularmente en la mesa). Cuando un filósofo quiere comer, coge un par de palillos cualesquiera y cuando acaba de comer, los devuelve a la mesa.

#include "rshmem.h"
#include <stdlib.h>
#include <sys/sem.h>
#include <math.h>
#include <time.h>
#define N 5   /* tomo 5, como un numero generico de filosofos */
#define M 50  /* numero total de veces que comen los filosofos *
/* Declaracion de la funcion incrementa */
incrementa (int *mem, int k){
int i;
i=*mem;
TP ; TP ; TP TP ;TP ; TP TP ; TP ; TP TP ; TP ;
TP i=i+k;TP ; TP ; TP TP ;TP ; TP TP ; TP ; TP TP ;
TP ; TP
*mem=i;
}
/* Declaracion de la funcion filosofo: uso de semaforos */
filosofo(FILE *pf, key_t *sclave, int *sfilo, int i, int *comer, int *fin, int *fc){
/* ABRIR SEMAFOROS */
/*Abrir semaforo del filosofo de la izquierda del que desea comer */
if (-1==(sfilo[i]=semOpen(sclave[i])))
fprintf(stderr,"no tengo el cualificador del semaforo filosofo %d\n",i);
/*Abrir semaforo del filosofo  de la derecha del que desea comer */
if (-1==(sfilo[(i+2)%N]=semOpen(sclave[(i+2)%N])))
fprintf(stderr,"no tengo el cualifacador semaforo filosofo %d\n",(i+2)%N);
while(*comer<M){
semWait(sfilo[i]);
(*fc)++;
if (*fc>(N+1)/2)   /* mira si mas de la mitad de los filosofos estan intentando comer */
   {
   semSignal(sfilo[i]);
   (*fc)--;
   }
else   {
   semWait(sfilo[(i+2)%N]);
   incrementa(comer,1);
   (void) fprintf(pf,"[comer:%.2d] el filosofo %d ha comido\n", *comer, (i+1)%N);
   fflush(pf); /* para sincronizar la escritura de datos en el fichero de salida */
   semSignal(sfilo[(i+2)%N]);
   semSignal(sfilo[i]);
   (*fc)--;
   }
}semClose(sfilo[i]);
semClose(sfilo[(i+2)%N]);
(*fin)++;
exit(1);
}
int main(){
FILE *pf;            /* puntero a fichero salida */
key_t sclave[N+1];   /* array de claves para semaforos */
int sfilo[N];        /* un semaforo por filosofo */
int *comer;          /* variable de memoria compartida */
int *fin;            /* variable de memoria compartida */
int *fc;             /* variable de memoria compartida */
int i;               /* contador */
printf("1");
if((pf=fopen("fich", "w+"))==NULL){
fprintf(stderr,"error al abrir el fichero para salidas\n");
exit(-1);
}
printf("abre fichero salida");
for(i=0; i<N; i++){
printf("el for ");
/*crear nombres claves filosofos */
if((key_t)-1==(sclave[i]=ftok("filos",'s'+i))){
fprintf(stderr,"main: error crear clave filosofo %d con ftok(%c)\n", i,'s'+i);
exit(1);
}
/*crear semaforos filosofos */
print("dentro del fo");
if(-1==(sfilo[i]=semCreate(sclave[i],1))){
fprintf(stderr,"main: no pude crear semaforo filosofo %d\n",i);
exit(1);
}
} 
printf("hola");
if(!crearMemoria())
fprintf(stderr,"error de crearMemoria()\n");
/*inicializar variable comer y variable fin */
comer = (int *) memoria;
*comer = 0;
fin = (int *) comer + sizeof(int);
*fin = 0;
fc = (int *) comer + sizeof(int);
for(i=0; i<N; i++){
if(0==fork())    /* PROCESOS HIJOS */
filosofo(pf, sclave, sfilo, i, comer, fin, fc);
}
while(*fin<5); /*espera a que los filosofos coman M veces */
fprintf(pf,"no habia comido ningun filososo y ahora han comido %d", *comer);
fclose(pf); /* eliminar memoria de las variables compartidas */
if(!eliminarMemoria())
fprintf(stderr,"error de eliminarMemoria()\n");/* cerrar semaforos */
for(i=0; i<N; i++)
semClose(sfilo[i]);
exit(0);
} /*fin proceso padre, fin main */

PRACTICA DE NUMEROS ALEATORIOS