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 hebraen Monitor al mismotiempo

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 cond1 Var cond2

ProcedimientosmonitorCola espera

monitor

Colas esperasVariables 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 bufferint 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 MutexCaso pthreads

Otra construcción Variables de condición pueden ser usadas con

mutexespthread_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