practica2

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).

#include<sys/types.h>
#include<sys/wait.h>
#include<unistd.h>
#include<stdio.h>
#include<stdlib.h>
#define L1 2
#define L2 3
int main (int argc, char *argv[]) {
  int cont1, cont2;
  pid_t pid;
    for (cont2= 0; cont2< L2; cont2++) {
      for (cont1= 0; cont1< L1; cont1++) {
    pid= fork();
    if (pid== 0)
      break;
      }
    if (pid!= 0)
    break;
    }
return 0;
}

Actividad1

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.

FIFO y LIFO

Colas (FIFO).

Una cola es una estructura de datos en la que el primer dato en entrar es el primer dato en salir. Es decir, es una estructura FIFO (First In First Out). Todo el mundo conocemos como funciona una cola, los nuevos se ponen al final, los servicios se prestan al principio y no está permitido “colarse”. Las mismas reglas se aplican a las colas de datos almacenadas en la memoria de un computador.

Hay varias formas de implementar una cola en la memoria de un computador. Una forma simple consiste en almacenar los datos en posiciones de memoria adyacentes y utilizar punteros para el principio y el fin de la cola. Cuando un elemento se añade a la cola, el puntero de la parte posterior se ajusta para que señale al nuevo elemento. De manera similar, cuando un elemento se elimina de la cola, se ajusta el puntero delantero para que señale al nuevo primer elemento.

El problema de este método para implementar las colas es que las posiciones de memoria que ocupan, varían a medida que se añaden y eliminan elementos de la misma. La solución habitual consiste en asignar un área fija para almacenar la cola y permitir que se mueva en este área de manera circular. Un área de almacenamiento de esta forma se denomina buffer circular , y puede apreciarse en la figura siguiente.

Entre las aplicaciones que tienen las colas se encuentran el almacenamiento de datos en camino, entre un procesador y un periférico, o actuar como punto intermedio en las redes de comunicación de datos.

Pilas (LIFO).

Una pila es una colección ordenada de datos a los que sólo se puede acceder por un extremo, denominado tope o cima de la pila. La pila es una estructura en la que el último elemento en entrar será el primero en salir, es decir, es lo que se denomina estructura LIFO (Last In First Out).

Podemos comparar esta estructura con una pila de platos colocada sobre un muelle. Cuando

se añade un nuevo plato en lo alto de la pila, los demás bajan, cuando se retira un plato de la pila, los demás suben. Igual que en el caso de las colas, van a existir dos punteros, uno que indica la posición tope de la pila, denominado puntero de pila, y otro que señala su base, denominado base de pila, y que mantiene el mismo valor mientras existe la pila. Cuando la pila esta vacía el puntero de pila tiene el mismo valor que la base de pila.

La pila es una de las estructuras más importantes en computación. Se usa en cálculos, para pasar de un lenguaje de computador a otro y, para transferir el control de una parte del programa a otra. Las operaciones que se pueden realizar tanto con las colas como con las pilas, son las siguientes:

· Añadir o eliminar un elemento: Si es una cola podremos añadirlo o eliminarlo al final

de la misma, y si es una pila al principio.

· Acceder al primer elemento: Normalmente es el único al que se va a poder acceder

directamente.

· Acceder al elemento siguiente del último procesado: Este es el mecanismo normal de

acceso tanto a colas como a pilas.

· Saber si está vacía: Están vacías si no contienen ningún elemento.

programa examen

Programa de Examen

#include <./include/rshmem.h>
#include <stdlib.h>
#include <sys/sem.h>
#include <math.h>
#include <time.h>
#define N 5  
#define M 50

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;
}

filosofo(FILE *pf, key_t *sclave, int *sfilo, int i, int *comer, int *fin, int *fc){

if (-1==(sfilo[i]=semOpen(sclave[i])))
fprintf(stderr,"no tengo el cualificador del semaforo filosofo %d\n",i);

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)     {
   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);
   semSignal(sfilo[(i+2)%N]);
   semSignal(sfilo[i]);
   (*fc)--;
   }
}

semClose(sfilo[i]);
semClose(sfilo[(i+2)%N]);
(*fin)++;
exit(1);
}

int main(){

FILE *pf;           
key_t sclave[N+1]; 
int sfilo[N];     
int *comer;   
int *fin;        
int *fc;          
int i;              

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 ");
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);
}

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");
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);
fprintf(pf,"no habia comido ningun filososo y ahora han comido %d", *comer);
fclose(pf);
if(!eliminarMemoria())
fprintf(stderr,"error de eliminarMemoria()\n");

for(i=0; i<N; i++)
semClose(sfilo[i]);
exit(0);
}