Monitores
Upcoming SlideShare
Loading in...5
×
 

Like this? Share it with your network

Share

Monitores

on

  • 13,552 views

Monitores

Monitores

Statistics

Views

Total Views
13,552
Views on SlideShare
13,503
Embed Views
49

Actions

Likes
3
Downloads
354
Comments
1

2 Embeds 49

http://www.slideshare.net 48
http://webcache.googleusercontent.com 1

Accessibility

Categories

Upload Details

Uploaded via as Microsoft PowerPoint

Usage Rights

© All Rights Reserved

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Processing…
  • alright
    Are you sure you want to
    Your message goes here
    Processing…
Post Comment
Edit your comment

Monitores Presentation Transcript

  • 1. 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?
  • 2. 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
  • 3. 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
  • 4. 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
  • 5. 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
  • 6. 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
  • 7. Monitores, incluyendo variables de condición lock Var cond1 Var cond2 Procedimientos monitor Cola espera monitor Colas esperas Variables de condición
  • 8. 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
  • 9. 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
  • 10. 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); } }
  • 11. 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
  • 12. 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
  • 13. 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
  • 14. 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);
      • }
  • 15. 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