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

 

practica 5

PRACTICA 5

 

posix

POSIX 

(Portable Operating System Interface)
 

DEFINICION

Son una familia de estándares de llamadas al sistema operativo definidos por el IEEE y especificados formalmente en el IEEE 1003. Persiguen generalizar las interfaces de los sistemas operativos para que una misma aplicación pueda ejecutarse en distintas plataformas. Estos estándares surgieron de un proyecto de normalización de las API y describen un conjunto de interfaces de aplicación adaptables a una gran variedad de implementaciones de sistemas operativos.


Cuando el sistema operativo crea un proceso, el proceso en sí es un hilo de ejecución. Sin embargo se puede escribir un programa para crear muchos hilos que se ejecutan en el mismo espacio de memoria en forma paralela.

Los hilos POSIX son los más recomendables para emplear dado que son portables y tienen mejor desempeño que los procesos ligeros de UNIX.

La portabilidad de código permite que se pueda compilar y ejecutar el programa sobre otra plataforma que soporte hilos POSIX. De tal manera que el programador paraleliza su código insertando funciones de hilos POSIX, lo compila y lo ejecuta en una plataforma de un procesador o de múltiples procesadores (Por ej. en IRIX) y el mismo código lo puede compilar y ejecutar en otra plataforma (Por ej. en Solaris).

Con hilos POSIX se pueden paralelizar:
Llamadas a subrutinas o funciones.

E/S en C.
Algunas dependencias de datos usando herramientas de sincronización.


Los hilos POSIX no pueden paralelizar:
Ciclos individuales dentro de un programa (deben ser reescritos como funciones).
Pipas gráficas.

Ejemplo de uso de hilos POSIX:

/* hola.c
Programa que que genera 2 hilos POXIS para
imprimir a pantalla "hola mundo".
compilar:
cc hola.c -o hola -lpthread
*/
#include <pthread.h>
#include <stdio.h>
void* imprime_mensaje( void *ptr );
main()
{
pthread_t hilo1, hilo2;
char *mensaje1 = "hola";
char *mensaje2 = "mundo";
/* se generan 2 hilos que se ejecutaran en paralelo con el padre */
pthread_create(&hilo1, NULL, imprime_mensaje, (void*) mensaje1);
/* aquí el hilo padre puede estar haciendo otra cosa en paralelo con
los 2 hilos POSIX hijos */
/* por ejemplo: */
printf("A lo mejor esto se imprime primero... \n");
pthread_create(&hilo2, NULL, imprime_mensaje, (void*) mensaje2);
sleep(1);
exit(0);
}
void* imprime_mensaje( void *ptr )
{
char *mensaje;
mensaje = (char *) ptr;
printf("%s \n", mensaje);
pthread_exit(0);


}

eleccion de proyecto

hola profesor yo elijo el programa numero 8

practica 4

pantalla de codigo y ejecucion de la practica 4