Semáforos y Comunicación entre Procesos

Presentación del tema: "Semáforos y Comunicación entre Procesos"— Transcripción de la presentación:

1 Semáforos y Comunicación entre Procesos
SISTEMAS OPERATIVOS Semáforos y Comunicación entre Procesos

2 espera ocupada: si no tiene permiso de entrada queda
Algoritmo de Peterson REPETIR interesado[Pi] =TRUE; /* Sección entrada */ turno = Pj; WHILE (turno= Pj AND interesado [Pj]); sección_crítica(); interesado[Pi] = FALSE; /* Sección salida */ sección_restante(); FIN espera ocupada: si no tiene permiso de entrada queda esperando

3 Una alternativa de solución a espera ocupada: bloqueo
void productor () { REPETIR producir un elemento (item) IF counter=N THEN sleep(); almacenar (item) incrementar counter IF counter = 1 THEN wake_up (consumidor) FIN } void consumidor () { REPETIR IF counter=0 THEN sleep(); retirar (item) decrementar counter IF counter = N-1 THEN wake_up (productor) consumir (item) FIN } Si con counter=0 se le retira la CPU al consumidor antes de

4 Una dificultad en la solución anterior
void productor () { REPETIR producir un elemento (item) IF counter=N THEN sleep(); almacenar (item) incrementar counter IF counter = 1 THEN wake_up (consumidor) FIN } void consumidor () { REPETIR IF counter=0 THEN sleep(); retirar (item) decrementar counter IF counter = N-1 THEN wake_up (productor) consumir (item) FIN } CPU

5 Conclusión Si: El almacén está vacío (counter=0).
Antes de ejecutarse el sleep, el planificador del SO le retira la CPU al consumidor para asignarlo al productor. Entonces: El productor puede ejecutar al menos una iteración completa de su ciclo antes de perder el CPU. Se duerme el consumidor y más tarde se duerme el productor. Ocurre un abrazo fatal (bloqueo mutuo). Un despertar enviado a un proceso que todavía no esté durmiendo se pierde.

6 Contenido Exclusión mutua con bloqueo. Semáforos.
Problemas clásicos de sincronización de procesos. Comunicación entre procesos Bibliografía: S. Tanenbaum, Sistemas Operativos Modernos, Ed. Prentice-Hall Hispanoamericana, 1996, pp.. 47—70. A. S. Tanembaum, Operating Systems Design and Implementation, Third Edition, Prentice Hall, pp , Sección

7 Bloqueo de procesos con semáforos
Un semáforo S (Dijkstra, 1965) es un tipo de variable no negativa que sólo puede ser accedida por 2 primitivas denominadas aquí DOWN y UP. Las primitivas DOWN y UP son tales que: Ejecutan sus operaciones de manera indivisible (acción atómica). Cuando un proceso ejecuta DOWN y encuentra que S = 0, entonces el proceso se bloquea. Un proceso bloqueado en un semáforo será restablecido por la ejecución de UP realizada por otro proceso.

8 Una versión de las primitivas DOWN y UP
DOWN(S): IF (S = 0) { añadir proceso a la lista sleep() } decrementar S UP(S): incrementar S IF (S > 0) { remover proceso P de la lista wake_up(P)

9 Cambio de espera ocupada a bloqueo
Al ejecutar DOWN, un proceso será bloqueado, si el valor del semáforo es cero. Colocar al proceso en un estado de espera Transferir el control del CPU al planificador Al ejecutar UP, un proceso que se encuentra bloqueado en un semáforo será restablecido Se cambiará el estado de dicho proceso de bloqueado a listo y se pondrá en la cola correspondiente

10 Exclusión mutua con semáforos
Los procesos concurrentes necesitan comunicarse entre sí para mantener una adecuada cooperación. Sea un semáforo (mutex) con las consideraciones siguientes: Toma solamente los valores 0 o 1. Su valor inicial es 1. Los procesos concurrentes comparten el semáforo mutex (comunicación a través de memoria) Esquema para exclusión mutua en sección crítica con semáforos REPETIR DOWN (mutex); /* sección entrada*/ sección_crítica(); UP (mutex); /* sección salida*/ sección_restante(); FIN

11 Problema del productor/consumidor con semáforos
mutex full: cantidad de “buffers” llenos. Valor inicial = 0 empty: cantidad de “buffers” vacíos. Valor inicial = N void productor () { REPETIR producir (item) DOWN (empty) DOWN (mutex) almacenar (item) UP (mutex) UP (full) FIN } void consumidor () { REPETIR DOWN (full) DOWN (mutex) retirar (item) UP (mutex) UP (empty) consumir (item) FIN }

12 Otro problema clásico de sincronización de procesos: lectores/escritores
BD sistema de reservaciones lectores escritores read write actualiza (escribe) consultan (leen)

13 Problema de lectores/escritores
Sean : rc: cuenta la cantidad de lectores que están accediendo a BD. Compartida por los lectores. Valor inicial es 0. mutex: semáforo que garantiza exclusión mutua en acceso a rc. Valor inicial es 1. wrt: semáforo que permite exclusión mutua en el acceso a la información de la BD. Valor inicial es 1.

14 Problema de lectores/escritores
void lector ( ) { REPETIR DOWN (mutex) incrementar (rc) IF (readcount=1) DOWN(wrt); UP (mutex) leer_datos( ) decrementar (rc) IF (readcount=0) UP (wrt); UP(mutex) usar_datos( ) FIN } void escritor( ) { REPETIR elaborar_datos( ) DOWN (wrt) escribir_datos( ) UP (wrt) FIN } void main ( ) { parbegin lector ( ) . escritor ( ) parend }

15 Comunicación entre procesos.
Formas de comunicación: Por medio de memoria compartida Responsabilidad de los programadores A través de sistemas de mensajes (intercambio de mensajes)‏ Responsabilidad del SO

16 Tipos de comunicación entre procesos por intercambio de mensajes
Comunicación directa Cada proceso debe explícitamente indicar el nombre del receptor o emisor de la comunicación. send(P, mensaje)‏ Enviar un mensaje al proceso P receive(Q, mensaje)‏ Recibir un mensaje del proceso Q Comunicación indirecta Los mensajes se envían y reciben de buzones y no directamente de los procesos. send(A, mensaje)‏ Enviar un mensaje al buzón A receive(B, mensaje)‏ Recibir un mensaje del buzón B

17 Solución al problema productor/consumidor con mensajes
Suposiciones: Una comunicación directa. Se utilizan N mensajes del mismo tamaño. El consumidor comienza enviando N mensajes vacíos al productor. Siempre que el productor tenga un elemento que enviar, toma un mensaje vacío y regresa uno ocupado. void productor( ) { REPETIR producir (item) receive (consumidor, mensaje) construir_mensaje (mensaje, item) send (consumidor, mensaje) FIN } void consumidor( ) { REPETIR N veces send (productor, mensaje) FIN REPETIR receive (productor, mensaje) extraer_elemento (mensaje, item) consumir (item) }

18 El problema de los filósofos comensales
Breve descripción: Cinco filósofos que piensan y comen sentados alrededor de una mesa. Cuando un filósofo piensa, no interactúa, pero ocasionalmente trata de tomar los dos tenedores que están más cerca de él. Un filósofo podrá tomar primero un tenedor y después el otro. Cuando logra tener los dos tenedores, comerá. Cuando termina de comer pondrá los tenedores sobre la mesa. Consideraciones para la solución: Estado de cada filósofo: pensando, con hambre, comiendo. Autobloqueo por filósofo para cuando aún teniendo hambre, no puede comer porque sus vecinos tienen ocupados los tenedores. Garantizar la exclusión mutua.