2do. PARCIAL (FIFO Y LIFO)

• MEMORIA LIFO.- Es una memoria en la que la información que entra primero es la última que se tiene disponible. Al igual que la fifo se necesita un registro de marca o puntero en el que se indique cual es la base de la memoria y cual la cima.Esta memoria 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.

•  MEMORIA FIFO.-En esta memoria la información que primero entra es la primera que se tiene disponible. En esta se introduce datos por el punto de carga y el primer dato introducido es el que está disponible para ser primeramente extraído de entre una cierta cantidad de datos introducidos. Es un registro de desplazamiento en que los datos se introducen a la izquierda y se extraen por la derecha.

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.

* Criterio FIFO: al utilizar este método se valoran las salidas del almacén según el precio de entrada y en el orden en que ésta se produce, es decir, el valor de la salida de los productos de almacén es el precio de las primeras unidades que entraron. De este modo las existencias salen del almacén valoradas en el mismo orden en que entraron.

*Criterio LIFO: según este criterio las existencias salen del almacén valoradas en orden inverso al de su entrada, es decir, el valor de la salida de las existencias es el precio de las últimas que entraron. Las existencias se registran a su valor de entrada, respetando también el orden cronológico.

PROGRAMA EXAMEN

 

CODIGO

#include <stdio.h>
#include <sys/ipc.h>
#include <sys/sem.h>

#define NUM_FILOSOFOS    5

#define PENSANDO    0
#define COMIENDO    1

#define LIBRE        1
#define USADO        0

typedef struct datos_filosofos {
    int filosofos[NUM_FILOSOFOS];
    int pids[NUM_FILOSOFOS];
    int semaforo_id,semaforo_id2;
    int memoria_id;
} datos_filosofos;

struct datos_filosofos *p_filosofos;

// Reservar semáforos y memoria compartida
int crea_filosofos(void)
{
    int i;
    int sem_id,sem_id2,mem_id;

    // Crea el área de memoria compartida
    if((mem_id=shmget(IPC_PRIVATE,sizeof(datos_filosofos),0774 | IPC_CREAT))==-1)
        return -1;

    if(!(p_filosofos=(datos_filosofos *)shmat(mem_id,(char *)0,0)))
        return -2;

    // Crea el set de semáforos para los cubiertos
    if((sem_id=semget(IPC_PRIVATE,NUM_FILOSOFOS,0774 | IPC_CREAT))==-1)
        return -3;

    // Crea el semáforo que evitará el interbloqueo
    if((sem_id2=semget(IPC_PRIVATE,1,0774 | IPC_CREAT))==-1)
        return -3;

    // Inicializa el área de memoria compartida
    for(i=0;i<NUM_FILOSOFOS;i++)
    {
        p_filosofos->filosofos[i]=PENSANDO;
        p_filosofos->pids[i]=0;
        semctl(sem_id,i,SETVAL,LIBRE);
    }

    semctl(sem_id2,0,SETVAL,NUM_FILOSOFOS-1);
    p_filosofos->semaforo_id=sem_id;
    p_filosofos->semaforo_id2=sem_id2;
    p_filosofos->memoria_id=mem_id;

    return sem_id;
}

// Liberar semáforos y memoria compartida
void elimina_filosofos(void)
{
    int i;
    int mem_id,sem_id;

    mem_id=p_filosofos->memoria_id;
    shmdt((char *)p_filosofos);
    shmctl(mem_id,IPC_RMID,(struct shmid_ds *)NULL);
    for(i=0;i<NUM_FILOSOFOS;i++)
        semctl(sem_id,i,IPC_RMID);
}

// Wait
void P(int id,int i)
{
    struct sembuf op[3]={i,-1,0};
    semop(id,op,1);
}

// Signal
void V(int id,int i)
{
    struct sembuf op[3]={i,1,0};
    semop(id,op,1);
}

int main()
{
    int res;
    int i;

    // Crea filósofos: reservar memoria, crear semáforos
    res=crea_filosofos();
    if(res<0)
    {
        printf("Error %d\n",-res);

        return 0;
    }

    // Crea los filósofos (procesos hijos)
    for(i=0;i<NUM_FILOSOFOS;i++)
        if(!fork())
        {
            // Proceso hijo #i
            p_filosofos->pids[i]=getpid();
            while(1)
            {
                // Máximo NUM_FILOSOFOS-1 entran a tratar de comer para evitar el interbloqueo
                P(p_filosofos->semaforo_id2,0);

                // Espera los dos cubiertos
                P(p_filosofos->semaforo_id,i);
                P(p_filosofos->semaforo_id,(i+1)%NUM_FILOSOFOS);
                p_filosofos->filosofos[i]=COMIENDO;
                sleep(1);

                // Devuelve los dos cubiertos
                V(p_filosofos->semaforo_id,i);
                V(p_filosofos->semaforo_id,(i+1)%NUM_FILOSOFOS);
                p_filosofos->filosofos[i]=PENSANDO;

                // Deja que otro trate de comer
                V(p_filosofos->semaforo_id2,0);
            }
        }

    // Bucle de espera del proceso padre
    while(res!=27)
    {
        // Muestra información
        printf("Estado de los filósofos: \n");
        for(i=0;i<NUM_FILOSOFOS;i++)
            printf("%d[%d] ==> %d\n",i,p_filosofos->pids[i],p_filosofos->filosofos[i]);
        res=getchar();
    }

    // Elimina los procesos hijos
    for(i=0;i<NUM_FILOSOFOS;i++)
        kill(p_filosofos->pids[i],9);

    elimina_filosofos();

    return 0;
}