practica 2

codigo de practica


int cuenta= 0;
tipo_flag flag_lleno, flag_vacio;
tipo_cerrojo mutex;
productor()
{
int elemento;
while (1) {
producir_elemento(&elemento);
while (cuenta == N)
dormir(flag_lleno);
lock(mutex);
dejar_elemento(elemento);
cuenta= cuenta+1;
unlock(mutex);
if (cuenta == 1)
despertar(flag_vacio);
}
}
consumidor()
{
int elemento;
while (1) {
while (cuenta == 0)
dormir(flag_vacio);
lock(mutex);
retirar_elemento(&elemento);
cuenta= cuenta-1;
unlock(mutex);
if (cuenta == N-1)
despertar(flag_lleno);
consumir_elemento(elemento);
}
}
lock_lp (tipo_flag flag)
{
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)
{
lock(cerrojo_flags);
flag= 0;
despertar(flag);
unlock(cerrojo_flags);
}

CARACTERISTICAS FIFO Y LIFO

TAREA # 1 SEGUNDO PARICIAL

CARACTERISTICAS FIFO  Y LIFO

MEMORIAS FIFO

Son memorias serie en las que la primera información que entra es la primera que sale (First Input First Output), pueden implementarse con registros de desplazamiento estáticos y una unidad de

 control. Esta última debe tener en cuenta las siguientes características de este tipo de memoria.

- La lectura es destructiva, es decir que al leer, el dato leído ya no está más en la memoria.

 - Cada operación de lectura o escritura debe producir un desplazamiento del resto de la memoria.

 - Cuando la memoria está llena no podrá escribirse, por lo tanto la Unidad de Control deberá ser

 capaz de generar una señal de Memoria llena.

 - Generar las señales de control necesarias para que el primer dato escrito esté disponible para la

 primera lectura.

 - Deberá aceptar al menos tres entradas exteriores: señal de lectura/escritura, señal de inicio de ciclo

 y señal de sincronismo.

es normalmente empleada en los ordenadores para guardar datos cuando hay una solicitud de interrupción  en el programa principal y luego volverlos a recuperar.

MEMORIAS FILO (LIFO)

En estas memorias al última información que entra es la primera que sale (Last Input First Output). Puede implementarse con un registro de desplazamiento reversible,.Un registro de desplazamiento reversible está formado por biestables síncronos y multiplexores. La salida de la memoria es la salida del primer biestable y la entrada es el segundo canal del primer multiplexor.

La inserción de una fifo resulta ideal como elemento de interconexión cuando dos sistemas que poseen información, cuyo flujo cuyo flujo presenta una cadencia o asíncrona deben inter cambiar datos. Los datos pueden introducirse o recuperarse ya sea en flujo uniforme, a ráfagas, irregular o incluso en una combinación de los citados.

 
 

 

programa de examen

procesos con semaforos

implemente utilizando semaforos una solucion a esta variante del problema de los filosofos.hai f filosofos(f<=5);

y hay p palillos, que se pueden tomar en cualquier orden (no estan ordenados circularmente en la mesa). cuando un filosofo quiere comer, coge un par de pàlillos cuando quiera y cuando acaba de comer; los debuelve a la mesa.


sa solucion debe estar libre de interbloqueos

codigo

#include<unistd.h>
#include<semaphore.h>
#include<pthread.h>
#include<sys/times.h>
#define TRUE1
#define N5
#define LEFT(x)(((x)-1)%N)
#define RIGHT(X)(((X)+1)%N)
typedef struct
{
int value;
/* Lista de procesos. */
}
semaphore;
typedef enum
{
THINKING, HUNGRY, EATING
}
status;
/* Estado de cada filosofo. */
status estado[N];
/* Semaforo para exclusion mutua. */
semaphore mutex,
/* Semaforo para bloquear los filosofos adyacentes. */
s[N];
main ()
{
extern status estado[N];
extern semaphore mutex, s[N];
int i, sw = 1;
void Philosopher (int);
/* Inicializamos los semaforos. */
InitSemaphore (mutex, 1);
for (i = 0; i < N; i++)
InitSemaphore (s[i], 0);
/* Inicializamos los estados. */
for (i = 0; i < N; i++)
estado[i] = THINKING;
/* Inicializamos los filosofos. */
for (i = 0; (i < N) && (sw); i++)
if (!(sw = fork ()))
Philosopher (i);
}
void
Philosopher (int i)
{
void think (), eat (), TakeForks (int), PutForks (int);
while (TRUE)
{
think ();
/* Obtiene dos tenedores o se bloquea. */
TakeForks (i);
eat ();
PutForks (i);
}
}
void
TakeForks (int i)
{
void test (int);
extern semaphore mutex, s[N];
extern status estado[N];
/* Acceso a seccion critica. */
wait (mutex);
estado[i] = HUNGRY;
/* Intenta tomar los dos tenedores. */
test (i);
signal (mutex);
/* Se bloquea si no consiguio los tenedores. */
wait (s[i]);
}
void
PutForks (int i)
{
void test (int);
extern semaphore mutex;
extern status estado[N];
/* Acceso a seccion critica. */
wait (mutex);
estado[i] = THINKING;
/* Comprueba si el vecino izquierdo puede comer ahora. */
test (LEFT (i));
/* Comprueba si el vecino derecho puede comer ahora. */
test (RIGHT (i));
signal (mutex);
}
void
test (int i)
{
extern semaphore s[N];
extern status estado[N];
if (estado[i] == HUNGRY && estado[LEFT (i)] != EATING &&
estado[RIGHT (i)] != EATING)
{
estado[i] = EATING;
signal (s[i]);
}
}

imprecion de pantalla