You are on page 1of 27

Sincronizacin de Procesos

Conceptos
Problema SC
Soluciones Software
Soluciones Hardware
Emely Arriz
Ene-Mar 08
Conceptos
Acceso concurrente de datos compartidos puede resultar en
inconsistencia de datos.
Mantener consistencia de la data requiere de mecanismos para
asegurar orden de ejecucin de los procesos cooperante.
Exclusin Mutua: mecanismo que asegura que solamente un
proceso est haciendo cierta cosa en el tiempo.
Seccin Crtica: una parte del cdigo en la cual solamente un
proceso puede estar ejecutndose.
Sincronizacin: el uso de operaciones atmicas para asegurar
la operacin correcta de los procesos colaboradores.

Problema S C. Race Condition
Procedure Deposito(cantidad: integer)
begin
micuenta := micuenta + cantidad
end


Parbegin
Deposito(100)
Deposito(50)
Parend
Problema S C
Load reg1,micuenta
add reg1,cantidad
store reg1,micuenta

Valor inicial de micuenta = 1000

Deposito1 Deposito2
local cantidad= 100 local cantidad =50
load reg1,micuenta
add reg1,cantidad
load reg1,micuenta
store reg1,micuenta
add reg1,cantidad
store reg1,micuenta
Problema Seccin Crtica
N procesos todos compitiendo por el uso de
algn dato compartido.
Cada proceso tiene un segmento de cdigo ,
llamado seccin crtica, en el cual los datos
compartidos son accesados.
Problema: disear un protocolo que los
procesos puedan usar, de forma tal que su
accin no dependa del orden de sus ejecuciones
Problema Seccin Crtica
(cont.)
Estructura del proceso P
While (TRUE) {
entrada a la SC
SC
salir de la SC
resto del bloque
}

Solucin al Problema SC
Exclusin Mutua: Si el proceso P
i
se est
ejecutando en su SC, ningn otro proceso puede
estar ejecutandose en su SC.
Progreso: Si ningn proceso se est ejecutando
en su SC y existe alguno que desea entrar , se le
debe garantizar su entrada sin demora.
Espera Acotada: Ningn proceso debe esperar
indefinidamente para entrar a su SC. El nmero
de veces que un proceso se le puede colear a
otro es acotada. (No deadlock,No starvation)

Exclusin Mutua
Problema
Solamente 2 Procesos P0,P1
Estructura del Proceso P0 (P1)
while (TRUE) {
entrada SC
SC
salir SC
resto del bloque
}
Proceso pueden compartir algunas variables
comunes, para sincronizarse.
Soluciones
Soluciones por Software
Algoritmos que garantizan la solucin
Soluciones por hardware
Basadas en instrucciones de mquinas
Soluciones del Sistema de Operacin
proveen algunas funciones y estructuras de
datos para el programador.
Algoritmo 1
Variables compartidas
var turn: 0..1
turn = 0
turn = i => Pi puede entrar a su SC
Proceso Pi
repeat
while turn != i do no-op
SC
turn := j
resto del bloque (RS)
until false
Algoritmo 1 (cont.)
Satisface exclusin Mutua.
No Satisface Progreso, ya que requiere estricta
alternabilidad entre procesos.
process blocked by another process
outside its critical section!!.
Ej. Supongamos que P0 tiene un largo RS y P1 lo
tiene pequeo. Si turn=0, P0 entra a la SC y luego
turn=1 y entra en su largo RS. P1 entra a su SC y
luego turn=0 y a su corto RS de la cual sale .
Trata de vuelta de entrar a SC. Requerimiento
rechazado, el debe espera hasta que P0 deje su
RS.

Algoritmo 2
Variables compartidas
var flag: array[0..1] of boolean
flag[0] = flag[1] = false
flag[i] = true => Pi listo para entrar en la SC
Proceso Pi
repeat
flag[i] := true
while flag[ j ] do no-op
SC
flag[i] := false
RS
until false
Algoritmo 2 (cont.)
Satisface exclusin Mutua.
No Satisface Progreso
processes can wait forever for each other!!
Si un proceso falla dentro de su SC, el otro proceso
se queda bloqueado.
Si ambos proceso colocan su flags en verdad antes
de ejecutar el while, cada uno de ellos piensa que
el otro esta en su SC, causando un DEADLOCK

Algoritmo 3 (Peterson s)
Combina 1 y 2
flag[0]=flag[1]=false; turn=0 o 1
Proceso Pi
repeat
flag[i] := true;
turn := j;
while( flag[ j ] and turn = j ) do no-op
SC
flag[i] := false
RS
until false
Algoritmo 3 (cont.)
Satisface exclusin Mutua.
Satisface Progreso.
P
i
no puede entrar a SC solamente, looping en el
while con flag[j]=true y turn=j
Si P
j
no esta listo para entrar a SC flag[j]=false, por
lo que P
i
puede entrar.
Satisface Espera acotada.
Resuelve el problema de SC pero para dos
procesos.

Algoritmo Bakery
N procesos
Antes de entrar a su SC, los procesos reciben un
nmero.
Si los procesos P
i
y P
j
reciben el mismo nmero,
si i<j, entonces P
i
es servido primero, en caso
contrario P
j
.
El esquema de numeracin siempre genera
nmeros en orden creciente. Ej 1,2,3,3,3,4,5.


Algoritmo Bakery
(# ticket, # procid)
(a,b) < (c,d) si a < c o si a = c y b< d
max(a0,..an-1) es un nmero k tal que k >= ai
para i= 0,..n-1
datos compartidos
var choosing: array[0,..n-1] of boolean
number: array[0,n-1] of integer
las estructura son inicializadas en falso y cero
respectivamente.


Bakery (cont.)
repeat
choosing[i] := true;
number[i] := max(number[0] ,... 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
SC
number[i] := 0
RS
until false
Desventajas por Software
Los procesos que estn solicitando entrar en su
SC estn consumiendo tiempo de procesador
innecesariamente.
Si sus SC son grandes, debera ser mas eficiente
bloquear a estos procesos que estar esperando.

Soluciones por Hardware
Deshabilitar interrupciones





Proceso P
i
repeat
disable interrupts
SC
enable interrupts
RS
until false
Soluciones por Hardware
Exclusin Mutua es preservada sobre un
procesador; pero la eficiencia de ejecucin es
degradada ya que todos los otros procesos estn
prohibidos de interrumpir
Sobre multiprocesadores no se cumple Exclusin
Mutua

Soluciones por Hardware
TSL (Test and set lock)
Probar y modificar el contenido de una palabra
atmicamente .

Function Test-and-Set(var target:boolean):boolean;
begin
Test-and-Set := target
target := true
end



Test and Set
var lock: boolean. Inicializada en false
Proceso P
i
repeat
while Test-and-Set(lock) do no-op
SC
lock := false
RS
until false
Test and Set
Si Pi entra en SC, el otro Pj esta en busy waiting.
Cumple Exclusin Mutua
Puede ser usado para cualquier nmero de
procesos.
Cuando P
i
sale, la seleccin del P
j
quien debera
entrar es arbitraria. Espera no acotada
Por lo que starvation es posible.
No deadlock. Garantiza progreso.
Implement fairness with TSL
test_and_set(int flag) - TSL #1,flag and
return(flag)
{
interested(i) = TRUE;
test = TRUE;
while(interested(i) == TRUE && test == TRUE)
test = test_and_set(lock);
interested(i) = FALSE;
}
. . . critical section . . .
{
j = i+1 % n;
while(j != i && !(interested(j))) j++ % n;
if(j == i) lock = FALSE;
else interested(j) = FALSE;
}
Swap
Definicin
void swap(boolean *a, boolean *b) {
boolean temp = *a;
*a = *b;
*b = temp;
}
Solucin usando swap
Variable global lock = FALSE
Cada proceso tiene una variable local key

Pi: while (TRUE) {
key = TRUE;
while ( key == TRUE) swap ( &lock, &key);
SC
lock = FALSE;
RS
}