Semáforos. Lecturas: Ben-Ari, secciones 4.1, 4.2, 4.3, 4.6 Andrews, intro. cap. 4 y sección 4.1. Exclusión mutua con semáforos

Transcripción

1 Lecturas: Ben-Ari, secciones 4.1, 4.2, 4.3, 4.6 Andrews, intro. cap. 4 y sección 4.1 Manuel Carro Universidad Politécnica de Madrid Este texto se distribuye bajo los términos de la Creative Commons License Tipo abstracto de datos (Dijkstra) Especificación de comportamiento: sem N Init(sem, n) sem := n Wait(sem) AWAIT sem>0 sem := sem-1 Signal(sem) sem := sem + 1 Código entre : acción atómica Init(sem, n): sólo inicialización valores AWAIT Cond suspende tarea hasta cumplimiento de Cond Wait(sem): suspende hasta que sem > 0, entonces decrementa Signal(sem): incrementa sem M. Carro (UPM) 1 / 20 M. Carro (UPM) 2 / 20 Exclusión mutua con semáforos X :=...; Compartida Init (Mutex, 1); Nadie en sección crítica X := X + X ; S.C. Wait: Signal: Invariante: Mutex = 0 algún proceso en sección crítica Puede decrementar si sección crítica está libre Suspende en otro caso Siempre puede incrementar Puede rearrancar alguna tarea suspendida Clases e implementación Binarios (sem {0, 1}): exclusión mutua Generales (sem N ): sincronización más avanzada binarios: Signal cuando ya tiene un valor 1 efecto indefinido No son parte nativa de Ada Implementación (entre las librerías de la asignatura) como tipos en el paquete Semaphores (semaphores.{ads,adb}): Tipo Semaphore : define un tipo paramétrico (para establecer el máximo valor del semáforo) (Sub)Tipo Bin Semaphore : binarios (Sub)Tipo Gen Semaphore : generales M. Carro (UPM) 3 / 20 M. Carro (UPM) 4 / 20

2 en Ada Paquete Semaphores Un interfaz de semáforos Establecimiento del máximo valor del semáforo en la declaración de variable: Sem: Semaphores.Semaphore (Max => 5); Inicializados al máximo valor por defecto Subtipos para semáforos binarios y generales: subtype Bin Semaphore is Semaphore (Max => 1); subtype Gen Semaphore is Semaphore (Max => Natural Last); Importante: la tarea madre o una de las tareas hijas debe inicializarlo con el valor deseado si éste no coincide con el máximo: Init (Sem, N) en Ada Un interfaz de semáforos Sólo diferencias sintácticas con el esquema ya visto: X : Natural := 1; V a r i a b l e compartida Semáforo b i n a r i o i n i c i a l i z a d o a 1 Mutex : Semaphores. Bin Semaphore ; task type Add ; task body Add i s begin Entrada en sección c r í t i c a X := X + X ; Sección c r í t i c a Salida de sección c r í t i c a end Add ; M. Carro (UPM) 5 / 20 M. Carro (UPM) 6 / 20 generales: sincronización condicional Operaciones externas, procesos, recursos Binarios: exclusión mutua (ya sabíamos hacerla) Generales: misma definición (excepto que sem N ), más potencia Ejemplo: aparcamiento 1 entrada / 1 salida Entrada Barrera_Entrada Entrar Aparcamiento Salir Barrera_Salida Salida Abrir_Entrada Aparcamiento Abrir_Salida Barreras / detectores de entrada y salida Permitir entrar coches (si hay sitio) Descontar los que vayan saliendo procedure Barrera Entrada: detecta coche a la entrada; bloqueante procedure Abrir Entrada: abre la barrera de entrada procedure Barrera Salida: detecta coche a la salida; bloqueante procedure Abrir Salida: abre barrera saluda Aparcamiento: depende de la implementación M. Carro (UPM) 7 / 20 M. Carro (UPM) 8 / 20

3 Aparcamiento: solución 0 Programamos controlador barreras aparcamiento Aparcamiento: solución 1 Con un semáforo binario N C := N C 1; Espacio := False ; loop Tarea s a l i d a N C:= N C 1; loop Tarea entrada Espacio : = False ; M. Carro (UPM) 9 / 20 M. Carro (UPM) 10 / 20 Solución 1: protección de N C Solución 2 Recurso compartido: número coches aparcados Acceso en exclusión mutua Pero: aparcamiento lleno espera activa Llevar mutex fuera de bucle principal? Encapsular sólo N C := N C + 1? No encapsular Espacio := True? Hay espacio Mutex, No Lleno : Bin Semaphore ; N C := N C 1; i f N C = MAX 1 then Signal ( No Lleno ) ; Wait ( No Lleno ) ; i f N C < Max then Signal ( No Lleno ) ; M. Carro (UPM) 11 / 20 M. Carro (UPM) 12 / 20

4 Solución 2: fuego cruzado Solución 3 Mutex: protege sección crítica No Lleno: sincroniza (sincronización condicional) No Lleno = 0 N C = MAX ( bloqueo si aparcamiento lleno) No Lleno = 0 sii ha entrado el último coche No obvio pero no hace espera activa Intercambiar Wait(No Lleno) y Wait(Mutex)? Huecos : Semaphore (Max ) ; Signal ( Huecos ) ; Wait(Huecos) permite paso si hay espacio Signal(Huecos) libera espacio El poder de los semáforos? Codificar con Peterson Wait ( Huecos ) ; Repetir análisis suponiendo que hay dos (o más) entradas M. Carro (UPM) 13 / 20 M. Carro (UPM) 14 / 20 desde la lejanía Algo truculentos y de bajo nivel Pero ampliamente disponibles (POSIX, API Win32) Sincronización condicional ad-hoc Linealización siempre posible, pero a veces no clara Mezclada con exclusión mutua Para implementar abstracciones de nivel superior Cola acotada s leen y escriben lleno: productor espera vacío: consumidor espera Poner(Item) Tomar(Item) M. Carro (UPM) 15 / 20 M. Carro (UPM) 16 / 20

5 Solución 1: sólo exclusión mutua Solucion 2 B u f f e r : T i p o B u f f e r ; loop << I n s e r t a en b u f f e r >> Precondiciones secuenciales vs. Precondiciones concurrencia loop << Quita de b u f f e r >> U t i l i z a r ( Un Dato ) ; B u f f e r : T i p o B u f f e r ; Vacios : Semaphore ( Max ) ; Llenos : Semaphore ( Max ) ; I n i t ( Llenos, 0 ) ; loop Wait ( Vacios ) ; <<I n s e r t a en b u f f e r >> Signal ( Llenos ) ; con dos misiones diferentes Esencialmente, aparcamiento simétrico Pero: estructura de datos separada de semáforo loop Wait ( Llenos ) ; <<Quita de b u f f e r >> Signal ( Vacios ) ; Consumir ( Un Dato ) ; M. Carro (UPM) 17 / 20 M. Carro (UPM) 18 / 20 de un dato Ejercicio: buffer par/impar Dato : Tipo Dato ; Lleno : Bin Semaphore ; con I n i t ( Lleno, 0 ) Vacio : Bin Semaphore ; loop Wait ( Vacio ) ; Dato := Un Dato ; Signal ( Lleno ) ; Establecer invariantes loop Wait ( Lleno ) ; Este Dato := Dato ; Signal ( Vacio ) ; Consumir ( Este Dato ) ; Por qué es más simple que el buffer general? de números pares e impares (en cualquier orden) es: Uno necesita números pares Otro necesita números impares Poner(Item) Usar un buffer de un dato Tomar_Par(Item) Tomar_Impar(Item) Pares Impares M. Carro (UPM) 19 / 20 M. Carro (UPM) 20 / 20