El documento trata sobre sistemas operativos y la sincronización de procesos. Explica los conceptos de sección crítica, exclusión mutua y semáforos como solución al problema de la sección crítica. También presenta el problema clásico de productor-consumidor y cómo resolverlo utilizando semáforos para controlar el acceso concurrente a un buffer compartido.

1. Sistemas Operativos
No sincronizados
Tiempo
3:00 Mira en la refri (no hay leche)
Sistemas Operativos Profesor: 3:05 Ir a la tienda
Your picture here
Ciclo 2012-1 Diaz Muñante Jorge 3:10 Mira en la refri (no hay leche)
3:15 Compra leche
3:20 Ir a la tienda
3:25 Llega a casa, guarda la leche
3:30 Compra leche
Sincronizacion de Procesos 3:35 Llega a casa, guarda la leche..
ya hay¡¡¡
Proceso Deposito / Retiro
Servidor de un Banco
Los procesos pueden coincidir en accesar a datos comunes
Proceso Deposito Proceso Retiro
…. …..
leer registro lee Registro
Saldo = Saldo + deposito Saldo = Saldo – Retiro
Actualiza registro actualiza registro
….. …..
Puedo Ocurrir desafortunamente:
Proceso Deposito Proceso Retiro
……..
t1 Leer registro
Problema en un Servidor: t2 Saldo = Saldo + deposito
– Se da servicio a un conjunto de requerimientos t3 Lee Registro
– Hay que hacerlo sin corromper la base de datos t4 Saldo = Saldo – Retiro
t5 Actualiza el registro
– Permitirlo puede costar mucho dinero t6 Actualiza registro
Sincronización de Procesos Sincronización de Procesos
Un proceso se ejecuta asíncronamente con respecto a otro,
Sección crítica: porción de código en la que se
debido a que sus ejecuciones son independientes. accede a un recurso compartido.
Sin embargo hay instantes en que deben sincronizar sus
Exclusión mutua: garantizar que en cada
actividades. momento se pueda estar ejecutando como
El acceso concurrente a datos compartidos puede resultar máximo una sección crítica asociada a un
recurso.
en datos inconsistentes.
Mantener la consistencia en los datos requiere de Proceso Deposito Proceso Retiro
mecanismos que aseguren la ejecución ordenada de ….
<protocolo de entrada>
…..
<protocolo de entrada>
procesos concurrentes. leer registro lee Registro
Saldo = Saldo + deposito Saldo = Saldo – Retiro
Actualiza registro actualiza registro
<protocolo de salida> <protocolo de salida>
….. …..
Diaz Muñante Jorge 1

2. Sistemas Operativos
Sección criticas Soluciones al Problema de la sección crítica
Condiciones obligatorias
1. Exclusión Mutua. Si un proceso Pi esta ejecutando su sección crítica,
A ingresa a sección critica entonces ningún otro proceso puede ejecutar su sección crítica.
A libera la sección critica
Proceso A
2. Ningún proceso que esta fuera de su sección crítica puede bloquear a otros.
B intenta B ingresa B libera
ingresar a a sección la sección 3. Ningún proceso puede ser esperar un tiempo arbitrariamente grande para
sección critica critica critica entrar en su sección crítica.
Proceso B 4. No se puede asumir la velocidad o rapidez de los procesos.
B bloqueado
T1 T2 T3 T4
¿Adónde vamos con la sincronización? Los semáforos
Programas Programas compartidos
P1 Recurso Semáforo:
Variable entera no
Alto negativa, con las
Nivel
Locks Semaforos Monitores P3 P2
Send/Receive siguientes
API P4
operaciones
Hardwar Load/Store Disable Ints Test&Set
e Comp&Swap S
Dos operaciones:
Vamos implementar varias primitivas de sincronizacion usando
operaciones atomicas P(S): V(S):
if ( S > 0 ) then if (alguien espera por S) then
S:=S-1 lo transita a listo
else else
bloquea al proceso S:=S+1
Tipo y uso de semáforos Productor / Consumidor
Uso Descripción
Concurrencia acotada Semáforo contador o general
Cuando un recurso será asignado,
tomándolo de un conjunto de Produce un elemento
recursos idénticos Guarda el elemento
Semáforo es inicializado con el Productor
número de recursos existentes
Exclusión mutua Semáforo binario
Inicializado en 1. Un proceso antes
Buffer
de ingresar a la sección critica X Y Z
realiza la operación “P” y cuando
termina la operación “V” 0 1 2 3 4 5 ............................................ 99
Señalización Semáforo sincronizador
P1 con enunciado S1
P2 con enunciado S2 Consumidor
Se desea que S2 sea ejecutado
después de que S1 haya terminado Saca un elemento
Consume el elemento
Diaz Muñante Jorge 2

3. Sistemas Operativos
#define N 100 /* Número de espacios en el almacen (buffer) */
Problema de productor consumidor int cont = 0; /* Número de elementos en el almacen (buffer) */
typedef int semaphore
#define N 100 /* Número de espacios en el almacen (buffer) */
int cont = 0; /* Número de elementos en el almacen (buffer) */ semaphore ocupado = 1;
semaphore vacio = N; Solución prob. prod-cons usando semáforos
semaphore lleno = 0;
void productor( )
{
int elemento; void productor( )
{
while (TRUE){ /* ciclo infinito */ int elemento;
produce_elem(&elemento); /* genera el siguiente elemento */
if (cont == N) /* si el almacen (buffer) esta lleno */ while (TRUE) { /* ciclo infinito */
sleep(); /* entonces se duerme */ produce_elem(&elemento); /* genera el siguiente elemento */
intro_elem(elemento); /* colocar elemento en almacen */ P(&vacio); /* decrementa contador espacios vacíos */
cont = cont+1 /* incrementa conta. elementos alma. */ P(&ocupado); / * entra en la sección crítica */
if (cont == 1) /* estaba vacio el almacen (buffer) */ intro_elem(elemento); /* colocar elemento en el almacen */
wake_up(consumidor);
} V(&ocupado); /* sale de la sección crítica */
} V(&lleno); /* incrementa cont entradas ocupadas */
}
}
void consumidor( ) void consumidor( )
{ {
int elemento; int elemento;
while (TRUE) { /* ciclo infinito */ while (TRUE) { /* ciclo infinito */
if (cont == 0) /* si el almacen (buffer) esta vacío */
sleep(); /* entonces se duerme */ P(&lleno); /* decrementa cont. entradas ocupadas */
retira_elem(&elemento); /* retira elemento del almacen */ P(&ocupado); /* entra en la sección crítica */
cont = cont - 1; /* decrementa conta. elementos alma */ retira_elem(elemento); /* toma un elemento del almacen */
if (cont == N-1) /* estaba lleno el almacen (buffer) */ V(&ocupado); /* sale de la sección crítica */
wakeup(productor); V(&vacio); /* incrementa contador entradas vacías */
consume_elem(elemento); /* consume el elemento */ haz_algo(elemento); /* hace algo con el elemento */
} }
} }
Ejemplo de corrida del algoritmo Continuación del ejemplo
Valores iniciales: ocupado=1 vacio=N lleno=0
PRODUCTOR CONSUMIDOR
PRODUCTOR CONSUMIDOR
produce_elem(&elemento) P(&vacio)
P(&vacio) vacio=98
vacio=99 P(&ocupado)
P(&ocupado) Temina quantum, cambio CPU
ocupado= 0 proceso espera liberación
intro_elem(elemento) de la variable ocupado
V(&ocupado)
ocupado=1 Temina quantum, cambio CPU
V(&ocupado)
P(&lleno) envio señal a quien
proceso esperaba ocupado
Temina quantum, cambio CPU bloqueado
V(&vacio)
V(&lleno) vacio=99
envio señal que proceso Temina quantum, cambio CPU haz_algo(elemento)
esperaba
produce_elem(&elemento)
Temina quantum, cambio CPU proceso despierta
proceso despierta intro_elem(elmento)
P(&ocupado)
ocupado=0 V(&ocupado)
Temina quantum, cambio CPU retira_elem(... ocupado=1
:
:
Lectores / escritores
W
R
R
R
Motivacion: Considere compartir una BD
– Hay 2 clases de usuarios:
• Lectores – no modifica la BD
• Escritores – leen y modifican la BD
– Tendremos muchos lectores a la vez y un solo escritor a
la vez
Diaz Muñante Jorge 3