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 Wait ( Mutex ) ; X : = X + X ; S.C. Signal ( Mutex ) ; 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 los ejemplos de la asignatura) como packages: Bin Semaphore : binario Semaphore : generales Definen tipo paramétrico (para inicializar semáforo) M. Carro (UPM) 3 / 20 M. Carro (UPM) 4 / 20

2 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 en Ada Cuestiones sintácticas Un interfaz de semáforos Inicialización expĺıcita en declaración de variable: Mutex: Bin Semaphore.Semaphore Type(1); Semáforo b i n a r i o i n i c i a l i z a d o a 1 Mutex : Bin Semaphore. Semaphore Type ( 1 ) ; 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 ; Notación de objetos: Procedimientos Wait(Mutex) Signal(Mutex) Objetos Mutex.Wait Mutex.Signal M. Carro (UPM) 5 / 20 M. Carro (UPM) 6 / 20 generales: sincronización 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 Aparcamiento: solución 1 Con un semáforo binario Espacio : = False ; Mutex : Semaphore Type ( 1 ) ; loop Tarea s a l i d a loop Tarea entrada Espacio : = False ; AbrirE ; 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 : Semaphore Type ( 1 ) ; i f N C = MAX 1 then No Lleno. Signal ; No Lleno. Wait ; No Lleno. Signal ; 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 No Lleno.Wait y Mutex.Wait? Huecos : Semaphore. Semaphore Type ( Max ) ; Huecos. Signal ; Huecos.Wait permite paso si hay espacio Huecos.Signal libera espacio El poder de los semáforos? Codificar con Peterson Huecos. Wait ; Repetir análisis suponiendo que hay dos (o más) entradas M. Carro (UPM) 13 / 20 M. Carro (UPM) 14 / 20 Solución 1: sólo exclusión mutua Cola acotada s leen y escriben lleno: productor espera vacío: consumidor espera Mutex : Bin Semaphore ( 1 ) ; 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 >> loop << Quita de b u f f e r >> U t i l i z a r ( Un Dato ) ; Poner(Item) Tomar(Item) Precondiciones secuenciales vs. Precondiciones concurrencia M. Carro (UPM) 15 / 20 M. Carro (UPM) 16 / 20

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