Diferencias LIFO & FIFO

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.

 

 

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.

 

DIFERENCIA

 

Esta radica en la forma en que el proceso de cola entre, y de la misma forma en que se procesa. Mientras la fifo es la primera en llegar sera la primera en salir y la lifo es conforme llega uno es como sàle primero. Aunque a veces se sabe exactamente cuándo se van a producir las llegadas al sistema, en general el tiempo que transcurre entre dos llegadas consecutivas se modela mediante una variable aleatoria. En particular, cuando la fuente es infinita se supone que las unidades que van llegando al sistema dan lugar a un proceso estocástico llamado de conteo.

Programa del Examen 04/oct/2011

Procesos con semaforos

Implemente utilizando semaforos una solucion a esta variante del problema de los filosofos. Hay F filosofos(F mator o igual 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.

Da solucion debe estar libre de interbloqueos


#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]);
}
}