Monitores

ITESM - CEM Sistemas Operativos I CB00856-1
Sistemas Operativos I
Cb00856 – 1
Modulo 5.
Semáforos y monitores
Soluciones al problema de
exclusión mutua
Prof. Erika MATA SANCHEZ

emata@itesm.mx
http://homepage.cem.itesm.mx/emata
Verano 2006
El problema del productor/consumidor
Sistemas Operativos I 2
Verano 2005 1
El problema del productor/consumidor
Dos procesos comparten un almacén (buffer) de

tamaño fijo.
productor: coloca información en el almacén (buffer)
consumidor: obtiene información del almacén
Problema:
productor desea colocar algo en el almacén lleno
consumidor desea obtener en el almacén vació
Solución
irse a dormir cuando el almacén este lleno (productor)
o cuando se encuentre vacío (consumidor)
Planteamiento de la solución
Dos variables compartidas por los procesos:
N: número elementos en el almacén (buffer)

Nm: número máximo elementos (tamaño buffer)
Actividades productor:
verificar si N= Nm
si es verdad => a dormir
si no es verdad => añadir un elemento
Actividades consumidor:
verificar si N = 0
si es verdad => a dormir
si no es verdad => quitar un elemento
Verano 2005 2
Primitivas de la solución
Dos primitivas de comunicación son usadas entre los
procesos que bloquean el CPU.
Primitiva dormir (sleep)

provoca el bloqueo de quien hizo la
llamada
será suspendido hasta que alguien lo
despierte
Primitiva despertar (wakeup)

despierta al proceso que invocó primitiva sleep
tiene un parámetro: el proceso a despertar
Solución problema productor/consumidor

#define Nm 100 /* Número de espacios en el almacen (buffer) –-- N */
int N = 0; /* Número de elementos en el almacen (buffer) --- cont*/
void productor( )
{
while (TRUE) { /* ciclo infinito */
produce_elem(&elemento);
produce_elem(&elemento); /* genera el siguiente elemento */
if (N == Nm)
Nm) /* si el almacen (buffer) esta lleno */
sleep();
sleep(); /* entonces se duerme */
intro_elem(elemento);
intro_elem(elemento); /* colocar elemento en almacen */
N = N+1 /* incrementa N elementos alma. */
if (N == 1) /* estaba vacío el almacen (buffer) */
wakeup(consumidor);
wakeup(consumidor);
}
}
Verano 2005 3
Solución problema productor/consumidor
void consumidor( )
{

if (N == 0) /* si el almacen (buffer) esta vacío */
sleep();
sleep(); /* entonces se duerme */
retira_elem(&elemento);
retira_elem(&elemento); /* retira elemento del almacen */
N = N - 1; /* decrementa conta. elementos alma */
if (N == Nm-
Nm-1) /* estaba lleno el almacen (buffer) */
wakeup(productor);
wakeup(productor);
consume_elem(elemento);
consume_elem(elemento); /* consume el elemento */
}
}
N = count
Problemas de la solución Nm = N
Almacen vacío
Productor Consumidor
Consumidor lee count (count = 0)
if (cont == 0) => verdad
Prod. introduce elemento en almacen

Incrementa cont
if (cont == 1) => verdad
wakeup(consumidor);
/* cons no esta dormido, señal se pierde */
sleep()
producira elementos hasta que se
llene el almacen y se ira a dormir
sleep()
Sistemas Operativos I
AMBOS DORMIRAN POR SIEMPRE 8
Verano 2005 4
Posible solución
Añadir un bit de espera de despertar
Sin embargo si se tienen dos o más procesos

un solo bit no es suficiente.
Los semáforos
Definidos por Dijkstra en 1965

Dijkstra, E. W., Cooperating sequential processes,
`Programming Languages', Genuys, F. (ed.),
Academic Press, 1965
Variable protegida cuyo valor solo puede ser

accesado y alterado por dos operaciones:
P(S) y V(S)
Nombres provienen del holandés
passeren (probar) y vrijgeven (incrementar).
10
Verano 2005 5
Las operaciones de semáforos
P(S) V(S)
if ( S > 0 ) then if (alguien espera por S)
then
S:=S-1 deja pasar al proceso
else else
esperar por S S:=S+1
11
Características principales
Desbloqueando procesos
El semáforo informa a los procesos que se encuentran
bloqueados.
El administrador de procesos que elige quien pasa a
ejecución
Atomicidad
Se garantiza que al iniciar una operación con un semáforo,
ningún otro proceso puede tener acceso al semáforo hasta
que la operación termine o se bloquee.
En ese tiempo ningún otro proceso puede simultáneamente
modificar el mismo valor de semáforo
12
Verano 2005 6
Tipos de semáforos
Contadores Binarios
Sincronización
13
Semáforos generales o contadores

Útiles cuando un recurso será asignado, tomándolo de
un conjunto de recursos idénticos
Semáforo es inicializado con el número de recursos

existentes:
P(S) decrementa S en 1; indicando que un recurso ha sido
suprimido del conjunto.
Si S = 0 no hay más recursos y el proceso se
bloquea
V(S) incrementa S en 1; indicando que un recurso ha sido

regresado al conjunto.
Si un proceso esperaba por un recurso, éste se
despierta.
14
Verano 2005 7
Semáforos binarios
Sólo pueden tomar dos valores: 0 o 1
Generalmente se inicializan con un valor de 1.
Son usados por dos o más procesos para garantizar
que sólo uno puede entrar en sección crítica.
Antes de entrar a sección crítica un proceso ejecuta
un P(S) y un V(S) antes de salir de ella
Estructura de cada proceso:
while(1)
while(1)
P(entrar)
<Secció
<Sección Crí
Crítica>
V(salir)
V(salir)
do
15
Semáforos sincronía
Solución varios problemas sincronización.
Sean dos procesos concurrentes P1 y P2 que se
encuentran corriendo:
P1 con enunciado S1
P2 con enunciado S2
Se desea que S2 sea ejecutado después de que S1 haya
terminado.
Solución: Semáforo síncrono (inicializado en 0).
P1: ------------- P2: --------------
------------- --------------
S1 P(sincro)
V(sincro) S2
------------- -------------
------------- -------------
16
Verano 2005 8
Solución prod/cons semáforos (1)
#define N 100 /* Número de espacios en el almacen (buffer) */

int cont = 0; * Número de elementos en el almacen (buffer) */
typedef int semaphore
semaphore ocupado = 1;
semaphore vacio = N;
semaphore lleno = 0;
17

void productor( )
{
produce_elem(&elemento);
produce_elem(&elemento); /* genera el siguiente elemento */
P(&vacio)
P( ); /* decrementa contador espacios vacíos */
P(&ocupado)
P( ); / * entra en la sección crítica */
intro_elem(elemento);
intro_elem(elemento); /* colocar elemento en el almacen */
V(&ocupado)
V( ); /* sale de la sección crítica */
V(&lleno)
V( ); /* incrementa cont entradas ocupadas */
}
}
18
Verano 2005 9

void consumidor( )
{
P(&lleno)
P( ); /* decrementa cont. entradas ocupadas */
P(&ocupado)
P( ); /* entra en la sección crítica */
retira_elem(elemento);
retira_elem(elemento); /* toma un elemento del almacen */
V(&ocupado)
V( ); /* sale de la sección crítica */
V(&vacio)
V( ); /* incrementa contador entradas vacías */
haz_algo(elemento); /* hace algo con el elemento */
}
}
19
Ejemplo ejecución (1)

PRODUCTOR CONSUMIDOR
produce_elem(&elemento)
P(&vacio)
vacio=99
P(&ocupado)
ocupado= 0
intro_elem(elemento)
V(&ocupado)
Temina quantum, cambio CPU
ocupado=1
P(&lleno)
proceso
Temina quantum, cambio CPU
bloqueado
20
Verano 2005 10

bloqueado
V(&lleno)
envio señal que proceso
esperaba
produce_elem(&elemento)
proceso despierta
P(&ocupado)
ocupado=0
retira_elem(...
21

P(&vacio)
vacio=98
P(&ocupado)
proceso espera liberación
de la variable ocupado
V(&ocupado)
envio señal a quien
esperaba ocupado
V(&vacio)
vacio=99
haz_algo(elemento)
proceso despierta
intro_elem(elemento)
V(&ocupado)
ocupado=1 22
Verano 2005 11
Problemas clásicos de exclusión mutua
El problema de la cena de filósofos
El problema del Barbero dormilón
El problema de los fumadores
El problema de la panadería
El problema de los lectores/escritores
23
La cena de filósofos
Cinco filósofos se sientan en una mesa redonda. Cada uno
tiene un plato de spaghetti y un tenedor frente a él.
Cinco filó
filósofos, cinco platos, cinco tenedores
El spaghetti es tan
escurridizo que un filósofo
necesita dos tenedores para
comerlo, pero cada filosofo
solo posee un tenedor.
24
Verano 2005 12
La vida de un filósofo consta de periodos alternados de

comer y pensar.
Cuando un filósofo siente hambre, intenta tomar el tenedor

de la izquierda y si lo consigue, lo intenta con el de la
derecha.
Si logra asir dos tenedores toma unos bocados y después

deja los cubiertos y sigue pensando.
25
El problema consiste en desarrollar un algoritmo que evite la

hambruna y el deadlock.
Deadlock – Ocurre cuando los 5 filosofos tienen un tenedor y

nadie puede tomar el segundo
F1 espera el tenedor que ocupa el F2 quien espera por el

tenedor del F3 y así sucesivamente. (Cadena circular de
bloqueo)
26
Verano 2005 13
Hambruna - si un filosofo no puede tomar 2 tenedores,
puede ocurrir independientemente del deadlock.
Analogia de tenedores con recursos -- CONCURRENCIA
BLOQUEO - Técnica común para asegurar que solo un recurso

sea utilizado a la vez:
• Cuando un programa se interesa por un recurso
bloqueado por alguien mas, éste espera a que se
desbloquee
• Cuando muchos recursos se involucran puede ocurrir un
Deadlock.
27
Ejemplo:
un programa requiere procesar dos archivos.

Cuando dos programas bloquean uno archivo cada
uno,
ambos esperan a que el otro desbloquée el segundo
archivo…
NUNCA SUCEDE
28
Verano 2005 14
Una solución:
• Ordenar los tenedores y decir a los filósofos de tomarlos en orden

creciente
• Filósofos : P1, P2, P3, P4 y P5
• Tenedores: T1, T2, T3, T4 y T5.
• P1 toma T1, si antes le permiten tomar el segundo tenedor T2.
• P2 a P4 actúan igual, tomando Tx antes de Tx+1.
• Pero P5 toma T1 antes de T5.
• Cambia conducta normal: P5 genera una asimetría que
previene un deadlock.
29
Una solución:
• Hambruna se previene en función del método MUTEX utilizado:
• busy waiting (ocupado, en espera) - causan
• Colas asegurando acceso equitativo al tenedor por medio del

filosofo adyacente – una solucion
Solución general:
Para un num arbitrario de agentes (A1...Am) que necesitan
acceso exclusivo a un num arbitrario de recursos (R1...Rn).
Agentes:
1. Peticiones de acceso en orden creciente (i.e. Acceso a R3
antes de acceso a R4).
2. Si un agente tiene Rx y necesita Ry, debe liberar primero Rx
si x > y
30
Verano 2005 15
Problema Barbero Dormilón

Una barbería tiene una sala de espera con n sillas, y otra sala
donde se encuentra el sillón de afeitado.
•Si no hay clientes a los que servir, el barbero se echa a
dormir en el sillón.
•Si entra un cliente en la barbería y todas las sillas están
ocupadas, el cliente se va.
•Si el barbero está ocupado afeitando, el cliente se sienta en
una de las sillas disponibles.
•Si el barbero está dormido, el cliente despierta al barbero.
Escribir un programa
que coordine al barbero y los clientes
mediante semáforos.
31

Problema clásico de IPC (Comunicacion interprocesos)
y sincronización entre múltiples procesos de SO
PROBLEMA:
Coordinación si crear condiciones de
competencia.
32
Verano 2005 16

Solucion comun: 3 semaforos
1. Espera clientes
2. Barbero (si esta desocupado)
3. MUTEX
Solo involucra al barbero:

single sleeping barber problem.
problem.
33
Problema de los fumadores

Considere un sistema con tres procesos fumadores
y un proceso agente.
Cada fumador esta continuamente enrrollando y fumando cigarrillos.
Sin embargo, para enrrollar y fumar un cigarrillo, el fumador necesita
tres ingredientes: tabaco, papel, y fósforos.
Uno de los procesos fumadores tiene papel, otro tiene el tabaco y el
tercero los fósforos.
El agente tiene una cantidad infinita de los tres materiales. El agente
coloca dos de los ingredientes sobre la mesa.
El fumador que tiene el ingrediente restante enrrolla un
cigarrillo y se lo fuma, avisando al agente cuando termina.
Entonces, el agente coloca dos de los tres ingredientes y
se repite el ciclo.
Sincronizar al agente y a los fumadores.
34
Verano 2005 17
Problema Panadería de Lamport

Una panadería tiene una variedad de panes y pasteles
vendidos por n vendedores. Cada uno de los cuales toma un
número al entrar. El cliente espera hasta oír su número. Cuando
el vendedor se desocupa, llama al siguiente número. Escriba un
procedimiento para los vendedores y otro para los clientes.
35
Los monitores
Otra opción para la sincronización de procesos.
Introducido por Hoare
C. A. R. Hoare's seminal research paper on monitors,
"Monitors: An Operating System Structuring Concept,"
Communications of the ACM, Vol. 17, No. 10, October
1974, pp. 549-557
Se trata de una construcción concurrente que
contiene los datos y procedimientos necesarios para
la asignación de un recurso compartido.
Para lograr la asignación de un recurso una función
del proceso debe llamar una entrada del monitor.
36
Verano 2005 18
Procesos y monitores
Procesos no tienen acceso directo a las estructuras de
datos.
Solo un proceso puede estar activo en un monitor en
cada momento.
Cuando se llama a un entrada la implementación monitor
verifica si no hay otro proceso dentro del monitor:
si: proceso efectuó la
Estructura E1
llamada es suspendido Datos
P1
no: el que hizo la llamada Proc. 1 E2
puede entrar P2
Proc. 2 E3
: : P3
procedimientos Proc. n En
entradas
37
Operaciones sincronía en procesos

Para sincronizar procesos se usan variables de
tipo condición y dos operaciones:
1. wait()
proceso descubre que no puede continuar (almacen
lleno) ejecuta wait en alguna variable de condición
proceso se bloquea y permite que otro proceso entre al
monitor
2. signal
proceso que entra puede despertar a otro con una
instrucción signal sobre la variable de condición que el
otro proceso espera
38
Verano 2005 19
Comentarios variables condición
Las variables de condición NO son

contadores.
No se acumulan señales para su uso
posterior (como los semáforos)
Si una variable de condición queda señalada
sin que nadie la espere, la señal se pierde.
La instrucción WAIT debe aparecer antes de
SIGNAL
regla que hace más sencilla la implementación
39
Monitores y problema prod/cons

Exclusión mutua es automática,
el monitor garantiza que solo el productor o el consumidor
estaran ejecutandose
Si el almacen esta totalmente ocupado, el productor
realizará una operación WAIT
se encontrará bloqueado hasta que consumidor ejecute un
SIGNAL
Si el almacen esta totalmente vacio el consumidor
realizará una operación WAIT
se encontrará bloqueado hasta que productor ejecute un
SIGNAL
40
Verano 2005 20
Solución prod/cons con monitores

monitor ProdCons
condition lleno, vacio; procedure retirar;
integer cont, N; begin
if (cont = 0) then
procedure producir; wait(vacio)
begin retirar_elemento;
if (cont = N) then cont := cont-1
wait(lleno); if (cont = N-1) then
introducir_elemento; signal(lleno);
cont := cont +1;
end;
if (cont = 1) then
signal(vacio);
end; cont := 0; N=100;
end monitor;
41
Llamando entradas monitor
procedure productor; procedure consumidor;

begin begin
while true do while true do
begin begin
producir_elemento; ProdCons.retirar;
ProdCons.producir; consumir_elemento;
end end
end; end;
42
Verano 2005 21
Esquema solución prod/cons con monitores

monitor ProdCons
condition lleno, vacio;

integer cont, N; P1
ProdCons.producir
ProdCons.retirar
procedure producir
cont :=0;
N:=100;
procedure retirar P2
ProdCons.producir
ProdCons.retirar
43
Problema lectores/escritores
En algunos sistemas computacionales se cuenta con dos
tipos de procesos
procesos lectores: leen datos
procesos escritores: escriben datos
Ejemplo de este tipo de sistema: reservación aérea.
Muchos lectores pueden acceder la base de datos a la vez

varios lectores no cambian el contenido de la base de datos
Un escritor debe tener acceso exclusivo
un escrito puede modificar los datos
44
Verano 2005 22
Planteamiento solución lec/esc
Si el escritor esta activo

ningún lector o escritor puede estar activo
Esta exclusión necesita realizarse solo a nivel registro (i.e.
no toda la base de datos)
no es necesario garantizar a un escritor el acceso exclusivo a la
base de datos completa
Problema propuesto por Courtois, Heymans y Parnas:
Courtois, P.J., Heymans, F., and Parnas, D.L. Concurrent
Control with Readers and Writers, CACM, Vol. 14, No. 10,
October 1971, pp.667-668
45
Solución lectores/escritores
monitor LectoresEscritores procedure terminar_lectura;
var begin
lectores: integer; lectores:= lectores - 1;
alguien_escribe: boolean; if (lectores = 0 ) then
puede_leer, puede_escribir: condition; signal(puede_escribir);
end;
procedure comenzar_lectura;
begin
if ( (alguien_escribe) o en_cola(puede_escribir) ) then
wait(puede_leer)
lectores:= lectores + 1;
signal(puede_leer)
end;
46
Verano 2005 23
procedure comenzar_escritura;
begin
if ( (lectores > 0) or (alguien_escribe) ) then
wait(puede_escribir)
wait
alguien_escribe:=true;
end;
procedure terminar_escritura;
begin
alguien_escribe:=false;
if ( en_cola(puede_leer)) then
signal(puede_leer)
signal
else
signal(puede_escribir)
signal
end I
Sistemas Operativos 47
47
begin
lectores:=0;
alguien_escribe:= false;
end;;
end
48
Verano 2005 24
Ultimo comentario sobre solución
El monitor lectores/escritores puede usarse para

controlar el acceso a
una base de datos completa,
un subconjutno de la base consistente de varios

registros
sobre un simple registro
49
Verano 2005 25

Monitores

Uploaded by

Document Information

Original Description:

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Monitores

Uploaded by

Copyright:

Available Formats

ITESM - CEM Sistemas Operativos I CB00856-1

Prof. Erika MATA SANCHEZ

El problema del productor/consumidor

El problema del productor/consumidor

Dos procesos comparten un almacén (buffer) de

si no es verdad => añadir un elemento

si no es verdad => quitar un elemento

Primitiva dormir (sleep)

Primitiva despertar (wakeup)

Solución problema productor/consumidor

Solución problema productor/consumidor

while (TRUE) { /* ciclo infinito */

Prod. introduce elemento en almacen

Añadir un bit de espera de despertar

Sin embargo si se tienen dos o más procesos

Definidos por Dijkstra en 1965

Variable protegida cuyo valor solo puede ser

Las operaciones de semáforos

Semáforos generales o contadores

Semáforo es inicializado con el número de recursos

V(S) incrementa S en 1; indicando que un recurso ha sido

Estructura de cada proceso:

Solución prod/cons semáforos (1)

#define N 100 /* Número de espacios en el almacen (buffer) */

typedef int semaphore

Solución prod/cons semáforos (2)

Solución prod/cons semáforos (3)

Ejemplo ejecución (1)

Ejemplo ejecución (2)

Ejemplo ejecución (3)

Problemas clásicos de exclusión mutua

El problema de la cena de filósofos

El problema del Barbero dormilón

El problema de los fumadores

El problema de los lectores/escritores

La vida de un filósofo consta de periodos alternados de

Cuando un filósofo siente hambre, intenta tomar el tenedor

Si logra asir dos tenedores toma unos bocados y después

El problema consiste en desarrollar un algoritmo que evite la

Deadlock – Ocurre cuando los 5 filosofos tienen un tenedor y

F1 espera el tenedor que ocupa el F2 quien espera por el

Analogia de tenedores con recursos -- CONCURRENCIA

BLOQUEO - Técnica común para asegurar que solo un recurso

un programa requiere procesar dos archivos.

• Ordenar los tenedores y decir a los filósofos de tomarlos en orden

• Colas asegurando acceso equitativo al tenedor por medio del

Problema Barbero Dormilón

Problema Barbero Dormilón

Problema Barbero Dormilón

Solo involucra al barbero:

Problema de los fumadores

Problema Panadería de Lamport

Operaciones sincronía en procesos

Comentarios variables condición

Las variables de condición NO son

Monitores y problema prod/cons

Solución prod/cons con monitores

Llamando entradas monitor

procedure productor; procedure consumidor;

Esquema solución prod/cons con monitores

condition lleno, vacio;

procesos escritores: escriben datos