Monitores Mecanismo sincronización de nivel más alto que semáforos Construcción a nivel de lenguaje de programación que controla el acceso a datos compartidos Código de sincronización es agregado por el compilador y es reforzado en tiempo de ejecución Por qué este es un mejor enfoque que el proporcionado por semáforos?

En qué consiste un Monitor? Módulo de software que encapsula Estructuras de datos compartidas Procedimientos que operan con los datos compartidos Sincronización entre hebras/procesos concurrentes que llaman procedimientos Garantiza acceso a datos compartido se realice sólo a través de los procedimientos definidos para su acceso

Ilustración de un Monitor Datos compartidos Procedimientos Código de Inicialización Cola de hebras para usar Monitor Sólo una hebra en Monitor al mismo tiempo

Cómo controla acceso Monitor Exclusión mutua Sólo una hebra/proceso puede estar ejecutándose dentro del monitor Sincronización esta implícita en el monitor Si una hebra/proceso trata de entrar al monitor cuando esta ocupado, entonces se bloquea hasta que se desocupe Más restrictivo que semáforos Más fácil de usar Una vez dentro de un monitor una hebra puede verse incapacitada de continuar Permite a una que está esperando entrar a monitor

Variables de Condición Cuando hebra está dentro de un monitor si no puede continuar se bloquea Si provee evento que eventualmente otra puede estar esperando notifica a posible hebra que espera que puede entrar al monitor Variables de Condición se usan para tal efecto Variables de condición pueden ser accesadas sólo desde dentro de un monitor Hay tres operaciones que se pueden realizar con variables de condición

Operaciones con Variables de Condición Una hebra/proceso puede realizar las siguientes operaciones con variables de condición Wait(var_cond) libera lock del monitor y se bloquea espera por otra hebra que le active (signal) la condición var_cond. (cuando es despertada recupera lock) variables de condición tienen asociadas cola de espera por var_cond Signal(var_cond) despierta una (si hay) hebra/proceso esperando por var_cond signal se pierde si nadie espera por var_cond Hoare: hebra que notifica inmediatamente entrega lock a hebra que despierta Mesa: hebra que notifica mantiene lock y procesador (requiere signal sea última instrucción despues de salir de procedimiento) broadcast(var_cond) despierta todos las hebras esperando por var_cond

Monitores, incluyendo variables de condición lock Var cond1Var cond2 Procedimientos monitor Cola espera monitor Colas esperas Variables de condición

Cómo resolver problemas con monitores? Identificar restricciones inherentes al problema Identificar datos a encapsular en monitor Definir procedimientos que accesarán datos Identificar condiciones de espera y señalización, asociar a variables de condición Identificar condiciones por las cuales hebras podrían necesitar para ejecutarse exitosamente en procedimientos Identificar condiciones que se pueden producir en procedimientos que podrían necesitar otras hebras Escribir los algoritmos

Ejemplo productor/consumidor Identificar restricciones inherentes al problema Las mismas que para el caso con semáforos (el problema es el mismo) Identificar datos a encapsular por monitor Buffer, in, out, contador Identificar procedimientos Ingresar: llamado por productores, manipular in, buffer y contador en forma exclusiva Remover: llamado por consumidores, manipular out, buffer y contador en forma exclusiva Identificar condiciones de espera y señalización Productor necesita esperar si buffer está lleno Productor debe señalizar a consumidor después de ingresar un elemento (consumidor puede estar esperando por uno buffer estaba vacío) Consumidor necesita esperar si buffer está vacío Consumidor debe señalizar a productor después de sacar un elemento de buffer (productor puede estar esperando por posición vacía) Variables de condición. Not_empty y not_full. Productor espera por condición not_full y señaliza condición not_empty despues de ingresar un elemento. Consumidor espera por condición not_empty y señaliza condición not_full, despues de sacar un elemento

Usando Monitores con Productor/Consumidor Monitor Producer_Consumer { buffer items[N]; condition not_full, not_empty; int count_items; // número de items en el buffer int in, out; procedure add_entry(item x){ while(count_items == N) wait(not_full); items[in] = x; in = (in + 1)%N; count_items++; signal(not_empty); } procedure get_entry(item *x){ while(count_items == 0) wait(not_empty); *x = items[out]; out = (out + 1) %N; count_items--; signal(not_full); }

Tipos de Monitores Qué significa operación signal? Monitores de Hoare Ejecutar hebra que espera inmediatamente Hebra que notifica se bloquea inmediatamente condición garantizada para cuando hebra que esperaba se ejecute hebra que notifica debe restaurar invariantes de monitor antes de notoficar Monitores Mesa Hebra que espera se prepara para ejecutar, pero hebra que notifica sigue en ejecución hebra que espera se ejecuta cuando hebra que notifica sale de monitor condición puede ser falsa cuando hebra que esperaba se ejecuta Hebra que notifica no necesita restaurar invariantes de monitor Hebra que esperaba debe volver a verificar por condición

Ejemplos con los dos tipos Monitors de Hoare if (not_ready) wait(var_cond) Monitors de Mesa while(not_ready) wait(var_cond) Monitores de Mesa son más fáciles de usar más eficiente, menos cambios, soporta broadcast directamente Monitores de Hoare condición está garantizada de ser verdadera cuando hebra que espera se ejecuta

Monitores en Java Del tipo Mesa Métodos deben ser declarados con palabra clave “synchronized” Variables de condición son anónimas Operaciones wait() corresponde a wait(var_cond) notify() corresponde a signal(var_cond) despierta una hebra esperando por condición. No garantía de que sea la que h aesperado por más tiempo notifyAll() corresponde a broadcast(var_cond) todas las hebras esperando condición despiertan. Cualquiera de ellas puede ejecutarse

Variables de Condición y Mutex Caso pthreads Otra construcción Variables de condición pueden ser usadas con mutexes pthread_mutex_t mutex; pthread_cond_t var_cond; boolean ready; void any(){ pthread_mutex_lock(&mutex); if(!ready) pthread_cond_wait(&var_cond, &mutex); …. ready= TRUE; pthread_cond_signal(&var_cond); pthread_mutex_unlock(&mutex); }

Resumen Monitores de nivel más alto que semáforos Permiten relacionar datos con primitiva de sincronización Un lock por monitor, hebras pueden salir entrar de monitor temporalmente según condiciones Deben ser soportados por lenguaje de programación Exclusión mutua garantizada por compilador Aunque es posible usar locks y variables de condición Menos flexible Estructura de datos bien definida