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