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

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

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

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

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.

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, 2006. pp. 78-81, Sección 2.2.5.

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.

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)

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

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

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 }

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

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.

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 }

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

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

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) }

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.