So 2009-mod 06

Sincronización de Procesos

Fundamentos
Sincronización de Procesos El Problema de la Sección Crítica
La Solución de Peterson y otras
Hardware de Sincronización
Semáforos
Módulo 6 Problemas Clásicos de Sincronización
Monitores
Ejemplos de Sincronización

Departamento de Ciencias e Ingeniería de la Computación
Universidad Nacional del Sur

JRA © 2009 Sistemas Operativos – Sincronización de Procesos

Fundamentos El Problema

El acceso concurrente a datos compartidos puede Productor contador = 4 Consumidor
resultar en inconsistencias.
: :
Mantener la consistencia de datos requiere mecanismos : :
: :
para asegurar la ejecución ordenada de procesos : :
cooperativos.
La solución con memoria compartida al problema del contador:= contador+1;
t d t d +1 contador:= contador-1;
t d t d 1
buffer limitado (módulo anterior) permite a lo sumo n – 1
items en el buffer al mismo tiempo. Una solución, donde : :
: :
todos los N buffers son usados, no es simple. : :
: :
Supóngase que se modifica el código del productor-
consumidor agregando una variable contador,
inicializado a 0 e incrementado en cada momento contador = 4
que un nuevo item es agregado al buffer
Luego de una operación de Productor y otra de
Consumidor … contador permanece invariante
JRA © 2009 Sistemas Operativos – Sincronización de Procesos JRA © 2009 Sistemas Operativos – Sincronización de Procesos

El Problema El Problema
Productor Consumidor P1 a=b=1 P2
: :
: : : :
: : : :
: : : :
: :

rega ← contador
contador regb ← contador
a:= a+1;
; a
a:= 2 * a;
rega ← rega+1
a +1
contador:= contador+1; regb ← regb - 1
contador:= contador-1; b:= b+1; b:= 2 * b;
contador ← regaa
contador ← reg contador ← regb : :
: :
: :
: : : :
: :
: :
: rega= 5 regb= 3 :
a=b=4

4
contador = 5
3
Luego de la ejecución de P1 seguida de P2 los valores de a y b deben ser iguales entre sí


1


a=b=1 A sig(A) B sig(B) C sig(C)
P1 P2
: :
L
: :
: :
: :

a:= a+1;
; a:
a:= 2 * a; D sig(D) E sig(E)
b:= b+1; b:= 2 * b;
: :
: :
: :
: : : :

sig(D) ← L sig(E) ← L
a=4,b=3
L ←D L ←E

Luego de la ejecución de P1 y P2 los valores de a y b deberían ser iguales : :
entre sí, pero no lo son.


A sig(A) B sig(B) C sig(C) A sig(A) B sig(B) C sig(C)
L L

D sig(D) E sig(E) D sig(D) E sig(E)

: : : :

sig(D) ← L sig(E) ← L sig(D) ← L sig(E) ← L
L ←D L ←E L ←D L ←E

: : : :


L L


: : : :


: : : :


2

L L


: : : :

: : : :


El Problema Condición de Carrera
A sig(A) B sig(B) C sig(C)
L
Condición de carrera – Es la situación donde varios
procesos acceden y manejan datos compartidos
concurrentemente. El valor final de los datos
compartidos depende de que proceso termina último.
D sig(D) E sig(E)
Para prevenir las condiciones de carrera , los
procesos concurrentes cooperativos deben ser
: : sincronizados.
sig(D) ← L sig(E) ← L
L ←D L ←E

: :


Problema de la Sección Crítica Solución al Problema de la Sección Crítica
1. Exclusión Mutua. Si el proceso Pj está ejecutando en su sección
crítica, entonces ningún otro proceso puede estar ejecutando en
n procesos todos compitiendo para usar datos sus secciones críticas.
compartidos 2. Progreso. Si ningún proceso está ejecutando en su sección crí-
tica y existe algunos procesos que desean entrar en sus secciones
Cada proceso tiene un segmento de código criticas, entonces la selección de procesos que desean entrar en la
llamado sección crítica, en la cual los datos sección crítica no puede ser pospuesta indefinidamente.
compartidos son accedidos 3. Espera Limitada. Debe existir un límite en el número de veces
que a otros procesos les está permitido entrar en sus secciones
Problema – asegurar que cuando un proceso críticas después que un proceso ha hecho un requerimiento para
entrar en su sección crítica y antes que ese requerimiento sea
está ejecutando en su sección crítica, no se le completado.
permite a otro proceso ejecutar en su Asuma que cada proceso ejecuta a velocidad distinta de cero.
respectiva sección crítica. No se asume nada respecto a la velocidad relativa de los n
procesos.


3

Resolución del Problema Solución de Peterson
Solo 2 procesos, P0 y P1
Estructura general del proceso Pi Proceso Pi
repeat
repeat
flag [i] := true;
protocolo de entrada turn := j;
while (flag [j] and turn = j) do no-op;
( )
sección crítica (SC) sección crítica
flag [i] := false;
protocolo de entrada resto de sección
until false;
resto de sección
until falso Alcanza los tres requerimientos; resuelve el problema
de la sección crítica para dos procesos.
Los procesos pueden compartir algunas variables
comunes para sincronizar sus acciones.

Algoritmo para N Procesos Algoritmo para N Procesos(Cont.)
(Algoritmo del “panadero”)
Sección crítica para n procesos Notación orden lexicográfico (ticket #,id proceso #)
(a,b) < c,d) si a < c o si a = c y b < d
Antes de entrar en su sección crítica, el proceso
recibe un número. El poseedor del número mas max (a0,…, an-1) es un número k, tal que k ≥ ai para
chico entra en su sección crítica. i = 0, …, n – 1
Si los procesos Pi y Pj reciben el mismo número , si i Dato compartido
< j, entonces Pi es servido primero; sino lo es Pj . var choosing: array [0..n – 1] of boolean;
El esquema de numeración siempre genera números number: array [0..n – 1] of integer,
en orden incremental de enumeración;
Las estructuras de datos son inicializadas a false y 0
p.e., 1,2,3,3,3,3,4,5... respectivamente.


Algoritmo para N Procesos(Cont.) Sincronización por Hardware
repeat Muchos sistemas proveen soporte por hardware para el código
choosing[i] := true; de la sección crítica
number[i] := max(number[0], number[1], …, number [n – 1])+1; Monoprocesador – pueden deshabilitarse las interrupciones
choosing[i] := false; El código que esta corriendo debe ejecutar sin apropiación
for j := 0 to n – 1 Generamente es demasiado ineficiente en sistemas
do begin multiprocesador
while choosing[j] do no-op; Los SOs que usan esto no son ampliamente escalables
while number[j] ≠ 0 Las computadoras modernas proveen instrucciones especiales
and (number[j],j) < (number[i], i) do no-op; que se ejecutan atómicamente
end; Atómico = no-interrumpible
sección crítica
Sea por verificación de una palabra de memoria y su
number[i] := 0; inicialización
resto de sección O por intercambio de dos palabras de memoria
until false;


4

Solución usando Test-and-Set Exclusión Mutua con Test-and-Set

Dato compartido : var lock: boolean (inicialmente false)
Verifica y modifica el contenido de una palabra
atomicamente. Proceso Pi
repeat
función Test-and-Set (var target: boolean): boolean; while Test-and-Set (lock) do no-op;
begin
b i sección crítica
Test-and-Set := target; lock := false;
target := true; resto de sección
end; until false;


Instrucción Swap Solución usando Swap
La variable booleana compartida es inicializada en FALSE;
Cada proceso tiene una variable local booleana key
Definición: Solución:
while (true) {
void Swap (boolean *a, boolean *b) key = TRUE;
{ while ( key == TRUE)
boolean temp = *a; Swap (&lock, &key );
*a = *b; // sección critica
*b = temp:
lock = FALSE;
}
// sección restante
}


Semáforos El Semáforo como Herramienta General de Sincronización
Semáforo de Cuenta – el valor entero puede tener un rango
Es una herramienta de sincronización. sobre un dominio sin restricciones.
Semáforo S – variable entera Semáforo Binario – el valor entero puede tener un rango
Dos operaciones standard modifican S: wait() y solo entre 0 y 1; puede ser más simple de implementar
signal() También se los conoce como mutex locks
Originalmente llamadas P() y V() Puede implementarse un semáforo de cuenta S como un
p
Puede ser accedido solo por dos operaciones semáforo binario
indivisibles (deben ser atómicas): Provee exclusión mutua
wait (S): while S≤ 0 do no-op; Semáforo S; // inicializado en 1
S := S – 1; wait (S);
Sección Critica
signal (S): S := S + 1;
signal (S);


5

El Semáforo como Herramienta General de Sincronización Implementación de S con Semáforos Binarios

Ejecute B en Pj solo después que A ejecute en Pi Estructuras de datos:
Use el semáforo flag inicializado a 0
Código: var S1: binary-semaphore;
S2: binary-semaphore;
S3: binary-semaphore;
binary semaphore;
Pi Pj
C: integer;
M M
A wait(flag) Initialización:
signal(flag) B S1 = S3 = 1
S2 = 0
C = valor inicial del semaforo S


Implementación de S (Cont.) Implementación del Semáforo
operación wait
wait(S3); Debe garantizar que dos procesos no puedan ejecutar wait ()
wait(S1); y signal () sobre el mismo semáforo al mismo tiempo
C := C – 1;
Entonces, la implementación se convierte en el problema de
if C < 0
la sección crítica donde el código del wait y el signal son la
then begin
sección crítica.
signal(S1);
wait(S2); Podemos tener ahora espera ocupada en la
end implementación de la sección crítica porque:
else signal(S1); El código de implementación es corto
signal(S3);
operación signal Poca espera ocupada si la sección crítica está
wait(S1); raramente invocada
C := C + 1; Note que las aplicaciones pueden pasar y gastar mucho
if C ≤ 0 then signal(S2); tiempo en secciones críticas, entonces esta no es una buena
signal(S1); solución.

Implementación de Semáforo sin Espera Ocupada Implementación (Cont.)
Las operaciones del semáforo se definen como
Con cada semáforo hay asociada una cola de espera.
Cada entrada en dicha cola tiene dos datos: wait(S): S.value := S.value – 1;
valor (de tipo entero) if S.value < 0
then begin
puntero al próximo registro en la lista
agregue este proceso a S.L;
block;
Dos operaciones: end;
signal(S): S.value := S.value + 1;
block – ubica el proceso invocando la operación en
la apropiada cola de espera . if S.value ≤ 0
then begin
wakeup – remueve uno de los procesos en la cola
remueva un proceso P de S.L;
de espera y lo ubica en la cola de listos. wakeup(P);
end;

6

Interbloqueo e Inanición Problemas Clásicos de Sincronización
Interbloqueo – dos o más procesos están esperando
indefinidamente por un evento que puede ser causado por
solo uno de los procesos que esperan.
Sean S y Q dos semáforos inicializados a 1 Problema del Buffer Limitado
P0 P1 Problema de Lectores y Escritores
wait(S); wait(Q);
Problema de los Filósofos Cenando
wait(Q); wait(S);
M M
signal(S); signal(Q);
signal(Q); signal(S);
Inanición – bloqueo indefinido. Un proceso no puede ser
removido nunca de la cola del semáforo en el que fue
suspendido.

JRA © 2009 Sistemas Operativos – Sincronización de Procesos JRA © 2009 Sistemas Operativos – Sincronización de Procesos 4

Problema del Buffer Limitado Problema del Buffer Limitado (Cont.)

Proceso Productor
Datos compartidos repeat
type item = … …
var buffer = … produce un item en nextp
…
full, empty, mutex: semaphore; wait(empty);
nextp, nextc: item; wait(mutex);
full :=0; empty := n; mutex :=1; …
agregue nextp al buffer
…
signal(mutex);
signal(full);
until false;


Problema del Buffer Limitado(Cont.) Problema de los Lectores-Escritores
Un conjunto de datos es compartido entre un número de procesos
Proceso Consumidor concurrentes
repeat Lectores – solo leen el conjunto de datos, no realizan
wait(full) actualizaciones
wait(mutex); Escritores – pueden leer y/o escribir
…
remueve un item de buffer a nextc Problema – permitir a múltiples lectores leer al mismo tiempo. Un
p p p
solo escritor puede acceder a los datos compartidos al mismo
…
tiempo.
signal(mutex);
Datos compartidos
signal(empty);
Conjunto de datos
…
consume el item en nextc Semáforo mutex inicializado a 1.

… Semáforo wrt inicializado a 1.
until false; Entero readcount inicializado a 0.


7

Problema de los Lectores-Escritores Problema de los Lectores-Escritores

Datos compartidos Proceso Lector
var mutex, wrt: semaphore (=1); wait(mutex);
readcount : integer (=0); readcount := readcount +1;
if readcount = 1 then wait(wrt);
signal(mutex);
Proceso Escritor
…
wait(wrt); se realiza la lectura
… …
se realiza la escritura wait(mutex);
… readcount := readcount – 1;
signal(wrt); if readcount = 0 then signal(wrt);
signal(mutex):


Problema de los Filósofos Cenando Problema de los Filósofos Cenando
Filósofo i:
repeat
wait(chopstick[i])
wait(chopstick[i+1 mod 5])
…
comer
…
signal(chopstick[i]);
signal(chopstick[i+1 mod 5]);
…
Datos compartidos pensar
Fuente con arroz (conjunto de datos) …
var chopstick: array [0..4] of semaphore;(=1 inicialmente) until false;

JRA © 2009 Sistemas Operativos – Sincronización de Procesos JRA © 2009 Sistemas Operativos – Sincronización de Procesos 4

Problemas con Semáforos Monitores
Es un constructor de sincronización de alto nivel que
Incorrecto uso de las operaciones sobre permite compartir en forma segura un tipo de dato
abstracto entre procesos concurrentes.
semáforos:
type monitor-name = monitor
signal (mutex) …. wait (mutex) declaraciones de variables
procedure entry P1 :(…);
wait (mutex) … wait (mutex) begin
b i … end; d
procedure entry P2(…);
begin … end;
Omitir el wait (mutex) o el signal (mutex) (o M
ambos) procedure entry Pn (…);
begin…end;
begin
código de inicialización
end

8

Vista esquemática de un Monitor Variables de Condición

condición x, y;
datos
compartidos
cola de entrada Dos operaciones sobre una variable de
condición
x.wait
x wait () – el proceso que invoca esa
... operación es suspendido

operaciones x.signal () – reinicia uno de los procesos (si
hay alguno) que invocó x.wait ()

código
inicialización


Monitor con Variables de Condición Solución de los Filósofos Cenando
type filósofos-cenando = monitor
var state : array [0..4] of :(pensando, hambre, comiendo);
datos var self : array [0..4] of condition;
compartidos
procedure entry pickup (i: 0..4);
x cola de entrada begin
y colas asociadas a las
estado[i] := hambre,
test (i);
variables de condición x e y
if estado[i] ≠ comiendo th self[i].wait,
t d [i] i d then lf[i] it
end;
...
procedure entry putdown (i: 0..4);
operaciones begin
estado[i] := pensando;
código test (i+4 mod 5);
inicialización test (i+1 mod 5);
end;

JRA © 2009 Sistemas Operativos – Sincronización de Procesos 5 JRA © 2009 Sistemas Operativos – Sincronización de Procesos

Solución de los Filósofos Cenando Solución de los Filósofos Cenando

procedure test(k: 0..4);
begin Cada filósofo invoca las operaciones pickup() y
if estado[k+4 mod 5] ≠ comiendo putdown() en la siguiente secuencia:
and state[k] = hambre
and state[k+1 mod 5] ] ≠ comiendo
then begin dp.pickup (i)
estado[k] : comiendo;
:=
self[k].signal; Comer
end;
end;
dp.putdown (i)
begin
for i := 0 to 4
do estado[i] := pensando;
end.

JRA © 2009 Sistemas Operativos – Sincronización de Procesos 5 JRA © 2009 Sistemas Operativos – Sincronización de Procesos

9

Ejemplos de Sincronización Sincronización en SOLARIS

Solaris Implementa una variedad de locks para soportar
multitasking, multithreading (incluyendo threads en
Windows XP tiempo real), y multiprocesamiento.
Linux Usa mutex adaptivos para mayor eficiencia en la
protección de datos para segmentos de código cortos.
Pthreads
Usa variables de condición y locks lectores-escritores
cuando grandes secciones de código necesitan acceder
a los datos.
Usa turnstiles para ordenar la lista de threads
esperando para adquirir un mutex adaptivo o un lock
lectores-escritores


Sincronización Windows XP Sincronización en Linux

Usa máscaras de interrupción para proteger el acceso a Linux:
recursos globales en sistemas mono procesador
Deshabilita las interrupciones para
Usa spinlocks en sistemas multiprocesador
implementar secciones críticas cortas
Tambiém provee dispatcher objects los cuales actuan
como mutex y semáforos
Los Dispatcher objects pueden proveer eventos Linux provee:
Un evento actúa como una variable de condición semaforos
spin locks


Sincronización en Pthreads

APIs Pthreads son independientes de los SOs
Proveen:
Locks mutex
Fin
Variables de condición

Extensiones no portables incluyen: Módulo 6
Locks lector-escritor
spin locks

Departamento de Ciencias e Ingeniería de la Computación
Universidad Nacional del Sur

JRA © 2009 Sistemas Operativos – Sincronización de Procesos

10

So 2009-mod 06

Recomendados

Recomendados

Más contenido relacionado

Similar a So 2009-mod 06

Similar a So 2009-mod 06 (20)

So 2009-mod 06