Está en la página 1de 58

Sistemas Operativos Sergio C.

FigueroaAgosto 2002
6.1
Modulo 6: Sincronización de Procesos
• Planificación RR y Prioridades
• Background
• Sección critica
• Sincronización ( Hardware )
• Semaphores
• Problemas clásicos de sincronización
• Regiones críticas
• Monitores
• Solaris 2
• Transacciones atómicas
Sistemas Operativos Sergio C. FigueroaAgosto 2002
6.2
Background
• La concurrencia en el accesos a los datos puede llevar a
inconsistencias (caso LPT)
• Mantener la consistencia de datos requiere de mecanismos que
aseguren la ejecución de procesos cooperativos
• La memoria-compartida soluciona el problema de compartir
buffers al mismo tiempo.
– Supongamos que modificamos el codigo de productor-
consumidor adicionando la var counter, inicializada en cero
e incrementada cada vez que se adiciona un item.
Sistemas Operativos Sergio C. FigueroaAgosto 2002
6.3
• Procesos p1, p2, p3
Procesos p1 p2 p3
– Ocio 80% 70% 60%
– Ocupado 20% 30% 40%
– Tiempo de arribo de procesos
– P1=10:00
– P2=10:05
– P3=10:10
– Los procesos tienen una duración de 3 minutos de
CPU ( también sin tiempo)
Solución
Consiste en hacer una tabla y luego un gráfico
para ver donde están y donde terminan los procesos
Ejemplos de planificación
Ejemplos de planificación
Sistemas Operativos Sergio C. FigueroaAgosto 2002
6.4
0.664 0.58 0.52 0.44 0.4 0.3 0.2
Total
0.295 0.33 0.35 0.4
Cpu/p3
0.221 0.25 0.26 0.3
Cpu/p2
0.148 0.17 0.18 0.2
Cpu/p1
0.664 0.58 0.52 0.44 0.4 0.3 0.2
Ocupado
0.336 0.42 0.48 0.56 0.6 0.7 0.8
Ocio
p
1
p
2
p
3
p
2
p
3
p
1
p
3
p
1
p
2
p
3
p
2
p
1
Procesos
Ejemplos de planificación
Ejemplos de planificación
Sistemas Operativos Sergio C. FigueroaAgosto 2002
6.5
ROUND ROBIN
1.00 0.88 0.74 Tot al
p1 0.20 0.20 0.20 0.20 0.20 0.18 0.18 0.18 0.18 0.18 0.15 0.15 0.15 0.15 0.15 2.62
p2 1.32 1.11
0.26 0.26 0.26 0.26 0.26 0.22 0.22 0.22 0.22 0.22 2.43
10:00 10:05 10:10 1.48 10:15
7:04 7:04 7:04 7:04 7:04 1.48
0:05 0:05 0:05
0:10 0:15
p1 p2 p3 p12 p13 p23 p123
Ocio 0.8 0.7 0.6 0.56 0.48 0.42 0.336
Busy 0.2 0.3 0.4 0.44 0.52 0.58 0.664
cpu/p1 0.2 0.18 0.17 0.148
cpu/p2 0.3 0.26 0.25 0.221
cpu/p3 0.4 0.35 0.33 0.295
TOTAL 0.2 0.3 0.4 0.44 0.52 0.58 0.664
Ejemplos de planificación
Ejemplos de planificación
Sistemas Operativos Sergio C. FigueroaAgosto 2002
6.6
El caso con tiempos fijos de CPU
p1 p2 p3 p12 p13 p23 p123
Ocio 0.8 0.7 0.6 0.56 0.48 0.42 0.336
Busy 0.2 0.3 0.4 0.44 0.52 0.58 0.664
cpu/p1 0.2 0.18 0.17 0.148
cpu/p2 0.3 0.26 0.25 0.221
cpu/p3 0.4 0.35 0.33 0.295
TOTAL 0.2 0.3 0.4 0.44 0.52 0.58 0.664
Ejemplos de planificación
Ejemplos de planificación
Sistemas Operativos Sergio C. FigueroaAgosto 2002
6.7
ROUND ROBIN
Tot al FALTA
p1 0.20 0.20 0.18 0.18 0.15 0.15 2.62 2.38 5.00
p2
0.26 0.26 0.22 0.22 2.43 2.38 0.19 5.00
10:00 10:05 10:10 10:15
7:04 7:04 1.48 2.38 0.25 0.89 5.00
0:05 0:05 0:05 16.14 0.77 2.22
0:10 0:15
10:11:21 10:15 10:31:08 10:31:54 10:33:13
Ejemplos de planificación
Ejemplos de planificación
Sistemas Operativos Sergio C. FigueroaAgosto 2002
6.8
Bounded-Buffer
• Compartir data: type item = … ;
var buffer array [0..n-1] of item;
in, out: 0..n-1;
counter: 0..n;
in, out, counter := 0;
• Proceso productor
repeat

producir un item en nextp

while counter = n do no-op;
buffer [in] := nextp;
in := in + 1 mod n;
counter := counter +1;
until false;
Sistemas Operativos Sergio C. FigueroaAgosto 2002
6.9
Bounded-Buffer (Cont.)
• Proceso consumidor
repeat
while counter = 0 do no-op;
nextc := buffer [out];
out := out + 1 mod n;
counter := counter – 1;

consumir el item en nextc

until false;
• Las sentencias:
– counter := counter + 1;
– counter := counter - 1;
Se deben ejecutar atómicamente
Sistemas Operativos Sergio C. FigueroaAgosto 2002
6.10
Problema de sección crítica.
• N procesos todos compitiendo para usar la misma data compartida.
• Cada proceso tiene tiene su propio segmenteo denominado “sección
crítica”, en la cual se comparte data.
• Problema – asegurarse que cuando un proceso se ejecuta en su sección
crítica, ningún otro pueda ejecutar la misma sección.
• Estructura de proceso P
i
repeat
entry section
sección critica
exit section
---------------
until false;
Sistemas Operativos Sergio C. FigueroaAgosto 2002
6.11
Problema de sección crítica.
1. Exclusión mutua. Si proceso Pi esta ejecutandose en su región
crítica, entonces ningún otro puede ejecutarse o entrar a
la región critica.
proceso
2.Progreso. Si no existe proceso en la región crítica y existe un
proceso que desea entrar a la región, entonces la selección de
procesos debe ser tal que no se debe posponer al proceso que
esta en espera ( no se debe posponer indefinidamente la entrada
a la región critica).
3. Esperas límites. Se debe establecer un límite para que un
proceso pueda entrar a la región critica posponiendo a otros de
entrar en ella.
Se debe asumir que los procesos tardan en su ejecución
No se debe asumir velocidades de ningún de los n
procesos.
Sistemas Operativos Sergio C. FigueroaAgosto 2002
6.12
1.- Dos procesos nunca pueden estar simultáneamente en sus
regiones críticas
2.- No se debe suponer velocidades de las CPU.
3.- Ningún proceso que se ejecute fuera de la región crítica puede
bloquear a otros procesos.
4.- Ningún proceso deberá esperar indefinidamente para entrar en
su región crítica
Cuatro condiciones
Cuatro condiciones
Sistemas Operativos Sergio C. FigueroaAgosto 2002
6.13
1.- Inhabilitar las interrupciones.
2.- Variables candado.
3.- Alternancia estricta
4.- Solución Peterson
5.- Instrucción TSL
While (TRUE){
While(turn !=0);/* esperar */
Región_critica();
Turn=1;
Region_no_critica();
}
While(TRUE){
While(turn !=1)/*esperar turnp */
Region_critica();
Turn=0;
Region_no_critica();
}
(a) (b)
Soluciones prácticas
Soluciones prácticas
Sistemas Operativos Sergio C. FigueroaAgosto 2002
6.14
Soluciones prácticas
• Solo 2 procesos, P
0
y P
1
• Estructura general de proceso P
i
repeat
entry section
region_critica
exit section
región_no_critica
until false;
• Los procesos deben compartir una variable para sincronizar
Sistemas Operativos Sergio C. FigueroaAgosto 2002
6.15
Algorithm 1
• Variables compartidas (candado):
– var turn: (0..1);
inicialmente turn = 0
– turn - i ⇒ P
i
puede entrar en la región
• Proceso P
i
repeat
while turn ≠ i do no-op;
region_critica
turn := j;
región_no_critica
until false;
• Satisfase eclusión mutua pero tiene error en el detalle (ver
diapositiva anterior)
Sistemas Operativos Sergio C. FigueroaAgosto 2002
6.16
Algorithm 2
• Variables compartidas
– var flag: array [0..1] of boolean;
inicialmente flag [0] = flag [1] = false.
– flag [i] = true ⇒ P
i
listo para entrar a su región crítica
• Proceso P
i
repeat
flag[i] := true;
while flag[j] do no-op;
region_critica
flag [i] := false;
región_no_critica
until false;
• Satisfase eclusión mutua pero tiene error en el detalle (ver
diapositiva anterior).
Sistemas Operativos Sergio C. FigueroaAgosto 2002
6.17
Algorithm 3
• Combinación de algorítmos 1 y 2.
• Proceso P
i
repeat
flag [i] := true;
turn := j;
while (flag [j] and turn = j) do no-op;
region_critica
flag [i] := false;
región_no_critica
until false;
• Resuelve el problema y posibilita la región critica para dos
procesos.
Sistemas Operativos Sergio C. FigueroaAgosto 2002
6.18
Algoritmo de Bakery
• Antes de entrar a la región crítica los procesos reciben un
número. El poseedor del número más pequeño ingresa a la
región crítica.
• Si proceso P
i
y P
j
reciben el mismo número, si i < j, entonces P
i
es atendido primero; else P
j
es atendido primero.
• El esquema de generación de números siempre genera números
en orden creciente, es decir: 1,2,3,3,3,3,4,5...
Critical section for n processes
Sistemas Operativos Sergio C. FigueroaAgosto 2002
6.19
Algoritmo de Bakery (Cont.)
• Notación <≡ orden lexicográfico (ticket #, process id #)
– (a,b) < (c,d) if a < c o if a = c and b < d
– max (a
0
,…, a
n-1
) es un número, k, tal que k ≥ a
i
para i - 0,
…, n – 1
• Shared data
var choosing: array [0..n – 1] of boolean;
number: array [0..n – 1] of integer,
Las estructuras de datos son inicializadas a FALSO y 0
respectivamente
Sistemas Operativos Sergio C. FigueroaAgosto 2002
6.20
Algoritmo de Bakery(Cont.)
repeat
choosing[i] := true;
number[i] := max(number[0], number[1], …, number [n – 1])+1;
choosing[i] := false;
for j := 0 to n – 1
do begin
while choosing[j] do no-op;
while number[j] ≠ 0
and (number[j],j) < (number[i], i) do no-op;
end;
critical section
number[i] := 0;
remainder section
until false;
Sistemas Operativos Sergio C. FigueroaAgosto 2002
6.21
Ayuda del Hardware
• TSL, modifica atomicamente y comprueba (dos en una).
function Test_and_Set (var target: boolean): boolean;
begin
Test_and_Set := target;
target := true;
end;
Sistemas Operativos Sergio C. FigueroaAgosto 2002
6.22
Mutual Exclusion with Test_and_Set
• Shared data: var lock: boolean (inicialmente false)
• Process P
i
repeat
while Test_and_Set (lock) do no-op;
critical section
lock := false;
remainder section
until false;
Sistemas Operativos Sergio C. FigueroaAgosto 2002
6.23
Test y Set Flag
• La forma general de tsl es:
Enter_region:
tsl reg,lock // copia contenido de lock en reg y
// pone en 1 loc
cmp reg,#0// compara reg con cero ?
jne enter_region// si no es cero salte nuevamente
ret // era cero sigue
También se puede hacer espera desocupada.
Leave_region:
move lock,#0 // pone a cero lock
ret // y regresamos
La instrucción tsl es una instrucción en firmware
Sistemas Operativos Sergio C. FigueroaAgosto 2002
6.24
Semaforo
• Es una herramienta de sincronización que no requiere de espera
ocupada (manda al proceso a “waiting”)
• Semaforo S – integer variable
• Puede accesarse via dos operaciones indivisibles (atómicas)
wait (S):
while S≤ 0 do no-op;
S := S – 1;
y también
signal (S):
S := S + 1;
Sistemas Operativos Sergio C. FigueroaAgosto 2002
6.25
Example: Critical Section of n Processes
• Shared variables
– var mutex : semaphore
– init al y mutex = 1 i l
• Proceso P
i
repeat
wait(mutex);
critical section
signal(mutex);
remainder section
until false;
Sistemas Operativos Sergio C. FigueroaAgosto 2002
6.26
Implementación de semaforos
• Definir semaforo como registro
type semaforo = record
value: integer
L: lista de procesos;
end;
• Se asumen dos operaciones simples:
– Bloquear y suspender el proceso que lo incoca
– wakeup(P) resume la ejecución del procesos bloqueado P.
Sistemas Operativos Sergio C. FigueroaAgosto 2002
6.27
Implementation (Cont.)
• Las operaciones del semaforo ahora se definen como:
wait(S): S.value := S.value – 1;
if S.value < 0
then begin
adicionar a S.Lista_de_proceso;
block;// o wait()
end;
signal(S): S.value := S.value = 1;
if S.value ≤ 0
then begin
remover proceso P desde S.
Lista_de_proceso;
wakeup(P);
end;
Sistemas Operativos Sergio C. FigueroaAgosto 2002
6.28
Semaphore as General Synchronization Tool
• Ejecute B en P
j
solamente despues que A se ha ejecutadoe en
P
i
• Use el semaforo flag inicialmente en 0
• Código
P
i
P
i
M M
A w (flag) ait
signal(flag) B
Sistemas Operativos Sergio C. FigueroaAgosto 2002
6.29
Deadlock y Starvation
• Deadlock – dos o más procesos esperan indefinidamente por
recursos que se encuentran asignados a otro procesos en espera.
• Sea S y Q dos semaforos inicializados en 1
P
0
P
1
wait(S); wait(Q);
wait(Q); wait(S);
M M
signal(S); signal(Q);
signal(Q) signal(S);
• Starvation – bloqueo infinito. Un procesos nunca es removido de
la cola en la cual se encuentra suspendido..
Sistemas Operativos Sergio C. FigueroaAgosto 2002
6.30
Tipos de semaforos
• Semaforo Contador – un valor entero puede ser de cualquier
valor (0…n)
• Semaforo Binary – puede ser 0 o 1; es simple de
implementar.
• El semaforo contador (es un conunt) puede implementarse
con semaforos binario.
Sistemas Operativos Sergio C. FigueroaAgosto 2002
6.31
Implementando el contador S con
semaforo binario
• Data structures:
var S1: binary-semaphore;
S2: binary-semaphore;
S3: binary-semaphore;
C: integer;
• Initialization:
S1 = S3 = 1
S2 = 0
C = initial value of semaphore S
Sistemas Operativos Sergio C. FigueroaAgosto 2002
6.32
Implementación (Cont.)
• wait operation
wait(S3);
wait(S1);
C := C – 1;
if C < 0
then begin
signal(S1);
wait(S2);
end
else signal(S1);
signal(S3);
• signal operation
wait(S1);
C := C + 1;
if C ≤ 0 then signal(S2);
signal(S)1;
Sistemas Operativos Sergio C. FigueroaAgosto 2002
6.33
Problemas clasicos de sincronización
• Problema del límite en buffers
• Problema de lector editor(escritor)
• Problema de los filósofos
Sistemas Operativos Sergio C. FigueroaAgosto 2002
6.34
Problema de límite en buffers
• Shared data
type item = …
var buffer = …
full, empty, mutex: semaphore;
nextp, nextc: item;
full :=0; empty := n; mutex :=1;
Sistemas Operativos Sergio C. FigueroaAgosto 2002
6.35
Problema de límite en buffers(Cont.)
• Producer process
repeat

produce an item in nextp

wait(empty);
wait(mutex);

signal(mutex);
signal(full);
until false;
Sistemas Operativos Sergio C. FigueroaAgosto 2002
6.36
Problema de límite en buffers(Cont.)
• Consumer process
repeat
wait(full)
wait(mutex);

remove an item from buffer to nextc

signal(mutex);
signal(empty);

consume the item in nextc

until false;
Sistemas Operativos Sergio C. FigueroaAgosto 2002
6.37
Problema “Readers-Writers”
• Shared data
var mutex, wrt: semaphore (=1);
readcount : integer (=0);
• Writer process
wait(wrt);

writing is performed

signal(wrt);
Sistemas Operativos Sergio C. FigueroaAgosto 2002
6.38
Problema “Readers-Writers”(Cont.)
• Reader process
wait(mutex);
readcount := readcount +1;
if readcount = 1 then wait(wrt);
signal(mutex);

reading is performed

wait(mutex);
readcount := readcount – 1;
if readcount = 0 then signal(wrt);
signal(mutex):
Sistemas Operativos Sergio C. FigueroaAgosto 2002
6.39
Problema “Dining-Philosophers”
Problema
• Problema de página 76 del Tanembaum
• Shared data
var chopstick: array [0..4] of semaphore;
(=1 inicialmente)
Sistemas Operativos Sergio C. FigueroaAgosto 2002
6.40
Dining-Philosophers Problem (Cont.)
• Philosopher i:
repeat
wait(chopstick[i])
wait(chopstick[i+1 mod 5])

eat

signal(chopstick[i]);
signal(chopstick[i+1 mod 5]);

think

until false;
Sistemas Operativos Sergio C. FigueroaAgosto 2002
6.41
Regiones críticas
• Sincronización de High-level
• Una variable compartida v of type T, se declara como:
var v: shared T
• Variable v accesada solamente dentro de la sentencia
region v when B do S
Donde B es una expresión booleana
“Cuando la sentencia S está ejecutandose, ningún otro proceso
puede accesar la variable v.
Sistemas Operativos Sergio C. FigueroaAgosto 2002
6.42
Regiones críticas(Cont.)
• Las regiones que se refieren a la misma variable compartida se
excluyen una a otra al mismo tiempo.
• Cuando un proceso trata de ejecutar la sentencia de la región,
entonces se evalua la expresión booleana B. Si B es verdadera,
se permite la ejecución de sentencia S. Si false, el
proceso se suspende hasta que B sea verdadera, de este modo
no se permite el acceso a otro proceso a la región asociada a la
variavble v.
entonces B es
Sistemas Operativos Sergio C. FigueroaAgosto 2002
6.43
Example – Bounded Buffer
• Shared variables:
var buffer: shared record
pool: array [0..n–1] of item;
count,in,out: integer
end;
• Producer process inserts nextp into the shared buffer
region buffer when count < n
do begin
pool[in] := nextp;
in:= in+1 mod n;
count := count + 1;
end;
Sistemas Operativos Sergio C. FigueroaAgosto 2002
6.44
Bounded Buffer Example (Cont.)
• Consumer process removes an item from the shared buffer and
puts it in nextc
region buffer when count > 0
do begin
nextc := pool[out];
out := out+1 mod n;
count := count – 1;
end;
Sistemas Operativos Sergio C. FigueroaAgosto 2002
6.45
Implementación: region x when B do S
• Asociar con la variable compartida x, las siguientes variables:
var mutex, first-delay, second-delay: semaphore;
first-count, second-count: integer,
• Exclusión mútua se consigue con mutex.
• Si un procesos no puede entrar a la región critica porque la
expresión booleana B es false, entonces se espera en el
semaforo first_delay; se mueve a second-delay semaforo antes
de reevaluar B.
Sistemas Operativos Sergio C. FigueroaAgosto 2002
6.46
Implementación (Cont.)
• Mantener la cuenta de los procesos que esperan en el primer y
segundo semaforo (first-delay y second-delay) con variables
first-count y second-count.
• El algoritmo asume FIFO en la cola del semaforo.
• En casos más complejos se debe implementar un algoritmo más
complejo.
Sistemas Operativos Sergio C. FigueroaAgosto 2002
6.47
wait(mutex);
while not B
do begin first-count := first-count + 1;
if second-count > 0
then signal(second-delay)
else signal(mutex);
wait(first-delay):
first-count := first-count – 1;
if first-count > 0 then signal(first-delay)
else signal(second-delay);
wait(second-delay);
second-count := second-count – 1;
end;
S;
if first-count >0
then signal(first-delay);
else if second-count >0
then signal(second-delay);
else signal(mutex);
Sistemas Operativos Sergio C. FigueroaAgosto 2002
6.48
• Sincronización de alto nivel provee un acceso a data ewn
procesos concurrentes.
type monitor-name = monitor
Declaraciones
procedure entry P1 :(…);
begin … end;
procedure entry P2(…);
begin … end;
M
procedure entry Pn (…);
begin…end;
begin
initialization code
end
Monitors
Monitors
Sistemas Operativos Sergio C. FigueroaAgosto 2002
6.49
• Un proceso puede esperar en interior de monitor con una
variable de condición, como:
var x, y: condition
• Las variables condition pueden ser utilizadas solamente con
operador wait y signal.
– La operación
x.wait;
Significa que el proceso invocando la operación se
suspende hasta que otro proceso invoque
x.signal;
– La operación x.signal resume exactamente uno u sólo
uno de los procesos suspendidos. Si no existe proceso
suspendido, entonces la señal no tiene ningún efecto.
Monitors (Cont.)
Monitors (Cont.)
Sistemas Operativos Sergio C. FigueroaAgosto 2002
6.50
Schematic view of a monitor
Schematic view of a monitor
Sistemas Operativos Sergio C. FigueroaAgosto 2002
6.51
Monitor with condition variables
Monitor with condition variables
Sistemas Operativos Sergio C. FigueroaAgosto 2002
6.52
type dining-philosophers = monitor
var state : array [0..4] of :(thinking, hungry, eating);
var self : array [0..4] of condition;
procedure entry pickup (i: 0..4);
begin
state[i] := hungry,
test (i);
if state[i] ≠ eating then self[i], wait,
end;
procedure entry putdown (i: 0..4);
begin
state[i] := thinking;
test (i+4 mod 5);
test (i+1 mod 5);
end;
Dining Philosophers Example
Dining Philosophers Example
Sistemas Operativos Sergio C. FigueroaAgosto 2002
6.53
procedure test(k: 0..4);
begin
if state[k+4 mod 5] ≠ eating
and state[k] = hungry
and state[k+1 mod 5] ] ≠ eating
then begin
state[k] := eating;
self[k].signal;
end;
end;
begin
for i := 0 to 4
do state[i] := thinking;
end.
Dining Philosophers (Cont.)
Dining Philosophers (Cont.)
Sistemas Operativos Sergio C. FigueroaAgosto 2002
6.54
• Variables
var mutex: semaphore (init = 1)
next: semaphore (init = 0)
next-count: integer (init = 0)
• Cada proceso externo F será reemplazado por
wait(mutex);

cuerpo de F;

if next-count > 0
then signal(next)
else signal(mutex);
• Esta asegurada la exclusión mutua.
Monitor Implementation Using Semaphores
Monitor Implementation Using Semaphores
Sistemas Operativos Sergio C. FigueroaAgosto 2002
6.55
• Para cada variable de condición x, tenemos:
var x-sem: semaphore (init = 0)
x-count: integer (init = 0)
• El operador x.wait puede ser implementado como:
x-count := x-count + 1;
if next-count >0
then signal(next)
else signal(mutex);
wait(x-sem);
x-count := x-count – 1;
Monitor Implementation (Cont.)
Monitor Implementation (Cont.)
Sistemas Operativos Sergio C. FigueroaAgosto 2002
6.56
• La operación x.signal puede ser implementada como:
if x-count > 0
then begin
next-count := next-count + 1;
signal(x-sem);
wait(next);
next-count := next-count – 1;
end;
Monitor Implementation (Cont.)
Monitor Implementation (Cont.)
Sistemas Operativos Sergio C. FigueroaAgosto 2002
6.57
• Conditional-wait constructor: x.wait(c);
– c – integer expression evaluada cuando el operador wait()
se ejecuta.
– value of c (priority number) se almacena en conjunto con el
proceso que es suspendido.
– cuando x.signal se ejecuta, el proceso conmenor prioridad
es activado o reasume primero.
– El procesos usuario debe siempre hacer los llamados al
monitor en una secuencia correcta.
– Se debe asegurar que los procesos no-colaborativos no
ignoren la exclusión mutua, esto nunca debe ocuuriir.
Monitor Implementation (Cont.)
Monitor Implementation (Cont.)
Sistemas Operativos Sergio C. FigueroaAgosto 2002
6.58
• Implementación de una variedad de bloqueos para soportar la
multitareas y muiltihilo (incluyendo real-time threads).
• Uso de mutex adaptivos para mejorar eficiencia cuando se debe
proteger data en segmentos pequeños.
• Uso de variables condicionales para proteger secciones mayores
Solaris 2 Operating System
Solaris 2 Operating System